func PostLike(db gorm.DB, router *gin.Engine) { // POST /like // POST new like to database router.POST("/like", func(c *gin.Context) { var likeData model.LikeData if err := c.BindJSON(&likeData); err == nil { like := &model.Like{ LikeData: likeData, } var x_user uint64 if resp := c.Request.Header.Get(userHeader); resp != "" { conv_user, _ := strconv.ParseUint(resp, 10, 64) x_user = conv_user like.Trace.CreatedBy = x_user like.Trace.UpdatedBy = x_user if err := checkDataLike(like.LikeData); err { if err := db.Create(&like).Error; err != nil { c.AbortWithError(http.StatusBadRequest, err) } else { c.JSON(http.StatusCreated, like) } } else { c.AbortWithStatus(http.StatusBadRequest) } } else { c.AbortWithStatus(http.StatusForbidden) } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
func PostActivity(db gorm.DB, router *gin.Engine) { // POST /activity // POST new activity to database router.POST("/activity", func(c *gin.Context) { var activityData model.ActivityData if err := c.BindJSON(&activityData); err == nil { activity := &model.Activity{ ActivityData: activityData, } var x_user uint64 if resp := c.Request.Header.Get(userHeader); resp != "" { conv_user, _ := strconv.ParseUint(resp, 10, 64) x_user = conv_user activity.Trace.CreatedBy = x_user activity.Trace.UpdatedBy = x_user if err := checkDataActivity(activity.ActivityData); err { if err := db.Create(&activity).Error; err != nil { c.AbortWithError(http.StatusBadRequest, err) } else { c.JSON(http.StatusCreated, activity) } } else { c.AbortWithStatus(http.StatusBadRequest) } } else { c.AbortWithStatus(http.StatusForbidden) } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
// releasesCreate creates a new Release and inserts it into the database. func releasesCreate(db *gorm.DB, release *Release) (*Release, error) { t := db.Begin() // Get the last release version for this app. v, err := releasesLastVersion(t, release.App.ID) if err != nil { t.Rollback() return release, err } // Increment the release version. release.Version = v + 1 if err := t.Create(release).Error; err != nil { t.Rollback() return release, err } if err := t.Commit().Error; err != nil { t.Rollback() return release, err } return release, nil }
// addSkip adds skip parameter into sql query func addSkip(query *gorm.DB, skip int) *gorm.DB { if skip > 0 { return query.Offset(skip) } return query }
func isAuthorized(db *gorm.DB, nameOfTable, header string) (*authPair, bool) { // blank login and password with ":" separator return, in base64, a size of 10 char if len(header) <= 10 { return nil, false } var i int var u authPair var cred string // get credentials from header if value, err := base64.StdEncoding.DecodeString(header[6:]); err != nil { return nil, false } else { cred = string(value) } // check ":" separator i = strings.Index(cred, ":") // check present in database db.Table(nameOfTable).Select( "identifiant, mot_de_passe").Where( "identifiant=? and mot_de_passe=?", cred[:i], cred[i+1:]).Find(&u) if reflect.DeepEqual(u, authPair{}) { return nil, false } // success return &u, true }
func MediaCreate(db gorm.DB, r render.Render, media models.Media) { if err := db.Save(&media).Error; err != nil { r.JSON(http.StatusConflict, map[string]interface{}{"error": "Media conflict"}) return } r.JSON(http.StatusCreated, media) }
func AddUserFile(db *gorm.DB, udt *UserFileInfo, content []byte) error { lastId, err := getLastFileIdByUserId(db, udt.UserId) if err != nil { revel.TRACE.Println(err) return err } nextId := lastId + 1 // revel.INFO.Println("Next DS id: ", nextId) udt.FileId = nextId err = db.Save(udt).Error if err != nil { revel.TRACE.Println(err) return err } ds := &UserFile{ UserId: udt.UserId, FileId: udt.FileId, Content: content, } err = db.Save(ds).Error if err != nil { revel.TRACE.Println(err) return err } return err }
func AddTables(db *gorm.DB) error { err := db.AutoMigrate(UserFileInfo{}).Error if err != nil { return err } return db.AutoMigrate(UserFile{}).Error }
func PutGroupAdmin(db gorm.DB, router *gin.Engine) { // PUT /group_admin // Update group_admin data by id router.PUT("/group_admin/:id", func(c *gin.Context) { _id := c.Param("id") if id, err := strconv.ParseUint(_id, 10, 64); err == nil { var group_adminData model.GroupAdminData if err := c.BindJSON(&group_adminData); err == nil { group_admin := &model.GroupAdmin{ GroupAdminData: group_adminData, GroupAdminId: model.GroupAdminId{Id: id}, } if err := checkDataGroupAdmin(group_admin.GroupAdminData); err { checkGroupAdmin := &model.GroupAdmin{ GroupAdminData: group_adminData, GroupAdminId: model.GroupAdminId{Id: id}, } if err := db.First(checkGroupAdmin).Error; err == nil { db.Save(&group_admin) c.JSON(http.StatusOK, group_admin) } else { c.AbortWithStatus(http.StatusNotFound) } } else { c.AbortWithStatus(http.StatusBadRequest) } } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
func PostGroupAdmin(db gorm.DB, router *gin.Engine) { // POST /group_admin // POST new group_admin to database router.POST("/group_admin", func(c *gin.Context) { var group_adminData model.GroupAdminData if err := c.BindJSON(&group_adminData); err == nil { group_admin := &model.GroupAdmin{ GroupAdminData: group_adminData, } var x_user uint64 if resp := c.Request.Header.Get(userHeader); resp != "" { conv_user, _ := strconv.ParseUint(resp, 10, 64) x_user = conv_user group_admin.Trace.CreatedBy = x_user group_admin.Trace.UpdatedBy = x_user if err := checkDataGroupAdmin(group_admin.GroupAdminData); err { if err := db.Create(&group_admin).Error; err != nil { c.AbortWithError(http.StatusBadRequest, err) } else { c.JSON(http.StatusCreated, group_admin) } } else { c.AbortWithStatus(http.StatusBadRequest) } } else { c.AbortWithStatus(http.StatusForbidden) } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
func AllDistinctDates(db gorm.DB) []Date { var results []Date scope := db.Table("media").Select("date_part('day', taken_at) as day, date_part('month', taken_at) as month, date_part('year', taken_at) as year") scope = scope.Group("day, month, year").Order("year, month, day") scope.Scan(&results) return results }
func compositeIndex(table *gorm.DB, kind string, primary_key string, dst interface{}, parents []string) { index_name := "idx_" + kind + "_" + primary_key indexes := []string{primary_key} if len(parents) == 0 { parents = []string{} st := reflect.TypeOf(dst).Elem() for i := 0; i < st.NumField(); i++ { field := st.Field(i) pacific_parent := field.Tag.Get("pacific_parent") if pacific_parent != "" { parents = append(parents, pacific_parent) } } } for _, parent := range parents { if parent != "" { index_name = index_name + "_" + parent indexes = append(indexes, parent) } } if len(indexes) > 0 { table.AddUniqueIndex(index_name, indexes...) //TODO: if not exists? } }
func isAuthorized(db *gorm.DB, nameOfTable, header string) (*authPair, bool) { var i int var u authPair var cred string // get credentials from header if value, err := base64.StdEncoding.DecodeString(header); err != nil { return nil, false } else { cred = string(value) } // check format if i = strings.Index(cred, ":"); len(cred) < 8 || i < 8 { return nil, false } // check present in database db.Table(nameOfTable).Select( "identifiant, mot_de_passe").Where( "identifiant=? and mot_de_passe=?", cred[6:i], cred[i:]).Find(&u) if reflect.DeepEqual(u, authPair{}) { return nil, false } // success return &u, true }
func storeFact(Fact *models.Fact, db *gorm.DB) (*models.Fact, error) { var err error if Fact == nil { return nil, errors.New("save: fact is nil") } if Fact.ID == 0 { err := db.Create(Fact).Error if err != nil { return nil, err } } var f models.Fact if err := db.Where(&models.Fact{ID: Fact.ID}).First(&f).Error; err != nil { return nil, err } if err := db.Where(f.ActionID).First(&f.Action).Error; err != nil { return nil, err } err = db.Where(f.ContactID).First(&f.Contact).Error if err != nil { //&& err != gorm.RecordNotFound return nil, err } if err == nil { if err := db.Where(f.Contact.AddressID).First(&f.Contact.Address).Error; err != nil { //&& err != gorm.RecordNotFound return nil, err } } return &f, nil }
func PutActivity(db gorm.DB, router *gin.Engine) { // PUT /activity // Update activity data by id router.PUT("/activity/:id", func(c *gin.Context) { _id := c.Param("id") if id, err := strconv.ParseUint(_id, 10, 64); err == nil { var activityData model.ActivityData if err := c.BindJSON(&activityData); err == nil { activity := &model.Activity{ ActivityData: activityData, ActivityId: model.ActivityId{Id: id}, } if err := checkDataActivity(activity.ActivityData); err { checkActivity := &model.Activity{ ActivityData: activityData, ActivityId: model.ActivityId{Id: id}, } if err := db.First(checkActivity).Error; err == nil { db.Save(&activity) c.JSON(http.StatusOK, activity) } else { c.AbortWithStatus(http.StatusNotFound) } } else { c.AbortWithStatus(http.StatusBadRequest) } } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
func getPlayerWeapons(db *gorm.DB, player uint) []WeaponStat { // have some initial capacity ws := make([]WeaponStat, 0, 10) rows, err := db.Table("weapon_stats"). Select("type, sum(weapon_stats.shots) as shots, sum(weapon_stats.hits) as hits, sum(weapon_stats.kills) as kills"). Joins("join player_match_stats on weapon_stats.player_match_stat_id = player_match_stats.id"). Joins("join aliases on player_match_stats.alias_id = aliases.id"). Where("aliases.player_id = ?", player). Group("weapon_stats.type"). Rows() if err != nil { log.Printf("query failed: %s", err) return ws } for rows.Next() { var t string // type var k, s, h uint // kills, shots, hits if err := rows.Scan(&t, &s, &h, &k); err != nil { log.Printf("failed to scan row: %s", err) } log.Printf("stats: %s %v %v %v", t, s, h, k) ws = append(ws, WeaponStat{ Shots: s, Kills: k, Hits: h, Type: t, }) } return ws }
func PutLike(db gorm.DB, router *gin.Engine) { // PUT /like // Update like data by id router.PUT("/like/:id", func(c *gin.Context) { _id := c.Param("id") if id, err := strconv.ParseUint(_id, 10, 64); err == nil { var likeData model.LikeData if err := c.BindJSON(&likeData); err == nil { like := &model.Like{ LikeData: likeData, LikeId: model.LikeId{Id: id}, } if err := checkDataLike(like.LikeData); err { checkLike := &model.Like{ LikeData: likeData, LikeId: model.LikeId{Id: id}, } if err := db.First(checkLike).Error; err == nil { db.Save(&like) c.JSON(http.StatusOK, like) } else { c.AbortWithStatus(http.StatusNotFound) } } else { c.AbortWithStatus(http.StatusBadRequest) } } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
func PostWallEntry(db gorm.DB, router *gin.Engine) { // POST /wall_entry // POST new wall_entry to database router.POST("/wall_entry", func(c *gin.Context) { var wall_entryData model.WallEntryData if err := c.BindJSON(&wall_entryData); err == nil { wall_entry := &model.WallEntry{ WallEntryData: wall_entryData, } var x_user uint64 if resp := c.Request.Header.Get(userHeader); resp != "" { conv_user, _ := strconv.ParseUint(resp, 10, 64) x_user = conv_user wall_entry.Trace.CreatedBy = x_user wall_entry.Trace.UpdatedBy = x_user if err := checkDataWallEntry(wall_entry.WallEntryData); err { if err := db.Create(&wall_entry).Error; err != nil { c.AbortWithError(http.StatusBadRequest, err) } else { c.JSON(http.StatusCreated, wall_entry) } } else { c.AbortWithStatus(http.StatusBadRequest) } } else { c.AbortWithStatus(http.StatusForbidden) } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
func DropTables(db *gorm.DB) error { err := db.DropTable(UserFileInfo{}).Error if err != nil { return err } return db.DropTable(UserFile{}).Error }
func PutWallEntry(db gorm.DB, router *gin.Engine) { // PUT /wall_entry // Update wall_entry data by id router.PUT("/wall_entry/:id", func(c *gin.Context) { _id := c.Param("id") if id, err := strconv.ParseUint(_id, 10, 64); err == nil { var wall_entryData model.WallEntryData if err := c.BindJSON(&wall_entryData); err == nil { wall_entry := &model.WallEntry{ WallEntryData: wall_entryData, WallEntryId: model.WallEntryId{Id: id}, } if err := checkDataWallEntry(wall_entry.WallEntryData); err { checkWallEntry := &model.WallEntry{ WallEntryData: wall_entryData, WallEntryId: model.WallEntryId{Id: id}, } if err := db.First(checkWallEntry).Error; err == nil { db.Save(&wall_entry) c.JSON(http.StatusOK, wall_entry) } else { c.AbortWithStatus(http.StatusNotFound) } } else { c.AbortWithStatus(http.StatusBadRequest) } } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
func ClassifyPost(params martini.Params, res http.ResponseWriter, cls models.Classify, db *gorm.DB) string { db.Save(&cls) fi, err := os.Open("./jade/layout-tmpl.jade") if err != nil { panic(err) } defer fi.Close() fd, err2 := ioutil.ReadAll(fi) f, err2 := os.OpenFile("./jade/layout.jade", os.O_RDWR, 0755) if err2 != nil { panic(err) } css := []models.Classify{} db.Find(&css) var buf bytes.Buffer for _, v := range css { buf.WriteString(" a(href=\"/" + v.Url + ".html\") " + v.Title + "\n") } w := strings.Replace(string(fd), "####", buf.String(), -1) n, err1 := io.WriteString(f, w) //写入文件(字符串) if err1 != nil { panic(err1) } fmt.Printf("写入 %d 个字节n", n) return "1" }
func PutFile(db gorm.DB, router *gin.Engine) { // PUT /file // Update file data by id router.PUT("/file/:id", func(c *gin.Context) { _id := c.Param("id") if id, err := strconv.ParseUint(_id, 10, 64); err == nil { var fileData model.FileData if err := c.BindJSON(&fileData); err == nil { file := &model.File{ FileData: fileData, FileId: model.FileId{Id: id}, } if err := checkDataFile(file.FileData); err { checkFile := &model.File{ FileData: fileData, FileId: model.FileId{Id: id}, } if err := db.First(checkFile).Error; err == nil { db.Save(&file) c.JSON(http.StatusOK, file) } else { c.AbortWithStatus(http.StatusNotFound) } } else { c.AbortWithStatus(http.StatusBadRequest) } } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
// BeforeSave invokes required actions before persisting. func (u *Team) BeforeSave(db *gorm.DB) (err error) { if u.Slug == "" { for i := 0; true; i++ { if i == 0 { u.Slug = slugify.Slugify(u.Name) } else { u.Slug = slugify.Slugify( fmt.Sprintf("%s-%d", u.Name, i), ) } notFound := db.Where( "slug = ?", u.Slug, ).Not( "id", u.ID, ).First( &Team{}, ).RecordNotFound() if notFound { break } } } return nil }
func GroupCreate(db gorm.DB, r render.Render, group models.Group) { if err := db.Save(&group).Error; err != nil { r.JSON(http.StatusConflict, map[string]interface{}{"error": "Group conflict"}) return } r.JSON(http.StatusCreated, group) }
// addPluck basically adds select statement for // only required fields func addPluck(query *gorm.DB, plucked string) *gorm.DB { if plucked == "" { return query } return query.Select(plucked) }
// BeforeSave invokes required actions before persisting. func (u *User) BeforeSave(db *gorm.DB) (err error) { if u.Slug == "" { for i := 0; true; i++ { if i == 0 { u.Slug = slugify.Slugify(u.Username) } else { u.Slug = slugify.Slugify( fmt.Sprintf("%s-%d", u.Username, i), ) } notFound := db.Where( "slug = ?", u.Slug, ).Not( "id", u.ID, ).First( &User{}, ).RecordNotFound() if notFound { break } } } if u.Email != "" { email, err := govalidator.NormalizeEmail( u.Email, ) if err != nil { return fmt.Errorf("Failed to normalize email") } u.Email = email } if u.Password != "" { encrypt, err := bcrypt.GenerateFromPassword( []byte(u.Password), bcrypt.DefaultCost, ) if err != nil { return fmt.Errorf("Failed to encrypt password") } u.Hashword = string(encrypt) } if u.Hash == "" { u.Hash = base32.StdEncoding.EncodeToString( securecookie.GenerateRandomKey(32), ) } return nil }
func PutUserHttpSession(db gorm.DB, router *gin.Engine) { // PUT /user_http_session // Update user_http_session data by id router.PUT("/user_http_session/:id", func(c *gin.Context) { _id := c.Param("id") if id, err := strconv.ParseUint(_id, 10, 64); err == nil { var user_http_sessionData model.UserHttpSessionData if err := c.BindJSON(&user_http_sessionData); err == nil { user_http_session := &model.UserHttpSession{ UserHttpSessionData: user_http_sessionData, UserHttpSessionId: model.UserHttpSessionId{Id: id}, } if err := checkDataUserHttpSession(user_http_session.UserHttpSessionData); err { checkUserHttpSession := &model.UserHttpSession{ UserHttpSessionData: user_http_sessionData, UserHttpSessionId: model.UserHttpSessionId{Id: id}, } if err := db.First(checkUserHttpSession).Error; err == nil { db.Save(&user_http_session) c.JSON(http.StatusOK, user_http_session) } else { c.AbortWithStatus(http.StatusNotFound) } } else { c.AbortWithStatus(http.StatusBadRequest) } } } else { log.Print(err) c.AbortWithError(http.StatusBadRequest, err) } }) }
func initDb() (l *Logger) { exists := false var err error var db *gorm.DB if _, err := os.Stat(dbfile); err == nil { log.Println("Database file already exists.") exists = true } db, err = gorm.Open("sqlite3", dbfile) if err != nil { log.Printf("Unable to open database file: %s\n", err) return nil } if !exists { db.CreateTable(&LogMessage{}) } l = &Logger{ db: db, dbPath: dbfile, } return l }
func FacultiesDepartments(db *gorm.DB) ([]json_models.FacultiesDepartments, error) { var result []json_models.FacultiesDepartments err := db.Model(&models.Faculties{}).Select("id as faculty_id, short_name as faculty_name").Scan(&result).Error if err != nil { return nil, err } for i, faculty := range result { var records []models.Departments err := db.Preload("Faculty").Where("faculty_id = ?", faculty.FacultyId).Find(&records).Error if err != nil { return nil, err } if len(records) != 0 { for _, record := range records { val := json_models.Department{Id: record.Id, Name: record.Name} result[i].Departments = append(result[i].Departments, val) } } else { result[i].Departments = []json_models.Department{} } } return result, nil }
// GetRepo retrieves a specific repo from the database. func (db *data) GetRepo(id string) (*model.Repo, *gorm.DB) { var ( record = &model.Repo{} query *gorm.DB ) if match, _ := regexp.MatchString("^([0-9]+)$", id); match { val, _ := strconv.ParseInt(id, 10, 64) query = db.Where( "id = ?", val, ) } else { query = db.Where( "slug = ?", id, ) } res := query.Model( &record, ).Preload( "Org", ).Preload( "Org.Registry", ).Preload( "Tags", ).First( &record, ) return record, res }