bagas/filekeeper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #9 from fossyy/staging

Browse Source 
Staging
This commit is contained in:
Bagas Aulia Rezki
2024-04-28 22:32:53 +07:00
committed by GitHub
parent 1a7ac48330 e6344743d5
commit ca31c40da2
14 changed files with 424 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

48
app/app.go Normal file
View File

@ -0,0 +1,48 @@
package app
import (
"fmt"
"github.com/fossyy/filekeeper/db"
"github.com/fossyy/filekeeper/middleware"
"github.com/fossyy/filekeeper/routes"
"github.com/fossyy/filekeeper/utils"
"net/http"
)
type App struct {
http.Server
DB db.Database
}
var Server App
func NewServer(addr string, handler http.Handler, database db.Database) App {
return App{
Server: http.Server{
Addr: addr,
Handler: handler,
},
DB: database,
}
}
func Start() {
serverAddr := fmt.Sprintf("%s:%s", utils.Getenv("SERVER_HOST"), utils.Getenv("SERVER_PORT"))
dbUser := utils.Getenv("DB_USERNAME")
dbPass := utils.Getenv("DB_PASSWORD")
dbHost := utils.Getenv("DB_HOST")
dbPort := utils.Getenv("DB_PORT")
dbName := utils.Getenv("DB_NAME")
database := db.NewPostgresDB(dbUser, dbPass, dbHost, dbPort, dbName, db.DisableSSL)
db.DB = database
Server = NewServer(serverAddr, middleware.Handler(routes.SetupRoutes()), database)
fmt.Printf("Listening on http://%s\n", Server.Addr)
err := Server.ListenAndServe()
if err != nil {
panic(err)
return
}
}

315
db/database.go
View File

