beancount-gs/service/ledger.go

package service

import (
	"crypto/sha1"
	"encoding/hex"
	"io"
	"io/ioutil"
	"os"
	"os/exec"
	"sort"
	"strings"
	"time"

	"github.com/beancount-gs/script"
	"github.com/gin-gonic/gin"
)

func CheckBeancount(c *gin.Context) {
	cmd := exec.Command("bean-query", "--version")
	output, err := cmd.Output()
	if err != nil {
		InternalError(c, err.Error())
		return
	}
	OK(c, string(output))
}

func QueryServerConfig(c *gin.Context) {
	OK(c, script.GetServerConfig())
}

type QueryLedgerResult struct {
	Mail              string `json:"mail"`
	Title             string `json:"title"`
	CreateDate        string `json:"createDate"`
	OperatingCurrency string `json:"operatingCurrency"`
}

type LedgerSort []QueryLedgerResult

func (s LedgerSort) Len() int {
	return len(s)
}

func (s LedgerSort) Swap(i, j int) {
	s[i], s[j] = s[j], s[i]
}

func (s LedgerSort) Less(i, j int) bool {
	return s[i].CreateDate <= s[j].CreateDate && s[i].Mail <= s[j].Mail
}

func QueryLedgerList(c *gin.Context) {
	result := make([]QueryLedgerResult, 0)
	for _, config := range script.GetLedgerConfigMap() {
		result = append(result, QueryLedgerResult{
			Title:             config.Title,
			Mail:              config.Mail,
			CreateDate:        config.CreateDate,
			OperatingCurrency: config.OperatingCurrency,
		})
	}
	sort.Sort(LedgerSort(result))
	OK(c, result)
}

type UpdateConfigForm struct {
	Secret            string `form:"secret" binding:"required"`
	StartDate         string `form:"startDate" binding:"required"`
	DataPath          string `form:"dataPath" binding:"required"`
	OperatingCurrency string `form:"operatingCurrency" binding:"required"`
	OpeningBalances   string `form:"openingBalances" binding:"required"`
	IsBak             bool   `form:"isBak" binding:"required"`
}

func UpdateServerConfig(c *gin.Context) {
	var updateConfigForm UpdateConfigForm
	if err := c.ShouldBindJSON(&updateConfigForm); err != nil {
		BadRequest(c, err.Error())
		return
	}
	if !script.EqualServerSecret(updateConfigForm.Secret) {
		ServerSecretNotMatch(c)
		return
	}
	var serverConfig = script.Config{
		OperatingCurrency: updateConfigForm.OperatingCurrency,
		DataPath:          updateConfigForm.DataPath,
		StartDate:         updateConfigForm.StartDate,
		OpeningBalances:   updateConfigForm.OpeningBalances,
		IsBak:             updateConfigForm.IsBak,
	}
	// 更新配置
	err := script.UpdateServerConfig(serverConfig)
	if err != nil {
		InternalError(c, err.Error())
		return
	}
	// 账本目录不存在，则创建
	dataPath := serverConfig.DataPath
	if !script.FileIfExist(dataPath) {
		err = script.MkDir(dataPath)
		if err != nil {
			InternalError(c, err.Error())
			return
		}
	}
	// 加载账户缓存
	err = script.LoadLedgerConfigMap()
	if err != nil {
		InternalError(c, err.Error())
		return
	}
	err = script.LoadLedgerAccountsMap()
	if err != nil {
		InternalError(c, err.Error())
		return
	}
	QueryServerConfig(c)
}

type LoginForm struct {
	LedgerName        string `form:"ledgerName" binding:"required"`
	Secret            string `form:"secret"`
	OperatingCurrency string `form:"operatingCurrency"`
	StartDate         string `form:"startDate"`
	OpeningBalances   string `form:"openingBalances"`
	IsBak             bool   `form:"isBak"`
}

func OpenOrCreateLedger(c *gin.Context) {
	var loginForm LoginForm
	if err := c.ShouldBindJSON(&loginForm); err != nil {
		BadRequest(c, err.Error())
		return
	}
	// is mail exist white list
	if !script.IsInWhiteList(loginForm.LedgerName) {
		LedgerIsNotExist(c)
		return
	}

	t := sha1.New()
	_, err := io.WriteString(t, loginForm.LedgerName+loginForm.Secret)
	if err != nil {
		LedgerIsNotAllowAccess(c)
		return
	}

	ledgerId := hex.EncodeToString(t.Sum(nil))
	userLedger := script.GetLedgerConfigByMail(loginForm.LedgerName)
	if userLedger != nil {
		if ledgerId != userLedger.Id {
			LedgerIsNotAllowAccess(c)
			return
		}
		// 账本已存在，返回账本信息
		resultMap := make(map[string]string)
		resultMap["ledgerId"] = ledgerId
		resultMap["title"] = userLedger.Title
		resultMap["currency"] = userLedger.OperatingCurrency
		resultMap["currencySymbol"] = script.GetCommoditySymbol(userLedger.OperatingCurrency)
		resultMap["createDate"] = userLedger.CreateDate
		OK(c, resultMap)
		return
	}

	userLedger, err = createNewLedger(loginForm, ledgerId)
	if err != nil {
		InternalError(c, err.Error())
		return
	}

	resultMap := make(map[string]string)
	resultMap["ledgerId"] = ledgerId
	resultMap["title"] = userLedger.Title
	resultMap["currency"] = userLedger.OperatingCurrency
	resultMap["currencySymbol"] = script.GetCommoditySymbol(userLedger.OperatingCurrency)
	resultMap["createDate"] = userLedger.CreateDate
	OK(c, resultMap)
}

