eta_data_analysis/services/ruizide/processor_business_logic.go

// Package ruizide
// @Author gmy 2024/10/21 10:50:00
package ruizide

import (
	"encoding/json"
	"eta/eta_data_analysis/models"
	"eta/eta_data_analysis/utils"
	"fmt"
	"github.com/beego/beego/v2/core/logs"
	"math"
	"strconv"
	"strings"
	"unicode"
)

var classifyMap = map[string]string{
	"Road Index":                       "analytics library",
	"Road Active Fleet":                "analytics library",
	"Aviation Index":                   "analytics library",
	"Aviation Active Fleet":            "analytics library",
	"Demand-Gasoline":                  "analytics library",
	"Demand - Diesel":                  "analytics library",
	"Demand - Jet Fuel":                "analytics library",
	"Demand - Maritime Bunker":         "analytics library",
	"Oil_Demand_Signals_Weekly_Report": "analytics library",
	"cube dashboards":                  "cube dashboards",
	"Oil Market Cube":                  "Oil Market Cube",
}

// RoadIndexProcessor
// @Description: AnalyticsLibrary处理器
type RoadIndexProcessor struct{}

func (p *RoadIndexProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing AnalyticsLibrary...")
	if tableName == "Content" {
		return nil, nil
	}
	if rowIndex < 4 {
		return nil, nil
	}

	frequency := "日度"
	unit := "%"
	indexNameColOne := "Index"
	indexNameColTwo := "Index 7DMA"

	// step_1: 分类
	classifyId, err := dealClassify(tableName, sheetName)
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := sheetName + "/" + rowData[len(rowData)-3] + "/" + indexNameColOne
	indexNameTwo := sheetName + "/" + rowData[len(rowData)-3] + "/" + indexNameColTwo

	// 生成指标编码
	indexCodeOne, err := getIndexId(sheetName, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColOne)
	indexCodeTwo, err := getIndexId(sheetName, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColTwo)

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCodeOne] = indexNameOne
	indexInfoMap[indexCodeTwo] = indexNameTwo

	var indexInfoList []*models.IndexInfo
	valueOne, err := strconv.ParseFloat(rowData[len(rowData)-2], 64)
	if err != nil {
		return nil, err
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	valueTwo, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}
	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("dataList: %v", dataList)

	return dataList, err
}

// RoadActiveFleetProcessor
// @Description: RoadActiveFleetProcessor处理器
type RoadActiveFleetProcessor struct{}

