fusen/fusenapi
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'develop' of https://gitee.com/fusenpack/fusenapi into develop

Browse Source
This commit is contained in:
eson 2023-06-16 19:00:18 +08:00
commit 87c9246c34
52 changed files with 878 additions and 827 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
constants/delivery.go Normal file
View File

@ -0,0 +1,7 @@
package constants
// 发货到地址方式
const DELIVERY_METHOD_ADDRESS = 1
// 发货到云仓方式
const DELIVERY_METHOD_CLOUD = 2

69
constants/order.go Normal file
View File

@ -0,0 +1,69 @@
package constants
// 新版订单状态-后台所有
// 未支付
const STATUS_NEW_NOT_PAY = 0
// 首款已付，尾款待付
const STATUS_NEW_PART_PAY = 1
// 全款已付
const STATUS_NEW_PAY_COMPLETED = 2
// 订单已确认
const STATUS_NEW_SURE = 3
// 订单生产中
const STATUS_NEW_PRODUTING = 4
// 订单生产完成
const STATUS_NEW_PRODUT_COMPLETED = 5
// 订单已到库
const STATUS_NEW_ARRIVAL = 6
// 已发货
const STATUS_NEW_DELIVER = 7
// UPS提货
const STATUS_NEW_UPS = 8
// 已完成
const STATUS_NEW_COMPLETED = 9
// 取消订单
const STATUS_NEW_CANCEL = 10
// 退款中
const STATUS_NEW_REFUNDING = 11
// 退款完成
const STATUS_NEW_REFUNDED = 12
// 订单删除
const STATUS_NEW_DELETE = 13
// 订单关闭
const STATUS_NEW_CLOSE = 14
// 前台订单
// 已支付
const STATUS_FONT_PAID = 1
// 生产中
const STATUS_FONT_PRODUCTION = 2
// 运输中
const STATUS_FONT_SHIPPED = 3
// 到达云仓
const STATUS_FONT_INVENTORY = 4
// 订单完成
const STATUS_FONT_COMPLETED = 5
// 订单关闭
const STATUS_FONT_CLOSED = 7
// 云仓完成
const STATUS_FONT_COMPLETED_CLOUD = 8

2
initalize/mysql.go
View File