func DeleteLedger(c *gin.Context) {
	ledgerConfig := script.GetLedgerConfigFromContext(c)
	// remove from ledger_config.json
	ledgerConfigMap := script.GetLedgerConfigMap()
	delete(ledgerConfigMap, ledgerConfig.Id)
	err := script.WriteLedgerConfigMap(ledgerConfigMap)
	if err != nil {
		InternalError(c, "Failed to update ledger_config.json")
		return
	}
	// remove from account cache
	script.ClearLedgerAccounts(ledgerConfig.Id)
	script.LogInfo(ledgerConfig.Mail, "Success clear ledger account cache "+ledgerConfig.Id)
	// remove from account types cache
	script.ClearLedgerAccountTypes(ledgerConfig.Id)
	script.LogInfo(ledgerConfig.Mail, "Success clear ledger account types cache "+ledgerConfig.Id)
	// delete source file
	err = os.RemoveAll(ledgerConfig.DataPath)
	if err != nil {
		script.LogError(ledgerConfig.Mail, "Failed to delete ledger, cause by "+err.Error())
		InternalError(c, "Failed to delete ledger")
		return
	}
	script.LogInfo(ledgerConfig.Mail, "Success delete "+ledgerConfig.DataPath)
	OK(c, "OK")
}

func createNewLedger(loginForm LoginForm, ledgerId string) (*script.Config, error) {
	// create new ledger
	serverConfig := script.GetServerConfig()
	ledgerConfigMap := script.GetLedgerConfigMap()

	currency := loginForm.OperatingCurrency
	if currency == "" {
		currency = serverConfig.OperatingCurrency
	}
	startDate := loginForm.StartDate
	if startDate == "" {
		startDate = serverConfig.StartDate
	}
	openingBalances := loginForm.OpeningBalances
	if openingBalances == "" {
		openingBalances = serverConfig.OpeningBalances
	}

	ledgerConfig := script.Config{
		Id:                ledgerId,
		Mail:              loginForm.LedgerName,
		Title:             loginForm.LedgerName,
		DataPath:          serverConfig.DataPath + "/" + ledgerId,
		OperatingCurrency: currency,
		StartDate:         startDate,
		OpeningBalances:   openingBalances,
		IsBak:             loginForm.IsBak,
		CreateDate:        time.Now().Format("2006-01-02"),
	}
	// init ledger files
	err := initLedgerFiles(script.GetTemplateLedgerConfigDirPath(), ledgerConfig.DataPath, ledgerConfig)
	if err != nil {
		return nil, err
	}
	// add ledger config to ledger_config.json
	ledgerConfigMap[ledgerId] = ledgerConfig
	err = script.WriteLedgerConfigMap(ledgerConfigMap)
	if err != nil {
		return nil, err
	}
	// add accounts cache
	err = script.LoadLedgerAccounts(ledgerId)
	if err != nil {
		return nil, err
	}
	return &ledgerConfig, nil
}

func initLedgerFiles(sourceFilePath string, targetFilePath string, ledgerConfig script.Config) error {
	return copyFile(sourceFilePath, targetFilePath, ledgerConfig)
}

func copyFile(sourceFilePath string, targetFilePath string, ledgerConfig script.Config) error {
	rd, err := ioutil.ReadDir(sourceFilePath)
	if err != nil {
		return err
	}
	for _, fi := range rd {
		newSourceFilePath := sourceFilePath + "/" + fi.Name()
		newTargetFilePath := targetFilePath + "/" + fi.Name()
		if fi.IsDir() {
			err = script.MkDir(newTargetFilePath)
			err = copyFile(newSourceFilePath, newTargetFilePath, ledgerConfig)
		} else if !script.FileIfExist(newTargetFilePath) {
			fileContent, err := script.ReadFile(newSourceFilePath)
			if err != nil {
				return err
			}
			err = script.WriteFile(newTargetFilePath, strings.ReplaceAll(strings.ReplaceAll(string(fileContent), "%startDate%", ledgerConfig.StartDate), "%operatingCurrency%", ledgerConfig.OperatingCurrency))
			script.LogInfo(ledgerConfig.Mail, "Success create file "+newTargetFilePath)
		}
		if err != nil {
			return err
		}
	}
	return nil
}