jx-callback/business/jxstore/initdata/initdata.go

package initdata

import (
	"crypto/md5"
	"fmt"
	"io/ioutil"
	"net/http"

	"git.rosy.net.cn/baseapi/platformapi/autonavi"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/jxutils/jxcontext"
	"git.rosy.net.cn/jx-callback/business/jxutils/tasksch"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/business/model/dao"
	"git.rosy.net.cn/jx-callback/business/partner"
	"git.rosy.net.cn/jx-callback/business/partner/purchase/mtwm"
	"git.rosy.net.cn/jx-callback/globals/api"
)

func TruncateTable(db *dao.DaoDB, tableName string) (err error) {
	_, err = dao.ExecuteSQL(db, "TRUNCATE TABLE "+tableName)
	return err
}

func insertPlace(ctx *jxcontext.Context, db *dao.DaoDB, parent *autonavi.District, placeList []*autonavi.District) (err error) {
	for _, v := range placeList {
		if v.Level <= autonavi.DistrictLevelDistrict {
			place := &model.Place{
				Code:    int(utils.Str2Int64(v.Adcode)),
				Name:    v.Name,
				Level:   int8(v.Level),
				TelCode: v.CityCode,
				Enabled: 1,
			}
			if parent != nil {
				place.ParentCode = int(utils.Str2Int64(parent.Adcode))
			}
			dao.WrapAddIDCULEntity(place, ctx.GetUserName())
			if err = dao.CreateEntity(db, place); err != nil {
				return err
			}
			if err = insertPlace(ctx, db, v, v.Districts); err != nil {
				return err
			}
		}
	}
	return nil
}

func InitPlace(ctx *jxcontext.Context) (err error) {
	db := dao.GetDB()
	if err = TruncateTable(db, "place"); err == nil {
		placeList, err2 := api.AutonaviAPI.GetDistricts(autonavi.DistrictLevelDistrict, "")
		if err = err2; err != nil {
			return err
		}
		placeList = placeList[0].Districts
		dao.Begin(db)
		defer func() {
			dao.Rollback(db)
		}()
		if err = insertPlace(ctx, db, nil, placeList); err != nil {
			return err
		}
		updateSqls := []string{
			`
            UPDATE place t1
            JOIN jde_city t2 ON t1.code = t2.col_tencentAddressCode
            SET t1.jd_code = t2.col_areaCode;
			`,
			`
            UPDATE place t1
            JOIN place t2 ON t1.parent_code = t2.code AND t2.jd_code != 0
            JOIN jde_district t3 ON t1.name = t3.col_areaName AND t2.jd_code = t3.col_cityCode
            SET t1.jd_code = t3.col_areaCode
            WHERE t1.level = 3;
			`,
			`
			UPDATE
			place t1
			JOIN ebde_places t2 ON t1.name = t2.col_city_name
			SET t1.ebai_code = t2.col_city_id
			WHERE t1.level = 1 OR t1.level = 2;
			`,
			`
			UPDATE
			place t1
			JOIN place t1p ON t1.parent_code = t1p.code
			JOIN ebde_places t2 ON t1.name = t2.col_city_name
			JOIN ebde_places t2p ON t2.col_parent_id = t2p.col_city_id AND t1p.ebai_code = t2p.col_city_id
			SET t1.ebai_code = t2.col_city_id
			WHERE t1.level = 3;
			`,
			`
            UPDATE
            place t1
            JOIN mtpsdeliveryprice t2 ON t1.code = t2.citycode
            SET t1.mtps_price = t2.price;
			`,
			`
            UPDATE
            place t1
            JOIN mtpsdeliveryprice t2 ON t1.name LIKE CONCAT(t2.cityname, '%')
            SET t1.mtps_price = t2.price
            WHERE t1.level = 2 AND t1.mtps_price = 0;
			`,
			`
            UPDATE place t1
            LEFT JOIN (
            SELECT DISTINCT city_code
            FROM store
            UNION DISTINCT
            SELECT DISTINCT place_code city_code
            FROM sku_name_place_bind
            ) t2 ON t1.code = t2.city_code
            SET t1.enabled = 0
            WHERE t1.level = 2 AND t2.city_code IS NULL;
			`,
		}
		for _, v := range updateSqls {
			if _, err = dao.ExecuteSQL(db, v); err != nil {
				return err
			}
		}
		dao.Commit(db)
	}
	return err
}

func InitSkuName(ctx *jxcontext.Context, isForce, isAsync, isContinueWhenError bool) (hint string, err error) {
	db := dao.GetDB()
	var skuNameList []*model.SkuName
	if err = dao.GetRows(db, &skuNameList, `
	SELECT *
	FROM sku_name
	WHERE deleted_at = ? AND img <> ''
	ORDER BY id
	`, utils.DefaultTimeValue); err != nil {
		return "", err
	}

	task := tasksch.NewParallelTask("InitSkuName calculate md5", tasksch.NewParallelConfig().SetIsContinueWhenError(isContinueWhenError), ctx.GetUserName(), func(task *tasksch.ParallelTask, batchItemList []interface{}, params ...interface{}) (retVal interface{}, err error) {
		skuName := batchItemList[0].(*model.SkuName)
		if skuName.ImgHashCode == "" || isForce {
			response, err := http.Get(skuName.Img)
			if err == nil {
				defer response.Body.Close()
				data, err2 := ioutil.ReadAll(response.Body)
				if err = err2; err == nil {
					skuName.ImgHashCode = fmt.Sprintf("%X", md5.Sum(data))
					db := dao.GetDB()
					_, err = dao.UpdateEntity(db, skuName, "ImgHashCode")
				}
			}
		}
		return nil, err
	}, skuNameList)
	tasksch.ManageTask(task).Run()
	if !isAsync {
		_, err = task.GetResult(0)
	} else {
		hint = task.ID
	}
	return hint, err
}

func InitVendorCategory(ctx *jxcontext.Context) (num int64, err error) {
	if handler, ok := partner.PurchasePlatformHandlers[model.VendorIDMTWM].(*mtwm.PurchaseHandler); ok {
		cats, err2 := handler.GetVendorCategories()
		if err2 != nil {
			return num, err2
		}

		db := dao.GetDB()
		dao.Begin(db)
		defer dao.Rollback(db)
		sql := `
		DELETE
		FROM sku_vendor_category
		WHERE vendor_id = ?
		`
		if _, err = dao.ExecuteSQL(db, sql, model.VendorIDMTWM); err != nil {
			return num, err
		}
		for _, cat := range cats {
			dao.WrapAddIDCULEntity(cat, ctx.GetUserName())
			if err = dao.CreateEntity(db, cat); err != nil {
				return num, err
			}
		}
		dao.Commit(db)
		num = int64(len(cats))
	}
	return num, err
}