Golang toolkit.ToString函数代码示例

func (l *LoginController) SavePassword(r *knot.WebContext) interface{} {
	r.Config.OutputType = knot.OutputJson

	payload := toolkit.M{}
	err := r.GetPayload(&payload)
	if err != nil {
		return helper.CreateResult(false, nil, err.Error())
	}

	if !payload.Has("newpassword") || !payload.Has("userid") {
		return helper.CreateResult(false, nil, "Data is not complete")
	}

	switch {
	case payload.Has("tokenid"):
		err = acl.ChangePasswordToken(toolkit.ToString(payload["userid"]), toolkit.ToString(payload["newpassword"]), toolkit.ToString(payload["tokenid"]))
	default:
		// check sessionid first
		savedsessionid := "" //change with get session
		//=======================
		userid, err := acl.FindUserBySessionID(savedsessionid)
		if err == nil && userid == toolkit.ToString(payload["userid"]) {
			err = acl.ChangePassword(toolkit.ToString(payload["userid"]), toolkit.ToString(payload["newpassword"]))
		} else if err == nil {
			err = errors.New("Userid is not match")
		}
	}

	return helper.CreateResult(true, nil, "save password success")
}

func (a *UserController) TestFindUserLdap(r *knot.WebContext) interface{} {
	r.Config.OutputType = knot.OutputJson
	payload := map[string]interface{}{}
	err := r.GetPayload(&payload)
	if err != nil {
		return helper.CreateResult(false, nil, err.Error())
	}

	addr := toolkit.ToString(payload["Address"])  //192.168.0.200:389
	basedn := toolkit.ToString(payload["BaseDN"]) //DC=eaciit,DC=local
	filter := toolkit.ToString(payload["Filter"]) //(&(objectclass=person)(objectclass=organizationalPerson)(cn=*))
	var attr []string

	err = toolkit.Serde(payload["Attribute"], &attr, "json")
	if err != nil {
		return helper.CreateResult(true, err, "error")
	}

	param := toolkit.M{}

	param.Set("username", toolkit.ToString(payload["Username"])) //Alip Sidik
	param.Set("password", toolkit.ToString(payload["Password"])) //Password.1
	// param.Set("attributes", []string{"cn", "givenName"})
	param.Set("attributes", attr)

	arrtkm, err := acl.FindDataLdap(addr, basedn, filter, param)
	if err != nil {
		return helper.CreateResult(true, err, "error")
	}
	return helper.CreateResult(true, arrtkm, "sukses")
}

func (l *LoginController) ProcessLogin(r *knot.WebContext) interface{} {
	r.Config.OutputType = knot.OutputJson

	payload := toolkit.M{}
	err := r.GetPayload(&payload)

	switch {
	case err != nil:
		return helper.CreateResult(false, nil, err.Error())
	case !payload.Has("username") || !payload.Has("password"):
		return helper.CreateResult(false, nil, "username or password not found")
	case payload.Has("username") && len(toolkit.ToString(payload["username"])) == 0:
		return helper.CreateResult(false, nil, "username cannot empty")
	case payload.Has("password") && len(toolkit.ToString(payload["password"])) == 0:
		return helper.CreateResult(false, nil, "password cannot empty")
	}

	sessid, err := acl.Login(toolkit.ToString(payload["username"]), toolkit.ToString(payload["password"]))
	if err != nil {
		return helper.CreateResult(true, "", err.Error())
	}
	r.SetSession("sessionid", sessid)
	return helper.CreateResult(true, toolkit.M{}.Set("status", true), "Login Success")

}

