liulei/jx-print
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

打印机

Browse Source
This commit is contained in:
邹宗楠
2022-07-11 16:43:16 +08:00
parent 80c079db4e
commit ecdb628231
17 changed files with 64 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

74
services/print_server/app.go Normal file
View File

@@ -0,0 +1,74 @@
package print_server
import (
"fmt"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-print/dao"
"git.rosy.net.cn/jx-print/globals"
"git.rosy.net.cn/jx-print/model"
putils "git.rosy.net.cn/jx-print/putils"
"github.com/gin-gonic/gin"
"time"
)
func GetApps(c *gin.Context, userID string) (apps []*model.Apps, err error) {
if userID == "" {
return nil, fmt.Errorf("账号信息有误，请重新登录！")
}
return dao.GetApps(globals.GetDB(), 0, userID, "")
}
func AddApp(c *gin.Context, code, name, mobile, userID string) (err error) {
var (
db = globals.GetDB()
now = time.Now()
)
//if rcode := putils.GetKey(mobile); rcode == "" {
// putils.DelKey(mobile)
// return fmt.Errorf("验证码错误！")
//} else if code != rcode {
// putils.DelKey(mobile)
// return fmt.Errorf("验证码错误！")
//}
//putils.DelKey(mobile)
if apps, _ := dao.GetApps(db, 0, userID, ""); len(apps) > 2 {
return fmt.Errorf("同一个账号最多只能建3个app！")
}
if apps, _ := dao.GetApps(db, 0, "", mobile); len(apps) > 0 {
return fmt.Errorf("同一个手机号只能建1个app！")
}
apps := &model.Apps{
CreatedAt: &now,
UpdatedAt: &now,
DeletedAt: &utils.DefaultTimeValue,
Name: name,
Type: 0,
Status: 1,
AppKey: putils.RandStringBytes(16),
UserID: userID,
Mobile: mobile,
}
err = dao.Insert(db, apps)
return err
}
func DelApp(c *gin.Context, appID int, userID string) (err error) {
var (
db = globals.GetDB()
now = time.Now()
)
if appID == 0 {
return fmt.Errorf("参数错误！appID :%v", appID)
}
if apps, err2 := dao.GetApps(db, appID, userID, ""); err2 != nil {
return err2
} else if len(apps) == 0 {
return fmt.Errorf("未查询到此应用！app_id :%d, user_id: %s", appID, userID)
} else {
app := apps[0]
app.DeletedAt = &now
err = dao.Update(db, app, model.FieldDeletedAt)
}
return err
}

12
services/print_server/config.go Normal file
View File

@@ -0,0 +1,12 @@
package print_server
import (
"git.rosy.net.cn/jx-print/dao"
"git.rosy.net.cn/jx-print/globals"
"git.rosy.net.cn/jx-print/model"
"github.com/gin-gonic/gin"
)
func GetConfig(c *gin.Context, configType, key string) (config *model.NewConfig, err error) {
return dao.GetConfig(globals.GetDB(), configType, key)
}

15
services/print_server/list_test.go Normal file
View File

@@ -0,0 +1,15 @@
package print_server
import (
"fmt"
"sort"
"testing"
)
func Test_list(b *testing.T) {
//aa := []string{"app_key", "format", "jd_param_json", "timestamp", "token", "v"}
aa := []string{"format", "jd_param_json", "app_key", "timestamp", "token", "v"}
fmt.Println(aa)
sort.Strings(aa)
fmt.Println(aa)
}

191
services/print_server/order.go Normal file
View File

