eta_crawler/services/commodity_trade_cffex.go

package services

import (
	"encoding/xml"
	"fmt"
	"hongze/hongze_data_crawler/models"
	"hongze/hongze_data_crawler/utils"
	"rdluck_tools/http"
	"strconv"
	"time"
)

type XmlItem struct {
	XMLName xml.Name `xml:"positionRank"`
	Data    []struct {
		ContractCode string `xml:"instrumentid"`
		Value        string `xml:"Value,attr"`
		Text         string `xml:"Text,attr"`
		Tradingday   string `xml:"tradingday"`
		Datatypeid   string `xml:"datatypeid"`
		Rank         int    `xml:"rank"`
		ShortName    string `xml:"shortname"`
		Volume       int    `xml:"volume"`
		Varvolume    int    `xml:"varvolume"`
		ProductId    string `xml:"productid"`
	} `xml:"data"`
}

var cffexIndexCode string
var cffexIndexCodeMap = make(map[string]string)
var cffexActionCodeMap = make(map[string]map[string]int)

func cffexIndexCodeGenerator(indexName, suffix string) string {
	cffexIndexCode, _ := cffexIndexCodeMap[indexName]
	if cffexIndexCode == "" {
		cffexIndexCode = fmt.Sprintf("CFFEX%s", time.Now().Format(utils.FormatDateTimeUnSpace)+strconv.Itoa(utils.GetRandInt(1, 100))+suffix)
		cffexIndexCodeMap[indexName] = cffexIndexCode
		err := models.AddBaseFromTradeMapping(indexName, cffexIndexCode, "CFFEX")
		if err != nil {
			fmt.Println("add Code err:", err)
		}
	}
	return cffexIndexCode
}