func (a *DataFlowController) Save(r *knot.WebContext) interface{} {
	r.Config.OutputType = knot.OutputJson

	payload := map[string]interface{}{}
	err := r.GetPayload(&payload)
	if err != nil {
		return helper.CreateResult(false, nil, err.Error())
	}

	dataShapes := payload["DataShapes"].(map[string]interface{})
	actions := payload["Actions"].([]interface{})

	currentDataFlow := new(colonycore.DataFlow)
	currentDataFlow.DataShapes = dataShapes
	currentDataFlow.Actions = constructActions(actions)
	currentDataFlow.Name = tk.ToString(payload["Name"])
	currentDataFlow.Description = tk.ToString(payload["Description"])
	currentDataFlow.ID = tk.ToString(payload["ID"])
	currentDataFlow.GlobalParam = tk.M{}

	for _, val := range payload["GlobalParam"].([]interface{}) {
		tmp := val.(map[string]interface{})
		currentDataFlow.GlobalParam.Set(tk.ToString(tmp["key"]), tk.ToString(tmp["value"]))
	}

	dataDs := []colonycore.DataFlow{}
	cursor, err := colonycore.Find(new(colonycore.DataFlow), dbox.Eq("_id", currentDataFlow.ID))
	if cursor != nil {
		cursor.Fetch(&dataDs, 0, false)
		defer cursor.Close()
	}
	if err != nil && cursor != nil {
		return helper.CreateResult(false, nil, err.Error())
	}

	if len(dataDs) == 0 {
		currentDataFlow.CreatedDate = time.Now()
		currentDataFlow.CreatedBy = "Test User"
		currentDataFlow.ID = strings.Replace(currentDataFlow.Name, " ", "", -1) + cast.Date2String(time.Now(), "YYYYMMddHHmm")
	} else {
		currentDataFlow.CreatedDate = dataDs[0].CreatedDate
		currentDataFlow.CreatedBy = dataDs[0].CreatedBy
	}

	currentDataFlow.LastModified = time.Now()

	err = colonycore.Save(currentDataFlow)
	fmt.Println("")
	if err != nil {
		return helper.CreateResult(false, nil, err.Error())
	}
	return helper.CreateResult(true, currentDataFlow, "success")
}

func main() {
	jsonarg := toolkit.M{}

	err := toolkit.UnjsonFromString(os.Args[1], &jsonarg)
	if err != nil {
		return
	}

	jsonarg["Date"] = time.Now().Format("020106")
	jsonarg[`MB 62% Fe`] = "FE " + toolkit.ToString(jsonarg[`MB 62% Fe`])
	jsonarg[`Platts 62% Fe IODEX`] = toolkit.ToString(toolkit.ToFloat64(jsonarg[`Platts 62% Fe IODEX`], 6, toolkit.RoundingAuto))
	fmt.Println(toolkit.JsonString(jsonarg))
}

func main() {
	jsonarg := toolkit.M{}

	err := toolkit.UnjsonFromString(os.Args[1], &jsonarg)
	if err != nil {
		return
	}

	jsonarg["Date"] = "000000"
	jsonarg[`MB 62% Fe`] = "POST " + toolkit.ToString(jsonarg[`MB 62% Fe`])
	jsonarg[`Platts 62% Fe IODEX`] = toolkit.ToString(toolkit.ToFloat64(jsonarg[`Platts 62% Fe IODEX`], 6, toolkit.RoundingAuto) * 5)
	fmt.Println(toolkit.JsonString(jsonarg))
}

func (c *Cursor) structValue(dataTypeList toolkit.M, col string, v interface{}) interface{} {
	for fieldname, datatype := range dataTypeList {
		if strings.ToLower(col) == fieldname {
			switch datatype.(string) {
			case "time.Time":
				val, e := time.Parse(c.DateFormat, toolkit.ToString(v))
				if e != nil {
					v = toolkit.ToString(v)
				} else {
					v = val
				}
			case "int", "int32", "int64":
				val, e := strconv.Atoi(toolkit.ToString(v))
				if e != nil {
					v = toolkit.ToString(v)
				} else {
					v = val
				}
			case "float", "float32", "float64":
				val, e := strconv.ParseFloat(toolkit.ToString(v), 64)
				if e != nil {
					v = toolkit.ToString(v)
				} else {
					v = val
				}
			case "bool":
				if c.driver == "mysql" {
					if toolkit.ToString(v) == "0" {
						v = false
					} else {
						v = true
					}
				} else {
					val, e := strconv.ParseBool(toolkit.ToString(v))
					if e != nil {
						v = toolkit.ToString(v)
					} else {
						v = val
					}
				}
			default:
				v = toolkit.ToString(v)
			}

		}
	}
	return v
}