@ -10,7 +10,7 @@ import (
// SourceMysql: fusentest:XErSYmLELKMnf3Dh@tcp(110.41.19.98:3306)/fusentest
// 初始化mysql
func InitMysql(sourceMysql string) *gorm.DB {
dsn := sourceMysql + "?" + "charset=utf8mb4&parseTime=true"
dsn := sourceMysql + "?charset=utf8mb4&parseTime=true"
db, err := gorm.Open(mysql.New(mysql.Config{
DSN: dsn, // DSN data source name
DefaultStringSize: 255, // string 类型字段的默认长度

23
model/gmodel/fs_address_logic.go Executable file
View File

@ -0,0 +1,23 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
func (a *FsAddressModel) GetOne(ctx context.Context, id int64, userId int64) (resp FsAddress, err error) {
err = a.db.WithContext(ctx).Model(&FsAddress{}).Where("`id` = ? and `user_id` = ? and `status` = ? ", id, userId, 1).First(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsAddress{}, err
}
return resp, nil
}
func (a *FsAddressModel) GetUserAllAddress(ctx context.Context, userId int64) (resp []FsAddress, err error) {
err = a.db.WithContext(ctx).Model(&FsAddress{}).Where("`user_id` = ? and `status` = ?", userId, 1).Order("`id` DESC").Find(&resp).Error
if err != nil {
return nil, err
}
return
}

20
model/gmodel/fscanteenproductmodel.go → model/gmodel/fs_canteen_product_logic.go
View File

@ -2,28 +2,8 @@ package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsCanteenProduct struct {
Id int64 `gorm:"primary_key" json:"id"` // ID
CanteenType *int64 `gorm:"default:0" json:"canteen_type"` // 餐厅类别id
ProductId *int64 `gorm:"default:0" json:"product_id"` // 产品id
SizeId *int64 `gorm:"default:0" json:"size_id"` // 尺寸id
Sort *int64 `gorm:"default:0" json:"sort"` // 排序
Status *int64 `gorm:"default:1" json:"status"` // 状态位 1启用0停用
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
Sid *string `gorm:"default:''" json:"sid"` // 前端带入的id
}
type FsCanteenProductModel struct {
db *gorm.DB
}
func NewFsCanteenProductModel(db *gorm.DB) *FsCanteenProductModel {
return &FsCanteenProductModel{db}
}
func (c *FsCanteenProductModel) GetAllByCanteenTypeId(ctx context.Context, typeId int64) (resp []FsCanteenProduct, err error) {
err = c.db.WithContext(ctx).Model(&FsCanteenProduct{}).Where("`canteen_type` = ? and `status` = ?", typeId, 1).Find(&resp).Error
if err != nil {

16
model/gmodel/fs_canteen_type_gen.go
View File

@ -1,16 +0,0 @@
package gmodel
import (
"gorm.io/gorm"
)
type FsCanteenType struct {
Id int64 `gorm:"primary_key" json:"id"` // ID
Name *string `gorm:"" json:"name"` // 餐厅名字
Sort *int64 `gorm:"" json:"sort"` // 排序
Status *int64 `gorm:"" json:"status"` // 状态位 1启用0停用
Ctime *int64 `gorm:"" json:"ctime"` // 添加时间
}
type FsCanteenTypeModel struct{ db *gorm.DB }
func NewFsCanteenTypeModel(db *gorm.DB) *FsCanteenTypeModel { return &FsCanteenTypeModel{db} }

9
model/gmodel/fs_canteen_type_logic.go
View File

@ -15,8 +15,15 @@ type FsGetTypeCanteenType struct {
// TODO: 使用model的属性做你想做的
func (c *FsCanteenTypeModel) FindAllGetType(ctx context.Context, id int64) (resp []*FsGetTypeCanteenType, err error) {
func (c *FsCanteenTypeModel) FindAllGetType(ctx context.Context) (resp []*FsGetTypeCanteenType, err error) {
err = c.db.WithContext(ctx).Model(&FsCanteenType{}).Select("id,name").Order("sort desc").Where("`status` = ?", 1).Find(&resp).Error
if err != nil {
return resp, err
}
return resp, nil
}
func (c *FsCanteenTypeModel) FindOne(ctx context.Context, id int64) (resp FsCanteenType, err error) {
err = c.db.WithContext(ctx).Model(&FsCanteenType{}).Where("`id` = ?", id).First(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return resp, err
}

4
model/gmodel/fscartmodel.go → model/gmodel/fs_cart_logic.go
View File

@ -6,9 +6,9 @@ import (
"context"
"errors"
"gorm.io/gorm"
"time"
)
<<<<<<< HEAD:model/gmodel/fscartmodel.go
type FsCart struct {
Id int64 `gorm:"primary_key" json:"id"` // id
UserId *int64 `gorm:"default:0" json:"user_id"` // 用户ID
@ -35,6 +35,8 @@ func NewFsCartModel(db *gorm.DB) *FsCartModel {
return &FsCartModel{db}
}
=======
>>>>>>> c6292a97dd29b5dc14f96ed71adc82e9ead8ef28:model/gmodel/fs_cart_logic.go
type FindOneCartByParamsReq struct {
UserId *int64
ProductId *int64

16
model/gmodel/fs_font_gen.go
View File

@ -1,16 +0,0 @@
package gmodel
import (
"gorm.io/gorm"
)
type FsFont struct {
Id int64 `gorm:"primary_key" json:"id"` // id
Title *string `gorm:"" json:"title"` // 字体名字
LinuxFontname *string `gorm:"" json:"linux_fontname"` // linux对应字体名
FilePath *string `gorm:"" json:"file_path"` // 字体文件路径
Sort *int64 `gorm:"" json:"sort"` // 排序
}
type FsFontModel struct{ db *gorm.DB }
func NewFsFontModel(db *gorm.DB) *FsFontModel { return &FsFontModel{db} }

11
model/gmodel/fs_map_library_logic.go Executable file
View File

@ -0,0 +1,11 @@
package gmodel
import "context"
func (ml *FsMapLibraryModel) GetAllEnabledList(ctx context.Context) (resp []FsMapLibrary, err error) {
err = ml.db.WithContext(ctx).Model(&FsMapLibrary{}).Where("`status` = ?", 0).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

13
model/gmodel/fs_order_detail_logic.go Executable file
View File

@ -0,0 +1,13 @@
package gmodel
import (
"context"
)
func (od *FsOrderDetailModel) GetOrderDetailsByOrderId(ctx context.Context, orderId int64) (resp []FsOrderDetail, err error) {
err = od.db.WithContext(ctx).Model(&FsOrderDetail{}).Where("`order_id` = ?", orderId).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

16
model/gmodel/fs_order_detail_template_logic.go Executable file
View File

@ -0,0 +1,16 @@
package gmodel
import (
"context"
)
func (dt *FsOrderDetailTemplateModel) GetListByIds(ctx context.Context, ids []int64) (resp []FsOrderDetailTemplate, err error) {
if len(ids) == 0 {
return
}
err = dt.db.WithContext(ctx).Model(&FsOrderDetailTemplate{}).Where("`id` in (?)", ids).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

18
model/gmodel/fs_order_logic.go Executable file
View File

@ -0,0 +1,18 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
func (o *FsOrderModel) FindOneBySn(ctx context.Context, userId int64, sn string) (resp FsOrder, err error) {
err = o.db.WithContext(ctx).Model(&FsOrder{}).Where(" `user_id` = ? and `sn` = ? ", userId, sn).First(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsOrder{}, err
}
return resp, nil
}
func (o *FsOrderModel) Update(ctx context.Context, id int64, data FsOrder) error {
return o.db.WithContext(ctx).Model(&FsOrder{}).Where("`id` = ?", id).Updates(data).Error
}

26
model/gmodel/fs_pay_gen.go
View File

@ -1,26 +0,0 @@
package gmodel
import (
"gorm.io/gorm"
)
type FsPay struct {
Id int64 `gorm:"primary_key" json:"id"` //
UserId *int64 `gorm:"" json:"user_id"` // 用户id
OrderNumber *string `gorm:"" json:"order_number"` // 订单编号
TradeNo *string `gorm:"" json:"trade_no"` // 第三方支付编号
PayAmount *int64 `gorm:"" json:"pay_amount"` // 支付金额 (分)
PayStatus *int64 `gorm:"" json:"pay_status"` // 支付状态 0 不成功 1 成功
IsRefund *int64 `gorm:"" json:"is_refund"` // 是否退款 0 未退款 1退款
PaymentMethod *int64 `gorm:"" json:"payment_method"` // 支付方式 1 stripe 2 paypal
PayStage *int64 `gorm:"" json:"pay_stage"` // 支付阶段 1首付 2尾款
OrderSource *int64 `gorm:"" json:"order_source"` // 订单来源 1pc
PayTime *int64 `gorm:"" json:"pay_time"` // 支付时间
CreatedAt *int64 `gorm:"" json:"created_at"` // 创建时间
UpdatedAt *int64 `gorm:"" json:"updated_at"` // 更新时间
CardNo *string `gorm:"" json:"card_no"` // 卡后4位
Brand *string `gorm:"" json:"brand"` // 银行品牌
}
type FsPayModel struct{ db *gorm.DB }
func NewFsPayModel(db *gorm.DB) *FsPayModel { return &FsPayModel{db} }

7
model/gmodel/fs_pay_logic.go
View File

@ -9,3 +9,10 @@ func (p *FsPayModel) GetListByOrderNumber(ctx context.Context, sn string) (resp
}
return resp, nil
}
func (p *FsPayModel) GetOrderPayList(ctx context.Context, sn string, payStatus int64, isRefund int64) (resp []FsPay, err error) {
err = p.db.WithContext(ctx).Model(&FsPay{}).Where("`order_number` = ? and `pay_status` = ? and `is_refund` = ?", sn, payStatus, isRefund).Find(&resp).Error
if err != nil {
return nil, err
}
return resp, nil
}

25
model/gmodel/fs_product_design_logic.go Executable file
View File

@ -0,0 +1,25 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
func (d *FsProductDesignModel) FindOneBySn(ctx context.Context, sn string) (resp FsProductDesign, err error) {
err = d.db.WithContext(ctx).Model(&FsProductDesign{}).Where("`sn` = ? and `status` = ?", sn, 1).First(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsProductDesign{}, err
}
return resp, nil
}
func (d *FsProductDesignModel) GetAllByIds(ctx context.Context, ids []int64) (resp []FsProductDesign, err error) {
if len(ids) == 0 {
return
}
err = d.db.WithContext(ctx).Model(&FsProductDesign{}).Where("`id` in (?) and `status` = ?", ids, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

47
model/gmodel/fs_product_logic.go Executable file
View File

@ -0,0 +1,47 @@
package gmodel
import "context"
func (p *FsProductModel) GetProductListByIds(ctx context.Context, productIds []int64, sort string) (resp []FsProduct, err error) {
if len(productIds) == 0 {
return
}
db := p.db.Model(&FsProduct{}).
Where("`id` in (?) and `is_del` =? and `is_shelf` = ? and `status` =?", productIds, 0, 1, 1)
switch sort {
case "sort-asc":
db = db.Order("`sort` ASC")
case "sort-desc":
db = db.Order("`sort` DESC")
}
if err = db.Find(&resp).Error; err != nil {
return nil, err
}
return
}
func (p *FsProductModel) GetProductListByTypeIds(ctx context.Context, productTypes []int64, sort string) (resp []FsProduct, err error) {
if len(productTypes) == 0 {
return
}
db := p.db.WithContext(ctx).Model(&FsProduct{}).Where("`type` in (?) and `is_del` =? and `is_shelf` = ? and `status` =?", productTypes, 0, 1, 1)
switch sort {
case "sort-asc":
db = db.Order("`sort` ASC")
case "sort-desc":
db = db.Order("`sort` DESC")
}
err = db.Find(&resp).Error
if err != nil {
return nil, err
}
return
}
func (p *FsProductModel) GetRandomProductList(ctx context.Context, limit int) (resp []FsProduct, err error) {
err = p.db.WithContext(ctx).Model(&FsProduct{}).
Where("`is_del` =? and `is_shelf` = ?", 0, 1).Order("RAND()").Limit(limit).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

1
model/gmodel/fs_product_model3d_light_logic.go Executable file
View File

@ -0,0 +1 @@
package gmodel

26
model/gmodel/fs_product_model3d_logic.go Executable file
View File

@ -0,0 +1,26 @@
package gmodel
import (
"context"
)
func (d *FsProductModel3dModel) GetAllByIds(ctx context.Context, ids []int64) (resp []FsProductModel3d, err error) {
if len(ids) == 0 {
return
}
err = d.db.WithContext(ctx).Model(&FsProductModel3d{}).Where("`id` in (?) and `status` = ?", ids, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}
func (d *FsProductModel3dModel) GetAllByIdsTag(ctx context.Context, ids []int64, tag int64) (resp []FsProductModel3d, err error) {
if len(ids) == 0 {
return
}
err = d.db.WithContext(ctx).Model(&FsProductModel3d{}).Where("`id` in (?) and `status` = ? and `tag` = ?", ids, 1, tag).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

23
model/gmodel/fsproductpricemodel.go → model/gmodel/fs_product_price_logic.go
View File

@ -7,29 +7,6 @@ import (
"gorm.io/gorm"
)
type FsProductPrice struct {
Id int64 `gorm:"primary_key" json:"id"`
Sn *string `gorm:"default:''" json:"sn"` // 唯一编码
Title *string `gorm:"default:''" json:"title"` // 标题描述
ProductId *int64 `gorm:"default:0" json:"product_id"` // 产品ID
MaterialId *int64 `gorm:"default:0" json:"material_id"` // 材质ID
SizeId *int64 `gorm:"default:0" json:"size_id"` // 尺寸ID
EachBoxNum *int64 `gorm:"default:0" json:"each_box_num"` // 每一箱的个数
EachBoxWeight *float64 `gorm:"default:0" json:"each_box_weight"` // 每一箱的重量 单位KG
MinBuyNum *int64 `gorm:"default:0" json:"min_buy_num"` // 最少购买量
StepNum *string `gorm:"default:''" json:"step_num"` // 数量阶梯 eg:10,20,30
StepPrice *string `gorm:"default:''" json:"step_price"` // 价格阶梯 eg:100,50,25
Status *int64 `gorm:"default:1" json:"status"` // 是否可用
IsDefault *int64 `gorm:"default:0" json:"is_default"` // 是否默认
}
type FsProductPriceModel struct {
db *gorm.DB
}
func NewFsProductPriceModel(db *gorm.DB) *FsProductPriceModel {
return &FsProductPriceModel{db}
}
type GetPriceListByProductIdsRsp struct {
ProductId int64 `json:"product_id"`
Price string `json:"price"`

21
model/gmodel/fsproductsizemodel.go → model/gmodel/fs_product_size_logic.go
View File

@ -2,29 +2,8 @@ package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsProductSize struct {
Id int64 `gorm:"primary_key" json:"id"`
ProductId *int64 `gorm:"default:0" json:"product_id"` // 产品ID
Title *string `gorm:"default:''" json:"title"` // 标题 10*10*20
Cover *string `gorm:"default:''" json:"cover"` // 封面图
CoverImg *string `gorm:"default:''" json:"cover_img"` // 背景图
Capacity *string `gorm:"default:''" json:"capacity"` // 自己填的尺寸名称
Status *int64 `gorm:"default:1" json:"status"` // 状态位 1显示 0删除
Sort *int64 `gorm:"default:50" json:"sort"` // 排序
Remark *string `gorm:"default:''" json:"remark"` // 备注信息
PartsCanDeleted *int64 `gorm:"default:1" json:"parts_can_deleted"` // 配件是否可移除 1是0否
}
type FsProductSizeModel struct {
db *gorm.DB
}
func NewFsProductSizeModel(db *gorm.DB) *FsProductSizeModel {
return &FsProductSizeModel{db}
}
func (s *FsProductSizeModel) GetAllByIds(ctx context.Context, ids []int64, sort string) (resp []FsProductSize, err error) {
if len(ids) == 0 {
return

16
model/gmodel/fs_product_template_tags_logic.go Executable file
View File

@ -0,0 +1,16 @@
package gmodel
import (
"context"
)
func (pt *FsProductTemplateTagsModel) GetListByIds(ctx context.Context, ids []int64) (resp []FsProductTemplateTags, err error) {
if len(ids) == 0 {
return
}
err = pt.db.WithContext(ctx).Model(&FsProductTemplateTags{}).Where("`id` in (?)", ids).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

16
model/gmodel/fs_product_template_v2_logic.go Executable file
View File

@ -0,0 +1,16 @@
package gmodel
import (
"context"
)
func (t *FsProductTemplateV2Model) FindAllByProductIds(ctx context.Context, productIds []int64) (resp []FsProductTemplateV2, err error) {
if len(productIds) == 0 {
return
}
err = t.db.WithContext(ctx).Model(&FsProductTemplateV2{}).Where("`id` in (?) and `is_del` = ? and `status` = ?", productIds, 0, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

22
model/gmodel/fs_qrcode_set_logic.go Executable file
View File

@ -0,0 +1,22 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
func (q *FsQrcodeSetModel) GetAll(ctx context.Context) (resp []FsQrcodeSet, err error) {
err = q.db.WithContext(ctx).Model(&FsQrcodeSet{}).Where("`status` = ?", 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}
func (q *FsQrcodeSetModel) FindOne(ctx context.Context, id int64) (resp FsQrcodeSet, err error) {
err = q.db.WithContext(ctx).Model(&FsQrcodeSet{}).Where("`id` = ?", id).First(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsQrcodeSet{}, err
}
return resp, nil
}

13
model/gmodel/fs_standard_logo_logic.go Executable file
View File

@ -0,0 +1,13 @@
package gmodel
import (
"context"
)
func (l *FsStandardLogoModel) GetAll(ctx context.Context) (resp []FsStandardLogo, err error) {
err = l.db.WithContext(ctx).Model(&FsStandardLogo{}).Where("`status` = ? ", 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

32
model/gmodel/fs_tags_logic.go Executable file
View File

@ -0,0 +1,32 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
func (t *FsTagsModel) FindOne(ctx context.Context, id int64) (resp FsTags, err error) {
err = t.db.WithContext(ctx).Model(&FsTags{}).Where("`id` = ? and `status` = ?", id, 1).First(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsTags{}, err
}
return resp, nil
}
func (t *FsTagsModel) GetAllByIds(ctx context.Context, ids []int64) (resp []FsTags, err error) {
if len(ids) == 0 {
return
}
err = t.db.WithContext(ctx).Model(&FsTags{}).Where("`id` in(?) and `status` = ?", ids, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}
func (t *FsTagsModel) GetAllByLevel(ctx context.Context, level int) (resp []FsTags, err error) {
err = t.db.Model(&FsTags{}).Where("`level` = ? and `status` = ?", level, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

37
model/gmodel/fs_user_gen.go
View File

@ -1,37 +0,0 @@
package gmodel
import (
"gorm.io/gorm"
)
type FsUser struct {
Id int64 `gorm:"primary_key" json:"id"` // ID
FaceId *int64 `gorm:"" json:"face_id"` // facebook的userid
Sub *int64 `gorm:"" json:"sub"` // google的sub
FirstName *string `gorm:"" json:"first_name"` // FirstName
LastName *string `gorm:"" json:"last_name"` // LastName
Username *string `gorm:"" json:"username"` // 用户名
Company *string `gorm:"" json:"company"` // 公司名称
Mobile *string `gorm:"" json:"mobile"` // 手机号码
AuthKey *string `gorm:"" json:"auth_key"` //
PasswordHash *string `gorm:"" json:"password_hash"` //
VerificationToken *string `gorm:"" json:"verification_token"` //
PasswordResetToken *string `gorm:"" json:"password_reset_token"` //
Email *string `gorm:"" json:"email"` // 邮箱
Type *int64 `gorm:"" json:"type"` // 1普通餐厅 2连锁餐厅
Status *int64 `gorm:"" json:"status"` // 1正常 0不正常
IsDel *int64 `gorm:"" json:"is_del"` // 是否删除 1删除
CreatedAt *int64 `gorm:"" json:"created_at"` // 添加时间
UpdatedAt *int64 `gorm:"" json:"updated_at"` // 更新时间
IsOrderStatusEmail *int64 `gorm:"" json:"is_order_status_email"` // 订单状态改变时是否接收邮件
IsEmailAdvertisement *int64 `gorm:"" json:"is_email_advertisement"` // 是否接收邮件广告
IsOrderStatusPhone *int64 `gorm:"" json:"is_order_status_phone"` // 订单状态改变是是否接收电话
IsPhoneAdvertisement *int64 `gorm:"" json:"is_phone_advertisement"` // 是否接收短信广告
IsOpenRender *int64 `gorm:"" json:"is_open_render"` // 是否打开个性化渲染（1：开启，0：关闭）
IsThousandFace *int64 `gorm:"" json:"is_thousand_face"` // 是否已经存在千人千面（1：存在，0：不存在）
IsLowRendering *int64 `gorm:"" json:"is_low_rendering"` // 是否开启低渲染模型渲染
IsRemoveBg *int64 `gorm:"" json:"is_remove_bg"` // 用户上传logo是否去除背景
}
type FsUserModel struct{ db *gorm.DB }
func NewFsUserModel(db *gorm.DB) *FsUserModel { return &FsUserModel{db} }

48
model/gmodel/fsaddressmodel.go
View File

@ -1,48 +0,0 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
type FsAddress struct {
Id int64 `gorm:"primary_key" json:"id"`
UserId *int64 `gorm:"default:0" json:"user_id"` // 用户ID
Name *string `gorm:"default:''" json:"name"` // 地址名称
FirstName *string `gorm:"default:''" json:"first_name"` // FirstName
LastName *string `gorm:"default:''" json:"last_name"` // LastName
Mobile *string `gorm:"default:''" json:"mobile"` // 手机号码
Street *string `gorm:"default:''" json:"street"` // 街道
Suite *string `gorm:"default:''" json:"suite"` // 房号
City *string `gorm:"default:''" json:"city"` // 城市
State *string `gorm:"default:''" json:"state"` // 州名
Country *string `gorm:"default:''" json:"country"` // 国家
ZipCode *string `gorm:"default:''" json:"zip_code"` // 邮编
Status *int64 `gorm:"default:1" json:"status"` // 1正常 0异常
IsDefault *int64 `gorm:"default:0" json:"is_default"` // 1默认地址，0非默认地址
}
type FsAddressModel struct {
db *gorm.DB
}
func NewFsAddressModel(db *gorm.DB) *FsAddressModel {
return &FsAddressModel{db}
}
func (a *FsAddressModel) GetOne(ctx context.Context, id int64, userId int64) (resp FsAddress, err error) {
err = a.db.WithContext(ctx).Model(&FsAddress{}).Where("`id` = ? and `user_id` = ? and `status` = ? ", id, userId, 1).Take(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsAddress{}, err
}
return resp, nil
}
func (a *FsAddressModel) GetUserAllAddress(ctx context.Context, userId int64) (resp []FsAddress, err error) {
err = a.db.WithContext(ctx).Model(&FsAddress{}).Where("`user_id` = ? and `status` = ?", userId, 1).Order("`id` DESC").Find(&resp).Error
if err != nil {
return nil, err
}
return
}

31
model/gmodel/fsmaplibrarymodel.go
View File

@ -1,31 +0,0 @@
package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsMapLibrary struct {
Id int64 `gorm:"primary_key" json:"id"` // Id
Title *string `gorm:"default:''" json:"title"` // 名称
Info *string `gorm:"default:''" json:"info"` // 贴图数据
Sort *int64 `gorm:"default:0" json:"sort"` // 排序
Status *int64 `gorm:"default:1" json:"status"` // 状态 1启用 0未启用
Ctime *int64 `gorm:"default:0" json:"ctime"` // 创建时间
TagId *int64 `gorm:"default:0" json:"tag_id"` // 模板标签id
}
type FsMapLibraryModel struct {
db *gorm.DB
}
func NewFsMapLibraryModel(db *gorm.DB) *FsMapLibraryModel {
return &FsMapLibraryModel{db}
}
func (ml *FsMapLibraryModel) GetAllEnabledList(ctx context.Context) (resp []FsMapLibrary, err error) {
err = ml.db.WithContext(ctx).Model(&FsMapLibrary{}).Where("`status` = ?", 0).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

48
model/gmodel/fsorderdetailmodel.go
View File

@ -1,48 +0,0 @@
package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsOrderDetail struct {
Id int64 `gorm:"primary_key" json:"id"`
Sn *string `gorm:"default:''" json:"sn"` // 唯一编码
OrderId *int64 `gorm:"default:0" json:"order_id"` // 订单ID
UserId *int64 `gorm:"default:0" json:"user_id"` // 用户ID
FactoryId *int64 `gorm:"default:0" json:"factory_id"` // 工厂ID
OrderDetailTemplateId *int64 `gorm:"default:0" json:"order_detail_template_id"` // 详情templateID
ProductId *int64 `gorm:"default:0" json:"product_id"` // 产品ID
BuyNum *int64 `gorm:"default:0" json:"buy_num"` // 购买数量
PushNum *int64 `gorm:"default:0" json:"push_num"` // 已发数量
Amount *int64 `gorm:"default:0" json:"amount"` // 单价
Cover *string `gorm:"default:''" json:"cover"` // 截图
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
Status *int64 `gorm:"default:0" json:"status"` // 状态位 是否推送到厂家 是否生产完成 是否发货完成
OptionalId *int64 `gorm:"default:0" json:"optional_id"` // 选项ID
OptionalTitle *string `gorm:"default:''" json:"optional_title"` // 选项名称
OptionPrice *int64 `gorm:"default:0" json:"option_price"` // 配件价格
IsTofactory *int64 `gorm:"default:0" json:"is_tofactory"` // 是否推送到工厂
IsProduct *int64 `gorm:"default:0" json:"is_product"` // 是否生产中
IsProductCompletion *int64 `gorm:"default:0" json:"is_product_completion"` // 是否生产完成
IsCloud *int64 `gorm:"default:0" json:"is_cloud"` // 是否是云仓订单
IsTocloud *int64 `gorm:"default:0" json:"is_tocloud"` // 是否已发云仓(云仓单要发货到云仓，直接发到用户的不需要发到云仓)
IsDeliver *int64 `gorm:"default:0" json:"is_deliver"` // 是否已发货
IsEnd *int64 `gorm:"default:0" json:"is_end"` // 是否完成订单(签收)
CartId *int64 `gorm:"default:0" json:"cart_id"` // 购物车编号
}
type FsOrderDetailModel struct {
db *gorm.DB
}
func NewFsOrderDetailModel(db *gorm.DB) *FsOrderDetailModel {
return &FsOrderDetailModel{db}
}
func (od *FsOrderDetailModel) GetOrderDetailsByOrderId(ctx context.Context, orderId int64) (resp []FsOrderDetail, err error) {
err = od.db.WithContext(ctx).Model(&FsOrderDetail{}).Where("`order_id` = ?", orderId).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

38
model/gmodel/fsorderdetailtemplatemodel.go
View File

@ -1,38 +0,0 @@
package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsOrderDetailTemplate struct {
Id int64 `gorm:"primary_key" json:"id"`
Sn *string `gorm:"default:''" json:"sn"` // 唯一编码
ProductId *int64 `gorm:"default:0" json:"product_id"` // 产品ID
ModelId *int64 `gorm:"default:0" json:"model_id"` // 模型ID
TemplateId *int64 `gorm:"default:0" json:"template_id"` // 模板ID
MaterialId *int64 `gorm:"default:0" json:"material_id"` // 材质id
SizeId *int64 `gorm:"default:0" json:"size_id"` // 尺寸id
EachBoxNum *int64 `gorm:"default:0" json:"each_box_num"` // 每一箱的个数
EachBoxWeight *float64 `gorm:"default:0.00" json:"each_box_weight"` // 每一箱的重量 单位KG
DesignId *int64 `gorm:"default:0" json:"design_id"` // 设计ID
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
}
type FsOrderDetailTemplateModel struct {
db *gorm.DB
}
func NewFsOrderDetailTemplateModel(db *gorm.DB) *FsOrderDetailTemplateModel {
return &FsOrderDetailTemplateModel{db}
}
func (dt *FsOrderDetailTemplateModel) GetListByIds(ctx context.Context, ids []int64) (resp []FsOrderDetailTemplate, err error) {
if len(ids) == 0 {
return
}
err = dt.db.WithContext(ctx).Model(&FsOrderDetailTemplate{}).Where("`id` in (?)", ids).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

66
model/gmodel/fsordermodel.go
View File

@ -1,66 +0,0 @@
package gmodel
import (
"context"
"errors"
"time"
"gorm.io/gorm"
)
type FsOrder struct {
Id int64 `gorm:"primary_key" json:"id"`
Sn *string `gorm:"default:''" json:"sn"` // 订单编号 FS211224OL2XDKNP
UserId *int64 `gorm:"default:0" json:"user_id"` // 用户ID
SellerUserId *int64 `gorm:"default:0" json:"seller_user_id"` // 销售员ID 0:自主下单
TotalAmount *int64 `gorm:"default:0" json:"total_amount"` // 总价
PayedAmount *int64 `gorm:"default:0" json:"payed_amount"` // 已支付金额
PayMethod *int64 `gorm:"default:0" json:"pay_method"` // 支付方式 1paypal 2strip
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
Utime *int64 `gorm:"default:0" json:"utime"` // 更新时间
Ptime *int64 `gorm:"default:0" json:"ptime"` // 最后一次 支付时间(可能多次支付)
AddressId *int64 `gorm:"default:0" json:"address_id"` // 地址ID或者云仓ID
DeliveryMethod *int64 `gorm:"default:0" json:"delivery_method"` // 配送方式 1:直接发货到收获地址 2：云仓
CustomerMark *string `gorm:"default:''" json:"customer_mark"` // 客户备注
Mark *string `gorm:"default:''" json:"mark"` // 后台订单备注
AddressInfo *string `gorm:"default:''" json:"address_info"` // 详细地址信息JSON
IsSup *int64 `gorm:"default:0" json:"is_sup"` // 0不是补货 1是补货
Status *int64 `gorm:"default:0" json:"status"` // 状态位（0：未支付，1：部分支付，2：支付完成，3：部分生产，4：部分生产完成，5：全部生产，6：全部生产完成，7：部分发货，8：发货完成，9：完成订单，10：取消订单，11:退款中，12：退款完成，13:订单已删除，14:订单已关闭）
IsPartPay *int64 `gorm:"default:0" json:"is_part_pay"` // 是否部分支付（0：否，1：是）
IsPayCompleted *int64 `gorm:"default:0" json:"is_pay_completed"` // 是否支付完成（0：否，1：是）
IsPartProduct *int64 `gorm:"default:0" json:"is_part_product"` // 是否部分生产（0：否，1：是）
IsPartProductCompleted *int64 `gorm:"default:0" json:"is_part_product_completed"` // 是否部分生产完成（0：否，1：是）
IsAllProduct *int64 `gorm:"default:0" json:"is_all_product"` // 是否全部生产（0：否，1：是）
IsAllProductCompleted *int64 `gorm:"default:0" json:"is_all_product_completed"` // 是否全部生产完成（0：否，1：是）
IsPartDelivery *int64 `gorm:"default:0" json:"is_part_delivery"` // 是否部分发货（0：否，1：是）
IsDeliveryCompleted *int64 `gorm:"default:0" json:"is_delivery_completed"` // 是否发货完成（0：否，1：是）
IsComplated *int64 `gorm:"default:0" json:"is_complated"` // 是否完成订单（0：否，1：是）
IsCancel *int64 `gorm:"default:0" json:"is_cancel"` // 是否取消订单（0：否，1：是）
IsRefunding *int64 `gorm:"default:0" json:"is_refunding"` // 是否退款中（0：否，1：是）
IsRefunded *int64 `gorm:"default:0" json:"is_refunded"` // 是否退款完成（0：否，1：是）
IsDeleted *int64 `gorm:"default:0" json:"is_deleted"` // 是否删除（0：否，1：是）
RefundReasonId *int64 `gorm:"default:0" json:"refund_reason_id"` // 取消订单原因ID
RefundReason *string `gorm:"default:''" json:"refund_reason"` // 取消订单原因
TsTime *time.Time `gorm:"" json:"ts_time"`
IsSure *int64 `gorm:"default:0" json:"is_sure"` // 是否确认订单 1确认0未确认
DeliverSn *string `gorm:"default:''" json:"deliver_sn"` // 发货单号
EmailTime *int64 `gorm:"default:0" json:"email_time"` // 邮件发送时间
}
type FsOrderModel struct {
db *gorm.DB
}
func NewFsOrderModel(db *gorm.DB) *FsOrderModel {
return &FsOrderModel{db}
}
func (o *FsOrderModel) FindOneBySn(ctx context.Context, userId int64, sn string) (resp FsOrder, err error) {
err = o.db.WithContext(ctx).Model(&FsOrder{}).Where(" `user_id` = ? and `sn` = ? ", userId, sn).Take(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsOrder{}, err
}
return resp, nil
}
func (o *FsOrderModel) Update(ctx context.Context, id int64, data FsOrder) error {
return o.db.WithContext(ctx).Model(&FsOrder{}).Where("`id` = ?", id).Updates(data).Error
}

53
model/gmodel/fsproductdesignmodel.go
View File

@ -1,53 +0,0 @@
package gmodel
import (
"context"
"errors"
"time"
"gorm.io/gorm"
)
type FsProductDesign struct {
Id int64 `gorm:"primary_key" json:"id"`
Sn *string `gorm:"default:''" json:"sn"` // 唯一标识
UserId *int64 `gorm:"default:0" json:"user_id"` // 用户ID
ProductId *int64 `gorm:"default:0" json:"product_id"` // 产品ID
TemplateId *int64 `gorm:"default:0" json:"template_id"` // 模型ID
MaterialId *int64 `gorm:"default:0" json:"material_id"` // 材质ID
SizeId *int64 `gorm:"default:0" json:"size_id"` // 尺寸ID
OptionalId *int64 `gorm:"default:0" json:"optional_id"` // 选项ID
Cover *string `gorm:"default:''" json:"cover"` // 封面图
Info *string `gorm:"default:''" json:"info"` // 保留的设计信息
Utime *time.Time `gorm:"" json:"utime"` // 更新时间
Status *int64 `gorm:"default:1" json:"status"` // 状态
IsDel *int64 `gorm:"default:0" json:"is_del"` // 是否删除 0未删除 1删除
IsPay *int64 `gorm:"default:0" json:"is_pay"` // 是否已有支付 0 未 1 有
LogoColor *string `gorm:"default:''" json:"logo_color"` // logo图片备选项
PageGuid *string `gorm:"default:''" json:"page_guid"` // 页面识别id
}
type FsProductDesignModel struct {
db *gorm.DB
}
func NewFsProductDesignModel(db *gorm.DB) *FsProductDesignModel {
return &FsProductDesignModel{db}
}
func (d *FsProductDesignModel) FindOneBySn(ctx context.Context, sn string) (resp FsProductDesign, err error) {
err = d.db.WithContext(ctx).Model(&FsProductDesign{}).Where("`sn` = ? and `status` = ?", sn, 1).Take(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsProductDesign{}, err
}
return resp, nil
}
func (d *FsProductDesignModel) GetAllByIds(ctx context.Context, ids []int64) (resp []FsProductDesign, err error) {
if len(ids) == 0 {
return
}
err = d.db.WithContext(ctx).Model(&FsProductDesign{}).Where("`id` in (?) and `status` = ?", ids, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

89
model/gmodel/fsproductmodel.go
View File

@ -1,89 +0,0 @@
package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsProduct struct {
Id int64 `gorm:"primary_key" json:"id"`
Sn *string `gorm:"default:''" json:"sn"` // 商品编号 P98f087j
Type *int64 `gorm:"default:0" json:"type"` // 分类ID
Title *string `gorm:"default:''" json:"title"` // 名称
TitleCn *string `gorm:"default:''" json:"title_cn"` // 中文名称
Cover *string `gorm:"default:''" json:"cover"` // 封面图
Imgs *string `gorm:"default:''" json:"imgs"` // 一个或多个介绍图或视频
Keywords *string `gorm:"default:''" json:"keywords"` // 关键字
Intro *string `gorm:"default:''" json:"intro"` // 简要描述
Sort *int64 `gorm:"default:0" json:"sort"` // 排序
SelledNum *int64 `gorm:"default:0" json:"selled_num"` // 已卖数量
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
View *int64 `gorm:"default:0" json:"view"` // 浏览量
SizeIds *string `gorm:"default:''" json:"size_ids"` // 尺寸 1,2,3,4
MaterialIds *string `gorm:"default:''" json:"material_ids"` // 材质 1,2,3
TagIds *string `gorm:"default:''" json:"tag_ids"` // 标签 逗号间隔
Status *int64 `gorm:"default:1" json:"status"` // 状态位 弃用
ProduceDays *int64 `gorm:"default:0" json:"produce_days"` // 生产天数
DeliveryDays *int64 `gorm:"default:0" json:"delivery_days"` // 运送天数
CoverImg *string `gorm:"default:''" json:"cover_img"` // 背景图
IsShelf *int64 `gorm:"default:1" json:"is_shelf"` // 是否上架
IsRecommend *int64 `gorm:"default:1" json:"is_recommend"` // 是否推荐
IsHot *int64 `gorm:"default:1" json:"is_hot"` // 是否热销
IsProtection *int64 `gorm:"default:1" json:"is_protection"` // 是否环保
IsMicrowave *int64 `gorm:"default:1" json:"is_microwave"` // 是否可微波炉
IsDel *int64 `gorm:"default:0" json:"is_del"` // 是否删除
RecommendProduct *string `gorm:"default:''" json:"recommend_product"` // 推荐产品id例如: 1,3,4,5
RecommendProductSort *string `gorm:"default:''" json:"recommend_product_sort"` // 推荐排序例如:1324
SceneIds *string `gorm:"default:''" json:"scene_ids"` // 关联的场景id
}
type FsProductModel struct {
db *gorm.DB
}
func NewFsProductModel(db *gorm.DB) *FsProductModel {
return &FsProductModel{db}
}
func (p *FsProductModel) GetProductListByIds(ctx context.Context, productIds []int64, sort string) (resp []FsProduct, err error) {
if len(productIds) == 0 {
return
}
db := p.db.Model(&FsProduct{}).
Where("`id` in (?) and `is_del` =? and `is_shelf` = ? and `status` =?", productIds, 0, 1, 1)
switch sort {
case "sort-asc":
db = db.Order("`sort` ASC")
case "sort-desc":
db = db.Order("`sort` DESC")
}
if err = db.Find(&resp).Error; err != nil {
return nil, err
}
return
}
func (p *FsProductModel) GetProductListByTypeIds(ctx context.Context, productTypes []int64, sort string) (resp []FsProduct, err error) {
if len(productTypes) == 0 {
return
}
db := p.db.WithContext(ctx).Model(&FsProduct{}).Where("`type` in (?) and `is_del` =? and `is_shelf` = ? and `status` =?", productTypes, 0, 1, 1)
switch sort {
case "sort-asc":
db = db.Order("`sort` ASC")
case "sort-desc":
db = db.Order("`sort` DESC")
}
err = db.Find(&resp).Error
if err != nil {
return nil, err
}
return
}
func (p *FsProductModel) GetRandomProductList(ctx context.Context, limit int) (resp []FsProduct, err error) {
err = p.db.WithContext(ctx).Model(&FsProduct{}).
Where("`is_del` =? and `is_shelf` = ?", 0, 1).Order("RAND()").Limit(limit).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

18
model/gmodel/fsproductmodel3dlightmodel.go
View File

@ -1,18 +0,0 @@
package gmodel
import "gorm.io/gorm"
type FsProductModel3dLight struct {
Id int64 `gorm:"primary_key" json:"id"`
Name *string `gorm:"default:''" json:"name"` // 灯光名称
Info *string `gorm:"default:''" json:"info"` // 灯光数据（json格式）
Status *int64 `gorm:"default:1" json:"status"` // 状态值（1：显示，0：删除）
Ctime *int64 `gorm:"default:0" json:"ctime"` // 创建时间
}
type FsProductModel3dLightModel struct {
db *gorm.DB
}
func NewFsProductModel3dLightModel(db *gorm.DB) *FsProductModel3dLightModel {
return &FsProductModel3dLightModel{db}
}

54
model/gmodel/fsproductmodel3dmodel.go
View File

@ -1,54 +0,0 @@
package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsProductModel3d struct {
Id int64 `gorm:"primary_key" json:"id"`
ProductId *int64 `gorm:"default:0" json:"product_id"` // 产品ID
Tag *int64 `gorm:"default:1" json:"tag"` // 类别（1：模型，2：配件，3：场景）
Title *string `gorm:"default:''" json:"title"` // 标题
Name *string `gorm:"default:''" json:"name"` // 详情页展示名称
ModelInfo *string `gorm:"default:''" json:"model_info"` // 模型详情
MaterialId *int64 `gorm:"default:0" json:"material_id"` // 材质ID
SizeId *int64 `gorm:"default:0" json:"size_id"` // 尺寸ID
Sort *int64 `gorm:"default:0" json:"sort"` // 排序
Light *int64 `gorm:"default:0" json:"light"` // 灯光组
LightList *string `gorm:"default:''" json:"light_list"` // 灯光备选项
PartId *int64 `gorm:"default:0" json:"part_id"` // 配件选项id（配件就是模型的id）
PartList *string `gorm:"default:''" json:"part_list"` // 配件备选项
Status *int64 `gorm:"default:1" json:"status"` // 状态位 1显示 0删除
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
OptionTemplate *int64 `gorm:"default:0" json:"option_template"` // 配件绑定的公共模板
Price *int64 `gorm:"default:0" json:"price"` // 仅配件用，配件的价格, 单位：美分
Sku *string `gorm:"default:''" json:"sku"` // sku
}
type FsProductModel3dModel struct {
db *gorm.DB
}
func NewFsProductModel3dModel(db *gorm.DB) *FsProductModel3dModel {
return &FsProductModel3dModel{db}
}
func (d *FsProductModel3dModel) GetAllByIds(ctx context.Context, ids []int64) (resp []FsProductModel3d, err error) {
if len(ids) == 0 {
return
}
err = d.db.WithContext(ctx).Model(&FsProductModel3d{}).Where("`id` in (?) and `status` = ?", ids, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}
func (d *FsProductModel3dModel) GetAllByIdsTag(ctx context.Context, ids []int64, tag int64) (resp []FsProductModel3d, err error) {
if len(ids) == 0 {
return
}
err = d.db.WithContext(ctx).Model(&FsProductModel3d{}).Where("`id` in (?) and `status` = ? and `tag` = ?", ids, 1, tag).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

31
model/gmodel/fsproducttemplatetagsmodel.go
View File

@ -1,31 +0,0 @@
package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsProductTemplateTags struct {
Id int64 `gorm:"primary_key" json:"id"` // ID
Title *string `gorm:"default:''" json:"title"` // 标题
Status *int64 `gorm:"default:1" json:"status"` // 状态 1：可用 0不可用
CreateAt *int64 `gorm:"default:0" json:"create_at"` // 创建时间
}
type FsProductTemplateTagsModel struct {
db *gorm.DB
}
func NewFsProductTemplateTagsModel(db *gorm.DB) *FsProductTemplateTagsModel {
return &FsProductTemplateTagsModel{db}
}
func (pt *FsProductTemplateTagsModel) GetListByIds(ctx context.Context, ids []int64) (resp []FsProductTemplateTags, err error) {
if len(ids) == 0 {
return
}
err = pt.db.WithContext(ctx).Model(&FsProductTemplateTags{}).Where("`id` in (?)", ids).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

42
model/gmodel/fsproducttemplatev2model.go
View File

@ -1,42 +0,0 @@
package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsProductTemplateV2 struct {
Id int64 `gorm:"primary_key" json:"id"`
ProductId *int64 `gorm:"default:0" json:"product_id"` // 产品ID
ModelId *int64 `gorm:"default:0" json:"model_id"` // 模型ID
Title *string `gorm:"default:''" json:"title"` // 模板（sku）,预留字段
Name *string `gorm:"default:''" json:"name"` // 名称
CoverImg *string `gorm:"default:''" json:"cover_img"` // 模板背景图
TemplateInfo *string `gorm:"default:''" json:"template_info"` // 模板详情
MaterialImg *string `gorm:"default:''" json:"material_img"` // 合成好的贴图
Sort *int64 `gorm:"default:0" json:"sort"` // 排序
LogoWidth *int64 `gorm:"default:0" json:"logo_width"` // logo图最大宽度
LogoHeight *int64 `gorm:"default:0" json:"logo_height"` // logo图最大高度
IsPublic *int64 `gorm:"default:0" json:"is_public"` // 是否可公用（1:可以，0：不可以）
Status *int64 `gorm:"default:1" json:"status"` // 状态1正常 2异常
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
Tag *string `gorm:"default:''" json:"tag"` // 标签（用户自填）
IsDel *int64 `gorm:"default:0" json:"is_del"` // 是否删除 1删除
}
type FsProductTemplateV2Model struct {
db *gorm.DB
}
func NewFsProductTemplateV2Model(db *gorm.DB) *FsProductTemplateV2Model {
return &FsProductTemplateV2Model{db}
}
func (t *FsProductTemplateV2Model) FindAllByProductIds(ctx context.Context, productIds []int64) (resp []FsProductTemplateV2, err error) {
if len(productIds) == 0 {
return
}
err = t.db.WithContext(ctx).Model(&FsProductTemplateV2{}).Where("`id` in (?) and `is_del` = ? and `status` = ?", productIds, 0, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

44
model/gmodel/fsqrcodesetmodel.go
View File

@ -1,44 +0,0 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
type FsQrcodeSet struct {
Id int64 `gorm:"primary_key" json:"id"` // id
Name *string `gorm:"default:''" json:"name"` // 二维码组件名称
Size *int64 `gorm:"default:0" json:"size"` // 二维码内容尺寸
IndexX *int64 `gorm:"default:0" json:"index_x"` // x偏移量
IndexY *int64 `gorm:"default:0" json:"index_y"` // y偏移量
SvgWebsite *string `gorm:"default:''" json:"svg_website"` // website d数据
SvgInstagram *string `gorm:"default:''" json:"svg_instagram"` // svg instagram d数据
SvgFacebook *string `gorm:"default:''" json:"svg_facebook"` // svg facebook d数据
Status *int64 `gorm:"default:1" json:"status"` // 状态 1正常 1删除
AdminId *int64 `gorm:"default:0" json:"admin_id"` // 操作人
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
Utime *int64 `gorm:"default:0" json:"utime"` // 更新时间
}
type FsQrcodeSetModel struct {
db *gorm.DB
}
func NewFsQrcodeSetModel(db *gorm.DB) *FsQrcodeSetModel {
return &FsQrcodeSetModel{db}
}
func (q *FsQrcodeSetModel) GetAll(ctx context.Context) (resp []FsQrcodeSet, err error) {
err = q.db.WithContext(ctx).Model(&FsQrcodeSet{}).Where("`status` = ?", 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}
func (q *FsQrcodeSetModel) FindOne(ctx context.Context, id int64) (resp FsQrcodeSet, err error) {
err = q.db.WithContext(ctx).Model(&FsQrcodeSet{}).Where("`id` = ?", id).Take(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsQrcodeSet{}, err
}
return resp, nil
}

28
model/gmodel/fsstandardlogomodel.go
View File

@ -1,28 +0,0 @@
package gmodel
import (
"context"
"gorm.io/gorm"
)
type FsStandardLogo struct {
Id int64 `gorm:"primary_key" json:"id"` // ID
Name *string `gorm:"default:''" json:"name"` // logo名称
Image *string `gorm:"default:''" json:"image"` // 图片地址
Ctime *int64 `gorm:"default:0" json:"ctime"` // 添加时间
Status *int64 `gorm:"default:1" json:"status"` // 状态 1正常 0删除
}
type FsStandardLogoModel struct {
db *gorm.DB
}
func NewFsStandardLogoModel(db *gorm.DB) *FsStandardLogoModel {
return &FsStandardLogoModel{db}
}
func (l *FsStandardLogoModel) GetAll(ctx context.Context) (resp []FsStandardLogo, err error) {
err = l.db.WithContext(ctx).Model(&FsStandardLogo{}).Where("`status` = ? ", 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

53
model/gmodel/fstagsmodel.go
View File

@ -1,53 +0,0 @@
package gmodel
import (
"context"
"errors"
"gorm.io/gorm"
)
type FsTags struct {
Id int64 `gorm:"primary_key" json:"id"` // ID
Title *string `gorm:"default:''" json:"title"` // 标题
Level *int64 `gorm:"default:0" json:"level"` // 层级、分类 1 => 二维码分类
ClickNum *int64 `gorm:"default:0" json:"click_num"` // 点击次数
Sort *int64 `gorm:"default:0" json:"sort"` // 排序(从大到小)
CreateAt *int64 `gorm:"default:0" json:"create_at"` // 创建时间
Icon *string `gorm:"default:''" json:"icon"` // 标签图标
Status *int64 `gorm:"default:1" json:"status"` // 状态 1：可用
Description *string `gorm:"default:''" json:"description"` // 介绍 Seo
RecommendProduct *string `gorm:"default:''" json:"recommend_product"` // 推荐产品id例如: 1,3,4,5
RecommendProductSort *string `gorm:"default:''" json:"recommend_product_sort"` // 推荐排序例如:1324
}
type FsTagsModel struct {
db *gorm.DB
}
func NewFsTagsModel(db *gorm.DB) *FsTagsModel {
return &FsTagsModel{db}
}
func (t *FsTagsModel) FindOne(ctx context.Context, id int64) (resp FsTags, err error) {
err = t.db.WithContext(ctx).Model(&FsTags{}).Where("`id` = ? and `status` = ?", id, 1).Take(&resp).Error
if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
return FsTags{}, err
}
return resp, nil
}
func (t *FsTagsModel) GetAllByIds(ctx context.Context, ids []int64) (resp []FsTags, err error) {
if len(ids) == 0 {
return
}
err = t.db.WithContext(ctx).Model(&FsTags{}).Where("`id` in(?) and `status` = ?", ids, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}
func (t *FsTagsModel) GetAllByLevel(ctx context.Context, level int) (resp []FsTags, err error) {
err = t.db.Model(&FsTags{}).Where("`level` = ? and `status` = ?", level, 1).Find(&resp).Error
if err != nil {
return nil, err
}
return
}

13
server/data-transfer/internal/logic/uploadqrcodelogic.go
View File

@ -54,7 +54,18 @@ func (l *UploadQrcodeLogic) UploadQrcode(req *types.UploadQrcodeReq, userinfo *a
qrType = *qrCodeSet.SvgFacebook
}
//生成二维码
imgBase64, err := qrcode.CreateQrCodeBs64WithLogo(req.Url, "", "", 512, int(*qrCodeSet.IndexX), int(*qrCodeSet.IndexY), true)
qrReq := qrcode.CreateQrCodeBs64WithLogoReq{
Content: req.Url,
OutPath: nil,
LogoPath: nil,
Size: *qrCodeSet.Size,
X: qrCodeSet.IndexX,
Y: qrCodeSet.IndexY,
ForegroundColor: nil,
BackgroundColor: nil,
DisableBorder: false,
}
imgBase64, err := qrcode.CreateQrCodeBs64WithLogo(qrReq)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to generate qrcode")

2
server/home-user-auth/internal/logic/usergettypelogic.go
View File

@ -33,7 +33,7 @@ func (l *UserGetTypeLogic) UserGetType(req *types.Request, userinfo *auth.UserIn
}
// 返回值必须调用Set重新返回, resp可以空指针调用 resp.SetStatus(basic.CodeOK, data)
data, err := gmodel.NewFsCanteenTypeModel(l.svcCtx.MysqlConn).FindAllGetType(l.ctx, userinfo.UserId)
data, err := gmodel.NewFsCanteenTypeModel(l.svcCtx.MysqlConn).FindAllGetType(l.ctx)
if err != nil {
logx.Error(err)
return

78
server/orders/internal/handler/getorderdetailhandler.go Normal file
View File

@ -0,0 +1,78 @@
package handler
import (
"errors"
"net/http"
"github.com/zeromicro/go-zero/core/logx"
"github.com/zeromicro/go-zero/rest/httpx"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"fusenapi/server/orders/internal/logic"
"fusenapi/server/orders/internal/svc"
"fusenapi/server/orders/internal/types"
)
func GetOrderDetailHandler(svcCtx *svc.ServiceContext) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
var (
// 定义错误变量
err error
// 定义用户信息变量
userinfo *auth.UserInfo
)
// 解析JWT token,并对空用户进行判断
claims, err := svcCtx.ParseJwtToken(r)
// 如果解析JWT token出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401, // 返回401状态码,表示未授权
Message: "unauthorized", // 返回未授权信息
})
logx.Info("unauthorized:", err.Error()) // 记录错误日志
return
}
if claims != nil {
// 从token中获取对应的用户信息
userinfo, err = auth.GetUserInfoFormMapClaims(claims)
// 如果获取用户信息出错,则返回未授权的JSON响应并记录错误消息
if err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 401,
Message: "unauthorized",
})
logx.Info("unauthorized:", err.Error())
return
}
} else {
// 如果claims为nil,则认为用户身份为白板用户
userinfo = &auth.UserInfo{UserId: 0, GuestId: 0}
}
var req types.GetOrderDetailReq
// 如果端点有请求结构体，则使用httpx.Parse方法从HTTP请求体中解析请求数据
if err := httpx.Parse(r, &req); err != nil {
httpx.OkJsonCtx(r.Context(), w, &basic.Response{
Code: 510,
Message: "parameter error",
})
logx.Info(err)
return
}
// 创建一个业务逻辑层实例
l := logic.NewGetOrderDetailLogic(r.Context(), svcCtx)
resp := l.GetOrderDetail(&req, userinfo)
// 如果响应不为nil，则使用httpx.OkJsonCtx方法返回JSON响应;
if resp != nil {
httpx.OkJsonCtx(r.Context(), w, resp)
} else {
err := errors.New("server logic is error, resp must not be nil")
httpx.ErrorCtx(r.Context(), w, err)
logx.Error(err)
}
}
}

5
server/orders/internal/handler/routes.go
View File

@ -17,6 +17,11 @@ func RegisterHandlers(server *rest.Server, serverCtx *svc.ServiceContext) {
Path: "/order/invoice",
Handler: GetOrderInvoiceHandler(serverCtx),
},
{
Method: http.MethodGet,
Path: "/order/detail",
Handler: GetOrderDetailHandler(serverCtx),
},
},
)
}

218
server/orders/internal/logic/getorderdetaillogic.go Normal file
View File

@ -0,0 +1,218 @@
package logic
import (
"fmt"
"fusenapi/constants"
"fusenapi/model/gmodel"
"fusenapi/utils/auth"
"fusenapi/utils/basic"
"fusenapi/utils/order"
"strings"
"time"
"context"
"fusenapi/server/orders/internal/svc"
"fusenapi/server/orders/internal/types"
"github.com/zeromicro/go-zero/core/logx"
)
type GetOrderDetailLogic struct {
logx.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
func NewGetOrderDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetOrderDetailLogic {
return &GetOrderDetailLogic{
Logger: logx.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetOrderDetailLogic) GetOrderDetail(req *types.GetOrderDetailReq, userinfo *auth.UserInfo) (resp *basic.Response) {
//查询订单信息
orderModel := gmodel.NewFsOrderModel(l.svcCtx.MysqlConn)
orderInfo, err := orderModel.FindOneBySn(l.ctx, userinfo.UserId, req.Sn)
if err != nil {
logx.Error(err)
return resp.SetStatus(basic.CodeServiceErr, "failed to get order info")
}
if orderInfo.Id == 0 {
return resp.SetStatusWithMessage(basic.CodeDbRecordNotFoundErr, "the order is not exists")
}
address := types.Address{}
//直接邮寄才有地址信息
if *orderInfo.DeliveryMethod == constants.DELIVERY_METHOD_ADDRESS {
addressInfo, err := gmodel.NewFsAddressModel(l.svcCtx.MysqlConn).GetOne(l.ctx, *orderInfo.AddressId, userinfo.UserId)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get address info")
}
if addressInfo.Id == 0 {
return resp.SetStatusWithMessage(basic.CodeDbRecordNotFoundErr, "address not exists")
}
address.Id = addressInfo.Id
address.UserId = *addressInfo.UserId
address.Name = *addressInfo.Name
address.FirstName = *addressInfo.FirstName
address.LastName = *addressInfo.LastName
address.Mobile = *addressInfo.Mobile
address.Street = *addressInfo.Street
address.Suite = *addressInfo.Suite
address.City = *addressInfo.City
address.State = *addressInfo.State
address.Country = *addressInfo.Country
address.ZipCode = *addressInfo.ZipCode
address.Status = *addressInfo.Status
address.IsDefault = *addressInfo.IsDefault
}
//获取订单详情
orderDetailModel := gmodel.NewFsOrderDetailModel(l.svcCtx.MysqlConn)
orderDetails, err := orderDetailModel.GetOrderDetailsByOrderId(l.ctx, orderInfo.Id)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get order details")
}
if len(orderDetails) == 0 {
return resp.SetStatusWithMessage(basic.CodeDbRecordNotFoundErr, "order details is empty")
}
optionalIds := make([]int64, 0, len(orderDetails))
productIds := make([]int64, 0, len(orderDetails))
orderDetailTemplateIds := make([]int64, 0, len(orderDetails))
for _, v := range orderDetails {
optionalIds = append(optionalIds, *v.OptionalId)
productIds = append(productIds, *v.ProductId)
orderDetailTemplateIds = append(orderDetailTemplateIds, *v.OrderDetailTemplateId)
}
//获取配件列表
productModel3dModel := gmodel.NewFsProductModel3dModel(l.svcCtx.MysqlConn)
productModel3dList, err := productModel3dModel.GetAllByIds(l.ctx, optionalIds)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get product 3d models")
}
mapModel3d := make(map[int64]int)
for k, v := range productModel3dList {
mapModel3d[v.Id] = k
}
//获取产品列表
productModel := gmodel.NewFsProductModel(l.svcCtx.MysqlConn)
productList, err := productModel.GetProductListByIds(l.ctx, productIds, "")
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get order product list")
}
mapProduct := make(map[int64]int)
for k, v := range productList {
mapProduct[v.Id] = k
}
//获取模板列表
orderDetailTemplateModel := gmodel.NewFsOrderDetailTemplateModel(l.svcCtx.MysqlConn)
detailTemplateList, err := orderDetailTemplateModel.GetListByIds(l.ctx, orderDetailTemplateIds)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get order detail template list")
}
sizeIds := make([]int64, 0, len(detailTemplateList))
mapDetailTemplate := make(map[int64]int)
for k, v := range detailTemplateList {
sizeIds = append(sizeIds, *v.SizeId)
mapDetailTemplate[v.Id] = k
}
//获取尺寸信息
productSizeModel := gmodel.NewFsProductSizeModel(l.svcCtx.MysqlConn)
productSizeList, err := productSizeModel.GetAllByIds(l.ctx, sizeIds, "")
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get product size list")
}
mapProductSize := make(map[int64]int)
for k, v := range productSizeList {
mapProductSize[v.Id] = k
}
//获取支付信息
payModel := gmodel.NewFsPayModel(l.svcCtx.MysqlConn)
payList, err := payModel.GetOrderPayList(l.ctx, *orderInfo.Sn, 1, 0)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get pay records")
}
mapPay := make(map[int64]int) //pay_stat作为索引
for k, v := range payList {
mapPay[*v.PayStage] = k
}
//处理订单状态
orderStatus := order.GetOrderStatus(*orderInfo.Status, *orderInfo.DeliveryMethod)
//组装
productListRsp := make([]types.Product, 0, len(orderDetails))
for _, v := range orderDetails {
cover := *v.Cover
if req.Size >= 200 {
coverSlice := strings.Split(".", *v.Cover)
if len(coverSlice) >= 2 {
cover = fmt.Sprintf("%s_%d.%s", coverSlice[0], req.Size, coverSlice[1])
}
}
Fitting := ""
if model3dIndex, ok := mapModel3d[*v.OptionalId]; ok {
Fitting = *productModel3dList[model3dIndex].Title
}
pcBox := int64(0)
Size := ""
if detailTemplateIndex, ok := mapDetailTemplate[*v.OrderDetailTemplateId]; ok {
pcBox = *v.BuyNum / *detailTemplateList[detailTemplateIndex].EachBoxNum
if sizeIndex, ok := mapProductSize[*detailTemplateList[detailTemplateIndex].SizeId]; ok {
Size = *productSizeList[sizeIndex].Capacity
}
}
Title := ""
if productIndex, ok := mapProduct[*v.ProductId]; ok {
Title = *productList[productIndex].Title
}
productListRsp = append(productListRsp, types.Product{
Cover: cover,
Fitting: Fitting,
OptionPrice: *v.OptionPrice,
OrderDetailTemplateId: *v.OrderDetailTemplateId,
OrderId: *v.OrderId,
Pcs: *v.BuyNum,
PcsBox: pcBox,
Price: *v.Amount,
ProductId: *v.ProductId,
Size: Size,
Title: Title,
})
}
data := types.GetOrderDetailRsp{
Id: orderInfo.Id,
TotalAmount: *orderInfo.TotalAmount,
Deposit: *orderInfo.TotalAmount / 2,
Remaining: *orderInfo.TotalAmount - *orderInfo.TotalAmount/2,
IsPayCompleted: *orderInfo.IsPayCompleted,
DeliveryMethod: *orderInfo.DeliveryMethod,
Sn: *orderInfo.Sn,
Status: orderStatus,
Ctime: time.Unix(*orderInfo.Ctime, 0).Format("2006-01-02 15:04:05"),
PayInfo: types.PayInfo{},
Address: address,
ProductList: productListRsp,
}
//首款
if payIndex, ok := mapPay[1]; ok {
data.PayInfo.Deposit = types.Deposit{
Method: *payList[payIndex].Brand,
TransNo: *payList[payIndex].TradeNo,
}
}
//尾款
if payIndex, ok := mapPay[2]; ok {
data.PayInfo.Final = types.Deposit{
Method: *payList[payIndex].Brand,
TransNo: *payList[payIndex].TradeNo,
}
}
return resp.SetStatusWithMessage(basic.CodeOK, "success", data)
}

61
server/orders/internal/types/types.go
View File

@ -15,6 +15,67 @@ type GetOrderInvoiceRsp struct {
Pdf string `json:"pdf"`
}
type GetOrderDetailReq struct {
Sn string `form:"sn"`
Size int64 `form:"size, optional"`
}
type GetOrderDetailRsp struct {
Id int64 `json:"id"`
TotalAmount int64 `json:"total_amount"`
Deposit int64 `json:"deposit"`
Remaining int64 `json:"remaining"`
IsPayCompleted int64 `json:"is_pay_completed"`
DeliveryMethod int64 `json:"delivery_method"`
Sn string `json:"sn"`
Status int64 `json:"status"`
Ctime string `json:"ctime"`
PayInfo PayInfo `json:"pay_info"`
Address Address `json:"address"`
ProductList []Product `json:"productList"`
}
type Product struct {
Cover string `json:"cover"`
Fitting string `json:"fitting"`
OptionPrice int64 `json:"option_price"`
OrderDetailTemplateId int64 `json:"order_detail_template_id"`
OrderId int64 `json:"order_id"`
Pcs int64 `json:"pcs"`
PcsBox int64 `json:"pcs_box"`
Price int64 `json:"price"`
ProductId int64 `json:"product_id"`
Size string `json:"size"`
Title string `json:"title"`
}
type Address struct {
Id int64 `json:"id"`
UserId int64 `json:"user_id"`
Name string `json:"name"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
Mobile string `json:"mobile"`
Street string `json:"street"`
Suite string `json:"suite"`
City string `json:"city"`
State string `json:"state"`
Country string `json:"country"`
ZipCode string `json:"zip_code"`
Status int64 `json:"status"`
IsDefault int64 `json:"is_default"`
}
type PayInfo struct {
Deposit Deposit `json:"Deposit"`
Final Deposit `json:"Final"`
}
type Deposit struct {
Method string `json:"method"`
TransNo string `json:"trans_no"`
}
type Response struct {
Code int `json:"code"`
Message string `json:"msg"`

4
server/product/internal/logic/getproductlistlogic.go
View File

@ -55,7 +55,7 @@ func (l *GetProductListLogic) GetProductList(req *types.GetProductListReq, useri
}
//查询用户信息
userModel := gmodel.NewFsUserModel(l.svcCtx.MysqlConn)
userInfo, err := userModel.FindOne(l.ctx, userinfo.UserId)
userInfo, err := userModel.FindUserById(l.ctx, userinfo.UserId)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "get user info err")
@ -150,7 +150,7 @@ func (l *GetProductListLogic) GetProductList(req *types.GetProductListReq, useri
//千人千面处理
thousandFaceImageFormatReq := image.ThousandFaceImageFormatReq{
Size: int(req.Size),
IsThousandFace: int(userInfo.IsThousandFace),
IsThousandFace: int(*userInfo.IsThousandFace),
Cover: *v.Cover,
CoverImg: *v.CoverImg,
CoverDefault: *v.CoverImg,

4
server/product/internal/logic/getsuccessrecommandlogic.go
View File

@ -32,7 +32,7 @@ func (l *GetSuccessRecommandLogic) GetSuccessRecommand(req *types.GetSuccessReco
}
//获取用户信息
userModel := gmodel.NewFsUserModel(l.svcCtx.MysqlConn)
user, err := userModel.FindOne(l.ctx, userInfo.UserId)
user, err := userModel.FindUserById(l.ctx, userInfo.UserId)
if err != nil {
logx.Error(err)
return resp.SetStatusWithMessage(basic.CodeServiceErr, "failed to get user info")
@ -68,7 +68,7 @@ func (l *GetSuccessRecommandLogic) GetSuccessRecommand(req *types.GetSuccessReco
//千人千面处理
thousandFaceImageFormatReq := image.ThousandFaceImageFormatReq{
Size: int(req.Size),
IsThousandFace: int(user.IsThousandFace),
IsThousandFace: int(*user.IsThousandFace),
Cover: *v.Cover,
CoverImg: *v.CoverImg,
CoverDefault: *v.CoverImg,

59
server_api/orders.api
View File

@ -11,6 +11,9 @@ service orders {
//获取订单发票
@handler GetOrderInvoiceHandler
get /order/invoice (GetOrderInvoiceReq) returns (response);
//获取订单详情
@handler GetOrderDetailHandler
get /order/detail (GetOrderDetailReq) returns (response);
}
//获取订单发票
@ -21,4 +24,60 @@ type GetOrderInvoiceReq {
type GetOrderInvoiceRsp {
FileName string `json:"file_name"`
Pdf string `json:"pdf"`
}
//获取订单详情
type GetOrderDetailReq {
Sn string `form:"sn"`
Size int64 `form:"size, optional"`
}
type GetOrderDetailRsp {
Id int64 `json:"id"`
TotalAmount int64 `json:"total_amount"`
Deposit int64 `json:"deposit"`
Remaining int64 `json:"remaining"`
IsPayCompleted int64 `json:"is_pay_completed"`
DeliveryMethod int64 `json:"delivery_method"`
Sn string `json:"sn"`
Status int64 `json:"status"`
Ctime string `json:"ctime"`
PayInfo PayInfo `json:"pay_info"`
Address Address `json:"address"`
ProductList []Product `json:"productList"`
}
type Product {
Cover string `json:"cover"`
Fitting string `json:"fitting"`
OptionPrice int64 `json:"option_price"`
OrderDetailTemplateId int64 `json:"order_detail_template_id"`
OrderId int64 `json:"order_id"`
Pcs int64 `json:"pcs"`
PcsBox int64 `json:"pcs_box"`
Price int64 `json:"price"`
ProductId int64 `json:"product_id"`
Size string `json:"size"`
Title string `json:"title"`
}
type Address {
Id int64 `json:"id"`
UserId int64 `json:"user_id"`
Name string `json:"name"`
FirstName string `json:"first_name"`
LastName string `json:"last_name"`
Mobile string `json:"mobile"`
Street string `json:"street"`
Suite string `json:"suite"`
City string `json:"city"`
State string `json:"state"`
Country string `json:"country"`
ZipCode string `json:"zip_code"`
Status int64 `json:"status"`
IsDefault int64 `json:"is_default"`
}
type PayInfo {
Deposit Deposit `json:"Deposit"`
Final Deposit `json:"Final"`
}
type Deposit {
Method string `json:"method"`
TransNo string `json:"trans_no"`
}

30
utils/order/order_status.go Normal file
View File

@ -0,0 +1,30 @@
package order
import "fusenapi/constants"
// 获取订单生产状态
func GetOrderStatus(orderStatus int64, deliveryMethod int64) int64 {
switch orderStatus {
//已支付
case constants.STATUS_NEW_PART_PAY, constants.STATUS_NEW_PAY_COMPLETED, constants.STATUS_NEW_SURE:
return constants.STATUS_FONT_PAID
//生产中
case constants.STATUS_NEW_PRODUTING, constants.STATUS_NEW_PRODUT_COMPLETED:
return constants.STATUS_FONT_PRODUCTION
//运输中-直邮单
case constants.STATUS_NEW_DELIVER, constants.STATUS_NEW_UPS:
return constants.STATUS_FONT_SHIPPED
//到达-云仓
case constants.STATUS_NEW_ARRIVAL:
return constants.STATUS_FONT_INVENTORY
//订单完成
case constants.STATUS_NEW_COMPLETED:
if deliveryMethod == constants.DELIVERY_METHOD_CLOUD {
return constants.STATUS_FONT_COMPLETED_CLOUD
}
return constants.STATUS_FONT_COMPLETED
//订单关闭
default:
return constants.STATUS_FONT_CLOSED
}
}

52
utils/qrcode/creator.go
View File

@ -7,37 +7,57 @@ import (
"github.com/skip2/go-qrcode"
"golang.org/x/image/draw"
"image"
"image/color"
_ "image/jpeg"
"image/png"
"os"
)
// 带logo的二维码图片生成 content-二维码内容 size-像素单位 outPath 保存路径（传空则不保存） disableBorder是否不启用边框 logoPath-logo文件路径(传空就不带) x：x轴整体偏移 y:y轴整体偏移
func CreateQrCodeBs64WithLogo(content, outPath string, logoPath string, size, x, y int, disableBorder bool) (data string, err error) {
code, err := qrcode.New(content, qrcode.High)
type CreateQrCodeBs64WithLogoReq struct {
Content string //二维码内容
OutPath *string //二维码保存路径（可选）
LogoPath *string //logo路径（可选）
Size int64 //二维码尺寸
X *int64 //二维码整体x偏移
Y *int64 //二维码整体Y偏移
ForegroundColor *color.Color //二维码纹路颜色
BackgroundColor *color.Color //二维码背景颜色
DisableBorder bool // 是否不要二维码边框
}
func CreateQrCodeBs64WithLogo(req CreateQrCodeBs64WithLogoReq) (data string, err error) {
code, err := qrcode.New(req.Content, qrcode.High)
if err != nil {
return
}
if disableBorder {
if req.DisableBorder {
code.DisableBorder = true
}
//二维码纹路颜色
if req.ForegroundColor != nil {
code.ForegroundColor = *req.ForegroundColor
}
//背景颜色
if req.BackgroundColor != nil {
code.BackgroundColor = *req.BackgroundColor
}
//设置文件大小并创建画板
qrcodeImg := code.Image(size)
qrcodeImg := code.Image(int(req.Size))
outImg := image.NewRGBA(qrcodeImg.Bounds())
buf := new(bytes.Buffer)
//无logo
if logoPath == "" {
if req.LogoPath == nil {
//图像偏移
if x != 0 || y != 0 {
draw.Draw(outImg, outImg.Bounds().Add(image.Pt(x, y)), qrcodeImg, outImg.Bounds().Min, draw.Src)
if req.X != nil && req.Y != nil {
draw.Draw(outImg, outImg.Bounds().Add(image.Pt(int(*req.X), int(*req.Y))), qrcodeImg, outImg.Bounds().Min, draw.Src)
}
err = png.Encode(buf, outImg)
if err != nil {
return "", err
}
if outPath != "" {
if req.OutPath != nil {
// 写入文件
f, err := os.Create(outPath)
f, err := os.Create(*req.OutPath)
if err != nil {
return "", err
}
@ -50,7 +70,7 @@ func CreateQrCodeBs64WithLogo(content, outPath string, logoPath string, size, x,
return base64.StdEncoding.EncodeToString(buf.Bytes()), nil
}
//读取logo文件
logoFile, err := os.Open(logoPath)
logoFile, err := os.Open(*req.LogoPath)
if err != nil {
return "", err
}
@ -58,7 +78,7 @@ func CreateQrCodeBs64WithLogo(content, outPath string, logoPath string, size, x,
if err != nil {
return "", err
}
logoImg = resize.Resize(uint(size/5), uint(size/5), logoImg, resize.Lanczos3)
logoImg = resize.Resize(uint(req.Size/5), uint(req.Size/5), logoImg, resize.Lanczos3)
// 添加边框
// 图片到边框距离
pic2FramePadding := logoImg.Bounds().Dx() / 10
@ -79,16 +99,16 @@ func CreateQrCodeBs64WithLogo(content, outPath string, logoPath string, size, x,
offset := image.Pt((outImg.Bounds().Max.X-transparentImg.Bounds().Max.X)/2, (outImg.Bounds().Max.Y-transparentImg.Bounds().Max.Y)/2)
draw.Draw(outImg, outImg.Bounds().Add(offset), transparentImg, image.Pt(0, 0), draw.Over)
//图像偏移
if x != 0 || y != 0 {
draw.Draw(outImg, outImg.Bounds().Add(image.Pt(x, y)), qrcodeImg, outImg.Bounds().Min, draw.Src)
if req.X != nil && req.Y != nil {
draw.Draw(outImg, outImg.Bounds().Add(image.Pt(int(*req.X), int(*req.Y))), qrcodeImg, outImg.Bounds().Min, draw.Src)
}
err = png.Encode(buf, outImg)
if err != nil {
return "", err
}
if outPath != "" {
if req.OutPath != nil {
// 写入文件
f, err := os.Create(outPath)
f, err := os.Create(*req.OutPath)
if err != nil {
return "", err
}