@@ -0,0 +1,191 @@
package print_server
import (
"encoding/json"
"git.rosy.net.cn/baseapi/platformapi/tonglianpayapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-print/dao"
"git.rosy.net.cn/jx-print/globals"
"git.rosy.net.cn/jx-print/model"
"git.rosy.net.cn/jx-print/putils"
"git.rosy.net.cn/jx-print/services/api"
"github.com/jmoiron/sqlx"
"time"
)
var (
findOrderPayPriceMap = map[string]func(db *sqlx.DB, typeID string) (int64, error){
model.OrderTypeFlow: func(db *sqlx.DB, typeID string) (payPrice int64, err error) {
var flowCfg []*model.FlowConfig
if config, err2 := dao.GetConfig(db, model.ConfigTypeSys, model.OrderTypeFlow); err2 == nil && config != nil {
if err = json.Unmarshal([]byte(config.Value), &flowCfg); err == nil && len(flowCfg) > 0 {
for _, v := range flowCfg {
if v.ID == utils.Str2Int(typeID) {
payPrice = v.Price
break
}
}
}
} else {
err = err2
}
return payPrice, err
},
model.OrderTypeCardValid: func(db *sqlx.DB, typeID string) (payPrice int64, err error) {
var (
avgPrice int64
count = utils.Str2Int(typeID) //充卡有效期代表几个月
)
if config, err2 := dao.GetConfig(db, model.ConfigTypeSys, model.OrderTypeCardValid); err2 == nil && config != nil {
avgPrice = utils.Str2Int64(config.Value)
} else {
err = err2
}
return avgPrice * int64(count), err
},
}
payFunc = map[string]func(db *sqlx.DB, order *model.PayOrder, vendorPayType string) (err error){
model.PayTypeTL: func(db *sqlx.DB, order *model.PayOrder, vendorPayType string) (err error) {
param := &tonglianpayapi.CreateUnitorderOrderParam{
Trxamt: int(order.PayPrice),
NotifyUrl: "http://print.jxc4.com/callback/tlPayCallback",
Reqsn: order.OrderID,
PayType: vendorPayType,
}
//if vendorPayType != tonglianpayapi.PayTypeWxCode {
// return fmt.Errorf("暂不支持的支付类型！vendorPayType :%s", vendorPayType)
//}
result, err := api.TLpayAPI.CreateUnitorderOrder(param)
if err == nil {
order.PrepayID = result.PayInfo
order.TransactionID = result.TrxID
err = dao.Update(db, order, "transaction_id", "prepay_id")
}
return err
},
}
payFinishedFunc = map[string]func(db *sqlx.DB, order *model.PayOrder) (err error){
//冲流量，支付完了之后要充进去
model.OrderTypeFlow: func(db *sqlx.DB, order *model.PayOrder) (err error) {
var (
flowCfg []*model.FlowConfig
iccID = order.ThingID
flow float64
unit string
now = time.Now()
monthBegin = utils.Str2Time(now.Format("2006-01") + "-01 00:00:00")
monthEnd = utils.Str2Time(monthBegin.AddDate(0, 1, 0).AddDate(0, 0, -1).Format("2006-01-02") + " 23:59:59")
)
if config, err2 := dao.GetConfig(db, model.ConfigTypeSys, model.OrderTypeFlow); err2 == nil && config != nil {
if err = json.Unmarshal([]byte(config.Value), &flowCfg); err == nil && len(flowCfg) > 0 {
for _, v := range flowCfg {
if v.ID == utils.Str2Int(order.TypeID) {
flow, unit = v.Flow, v.Unit
break
}
}
}
}
err = FlowIncome(db, iccID, flow, unit, model.FlowIncomeTypeUser, order.OrderID)
//冲进去之后重新计算流量超标
sumIncome, _ := dao.GetSimFlowIncomeSum(db, iccID, monthBegin, monthEnd)
sumExpend, _ := dao.GetSimFlowExpendSum(db, iccID, monthBegin, monthEnd)
if sumIncome != nil && sumExpend != nil {
if printer, err := dao.GetPrinter(db, "", iccID); err == nil && printer != nil {
flowFlag := 0
if sumIncome.Flow-sumExpend.Flow <= 0 {
flowFlag = 1
}
printer.FlowFlag = flowFlag
err = dao.Update(db, printer, "flow_flag")
}
}
return err
},
model.OrderTypeCardValid: func(db *sqlx.DB, order *model.PayOrder) (err error) {
_, err = api.TibiotAPI.Submit(order.ThingID, utils.Str2Int(order.TypeID))
return err
},
}
)
func CreateOrder(tokenInfo *model.TokenInfo, orderType, origin, thingID, typeID string) (orderID string, err error) {
var (
db = globals.GetDB()
now = time.Now()
payPrice int64
)
if payPrice, err = findOrderPayPriceMap[orderType](db, typeID); err != nil {
return "", err
}
globals.SugarLogger.Debugf("CreateOrder payPrice: %v", payPrice)
orderID = utils.Int64ToStr(putils.GenOrderNo())
payOrder := &model.PayOrder{
CreatedAt: &now,
OrderID: orderID,
PayPrice: payPrice,
UserID: tokenInfo.User.UserID,
OrderType: orderType,
Origin: origin,
ThingID: thingID,
TypeID: typeID,
}
err = dao.Insert(db, payOrder)
return orderID, err
}
func Pay(tokenInfo *model.TokenInfo, orderID, payType, vendorPayType string) (order *model.PayOrder, err error) {
var (
db = globals.GetDB()
)
if order, err = dao.GetOrder(db, orderID); err != nil {
return order, err
}
err = payFunc[payType](db, order, vendorPayType)
return order, err
}
func PayTLCallback(call *tonglianpayapi.CallBackResult) (err error) {
var (
db = globals.GetDB()
orderID = call.CusorderID
)
if order, err := dao.GetOrder(db, orderID); err == nil {
if order.Status != model.OrderStatusWaitPay {
globals.SugarLogger.Debugf("already pay msg:%s, err:%v", utils.Format4Output(call, true), err)
return err
}
loc, _ := time.LoadLocation("Local")
t1, _ := time.ParseInLocation("20060102150405", call.PayTime, loc)
order.PayFinishedAt = &t1
data, _ := json.Marshal(call)
dataStr := string(data)
order.OriginalData = &dataStr
if call.TrxStatus == tonglianpayapi.TrxStatusSuccess {
order.Status = model.OrderStatusPaid
} else {
order.Status = model.OrderStatusPayFail
}
dao.Update(db, order, "status", "pay_finished_at", "original_data")
if call.TrxStatus == tonglianpayapi.TrxStatusSuccess {
err = OnPayFinished(order)
}
} else {
globals.SugarLogger.Debugf("onTLpayFinished msg:%s, err:%v", utils.Format4Output(call, true), err)
}
return err
}
func OnPayFinished(order *model.PayOrder) (err error) {
var (
db = globals.GetDB()
)
err = payFinishedFunc[order.OrderType](db, order)
if err != nil {
order.Comment = err.Error()
dao.Update(db, order, "Comment")
}
return err
}

