package models import ( "errors" "fmt" "reflect" "strings" "time" "github.com/astaxie/beego/orm" ) type UserCompanyMap struct { ID int `orm:"column(id)"` // removed pk here to fix postgres error Email string `orm:"column(email)"` PasswordHash string `orm:"column(password_hash)"` Company string `orm:"column(company)"` CompanyUserID int16 `orm:"column(company_user_id)"` Created time.Time `orm:"column(created);type(timestamp with time zone);auto_now_add"` Modified time.Time `orm:"column(modified);type(timestamp with time zone);auto_now_add"` } // TableName returns tablename func (t *UserCompanyMap) TableName() string { return "user_company_map" } func init() { orm.RegisterModel(new(UserCompanyMap)) } // AddUserCompanyMap insert a new UserCompanyMap into database and returns // last inserted Id on success. func AddUserCompanyMap(o orm.Ormer, m *UserCompanyMap) (id int64, err error) { id, err = o.Insert(m) return } // GetUserCompanyMapByID retrieves UserCompanyMap by Id. Returns error if Id doesn't exist func GetUserCompanyMapByID(o orm.Ormer, id int) (v *UserCompanyMap, err error) { v = &UserCompanyMap{ID: id} if err = o.Read(v); err == nil { return v, nil } return nil, err } // GetUserCompanyMapByEmail retrieves UserCompanyMap by email. Returns error if email doesn't exist func GetUserCompanyMapByEmail(o orm.Ormer, email string) (v *UserCompanyMap, err error) { v = &UserCompanyMap{Email: email} if err = o.Read(v, "email"); err == nil { return v, nil } return nil, err } // GetAllUserCompanyMap retrieves all UserCompanyMap matches certain condition. Returns empty list if // no records exist func GetAllUserCompanyMap(o orm.Ormer, query map[string]string, fields []string, sortby []string, order []string, offset int64, limit int64) (ml []interface{}, err error) { qs := o.QueryTable(new(UserCompanyMap)) // query k=v for k, v := range query { // rewrite dot-notation to Object__Attribute k = strings.Replace(k, ".", "__", -1) if strings.Contains(k, "isnull") { qs = qs.Filter(k, (v == "true" || v == "1")) } else { qs = qs.Filter(k, v) } } // order by: var sortFields []string if len(sortby) != 0 { if len(sortby) == len(order) { // 1) for each sort field, there is an associated order for i, v := range sortby { orderby := "" if order[i] == "desc" { orderby = "-" + v } else if order[i] == "asc" { orderby = v } else { return nil, errors.New("Error: Invalid order. Must be either [asc|desc]") } sortFields = append(sortFields, orderby) } qs = qs.OrderBy(sortFields...) } else if len(sortby) != len(order) && len(order) == 1 { // 2) there is exactly one order, all the sorted fields will be sorted by this order for _, v := range sortby { orderby := "" if order[0] == "desc" { orderby = "-" + v } else if order[0] == "asc" { orderby = v } else { return nil, errors.New("Error: Invalid order. Must be either [asc|desc]") } sortFields = append(sortFields, orderby) } } else if len(sortby) != len(order) && len(order) != 1 { return nil, errors.New("Error: 'sortby', 'order' sizes mismatch or 'order' size is not 1") } } else { if len(order) != 0 { return nil, errors.New("Error: unused 'order' fields") } } var l []UserCompanyMap qs = qs.OrderBy(sortFields...) if _, err = qs.Limit(limit, offset).All(&l, fields...); err == nil { if len(fields) == 0 { for _, v := range l { ml = append(ml, v) } } else { // trim unused fields for _, v := range l { m := make(map[string]interface{}) val := reflect.ValueOf(v) for _, fname := range fields { m[fname] = val.FieldByName(fname).Interface() } ml = append(ml, m) } } return ml, nil } return nil, err } // UpdateUserCompanyMapById updates UserCompanyMap by Id and returns error if the record to be updated doesn't exist func UpdateUserCompanyMapById(o orm.Ormer, m *UserCompanyMap) (err error) { v := UserCompanyMap{ID: m.ID} // ascertain id exists in the database if err = o.Read(&v); err == nil { var num int64 if num, err = o.Update(m); err == nil { fmt.Println("Number of records updated in database:", num) } } return } // DeleteUserCompanyMap deletes UserCompanyMap by Id and returns error if // the record to be deleted doesn't exist func DeleteUserCompanyMap(o orm.Ormer, id int) (err error) { v := UserCompanyMap{ID: id} // ascertain id exists in the database if err = o.Read(&v); err == nil { var num int64 if num, err = o.Delete(&UserCompanyMap{ID: id}); err == nil { fmt.Println("Number of records deleted in database:", num) } } return }