first commit

server/service/fileService.go

@@ -0,0 +1,236 @@
+package service
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"path"
+	"path/filepath"
+	"sort"
+	"strconv"
+	"time"
+
+	"github.com/akhilrex/hammond/db"
+	"github.com/akhilrex/hammond/internal/sanitize"
+	"github.com/akhilrex/hammond/models"
+	uuid "github.com/satori/go.uuid"
+)
+
+func CreateAttachment(path, originalName string, size int64, contentType, userId string) (*db.Attachment, error) {
+	model := &db.Attachment{
+		Path:         path,
+		OriginalName: originalName,
+		Size:         size,
+		ContentType:  contentType,
+		UserID:       userId,
+	}
+	tx := db.DB.Create(&model)
+
+	if tx.Error != nil {
+		return nil, tx.Error
+	}
+	return model, nil
+}
+
+func CreateQuickEntry(model models.CreateQuickEntryModel, attachmentId, userId string) (*db.QuickEntry, error) {
+	toCreate := &db.QuickEntry{
+		AttachmentID: attachmentId,
+		UserID:       userId,
+		Comments:     model.Comments,
+	}
+	tx := db.DB.Create(&toCreate)
+
+	if tx.Error != nil {
+		return nil, tx.Error
+	}
+	return toCreate, nil
+}
+func GetAllQuickEntries(sorting string) (*[]db.QuickEntry, error) {
+	return db.GetAllQuickEntries(sorting)
+}
+func GetQuickEntriesForUser(userId, sorting string) (*[]db.QuickEntry, error) {
+	return db.GetQuickEntriesForUser(userId, sorting)
+}
+func GetQuickEntryById(id string) (*db.QuickEntry, error) {
+	return db.GetQuickEntryById(id)
+}
+func SetQuickEntryAsProcessed(id string) error {
+	return db.SetQuickEntryAsProcessed(id, time.Now())
+
+}
+
+func GetAttachmentById(id string) (*db.Attachment, error) {
+	return db.GetAttachmentById(id)
+}
+
+func GetAllBackupFiles() ([]string, error) {
+	var files []string
+	folder := createConfigFolderIfNotExists("backups")
+	err := filepath.Walk(folder, func(path string, info os.FileInfo, err error) error {
+		if !info.IsDir() {
+			files = append(files, path)
+		}
+		return nil
+	})
+	sort.Sort(sort.Reverse(sort.StringSlice(files)))
+	return files, err
+}
+
+func GetFileSize(path string) (int64, error) {
+	info, err := os.Stat(path)
+	if err != nil {
+		return 0, err
+	}
+	return info.Size(), nil
+}
+
+func deleteOldBackup() {
+	files, err := GetAllBackupFiles()
+	if err != nil {
+		return
+	}
+	if len(files) <= 5 {
+		return
+	}
+
+	toDelete := files[5:]
+	for _, file := range toDelete {
+		fmt.Println(file)
+		DeleteFile(file)
+	}
+}
+
+func GetFilePath(originalName string) string {
+	dataPath := os.Getenv("DATA")
+	return path.Join(dataPath, getFileName(originalName))
+}
+func getFileName(orig string) string {
+
+	ext := filepath.Ext(orig)
+	return uuid.NewV4().String() + ext
+
+}
+
+func CreateBackup() (string, error) {
+
+	backupFileName := "hammond_backup_" + time.Now().Format("2006.01.02_150405") + ".tar.gz"
+	folder := createConfigFolderIfNotExists("backups")
+	configPath := os.Getenv("CONFIG")
+	tarballFilePath := path.Join(folder, backupFileName)
+	file, err := os.Create(tarballFilePath)
+	if err != nil {
+		return "", errors.New(fmt.Sprintf("Could not create tarball file '%s', got error '%s'", tarballFilePath, err.Error()))
+	}
+	defer file.Close()
+
+	dbPath := path.Join(configPath, "hammond.db")
+	_, err = os.Stat(dbPath)
+	if err != nil {
+		return "", errors.New(fmt.Sprintf("Could not find db file '%s', got error '%s'", dbPath, err.Error()))
+	}
+	gzipWriter := gzip.NewWriter(file)
+	defer gzipWriter.Close()
+
+	tarWriter := tar.NewWriter(gzipWriter)
+	defer tarWriter.Close()
+
+	err = addFileToTarWriter(dbPath, tarWriter)
+	if err == nil {
+		deleteOldBackup()
+	}
+	return backupFileName, err
+}
+
+func addFileToTarWriter(filePath string, tarWriter *tar.Writer) error {
+	file, err := os.Open(filePath)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Could not open file '%s', got error '%s'", filePath, err.Error()))
+	}
+	defer file.Close()
+
+	stat, err := file.Stat()
+	if err != nil {
+		return errors.New(fmt.Sprintf("Could not get stat for file '%s', got error '%s'", filePath, err.Error()))
+	}
+
+	header := &tar.Header{
+		Name:    filePath,
+		Size:    stat.Size(),
+		Mode:    int64(stat.Mode()),
+		ModTime: stat.ModTime(),
+	}
+
+	err = tarWriter.WriteHeader(header)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Could not write header for file '%s', got error '%s'", filePath, err.Error()))
+	}
+
+	_, err = io.Copy(tarWriter, file)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Could not copy the file '%s' data to the tarball, got error '%s'", filePath, err.Error()))
+	}
+
+	return nil
+}
+func httpClient() *http.Client {
+	client := http.Client{
+		CheckRedirect: func(r *http.Request, via []*http.Request) error {
+			//	r.URL.Opaque = r.URL.Path
+			return nil
+		},
+	}
+
+	return &client
+}
+
+func createFolder(folder string, parent string) string {
+	folder = cleanFileName(folder)
+	//str := stringy.New(folder)
+	folderPath := path.Join(parent, folder)
+	if _, err := os.Stat(folderPath); os.IsNotExist(err) {
+		os.MkdirAll(folderPath, 0777)
+		changeOwnership(folderPath)
+	}
+	return folderPath
+}
+
+func createDataFolderIfNotExists(folder string) string {
+	dataPath := os.Getenv("DATA")
+	return createFolder(folder, dataPath)
+}
+func createConfigFolderIfNotExists(folder string) string {
+	dataPath := os.Getenv("CONFIG")
+	return createFolder(folder, dataPath)
+}
+
+func cleanFileName(original string) string {
+	return sanitize.Name(original)
+}
+func changeOwnership(path string) {
+	uid, err1 := strconv.Atoi(os.Getenv("PUID"))
+	gid, err2 := strconv.Atoi(os.Getenv("PGID"))
+	fmt.Println(path)
+	if err1 == nil && err2 == nil {
+		fmt.Println(path + " : Attempting change")
+		os.Chown(path, uid, gid)
+	}
+
+}
+func DeleteFile(filePath string) error {
+	if _, err := os.Stat(filePath); os.IsNotExist(err) {
+		return err
+	}
+	if err := os.Remove(filePath); err != nil {
+		return err
+	}
+	return nil
+}
+func checkError(err error) {
+	if err != nil {
+		panic(err)
+	}
+}

