func (s *ScenarioSimulation) GetDataSimulation(k *knot.WebContext) interface{} {
k.Config.OutputType = knot.OutputJson
result, status, msg := tk.M{}, "", ""
simDataTmp := []tk.M{}
filter := tk.M{}
filter.Set("name", "GetAllScenarioSimulation")
csr, err := s.DB().Connection.NewQuery().Command("procedure", filter).Cursor(nil)
defer csr.Close()
err = csr.Fetch(&simDataTmp, 0, true)
if err != nil {
msg = err.Error()
status = "NOK"
} else {
status = "OK"
}
SimulationDatas := constructScenarionSimulation(simDataTmp)
result.Set("Status", status)
result.Set("Message", msg)
result.Set("Data", SimulationDatas)
return result
}
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 (a *GroupController) FindUserLdap(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 := payload["Address"].(string)
basedn := payload["BaseDN"].(string)
filter := payload["Filter"].(string)
username := payload["Username"].(string)
password := payload["Password"].(string)
var attr []string
err = toolkit.Serde(payload["Attribute"], &attr, "json")
if err != nil {
return helper.CreateResult(false, err, "error")
}
param := toolkit.M{}
param.Set("username", username)
param.Set("password", password)
param.Set("attributes", attr)
arrm, err := acl.FindDataLdap(addr, basedn, filter, param)
if err != nil {
return helper.CreateResult(false, err, "error")
}
return helper.CreateResult(true, arrm, "success")
}
func (d *DataContext) Find(m IModel, parms tk.M) (dbox.ICursor, error) {
////_ = "breakpoint"
q := d.Connection.NewQuery().From(m.TableName())
if qe := parms.Get(ConfigSelect); qe != nil {
fields := qe.(string)
selectFields := strings.Split(fields, ",")
q = q.Select(selectFields...)
}
if qe := parms.Get(ConfigWhere, nil); qe != nil {
//q = q.Where(qe.(*dbox.Filter))
filters := qe.([]*dbox.Filter)
if len(filters) > 0 {
q = q.Where(dbox.And(filters...))
}
}
if qe := parms.Get(ConfigOrder, nil); qe != nil {
q = q.Order(qe.([]string)...)
}
if qe := parms.Get(ConfigSkip, nil); qe != nil {
q = q.Skip(qe.(int))
}
if qe := parms.Get(ConfigLimit, nil); qe != nil {
q = q.Take(qe.(int))
}
//fmt.Printf("Debug Q: %s\n", tk.JsonString(q))
return q.Cursor(nil)
//return c
}
func (d *DataBrowserController) parseQuery(conn dbox.IConnection, dbrowser colonycore.DataBrowser, datacon *colonycore.Connection) (dbox.IQuery, error) {
var dataQuery dbox.IQuery
if dbrowser.QueryType == "nonQueryText" {
dataQuery = conn.NewQuery().From(dbrowser.TableNames)
} else if dbrowser.QueryType == "SQL" {
if toolkit.HasMember(rdbms, datacon.Driver) {
dataQuery = conn.NewQuery().Command("freequery", toolkit.M{}.
Set("syntax", dbrowser.QueryText))
} else {
return nil, errors.New("Free Text Query with SQL only for RDBMS, please use Dbox")
}
} else if dbrowser.QueryType == "Dbox" {
queryInfo := toolkit.M{}
toolkit.UnjsonFromString(dbrowser.QueryText, &queryInfo)
toolkit.Println("queryinfo", queryInfo)
if qFrom := queryInfo.Get("from", "").(string); qFrom != "" {
dataQuery = conn.NewQuery()
dataQuery = dataQuery.From(qFrom)
}
if qSelect := queryInfo.Get("select", "").(string); qSelect != "" {
if qSelect != "*" {
dataQuery = dataQuery.Select(strings.Split(qSelect, ",")...)
}
}
}
return dataQuery, nil
}
func (c *ValueEquationController) Initiate(k *knot.WebContext) interface{} {
k.Config.OutputType = knot.OutputJson
var e error
csr, e := c.Ctx.Find(new(PlantModel), tk.M{}.Set("skip", 0).Set("limit", 0))
defer csr.Close()
PlantList := make([]PlantModel, 0)
e = csr.Fetch(&PlantList, 0, false)
if e != nil {
return e.Error()
}
csr, e = c.Ctx.Find(new(PhaseModel), tk.M{}.Set("skip", 0).Set("limit", 0))
PhaseList := make([]PhaseModel, 0)
e = csr.Fetch(&PhaseList, 0, false)
if e != nil {
return e.Error()
}
csr, e = c.Ctx.Find(new(UnitModel), tk.M{}.Set("skip", 0).Set("limit", 0))
UnitList := make([]UnitModel, 0)
e = csr.Fetch(&UnitList, 0, false)
if e != nil {
return e.Error()
}
result := tk.M{}
result.Set("PlantList", PlantList)
result.Set("PhaseList", PhaseList)
result.Set("UnitList", UnitList)
return ResultInfo(result, e)
}
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 getresultobj(strsplits []string, tval interface{}, val toolkit.M) interface{} {
var xval interface{}
if val == nil {
val = toolkit.M{}
}
switch {
case len(strsplits) == 1:
xval = tval
case len(strsplits) > 1:
tm := toolkit.M{}
if val.Has(strsplits[1]) {
tm, _ = toolkit.ToM(val[strsplits[1]])
}
xval = val.Set(strsplits[1], getresultobj(strsplits[1:], tval, tm))
}
return xval
// if {
// val = tval
// } else {
// val = val.Set(k, v)
// if val == nil {
// } else {
// }
// val = getresultobj(strsplits[1:], tval)
// }
// return val
}
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 (q *Query) generateIndex(filters []*dbox.Filter) (output []int, e error) {
var n int = 0
for {
tdread, e := q.reader.Read()
if e != nil && e != io.EOF {
break
}
n++
tm := toolkit.M{}
for i, v := range tdread {
tolower := strings.ToLower(q.headerColumn[i].name)
tm.Set(tolower, v)
if q.headerColumn[i].dataType == "int" {
tm[tolower] = cast.ToInt(v, cast.RoundingAuto)
} else if q.headerColumn[i].dataType == "float" {
tm[tolower] = cast.ToF64(v, (len(v) - (strings.IndexAny(v, "."))), cast.RoundingAuto)
}
}
match := dbox.MatchM(tm, filters)
if (len(filters) == 0 || match) && len(tm) > 0 {
output = append(output, n)
}
if e == io.EOF {
break
}
}
e = q.resetReader()
return
}
func (s *ScenarioSimulation) Initiate(k *knot.WebContext) interface{} {
k.Config.OutputType = knot.OutputJson
//csr, e := s.DB().Find(new(PlantModel), tk.M{}.Set("skip", 0).Set("limit", 0))
csr, e := s.DB().Connection.NewQuery().Select("Plant").From("MasterPlant").Cursor(nil)
PlantList := make([]PlantModel, 0)
e = csr.Fetch(&PlantList, 0, true)
if e != nil {
return e.Error()
}
//csr, e = s.DB().Find(new(UnitModel), tk.M{}.Set("skip", 0).Set("limit", 0))
csr, e = s.DB().Connection.NewQuery().Select("Unit").From("MasterUnit").Cursor(nil)
UnitList := make([]UnitModel, 0)
e = csr.Fetch(&UnitList, 0, true)
if e != nil {
return e.Error()
}
defer csr.Close()
result := tk.M{}
result.Set("PlantList", PlantList)
result.Set("UnitList", UnitList)
return ResultInfo(result, e)
}
func (p *Page) SaveNewWidget(payload toolkit.M, widgetPath string) (*WidgetPage, error) {
wp := new(WidgetPage)
wp.ID = payload.Get("widgetPageId", "").(string)
wp.WidgetID = payload.Get("widgetId", "").(string)
widget := new(Widget)
widget.ID = wp.WidgetID
widget.GetById()
wp.ConfigDefault = widget.Config
extractDest := filepath.Join(widgetPath, widget.ID)
path, err := GetWidgetPath(extractDest)
if path == "" {
return nil, errors.New("directory doesn't contains index.html")
}
if err != nil {
return nil, err
}
getConfigFile := filepath.Join(path, "config-widget.json")
result, err := GetJsonFile(getConfigFile)
if err != nil {
return nil, err
}
if result != nil { /*going to select dataSources field only from config-widget.json*/
for _, value := range result[0].Get("dataSources").([]interface{}) {
wp.DataSources = append(wp.DataSources, value.(map[string]interface{}))
}
}
return wp, nil
}
func ReadVariable(f *dbox.Filter, in toolkit.M) *dbox.Filter {
f.Field = strings.ToLower(f.Field)
if (f.Op == "$and" || f.Op == "$or") && strings.Contains(reflect.TypeOf(f.Value).String(), "dbox.Filter") {
fs := f.Value.([]*dbox.Filter)
for i, ff := range fs {
bf := ReadVariable(ff, in)
fs[i] = bf
}
f.Value = fs
} else {
if reflect.TypeOf(f.Value).Kind() == reflect.Slice {
fSlice := f.Value.([]interface{})
// nilai fSlice : [@name1 @name2]
for i := 0; i < len(fSlice); i++ {
// nilai fSlice [i] : @name1
if len(cast.ToString(f.Value)) > 0 && string(cast.ToString(fSlice[i])[0]) == "@" {
fSlice[i] = in.Get(cast.ToString(fSlice[i]), "")
}
}
f.Value = fSlice
} else if len(cast.ToString(f.Value)) > 0 && string(cast.ToString(f.Value)[0]) == "@" {
f.Value = in.Get(cast.ToString(f.Value), "")
}
}
return f
}
func extractDataBulk(attrList []string, data toolkit.M, driverName string) string {
var values string
if data != nil {
for i, attr := range attrList {
val := data.Get(attr)
var datatypelist = []string{"map", "invalid", "struct", "slice"}
var value reflect.Value
if val != nil {
value = reflect.Zero(reflect.TypeOf(val))
}
if toolkit.HasMember(datatypelist, value.Kind().String()) {
continue
}
stringValues := StringValue(val, driverName)
if i == 0 {
values = "(" + stringValues
} else {
values += ", " + stringValues
}
}
values += ")"
}
return values
}
func (c *Coordinator) UpdateMetadata(in toolkit.M) *toolkit.Result {
result := toolkit.NewResult()
keys := []string{}
bs := in.Get("keys", []byte{}).([]byte)
toolkit.FromBytes(bs, "gob", &keys)
return result
}
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
}
func (p *PageController) LoadWidgetPageData(r *knot.WebContext) interface{} {
r.Config.OutputType = knot.OutputJson
payload := []toolkit.M{}
if err := r.GetPayload(&payload); err != nil {
return helper.CreateResult(false, nil, err.Error())
}
result := toolkit.M{}
for _, each := range payload {
filter := each.GetString("filter")
namespace := each.GetString("namespace")
fields := strings.Split(each.Get("fields").(string), ",")
dsID := each.GetString("value")
opt := toolkit.M{"fields": fields, "value": filter}
data, err := helper.FetchDataFromDSWithFilter(dsID, 0, opt)
if err != nil {
return helper.CreateResult(false, nil, err.Error())
}
result.Set(namespace, data)
}
return helper.CreateResult(true, result, "")
}
func (c *Cursor) Fetch(result interface{}) (bool, error) {
if !c.rows.Next() {
return false, nil
}
e := c.rows.Scan(c.rowMemory...)
if e != nil {
return false, createError("Fetch", e.Error())
}
rowData := toolkit.M{}
for i, each := range c.rowDataRaw {
value := "NULL"
if each != nil {
value = string(each)
}
rowData.Set(c.columns[i], value)
}
*(result.(*toolkit.M)) = rowData
return true, nil
}
func (c *Coordinator) Get(in toolkit.M) *toolkit.Result {
result := toolkit.NewResult()
result.SetErrorTxt("Get command is still under development")
key := in.GetString("key")
owner, table, datakey := ParseKey(key)
key = MakeKey(owner, table, datakey)
return result
}
func (a *ConfigurationController) Default(k *knot.WebContext) interface{} {
k.Config.OutputType = knot.OutputTemplate
data := tk.M{}
d, _ := os.Getwd()
d = strings.Replace(strings.Replace(d, "\\cli", "", -1), "/cli", "", -1)
data.Set("data_dir", d+tk.PathSeparator+filepath.Join("data", "Output")+tk.PathSeparator)
data.Set("log_dir", d+tk.PathSeparator+filepath.Join("data", "Log")+tk.PathSeparator)
return data
}
func (a *controller) Hi(in toolkit.M) *toolkit.Result {
r := toolkit.NewResult()
name := in.GetString("name")
r.SetBytes(struct {
HelloMessage string
TimeNow time.Time
Scores []Score
}{"Hello " + name, time.Now(), []Score{{"Bahasa Indonesia", 90}, {"Math", 85}}}, "gob")
return r
}
func ACL() {
var driver, host, db, user, pass string
fmt.Println("Setup ACL database ==============")
fmt.Print(" driver (mongo/json/csv/mysql) : ")
fmt.Scanln(&driver)
fmt.Print(" host (& port) : ")
fmt.Scanln(&host)
fmt.Print(" database name : ")
fmt.Scanln(&db)
fmt.Print(" username : "******" password : "******"driver", driver)
config.Set("host", host)
config.Set("db", db)
config.Set("user", user)
config.Set("pass", pass)
fmt.Println("ACL Configuration saved!")
colonycore.SetConfig(colonycore.CONF_DB_ACL, config)
}
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 (q *Query) Exec(parm toolkit.M) (e error) {
data := parm.Get("data")
driverName := q.GetDriverDB()
if toolkit.IsSlice(data) && driverName == "mssql" {
e = q.insertBulk(parm)
} else {
_, e = q.ExecOut(parm)
}
return e
}
func (a *SessionController) GetSession(r *knot.WebContext) interface{} {
var filter *dbox.Filter
r.Config.OutputType = knot.OutputJson
_ = a.InitialSetDatabase()
payload := map[string]interface{}{}
err := r.GetForms(&payload)
if err != nil {
return helper.CreateResult(false, nil, err.Error())
}
if strings.Contains(toolkit.TypeName(payload["find"]), "float") {
payload["find"] = toolkit.ToInt(payload["find"], toolkit.RoundingAuto)
}
tSession := new(acl.Session)
if find := toolkit.ToString(payload["find"]); find != "" {
filter = new(dbox.Filter)
filter = dbox.Contains("loginid", find)
}
take := toolkit.ToInt(payload["take"], toolkit.RoundingAuto)
skip := toolkit.ToInt(payload["skip"], toolkit.RoundingAuto)
// c, err := acl.Find(tAccess, filter, toolkit.M{}.Set("take", take).Set("skip", skip))
// c, err := acl.Find(tSession, nil, toolkit.M{}.Set("take", payload["take"].(int)).Set("skip", payload["skip"].(int)))
c, err := acl.Find(tSession, filter, toolkit.M{}.Set("take", take).Set("skip", skip))
if err != nil {
return helper.CreateResult(true, nil, err.Error())
}
data := toolkit.M{}
arrm := make([]toolkit.M, 0, 0)
err = c.Fetch(&arrm, 0, false)
for i, val := range arrm {
arrm[i].Set("duration", time.Since(val["created"].(time.Time)).Hours())
arrm[i].Set("status", "ACTIVE")
if val["expired"].(time.Time).Before(time.Now().UTC()) {
arrm[i].Set("duration", val["expired"].(time.Time).Sub(val["created"].(time.Time)).Hours())
arrm[i].Set("status", "EXPIRED")
}
}
c.Close()
c, err = acl.Find(tSession, filter, nil)
data.Set("Datas", arrm)
data.Set("total", c.Count())
if err != nil {
return helper.CreateResult(true, nil, err.Error())
} else {
return helper.CreateResult(true, data, "")
}
}
func removeDuplicatesUnordered(elements toolkit.M, key []string) []string {
for _, k := range key {
elements.Unset(k)
}
result := []string{}
for key, _ := range elements {
result = append(result, key)
}
return result
}
func populateParmValue(inputM *toolkit.M, parms toolkit.M) {
in := *inputM
for k, _ := range in {
if parms.Has(k) {
in[k] = parms[k]
} else {
in[k] = ""
}
}
*inputM = in
}
func generateWhereCondition(strwhere string) (oprstr string, sstr []string) {
oprstr = "or"
r := regexp.MustCompile(`^(?P<lastprocess01>(.*))(?P<firstprocess>(\(.*([Aa][Nn][Dd]|[Oo][Rr]).*\)))(?P<lastprocess02>(.*))$`)
// ror := regexp.MustCompile(`(.*) (?P<oprandor>([Oo][Rr])) (.*)`)
// rand := regexp.MustCompile(`(.*) (?P<oprandor>([Aa][Nn][Dd])) (.*)`)
// if !r.MatchString(strwhere) {
// r = ror
// }
// if !r.MatchString(strwhere) {
// r = rand
// }
// tempalias := make(toolkit.M, 0, 0)
tempalias := toolkit.M{}
for r.MatchString(strwhere) {
condpart := toolkit.M{}
temparray := r.FindStringSubmatch(strwhere)
for i, val := range r.SubexpNames() {
if val != "" && temparray[i] != "" {
condpart.Set(val, temparray[i])
}
}
straliaskey := "@" + toolkit.GenerateRandomString("1234567890", 10)
strwhere = strings.Replace(strwhere, condpart["firstprocess"].(string), straliaskey, -1)
tempalias.Set(straliaskey, condpart["firstprocess"])
}
r = regexp.MustCompile(`(.*) (?P<oprandor>([Oo][Rr])) (.*)`)
if !r.MatchString(strwhere) {
r = regexp.MustCompile(`(.*) (?P<oprandor>([Aa][Nn][Dd])) (.*)`)
}
condpart := toolkit.M{}
temparray := r.FindStringSubmatch(strwhere)
// toolkit.Printf("Connection 319 : %#v\n", temparray)
for i, val := range r.SubexpNames() {
if val != "" && temparray[i] != "" {
condpart.Set(val, temparray[i])
}
}
sstr = strings.Split(strwhere, condpart["oprandor"].(string))
if strings.ToLower(condpart["oprandor"].(string)) == "and" {
oprstr = "and"
}
for key, val := range tempalias {
for i, strval := range sstr {
sstr[i] = strings.Replace(strval, key, val.(string), -1)
}
}
return
}
func (c *DashboardController) GetData(k *knot.WebContext) interface{} {
k.Config.OutputType = knot.OutputJson
d := struct {
StartDate string
EndDate string
Plant []string
}{}
e := k.GetPayload(&d)
type ReturnValue struct {
PlantList []PowerPlantCoordinates
PlantCapacityList []tk.M
}
var (
Result ReturnValue
)
filter := tk.M{}
curr, e := c.DB().Find(&PowerPlantCoordinates{}, filter)
if e != nil {
}
e = curr.Fetch(&Result.PlantList, 0, false)
if e != nil {
return e.Error()
}
defer curr.Close()
//selectedPeriod := d.StartDate
selectedPeriod := time.Now().Year() - 1
cursor, _ := c.DB().Connection.NewQuery().
Select("PlantCode as _id").
From("ValueEquation_Dashboard").
Where(dbox.Eq("Year", selectedPeriod)).
Aggr(dbox.AggrSum, "InstalledCapacity", "TotalCapacity").
Group("PlantCode").
Cursor(nil)
defer cursor.Close()
e = cursor.Fetch(&Result.PlantCapacityList, 0, false)
result := tk.M{}
result.Set("success", true)
result.Set("Data", Result)
return ResultInfo(result, e)
}
func (a *SessionController) GetSession(r *knot.WebContext) interface{} {
r.Config.OutputType = knot.OutputJson
_ = a.InitialSetDatabase()
// payload := map[string]interface{}{}
// err := r.GetPayload(&payload)
// if err != nil {
// return helper.CreateResult(false, nil, err.Error())
// }
tSession := new(acl.Session)
data := toolkit.M{}
arrm := make([]toolkit.M, 0, 0)
// c, err := acl.Find(tSession, nil, toolkit.M{}.Set("take", payload["take"].(int)).Set("skip", payload["skip"].(int)))
c, err := acl.Find(tSession, nil, toolkit.M{}.Set("take", 10).Set("skip", 0))
if err != nil {
return helper.CreateResult(true, nil, err.Error())
}
err = c.Fetch(&arrm, 0, false)
for i, val := range arrm {
tUser := new(acl.User)
e := acl.FindByID(tUser, toolkit.ToString(val.Get("userid", "")))
if e != nil {
continue
}
arrm[i].Set("username", tUser.LoginID)
arrm[i].Set("duration", time.Since(val["created"].(time.Time)).Hours())
arrm[i].Set("status", "ACTIVE")
if val["expired"].(time.Time).Before(time.Now().UTC()) {
arrm[i].Set("duration", val["expired"].(time.Time).Sub(val["created"].(time.Time)).Hours())
arrm[i].Set("status", "EXPIRED")
}
arrm[i].Set("username", tUser.LoginID)
// toolkit.Printf("Debug date : %v : %v\n", toolkit.TypeName(val["created"]), val["created"].(time.Time))
}
c.Close()
c, err = acl.Find(tSession, nil, nil)
data.Set("Datas", arrm)
data.Set("total", c.Count())
// data.Set("total", 100)
if err != nil {
return helper.CreateResult(true, nil, err.Error())
} else {
return helper.CreateResult(true, data, "")
}
}