238
services/print_server/print.go Normal file
View File

@@ -0,0 +1,238 @@
package print_server
import (
"fmt"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-print/dao"
"git.rosy.net.cn/jx-print/globals"
"git.rosy.net.cn/jx-print/model"
putils "git.rosy.net.cn/jx-print/putils"
"github.com/gin-gonic/gin"
"time"
)
const (
sounda = "sounda" //提示音a
soundb = "soundb" //提示音b
soundc = "soundc" //提示音c
soundd = "soundd" //提示音d
sounde = "sounde" //报警音e
soundf = "soundf" //报警音f
soundg = "soundg" //报警音g
)
func AddPrinters(c *gin.Context, tokenInfo *model.TokenInfo, appID int, printInfos []*model.PrintInfo) (err error) {
var (
db = globals.GetDB()
errs []error
now = time.Now()
)
if len(printInfos) > 50 {
return fmt.Errorf("每次最多添加50台！")
}
if apps, _ := dao.GetApps(db, appID, tokenInfo.User.UserID, ""); len(apps) == 0 {
return fmt.Errorf("未查询到此应用！app_id:%d", appID)
}
for _, v := range printInfos {
if v.PrintNo == "" {
errs = append(errs, fmt.Errorf("请输入正确的打印机编号！print_no :%s 。", v.PrintNo))
continue
}
printers, _ := dao.GetPrinters(db, appID, v.PrintNo, 0, 0, 0)
if len(printers) > 0 {
errs = append(errs, fmt.Errorf("此打印机已被其他应用绑定！print_no :%s 。", v.PrintNo))
continue
}
printer := &model.Printer{
CreatedAt: &now,
UpdatedAt: &now,
DeletedAt: &utils.DefaultTimeValue,
LastOperator: tokenInfo.User.Name,
AppID: appID,
PrintNo: v.PrintNo,
Name: v.Name,
//SIM: v.SIM,
Status: model.PrinterStatusNormal,
IsOnline: model.PrinterOffline,
Sound: sounda,
Volume: 4,
}
if err = dao.Insert(db, printer); err != nil {
errs = append(errs, err)
}
}
if len(errs) > 0 {
err = putils.BuildErr(errs)
}
return err
}
func GetPrinters(c *gin.Context, appID int, printNo, name string, status, isOnline, offset, pageSize int) (page *model.PagedInfo, err error) {
return dao.GetPrintersPage(globals.GetDB(), appID, printNo, name, status, isOnline, offset, pageSize)
}
func DelPrinters(c *gin.Context, appID int, tokenInfo *model.TokenInfo, printNos []string) (err error) {
var (
db = globals.GetDB()
errs []error
now = time.Now()
)
if len(printNos) > 50 {
return fmt.Errorf("每次最多删除50台！")
}
if apps, _ := dao.GetApps(db, appID, tokenInfo.User.UserID, ""); len(apps) == 0 {
return fmt.Errorf("未查询到此应用！app_id:%d", appID)
}
for _, v := range printNos {
if v == "" {
errs = append(errs, fmt.Errorf("请输入正确的打印机编号！print_no :%s 。", v))
continue
}
printers, _ := dao.GetPrinters(db, appID, v, 0, 0, 0)
if len(printers) == 0 {
errs = append(errs, fmt.Errorf("未在该应用下查到此打印机！app_id: %d, print_no: %s", appID, v))
continue
}
printer := printers[0]
printer.DeletedAt = &now
printer.LastOperator = tokenInfo.User.Name
if err = dao.Update(db, printer, model.FieldLastOperator, model.FieldDeletedAt); err != nil {
errs = append(errs, err)
}
}
if len(errs) > 0 {
err = putils.BuildErr(errs)
}
return err
}
func UpdatePrinter(c *gin.Context, appID int, tokenInfo *model.TokenInfo, printNo, name, sound string, volume int) (err error) {
var (
db = globals.GetDB()
now = time.Now()
fields []string
)
if apps, _ := dao.GetApps(db, appID, tokenInfo.User.UserID, ""); len(apps) == 0 {
return fmt.Errorf("未查询到此应用！app_id:%d", appID)
}
printers, _ := dao.GetPrinters(db, appID, printNo, 0, 0, 0)
if len(printers) == 0 {
return fmt.Errorf("未在该应用下查到此打印机！app_id: %d, print_no: %s", appID, printNo)
}
printer := printers[0]
printer.UpdatedAt = &now
printer.LastOperator = tokenInfo.User.Name
fields = append(fields, model.FieldUpdatedAt, model.FieldLastOperator)
if name != printer.Name {
printer.Name = name
fields = append(fields, "name")
}
//if sim != printer.IccID {
// printer.IccID = sim
// fields = append(fields, "iccid")
//}
if sound != printer.Sound {
printer.Sound = sound
fields = append(fields, "sound")
}
if volume != printer.Volume {
printer.Volume = volume
fields = append(fields, "volume")
}
if err = dao.Update(db, printer, fields...); err != nil {
return err
}
return err
}
func TestPrint(c *gin.Context, appID int, tokenInfo *model.TokenInfo, printNo string, orderNo int, content string) (msgID string, err error) {
var (
db = globals.GetDB()
now = time.Now()
)
msgID = now.Format("20060102150405") + "_" + putils.RandStringBytesWithNumber(8)
if apps, _ := dao.GetApps(db, appID, tokenInfo.User.UserID, ""); len(apps) == 0 {
return "", fmt.Errorf("未查询到此应用！app_id:%d", appID)
}
printers, _ := dao.GetPrinters(db, appID, printNo, 0, 0, 0)
if len(printers) == 0 {
return "", fmt.Errorf("未在该应用下查到此打印机！app_id: %d, print_no: %s", appID, printNo)
}
printMsg := &model.PrintMsg{
CreatedAt: &now,
UpdatedAt: &now,
LastOperator: tokenInfo.User.Name,
DeletedAt: &utils.DefaultTimeValue,
PrintNo: printNo,
OrderNo: orderNo,
Content: content,
MsgID: msgID,
}
err = dao.Insert(db, printMsg)
return msgID, err
}
func GetPrintMessages(c *gin.Context, appID int, tokenInfo *model.TokenInfo, printNo, msgID string, beginAt, endAt string, offset, pageSize int) (page *model.PagedInfo, err error) {
var (
db = globals.GetDB()
)
if apps, _ := dao.GetApps(db, appID, tokenInfo.User.UserID, ""); len(apps) == 0 {
return nil, fmt.Errorf("未查询到此应用！app_id:%d", appID)
}
printers, _ := dao.GetPrinters(db, appID, printNo, 0, 0, 0)
if len(printers) == 0 {
return nil, fmt.Errorf("未在该应用下查到此打印机！app_id: %d, print_no: %s", appID, printNo)
}
return dao.GetPrintMessagesPage(db, printNo, msgID, beginAt, endAt, offset, pageSize)
}
type GetPrinterReportResult struct {
WeekPrintCount int `json:"week_print_count"`
DayPrintCount int `json:"day_print_count"`
DayUnPrintCount int `json:"day_un_print_count"`
OnlinePrinterCount int `json:"online_printer_count"`
OfflinePrinterCount int `json:"offline_printer_count"`
FlowPrinterCount int `json:"flow_printer_count"`
PaperPrinterCount int `json:"paper_printer_count"`
}
func GetPrinterReport(c *gin.Context, tokenInfo *model.TokenInfo) (getPrinterReportResult *GetPrinterReportResult, err error) {
var (
db = globals.GetDB()
weekCount, DayCount, DayUnCount = 0, 0, 0
onlineC, offlineC, flowC, paperC = 0, 0, 0, 0
)
getPrinterReportResult = &GetPrinterReportResult{}
apps, _ := dao.GetApps(db, 0, tokenInfo.User.UserID, "")
if len(apps) == 0 {
return nil, err
}
for _, app := range apps {
printers, _ := dao.GetPrinters(db, app.ID, "", 0, 0, 0)
for _, printer := range printers {
weeks, _ := dao.GetPrintMessages(db, printer.PrintNo, "", utils.Time2Str(time.Now().AddDate(0, 0, -7)), utils.Time2Str(time.Now()), 0)
weekCount += len(weeks)
days, _ := dao.GetPrintMessages(db, printer.PrintNo, "", utils.Time2Str(time.Now().AddDate(0, 0, -1)), utils.Time2Str(time.Now()), 0)
DayCount += len(days)
dayUns, _ := dao.GetPrintMessages(db, printer.PrintNo, "", utils.Time2Str(time.Now().AddDate(0, 0, -1)), utils.Time2Str(time.Now()), 1)
DayUnCount += len(dayUns)
}
onlines, _ := dao.GetPrinters(db, app.ID, "", model.PrinterOnline, 0, 0)
onlineC += len(onlines)
offlines, _ := dao.GetPrinters(db, app.ID, "", model.PrinterOffline, 0, 0)
offlineC += len(offlines)
flows, _ := dao.GetPrinters(db, app.ID, "", 0, 0, 1)
flowC += len(flows)
papers, _ := dao.GetPrinters(db, app.ID, "", model.PrinterStatusWithouPaper, 0, 0)
paperC += len(papers)
}
getPrinterReportResult.WeekPrintCount = weekCount
getPrinterReportResult.DayPrintCount = DayCount
getPrinterReportResult.DayUnPrintCount = DayUnCount
getPrinterReportResult.OnlinePrinterCount = onlineC
getPrinterReportResult.OfflinePrinterCount = offlineC
getPrinterReportResult.FlowPrinterCount = flowC
getPrinterReportResult.PaperPrinterCount = paperC
return getPrinterReportResult, err
}