@ -1,39 +1,326 @@
package db
import (
"errors"
"fmt"
"os"
"strings"
"github.com/fossyy/filekeeper/logger"
"github.com/fossyy/filekeeper/utils"
"github.com/fossyy/filekeeper/types/models"
"gorm.io/driver/mysql"
"gorm.io/driver/postgres"
"gorm.io/gorm"
gormLogger "gorm.io/gorm/logger"
"os"
"strings"
)
var DB *gorm.DB
var log *logger.AggregatedLogger
var DB Database
func init() {
type mySQLdb struct {
*gorm.DB
}
type postgresDB struct {
*gorm.DB
}
type SSLMode string
const (
DisableSSL SSLMode = "disable"
EnableSSL SSLMode = "enable"
)
type Database interface {
IsUserRegistered(email string, username string) bool
CreateUser(user *models.User) error
GetUser(email string) (*models.User, error)
UpdateUserPassword(email string, password string) error
CreateFile(file *models.File) error
GetFile(fileID string) (*models.File, error)
GetUserFile(name string, ownerID string) (*models.File, error)
GetFiles(ownerID string) ([]*models.File, error)
CreateUploadInfo(info models.FilesUploaded) error
GetUploadInfo(uploadID string) (*models.FilesUploaded, error)
UpdateUpdateIndex(index int, fileID string)
FinalizeFileUpload(fileID string)
}
func NewMYSQLdb(username, password, host, port, dbName string) Database {
var err error
connection := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", utils.Getenv("DB_USERNAME"), utils.Getenv("DB_PASSWORD"), utils.Getenv("DB_HOST"), utils.Getenv("DB_PORT"), utils.Getenv("DB_NAME"))
DB, err = gorm.Open(mysql.Open(connection), &gorm.Config{}, &gorm.Config{
connection := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local", username, password, host, port, dbName)
DB, err := gorm.Open(mysql.New(mysql.Config{
DSN: connection,
DefaultStringSize: 256,
DisableDatetimePrecision: true,
DontSupportRenameIndex: true,
DontSupportRenameColumn: true,
SkipInitializeWithVersion: false,
}), &gorm.Config{
Logger: gormLogger.Default.LogMode(gormLogger.Silent),
})
if err != nil {
panic("failed to connect database" + err.Error())
panic("failed to connect database: " + err.Error())
}
file, err := os.ReadFile("schema.sql")
if err != nil {
log.Error("Error opening file: %s", err.Error())
panic("Error opening file: " + err.Error())
}
queries := strings.Split(string(file), ";")
for _, query := range queries {
query = strings.TrimSpace(query)
if query == "" {
continue
}
querys := strings.Split(string(file), "\n")
for _, query := range querys {
err := DB.Exec(query).Error
if err != nil {
panic(err.Error())
panic("Error executing query: " + err.Error())
}
}
return &mySQLdb{DB}
}
func NewPostgresDB(username, password, host, port, dbName string, mode SSLMode) Database {
var err error
connection := fmt.Sprintf("host=%s user=%s password=%s dbname=%s port=%s sslmode=%s TimeZone=Asia/Jakarta", host, username, password, dbName, port, mode)
DB, err := gorm.Open(postgres.New(postgres.Config{
DSN: connection,
}), &gorm.Config{
Logger: gormLogger.Default.LogMode(gormLogger.Silent),
})
if err != nil {
panic("failed to connect database: " + err.Error())
}
file, err := os.ReadFile("schema.sql")
if err != nil {
panic("Error opening file: " + err.Error())
}
queries := strings.Split(string(file), ";")
for _, query := range queries {
query = strings.TrimSpace(query)
if query == "" {
continue
}
err := DB.Exec(query).Error
if err != nil {
panic("Error executing query: " + err.Error())
}
}
return &postgresDB{DB}
}
func (db *mySQLdb) IsUserRegistered(email string, username string) bool {
var data models.User
err := db.DB.Table("users").Where("email = ? OR username = ?", email, username).First(&data).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return false
}
return true
}
return true
}
func (db *mySQLdb) CreateUser(user *models.User) error {
err := db.DB.Create(user).Error
if err != nil {
return err
}
return nil
}
func (db *mySQLdb) GetUser(email string) (*models.User, error) {
var user models.User
err := db.DB.Table("users").Where("email = ?", email).First(&user).Error
if err != nil {
return nil, err
}
return &user, nil
}
func (db *mySQLdb) UpdateUserPassword(email string, password string) error {
err := db.DB.Table("users").Where("email = ?", email).Update("password", password).Error
if err != nil {
return err
}
return nil
}
func (db *mySQLdb) CreateFile(file *models.File) error {
err := db.DB.Create(file).Error
if err != nil {
return err
}
return nil
}
func (db *mySQLdb) GetFile(fileID string) (*models.File, error) {
var file models.File
err := db.DB.Table("files").Where("id = ?", fileID).First(&file).Error
if err != nil {
return nil, err
}
return &file, nil
}
func (db *mySQLdb) GetUserFile(name string, ownerID string) (*models.File, error) {
var file models.File
err := db.DB.Table("files").Where("name = ? AND owner_id = ?", name, ownerID).First(&file).Error
if err != nil {
return nil, err
}
return &file, nil
}
func (db *mySQLdb) GetFiles(ownerID string) ([]*models.File, error) {
var files []*models.File
err := db.DB.Table("files").Where("owner_id = ?", ownerID).Find(&files).Error
if err != nil {
return nil, err
}
return files, err
}
// CreateUploadInfo It's not optimal, but it's okay for now. Consider implementing caching instead of pushing all updates to the database for better performance in the future.
func (db *mySQLdb) CreateUploadInfo(info models.FilesUploaded) error {
err := db.DB.Create(info).Error
if err != nil {
return err
}
return nil
}
func (db *mySQLdb) GetUploadInfo(fileID string) (*models.FilesUploaded, error) {
var info models.FilesUploaded
err := db.DB.Table("files_uploadeds").Where("file_id = ?", fileID).First(&info).Error
if err != nil {
return nil, err
}
return &info, nil
}
func (db *mySQLdb) UpdateUpdateIndex(index int, fileID string) {
db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).Updates(map[string]interface{}{
"Uploaded": index,
})
}
func (db *mySQLdb) FinalizeFileUpload(fileID string) {
db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).Updates(map[string]interface{}{
"Done": true,
})
}
// POSTGRES FUNCTION
func (db *postgresDB) IsUserRegistered(email string, username string) bool {
var data models.User
err := db.DB.Table("users").Where("email = $1 OR username = $2", email, username).First(&data).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return false
}
return true
}
return true
}
func (db *postgresDB) CreateUser(user *models.User) error {
err := db.DB.Create(user).Error
if err != nil {
return err
}
return nil
}
func (db *postgresDB) GetUser(email string) (*models.User, error) {
var user models.User
err := db.DB.Table("users").Where("email = $1", email).First(&user).Error
if err != nil {
return nil, err
}
return &user, nil
}
func (db *postgresDB) UpdateUserPassword(email string, password string) error {
err := db.DB.Table("users").Where("email = $1", email).Update("password", password).Error
if err != nil {
return err
}
return nil
}
func (db *postgresDB) CreateFile(file *models.File) error {
err := db.DB.Create(file).Error
if err != nil {
return err
}
return nil
}
func (db *postgresDB) GetFile(fileID string) (*models.File, error) {
var file models.File
err := db.DB.Table("files").Where("id = $1", fileID).First(&file).Error
if err != nil {
return nil, err
}
return &file, nil
}
func (db *postgresDB) GetUserFile(name string, ownerID string) (*models.File, error) {
var file models.File
err := db.DB.Table("files").Where("name = $1 AND owner_id = $2", name, ownerID).First(&file).Error
if err != nil {
return nil, err
}
return &file, nil
}
func (db *postgresDB) GetFiles(ownerID string) ([]*models.File, error) {
var files []*models.File
err := db.DB.Table("files").Where("owner_id = $1", ownerID).Find(&files).Error
if err != nil {
return nil, err
}
return files, err
}
// CreateUploadInfo It's not optimal, but it's okay for now. Consider implementing caching instead of pushing all updates to the database for better performance in the future.
func (db *postgresDB) CreateUploadInfo(info models.FilesUploaded) error {
err := db.DB.Create(info).Error
if err != nil {
return err
}
return nil
}
func (db *postgresDB) GetUploadInfo(fileID string) (*models.FilesUploaded, error) {
var info models.FilesUploaded
err := db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).First(&info).Error
if err != nil {
return nil, err
}
return &info, nil
}
func (db *postgresDB) UpdateUpdateIndex(index int, fileID string) {
db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).Updates(map[string]interface{}{
"Uploaded": index,
})
}
func (db *postgresDB) FinalizeFileUpload(fileID string) {
db.DB.Table("files_uploadeds").Where("file_id = $1", fileID).Updates(map[string]interface{}{
"Done": true,
})
}

