本文整理汇总了Golang中github.com/eaciit/toolkit.Jsonify函数的典型用法代码示例。如果您正苦于以下问题:Golang Jsonify函数的具体用法?Golang Jsonify怎么用?Golang Jsonify使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了Jsonify函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: getMsgAsResult
func (s *Subscriber) getMsgAsResult(key string) *toolkit.Result {
result := toolkit.NewResult()
if key == "" {
if len(s.messageKeys) > 0 {
key = s.messageKeys[0]
}
}
// if no key is provided, check from the latest
if key == "" {
result.Status = toolkit.Status_NOK
result.Message = "No key has been provided to receive the message"
} else {
msgQue, exist := s.MessageQues[key]
if !exist {
result.Status = toolkit.Status_NOK
result.Message = "Key " + key + " is not exist on message que or it has been collected. Available keys are: " + strings.Join(s.messageKeys, ",")
} else {
url := fmt.Sprintf("%s/getmsg", s.BroadcasterAddress)
r, e := toolkit.HttpCall(url, "POST",
toolkit.Jsonify(msgQue), nil)
if e != nil {
result.SetErrorTxt("Subscriber ReceiveMsg Call Error: " + e.Error())
} else if r.StatusCode != 200 {
result.SetErrorTxt("Subsciber ReceiveMsg Call Error: " + r.Status)
} else {
//var resultMsg toolkit.Result
e := toolkit.Unjson(toolkit.HttpContent(r),
&result)
if e != nil {
result.SetErrorTxt(fmt.Sprintf("Subsciber ReceiveMsg Decode Error: ", e.Error()))
}
/*else {
if resultMsg.Status == toolkit.Status_OK {
result.Data = resultMsg.Data
} else {
result.SetErrorTxt(resultMsg.Message)
}
}
*/
}
}
}
if result.Status == "OK" {
url := fmt.Sprintf("%s/msgreceived")
toolkit.HttpCall(url, "POST", toolkit.Jsonify(struct {
Key string
Subscriber string
}{key, s.Address}), nil)
}
return result
}
示例2: ResultFromDatabase
func (g *GetDatabase) ResultFromDatabase(dataSettingId string, out interface{}) error {
c, e := dbox.NewConnection(g.desttype, &g.ConnectionInfo)
if e != nil {
return e
}
e = c.Connect()
if e != nil {
return e
}
defer c.Close()
iQ := c.NewQuery()
if g.CollectionSettings[dataSettingId].Collection != "" {
iQ.From(g.CollectionSettings[dataSettingId].Collection)
}
for _, val := range g.CollectionSettings[dataSettingId].MapsColumns {
iQ.Select(val.Source)
}
if len(g.CollectionSettings[dataSettingId].FilterCond) > 0 {
iQ.Where(g.CollectionSettings[dataSettingId].filterDbox)
}
csr, e := iQ.Cursor(nil)
if e != nil {
return e
}
if csr == nil {
return e
}
defer csr.Close()
results := make([]toolkit.M, 0)
e = csr.Fetch(&results, 0, false)
if e != nil {
return e
}
ms := []toolkit.M{}
for _, val := range results {
m := toolkit.M{}
for _, column := range g.CollectionSettings[dataSettingId].MapsColumns {
m.Set(column.Source, "")
if val.Has(column.Destination) {
m.Set(column.Source, val[column.Destination])
}
}
ms = append(ms, m)
}
if edecode := toolkit.Unjson(toolkit.Jsonify(ms), out); edecode != nil {
return edecode
}
return nil
}
示例3: DataByte
func (g *Grabber) DataByte() []byte {
d := g.Data()
if toolkit.IsValid(d) {
return toolkit.Jsonify(d)
}
return []byte{}
}
示例4: TestDelete
func TestDelete(t *testing.T) {
//t.Skip()
ctx, e := prepareContext()
if e != nil {
t.Errorf("Error Connect: %s", e.Error())
return
}
defer ctx.Close()
u := new(UserModel)
e = ctx.GetById(u, "user2")
if e == nil {
fmt.Printf("Will Delete UserModel:\n %s \n", tk.JsonString(u))
e = ctx.Delete(u)
if e != nil {
t.Errorf("Error Load: %s", e.Error())
return
} else {
tk.Unjson(tk.Jsonify(u), u)
fmt.Printf("UserModel: %v has been deleted \n", u.RandomDate.UTC())
fmt.Println("")
}
} else {
t.Errorf("Delete error: %s", e.Error())
}
}
示例5: Cursor
func (q *Query) Cursor(in toolkit.M) (dbox.ICursor, error) {
var (
e error
dataMaps []toolkit.M
)
q.ReadFile(&dataMaps, q.Connection().(*Connection).filePath)
cursor := dbox.NewCursor(new(Cursor))
filters, e := q.Filters(in)
if e != nil {
return nil, errorlib.Error(packageName, modQuery, "Cursor", e.Error())
}
commandType := filters.GetString("cmdType")
if commandType != dbox.QueryPartSelect {
return nil, errorlib.Error(packageName, modQuery, "Cursor", "Cursor is only working with select command, for "+commandType+" please use .Exec instead")
}
aggregate := false
hasWhere := filters.Has("where")
if !aggregate {
var whereFields []*dbox.Filter
var dataInterface interface{}
json.Unmarshal(toolkit.Jsonify(dataMaps), &dataInterface)
if hasWhere {
whereFields = filters.Get("where").([]*dbox.Filter)
// jsonSelect = fields
cursor.(*Cursor).isWhere = true
}
cursor = cursor.SetConnection(q.Connection())
cursor.(*Cursor).whereFields = whereFields
cursor.(*Cursor).jsonSelect = filters.Get("select").([]string)
cursor.(*Cursor).readFile = toolkit.Jsonify(dataMaps)
} else {
return nil, errorlib.Error(packageName, modQuery, "Cursor", "No Aggregate function")
}
return cursor, nil
}
示例6: writeFile
func (q *Query) writeFile() error {
_, e := os.Stat(q.jsonPath)
if e != nil && e == os.ErrNotExist {
f, e := os.Create(q.jsonPath)
if e != nil {
return err.Error(packageName, modQuery, "writeFile", e.Error())
}
f.Close()
}
bs := toolkit.Jsonify(q.data)
e = ioutil.WriteFile(q.jsonPath, bs, 0644)
if e != nil {
return err.Error(packageName, modQuery, "WriteFile", e.Error())
}
return nil
}
示例7: parseHostAlias
func parseHostAlias(what string, raw interface{}) string {
hostAliases := []struct {
IP string `json:"ip", bson:"ip"`
HostName string `json:"hostName", bson:"hostName"`
}{}
toolkit.Unjson(toolkit.Jsonify(raw), &hostAliases)
for _, alias := range hostAliases {
if strings.Contains(strings.Split(what, "webhdfs")[0], alias.HostName) {
what = strings.Replace(what, alias.HostName, alias.IP, 1)
break
}
}
return what
}
示例8: AddChannel
func (s *Subscriber) AddChannel(c string) error {
url := fmt.Sprintf("%s/channelregister", s.BroadcasterAddress)
r, e := toolkit.HttpCall(url, "POST", toolkit.Jsonify(ChannelRegister{c, s.Address}), nil)
if e != nil {
return fmt.Errorf("Channel Register Call Error: %s", e.Error())
}
if r.StatusCode != 200 {
return fmt.Errorf("Channel Register Call Error: %s", r.Status)
}
result := new(toolkit.Result)
e = toolkit.Unjson(toolkit.HttpContent(r), &result)
if e != nil {
return fmt.Errorf("Channel Register Decode error: %s", e.Error())
}
if result.Status != toolkit.Status_OK {
return fmt.Errorf("Channel Register error: %s", result.Message)
}
return nil
}
示例9: ResultFromHtml
func (g *Grabber) ResultFromHtml(dataSettingId string, out interface{}) error {
reader := bytes.NewReader(g.bodyByte)
doc, e := gq.NewDocumentFromReader(reader)
if e != nil {
return e
}
ms := []toolkit.M{}
records := doc.Find(g.Config.DataSettings[dataSettingId].RowSelector)
recordCount := records.Length()
for i := 0; i < recordCount; i++ {
record := records.Eq(i)
m := toolkit.M{}
for cindex, c := range g.Config.DataSettings[dataSettingId].ColumnSettings {
columnId := fmt.Sprintf("%s", cindex)
if c.Alias != "" {
columnId = c.Alias
}
sel := record.Find(c.Selector)
var value interface{}
valuetype := strings.ToLower(c.ValueType)
if valuetype == "attr" {
value, _ = sel.Attr(c.AttrName)
} else if valuetype == "html" {
value, _ = sel.Html()
} else {
value = sel.Text()
}
value = strings.TrimSpace(fmt.Sprintf("%s", value))
m.Set(columnId, value)
}
if g.Config.DataSettings[dataSettingId].getCondition(m) {
ms = append(ms, m)
}
}
if edecode := toolkit.Unjson(toolkit.Jsonify(ms), out); edecode != nil {
return edecode
}
return nil
}
示例10: ditributeBroadcast
func (m *MessageMonitor) ditributeBroadcast() {
//for len(m.Targets) != m.Success && time.Now().After(m.Expiry) == false {
wg := new(sync.WaitGroup)
for k, t := range m.Targets {
wg.Add(1)
go func(wg *sync.WaitGroup, k int, t string) {
defer wg.Done()
if m.Status[k] != "OK" {
var command, url string
if m.Command != "" {
command = m.Command
} else {
command = "msg"
}
url = fmt.Sprintf("http://%s/%s", t, command)
r, ecall := toolkit.HttpCall(url, "POST",
toolkit.Jsonify(Message{Key: m.Key, Data: m.Data, Expiry: m.Expiry}), nil)
if ecall != nil {
m.setSuccessFail(k, "CALL ERROR: "+url+" ERR:"+ecall.Error())
} else if r.StatusCode != 200 {
m.setSuccessFail(k, fmt.Sprintf("CALL STATUS ERROR: %s ERR: %s", url, r.Status))
} else {
var result toolkit.Result
bs := toolkit.HttpContent(r)
edecode := toolkit.Unjson(bs, &result)
if edecode != nil {
m.setSuccessFail(k, "DECODE ERROR: "+string(bs)+" ERR:"+edecode.Error())
} else {
m.setSuccessFail(k, toolkit.IfEq(result.Status, toolkit.Status_OK, "OK", result.Message).(string))
}
}
}
}(wg, k, t)
}
wg.Wait()
//time.Sleep(1 * time.Millisecond)
//fmt.Printf("%d = %d \n", len(m.Targets), m.Success+m.Fail)
//}
}
示例11: distributeQue
func (m *MessageMonitor) distributeQue() {
//--- inform all targets that new message has been created
msg := toolkit.Jsonify(Message{Key: m.Key, Data: m.Data, Expiry: m.Expiry})
wg := new(sync.WaitGroup)
targetCount := len(m.Targets)
var newtargets []string
var failtargets []string
for _, t := range m.Targets {
wg.Add(1)
go func(wg *sync.WaitGroup, t string) {
defer wg.Done()
url := fmt.Sprintf("%s://%s/newkey", "http", t)
r, e := toolkit.HttpCall(url, "POST", msg, nil)
if e != nil {
m.Broadcaster.Log().Warning(fmt.Sprintf(
"Unable to inform %s for new que %s. %s",
url, m.Key, e.Error()))
failtargets = append(failtargets, t)
} else if r.StatusCode != 200 {
m.Broadcaster.Log().Warning(fmt.Sprintf(
"Unable to inform %s for new que %s %s",
url, m.Key, r.Status))
failtargets = append(failtargets, t)
} else {
newtargets = append(newtargets, t)
}
}(wg, t)
}
wg.Wait()
m.Targets = newtargets
m.Broadcaster.Log().Info(fmt.Sprintf("Ping %d servers for new message %s. Succcess: %d Fail: %d", targetCount, m.Key, len(newtargets), len(failtargets)))
//-- loop while not all target complete receival or expire
for len(m.Targets) != m.Success && time.Now().After(m.Expiry) == false {
time.Sleep(1 * time.Millisecond)
}
}
示例12: Exec
func (q *Query) Exec(in toolkit.M) error {
setting, e := q.prepare(in)
commandType := setting["commandtype"].(string)
if e != nil {
return err.Error(packageName, modQuery, "Exec: "+commandType, e.Error())
}
if setting.GetString("commandtype") == dbox.QueryPartSelect {
return err.Error(packageName, modQuery, "Exec: "+commandType, "Exec is not working with select command, please use .Cursor instead")
}
q.Lock()
defer q.Unlock()
var dataM toolkit.M
var dataMs []toolkit.M
hasData := in.Has("data")
dataIsSlice := false
data := in.Get("data")
if toolkit.IsSlice(data) {
dataIsSlice = true
e = toolkit.Unjson(toolkit.Jsonify(data), dataMs)
if e != nil {
return err.Error(packageName, modQuery, "Exec: "+commandType, "Data encoding error: "+e.Error())
}
} else {
dataM, e = toolkit.ToM(data)
dataMs = append(dataMs, dataM)
if e != nil {
return err.Error(packageName, modQuery, "Exec: "+commandType, "Data encoding error: "+e.Error())
}
}
hasWhere := in.Has("where")
where := in.Get("where", []*dbox.Filter{}).([]*dbox.Filter)
if hasData && hasWhere == false && toolkit.HasMember([]interface{}{dbox.QueryPartInsert, dbox.QueryPartUpdate, dbox.QueryPartSave}, commandType) {
hasWhere = true
if toolkit.IsSlice(data) {
ids := []interface{}{}
idField := ""
if idField == "" {
return err.Error(packageName, modQuery, "Exec:"+commandType, "Data send is a slice, but its element has no ID")
}
dataCount := toolkit.SliceLen(data)
for i := 0; i < dataCount; i++ {
dataI := toolkit.SliceItem(data, i)
if i == 0 {
idField = toolkit.IdField(dataI)
}
ids = append(ids, toolkit.Id(dataI))
}
where = []*dbox.Filter{dbox.In(idField, ids)}
} else {
id := toolkit.Id(data)
if toolkit.IsNilOrEmpty(id) {
where = []*dbox.Filter{dbox.Eq(toolkit.IdField(id), id)}
} else {
where = nil
hasWhere = false
}
}
}
q.openFile()
if commandType == dbox.QueryPartInsert {
if !hasData {
return err.Error(packageName, modQuery, "Exec:"+commandType, "Data is empty")
}
if dataIsSlice {
q.data = append(q.data, dataMs...)
} else {
q.data = append(q.data, dataM)
}
} else if commandType == dbox.QueryPartUpdate {
if !hasData {
return err.Error(packageName, modQuery, "Exec:"+commandType, "Data is empty")
}
var indexes []interface{}
if hasWhere {
toolkit.Serde(dbox.Find(q.data, where), &indexes, "")
}
var dataUpdate toolkit.M
var updateDataIndex int
isDataSlice := toolkit.IsSlice(data)
if isDataSlice == false {
isDataSlice = false
e = toolkit.Serde(data, &dataUpdate, "")
if e != nil {
return err.Error(packageName, modQuery, "Exec:"+commandType, "Unable to serialize data. "+e.Error())
}
}
var idField string
for i, v := range q.data {
if toolkit.HasMember(indexes, i) || len(indexes) == 0 {
if idField == "" {
//.........这里部分代码省略.........
示例13: Fetch
func (c *Cursor) Fetch(m interface{}, n int, closeWhenDone bool) error {
if closeWhenDone {
defer c.Close()
}
// if !toolkit.IsPointer(m) {
// return errorlib.Error(packageName, modCursor, "Fetch", "Model object should be pointer")
// }
if n != 1 && reflect.ValueOf(m).Elem().Kind() != reflect.Slice {
return errorlib.Error(packageName, modCursor, "Fetch", "Model object should be pointer of slice")
}
e := c.prepIter()
if e != nil {
return errorlib.Error(packageName, modCursor, "Fetch", e.Error())
}
datas := []toolkit.M{}
// lineCount := 0
//=============================
maxGetData := c.count
if n > 0 {
maxGetData = c.fetchRow + n
}
linecount := 0
for _, row := range c.reader.Sheet[c.sheetname].Rows {
isAppend := true
recData := toolkit.M{}
appendData := toolkit.M{}
for i, cell := range row.Cells {
if i < len(c.headerColumn) {
recData.Set(c.headerColumn[i].name, cell.Value)
if len(c.ConditionVal.Select) == 0 || c.ConditionVal.Select.Get("*", 0).(int) == 1 {
appendData.Set(c.headerColumn[i].name, cell.Value)
} else {
if c.ConditionVal.Select.Get(c.headerColumn[i].name, 0).(int) == 1 {
appendData.Set(c.headerColumn[i].name, cell.Value)
}
}
}
}
isAppend = c.ConditionVal.getCondition(recData)
if c.fetchRow < c.ConditionVal.skip || (c.fetchRow > (c.ConditionVal.skip+c.ConditionVal.limit) && c.ConditionVal.limit > 0) {
isAppend = false
}
if isAppend && len(appendData) > 0 {
linecount += 1
if linecount > c.fetchRow {
datas = append(datas, appendData)
c.fetchRow += 1
}
}
if c.fetchRow >= maxGetData {
break
}
}
e = toolkit.Unjson(toolkit.Jsonify(datas), m)
if e != nil {
return errorlib.Error(packageName, modCursor, "Fetch", e.Error())
}
return nil
}
示例14: ExecOut
func (q *Query) ExecOut(parm toolkit.M) (int64, error) {
var e error
if parm == nil {
parm = toolkit.M{}
}
driverName := q.GetDriverDB()
// driverName = "oracle"
tablename := ""
data := parm.Get("data")
var attributes string
var values string
var setUpdate string
var dataM toolkit.M
var dataMs []toolkit.M
var returnId int64
if toolkit.IsSlice(data) {
e = toolkit.Unjson(toolkit.Jsonify(data), &dataMs)
if e != nil {
return returnId, errorlib.Error(packageName, modQuery, "Exec: data extraction", "Data encoding error: "+e.Error())
}
} else {
dataM, e = toolkit.ToM(data)
dataMs = append(dataMs, dataM)
if e != nil {
return returnId, errorlib.Error(packageName, modQuery, "Exec: data extraction", "Data encoding error: "+e.Error())
}
}
for _, dataVal := range dataMs {
temp := ""
quyerParts := q.Parts()
c := crowd.From(&quyerParts)
groupParts := c.Group(func(x interface{}) interface{} {
qp := x.(*dbox.QueryPart)
temp = toolkit.JsonString(qp)
return qp.PartType
}, nil).Exec()
parts := map[interface{}]interface{}{}
if len(groupParts.Result.Data().([]crowd.KV)) > 0 {
for _, kv := range groupParts.Result.Data().([]crowd.KV) {
parts[kv.Key] = kv.Value
}
}
commandType := ""
_, hasDelete := parts[dbox.QueryPartDelete]
_, hasInsert := parts[dbox.QueryPartInsert]
_, hasUpdate := parts[dbox.QueryPartUpdate]
_, hasSave := parts[dbox.QueryPartSave]
if hasDelete {
commandType = dbox.QueryPartDelete
} else if hasInsert {
commandType = dbox.QueryPartInsert
} else if hasUpdate {
commandType = dbox.QueryPartUpdate
} else if hasSave {
commandType = dbox.QueryPartSave
}
if hasInsert || hasUpdate || hasSave {
attributes, setUpdate, values = extractData(dataVal, driverName)
} else if hasDelete {
}
fromParts, hasFrom := parts[dbox.QueryPartFrom]
if !hasFrom {
return returnId, errorlib.Error(packageName, "Query", modQuery, "Invalid table name")
}
tablename = fromParts.([]*dbox.QueryPart)[0].Value.(string)
var where interface{}
whereParts, hasWhere := parts[dbox.QueryPartWhere]
if hasWhere {
fb := q.Connection().Fb()
for _, p := range whereParts.([]*dbox.QueryPart) {
fs := p.Value.([]*dbox.Filter)
for _, f := range fs {
fb.AddFilter(f)
}
}
where, e = fb.Build()
if e != nil {
} else {
}
}
var id string
var idVal interface{}
//.........这里部分代码省略.........
示例15: insertBulk
func (q *Query) insertBulk(parm toolkit.M) error {
var e error
if parm == nil {
parm = toolkit.M{}
}
driverName := q.GetDriverDB()
// driverName = "oracle"
tablename := ""
data := parm.Get("data")
var attributes string
var dataM toolkit.M
var dataMs []toolkit.M
if toolkit.IsSlice(data) {
e = toolkit.Unjson(toolkit.Jsonify(data), &dataMs)
if e != nil {
return errorlib.Error(packageName, modQuery, "Exec: data extraction", "Data encoding error: "+e.Error())
}
} else {
dataM, e = toolkit.ToM(data)
dataMs = append(dataMs, dataM)
if e != nil {
return errorlib.Error(packageName, modQuery, "Exec: data extraction", "Data encoding error: "+e.Error())
}
}
temp := ""
quyerParts := q.Parts()
c := crowd.From(&quyerParts)
groupParts := c.Group(func(x interface{}) interface{} {
qp := x.(*dbox.QueryPart)
temp = toolkit.JsonString(qp)
return qp.PartType
}, nil).Exec()
parts := map[interface{}]interface{}{}
if len(groupParts.Result.Data().([]crowd.KV)) > 0 {
for _, kv := range groupParts.Result.Data().([]crowd.KV) {
parts[kv.Key] = kv.Value
}
}
commandType := ""
_, hasInsert := parts[dbox.QueryPartInsert]
if hasInsert {
commandType = dbox.QueryPartInsert
} else {
_, e = q.ExecOut(parm)
return e
// return errorlib.Error(packageName, "Query", modQuery+".InsertBulk", "Invalid Operation")
}
fromParts, hasFrom := parts[dbox.QueryPartFrom]
if !hasFrom {
return errorlib.Error(packageName, "Query", modQuery, "Invalid table name")
}
tablename = fromParts.([]*dbox.QueryPart)[0].Value.(string)
session := q.Session()
attributeList := extractFields(dataMs[0])
var datas []string
for _, dataVal := range dataMs {
var values string
tmp := toolkit.M{}
for _, attr := range attributeList {
tmp.Set(attr, dataVal.Get(attr))
}
values = extractDataBulk(attributeList, tmp, driverName)
// toolkit.Printf("test: \n %v \n------\n %v \n------\n %v \n------\n %v \n", attributeList, dataVal, tmp, values)
datas = append(datas, values)
}
attributes = "(" + strings.Join(attributeList, ",") + ")"
if attributes != "" && nil != datas {
var statement string
if driverName == "hive" {
/*statement = "INSERT INTO " + tablename + " VALUES " + values
e = sessionHive.Exec(statement, nil)*/
return errorlib.Error(packageName, modQuery+".Exec", commandType,
"Not Implemented Yet for HIVE")
} else {
statement = fmt.Sprintf("INSERT INTO "+tablename+" "+attributes+" VALUES %s", strings.Join(datas, ","))
_, e = session.Exec(statement)
}
if e != nil {
return errorlib.Error(packageName, modQuery+".Exec", commandType,
cast.ToString(e.Error()))
//.........这里部分代码省略.........