func (p *RoadActiveFleetProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing RoadActiveFleet...")
	if tableName == "Content" {
		return nil, nil
	}
	if rowIndex < 4 {
		return nil, nil
	}

	frequency := "日度"
	unit := "辆"
	indexNameColOne := "Active Fleet"
	indexNameColTwo := "Active Fleet 7DMA"

	// step_1: 分类
	classifyId, err := dealClassify(tableName, sheetName)
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := sheetName + "/" + rowData[len(rowData)-3] + "/" + indexNameColOne
	indexNameTwo := sheetName + "/" + rowData[len(rowData)-3] + "/" + indexNameColTwo

	// 生成指标编码
	indexCodeOne, err := getIndexId(sheetName, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColOne)
	indexCodeTwo, err := getIndexId(sheetName, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColTwo)

	var indexInfoList []*models.IndexInfo
	valueOne, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
	if err != nil {
		return nil, err
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	valueTwo, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
	if err != nil {
		return nil, err
	}
	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("RoadActiveFleetProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("RoadActiveFleetProcessor dataList: %v", dataList)

	return dataList, err
}

// AviationIndexProcessor
// @Description: AviationIndexProcessor处理器
type AviationIndexProcessor struct{}

func (p *AviationIndexProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing AviationIndexProcessor...")
	if tableName == "Content" {
		return nil, nil
	}
	if rowIndex < 4 {
		return nil, nil
	}

	frequency := "日度"
	unit := "%"
	indexNameColOne := "Index"
	indexNameColTwo := "Index 7DMA"

	// step_1: 分类
	classifyId, err := dealClassify(tableName, sheetName)
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := sheetName + "/" + rowData[len(rowData)-3] + "/" + indexNameColOne
	indexNameTwo := sheetName + "/" + rowData[len(rowData)-3] + "/" + indexNameColTwo

	// 生成指标编码
	indexCodeOne, err := getIndexId(sheetName, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColOne)
	indexCodeTwo, err := getIndexId(sheetName, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColTwo)

	var indexInfoList []*models.IndexInfo
	valueOne, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
	if err != nil {
		return nil, err
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	valueTwo, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
	if err != nil {
		return nil, err
	}
	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("AviationIndexProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("AviationIndexProcessor dataList: %v", dataList)

	return dataList, err
}

// AviationActiveFleetProcessor
// @Description: AviationActiveFleetProcessor处理器
type AviationActiveFleetProcessor struct{}

func (p *AviationActiveFleetProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing AviationActiveFleetProcessor...")
	if tableName == "Content" {
		return nil, nil
	}
	if rowIndex < 4 {
		return nil, nil
	}

	frequency := "日度"
	unit := "辆"
	indexNameColOne := "Active Fleet"
	indexNameColTwo := "Active Fleet 7DMA"

	// step_1: 分类
	classifyId, err := dealClassify(tableName, sheetName)
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := sheetName + "/" + rowData[len(rowData)-3] + "/" + indexNameColOne
	indexNameTwo := sheetName + "/" + rowData[len(rowData)-3] + "/" + indexNameColTwo

	// 生成指标编码
	indexCodeOne, err := getIndexId(sheetName, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColOne)
	indexCodeTwo, err := getIndexId(sheetName, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColTwo)

	var indexInfoList []*models.IndexInfo
	valueOne, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
	if err != nil {
		return nil, err
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	valueTwo, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
	if err != nil {
		return nil, err
	}
	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("AviationActiveFleetProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("AviationActiveFleetProcessor dataList: %v", dataList)

	return dataList, err
}

// DemandGasolineProcessor
// @Description: DemandGasolineProcessor处理器
type DemandGasolineProcessor struct{}

func (p *DemandGasolineProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing DemandGasolineProcessor...")
	if tableName == "Content" {
		return nil, nil
	}
	if rowIndex < 4 {
		return nil, nil
	}

	frequency := "日度"
	unit := "千桶每天"
	indexNameColOne := "Demand"
	indexNameColTwo := "Demand 7DMA"

	// step_1: 分类
	classifyId, err := dealClassify(tableName, sheetName)
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := "Gasoline Demand" + "/" + rowData[len(rowData)-3] + "/" + indexNameColOne
	indexNameTwo := "Gasoline Demand" + "/" + rowData[len(rowData)-3] + "/" + indexNameColTwo

	// 生成指标编码
	indexCodeOne, err := getIndexId("Gasoline Demand", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColOne)
	indexCodeTwo, err := getIndexId("Gasoline Demand", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColTwo)

	var indexInfoList []*models.IndexInfo
	var valueOne float64
	if rowData[len(rowData)-2] == "" {
		valueOne = 0
	} else {
		valueOne, err = strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
		if err != nil {
			return nil, err
		}
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	var valueTwo float64
	if rowData[len(rowData)-1] == "" {
		valueTwo = 0
	} else {
		valueTwo, err = strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
		if err != nil {
			return nil, err
		}
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("DemandGasolineProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("DemandGasolineProcessor dataList: %v", dataList)

	return dataList, err
}

// DemandDieselProcessor
// @Description: DemandDieselProcessor处理器
type DemandDieselProcessor struct{}

func (p *DemandDieselProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing DemandDieselProcessor...")
	if tableName == "Content" {
		return nil, nil
	}
	if rowIndex < 4 {
		return nil, nil
	}

	frequency := "日度"
	unit := "千桶每天"
	indexNameColOne := "Demand"
	indexNameColTwo := "Demand 7DMA"

	// step_1: 分类
	classifyId, err := dealClassify(tableName, sheetName)
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := "Demand Diesel" + "/" + rowData[len(rowData)-3] + "/" + indexNameColOne
	indexNameTwo := "Demand Diesel" + "/" + rowData[len(rowData)-3] + "/" + indexNameColTwo

	// 生成指标编码
	indexCodeOne, err := getIndexId("Demand Diesel", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColOne)
	indexCodeTwo, err := getIndexId("Demand Diesel", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColTwo)

	var indexInfoList []*models.IndexInfo
	valueOne, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
	if err != nil {
		return nil, err
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	valueTwo, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
	if err != nil {
		return nil, err
	}
	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("DemandDieselProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("DemandDieselProcessor dataList: %v", dataList)

	return dataList, err
}

// DemandJetFuelProcessor
// @Description: DemandJetFuelProcessor处理器
type DemandJetFuelProcessor struct{}

func (p *DemandJetFuelProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing DemandJetFuelProcessor...")
	if tableName == "Content" {
		return nil, nil
	}
	if rowIndex < 4 {
		return nil, nil
	}

	frequency := "日度"
	unit := "千桶每天"
	indexNameColOne := "Demand"
	indexNameColTwo := "Demand 7DMA"

	// step_1: 分类
	classifyId, err := dealClassify(tableName, sheetName)
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := "Demand Jet Fuel" + "/" + rowData[len(rowData)-3] + "/" + indexNameColOne
	indexNameTwo := "Demand Jet Fuel" + "/" + rowData[len(rowData)-3] + "/" + indexNameColTwo

	// 生成指标编码
	indexCodeOne, err := getIndexId("Demand Jet Fuel", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColOne)
	indexCodeTwo, err := getIndexId("Demand Jet Fuel", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColTwo)

	var indexInfoList []*models.IndexInfo
	valueOne, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
	if err != nil {
		return nil, err
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	valueTwo, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
	if err != nil {
		return nil, err
	}
	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("DemandJetFuelProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("DemandJetFuelProcessor dataList: %v", dataList)

	return dataList, err
}

// DemandMaritimeBunkerProcessor
// @Description: DemandMaritimeBunkerProcessor处理器
type DemandMaritimeBunkerProcessor struct{}

func (p *DemandMaritimeBunkerProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing DemandMaritimeBunkerProcessor...")
	if tableName == "Content" {
		return nil, nil
	}
	if rowIndex < 4 {
		return nil, nil
	}

	frequency := "日度"
	unit := "千桶每天"
	indexNameColOne := "Demand"
	indexNameColTwo := "Demand 7DMA"

	// step_1: 分类
	classifyId, err := dealClassify(tableName, sheetName)
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := "Demand Maritime Bunker" + "/" + rowData[len(rowData)-3] + "/" + indexNameColOne
	indexNameTwo := "Demand Maritime Bunker" + "/" + rowData[len(rowData)-3] + "/" + indexNameColTwo

	// 生成指标编码
	indexCodeOne, err := getIndexId("Demand Maritime Bunker", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColOne)
	indexCodeTwo, err := getIndexId("Demand Maritime Bunker", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-3]), " ", ""), indexNameColTwo)

	var indexInfoList []*models.IndexInfo
	valueOne, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
	if err != nil {
		return nil, err
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	valueTwo, err := strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
	if err != nil {
		return nil, err
	}
	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("DemandMaritimeBunkerProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("DemandMaritimeBunkerProcessor dataList: %v", dataList)

	return dataList, err
}

// SupplyRevisionAnalysisChartOneProcessor
// @Description: SupplyRevisionAnalysisChartOneProcessor处理器
type SupplyRevisionAnalysisChartOneProcessor struct{}

func (p *SupplyRevisionAnalysisChartOneProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing SupplyRevisionAnalysisChartOne...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "季度"
	unit := "千桶每天"
	indexNameColSuffix := "YearQuarter"
	indexNameColPrefix := "Country Revision Group"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Supply Revision Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-1]

	// 生成指标编码
	indexCode, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix+" Year Quarter", strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-1]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	var value float64
	if rowData[len(rowData)-2] == "" {
		value = 0
	} else {
		value, err = strconv.ParseFloat(rowData[len(rowData)-2], 64)
		if err != nil {
			return nil, err
		}
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat2(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartOneProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartOneProcessor dataList: %v", dataList)

	return dataList, err
}

// SupplyRevisionAnalysisChartTwoProcessor
// @Description: SupplyRevisionAnalysisChartTwoProcessor处理器
type SupplyRevisionAnalysisChartTwoProcessor struct{}

func (p *SupplyRevisionAnalysisChartTwoProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing SupplyRevisionAnalysisChartTwoProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "季度"
	unit := "千桶每天"
	indexNameColPrefix := "YearQuarter"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Supply Revision Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + "Current"
	indexNameTwo := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + "Previous"

	// 生成指标编码
	indexCodeOne, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix, "Current", "")
	indexCodeTwo, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix, "Previous", "")

	var indexInfoList []*models.IndexInfo
	var valueOne float64
	if rowData[len(rowData)-2] == "" {
		valueOne = 0
	} else {
		valueOne, err = strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
		if err != nil {
			return nil, err
		}
	}

	dataTimeOne := rowData[1]
	formatOne, err := utils.ConvertDateFormat2(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	var valueTwo float64
	if rowData[len(rowData)-1] == "" {
		valueTwo = 0
	} else {
		valueTwo, err = strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
		if err != nil {
			return nil, err
		}
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartTwoProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartTwoProcessor dataList: %v", dataList)

	return dataList, err
}

// SupplyRevisionAnalysisChartThreeProcessor
// @Description: SupplyRevisionAnalysisChartThreeProcessor
type SupplyRevisionAnalysisChartThreeProcessor struct{}

func (p *SupplyRevisionAnalysisChartThreeProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing SupplyRevisionAnalysisChartThreeProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "年度"
	unit := "千桶每天"
	indexNameColSuffix := "Year"
	indexNameColPrefix := "Country Revision Group"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Supply Revision Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-1]

	// 生成指标编码
	indexCode, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix+" "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-1]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	var value float64
	if rowData[len(rowData)-2] == "" {
		value = 0
	} else {
		value, err = strconv.ParseFloat(rowData[len(rowData)-2], 64)
		if err != nil {
			return nil, err
		}
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat4(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartThreeProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartThreeProcessor dataList: %v", dataList)

	return dataList, err
}

// SupplyRevisionAnalysisChartFourProcessor
// @Description: SupplyRevisionAnalysisChartFourProcessor处理器
type SupplyRevisionAnalysisChartFourProcessor struct{}

func (p *SupplyRevisionAnalysisChartFourProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing SupplyRevisionAnalysisChartFourProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "年度"
	unit := "千桶每天"
	indexNameColPrefix := "Year"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Supply Revision Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + "Current"
	indexNameTwo := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + "Previous"

	// 生成指标编码
	indexCodeOne, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix, "current", "")
	indexCodeTwo, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix, "previous", "")

	var indexInfoList []*models.IndexInfo
	var valueOne float64
	if rowData[len(rowData)-2] == "" {
		valueOne = 0
	} else {
		valueOne, err = strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
		if err != nil {
			return nil, err
		}
	}

	dataTimeOne := rowData[0]
	formatOne, err := utils.ConvertDateFormat4(dataTimeOne)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	var valueTwo float64
	if rowData[len(rowData)-1] == "" {
		valueTwo = 0
	} else {
		valueTwo, err = strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-1], ",", ""), 64)
		if err != nil {
			return nil, err
		}
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartFourProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartFourProcessor dataList: %v", dataList)

	return dataList, err
}

// SupplyRevisionAnalysisChartFiveProcessor
// @Description: SupplyRevisionAnalysisChartFiveProcessor处理器
type SupplyRevisionAnalysisChartFiveProcessor struct{}

func (p *SupplyRevisionAnalysisChartFiveProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing SupplyRevisionAnalysisChartFiveProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColPrefix := "YearMonth"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Supply Revision Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexNameOne := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + "Current/Chat5"
	indexNameTwo := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + "Previous/Chat5"

	// 生成指标编码
	indexCodeOne, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix, "currentchat5", "")
	indexCodeTwo, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix, "previouschat5", "")

	var indexInfoList []*models.IndexInfo
	var valueOne float64
	if rowData[len(rowData)-2] == "" {
		valueOne = 0
	} else {
		valueOne, err = strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-2], ",", ""), 64)
		if err != nil {
			return nil, err
		}
	}

	dataTimeOne := rowData[len(rowData)-1]
	timeSplit := strings.Split(dataTimeOne, "-")
	formatOne, err := utils.GetLastDayOfMonth(timeSplit[0] + "-" + timeSplit[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameOne,
		IndexCode: indexCodeOne,
		Value:     valueOne,
		DataTime:  formatOne,
	})
	var valueTwo float64
	if rowData[len(rowData)-3] == "" {
		valueTwo = 0
	} else {
		valueTwo, err = strconv.ParseFloat(strings.ReplaceAll(rowData[len(rowData)-3], ",", ""), 64)
		if err != nil {
			return nil, err
		}
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexNameTwo,
		IndexCode: indexCodeTwo,
		Value:     valueTwo,
		DataTime:  formatOne,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartFiveProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartFiveProcessor dataList: %v", dataList)

	return dataList, err
}

// SupplyRevisionAnalysisChartSixProcessor
// @Description: SupplyRevisionAnalysisChartSixProcessor
type SupplyRevisionAnalysisChartSixProcessor struct{}

func (p *SupplyRevisionAnalysisChartSixProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing SupplyRevisionAnalysisChartSixProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "YearMonth"
	indexNameColPrefix := "Country Revision Group"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Supply Revision Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Supply Revision Analysis" + "/" + indexNameColPrefix + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Supply Revision Analysis "+indexNameColPrefix+" "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	var value float64
	if rowData[len(rowData)-1] == "" {
		value = 0
	} else {
		value, err = strconv.ParseFloat(rowData[len(rowData)-1], 64)
		if err != nil {
			return nil, err
		}
	}

	dataTime := rowData[0]
	timeSplit := strings.Split(dataTime, "-")
	format, err := utils.GetLastDayOfMonth(timeSplit[0] + "-" + timeSplit[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartSixProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("SupplyRevisionAnalysisChartSixProcessor dataList: %v", dataList)

	return dataList, err
}

// OilSupplyAnalysisChartOneProcessor
// @Description: OilSupplyAnalysisChartOneProcessor处理器
type OilSupplyAnalysisChartOneProcessor struct{}

func (p *OilSupplyAnalysisChartOneProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilSupplyAnalysisChartOne...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Oil And Gas Category"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Supply Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Supply Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Supply Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilSupplyAnalysisChartOneProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilSupplyAnalysisChartOneProcessor dataList: %v", dataList)

	return dataList, err
}

// OilSupplyAnalysisChartTwoProcessor
// @Description: OilSupplyAnalysisChartTwoProcessor处理器
type OilSupplyAnalysisChartTwoProcessor struct{}

func (p *OilSupplyAnalysisChartTwoProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilSupplyAnalysisChartTwoProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Region"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Supply Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Supply Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-1]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Supply Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-1]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-2], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilSupplyAnalysisChartTwoProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilSupplyAnalysisChartTwoProcessor dataList: %v", dataList)

	return dataList, err
}

// OilSupplyAnalysisChartThreeProcessor
// @Description: OilSupplyAnalysisChartThreeProcessor处理器
type OilSupplyAnalysisChartThreeProcessor struct{}

func (p *OilSupplyAnalysisChartThreeProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilSupplyAnalysisChartThreeProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "CapacityDetail"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Supply Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Supply Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Supply Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilSupplyAnalysisChartThreeProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilSupplyAnalysisChartThreeProcessor dataList: %v", dataList)

	return dataList, err
}

// OilSupplyAnalysisChartFourProcessor
// @Description: OilSupplyAnalysisChartFourProcessor处理器
type OilSupplyAnalysisChartFourProcessor struct{}

func (p *OilSupplyAnalysisChartFourProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilSupplyAnalysisChartFourProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Oil Classification Group"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Supply Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Supply Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Supply Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilSupplyAnalysisChartFourProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilSupplyAnalysisChartFourProcessor dataList: %v", dataList)

	return dataList, err
}

// OilDemandAnalysisContinentProcessor
// @Description: OilDemandAnalysisContinentProcessor处理器
type OilDemandAnalysisContinentProcessor struct{}

func (p *OilDemandAnalysisContinentProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilDemandAnalysisContinentProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Continent"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Demand Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Demand Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Demand Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisContinentProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisContinentProcessor dataList: %v", dataList)

	return dataList, err
}

// OilDemandAnalysisRegionProcessor
// @Description: OilDemandAnalysisRegionProcessor处理器
type OilDemandAnalysisRegionProcessor struct{}

func (p *OilDemandAnalysisRegionProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilDemandAnalysisRegionProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Region"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Demand Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Demand Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Demand Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisRegionProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisRegionProcessor dataList: %v", dataList)

	return dataList, err
}

// OilDemandAnalysisCountryProcessor
// @Description: OilDemandAnalysisCountryProcessor
type OilDemandAnalysisCountryProcessor struct{}

func (p *OilDemandAnalysisCountryProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilDemandAnalysisCountryProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Country"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Demand Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Demand Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Demand Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisCountryProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisCountryProcessor dataList: %v", dataList)

	return dataList, err
}