164
services/print_server/sim.go Normal file
View File

@@ -0,0 +1,164 @@
package print_server
import (
"fmt"
"git.rosy.net.cn/baseapi/platformapi/tibiotapi"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-print/dao"
"git.rosy.net.cn/jx-print/globals"
"git.rosy.net.cn/jx-print/model"
putils "git.rosy.net.cn/jx-print/putils"
"git.rosy.net.cn/jx-print/services/api"
"github.com/jmoiron/sqlx"
"time"
)
//每日流量卡流量结算
func SimFlowDaySettle() (err error) {
var (
db = globals.GetDB()
now = time.Now()
monthBegin = utils.Str2Time(now.Format("2006-01") + "-01 00:00:00")
monthEnd = utils.Str2Time(monthBegin.AddDate(0, 1, 0).AddDate(0, 0, -1).Format("2006-01-02") + " 23:59:59")
)
globals.SugarLogger.Debugf("SimFlowDaySettle Begin monthBegin %v, monthEnd %v", monthBegin, monthEnd)
//月末好像不用算超不超了
if now.Month().String() != now.AddDate(0, 0, -1).Month().String() {
return
}
//找出所有状态不为 超流量的打印机（iccid卡）
printers, _ := dao.GetPrinters(db, 0, "", 0, 0, 0)
for _, v := range printers {
//查询前一日使用的流量数
if v.IccID != "" {
flowExpend := &model.SimFlowExpend{
IccID: v.IccID,
CreatedAt: &now,
UpdatedAt: &now,
LastOperator: "jxadmin",
}
var (
getCardInfoResult *tibiotapi.IotDataResult
getCardInfoResultMonth *tibiotapi.IotDataMonthResult
)
if getCardInfoResult, err = api.TibiotAPI.IotData(v.IccID, now.AddDate(0, 0, -1).Format("2006-01-02")); err == nil {
//表示还没有同步前一天的流量，只能自己算了
if getCardInfoResult == nil || getCardInfoResult.SyncStatus == "1" || getCardInfoResult.CardFlow == "0KB" || getCardInfoResult.CardFlow == "" { //未同步
//先查当月用的总的, 减去当月已经用的总的，就是昨天用的
if getCardInfoResultMonth, err = api.TibiotAPI.IotDataMonth(v.IccID); err == nil {
//表示当月用的总的也还没同步。只有去查卡信息中的总流量使用，减去所有总使用，就是昨天用的。。太折磨了先不写
if getCardInfoResultMonth == nil || getCardInfoResultMonth.CardFlow == "" || getCardInfoResultMonth.CardFlow == "0KB" {
//api.TibiotAPI.BatchQueryCardInfo(1)
} else {
if sumExpend, err := dao.GetSimFlowExpendSum(db, v.IccID, monthBegin, monthEnd); err == nil {
cardFlow := putils.Flow2KB(putils.SplitFlowAndUnit(getCardInfoResultMonth.CardFlow))
flowExpend.Flow, flowExpend.FlowUnit = putils.FlowKB2Other(cardFlow - sumExpend.Flow)
}
}
}
} else {
flowExpend.Flow, flowExpend.FlowUnit = putils.SplitFlowAndUnit(getCardInfoResult.CardFlow)
}
}
//可能有精度误差
if flowExpend.Flow > 0.1 && flowExpend.FlowUnit != "" {
err = dao.Insert(db, flowExpend)
}
//算是否超了一个月的流量了
//一个月总的收入流量 - 一个月总的支出流量 <= 0
sumIncome, _ := dao.GetSimFlowIncomeSum(db, v.IccID, monthBegin, monthEnd)
sumExpend, _ := dao.GetSimFlowExpendSum(db, v.IccID, monthBegin, monthEnd)
if sumIncome != nil && sumExpend != nil {
if sumIncome.Flow-sumExpend.Flow <= 0 {
v.FlowFlag = 1
} else {
v.FlowFlag = 0
}
err = dao.Update(db, v, "flow_flag")
}
}
}
return err
}
//每月流量卡流量划转
func SimFlowMonthSettle() {
var (
db = globals.GetDB()
)
//..每月1号划转
if time.Now().Day() != 1 {
return
}
//找出所有有iccid 卡的
printers, _ := dao.GetPrinters(db, 0, "", 0, 0, 0)
for _, v := range printers {
if v.IccID != "" {
if err := FlowIncome(db, v.IccID, 30, "MB", model.FlowIncomeTypeJX, ""); err == nil {
//划转后，每个月月初打印机都应该是不缺流量的状态
v.FlowFlag = 0
dao.Update(db, v, "flow_flag")
}
}
}
}
func FlowIncome(db *sqlx.DB, iccID string, flow float64, unit string, incomeType int, orderID string) (err error) {
var (
now = time.Now()
)
flowIncome := &model.SimFlowIncome{
IccID: iccID,
CreatedAt: &now,
UpdatedAt: &now,
LastOperator: "jxadmin",
Flow: flow,
FlowUnit: unit,
IncomeType: incomeType,
OrderID: orderID,
}
err = dao.Insert(db, flowIncome)
return err
}
func GetCardsInfo(tokenInfo *model.TokenInfo, appID int, printNo string, cardStatus int, iccID, beginDate, endDate string, offset, pagiSize int) (cardInfo *tibiotapi.BatchQueryCardInfoResult, err error) {
var (
db = globals.GetDB()
)
if printNo != "" {
printers, _ := dao.GetPrinters(db, appID, printNo, 0, 0, 0)
if len(printers) == 0 {
err = fmt.Errorf("未在该应用下查到此打印机！app_id: %d, print_no: %s", appID, printNo)
return nil, err
} else {
iccID = printers[0].IccID
}
}
if beginDate != "" {
beginDate = beginDate[:10]
}
if endDate != "" {
endDate = endDate[:10]
}
if cardInfo, err = api.TibiotAPI.BatchQueryCardInfo(&tibiotapi.BatchQueryCardInfoParam{
CardStatus: cardStatus,
IccID: iccID,
BeginPackageTime: beginDate,
EndPackageTime: endDate,
PageNum: offset,
PageSize: pagiSize,
}); err == nil && cardInfo != nil {
for _, v := range cardInfo.Records {
if printer, err2 := dao.GetPrinter(db, "", v.Iccid); err2 == nil && printer != nil {
v.PrintNo = printer.PrintNo
v.Name = printer.Name
}
}
}
return cardInfo, err
}
func GetChargeInfo(tokenInfo *model.TokenInfo, appID int, printNo string, iccID, beginDate, endDate string, offset, pageSize int) (paged *model.PagedInfo, err error) {
return dao.GetChargeInfo(globals.GetDB(), appID, printNo, iccID, beginDate, endDate, offset, pageSize)
}

