jx-callback/business/model/dao/dao_bz.go

package dao

import (
	"reflect"
	"time"

	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxutils"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/globals"
	"github.com/astaxie/beego/orm"
)

// 这里面的函数要求实体是IDCUDL的，即含有ID, UpdatedAt, LastOperator, DeletedAt字段

func GetEntitiesByKV(db *DaoDB, item interface{}, conditions map[string]interface{}, isIncludeDeleted bool) (err error) {
	if db == nil {
		db = GetDB()
	}
	err = utils.CallFuncLogError(func() error {
		typeInfo := reflect.TypeOf(item).Elem().Elem()
		if typeInfo.Kind() == reflect.Ptr {
			typeInfo = typeInfo.Elem()
		}
		qs := db.db.QueryTable(reflect.New(typeInfo).Interface())
		for k, v := range conditions {
			qs = qs.Filter(k, v)
		}
		qs = qs.Limit(-1)
		if !isIncludeDeleted {
			if _, ok := typeInfo.FieldByName(model.FieldDeletedAt); ok {
				qs = qs.Filter(model.FieldDeletedAt, utils.DefaultTimeValue)
			}
		}
		_, err = qs.All(item)
		return err
	}, reflect.TypeOf(item).Name())
	return err
}

func UpdateEntityByKV(db *DaoDB, item interface{}, kvs map[string]interface{}, conditions map[string]interface{}) (num int64, err error) {
	if db == nil {
		db = GetDB()
	}
	qs := db.db.QueryTable(item)
	if conditions == nil {
		qs = qs.Filter(model.FieldID, jxutils.GetObjFieldByName(item, model.FieldID))
	} else {
		for k, v := range conditions {
			qs = qs.Filter(k, v)
		}
	}
	num, err = qs.Update(kvs)
	if err != nil && !IsDuplicateError(err) {
		globals.SugarLogger.Errorf("UpdateEntityByKV %s failed with error:%v", reflect.TypeOf(item).Name(), err)
	}
	return num, err
}

func UpdateEntityLogically(db *DaoDB, item interface{}, kvs map[string]interface{}, userName string, conditions map[string]interface{}) (num int64, err error) {
	if conditions != nil {
		conditions = utils.MergeMaps(conditions, map[string]interface{}{
			model.FieldDeletedAt: utils.DefaultTimeValue,
		})
	}
	return UpdateEntityByKV(db, item, utils.MergeMaps(kvs, map[string]interface{}{
		model.FieldUpdatedAt:    time.Now(),
		model.FieldLastOperator: userName,
	}), conditions)
}

// 此函数会更新同步标志
func UpdateEntityLogicallyAndUpdateSyncStatus(db *DaoDB, item interface{}, kvs map[string]interface{}, userName string, conditions map[string]interface{}, syncStatusFieldName string) (num int64, err error) {
	if conditions != nil {
		conditions = utils.MergeMaps(conditions, map[string]interface{}{
			model.FieldDeletedAt: utils.DefaultTimeValue,
		})
	} else {
		conditions = map[string]interface{}{
			model.FieldID: jxutils.GetObjFieldByName(item, model.FieldID),
		}
	}
	typeInfo := reflect.TypeOf(item)
	valueRows := reflect.New(reflect.SliceOf(typeInfo))
	rows := valueRows.Interface()
	if err = GetEntitiesByKV(db, rows, conditions, false); err == nil {
		// globals.SugarLogger.Debug(utils.Format4Output(rows, false))
		valueRows = reflect.Indirect(valueRows)
		for i := 0; i < valueRows.Len(); i++ {
			value := reflect.Indirect(valueRows.Index(i))
			status := value.FieldByName(syncStatusFieldName).Int() | model.SyncFlagModifiedMask
			num2, err2 := UpdateEntityByKV(db, value.Interface(), utils.MergeMaps(kvs, map[string]interface{}{
				model.FieldUpdatedAt:    time.Now(),
				model.FieldLastOperator: userName,
				syncStatusFieldName:     status,
			}), nil)
			if err = err2; err == nil {
				num += num2
			} else {
				return num, err
			}
		}
	}
	return num, err
}

func DeleteEntityLogically(db *DaoDB, item interface{}, kvs map[string]interface{}, userName string, conditions map[string]interface{}) (num int64, err error) {
	return UpdateEntityLogically(db, item, utils.MergeMaps(kvs, map[string]interface{}{
		model.FieldDeletedAt: time.Now(),
	}), userName, conditions)
}

func AddStoreCategoryMap(db *DaoDB, storeID, categoryID int, vendorID int, vendorCategoryID string, status int8, userName string) (err error) {
	storeCat := &model.StoreSkuCategoryMap{
		StoreID:        storeID,
		CategoryID:     categoryID,
		MtwmSyncStatus: model.SyncFlagNewMask,
		WscSyncStatus:  model.SyncFlagNewMask,
	}
	storeCat.DeletedAt = utils.DefaultTimeValue
	if err = GetEntity(db, storeCat, model.FieldStoreID, model.FieldCategoryID, model.FieldDeletedAt); err != nil && err != orm.ErrNoRows {
		return err
	}
	if vendorID == model.VendorIDEBAI {
		if vendorCategoryID != "" {
			storeCat.EbaiID = utils.Str2Int64(vendorCategoryID)
		}
		storeCat.EbaiSyncStatus = status
	} else {
		panic("unsupported vendor")
	}
	if storeCat.ID == 0 {
		WrapAddIDCULDEntity(storeCat, userName)
		err = CreateEntity(db, storeCat)
	} else {
		WrapUpdateULEntity(storeCat, userName)
		_, err = UpdateEntity(db, storeCat)
	}
	return err
}

func GetStoreMapByStoreID(db *DaoDB, storeID, vendorID int) (storeMap *model.StoreMap, err error) {
	if db == nil {
		db = GetDB()
	}
	storeMap = &model.StoreMap{
		StoreID:  storeID,
		VendorID: vendorID,
	}
	storeMap.DeletedAt = utils.DefaultTimeValue
	if err = GetEntity(db, storeMap, model.FieldStoreID, model.FieldVendorID, model.FieldDeletedAt); err != nil {
		if err != orm.ErrNoRows {
			globals.SugarLogger.Warnf("GetStoreMapByStoreID storeID:%d, vendorID:%d read storefeature failed with error:%v", storeID, vendorID, err)
		}
		return nil, err
	}
	return storeMap, nil
}

func GetStoreCouriersByStoreID(db *DaoDB, storeID, vendorID int) (storeMaps []*model.StoreMap, err error) {
	if db == nil {
		db = GetDB()
	}
	if err = utils.CallFuncLogError(func() error {
		sql := `
		SELECT *
		FROM store_courier_map
		WHERE store_id = ? AND status = ? AND deleted_at = ?
		`
		sqlParams := []interface{}{
			storeID,
			model.StoreStatusOpened,
			utils.DefaultTimeValue,
		}
		if vendorID != -1 {
			sql += " AND vendor_id = ?"
			sqlParams = append(sqlParams, vendorID)
		}
		return GetRows(db, &storeMaps, sql, sqlParams...)
	}, "GetStoreCouriersByStoreID storeID:%d, vendorID:%d", storeID, vendorID); err != nil {
		return nil, err
	}
	return storeMaps, nil
}