// OilDemandAnalysisProductCategoryProcessor
// @Description: OilDemandAnalysisProductCategoryProcessor处理器
type OilDemandAnalysisProductCategoryProcessor struct{}

func (p *OilDemandAnalysisProductCategoryProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilDemandAnalysisProductCategoryProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Product category"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Demand Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Demand Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Demand Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisProductCategoryProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisProductCategoryProcessor dataList: %v", dataList)

	return dataList, err
}

// OilDemandAnalysisProductDetailProcessor
// @Description: OilDemandAnalysisProductDetailProcessor处理器
type OilDemandAnalysisProductDetailProcessor struct{}

func (p *OilDemandAnalysisProductDetailProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilDemandAnalysisProductDetailProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Product detail"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Demand Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Demand Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Demand Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisProductDetailProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisProductDetailProcessor dataList: %v", dataList)

	return dataList, err
}

// OilDemandAnalysisSectorCategoryProcessor
// @Description: OilDemandAnalysisSectorCategoryProcessor处理器
type OilDemandAnalysisSectorCategoryProcessor struct{}

func (p *OilDemandAnalysisSectorCategoryProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilDemandAnalysisSectorCategoryProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Sector category"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Demand Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Demand Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Demand Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisSectorCategoryProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisSectorCategoryProcessor dataList: %v", dataList)

	return dataList, err
}