func (a *DataFlowController) GetListData(r *knot.WebContext) interface{} {
	r.Config.OutputType = knot.OutputJson

	payload := map[string]interface{}{}
	err := r.GetPayload(&payload)
	if err != nil {
		return helper.CreateResult(false, nil, err.Error())
	}

	search := tk.ToString(payload["search"])
	var query *dbox.Filter
	if search != "" {
		query = dbox.Or(dbox.Contains("name", search), dbox.Contains("description", search), dbox.Contains("createdby", search))
	}

	cursor, err := colonycore.Find(new(colonycore.DataFlow), query)

	dataDs := []colonycore.DataFlow{}

	if cursor != nil {
		cursor.Fetch(&dataDs, 0, false)
		defer cursor.Close()
	}

	if err != nil && cursor != nil {
		return helper.CreateResult(false, nil, err.Error())
	}

	return helper.CreateResult(true, dataDs, "success")
}

func saverechistory(key string, dt toolkit.M) (err error) {
	err = nil
	fullfilename := filepath.Join(toolkit.ToString(histConf.Get("recpath", "")), mapRecHistory[key])
	if EC_DATA_PATH != "" {
		fullfilename = filepath.Join(EC_DATA_PATH, "datagrabber", "historyrec", mapRecHistory[key])
	}
	// fmt.Println(fullfilename, " - Key - ", key, " - filename - ", mapRecHistory)
	cconfig := toolkit.M{"newfile": true, "useheader": true, "delimiter": ","}
	conn, err := prepareconnection("csv", fullfilename, "", "", "", cconfig)
	if err != nil {
		return
	}

	q := conn.NewQuery().SetConfig("multiexec", true).Insert()
	for k, v := range dt {
		if toolkit.TypeName(v) == "toolkit.M" {
			dt.Set(k, fmt.Sprintf("%v", v))
		}
	}

	err = q.Exec(toolkit.M{}.Set("data", dt))
	conn.Close()

	return
}

func (c *Connection) RdbmsConnect(drivername string, stringConnection string) error {
	if drivername == "hive" {
		connInfo := strings.Split(stringConnection, ",")
		c.Hive = hive.HiveConfig(connInfo[0], connInfo[1], connInfo[2], connInfo[3], connInfo[4], connInfo[5])
		c.Drivername = drivername
		c.Hive.Conn.Open()
		e := c.Hive.Conn.TestConnection()
		if e != nil {
			return err.Error(packageName, modConnection, "Connect", e.Error())
		}
	} else {
		sqlcon, e := sql.Open(drivername, stringConnection)
		if e != nil {
			return err.Error(packageName, modConnection, "Connect", e.Error())
		}
		c.Sql = *sqlcon
		c.Drivername = drivername
		e = sqlcon.Ping()
		if e != nil {
			return err.Error(packageName, modConnection, "Connect", e.Error())
		}
	}
	if c.Info().Settings.Has("dateformat") {
		c.DateFormat = toolkit.ToString(c.Info().Settings.Get("dateformat", ""))
	}

	return nil
}