5
db/model/user/user.go
View File

@ -61,8 +61,7 @@ func Get(email string) (*UserWithExpired, error) {
return user, nil
}
var userData UserWithExpired
err := db.DB.Table("users").Where("email = ?", email).First(&userData).Error
userData, err := db.DB.GetUser(email)
if err != nil {
return nil, err
}
@ -75,7 +74,7 @@ func Get(email string) (*UserWithExpired, error) {
AccessAt: time.Now(),
}
return &userData, nil
return UserCache.users[email], nil
}
func DeleteCache(email string) {

5
go.mod
View File

@ -9,12 +9,17 @@ require (
golang.org/x/crypto v0.21.0
gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df
gorm.io/driver/mysql v1.5.6
gorm.io/driver/postgres v1.5.7
gorm.io/gorm v1.25.8
)
require (
github.com/go-sql-driver/mysql v1.7.0 // indirect
github.com/jackc/pgpassfile v1.0.0 // indirect
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a // indirect
github.com/jackc/pgx/v5 v5.4.3 // indirect
github.com/jinzhu/inflection v1.0.0 // indirect
github.com/jinzhu/now v1.1.5 // indirect
golang.org/x/text v0.14.0 // indirect
gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc // indirect
)

24
go.sum
View File

@ -1,25 +1,49 @@
github.com/a-h/templ v0.2.648 h1:A1ggHGIE7AONOHrFaDTM8SrqgqHL6fWgWCijQ21Zy9I=
github.com/a-h/templ v0.2.648/go.mod h1:SA7mtYwVEajbIXFRh3vKdYm/4FYyLQAtPH1+KxzGPA8=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/go-sql-driver/mysql v1.7.0 h1:ueSltNNllEqE3qcWBTD0iQd3IpL/6U+mJxLkazJ7YPc=
github.com/go-sql-driver/mysql v1.7.0/go.mod h1:OXbVy3sEdcQ2Doequ6Z5BW6fXNQTmx+9S1MCJN5yJMI=
github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI=
github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/jackc/pgpassfile v1.0.0 h1:/6Hmqy13Ss2zCq62VdNG8tM1wchn8zjSGOBJ6icpsIM=
github.com/jackc/pgpassfile v1.0.0/go.mod h1:CEx0iS5ambNFdcRtxPj5JhEz+xB6uRky5eyVu/W2HEg=
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a h1:bbPeKD0xmW/Y25WS6cokEszi5g+S0QxI/d45PkRi7Nk=
github.com/jackc/pgservicefile v0.0.0-20221227161230-091c0ba34f0a/go.mod h1:5TJZWKEWniPve33vlWYSoGYefn3gLQRzjfDlhSJ9ZKM=
github.com/jackc/pgx/v5 v5.4.3 h1:cxFyXhxlvAifxnkKKdlxv8XqUf59tDlYjnV5YYfsJJY=
github.com/jackc/pgx/v5 v5.4.3/go.mod h1:Ig06C2Vu0t5qXC60W8sqIthScaEnFvojjj9dSljmHRA=
github.com/jinzhu/inflection v1.0.0 h1:K317FqzuhWc8YvSVlFMCCUb36O/S9MCKRDI7QkRKD/E=
github.com/jinzhu/inflection v1.0.0/go.mod h1:h+uFLlag+Qp1Va5pdKtLDYj+kHp5pxUVkryuEj+Srlc=
github.com/jinzhu/now v1.1.5 h1:/o9tlHleP7gOFmsnYNz3RGnqzefHA47wQpKrrdTIwXQ=
github.com/jinzhu/now v1.1.5/go.mod h1:d3SSVoowX0Lcu0IBviAWJpolVfI5UJVZZ7cO71lE/z8=
github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk=
github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo=
golang.org/x/crypto v0.21.0 h1:X31++rzVUdKhX5sWmSOFZxx8UW/ldWx55cbf08iNAMA=
golang.org/x/crypto v0.21.0/go.mod h1:0BP7YvVV9gBbVKyeTG0Gyn+gZm94bibOW5BjDEYAOMs=
golang.org/x/text v0.14.0 h1:ScX5w1eTa3QqT8oi6+ziP7dTV1S2+ALU0bI+0zXKWiQ=
golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc h1:2gGKlE2+asNV9m7xrywl36YYNnBG5ZQ0r/BOOxqPpmk=
gopkg.in/alexcesaro/quotedprintable.v3 v3.0.0-20150716171945-2caba252f4dc/go.mod h1:m7x9LTH6d71AHyAX77c9yqWCCa3UKHcVEj9y7hAtKDk=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df h1:n7WqCuqOuCbNr617RXOY0AWRXxgwEyPp2z+p0+hgMuE=
gopkg.in/gomail.v2 v2.0.0-20160411212932-81ebce5c23df/go.mod h1:LRQQ+SO6ZHR7tOkpBDuZnXENFzX8qRjMDMyPD6BRkCw=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gorm.io/driver/mysql v1.5.6 h1:Ld4mkIickM+EliaQZQx3uOJDJHtrd70MxAUqWqlx3Y8=
gorm.io/driver/mysql v1.5.6/go.mod h1:sEtPWMiqiN1N1cMXoXmBbd8C6/l+TESwriotuRRpkDM=
gorm.io/driver/postgres v1.5.7 h1:8ptbNJTDbEmhdr62uReG5BGkdQyeasu/FZHxI0IMGnM=
gorm.io/driver/postgres v1.5.7/go.mod h1:3e019WlBaYI5o5LIdNV+LyxCMNtLOQETBXL2h4chKpA=
gorm.io/gorm v1.25.7/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=
gorm.io/gorm v1.25.8 h1:WAGEZ/aEcznN4D03laj8DKnehe1e9gYQAjW8xyPRdeo=
gorm.io/gorm v1.25.8/go.mod h1:hbnx/Oo0ChWMn1BIhpy1oYozzpM15i4YPuHDmfYtwg8=

9
handler/download/download.go
View File

@ -9,7 +9,6 @@ import (
"github.com/fossyy/filekeeper/middleware"
"github.com/fossyy/filekeeper/session"
"github.com/fossyy/filekeeper/types"
"github.com/fossyy/filekeeper/types/models"
"github.com/fossyy/filekeeper/utils"
downloadView "github.com/fossyy/filekeeper/view/download"
)
@ -41,8 +40,12 @@ func GET(w http.ResponseWriter, r *http.Request) {
}
userSession := middleware.GetUser(storeSession)
var files []models.File
db.DB.Table("files").Where("owner_id = ?", userSession.UserID).Find(&files)
files, err := db.DB.GetFiles(userSession.UserID.String())
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
var filesData []types.FileData
for i := 0; i < len(files); i++ {
filesData = append(filesData, types.FileData{

8
handler/download/file/file.go
View File

@ -7,7 +7,6 @@ import (
"github.com/fossyy/filekeeper/db"
"github.com/fossyy/filekeeper/logger"
"github.com/fossyy/filekeeper/types/models"
)
var log *logger.AggregatedLogger
@ -18,12 +17,11 @@ func init() {
func GET(w http.ResponseWriter, r *http.Request) {
fileID := r.PathValue("id")
var file models.File
err := db.DB.Table("files").Where("id = ?", fileID).First(&file).Error
file, err := db.DB.GetFile(fileID)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())
return
}
uploadDir := "uploads"
@ -42,6 +40,7 @@ func GET(w http.ResponseWriter, r *http.Request) {
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())
return
}
defer openFile.Close()
@ -49,6 +48,7 @@ func GET(w http.ResponseWriter, r *http.Request) {
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())
return
}
w.Header().Set("Content-Disposition", "attachment; filename="+stat.Name())

6
handler/forgotPassword/forgotPassword.go
View File

@ -39,6 +39,7 @@ func init() {
smtpPort, _ := strconv.Atoi(utils.Getenv("SMTP_PORT"))
mailServer = email.NewSmtpServer(utils.Getenv("SMTP_HOST"), smtpPort, utils.Getenv("SMTP_USER"), utils.Getenv("SMTP_PASSWORD"))
ticker := time.NewTicker(time.Minute)
//TESTING
go func() {
for {
<-ticker.C
@ -84,8 +85,7 @@ func POST(w http.ResponseWriter, r *http.Request) {
emailForm := r.Form.Get("email")
var user models.User
err = db.DB.Table("users").Where("email = ?", emailForm).First(&user).Error
user, err := db.DB.GetUser(emailForm)
if errors.Is(err, gorm.ErrRecordNotFound) {
component := forgotPasswordView.Main(fmt.Sprintf("Account with this email address %s is not found", emailForm), types.Message{
Code: 0,
@ -100,7 +100,7 @@ func POST(w http.ResponseWriter, r *http.Request) {
return
}
err = verifyForgot(&user)
err = verifyForgot(user)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())

4
handler/forgotPassword/verify/verify.go
View File

@ -18,6 +18,8 @@ var log *logger.AggregatedLogger
func init() {
log = logger.Logger()
//TESTING
}
func GET(w http.ResponseWriter, r *http.Request) {
@ -84,7 +86,7 @@ func POST(w http.ResponseWriter, r *http.Request) {
return
}
err = db.DB.Table("users").Where("email = ?", data.User.Email).Update("password", hashedPassword).Error
err = db.DB.UpdateUserPassword(data.User.Email, hashedPassword)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())

28
handler/signup/signup.go
View File

@ -3,7 +3,6 @@ package signupHandler
import (
"bytes"
"context"
"errors"
"fmt"
"net/http"
"strconv"
@ -19,7 +18,6 @@ import (
emailView "github.com/fossyy/filekeeper/view/email"
signupView "github.com/fossyy/filekeeper/view/signup"
"github.com/google/uuid"
"gorm.io/gorm"
)
type UnverifiedUser struct {
@ -110,18 +108,11 @@ func POST(w http.ResponseWriter, r *http.Request) {
Password: hashedPassword,
}
var data models.User
err = db.DB.Table("users").Where("email = ? OR username = ?", userEmail, username).First(&data).Error
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
err = verifyEmail(&newUser)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())
return
}
component := signupView.EmailSend("Sign up Page")
if registered := db.DB.IsUserRegistered(userEmail, username); registered {
component := signupView.Main("Sign up Page", types.Message{
Code: 0,
Message: "Email or Username has been registered",
})
err = component.Render(r.Context(), w)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
@ -130,14 +121,15 @@ func POST(w http.ResponseWriter, r *http.Request) {
}
return
}
err = verifyEmail(&newUser)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Error(err.Error())
return
}
component := signupView.Main("Sign up Page", types.Message{
Code: 0,
Message: "Email or Username has been registered",
})
component := signupView.EmailSend("Sign up Page")
err = component.Render(r.Context(), w)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)

3
handler/signup/verify/verify.go
View File

@ -25,8 +25,7 @@ func GET(w http.ResponseWriter, r *http.Request) {
return
}
err := db.DB.Create(&data.User).Error
err := db.DB.CreateUser(data.User)
if err != nil {
component := signupView.Main("Sign up Page", types.Message{
Code: 0,

27
handler/upload/initialisation/initialisation.go
View File

@ -53,7 +53,7 @@ func POST(w http.ResponseWriter, r *http.Request) {
return
}
fileData, err := getFile(fileInfo.Name, userSession.UserID)
fileData, err := db.DB.GetUserFile(fileInfo.Name, userSession.UserID.String())
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
upload, err := handleNewUpload(userSession, fileInfo)
@ -68,7 +68,7 @@ func POST(w http.ResponseWriter, r *http.Request) {
return
}
info, err := GetUploadInfo(fileData.ID.String())
info, err := db.DB.GetUploadInfo(fileData.ID.String())
if err != nil {
log.Error(err.Error())
return
@ -81,15 +81,6 @@ func POST(w http.ResponseWriter, r *http.Request) {
respondJSON(w, info)
}
func getFile(name string, ownerID uuid.UUID) (models.File, error) {
var data models.File
err := db.DB.Table("files").Where("name = ? AND owner_id = ?", name, ownerID).First(&data).Error
if err != nil {
return data, err
}
return data, nil
}
func handleNewUpload(user types.User, file types.FileInfo) (models.FilesUploaded, error) {
uploadDir := "uploads"
if _, err := os.Stat(uploadDir); os.IsNotExist(err) {
@ -124,7 +115,8 @@ func handleNewUpload(user types.User, file types.FileInfo) (models.FilesUploaded
Size: file.Size,
Downloaded: 0,
}
err = db.DB.Create(&newFile).Error
err = db.DB.CreateFile(&newFile)
if err != nil {
log.Error(err.Error())
return models.FilesUploaded{}, err
@ -140,7 +132,7 @@ func handleNewUpload(user types.User, file types.FileInfo) (models.FilesUploaded
Done: false,
}
err = db.DB.Create(&filesUploaded).Error
err = db.DB.CreateUploadInfo(filesUploaded)
if err != nil {
log.Error(err.Error())
return models.FilesUploaded{}, err
@ -148,15 +140,6 @@ func handleNewUpload(user types.User, file types.FileInfo) (models.FilesUploaded
return filesUploaded, nil
}
func GetUploadInfo(fileID string) (*models.FilesUploaded, error) {
var data *models.FilesUploaded
err := db.DB.Table("files_uploadeds").Where("file_id = ?", fileID).First(&data).Error
if err != nil {
return data, err
}
return data, nil
}
func respondJSON(w http.ResponseWriter, data interface{}) {
w.Header().Set("Content-Type", "application/json")
if err := json.NewEncoder(w).Encode(data); err != nil {

21
handler/upload/upload.go
View File

@ -2,6 +2,7 @@ package uploadHandler
import (
"errors"
"github.com/fossyy/filekeeper/db"
"io"
"net/http"
"os"
@ -9,8 +10,6 @@ import (
"strconv"
"sync"
"github.com/fossyy/filekeeper/db"
"github.com/fossyy/filekeeper/handler/upload/initialisation"
"github.com/fossyy/filekeeper/logger"
"github.com/fossyy/filekeeper/middleware"
"github.com/fossyy/filekeeper/session"
@ -57,7 +56,7 @@ func POST(w http.ResponseWriter, r *http.Request) {
userSession := middleware.GetUser(storeSession)
if r.FormValue("done") == "true" {
finalizeFileUpload(fileID)
db.DB.FinalizeFileUpload(fileID)
return
}
@ -67,7 +66,7 @@ func POST(w http.ResponseWriter, r *http.Request) {
return
}
file, err := initialisation.GetUploadInfo(fileID)
file, err := db.DB.GetUploadInfo(fileID)
if err != nil {
log.Error("error getting upload info: " + err.Error())
return
@ -105,13 +104,7 @@ func POST(w http.ResponseWriter, r *http.Request) {
if err != nil {
return
}
updateIndex(index, fileID)
}
func finalizeFileUpload(fileID string) {
db.DB.Table("files_uploadeds").Where("file_id = ?", fileID).Updates(map[string]interface{}{
"Done": true,
})
db.DB.UpdateUpdateIndex(index, fileID)
}
func createUploadDirectory(uploadDir string) error {
@ -123,12 +116,6 @@ func createUploadDirectory(uploadDir string) error {
return nil
}
func updateIndex(index int, fileID string) {
db.DB.Table("files_uploadeds").Where("file_id = ?", fileID).Updates(map[string]interface{}{
"Uploaded": index,
})
}
func handleCookieError(w http.ResponseWriter, r *http.Request, err error) {
if errors.Is(err, http.ErrNoCookie) {
http.Redirect(w, r, "/signin", http.StatusSeeOther)

19
main.go
View File

@ -1,24 +1,9 @@
package main
import (
"fmt"
"net/http"
"github.com/fossyy/filekeeper/middleware"
"github.com/fossyy/filekeeper/routes"
"github.com/fossyy/filekeeper/utils"
"github.com/fossyy/filekeeper/app"
)
func main() {
serverAddr := fmt.Sprintf("%s:%s", utils.Getenv("SERVER_HOST"), utils.Getenv("SERVER_PORT"))
server := http.Server{
Addr: serverAddr,
Handler: middleware.Handler(routes.SetupRoutes()),
}
fmt.Printf("Listening on http://%s\n", serverAddr)
err := server.ListenAndServe()
if err != nil {
return
}
app.Start()
}