// OilDemandAnalysisSectorDetailProcessor
// @Description: OilDemandAnalysisSectorDetailProcessor处理器
type OilDemandAnalysisSectorDetailProcessor struct{}

func (p *OilDemandAnalysisSectorDetailProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilDemandAnalysisSectorDetailProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Sector detail"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Demand Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Demand Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Demand Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisSectorDetailProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisSectorDetailProcessor dataList: %v", dataList)

	return dataList, err
}

// OilDemandAnalysisScenarioProcessor
// @Description: OilDemandAnalysisScenarioProcessor处理器
type OilDemandAnalysisScenarioProcessor struct{}

func (p *OilDemandAnalysisScenarioProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilDemandAnalysisScenarioProcessor...")
	if rowIndex < 1 {
		return nil, nil
	}

	frequency := "月度"
	unit := "千桶每天"
	indexNameColSuffix := "Scenario"
	//indexNameColPrefix := "CountryRevisionGroup"

	// step_1: 分类
	classifyId, err := dealClassify("cube dashboards", "Oil Demand Analysis")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Oil Demand Analysis" + "/" + indexNameColSuffix + "/" + rowData[len(rowData)-2]

	// 生成指标编码
	indexCode, err := getIndexId("Oil Demand Analysis "+indexNameColSuffix, strings.ReplaceAll(strings.ToLower(rowData[len(rowData)-2]), " ", ""), "")

	indexInfoMap := make(map[string]string)
	indexInfoMap[indexCode] = indexName

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat3(dataTime)
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisScenarioProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilDemandAnalysisScenarioProcessor dataList: %v", dataList)

	return dataList, err
}