server/service/miscService.go

@@ -0,0 +1,30 @@
+package service
+
+import (
+	"github.com/akhilrex/hammond/db"
+)
+
+func CanInitializeSystem() (bool, error) {
+	return db.CanInitializeSystem()
+}
+
+func UpdateSettings(currency string, distanceUnit db.DistanceUnit) error {
+	setting := db.GetOrCreateSetting()
+	setting.Currency = currency
+	setting.DistanceUnit = distanceUnit
+	return db.UpdateSettings(setting)
+}
+func UpdateUserSettings(userId, currency string, distanceUnit db.DistanceUnit) error {
+	user, err := db.GetUserById(userId)
+	if err != nil {
+		return err
+	}
+
+	user.Currency = currency
+	user.DistanceUnit = distanceUnit
+	return db.UpdateUser(user)
+}
+
+func GetSettings() *db.Setting {
+	return db.GetOrCreateSetting()
+}

server/service/userService.go

@@ -0,0 +1,47 @@
+package service
+
+import (
+	"github.com/akhilrex/hammond/db"
+	"github.com/akhilrex/hammond/models"
+)
+
+func CreateUser(userModel *models.RegisterRequest, role db.Role) error {
+	setting := db.GetOrCreateSetting()
+	toCreate := db.User{
+		Email:        userModel.Email,
+		Name:         userModel.Name,
+		Role:         role,
+		Currency:     setting.Currency,
+		DistanceUnit: setting.DistanceUnit,
+	}
+
+	toCreate.SetPassword(userModel.Password)
+
+	return db.CreateUser(&toCreate)
+
+}
+
+func GetUserById(id string) (*db.User, error) {
+	var myUserModel db.User
+	tx := db.DB.Debug().Preload("Vehicles").First(&myUserModel, map[string]string{
+		"ID": id,
+	})
+	return &myUserModel, tx.Error
+}
+
+func GetAllUsers() (*[]db.User, error) {
+	return db.GetAllUsers()
+}
+
+func UpdatePassword(id, password string) (bool, error) {
+	user, err := GetUserById(id)
+	if err != nil {
+		return false, err
+	}
+	user.SetPassword(password)
+	err = db.UpdateUser(user)
+	if err != nil {
+		return false, err
+	}
+	return true, nil
+}

