func (c *Sample) GetSampleData() {
tk.Println("Getting sample data..")
availability := m.Availability{}
data, _ := availability.GetData(176, c.SqlCtx)
tk.Println(data)
tk.Println("Process Complete")
}
func TestFreeQuery(t *testing.T) {
t.Skip()
c, e := prepareConnection()
if e != nil {
t.Errorf("Unable to connect %s \n", e.Error())
}
defer c.Close()
csr, e := c.NewQuery().
Command("freequery", toolkit.M{}.
Set("syntax", "select name from tes where name like 'r%'")).
Cursor(nil)
if csr == nil {
t.Errorf("Cursor not initialized", e.Error())
return
}
defer csr.Close()
results := make([]map[string]interface{}, 0)
err := csr.Fetch(&results, 0, false)
if err != nil {
t.Errorf("Unable to fetch: %s \n", err.Error())
} else {
toolkit.Println("======================")
toolkit.Println("TEST FREE QUERY")
toolkit.Println("======================")
toolkit.Println("Fetch N OK. Result: ")
for _, val := range results {
toolkit.Printf("%v \n",
toolkit.JsonString(val))
}
}
}
func TestOdbc(t *testing.T) {
conn, e := odbc.Connect("DSN=mysql-dsn;UID=root;PWD=root")
if e != nil {
toolkit.Println("Conn Error found: ", e.Error())
}
toolkit.Println(conn)
query := "SELECT id, name FROM dummy"
stmt, e := conn.Prepare(query)
if e != nil {
toolkit.Println("STMT Error found: ", e.Error())
}
// toolkit.Println(conn, stmt)
e = stmt.Execute()
if e != nil {
toolkit.Println("Execute Error found: ", e.Error())
}
rows, e := stmt.FetchAll()
if e != nil {
toolkit.Println("FetchAll Error found: ", e.Error())
}
// toolkit.Println(toolkit.JsonString(rows))
for _, row := range rows {
toolkit.Printf("%v\n", row.Data)
}
stmt.Close()
conn.Close()
}
func (c *Sample) InsertSampleData() {
tk.Println("Starting Insert sample data..")
e := c.ConvertMGOToSQLServer(new(m.Availability))
if e != nil {
tk.Println(e)
}
tk.Println("Process Complete")
}
// Generate ...
func (d *GenWOListSummary) Generate() {
tk.Println("##Generating Summary Data..")
e := d.generateDurationIntervalSummary()
if e != nil {
tk.Println(e)
}
tk.Println("##Summary Data : DONE\n")
}
func main() {
tk.Println("Starting the app..")
mongo, e := PrepareConnection("mongo")
if e != nil {
tk.Println(e)
}
ctx = orm.New(mongo)
GetStructFromCollection("ValueEquation_Dashboard")
defer ctx.Close()
}
// Generate
func (s *GenPreventiveCorrectiveSummary) Generate(base *BaseController) {
if base != nil {
s.BaseController = base
}
tk.Println("##Generating PreventiveCorrectiveSummary..")
e := s.generatePreventiveCorrectiveSummary()
if e != nil {
tk.Println(e)
}
tk.Println("##PreventiveCorrectiveSummary : DONE\n")
}
func TestConnect(t *testing.T) {
t.Skip()
c, e := prepareConnection()
if e != nil {
t.Errorf("Unable to connect: %s \n", e.Error())
toolkit.Println(e)
} else {
toolkit.Println("###########################")
toolkit.Println("Horay, connection success!")
toolkit.Println("###########################")
}
defer c.Close()
}
// Generate Do the generate process
func (d *GenPlantMaster) Generate(base *BaseController) {
if base != nil {
d.BaseController = base
}
tk.Println("##Generating Plant Master..")
e := d.generatePlantMaster()
if e != nil {
tk.Println(e)
}
tk.Println("##Plant Master : DONE\n")
}
func (m *MigrateData) DoGenerateDataBrowserFields() error {
tStart := time.Now()
tk.Println("Starting DoGenerateDataBrowserFields..")
mod := new(DataBrowserFields)
c, e := m.BaseController.MongoCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
if e != nil {
return e
}
defer c.Close()
result := []tk.M{}
e = c.Fetch(&result, 0, false)
for _, val := range result {
selectedFields := val.Get("Fields")
if nil != selectedFields {
fields := selectedFields.(interface{}).([]interface{})
for _, field := range fields {
for {
v := reflect.ValueOf(field)
x := v.Interface()
details := x.(tk.M)
newVal := tk.M{}
newVal.Set("FieldsReference", val.Get("_id"))
newVal.Set("Alias", details["alias"])
newVal.Set("Field", details["field"])
newVal.Set("Type", details["tipe"])
_, e := m.InsertOut(newVal, new(DataBrowserFields))
if e == nil {
break
} else {
tk.Println(e.Error())
m.SqlCtx.Connection.Connect()
}
}
}
}
}
cr, e := m.BaseController.SqlCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
ctn := cr.Count()
cr.Close()
tk.Printf("Completed Success in %v | %v data(s)\n", time.Since(tStart), ctn)
return nil
}
func TestSelect(t *testing.T) {
// t.Skip()
skipIfConnectionIsNil(t)
cursor, e := ctx.NewQuery().
Select("id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("amount", 150), dbox.Eq("nama", "buku"))).
// Where(dbox.Contains("nama", "tem", "pe")).
// Order("nama").
// Skip(2).
// Take(1).
Cursor(nil)
// Where(dbox.And(dbox.Gt("price", "@price"), dbox.Eq("status", "@status"))).
// Cursor(toolkit.M{}.Set("@price", 100000).Set("@status", "available"))
// Where(dbox.And(dbox.Or(dbox.Eq("nama", "@name1"), dbox.Eq("nama", "@name2"),
// dbox.Eq("nama", "@name3")), dbox.Lt("quantity", "@quantity"))).
// Cursor(toolkit.M{}.Set("@name1", "buku").Set("@name2", "tas").
// Set("@name3", "dompet").Set("@quantity", 4))
if e != nil {
t.Fatalf("Cursor error: " + e.Error())
}
defer cursor.Close()
var results []toolkit.M
e = cursor.Fetch(&results, 0, false)
operation = "Test Select Filter"
sintaks = `
ctx.NewQuery().
Select("id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("amount", 150000),
dbox.Eq("nama", "buku"))).
Cursor(nil)`
if e != nil {
t.Errorf("Unable to fetch: %s \n", e.Error())
} else {
toolkit.Println("======================")
toolkit.Println(operation)
toolkit.Println("======================")
toolkit.Println(sintaks)
toolkit.Println("Fetch OK. Result:")
for _, val := range results {
toolkit.Printf("%v \n",
toolkit.JsonString(val))
}
}
}
func (c *Connection) OnQuery(query string, name string) []string {
var astr = []string{}
rows, e := c.Sql.Query(query)
if e != nil {
toolkit.Println(e.Error())
return nil
}
defer rows.Close()
columns, e := rows.Columns()
if e != nil {
toolkit.Println(e.Error())
return nil
}
count := len(columns)
tableData := []toolkit.M{}
values := make([]interface{}, count)
valuePtrs := make([]interface{}, count)
for rows.Next() {
for i := 0; i < count; i++ {
valuePtrs[i] = &values[i]
}
rows.Scan(valuePtrs...)
entry := toolkit.M{}
for i, col := range columns {
var v interface{}
val := values[i]
b, ok := val.([]byte)
if ok {
v = string(b)
} else {
v = val
}
entry.Set(strings.ToLower(col), v)
}
tableData = append(tableData, entry)
}
for _, val := range tableData {
astr = append(astr, val[name].(string))
}
return astr
}
func TestSelectAggregate(t *testing.T) {
t.Skip()
skipIfConnectionIsNil(t)
csr, e := ctx.NewQuery().
Select("nama").
// Aggr(dbox.AggrSum, 1, "Total Item").
Aggr(dbox.AggrMax, "amount", "Max Amount").
Aggr(dbox.AggrSum, "amount", "Total Amount").
// Aggr(dbox.AggrAvr, "amount", "Average Amount").
From(tableName).
Group("nama").
Order("-nama").
Cursor(nil)
if e != nil {
t.Errorf("Cursor pre error: %s \n", e.Error())
return
}
if csr == nil {
t.Errorf("Cursor not initialized")
return
}
defer csr.Close()
results := make([]map[string]interface{}, 0)
err := csr.Fetch(&results, 0, false)
sintaks = `
ctx.NewQuery().
Select("nama").
Aggr(dbox.AggrMax, "amount", "Max Amount").
Aggr(dbox.AggrSum, "amount", "Total Amount").
From(tableName).
Group("nama").
Order("-nama").
Cursor(nil)`
if err != nil {
t.Errorf("Unable to fetch: %s \n", err.Error())
} else {
toolkit.Println("======================")
toolkit.Println("QUERY AGGREGATION")
toolkit.Println("======================")
toolkit.Println("Fetch N OK. Result:")
for _, val := range results {
toolkit.Printf("%v \n",
toolkit.JsonString(val))
}
}
}
// Generate ...
func (s *GenSummaryData) Generate(base *BaseController) {
var (
e error
)
if base != nil {
s.BaseController = base
}
tk.Println("##Generating Summary Data..")
e = s.generateSummaryData()
if e != nil {
tk.Println(e)
}
tk.Println("##Summary Data : DONE\n")
}
func (m *MigrateData) DoPowerPlantOutages() error {
tStart := time.Now()
tk.Println("Starting DoPowerPlantOutages..")
mod := new(PowerPlantOutages)
c, e := m.BaseController.MongoCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
if e != nil {
return e
}
defer c.Close()
result := []tk.M{}
e = c.Fetch(&result, 0, false)
for _, val := range result {
details := val.Get("Details").(interface{}).([]interface{})
val.Set("Details", nil)
_, e := m.InsertOut(val, new(PowerPlantOutages))
if e != nil {
tk.Printf("\n----------- ERROR -------------- \n %v \n\n %#v \n------------------------- \n", e.Error(), val)
return e
}
id := val.GetString("_id")
tk.Printf("%#v \n\n", id)
for _, detail := range details {
det := detail.(tk.M)
det.Set("POId", id)
tk.Println(det)
_, e = m.InsertOut(det, new(PowerPlantOutagesDetails))
if e != nil {
tk.Printf("\n----------- ERROR -------------- \n %v \n\n %#v \n------------------------- \n", e.Error(), det)
return e
}
}
}
cr, e := m.BaseController.SqlCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
ctn := cr.Count()
cr.Close()
tk.Printf("Completed Success in %v | %v data(s)\n", time.Since(tStart), ctn)
return nil
}
func TestFindByEnable(t *testing.T) {
//InitCall()
emp6, _ := office.EmployeeGetByID("emp6", "")
emp8, _ := office.EmployeeGetByID("emp8", "")
office.DB().Delete(emp6)
office.DB().Delete(emp8)
emps := office.EmployeeFindByEnable(true,
"_id,title,enable", 0, 0)
defer emps.Close()
log.Printf("EMPS => %+v\n", emps.Count())
i := 0
for {
emp := office.NewEmployee()
e := emps.Fetch(emp, 1, false)
if e != nil {
break
}
toolkit.Println(toolkit.JsonString(emp))
i++
if i == 10 {
break
}
}
}
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 (m *MigrateData) DoMasterUnit() error {
tStart := time.Now()
tk.Println("Starting MasterUnit..")
mod := new(MasterUnit)
c, e := m.BaseController.MongoCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
if e != nil {
return e
}
defer c.Close()
result := []tk.M{}
e = c.Fetch(&result, 0, false)
for _, val := range result {
val.Set("Unit", val.Get("_id").(string))
_, e := m.InsertOut(val, new(MasterUnit))
if e != nil {
tk.Printf("\n----------- ERROR -------------- \n %v \n\n %#v \n------------------------- \n", e.Error(), val)
return e
}
}
cr, e := m.BaseController.SqlCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
ctn := cr.Count()
cr.Close()
tk.Printf("Completed Success in %v | %v data(s)\n", time.Since(tStart), ctn)
return nil
}
func (m *MigrateData) DoGenerateTempMstPlant() error {
tStart := time.Now()
tk.Println("Starting DoGenerateTempMstPlant..")
mod := new(TempMstPlant)
c, e := m.BaseController.MongoCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
if e != nil {
return e
}
defer c.Close()
result := []tk.M{}
e = c.Fetch(&result, 0, false)
_ = tStart
for _, val := range result {
for {
_, e := m.InsertOut(val, new(TempMstPlant))
if e == nil {
break
} else {
m.SqlCtx.Connection.Connect()
}
}
}
cr, e := m.BaseController.SqlCtx.Connection.NewQuery().From(mod.TableName()).Cursor(nil)
ctn := cr.Count()
cr.Close()
tk.Printf("Completed Success in %v | %v data(s)\n", time.Since(tStart), ctn)
return nil
}
func TestSaveQuery(t *testing.T) {
var e error
for i := 1; i <= 5; i++ {
ds := new(colonycore.DataSource)
ds.ID = toolkit.Sprintf("ds%d", i)
ds.ConnectionID = "conn1"
ds.QueryInfo = toolkit.M{}
ds.MetaData = nil
e = colonycore.Save(ds)
if e != nil {
t.Fatalf("Save datasource fail. " + e.Error())
}
}
var dss []colonycore.DataSource
c, e := colonycore.Find(new(colonycore.DataSource), nil)
if e != nil {
t.Fatalf("Load ds fail: " + e.Error())
}
e = c.Fetch(&dss, 0, true)
if e != nil {
t.Fatalf("Ftech ds fail: " + e.Error())
}
if len(dss) != 5 {
t.Fatal("Fetch ds fail. Got %d records only", len(dss))
}
toolkit.Println("Data:", toolkit.JsonString(dss))
}
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 TestConnect(t *testing.T) {
e := connect()
if e != nil {
t.Errorf("Error connecting to database: %s \n", e.Error())
} else {
toolkit.Println("connected . . .")
}
}
func TestConnect(t *testing.T) {
c, e := prepareConnection()
if e != nil {
t.Errorf("Unable to connect: %s \n", e.Error())
toolkit.Println(e)
}
defer c.Close()
}
func PrepareConnection(ConnectionType string) (dbox.IConnection, error) {
config := ReadConfig()
tk.Println("Connecting database..")
ci := &dbox.ConnectionInfo{config["host_"+ConnectionType], config["database_"+ConnectionType], config["username_"+ConnectionType], config["password_"+ConnectionType], nil}
c, e := dbox.NewConnection(ConnectionType, ci)
if e != nil {
return nil, e
}
e = c.Connect()
if e != nil {
return nil, e
}
tk.Println("Database connected..")
return c, nil
}
// if e != nil {
// t.Errorf("Unable to fetch: %s \n", e.Error())
// } else {
// toolkit.Println("======================")
// toolkit.Println(operation)
// toolkit.Println("======================")
// toolkit.Println(sintaks)
// toolkit.Println("Fetch OK. Result:")
// for _, val := range results {
// toolkit.Printf("%v \n",
// toolkit.JsonString(val))
// }
// }
// }
func TestSelectFilter(t *testing.T) {
// t.Skip()
skipIfConnectionIsNil(t)
cursor, e := ctx.NewQuery().
Select("_id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("amount", 150), dbox.Eq("nama", "buku"))).
Cursor(nil)
operation = "TestSelectFilter"
sintaks = `
ctx.NewQuery().
Select("_id", "nama", "amount").
From(tableName).
Where(dbox.And(dbox.Gt("amount", 150000),
dbox.Eq("nama", "buku"))).
Cursor(nil)`
if e != nil {
t.Fatalf("Cursor error: " + e.Error())
}
defer cursor.Close()
if cursor.Count() == 0 {
t.Fatalf("No record found")
}
var results []toolkit.M
e = cursor.Fetch(&results, 0, false)
if e != nil {
t.Errorf("Unable to fetch: %s \n", e.Error())
} else {
toolkit.Println("======================")
toolkit.Println(operation)
toolkit.Println("======================")
toolkit.Println(sintaks)
toolkit.Println("Fetch OK. Result:")
for _, val := range results {
toolkit.Printf("%v \n",
toolkit.JsonString(val))
}
}
}
func (d *GenDataBrowser) generateMaintenanceDataBrowser() (e error) {
ctx := d.BaseController.Ctx
c := ctx.Connection
// dataToSave := []DataBrowser{}
// dataCount = 0
tk.Println("Generating Maintenance Data Browser..")
// Get fuelCost
csr, e := c.NewQuery().From(new(FuelCost).TableName()).Cursor(nil)
e = csr.Fetch(&fuelCosts, 0, false)
ErrorHandler(e, "generateMaintenanceDataBrowser")
csr.Close()
// Get plants
csr, e = c.NewQuery().From(new(PowerPlantCoordinates).TableName()).Cursor(nil)
e = csr.Fetch(&plants, 0, false)
ErrorHandler(e, "generateMaintenanceDataBrowser")
csr.Close()
// Get generalInfo
csr, e = c.NewQuery().From(new(GeneralInfo).TableName()).Cursor(nil)
e = csr.Fetch(&generalInfos, 0, false)
ErrorHandler(e, "generateMaintenanceDataBrowser")
csr.Close()
// Get GeneralInfoDetails
csr, e = c.NewQuery().From(new(GeneralInfoDetails).TableName()).Cursor(nil)
e = csr.Fetch(&generalInfoDetails, 0, false)
ErrorHandler(e, "generateMaintenanceDataBrowser")
csr.Close()
// Get GeneralInfoActualFuelConsumption
csr, e = c.NewQuery().From(new(GeneralInfoActualFuelConsumption).TableName()).Cursor(nil)
e = csr.Fetch(&generalInfoActualFuelConsumption, 0, false)
ErrorHandler(e, "generateMaintenanceDataBrowser")
csr.Close()
// Get NewEquipmentType
csr, e = c.NewQuery().Select("EquipmentType, NewEquipmentGroup").From(new(NewEquipmentType).TableName()).Where(dbox.Ne("NewEquipmentGroup", "Disregard")).Cursor(nil)
e = csr.Fetch(&newEquipmentType, 0, false)
ErrorHandler(e, "generateMaintenanceDataBrowser")
csr.Close()
constructEquipmentType(newEquipmentType)
wg := &sync.WaitGroup{}
wg.Add(len(plants))
for _, plant := range plants {
go doGenerateMaintenanceDataBrowser(wg, d, plant)
}
wg.Wait()
return
}
func (c *Sample) RemoveSampleData() {
data := new(m.Availability)
e := c.GetById(data, 526, "id")
tk.Println(data)
e = c.SqlCtx.Delete(data)
if e != nil {
tk.Errorf("Unable to remove: %s \n", e.Error())
}
}
func main() {
runtime.GOMAXPROCS(runtime.NumCPU())
tk.Println("Starting the app..\n")
sql, e := PrepareConnection()
if e != nil {
tk.Println(e)
} else {
base := new(BaseController)
base.Ctx = orm.New(sql)
defer base.Ctx.Close()
/*new(GenSummaryData).Generate(base)
new(GenMOR).Generate(base)
new(GenPreventiveCorrectiveSummary).Generate(base)
new(GenWODurationSummary).Generate(base)
new(GenWOListSummary).Generate(base)
new(GenPlantMaster).Generate(base)*/
// new(GenDataBrowser).Generate(base)
// new(REFunctionalLocation).Generate(base)
//new(GenValueEquation).Generate(base)
//new(GenValueEquation).Generate(base)
new(GenValueEquationDashboard).Generate(base)
// new(REFunctionalLocation).Generate(base)
// new(REWOList).Generate(base)
// new(RERPPCloseWO).Generate(base)
// new(REFuelCargo).Generate(base)
// new(REMaintenanceWO).Generate(base)
// new(RESyntheticPM).Generate(base, 2014)
// new(REPerfromanceFactors).Generate(base, "Qurayyah")
// new(REConsolidated).Generate(base)
// new(REVBMOperationalData).Generate(base) //Revenue
// new(REFuelCost).Generate(base)
// new(REPreventiveMaintenance).Generate(base)
// new(REPlannedMaintenance).Generate(base)
// new(REMaintenancePlan).Generate(base)
// new(RENewObjectType).Generate(base)
}
tk.Println("Application Close..")
}
func (b *BaseController) GetDataSource(dataSourceFolder string) ([]os.FileInfo, string) {
config := ReadConfig()
source := config["datasource"]
files, e := ioutil.ReadDir(source + "\\" + dataSourceFolder)
if e != nil {
tk.Println(e)
os.Exit(0)
}
return files, source + "\\" + dataSourceFolder
}
func TestRunDaemon(t *testing.T) {
t.Skip("Skip : Comment this line to do test")
// tbasepath := strings.Replace(basePath, " ", toolkit.PathSeparator+" ", -1)
if runtime.GOOS == "windows" {
cmd = exec.Command("cmd", "/C", "..\\daemon\\sedotandaemon.exe", `-config="`+tbasepath+`\config-daemon.json"`, `-logpath="`+tbasepath+`\log"`)
} else {
cmd = exec.Command("sudo", "../daemon/sedotandaemon", `-config="`+tbasepath+`\config-daemon.json"`, `-logpath="`+tbasepath+`\log"`)
}
err := cmd.Start()
if err != nil {
t.Errorf("Error, %s \n", err)
}
go func(cmd *exec.Cmd) {
daemoninterval := 60 * time.Second
<-time.After(daemoninterval)
err := cmd.Process.Signal(os.Kill)
if err != nil {
toolkit.Println("Error, %s \n", err.Error())
}
if runtime.GOOS == "windows" {
err = exec.Command("cmd", "/C", "taskkill", "/F", "/IM", "sedotandaemon.exe", "/T").Run()
} else {
err = exec.Command("sudo", "pkill", "sedotandaemon").Run()
}
if err != nil {
toolkit.Println("Error, %s \n", err.Error())
}
}(cmd)
err = cmd.Wait()
if err != nil {
t.Errorf("Error, %s \n", err.Error())
}
}