// UpstreamSupplyOilQualityApiProcessor
// @Description: UpstreamSupplyOilQualityApiProcessor处理器
type UpstreamSupplyOilQualityApiProcessor struct{}

var rzdApiFlag string

func (p *UpstreamSupplyOilQualityApiProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing UpstreamSupplyOilQualityApiProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdApiFlag = rowData[0]
	} else {
		rowData[0] = rzdApiFlag
	}

	frequency := "月度"
	unit := "°"
	indexNameColSuffix := "Oil Quality"
	//indexNameColPrefix := "CountryRevisionGroup"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColSuffix + "/" + "API"

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply "+indexNameColSuffix, strings.ToLower("API"), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOilQualityApiProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOilQualityApiProcessor dataList: %v", dataList)

	return dataList, err
}

// OilMarketCubeUpstreamSupplyOilQualitySulphurProcessor
// @Description: OilMarketCubeUpstreamSupplyOilQualitySulphurProcessor处理器
type OilMarketCubeUpstreamSupplyOilQualitySulphurProcessor struct{}

var rzdSulphurFlag string

func (p *OilMarketCubeUpstreamSupplyOilQualitySulphurProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilMarketCubeUpstreamSupplyOilQualitySulphurProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdSulphurFlag = rowData[0]
	} else {
		rowData[0] = rzdSulphurFlag
	}

	frequency := "月度"
	unit := "%wt"
	indexNameColSuffix := "Oil Quality"
	//indexNameColPrefix := "CountryRevisionGroup"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColSuffix + "/" + "Sulphur"

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply "+indexNameColSuffix, strings.ToLower("Sulphur"), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilMarketCubeUpstreamSupplyOilQualitySulphurProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilMarketCubeUpstreamSupplyOilQualitySulphurProcessor dataList: %v", dataList)

	return dataList, err
}

// OilMarketCubeUpstreamSupplyCapacityCapacityProcessor
// @Description: OilMarketCubeUpstreamSupplyCapacityCapacityProcessor处理器
type OilMarketCubeUpstreamSupplyCapacityCapacityProcessor struct{}

var rzdCapacityFlag string

func (p *OilMarketCubeUpstreamSupplyCapacityCapacityProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilMarketCubeUpstreamSupplyCapacityCapacityProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdCapacityFlag = rowData[0]
	} else {
		rowData[0] = rzdCapacityFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColSuffix := "Capacity"
	//indexNameColPrefix := "CountryRevisionGroup"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply ", strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilMarketCubeUpstreamSupplyCapacityCapacityProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilMarketCubeUpstreamSupplyCapacityCapacityProcessor dataList: %v", dataList)

	return dataList, err
}

// OilMarketCubeUpstreamSupplyProductionProcessor
// @Description: OilMarketCubeUpstreamSupplyProductionProcessor处理器
type OilMarketCubeUpstreamSupplyProductionProcessor struct{}

var rzdProductionFlag string

func (p *OilMarketCubeUpstreamSupplyProductionProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing OilMarketCubeUpstreamSupplyProductionProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdProductionFlag = rowData[0]
	} else {
		rowData[0] = rzdProductionFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColSuffix := "Production"
	//indexNameColPrefix := "CountryRevisionGroup"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply", strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("OilMarketCubeUpstreamSupplyProductionProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("OilMarketCubeUpstreamSupplyProductionProcessor dataList: %v", dataList)

	return dataList, err
}

// UpstreamSupplyProductionWoSeasonalityProcessor
// @Description: UpstreamSupplyProductionWoSeasonalityProcessor处理器
type UpstreamSupplyProductionWoSeasonalityProcessor struct{}

var rzdProductionWoSeasonalityFlag string

func (p *UpstreamSupplyProductionWoSeasonalityProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing UpstreamSupplyProductionWoSeasonalityProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdProductionWoSeasonalityFlag = rowData[0]
	} else {
		rowData[0] = rzdProductionWoSeasonalityFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColSuffix := "Production Wo Seasonality"
	//indexNameColPrefix := "CountryRevisionGroup"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply", strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyProductionWoSeasonalityProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyProductionWoSeasonalityProcessor dataList: %v", dataList)

	return dataList, err
}

// UpstreamSupplyOPECPolicyReferenceProductionProcessor
// @Description: UpstreamSupplyOPECPolicyReferenceProductionProcessor处理器
type UpstreamSupplyOPECPolicyReferenceProductionProcessor struct{}

var rzdReferenceProductionFlag string