func StringValue(v interface{}, db string) string {
	var ret string
	switch v.(type) {
	case string:
		t, e := time.Parse(time.RFC3339, toolkit.ToString(v))
		if e != nil {
			ret = fmt.Sprintf("%s", "'"+v.(string)+"'")
		} else {
			if strings.Contains(db, "oci8") {
				// toolkit.Println(t.Format("2006-01-02 15:04:05"))
				ret = "to_date('" + t.Format("02-01-2006 15:04:05") + "','DD-MM-YYYY hh24:mi:ss')"
			} else {
				ret = "'" + t.Format("2006-01-02 15:04:05") + "'"
			}
		}
	case time.Time:
		t := v.(time.Time).UTC()
		if strings.Contains(db, "oci8") {
			ret = "to_date('" + t.Format("2006-01-02 15:04:05") + "','yyyy-mm-dd hh24:mi:ss')"
		} else {
			ret = "'" + t.Format("2006-01-02 15:04:05") + "'"
		}
	case int, int32, int64, uint, uint32, uint64:
		ret = fmt.Sprintf("%d", v.(int))
	case nil:
		ret = ""
	default:
		ret = fmt.Sprintf("%v", v)
	}
	return ret
}

func getSQLScript(path string, params tk.M) (script string) {

	file, err := os.Open(wd + path)
	if err == nil {
		defer file.Close()

		reader := bufio.NewReader(file)

		for {
			line, _, e := reader.ReadLine()
			if e != nil {
				break
			}

			script += string(line[:len(line)])
		}
	} else {
		tk.Println(err.Error())
	}

	for idx, val := range params {
		script = strings.Replace(script, idx, tk.ToString(val), -1)
	}

	script = strings.Replace(script, "\t", "", -1)

	return
}

func decodeTSV(file []byte) (retVal interface{}, e error) {
	reader := csv.NewReader(strings.NewReader(string(file)))
	reader.Comma = '\t'
	records, e := reader.ReadAll()

	if e != nil {
		return
	}

	var list []interface{}

	for _, row := range records {
		line := toolkit.M{}
		for idx, val := range row {
			line.Set(toolkit.ToString(idx), val)
		}

		list = append(list, line)
	}

	if len(list) > 0 {
		retVal = list[0]
	}

	return
}

func (q *Query) DataType(data interface{}) interface{} {
	if data != nil {
		rf := toolkit.TypeName(data)
		// toolkit.Println("data>", rf)
		if rf == "[]uint8" {
			uintToString := string(data.([]uint8))
			spChar := strings.Contains(uintToString, "\x00")
			if spChar {
				uintToString = strings.Replace(uintToString, "\x00", "", 1)
			}

			floatVal, e := strconv.ParseFloat(uintToString, 64)
			if e != nil {

			} else {
				data = floatVal
			}
		} else {
			intVal, e := strconv.Atoi(toolkit.ToString(data))
			if e != nil {
				e = nil
				floatVal, e := strconv.ParseFloat(toolkit.ToString(data), 64)
				if e != nil {
					e = nil
					boolVal, e := strconv.ParseBool(toolkit.ToString(data))
					if e != nil {
						e = nil
						dateVal, e := time.Parse(q.DateFormat, toolkit.ToString(data))
						if e != nil {
							data = data
						} else { /*if string is date*/
							data = dateVal
						}
					} else { /*if string is bool*/
						data = boolVal
					}
				} else { /*if string is float*/
					data = floatVal
				}
			} else { /*if string is int*/
				data = intVal
			}
		}
	}

	return data
}

func (l *LoginController) Logout(r *knot.WebContext) interface{} {
	r.Config.OutputType = knot.OutputJson
	sessionId := toolkit.ToString(r.Session("sessionid", ""))
	if toolkit.ToString(sessionId) == "" {
		return helper.CreateResult(true, nil, "Active sessionid not found")
	}

	err := acl.Logout(sessionId)
	if err != nil && (err.Error() == "Session id not found" || err.Error() == "Session id is expired") {
		return helper.CreateResult(true, nil, "Active sessionid not found")
	} else if err != nil {
		return helper.CreateResult(true, nil, toolkit.Sprintf("Error found : %v", err.Error()))
	}

	r.SetSession("sessionid", "")

	return helper.CreateResult(true, nil, "Logout success")
}