func (d *DataContext) setConnectionFromConfigFile(name string) error {
d.ConnectionName = name
if d.ConnectionName == "" {
d.ConnectionName = fmt.Sprintf("Default")
}
connType := strings.ToLower(config.Get("Connection_" + d.ConnectionName + "_Type").(string))
host := config.Get("Connection_" + d.ConnectionName + "_Host").(string)
username := config.Get("Connection_" + d.ConnectionName + "_Username").(string)
password := config.Get("Connection_" + d.ConnectionName + "_Password").(string)
database := config.Get("Connection_" + d.ConnectionName + "_database").(string)
ci := new(dbox.ConnectionInfo)
ci.Host = host
ci.UserName = username
ci.Password = password
ci.Database = database
conn, eConnect := dbox.NewConnection(connType, ci)
if eConnect != nil {
return err.Error(packageName, modCtx, "SetConnectionFromConfigFile", eConnect.Error())
}
if eConnect = conn.Connect(); eConnect != nil {
return err.Error(packageName, modCtx, "SetConnectionFromConfigFile", eConnect.Error())
}
d.Connection = conn
return nil
}
func GrabHtmlConfig(data toolkit.M) (*sdt.GrabService, error) {
var e error
var gi, ti time.Duration
xGrabService := sdt.NewGrabService()
xGrabService.Name = data["nameid"].(string) //"irondcecom"
xGrabService.Url = data["url"].(string) //"http://www.dce.com.cn/PublicWeb/MainServlet"
xGrabService.SourceType = sdt.SourceType_HttpHtml
grabintervalToInt := toolkit.ToInt(data["grabinterval"], toolkit.RoundingAuto)
timeintervalToInt := toolkit.ToInt(data["timeoutinterval"], toolkit.RoundingAuto)
if data["intervaltype"].(string) == "seconds" {
gi = time.Duration(grabintervalToInt) * time.Second
ti = time.Duration(timeintervalToInt) * time.Second
} else if data["intervaltype"].(string) == "minutes" {
gi = time.Duration(grabintervalToInt) * time.Minute
ti = time.Duration(timeintervalToInt) * time.Minute
} else if data["intervaltype"].(string) == "hours" {
gi = time.Duration(grabintervalToInt) * time.Hour
ti = time.Duration(timeintervalToInt) * time.Hour
}
xGrabService.GrabInterval = gi //* time.Minute
xGrabService.TimeOutInterval = ti //* time.Minute //time.Hour, time.Minute, time.Second
xGrabService.TimeOutIntervalInfo = fmt.Sprintf("%v %s", timeintervalToInt, data["intervaltype"] /*"seconds"*/)
grabConfig := sdt.Config{}
if data["calltype"].(string) == "POST" {
dataurl := toolkit.M{}
for _, grabconf := range data["grabconf"].(map[string]interface{}) {
grabDataConf, e := toolkit.ToM(grabconf)
if e != nil {
return nil, e
}
for key, subGrabDataConf := range grabDataConf {
if reflect.ValueOf(subGrabDataConf).Kind() == reflect.Float64 {
i := toolkit.ToInt(subGrabDataConf, toolkit.RoundingAuto)
toString := strconv.Itoa(i)
dataurl[key] = toString
} else {
dataurl[key] = subGrabDataConf
}
}
}
grabConfig.SetFormValues(dataurl)
}
grabDataConf, e := toolkit.ToM(data["grabconf"])
if e != nil {
return nil, e
}
isAuthType := grabDataConf.Has("authtype")
if isAuthType {
grabConfig.AuthType = grabDataConf["authtype"].(string)
grabConfig.LoginUrl = grabDataConf["loginurl"].(string) //"http://localhost:8000/login"
grabConfig.LogoutUrl = grabDataConf["logouturl"].(string) //"http://localhost:8000/logout"
grabConfig.LoginValues = toolkit.M{}.
Set("name", grabDataConf["loginvalues"].(map[string]interface{})["name"].(string)).
Set("password", grabDataConf["loginvalues"].(map[string]interface{})["password"].(string))
}
xGrabService.ServGrabber = sdt.NewGrabber(xGrabService.Url, data["calltype"].(string), &grabConfig)
logconfToMap, e := toolkit.ToM(data["logconf"])
if e != nil {
return nil, e
}
logpath := logconfToMap["logpath"].(string) //"E:\\data\\vale\\log"
filename := logconfToMap["filename"].(string) + "-%s" //"LOG-GRABDCETEST"
filepattern := logconfToMap["filepattern"].(string) //"20060102"
logconf, e := toolkit.NewLog(false, true, logpath, filename, filepattern)
if e != nil {
return nil, e
}
xGrabService.Log = logconf
xGrabService.ServGrabber.DataSettings = make(map[string]*sdt.DataSetting)
xGrabService.DestDbox = make(map[string]*sdt.DestInfo)
tempDataSetting := sdt.DataSetting{}
tempDestInfo := sdt.DestInfo{}
// isCondition := []interface{}{}
tempFilterCond := toolkit.M{}
// var condition string
for _, dataSet := range data["datasettings"].([]interface{}) {
dataToMap, _ := toolkit.ToM(dataSet)
tempDataSetting.RowSelector = dataToMap["rowselector"].(string)
for _, columnSet := range dataToMap["columnsettings"].([]interface{}) {
columnToMap, e := toolkit.ToM(columnSet)
if e != nil {
return nil, e
}
i := toolkit.ToInt(columnToMap["index"], toolkit.RoundingAuto)
tempDataSetting.Column(i, &sdt.GrabColumn{Alias: columnToMap["alias"].(string), Selector: columnToMap["selector"].(string)})
}
/*if data["calltype"].(string) == "POST" {
// orCondition := []interface{}{}
isRowdeletecond := dataToMap.Has("rowdeletecond")
fmt.Println("isRowdeletecond>", isRowdeletecond)
if hasRowdeletecond := dataToMap.Has("rowdeletecond"); hasRowdeletecond {
for key, rowDeleteMap := range dataToMap["rowdeletecond"].(map[string]interface{}) {
if key == "$or" || key == "$and" {
for _, subDataRowDelete := range rowDeleteMap.([]interface{}) {
for subIndex, getValueRowDelete := range subDataRowDelete.(map[string]interface{}) {
orCondition = append(orCondition, map[string]interface{}{subIndex: getValueRowDelete})
}
}
condition = key
}
}
}
// tempDataSetting.RowDeleteCond = toolkit.M{}.Set(condition, orCondition)
tempFilterCond := toolkit.M{}.Set(condition, orCondition)
tempDataSetting.SetFilterCond(tempFilterCond)
}*/
if hasRowdeletecond := dataToMap.Has("rowdeletecond"); hasRowdeletecond {
rowToM, e := toolkit.ToM(dataToMap["rowdeletecond"])
if e != nil {
return nil, e
}
tempFilterCond, e = toolkit.ToM(rowToM.Get("filtercond", nil))
tempDataSetting.SetFilterCond(tempFilterCond)
}
if hasRowincludecond := dataToMap.Has("rowincludecond"); hasRowincludecond {
rowToM, e := toolkit.ToM(dataToMap["rowincludecond"])
if e != nil {
return nil, e
}
tempFilterCond, e = toolkit.ToM(rowToM.Get("filtercond", nil))
tempDataSetting.SetFilterCond(tempFilterCond)
}
xGrabService.ServGrabber.DataSettings[dataToMap["name"].(string)] = &tempDataSetting //DATA01 use name in datasettings
connToMap, e := toolkit.ToM(dataToMap["connectioninfo"])
if e != nil {
return nil, e
}
var db, usr, pwd string
if hasDb := connToMap.Has("database"); !hasDb {
db = ""
} else {
db = connToMap["database"].(string)
}
if hasUser := connToMap.Has("username"); !hasUser {
usr = ""
} else {
usr = connToMap["username"].(string)
}
if hasPwd := connToMap.Has("password"); !hasPwd {
pwd = ""
} else {
pwd = connToMap["username"].(string)
}
ci := dbox.ConnectionInfo{}
ci.Host = connToMap["host"].(string) //"E:\\data\\vale\\Data_GrabIronTest.csv"
ci.Database = db
ci.UserName = usr
ci.Password = pwd
if hasSettings := connToMap.Has("settings"); !hasSettings {
ci.Settings = nil
} else {
settingToMap, e := toolkit.ToM(connToMap["settings"])
if e != nil {
return nil, e
}
ci.Settings = settingToMap //toolkit.M{}.Set("useheader", settingToMap["useheader"].(bool)).Set("delimiter", settingToMap["delimiter"])
}
if hasCollection := connToMap.Has("collection"); !hasCollection {
tempDestInfo.Collection = ""
} else {
tempDestInfo.Collection = connToMap["collection"].(string)
}
tempDestInfo.Desttype = dataToMap["desttype"].(string)
tempDestInfo.IConnection, e = dbox.NewConnection(tempDestInfo.Desttype, &ci)
if e != nil {
return nil, e
}
xGrabService.DestDbox[dataToMap["name"].(string)] = &tempDestInfo
//=History===========================================================
xGrabService.HistoryPath = HistoryPath //"E:\\data\\vale\\history\\"
xGrabService.HistoryRecPath = HistoryRecPath //"E:\\data\\vale\\historyrec\\"
//===================================================================
}
return xGrabService, nil
}
func fetchConfig() (err error) {
switch toolkit.ToString(config.Get("sourcetype", "")) {
case "SourceType_DocExcel":
SourceType = SourceType_DocExcel
case "SourceType_DocMongo":
SourceType = SourceType_DocMongo
default:
err = errors.New(fmt.Sprintf("Fetch Config, Source type is not defined : %v", config.Get("sourcetype", "")))
return
}
Log.AddLog("Start fetch grabconf", "INFO")
if !config.Has("grabconf") {
err = errors.New(fmt.Sprintf("Fetch Config, grabconf not found error"))
return
}
tconfgrab := toolkit.M{}
tconfgrab, err = toolkit.ToM(config["grabconf"])
if err != nil {
err = errors.New(fmt.Sprintf("Fetch Config, grabconf found error : %v", err.Error()))
return
}
if !tconfgrab.Has("doctype") {
err = errors.New("Fetch Config, doctype not found")
return
}
ci := dbox.ConnectionInfo{}
mapconninfo := toolkit.M{}
mapconninfo, err = toolkit.ToM(tconfgrab.Get("connectioninfo", nil))
if err != nil {
err = errors.New(fmt.Sprintf("Fetch Config, load connectioninfo found error : %v", err.Error()))
return
}
ci.Host = toolkit.ToString(mapconninfo.Get("host", ""))
ci.Database = toolkit.ToString(mapconninfo.Get("database", ""))
ci.UserName = toolkit.ToString(mapconninfo.Get("userName", ""))
ci.Password = toolkit.ToString(mapconninfo.Get("password", ""))
ci.Settings, err = toolkit.ToM(mapconninfo.Get("settings", nil))
if err != nil {
err = errors.New(fmt.Sprintf("Fetch Config, load connectioninfo.settings found error : %v", err.Error()))
return
}
sGrabber, err = sedotan.NewGetDatabase(ci.Host, toolkit.ToString(tconfgrab.Get("doctype", "")), &ci)
if err != nil {
err = errors.New(fmt.Sprintf("Fetch Config, create new get database found error : %v", err.Error()))
}
Log.AddLog("Start fetch datasettings", "INFO")
if !config.Has("datasettings") || !(toolkit.TypeName(config["datasettings"]) == "[]interface {}") {
err = errors.New("Fetch Config, datasettings is not found or have wrong format")
return
}
sGrabber.CollectionSettings = make(map[string]*sedotan.CollectionSetting)
destDboxs = make(map[string]*DestInfo)
for i, xVal := range config["datasettings"].([]interface{}) {
err = nil
tCollectionSetting := sedotan.CollectionSetting{}
tDestDbox := DestInfo{}
mVal := toolkit.M{}
mVal, err = toolkit.ToM(xVal)
if err != nil {
Log.AddLog(fmt.Sprintf("[Fetch.Ds.%d] Found : %v", i, err.Error()), "ERROR")
continue
}
tnameid := toolkit.ToString(mVal.Get("nameid", ""))
if tnameid == "" {
Log.AddLog(fmt.Sprintf("[Fetch.Ds.%d] Data Setting Id is not found", i), "ERROR")
continue
}
tCollectionSetting.Collection = toolkit.ToString(mVal.Get("collection", ""))
// Fetch mapssettings
if !mVal.Has("mapssettings") || !(toolkit.TypeName(mVal["mapssettings"]) == "[]interface {}") {
Log.AddLog(fmt.Sprintf("[Fetch.Ds.%d.%v] Found : mapssettings is not found or incorrect", i, tnameid), "ERROR")
continue
}
tCollectionSetting.MapsColumns = make([]*sedotan.MapColumn, 0, 0)
for xi, Valcs := range mVal["mapssettings"].([]interface{}) {
mValcs := toolkit.M{}
mValcs, err = toolkit.ToM(Valcs)
if err != nil {
Log.AddLog(fmt.Sprintf("[Fetch.Ds.%d.%v.%v] Found : mapssettings is not found or incorrect", i, tnameid, xi), "ERROR")
continue
}
tgrabcolumn := sedotan.MapColumn{}
tgrabcolumn.Source = toolkit.ToString(mValcs.Get("source", ""))
tgrabcolumn.SType = toolkit.ToString(mValcs.Get("sourcetype", ""))
tgrabcolumn.Destination = toolkit.ToString(mValcs.Get("destination", ""))
tgrabcolumn.DType = toolkit.ToString(mValcs.Get("destinationtype", ""))
// tindex := toolkit.ToInt(mValcs.Get("index", 0), toolkit.RoundingAuto)
tCollectionSetting.MapsColumns = append(tCollectionSetting.MapsColumns, &tgrabcolumn)
}
//Fetch Filter Condition
if mVal.Has("filtercond") {
tfiltercond := toolkit.M{}
tfiltercond, err = toolkit.ToM(mVal.Get("filtercond", toolkit.M{}))
if err != nil {
Log.AddLog(fmt.Sprintf("[Fetch.Ds.%d.%v] Found : filter cond is incorrect, %v", i, tnameid, err.Error()), "ERROR")
} else {
tCollectionSetting.SetFilterCond(tfiltercond)
}
}
//Fetch limit data
if mVal.Has("limitrow") {
tLimitrow, err := toolkit.ToM(mVal["limitrow"])
if err == nil {
tCollectionSetting.Take = toolkit.ToInt(tLimitrow.Get("take", 0), toolkit.RoundingAuto)
tCollectionSetting.Skip = toolkit.ToInt(tLimitrow.Get("skip", 0), toolkit.RoundingAuto)
}
}
//Fetch Connection Info
tConnInfo := toolkit.M{}
tConnInfo, err = toolkit.ToM(mVal.Get("connectioninfo", toolkit.M{}))
if err != nil {
Log.AddLog(fmt.Sprintf("[Fetch.Ds.%d.%v] Found : %v", i, tnameid, err.Error()), "ERROR")
continue
}
tDestDbox.desttype = toolkit.ToString(mVal.Get("desttype", ""))
tDestDbox.collection = toolkit.ToString(tConnInfo.Get("collection", ""))
tHost := toolkit.ToString(tConnInfo.Get("host", ""))
tDatabase := toolkit.ToString(tConnInfo.Get("database", ""))
tUserName := toolkit.ToString(tConnInfo.Get("username", ""))
tPassword := toolkit.ToString(tConnInfo.Get("password", ""))
tSettings := toolkit.M{}
tSettings, err = toolkit.ToM(tConnInfo.Get("settings", nil))
if err != nil {
Log.AddLog(fmt.Sprintf("[Fetch.Ds.%d.%v] Connection Setting Found : %v", i, tnameid, err.Error()), "ERROR")
continue
}
tDestDbox.IConnection, err = prepareconnection(tDestDbox.desttype, tHost, tDatabase, tUserName, tPassword, tSettings)
if err != nil {
Log.AddLog(fmt.Sprintf("[Fetch.Ds.%d.%v] Create connection found : %v", i, tnameid, err.Error()), "ERROR")
continue
}
tDestDbox.IConnection.Close()
destDboxs[tnameid] = &tDestDbox
sGrabber.CollectionSettings[tnameid] = &tCollectionSetting
}
err = nil
if len(destDboxs) == 0 || len(sGrabber.CollectionSettings) == 0 {
err = errors.New("Fetch Config, datasettings is not found or have wrong format")
return
}
if !config.Has("histconf") {
err = errors.New("Fetch Config, history configuration is not found or have wrong format")
return
}
Log.AddLog("Start fetch histconf", "INFO")
histConf, err = toolkit.ToM(config.Get("histconf", nil))
if err != nil || len(histConf) == 0 || !histConf.Has("histpath") || !histConf.Has("recpath") || !histConf.Has("filename") || !histConf.Has("filepattern") {
err = errors.New("Fetch Config, history configuration is not found or have wrong format")
return
}
if !config.Has("extcommand") {
return
}
Log.AddLog("Start fetch extcommand", "INFO")
extCommand, _ = toolkit.ToM(config.Get("extcommand", nil))
return
}
func GrabDocConfig(data toolkit.M) (*sdt.GrabService, error) {
var e error
var gi, ti time.Duration
GrabService := sdt.NewGrabService()
GrabService.Name = data["nameid"].(string) //"iopriceindices"
GrabService.SourceType = sdt.SourceType_DocExcel
grabintervalToInt := toolkit.ToInt(data["grabinterval"], toolkit.RoundingAuto)
timeintervalToInt := toolkit.ToInt(data["timeoutinterval"], toolkit.RoundingAuto)
if data["intervaltype"].(string) == "seconds" {
gi = time.Duration(grabintervalToInt) * time.Second
ti = time.Duration(timeintervalToInt) * time.Second
} else if data["intervaltype"].(string) == "minutes" {
gi = time.Duration(grabintervalToInt) * time.Minute
ti = time.Duration(timeintervalToInt) * time.Minute
} else if data["intervaltype"].(string) == "hours" {
gi = time.Duration(grabintervalToInt) * time.Hour
ti = time.Duration(timeintervalToInt) * time.Hour
}
GrabService.GrabInterval = gi
GrabService.TimeOutInterval = ti //time.Hour, time.Minute, time.Second
GrabService.TimeOutIntervalInfo = fmt.Sprintf("%v %s", timeintervalToInt, data["intervaltype"])
ci := dbox.ConnectionInfo{}
grabDataConf, e := toolkit.ToM(data["grabconf"])
if e != nil {
return nil, e
}
isDoctype := grabDataConf.Has("doctype")
if isDoctype {
connToMap, e := toolkit.ToM(grabDataConf["connectioninfo"])
if e != nil {
return nil, e
}
ci.Host = connToMap["host"].(string) //"E:\\data\\sample\\IO Price Indices.xlsm"
if hasSettings := connToMap.Has("settings"); !hasSettings {
ci.Settings = nil
} else {
settingToMap, e := toolkit.ToM(connToMap["settings"])
if e != nil {
return nil, e
}
ci.Settings = settingToMap //toolkit.M{}.Set("useheader", settingToMap["useheader"].(bool)).Set("delimiter", settingToMap["delimiter"])
}
GrabService.ServGetData, e = sdt.NewGetDatabase(ci.Host, grabDataConf["doctype"].(string), &ci)
}
logconfToMap, e := toolkit.ToM(data["logconf"])
if e != nil {
return nil, e
}
logpath := logconfToMap["logpath"].(string) //"E:\\data\\vale\\log"
filename := logconfToMap["filename"].(string) + "-%s" //"LOG-LOCALXLSX-%s"
filepattern := logconfToMap["filepattern"].(string) //"20060102"
logconf, e := toolkit.NewLog(false, true, logpath, filename, filepattern)
if e != nil {
return nil, e
}
GrabService.Log = logconf
GrabService.ServGetData.CollectionSettings = make(map[string]*sdt.CollectionSetting)
GrabService.DestDbox = make(map[string]*sdt.DestInfo)
tempDataSetting := sdt.CollectionSetting{}
tempDestInfo := sdt.DestInfo{}
for _, dataSet := range data["datasettings"].([]interface{}) {
dataToMap, e := toolkit.ToM(dataSet)
if e != nil {
return nil, e
}
tempDataSetting.Collection = dataToMap["rowselector"].(string) //"HIST"
for _, columnSet := range dataToMap["columnsettings"].([]interface{}) {
columnToMap, e := toolkit.ToM(columnSet)
if e != nil {
return nil, e
}
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &sdt.GrabColumn{Alias: columnToMap["alias"].(string), Selector: columnToMap["selector"].(string)})
}
GrabService.ServGetData.CollectionSettings[dataToMap["name"].(string)] = &tempDataSetting //DATA01 use name in datasettings
// fmt.Println("doctype>", grabDataConf["doctype"])
connToMap, e := toolkit.ToM(dataToMap["connectioninfo"])
if e != nil {
return nil, e
}
var db, usr, pwd string
if hasDb := connToMap.Has("database"); !hasDb {
db = ""
} else {
db = connToMap["database"].(string)
}
if hasUser := connToMap.Has("username"); !hasUser {
usr = ""
} else {
usr = connToMap["username"].(string)
}
if hasPwd := connToMap.Has("password"); !hasPwd {
pwd = ""
} else {
pwd = connToMap["username"].(string)
}
ci = dbox.ConnectionInfo{}
ci.Host = connToMap["host"].(string) //"localhost:27017"
ci.Database = db //"valegrab"
ci.UserName = usr //""
ci.Password = pwd //""
//tempDestInfo.Collection = "iopriceindices"
if hasCollection := connToMap.Has("collection"); !hasCollection {
tempDestInfo.Collection = ""
} else {
tempDestInfo.Collection = connToMap["collection"].(string)
}
tempDestInfo.Desttype = dataToMap["desttype"].(string) //"mongo"
tempDestInfo.IConnection, e = dbox.NewConnection(tempDestInfo.Desttype, &ci)
if e != nil {
return nil, e
}
GrabService.DestDbox[dataToMap["name"].(string)] = &tempDestInfo
//=History===========================================================
GrabService.HistoryPath = HistoryPath //"E:\\data\\vale\\history\\"
GrabService.HistoryRecPath = HistoryRecPath //"E:\\data\\vale\\historyrec\\"
//===================================================================
}
return GrabService, e
}
func TestServiceGrabDocument(t *testing.T) {
var e error
xGrabService := NewGrabService()
xGrabService.Name = "iopriceindices"
xGrabService.SourceType = SourceType_DocExcel
xGrabService.GrabInterval = 5 * time.Minute
xGrabService.TimeOutInterval = 10 * time.Second //time.Hour, time.Minute, time.Second
xGrabService.TimeOutIntervalInfo = fmt.Sprintf("%v %s", 1, "seconds")
//==must have grabconf and Connection info inside grabconf ===========================================
// mapValConfig, e := toolkit.ToM(mapVal.Get("grabconf", nil).(map[string]interface{}))
// mapConnVal, e := toolkit.ToM(mapValConfig.Get("connectioninfo", nil).(map[string]interface{}))
ci := dbox.ConnectionInfo{}
ci.Host = "E:\\data\\sample\\IO Price Indices.xlsm"
// ci.Database = mapConnVal.Get("database", "").(string)
// ci.UserName = mapConnVal.Get("userName", "").(string)
// ci.Password = mapConnVal.Get("password", "").(string)
// if have setting inside of connection info
// ci.Settings, e = toolkit.ToM(tempSetting.(map[string]interface{}))
ci.Settings = nil
xGrabService.ServGetData, e = NewGetDatabase(ci.Host, "xlsx", &ci)
//===================================================================
//==For Data Log ===========================================
// logpath = tempLogConf.Get("logpath", "").(string)
// filename = tempLogConf.Get("filename", "").(string)
// filepattern = tempLogConf.Get("filepattern", "").(string)
logpath := "E:\\data\\vale\\log"
filename := "LOG-LOCALXLSX-%s"
filepattern := "20060102"
logconf, e := toolkit.NewLog(false, true, logpath, filename, filepattern)
if e != nil {
t.Errorf("Error Found : ", e)
}
xGrabService.Log = logconf
//===================================================================
//===================================================================
//==Data Setting and Destination Save =====================
xGrabService.ServGetData.CollectionSettings = make(map[string]*CollectionSetting)
xGrabService.DestDbox = make(map[string]*DestInfo)
// ==For Every Data Setting ===============================
tempDataSetting := CollectionSetting{}
tempDestInfo := DestInfo{}
// .Collection = mapxVal.Get("rowselector", "").(string)
tempDataSetting.Collection = "HIST"
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &GrabColumn{Alias: "Date", Selector: "1"})
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &GrabColumn{Alias: "Platts 62% Fe IODEX", Selector: "2"})
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &GrabColumn{Alias: "Platts 65% Fe", Selector: "4"})
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &GrabColumn{Alias: "TSI 62% Fe", Selector: "15"})
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &GrabColumn{Alias: "TSI 65% Fe", Selector: "16"})
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &GrabColumn{Alias: "TSI 62% Fe LOW ALUMINA", Selector: "17"})
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &GrabColumn{Alias: "MB 62% Fe", Selector: "26"})
tempDataSetting.SelectColumn = append(tempDataSetting.SelectColumn, &GrabColumn{Alias: "MB 65% Fe", Selector: "29"})
// tempDataSetting.SetFilterCond(tempFilterCond)
// -Check "filtercond" in config-
// tempFilterCond, e = toolkit.ToM(mapxVal.Get("filtercond", nil).(map[string]interface{}))
// tempDataSetting.SetFilterCond(tempFilterCond)
xGrabService.ServGetData.CollectionSettings["DATA01"] = &tempDataSetting //DATA01 use name in datasettings
ci = dbox.ConnectionInfo{}
ci.Host = "localhost:27017"
ci.Database = "valegrab"
ci.UserName = ""
ci.Password = ""
// ci.Settings = toolkit.M{}.Set("useheader", true).Set("delimiter", ",")
// setting will be depend on config file
tempDestInfo.Collection = "iopriceindices"
tempDestInfo.Desttype = "mongo"
tempDestInfo.IConnection, e = dbox.NewConnection(tempDestInfo.Desttype, &ci)
if e != nil {
t.Errorf("Error Found : ", e)
}
xGrabService.DestDbox["DATA01"] = &tempDestInfo
//=History===========================================================
xGrabService.HistoryPath = "E:\\data\\vale\\history\\"
xGrabService.HistoryRecPath = "E:\\data\\vale\\historyrec\\"
//===================================================================
e = xGrabService.StartService()
if e != nil {
t.Errorf("Error Found : ", e)
} else {
for i := 0; i < 100; i++ {
fmt.Printf(".")
time.Sleep(1000 * time.Millisecond)
}
e = xGrabService.StopService()
if e != nil {
t.Errorf("Error Found : ", e)
}
}
}