func (p *UpstreamSupplyOPECPolicyReferenceProductionProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing UpstreamSupplyOPECPolicyReferenceProductionProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdReferenceProductionFlag = rowData[0]
	} else {
		rowData[0] = rzdReferenceProductionFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Reference Production"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColPrefix + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply "+indexNameColPrefix, strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyReferenceProductionProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyReferenceProductionProcessor dataList: %v", dataList)

	return dataList, err
}

// UpstreamSupplyOPECPolicyTargetProductionProcessor
// @Description: UpstreamSupplyOPECPolicyTargetProductionProcessor处理器
type UpstreamSupplyOPECPolicyTargetProductionProcessor struct{}

var rzdTargetProductionFlag string

func (p *UpstreamSupplyOPECPolicyTargetProductionProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing UpstreamSupplyOPECPolicyTargetProductionProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdTargetProductionFlag = rowData[0]
	} else {
		rowData[0] = rzdTargetProductionFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Target Production"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColPrefix + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply "+indexNameColPrefix, strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyTargetProductionProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyTargetProductionProcessor dataList: %v", dataList)

	return dataList, err
}

// UpstreamSupplyOPECPolicyTargetCutProcessor
// @Description: UpstreamSupplyOPECPolicyTargetCutProcessor处理器
type UpstreamSupplyOPECPolicyTargetCutProcessor struct{}

var rzdTargetCutFlag string

func (p *UpstreamSupplyOPECPolicyTargetCutProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing UpstreamSupplyOPECPolicyTargetCutProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdTargetCutFlag = rowData[0]
	} else {
		rowData[0] = rzdTargetCutFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Target Cut"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColPrefix + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply "+indexNameColPrefix, strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyTargetCutProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyTargetCutProcessor dataList: %v", dataList)

	return dataList, err
}

// UpstreamSupplyOPECPolicyActualCutProcessor
// @Description: UpstreamSupplyOPECPolicyActualCutProcessor处理器
type UpstreamSupplyOPECPolicyActualCutProcessor struct{}

var rzdActualCutFlag string

func (p *UpstreamSupplyOPECPolicyActualCutProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing UpstreamSupplyOPECPolicyActualCutProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdActualCutFlag = rowData[0]
	} else {
		rowData[0] = rzdActualCutFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Actual Cut"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColPrefix + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply "+indexNameColPrefix, strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyActualCutProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyActualCutProcessor dataList: %v", dataList)

	return dataList, err
}

// UpstreamSupplyOPECPolicyComplianceProcessor
// @Description: UpstreamSupplyOPECPolicyComplianceProcessor处理器
type UpstreamSupplyOPECPolicyComplianceProcessor struct{}

var rzdComplianceFlag string

func (p *UpstreamSupplyOPECPolicyComplianceProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing UpstreamSupplyOPECPolicyComplianceProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdComplianceFlag = rowData[0]
	} else {
		rowData[0] = rzdComplianceFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Compliance"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColPrefix + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply "+indexNameColPrefix, strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyComplianceProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyComplianceProcessor dataList: %v", dataList)

	return dataList, err
}

// UpstreamSupplyOPECPolicyProductionSubjectToCutProcessor
// @Description: UpstreamSupplyOPECPolicyProductionSubjectToCutProcessor处理器
type UpstreamSupplyOPECPolicyProductionSubjectToCutProcessor struct{}

var rzdProductionSubjectToCutFlag string

func (p *UpstreamSupplyOPECPolicyProductionSubjectToCutProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing UpstreamSupplyOPECPolicyProductionSubjectToCutProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdProductionSubjectToCutFlag = rowData[0]
	} else {
		rowData[0] = rzdProductionSubjectToCutFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Production Subject To Cut"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Upstream Supply")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Upstream Supply" + "/" + indexNameColPrefix + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Upstream Supply "+indexNameColPrefix, strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyProductionSubjectToCutProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("UpstreamSupplyOPECPolicyProductionSubjectToCutProcessor dataList: %v", dataList)

	return dataList, err
}

// ProductsDemandProductsDemandMeanProcessor
// @Description: ProductsDemandProductsDemandMeanProcessor处理器
type ProductsDemandProductsDemandMeanProcessor struct{}

var rzdProductsDemandMeanFlag string

func (p *ProductsDemandProductsDemandMeanProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing ProductsDemandProductsDemandMeanProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdProductsDemandMeanFlag = rowData[0]
	} else {
		rowData[0] = rzdProductsDemandMeanFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	//indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Products Demand Mean (1.0 DG) "

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Products Demand")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Products Demand" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Products Demand "+"Products Demand Mean", strings.ReplaceAll(strings.ToLower("1.0dg"), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("ProductsDemandProductsDemandMeanProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("ProductsDemandProductsDemandMeanProcessor dataList: %v", dataList)

	return dataList, err
}

// ProductsDemandProductsDemandAddSigmaProcessor
// @Description: ProductsDemandProductsDemandAddSigmaProcessor处理器
type ProductsDemandProductsDemandAddSigmaProcessor struct{}

var rzdAddSigmaFlag string

func (p *ProductsDemandProductsDemandAddSigmaProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing ProductsDemandProductsDemandAddSigmaProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdAddSigmaFlag = rowData[0]
	} else {
		rowData[0] = rzdAddSigmaFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	//indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Products Demand +Sigma (2.2 DG) "

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Products Demand")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Products Demand" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Products Demand "+"Products Demand Sigma", strings.ReplaceAll(strings.ToLower("2.2dg"), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("ProductsDemandProductsDemandAddSigmaProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("ProductsDemandProductsDemandAddSigmaProcessor dataList: %v", dataList)

	return dataList, err
}

// ProductsDemandProductsDemandSubSigmaProcessor
// @Description: ProductsDemandProductsDemandSubSigmaProcessor处理器
type ProductsDemandProductsDemandSubSigmaProcessor struct{}

var rzdSubSigmaFlag string