147
services/print_server/user.go Normal file
View File

@@ -0,0 +1,147 @@
package print_server
import (
"crypto/md5"
"encoding/json"
"fmt"
"git.rosy.net.cn/baseapi/utils"
"git.rosy.net.cn/jx-print/dao"
"git.rosy.net.cn/jx-print/globals"
"git.rosy.net.cn/jx-print/model"
putils "git.rosy.net.cn/jx-print/putils"
"github.com/gin-gonic/gin"
"github.com/jmoiron/sqlx"
"strings"
"time"
)
const (
TokenHeader = "TOKEN"
TokenVer = "V2"
TokenTypeSep = "."
)
type UserService struct {
C *gin.Context
DB *sqlx.DB
}
type UserServiceInterface interface {
Login(name, password string) (loginResult *LoginResult, err error)
RegisterUser(c *gin.Context, name, password string) (err error)
}
var (
UserServiceHandler UserServiceInterface
)
func InitHandler(handler UserServiceInterface) {
UserServiceHandler = handler
}
func (c *UserService) GetUsers(name, mobile, userID string) (users []*model.User, err error) {
return dao.GetUsers(globals.GetDB(), userID, name, mobile)
}
func RegisterUser(c *gin.Context, name, password string) (err error) {
var (
db = globals.GetDB()
user = &model.User{}
now = time.Now()
)
if users, _ := dao.GetUsers(db, "", name, ""); len(users) > 0 {
return fmt.Errorf("用户名重复！")
}
user.UserID = utils.GetUUID()
user.Name = name
user.Password = fmt.Sprintf("%x", md5.Sum([]byte(model.RegisterKey+password)))
user.CreatedAt = &now
user.UpdatedAt = &now
user.DeletedAt = &utils.DefaultTimeValue
err = dao.Insert(db, user)
return err
}
type LoginResult struct {
model.User
Token string `json:"token"` //token
}
func Login(c *gin.Context, name, password string) (loginResult *LoginResult, err error) {
var (
db = globals.GetDB()
now = time.Now()
user = &model.User{}
token string
)
loginResult = &LoginResult{}
if users, _ := dao.GetUsers(db, "", name, ""); len(users) == 0 {
return loginResult, fmt.Errorf("用户名不存在！")
}
if users, err := dao.GetUserForLogin(db, name, fmt.Sprintf("%x", md5.Sum([]byte(model.RegisterKey+password)))); err != nil {
return loginResult, err
} else if len(users) == 0 {
return loginResult, fmt.Errorf("密码错误或用户不存在！")
} else {
user = users[0]
}
loginResult.User = *user
//创建token
token, err = setToken(user)
loginResult.Token = token
//更新登录时间和ip
user.LastLoginAt = &now
user.LastLoginIP = c.ClientIP()
err = dao.Update(db, user, "last_login_at", "last_login_ip")
return loginResult, err
}
func setToken(user *model.User) (token string, err error) {
token = createToken(user)
err = putils.SetKey(token, user, putils.DefTokenDuration)
return token, err
}
func createToken(user *model.User) (token string) {
return strings.Join([]string{
TokenHeader,
TokenVer,
user.UserID,
time.Now().Format("20060102-150405"),
utils.GetUUID(),
user.Name,
}, TokenTypeSep)
}
func Logout(c *gin.Context, token string) (err error) {
return putils.DelKey(token)
}
func UpdateUser(c *gin.Context, payload string) (err error) {
var (
db = globals.GetDB()
userp = &model.User{}
user = &model.User{}
)
if err = json.Unmarshal([]byte(payload), &userp); err != nil {
return err
}
if userp.ID == 0 || userp.UserID == "" {
return fmt.Errorf("id 和 user_id 必传！")
}
if users, err := dao.GetUsers(db, userp.UserID, "", ""); err != nil {
return err
} else {
user = users[0]
}
err = dao.UpdateDiff(db, userp, user)
return err
}
func GetMenus(c *gin.Context) (menus []*model.Menu, err error) {
return dao.GetMenus(globals.GetDB())
}
func GetMenuDetail(c *gin.Context, id int) (menu *model.MenuDetail, err error) {
return dao.GetMenuDetail(globals.GetDB(), id)
}