351 lines
9.3 KiB
Go
351 lines
9.3 KiB
Go
package service
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/csv"
|
|
"fmt"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/akhilrex/hammond/db"
|
|
"github.com/leekchan/accounting"
|
|
)
|
|
|
|
// TODO: Move drivvo stuff to separate file
|
|
|
|
func DrivvoParseExpenses(content []byte, user *db.User) ([]db.Expense, []string) {
|
|
expenseReader := csv.NewReader(bytes.NewReader(content))
|
|
expenseReader.Comment = '#'
|
|
// Read headers (there is a trailing comma at the end, that's why we have to read the first line)
|
|
expenseReader.Read()
|
|
expenseReader.FieldsPerRecord = 6
|
|
expenseRecords, err := expenseReader.ReadAll()
|
|
|
|
var errors []string
|
|
if err != nil {
|
|
errors = append(errors, err.Error())
|
|
println(err.Error())
|
|
return nil, errors
|
|
}
|
|
|
|
var expenses []db.Expense
|
|
for index, record := range expenseRecords {
|
|
expense := db.Expense{}
|
|
|
|
date, err := time.Parse("2006-01-02 15:04:05", record[1])
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid date/time at service/expense row "+strconv.Itoa(index+1))
|
|
}
|
|
expense.Date = date
|
|
|
|
totalCost, err := strconv.ParseFloat(record[2], 32)
|
|
if err != nil {
|
|
errors = append(errors, "Found and invalid total cost at service/expense row "+strconv.Itoa(index+1))
|
|
}
|
|
expense.Amount = float32(totalCost)
|
|
|
|
odometer, err := strconv.Atoi(record[0])
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid odometer reading at service/expense row "+strconv.Itoa(index+1))
|
|
}
|
|
expense.OdoReading = odometer
|
|
|
|
notes := fmt.Sprintf("Location: %s\nNotes: %s\n", record[4], record[5])
|
|
expense.Comments = notes
|
|
|
|
expense.ExpenseType = record[3]
|
|
expense.UserID = user.ID
|
|
expense.Currency = user.Currency
|
|
expense.DistanceUnit = user.DistanceUnit
|
|
expense.Source = "Drivvo"
|
|
|
|
expenses = append(expenses, expense)
|
|
}
|
|
|
|
return expenses, errors
|
|
}
|
|
|
|
func DrivvoParseRefuelings(content []byte, user *db.User) ([]db.Fillup, []string) {
|
|
refuelingReader := csv.NewReader(bytes.NewReader(content))
|
|
refuelingReader.Comment = '#'
|
|
refuelingRecords, err := refuelingReader.ReadAll()
|
|
|
|
var errors []string
|
|
if err != nil {
|
|
errors = append(errors, err.Error())
|
|
println(err.Error())
|
|
return nil, errors
|
|
}
|
|
|
|
var fillups []db.Fillup
|
|
for index, record := range refuelingRecords {
|
|
// Skip column titles
|
|
if index == 0 {
|
|
continue
|
|
}
|
|
|
|
fillup := db.Fillup{}
|
|
|
|
date, err := time.Parse("2006-01-02 15:04:05", record[1])
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid date/time at refuel row "+strconv.Itoa(index+1))
|
|
}
|
|
fillup.Date = date
|
|
|
|
totalCost, err := strconv.ParseFloat(record[4], 32)
|
|
if err != nil {
|
|
errors = append(errors, "Found and invalid total cost at refuel row "+strconv.Itoa(index+1))
|
|
}
|
|
fillup.TotalAmount = float32(totalCost)
|
|
|
|
odometer, err := strconv.Atoi(record[0])
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid odometer reading at refuel row "+strconv.Itoa(index+1))
|
|
}
|
|
fillup.OdoReading = odometer
|
|
|
|
// TODO: Make optional
|
|
location := record[17]
|
|
fillup.FillingStation = location
|
|
|
|
pricePerUnit, err := strconv.ParseFloat(record[3], 32)
|
|
if err != nil {
|
|
// TODO: Add unit type to error message
|
|
errors = append(errors, "Found an invalid cost per unit at refuel row "+strconv.Itoa(index+1))
|
|
}
|
|
fillup.PerUnitPrice = float32(pricePerUnit)
|
|
|
|
quantity, err := strconv.ParseFloat(record[5], 32)
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid quantity at refuel row "+strconv.Itoa(index+1))
|
|
}
|
|
fillup.FuelQuantity = float32(quantity)
|
|
|
|
isTankFull := record[6] == "Yes"
|
|
fillup.IsTankFull = &isTankFull
|
|
|
|
// Unfortunatly, drivvo doesn't expose this info in their export
|
|
fal := false
|
|
fillup.HasMissedFillup = &fal
|
|
|
|
notes := fmt.Sprintf("Reason: %s\nNotes: %s\nFuel: %s\n", record[18], record[19], record[2])
|
|
fillup.Comments = notes
|
|
|
|
fillup.UserID = user.ID
|
|
fillup.Currency = user.Currency
|
|
fillup.DistanceUnit = user.DistanceUnit
|
|
fillup.Source = "Drivvo"
|
|
|
|
fillups = append(fillups, fillup)
|
|
}
|
|
return fillups, errors
|
|
}
|
|
|
|
func DrivvoImport(content []byte, userId string) []string {
|
|
var errors []string
|
|
user, err := GetUserById(userId)
|
|
if err != nil {
|
|
errors = append(errors, err.Error())
|
|
return errors
|
|
}
|
|
|
|
serviceSectionIndex := bytes.Index(content, []byte("#Service"))
|
|
|
|
endParseIndex := bytes.Index(content, []byte("#Income"))
|
|
if endParseIndex == -1 {
|
|
endParseIndex = bytes.Index(content, []byte("#Route"))
|
|
if endParseIndex == -1 {
|
|
endParseIndex = len(content)
|
|
}
|
|
|
|
}
|
|
|
|
expenseSectionIndex := bytes.Index(content, []byte("#Expense"))
|
|
if expenseSectionIndex == -1 {
|
|
expenseSectionIndex = endParseIndex
|
|
}
|
|
|
|
fillups, errors := DrivvoParseRefuelings(content[:serviceSectionIndex], user)
|
|
_ = fillups
|
|
|
|
var allExpenses []db.Expense
|
|
if serviceSectionIndex != -1 {
|
|
services, parseErrors := DrivvoParseExpenses(content[serviceSectionIndex:expenseSectionIndex], user)
|
|
if parseErrors != nil {
|
|
errors = append(errors, parseErrors...)
|
|
}
|
|
allExpenses = append(allExpenses, services...)
|
|
}
|
|
|
|
if expenseSectionIndex != endParseIndex {
|
|
expenses, parseErrors := DrivvoParseExpenses(content[expenseSectionIndex:endParseIndex], user)
|
|
if parseErrors != nil {
|
|
errors = append(errors, parseErrors...)
|
|
}
|
|
allExpenses = append(allExpenses, expenses...)
|
|
}
|
|
|
|
if len(errors) != 0 {
|
|
return errors
|
|
}
|
|
|
|
errors = append(errors, "Not implemented")
|
|
return errors
|
|
}
|
|
|
|
func FuellyImport(content []byte, userId string) []string {
|
|
stream := bytes.NewReader(content)
|
|
reader := csv.NewReader(stream)
|
|
records, err := reader.ReadAll()
|
|
|
|
var errors []string
|
|
if err != nil {
|
|
errors = append(errors, err.Error())
|
|
return errors
|
|
}
|
|
|
|
vehicles, err := GetUserVehicles(userId)
|
|
if err != nil {
|
|
errors = append(errors, err.Error())
|
|
return errors
|
|
}
|
|
user, err := GetUserById(userId)
|
|
|
|
if err != nil {
|
|
errors = append(errors, err.Error())
|
|
return errors
|
|
}
|
|
|
|
var vehicleMap map[string]db.Vehicle = make(map[string]db.Vehicle)
|
|
for _, vehicle := range *vehicles {
|
|
vehicleMap[vehicle.Nickname] = vehicle
|
|
}
|
|
|
|
var fillups []db.Fillup
|
|
var expenses []db.Expense
|
|
layout := "2006-01-02 15:04"
|
|
altLayout := "2006-01-02 3:04 PM"
|
|
|
|
for index, record := range records {
|
|
if index == 0 {
|
|
continue
|
|
}
|
|
|
|
var vehicle db.Vehicle
|
|
var ok bool
|
|
if vehicle, ok = vehicleMap[record[4]]; !ok {
|
|
errors = append(errors, "Found an unmapped vehicle entry at row "+strconv.Itoa(index+1))
|
|
}
|
|
dateStr := record[2] + " " + record[3]
|
|
date, err := time.Parse(layout, dateStr)
|
|
if err != nil {
|
|
date, err = time.Parse(altLayout, dateStr)
|
|
}
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid date/time at row "+strconv.Itoa(index+1))
|
|
}
|
|
|
|
totalCostStr := accounting.UnformatNumber(record[9], 3, user.Currency)
|
|
totalCost64, err := strconv.ParseFloat(totalCostStr, 32)
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid total cost at row "+strconv.Itoa(index+1))
|
|
}
|
|
|
|
totalCost := float32(totalCost64)
|
|
odoStr := accounting.UnformatNumber(record[5], 0, user.Currency)
|
|
odoreading, err := strconv.Atoi(odoStr)
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid odo reading at row "+strconv.Itoa(index+1))
|
|
}
|
|
location := record[12]
|
|
|
|
//Create Fillup
|
|
if record[0] == "Gas" {
|
|
rateStr := accounting.UnformatNumber(record[7], 3, user.Currency)
|
|
ratet64, err := strconv.ParseFloat(rateStr, 32)
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid cost per gallon at row "+strconv.Itoa(index+1))
|
|
}
|
|
rate := float32(ratet64)
|
|
|
|
quantity64, err := strconv.ParseFloat(record[8], 32)
|
|
if err != nil {
|
|
errors = append(errors, "Found an invalid quantity at row "+strconv.Itoa(index+1))
|
|
}
|
|
quantity := float32(quantity64)
|
|
|
|
notes := fmt.Sprintf("Octane:%s\nGas Brand:%s\nLocation%s\nTags:%s\nPayment Type:%s\nTire Pressure:%s\nNotes:%s\nMPG:%s",
|
|
record[10], record[11], record[12], record[13], record[14], record[15], record[16], record[1],
|
|
)
|
|
|
|
isTankFull := record[6] == "Full"
|
|
fal := false
|
|
fillups = append(fillups, db.Fillup{
|
|
VehicleID: vehicle.ID,
|
|
FuelUnit: vehicle.FuelUnit,
|
|
FuelQuantity: quantity,
|
|
PerUnitPrice: rate,
|
|
TotalAmount: totalCost,
|
|
OdoReading: odoreading,
|
|
IsTankFull: &isTankFull,
|
|
Comments: notes,
|
|
FillingStation: location,
|
|
HasMissedFillup: &fal,
|
|
UserID: userId,
|
|
Date: date,
|
|
Currency: user.Currency,
|
|
DistanceUnit: user.DistanceUnit,
|
|
Source: "Fuelly",
|
|
})
|
|
|
|
}
|
|
if record[0] == "Service" {
|
|
notes := fmt.Sprintf("Tags:%s\nPayment Type:%s\nNotes:%s",
|
|
record[13], record[14], record[16],
|
|
)
|
|
expenses = append(expenses, db.Expense{
|
|
VehicleID: vehicle.ID,
|
|
Amount: totalCost,
|
|
OdoReading: odoreading,
|
|
Comments: notes,
|
|
ExpenseType: record[17],
|
|
UserID: userId,
|
|
Currency: user.Currency,
|
|
Date: date,
|
|
DistanceUnit: user.DistanceUnit,
|
|
Source: "Fuelly",
|
|
})
|
|
}
|
|
|
|
}
|
|
if len(errors) != 0 {
|
|
return errors
|
|
}
|
|
|
|
tx := db.DB.Begin()
|
|
defer func() {
|
|
if r := recover(); r != nil {
|
|
tx.Rollback()
|
|
}
|
|
}()
|
|
if err := tx.Error; err != nil {
|
|
errors = append(errors, err.Error())
|
|
return errors
|
|
}
|
|
if err := tx.Create(&fillups).Error; err != nil {
|
|
tx.Rollback()
|
|
errors = append(errors, err.Error())
|
|
return errors
|
|
}
|
|
if err := tx.Create(&expenses).Error; err != nil {
|
|
tx.Rollback()
|
|
errors = append(errors, err.Error())
|
|
return errors
|
|
}
|
|
err = tx.Commit().Error
|
|
if err != nil {
|
|
errors = append(errors, err.Error())
|
|
}
|
|
return errors
|
|
}
|