func (p *ProductsDemandProductsDemandSubSigmaProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing ProductsDemandProductsDemandSubSigmaProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdSubSigmaFlag = rowData[0]
	} else {
		rowData[0] = rzdSubSigmaFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	//indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Products Demand -Sigma (1.8 DG) "

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Products Demand")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Products Demand" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Products Demand "+"Products Demand Sigma", strings.ReplaceAll(strings.ToLower("1.8dg"), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("ProductsDemandProductsDemandSubSigmaProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("ProductsDemandProductsDemandSubSigmaProcessor dataList: %v", dataList)

	return dataList, err
}

// BalancesTotalLiquidsBalancesProcessor
// @Description: BalancesTotalLiquidsBalancesProcessor处理器
type BalancesTotalLiquidsBalancesProcessor struct{}

var rzdTotalLiquidsBalancesFlag string

func (p *BalancesTotalLiquidsBalancesProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing BalancesTotalLiquidsBalancesProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdTotalLiquidsBalancesFlag = rowData[0]
	} else {
		rowData[0] = rzdTotalLiquidsBalancesFlag
	}

	frequency := "月度"
	unit := "kbbl/d"
	//indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Total Liquids Balances"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Balances")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Balances" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Balances", strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("BalancesTotalLiquidsBalancesProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("BalancesTotalLiquidsBalancesProcessor dataList: %v", dataList)

	return dataList, err
}

// GeographyLatitudeProcessor
// @Description: GeographyLatitudeProcessor处理器
type GeographyLatitudeProcessor struct{}

var rzdLatitudeFlag string

func (p *GeographyLatitudeProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing GeographyLatitudeProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdLatitudeFlag = rowData[0]
	} else {
		rowData[0] = rzdLatitudeFlag
	}

	frequency := "月度"
	unit := ""
	//indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Latitude"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Geography")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Geography" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Geography", strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("GeographyLatitudeProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("GeographyLatitudeProcessor dataList: %v", dataList)

	return dataList, err
}

// GeographyLongitudeProcessor
// @Description: GeographyLongitudeProcessor处理器
type GeographyLongitudeProcessor struct{}

var rzdLongitudeFlag string

func (p *GeographyLongitudeProcessor) Process(tableName string, sheetName string, rowIndex int, rowData []string) ([]models.BaseFromRzdData, error) {
	logs.Info("Processing GeographyLongitudeProcessor...")
	if rowIndex <= 1 {
		return nil, nil
	}

	if rowData[0] != "" {
		rzdLongitudeFlag = rowData[0]
	} else {
		rowData[0] = rzdLongitudeFlag
	}

	frequency := "月度"
	unit := ""
	//indexNameColPrefix := "OPEC_Policy"
	indexNameColSuffix := "Longitude"

	if !utils.IsNumeric(rowData[0]) {
		return nil, nil
	}
	if rowData[1] == "Sum" {
		return nil, nil
	}

	// step_1: 分类
	classifyId, err := dealClassify("Oil Market Cube", "Geography")
	if err != nil {
		return nil, err
	}
	logs.Info("classifyId: %v", classifyId)

	// step_2: 指标
	// 指标名称
	indexName := "Geography" + "/" + indexNameColSuffix

	// 生成指标编码
	indexCode, err := getIndexId("Geography", strings.ReplaceAll(strings.ToLower(indexNameColSuffix), " ", ""), "")

	var indexInfoList []*models.IndexInfo
	value, err := strconv.ParseFloat(rowData[len(rowData)-1], 64)
	if err != nil {
		return nil, err
	}

	dataTime := rowData[0]
	format, err := utils.ConvertDateFormat6(dataTime + "-" + rowData[1])
	if err != nil {
		return nil, err
	}

	indexInfoList = append(indexInfoList, &models.IndexInfo{
		IndexName: indexName,
		IndexCode: indexCode,
		Value:     value,
		DataTime:  format,
	})

	indexInfoList, err = dealIndex(indexInfoList, frequency, unit, classifyId)
	if err != nil {
		return nil, err
	}
	logs.Info("GeographyLongitudeProcessor indexInfoList: %v", indexInfoList)

	// step_3: 指标数据
	dataList, err := dealData(indexInfoList)
	if err != nil {
		return nil, err
	}
	logs.Info("GeographyLongitudeProcessor dataList: %v", dataList)

	return dataList, err
}

func dealData(indexInfoList []*models.IndexInfo) ([]models.BaseFromRzdData, error) {
	var dataList []models.BaseFromRzdData
	for _, indexInfo := range indexInfoList {
		paramsLib := make(map[string]interface{})
		paramsLib["IndexCode"] = indexInfo.IndexCode
		paramsLib["DataTime"] = indexInfo.DataTime
		postEdbLib, err := httpRequestFill(paramsLib, utils.GET_RZD_INDEX_DATA_BY_CODE_AND_TIME)
		if err != nil {
			return nil, err
		}
		var requestResponse models.RequestResponse[models.BaseFromRzdData]
		err = json.Unmarshal(postEdbLib, &requestResponse)
		if err != nil {
			return nil, err
		}
		if requestResponse.Data.BaseFromRzdIndexId == 0 {
			dataOne := models.BaseFromRzdData{
				BaseFromRzdIndexId: indexInfo.IndexInfoId,
				CreateTime:         utils.GetCurrentTime(),
				DataTime:           indexInfo.DataTime,
				IndexCode:          indexInfo.IndexCode,
				ModifyTime:         utils.GetCurrentTime(),
				Value:              math.Round(indexInfo.Value*10000) / 10000,
			}
			dataList = append(dataList, dataOne)
		} else {
			// 编辑
			value := math.Round(indexInfo.Value*10000) / 10000
			if requestResponse.Data.Value != value {
				rzdData := requestResponse.Data
				rzdData.Value = value

				_, err = httpRequestFill(rzdData, utils.UPDATE_RZD_EDB_DATA)
				if err != nil {
					return nil, err
				}
			}
		}
	}

	return dataList, nil
}

