func TestSave(t *testing.T) {
t.Skip()
c, e := prepareConnection()
if e != nil {
t.Errorf("Unable to connect %s \n", e.Error())
return
}
defer c.Close()
q := c.NewQuery().From(tableProducts).Save()
data := products{}
data.Id = 2
data.Productname = "Jono"
data.Productcode = "0007 0012 0090"
data.DATE = toolkit.String2Date("12-NOV-2010", "dd-MMM-YYYY")
e = q.Exec(toolkit.M{"data": data})
if e != nil {
t.Errorf("Unable to save data : %s \n", e.Error())
}
data.Id = 3
data.Productname = "Jarwo"
data.Productcode = "1111 2222 3333"
data.DATE = toolkit.String2Date("21-May-1998", "dd-MMM-YYYY")
e = q.Exec(toolkit.M{"data": data})
if e != nil {
t.Errorf("Unable to save data : %s \n", e.Error())
}
}
func parse(line string, path string) (result FileInfo, e error) {
if line != "" {
cols := strings.Split(strings.Trim(line, " "), "||")
if len(cols) == 9 {
if cols[0] != "" || strings.TrimSpace(cols[8]) != "" {
result.Type = strings.TrimSpace(cols[0][:1])
result.Sub = nil
if result.Type == "d" {
result.IsDir = true
}
result.Permissions = strings.TrimSpace(cols[0][1:])
subCount, _ := strconv.ParseInt(strings.TrimSpace(cols[1]), 10, 64)
result.SubCount = subCount
result.User = strings.TrimSpace(cols[2])
result.Group = strings.TrimSpace(cols[3])
size, _ := strconv.ParseFloat(strings.TrimSpace(cols[4]), 64)
result.Size = size
var lastModified time.Time
str := strings.TrimSpace(cols[5]) + "-" + strings.TrimSpace(cols[6]) + "-" + strings.TrimSpace(cols[7])
if len(strings.TrimSpace(cols[7])) == 5 {
str = str + "-" + strconv.Itoa(time.Now().Year())
lastModified = toolkit.String2Date(str, "MMM-d-H:mm-YYYY")
} else {
lastModified = toolkit.String2Date(str, "MMM-d-YYYY")
}
result.LastModified = lastModified
result.Name = strings.TrimSpace(cols[8])
if len(path) > 1 {
if path[len(path)-1:] != DELIMITER {
path = path + DELIMITER
}
result.Path = path + result.Name
}
result.IsEditable = true
}
} else {
e = errorlib.Error("", "", "parse", "column is not valid")
}
}
return
}
func TestUpdate(t *testing.T) {
t.Skip()
c, e := prepareConnection()
if e != nil {
t.Errorf("Unable to connect %s \n", e.Error())
return
}
defer c.Close()
/*data := products{}
data.Id = 1
data.Productname = "Hendro"
data.Productcode = "0007 2189 9383"
data.DATE = toolkit.String2Date("12-NOV-2014", "dd-MMM-YYYY")
e = c.NewQuery().From(tableProducts).Where(dbox.Eq("id", 1)).Update().Exec(toolkit.M{"data": data})
if e != nil {
t.Errorf("Unable to update: %s \n", e.Error())
}*/
/*================ update WITHOUT where ===================================================*/
data := products{}
data.Id = 2
data.Productname = "Paijo"
data.Productcode = "0007 0012 0090"
data.DATE = toolkit.String2Date("12-NOV-2010", "dd-MMM-YYYY")
e = c.NewQuery().From(tableProducts).Update().Exec(toolkit.M{"data": data})
if e != nil {
t.Errorf("Unable to update: %s \n", e.Error())
}
}
func TestInsert(t *testing.T) {
t.Skip()
c, e := prepareConnection()
if e != nil {
t.Errorf("Unable to connect %s \n", e.Error())
return
}
defer c.Close()
/*===============================INSERT==============================*/
/*q := c.NewQuery().From(tableCustomers).Insert()
data := customers{}
data.Id = 7
data.Name = "Bejo"
data.Phone = "(08) 1234 5678"
data.Email = "*****@*****.**"
data.Date = toolkit.String2Date("02-FEB-1902", "dd-MMM-YYYY")*/
q := c.NewQuery().From(tableProducts).Insert()
data := products{}
data.Id = 1
data.Productname = "Joko"
data.Productcode = "000 1234 5678"
data.DATE = toolkit.String2Date("02-FEB-1002", "dd-MMM-YYYY")
e = q.Exec(toolkit.M{"data": data})
if e != nil {
t.Errorf("Unable to insert data : %s \n", e.Error())
}
}
func toInterface(data string, dataType string, dateFormat string) interface{} {
if dataType == "" {
if strings.HasPrefix(data, "#") && strings.HasSuffix(data, "#") {
dataType = DataDate
} else {
vfloat := toolkit.ToFloat64(dataType, 2, toolkit.RoundingAuto)
vint := toolkit.ToInt(dataType, toolkit.RoundingAuto)
if int(vfloat) == vint && vint != 0 {
dataType = DataInt
} else if vfloat != 0 {
// dataType = DataFloat
b, i := toolkit.MemberIndex(DataFloats, dataType)
if b {
for idx, dataFloat := range DataFloats {
if idx == i {
dataType = dataFloat
}
}
}
} else {
dataType = DataString
}
}
}
if dataType == DataDate {
return toolkit.String2Date(data, dateFormat)
} else if dataType == DataInt {
return toolkit.ToInt(data, toolkit.RoundingAuto)
} else if toolkit.HasMember(DataFloats, dataType) {
return toolkit.ToFloat64(data, 2, toolkit.RoundingAuto)
} else {
return data
}
return nil
}
func DateSecondPress(tm time.Time) time.Time {
return toolkit.String2Date(toolkit.Date2String(tm, dateformat), dateformat).UTC()
}
func DateMinutePress(tm time.Time) time.Time {
return toolkit.String2Date(toolkit.Date2String(tm, "YYYY-MM-dd HH:mm"), "YYYY-MM-dd HH:mm").UTC()
}
func StringToDate(sdate string) time.Time {
return toolkit.String2Date(sdate, dateformat).UTC()
}
func (w *WebGrabberController) GetLogHistory(datas []interface{}, date string) interface{} {
for _, v := range datas {
vMap, _ := toolkit.ToM(v)
logConf := vMap["logconf"].(map[string]interface{})
dateNowFormat := logConf["filepattern"].(string)
theDate := cast.String2Date(date, "YYYY/MM/dd HH:mm:ss")
theDateString := cast.Date2String(theDate, dateNowFormat)
fileName := fmt.Sprintf("%s-%s", logConf["filename"], theDateString)
w.logPath = f.Join(EC_DATA_PATH, "webgrabber", "log", fileName)
}
file, err := os.Open(w.logPath)
if err != nil {
return helper.CreateResult(false, nil, err.Error())
}
defer file.Close()
addMinute := toolkit.String2Date(date, "YYYY/MM/dd HH:mm:ss").Add(1 * time.Minute)
dateAddMinute := toolkit.Date2String(addMinute, "YYYY/MM/dd HH:mm:ss")
getHours := strings.Split(date, ":")
getAddMinute := strings.Split(dateAddMinute, ":")
containString := getHours[0] + ":" + getHours[1]
containString2 := getAddMinute[0] + ":" + getAddMinute[1]
scanner := bufio.NewScanner(file)
lines := 0
containLines := 0
logsseparator := ""
add7Hours := func(s string) string {
t, _ := time.Parse("2006/01/02 15:04", s)
t = t.Add(time.Hour * 7)
return t.Format("2006/01/02 15:04")
}
containString = add7Hours(containString)
containString2 = add7Hours(containString2)
var logs []interface{}
for scanner.Scan() {
lines++
contains := strings.Contains(scanner.Text(), containString)
contains2 := strings.Contains(scanner.Text(), containString2)
if contains {
containLines = lines
logsseparator = containString
}
if contains2 {
containLines = lines
logsseparator = containString2
}
result := toolkit.M{}
if lines == containLines {
arrlogs := strings.Split(scanner.Text(), logsseparator)
result.Set("Type", arrlogs[0])
result.Set("Date", logsseparator+":"+arrlogs[1][1:3])
result.Set("Desc", arrlogs[1][4:len(arrlogs[1])])
logs = append(logs, result)
}
}
if err := scanner.Err(); err != nil {
return helper.CreateResult(false, nil, err.Error())
}
var addSlice = toolkit.M{}
addSlice.Set("logs", logs)
return addSlice
}
func (c *Cursor) Fetch(m interface{}, n int, closeWhenDone bool) error {
if closeWhenDone {
defer c.Close()
}
e := c.prepIter()
if e != nil {
return errorlib.Error(packageName, modCursor, "Fetch", e.Error())
}
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")
}
var v reflect.Type
if n == 1 && reflect.ValueOf(m).Elem().Kind() != reflect.Slice {
v = reflect.TypeOf(m).Elem()
} else {
v = reflect.TypeOf(m).Elem().Elem()
}
ivs := reflect.MakeSlice(reflect.SliceOf(v), 0, 0)
lineCount := 0
//=============================
// fmt.Println("Qursor 191 : ", c.headerColumn)
for {
iv := reflect.New(v).Interface()
isAppend := true
// c.count += 1
recData := toolkit.M{}
appendData := toolkit.M{}
dataTemp, e := c.reader.Read()
for i, val := range dataTemp {
orgname := c.headerColumn[i].name
lowername := strings.ToLower(c.headerColumn[i].name)
switch c.headerColumn[i].dataType {
case "int":
recData[lowername] = cast.ToInt(val, cast.RoundingAuto)
case "float":
decimalPoint := len(val) - (strings.Index(val, ".") + 1)
recData[lowername] = cast.ToF64(val, decimalPoint, cast.RoundingAuto)
case "date":
recData[lowername] = toolkit.String2Date(val, c.headerColumn[i].format) // Just for test
// fmt.Printf("FOR DEBUG : %v \n", c.headerColumn[i].format)
default:
recData[lowername] = val
}
if len(c.ConditionVal.Select) == 0 || c.ConditionVal.Select.Get("*", 0).(int) == 1 {
appendData[orgname] = recData[lowername]
} else {
if c.ConditionVal.Select.Get(strings.ToLower(c.headerColumn[i].name), 0).(int) == 1 {
appendData[orgname] = recData[lowername]
}
}
}
isAppend = c.ConditionVal.getCondition(recData)
if isAppend {
c.count += 1
}
if c.count <= c.ConditionVal.skip || (c.count > (c.ConditionVal.skip+c.ConditionVal.limit) && c.ConditionVal.limit > 0) {
isAppend = false
}
// fmt.Printf("%v - %v \n", v.Elem().Kind(), toolkit.TypeName(v))
if v.Kind() == reflect.Struct || v.Elem().Kind() == reflect.Struct {
tv := v
if v.Elem().Kind() == reflect.Struct {
tv = v.Elem()
}
for i := 0; i < tv.NumField(); i++ {
str := tv.Field(i).Name
fcond := false
if appendData.Has(str) {
fcond = true
} else if appendData.Has(strings.ToLower(str)) {
fcond = true
str = strings.ToLower(str)
} else if strings.ToLower(str) == "id" && appendData.Has("_id") {
str = "_id"
fcond = true
}
if fcond {
switch tv.Field(i).Type.Kind() {
case reflect.Int:
appendData.Set(str, cast.ToInt(appendData[str], cast.RoundingAuto))
case reflect.String:
appendData.Set(str, toolkit.ToString(appendData[str]))
case reflect.Float64:
tstr := toolkit.ToString(appendData[str])
decimalPoint := len(tstr) - (strings.Index(tstr, ".") + 1)
appendData.Set(str, toolkit.ToFloat64(tstr, decimalPoint, toolkit.RoundingAuto))
}
}
}
}
if e == io.EOF {
if isAppend && len(appendData) > 0 {
toolkit.Serde(appendData, iv, "json")
ivs = reflect.Append(ivs, reflect.ValueOf(iv).Elem())
lineCount += 1
}
break
} else if e != nil {
return errorlib.Error(packageName, modCursor,
"Fetch", e.Error())
}
if isAppend && len(appendData) > 0 {
toolkit.Serde(appendData, iv, "json")
ivs = reflect.Append(ivs, reflect.ValueOf(iv).Elem())
lineCount += 1
}
if n > 0 {
if lineCount >= n {
break
}
}
}
if e != nil {
return errorlib.Error(packageName, modCursor, "Fetch", e.Error())
}
if n == 1 && reflect.ValueOf(m).Elem().Kind() != reflect.Slice {
if ivs.Len() > 0 {
reflect.ValueOf(m).Elem().Set(ivs.Index(0))
}
} else {
reflect.ValueOf(m).Elem().Set(ivs)
}
return nil
}