// SyncRankingFromCffex 中国金融期货交易所
func SyncRankingFromCffex() {
	for i := 2; i > 0; i-- {
		zzUrl := "http://www.cffex.com.cn/sj/ccpm/%s/%s/"
		date := time.Now().AddDate(0, 0, -i)
		dateStr := date.Format(utils.FormatDateUnSpace)
		pre := dateStr[:6]
		sub := dateStr[6:]
		zzUrl = fmt.Sprintf(zzUrl, pre, sub)
		fmt.Println(zzUrl)

		var xmlItems = make([]*XmlItem, 6)
		xmlItems[0] = GetXmlItem(zzUrl, "IF")
		xmlItems[1] = GetXmlItem(zzUrl, "IC")
		xmlItems[2] = GetXmlItem(zzUrl, "IH")
		xmlItems[3] = GetXmlItem(zzUrl, "TS")
		xmlItems[4] = GetXmlItem(zzUrl, "TF")
		xmlItems[5] = GetXmlItem(zzUrl, "T")
		//获取新的指标信息
		var sRank string

		//获取所有指标信息
		allIndex, err := models.GetBaseFromTradeCffexIndexAll(dateStr)
		if err != nil {
			fmt.Println("select err:", err)
		}

		existDealMap := make(map[string]int)
		existBuyMap := make(map[string]int)
		existSoldMap := make(map[string]int)
		for _, v := range allIndex {
			existDealMap[v.DealName] = v.BaseFromTradeCffexIndexId
			existBuyMap[v.BuyName] = v.BaseFromTradeCffexIndexId
			existSoldMap[v.SoldName] = v.BaseFromTradeCffexIndexId
			sRank = fmt.Sprintf("%d", v.Rank)
			cffexActionCodeMap[sRank+v.ClassifyType] = map[string]int{"0": v.DealValue, "1": v.BuyValue, "2": v.SoldValue, "id": v.BaseFromTradeCffexIndexId}
		}
		shortNameColum := map[string]string{"0": "deal_short_name", "1": "buy_short_name", "2": "sold_short_name"}
		nameColum := map[string]string{"0": "deal_name", "1": "buy_name", "2": "sold_name"}
		codeColum := map[string]string{"0": "deal_code", "1": "buy_code", "2": "sold_code"}
		valueColum := map[string]string{"0": "deal_value", "1": "buy_value", "2": "sold_value"}
		changeColum := map[string]string{"0": "deal_change", "1": "buy_change", "2": "sold_change"}
		var dataName string
		var dataCode string

		var indexKey string
		for _, xmlItem := range xmlItems {
			for _, i := range xmlItem.Data {
				var item = new(models.BaseFromTradeCffexIndex)
				item.Rank = i.Rank
				switch i.Value {
				case "0":
					item.DealShortName = i.ShortName
					item.DealName = fmt.Sprintf("%s", i.ShortName+"_成交量_"+i.ContractCode)
					item.DealCode = cffexIndexCodeGenerator(item.DealName, "deal")
					item.DealValue = i.Volume
					item.DealChange = i.Varvolume

					dataName = item.DealName
					dataCode = item.DealCode
				case "1":
					item.BuyShortName = i.ShortName
					item.BuyName = fmt.Sprintf("%s", i.ShortName+"_持买单量_"+i.ContractCode)
					item.BuyCode = cffexIndexCodeGenerator(item.BuyName, "buy")
					item.BuyValue = i.Volume
					item.BuyChange = i.Varvolume

					dataName = item.BuyName
					dataCode = item.BuyCode
				case "2":
					item.SoldShortName = i.ShortName
					item.SoldName = fmt.Sprintf("%s", i.ShortName+"_持卖单量_"+i.ContractCode)
					item.SoldCode = cffexIndexCodeGenerator(item.SoldName, "sold")
					item.SoldValue = i.Volume
					item.SoldChange = i.Varvolume

					dataName = item.SoldName
					dataCode = item.SoldCode
				default:
					fmt.Println("No data value")
				}
				item.Frequency = "日度"
				item.ClassifyName = i.ProductId
				item.ClassifyType = i.ContractCode
				item.CreateTime = time.Now()
				item.ModifyTime = time.Now()
				item.DataTime = i.Tradingday

				valueMap := map[string]int{"0": item.DealValue, "1": item.BuyValue, "2": item.SoldValue}
				//检查在actionCodeMap中是否已经有了
				indexKey = fmt.Sprintf("%d", item.Rank) + item.ClassifyType
				if existMap, ok := cffexActionCodeMap[indexKey]; !ok {
					if _, ok := existDealMap[item.DealName]; !ok {
						if _, ok := existBuyMap[item.BuyName]; !ok {
							if _, ok := existSoldMap[item.SoldName]; !ok {
								//没有，新增
								newID, err := models.AddBaseFromTradeCffexIndex(item)
								if err != nil {
									fmt.Println("insert error:", err)
								}
								fmt.Println("insert new indexID:", newID)
								existMap = make(map[string]int)
								existMap[i.Value] = i.Volume
								existMap["id"] = int(newID)
								cffexActionCodeMap[indexKey] = existMap
							}
						}
					}
				} else if existMap != nil && existMap[i.Value] != i.Volume {
					//更新
					var columnList = [5]string{
						shortNameColum[i.Value],
						nameColum[i.Value],
						codeColum[i.Value],
						valueColum[i.Value],
						changeColum[i.Value],
					}
					var dataList = [5]interface{}{
						i.ShortName,
						dataName,
						dataCode,
						valueMap[i.Value],
						i.Varvolume,
					}
					err := models.ModifyBaseFromTradeCffexIndex(columnList, dataList, existMap["id"])
					if err != nil {
						fmt.Println("data update err:", err)
					}
					cffexActionCodeMap[indexKey][i.Value] = i.Volume
				}
			}
		}
	}
}

func GetXmlItem(url, contract string) *XmlItem {
	zzUrl := url + contract + ".xml"
	fmt.Println(zzUrl)
	body, err := http.Get(zzUrl)
	if err != nil {
		fmt.Println("err:", err)
	}
	xmlItem := new(XmlItem)
	err = xml.Unmarshal(body, &xmlItem)
	if err != nil {
		fmt.Println("xml.Unmarshal:", err.Error())
	}
	return xmlItem

}