func dealIndex(indexInfoList []*models.IndexInfo, frequency string, unit string, classifyId int) ([]*models.IndexInfo, error) {
	for _, index := range indexInfoList {
		// 处理第一个指标
		paramsLib := make(map[string]interface{})
		paramsLib["indexCode"] = index.IndexCode
		postEdbLib, err := httpRequestFill(paramsLib, utils.GET_RZD_INDEX_BY_CODE)
		if err != nil {
			return nil, fmt.Errorf("getIndexId() : Failed to get rzd index by code: %v", err)
		}
		var requestResponse models.RequestResponse[models.BaseFromRzdIndex]
		err = json.Unmarshal(postEdbLib, &requestResponse)
		if err != nil {
			return nil, err
		}
		if requestResponse.Data.BaseFromRzdIndexId == 0 {
			indexOne := models.BaseFromRzdIndex{
				CreateTime:           utils.GetCurrentTime(),
				ModifyTime:           utils.GetCurrentTime(),
				BaseFromLyClassifyId: classifyId,
				IndexCode:            index.IndexCode,
				IndexName:            index.IndexName,
				Frequency:            frequency,
				Unit:                 unit,
			}
			// 这里避免服务器宕机 出现唯一索引异常，进行分开保存
			postEdbLib, err = httpRequestFill(indexOne, utils.ADD_RZD_INDEX)
			if err != nil {
				return nil, fmt.Errorf("getIndexId() : Failed to get rzd index by code: %v", err)
			}
			var requestResponse models.RequestResponse[int]
			err = json.Unmarshal(postEdbLib, &requestResponse)
			if err != nil {
				return nil, err
			}
			logs.Info("indexOneId: %v", requestResponse.Data)

			index.IndexInfoId = requestResponse.Data
		} else {
			logs.Info("indexOneId: %v", requestResponse.Data.BaseFromRzdIndexId)
			index.IndexInfoId = requestResponse.Data.BaseFromRzdIndexId
		}
	}
	return indexInfoList, nil
}

func getIndexId(prefix string, area string, suffix string) (string, error) {
	prefixWords := strings.Fields(prefix) // 分割字符串为单词
	firstLetters := ""

	for _, word := range prefixWords {
		if len(word) > 0 {
			firstLetters += string(unicode.ToLower(rune(word[0]))) // 获取小写的第一个字母
		}
	}

	suffixWords := strings.Fields(suffix) // 分割字符串为单词
	SecondLetters := ""

	for _, word := range suffixWords {
		if len(word) > 0 {
			SecondLetters += string(unicode.ToLower(rune(word[0]))) // 获取小写的第一个字母
		}
	}
	indexCode := "rzd" + firstLetters + area + SecondLetters

	return indexCode, nil
}

// 处理分类
func dealClassify(tableName, sheetName string) (int, error) {
	// 查询一级分类是否存在
	paramsLib := make(map[string]interface{})
	paramsLib["classifyName"] = classifyMap[tableName]
	postEdbLib, err := httpRequestFill(paramsLib, utils.GET_RZD_CLASSIFY_BY_NAME)
	if err != nil {
		return 0, fmt.Errorf("AnalyticsLibraryProcessor Process() : failed to get classify: %v", err)
	}
	var requestResponse models.RequestResponse[models.BaseFromRzdClassify]
	err = json.Unmarshal(postEdbLib, &requestResponse)
	if err != nil {
		return 0, err
	}

	// 处理一级分类
	var parentId int
	if requestResponse.Data.BaseFromRzdClassifyId == 0 {
		// 一级分类不存在，新增一级分类
		paramsLib = make(map[string]interface{})
		paramsLib["parentId"] = 0
		paramsLib["classifyName"] = classifyMap[tableName]
		postEdbLib, err = httpRequestFill(paramsLib, utils.ADD_RZD_CLASSIFY)
		if err != nil {
			return 0, fmt.Errorf("AnalyticsLibraryProcessor Process() : failed to add classify: %v", err)
		}
		var requestResponse models.RequestResponse[int]
		err = json.Unmarshal(postEdbLib, &requestResponse)
		if err != nil {
			return 0, err
		}
		parentId = requestResponse.Data
	} else {
		// 一级分类已存在，使用其 ID
		parentId = requestResponse.Data.BaseFromRzdClassifyId
	}
	// 查询二级分类是否存在
	paramsSubLib := make(map[string]interface{})
	paramsSubLib["classifyName"] = sheetName // 这里替换成实际的二级分类名称
	postSubEdbLib, err := httpRequestFill(paramsSubLib, utils.GET_RZD_CLASSIFY_BY_NAME)
	if err != nil {
		return 0, fmt.Errorf("AnalyticsLibraryProcessor Process() : failed to get sub classify: %v", err)
	}

	var subRequestResponse models.RequestResponse[models.BaseFromRzdClassify]
	err = json.Unmarshal(postSubEdbLib, &subRequestResponse)
	if err != nil {
		return 0, err
	}

	// 新增二级分类
	var classifyId int
	if subRequestResponse.Data.BaseFromRzdClassifyId == 0 {
		paramsLib = make(map[string]interface{})
		paramsLib["parentId"] = parentId
		paramsLib["classifyName"] = sheetName
		postEdbLib, err = httpRequestFill(paramsLib, utils.ADD_RZD_CLASSIFY)
		if err != nil {
			return 0, fmt.Errorf("AnalyticsLibraryProcessor Process() : failed to add classify: %v", err)
		}
		var requestResponse models.RequestResponse[int]
		err = json.Unmarshal(postEdbLib, &requestResponse)
		if err != nil {
			return 0, err
		}
		classifyId = requestResponse.Data
	} else {
		classifyId = subRequestResponse.Data.BaseFromRzdClassifyId
	}

	return classifyId, nil
}