server/service/vehicleService.go

@@ -0,0 +1,234 @@
+package service
+
+import (
+	"github.com/akhilrex/hammond/db"
+	"github.com/akhilrex/hammond/models"
+	"gorm.io/gorm/clause"
+)
+
+func CreateVehicle(model models.CreateVehicleRequest, userId string) (*db.Vehicle, error) {
+	vehicle := db.Vehicle{
+		Nickname:          model.Nickname,
+		Registration:      model.Registration,
+		Model:             model.Model,
+		Make:              model.Make,
+		YearOfManufacture: model.YearOfManufacture,
+		EngineSize:        model.EngineSize,
+		FuelUnit:          *model.FuelUnit,
+		FuelType:          *model.FuelType,
+	}
+
+	tx := db.DB.Create(&vehicle)
+	if tx.Error != nil {
+		return nil, tx.Error
+	}
+	association := db.UserVehicle{
+		UserID:    userId,
+		VehicleID: vehicle.ID,
+		IsOwner:   true,
+	}
+	tx = db.DB.Create(&association)
+	if tx.Error != nil {
+		return nil, tx.Error
+	}
+	return &vehicle, nil
+
+}
+
+func GetVehicleOwner(vehicleId string) (string, error) {
+	return db.GetVehicleOwner(vehicleId)
+}
+
+func GetVehicleUsers(vehicleId string) (*[]db.UserVehicle, error) {
+	return db.GetVehicleUsers(vehicleId)
+}
+func ShareVehicle(vehicleId, userId string) error {
+	return db.ShareVehicle(vehicleId, userId)
+}
+func UnshareVehicle(vehicleId, userId string) error {
+	return db.UnshareVehicle(vehicleId, userId)
+}
+
+func GetVehicleById(vehicleID string) (*db.Vehicle, error) {
+	return db.GetVehicleById(vehicleID)
+}
+func GetFillupsByVehicleId(vehicleId string) (*[]db.Fillup, error) {
+	return db.GetFillupsByVehicleId(vehicleId)
+}
+func GetExpensesByVehicleId(vehicleId string) (*[]db.Expense, error) {
+	return db.GetExpensesByVehicleId(vehicleId)
+}
+func GetFillupById(fillupId string) (*db.Fillup, error) {
+	return db.GetFillupById(fillupId)
+}
+func GetExpenseById(expenseId string) (*db.Expense, error) {
+	return db.GetExpenseById(expenseId)
+}
+func UpdateVehicle(vehicleID string, model models.UpdateVehicleRequest) error {
+	toUpdate, err := GetVehicleById(vehicleID)
+	if err != nil {
+		return err
+	}
+	//return db.DB.Model(&toUpdate).Updates(db.Vehicle{
+	toUpdate.Nickname = model.Nickname
+	toUpdate.Registration = model.Registration
+	toUpdate.Model = model.Model
+	toUpdate.Make = model.Make
+	toUpdate.YearOfManufacture = model.YearOfManufacture
+	toUpdate.EngineSize = model.EngineSize
+	toUpdate.FuelUnit = *model.FuelUnit
+	toUpdate.FuelType = *model.FuelType
+	//}).Error
+
+	return db.DB.Omit(clause.Associations).Save(toUpdate).Error
+}
+func GetAllVehicles() (*[]db.Vehicle, error) {
+	return db.GetAllVehicles("")
+}
+
+func GetUserVehicles(id string) (*[]db.Vehicle, error) {
+	return db.GetUserVehicles(id)
+}
+
+func CreateFillup(model models.CreateFillupRequest) (*db.Fillup, error) {
+
+	user, err := db.GetUserById(model.UserID)
+	if err != nil {
+		return nil, err
+	}
+
+	fillup := db.Fillup{
+		VehicleID:       model.VehicleID,
+		FuelUnit:        *model.FuelUnit,
+		FuelQuantity:    model.FuelQuantity,
+		PerUnitPrice:    model.PerUnitPrice,
+		TotalAmount:     model.TotalAmount,
+		OdoReading:      model.OdoReading,
+		IsTankFull:      model.IsTankFull,
+		HasMissedFillup: model.HasMissedFillup,
+		Comments:        model.Comments,
+		FillingStation:  model.FillingStation,
+		UserID:          model.UserID,
+		Date:            model.Date,
+		Currency:        user.Currency,
+		DistanceUnit:    user.DistanceUnit,
+	}
+
+	tx := db.DB.Create(&fillup)
+	if tx.Error != nil {
+		return nil, tx.Error
+	}
+
+	return &fillup, nil
+
+}
+
+func CreateExpense(model models.CreateExpenseRequest) (*db.Expense, error) {
+	user, err := db.GetUserById(model.UserID)
+	if err != nil {
+		return nil, err
+	}
+
+	expense := db.Expense{
+		VehicleID:    model.VehicleID,
+		Amount:       model.Amount,
+		OdoReading:   model.OdoReading,
+		ExpenseType:  model.ExpenseType,
+		Comments:     model.Comments,
+		UserID:       model.UserID,
+		Date:         model.Date,
+		Currency:     user.Currency,
+		DistanceUnit: user.DistanceUnit,
+	}
+
+	tx := db.DB.Create(&expense)
+	if tx.Error != nil {
+		return nil, tx.Error
+	}
+
+	return &expense, nil
+
+}
+
+func UpdateFillup(fillupId string, model models.UpdateFillupRequest) error {
+	toUpdate, err := GetFillupById(fillupId)
+	if err != nil {
+		return err
+	}
+	return db.DB.Model(&toUpdate).Updates(db.Fillup{
+		VehicleID:       model.VehicleID,
+		FuelUnit:        *model.FuelUnit,
+		FuelQuantity:    model.FuelQuantity,
+		PerUnitPrice:    model.PerUnitPrice,
+		TotalAmount:     model.TotalAmount,
+		OdoReading:      model.OdoReading,
+		IsTankFull:      model.IsTankFull,
+		HasMissedFillup: model.HasMissedFillup,
+		Comments:        model.Comments,
+		FillingStation:  model.FillingStation,
+		UserID:          model.UserID,
+		Date:            model.Date,
+	}).Error
+}
+
+func UpdateExpense(fillupId string, model models.UpdateExpenseRequest) error {
+	toUpdate, err := GetExpenseById(fillupId)
+	if err != nil {
+		return err
+	}
+	return db.DB.Model(&toUpdate).Updates(db.Expense{
+		VehicleID:   model.VehicleID,
+		Amount:      model.Amount,
+		OdoReading:  model.OdoReading,
+		ExpenseType: model.ExpenseType,
+		Comments:    model.Comments,
+		UserID:      model.UserID,
+		Date:        model.Date,
+	}).Error
+}
+
+func DeleteFillupById(fillupId string) error {
+	return db.DeleteFillupById(fillupId)
+}
+func DeleteExpenseById(expenseId string) error {
+	return db.DeleteExpenseById(expenseId)
+}
+
+func CreateVehicleAttachment(vehicleId, attachmentId, title string) error {
+	model := &db.VehicleAttachment{
+		AttachmentID: attachmentId,
+		VehicleID:    vehicleId,
+		Title:        title,
+	}
+	return db.DB.Create(model).Error
+}
+func GetVehicleAttachments(vehicleId string) (*[]db.Attachment, error) {
+
+	return db.GetVehicleAttachments(vehicleId)
+}
+
+func GetUserStats(userId string, model models.UserStatsQueryModel) ([]models.VehicleStatsModel, error) {
+
+	vehicles, err := GetUserVehicles(userId)
+	if err != nil {
+		return nil, err
+	}
+
+	var vehicleIds []string
+	for _, v := range *vehicles {
+		vehicleIds = append(vehicleIds, v.ID)
+	}
+
+	expenses, err := db.FindExpensesForDateRange(vehicleIds, model.Start, model.End)
+	if err != nil {
+		return nil, err
+	}
+	fillups, err := db.FindFillupsForDateRange(vehicleIds, model.Start, model.End)
+	if err != nil {
+		return nil, err
+	}
+	toReturn := models.VehicleStatsModel{}
+	stats := toReturn.SetStats(fillups, expenses)
+
+	return stats, nil
+}