Example #1
1
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 PutProfileFieldCategory(db gorm.DB, router *gin.Engine) {
	// PUT /profile_field_category
	// Update profile_field_category data by id
	router.PUT("/profile_field_category/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			var profile_field_categoryData model.ProfileFieldCategoryData
			if err := c.BindJSON(&profile_field_categoryData); err == nil {
				profile_field_category := &model.ProfileFieldCategory{
					ProfileFieldCategoryData: profile_field_categoryData,
					ProfileFieldCategoryId:   model.ProfileFieldCategoryId{Id: id},
				}
				if err := checkDataProfileFieldCategory(profile_field_category.ProfileFieldCategoryData); err {
					checkProfileFieldCategory := &model.ProfileFieldCategory{
						ProfileFieldCategoryData: profile_field_categoryData,
						ProfileFieldCategoryId:   model.ProfileFieldCategoryId{Id: id},
					}
					if err := db.First(checkProfileFieldCategory).Error; err == nil {
						db.Save(&profile_field_category)
						c.JSON(http.StatusOK, profile_field_category)
					} else {
						c.AbortWithStatus(http.StatusNotFound)
					}
				} else {
					c.AbortWithStatus(http.StatusBadRequest)
				}
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}
Example #3
0
func PutNotification(db gorm.DB, router *gin.Engine) {
	// PUT /notification
	// Update notification data by id
	router.PUT("/notification/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			var notificationData model.NotificationData
			if err := c.BindJSON(&notificationData); err == nil {
				notification := &model.Notification{
					NotificationData: notificationData,
					NotificationId:   model.NotificationId{Id: id},
				}
				if err := checkDataNotification(notification.NotificationData); err {
					checkNotification := &model.Notification{
						NotificationData: notificationData,
						NotificationId:   model.NotificationId{Id: id},
					}
					if err := db.First(checkNotification).Error; err == nil {
						db.Save(&notification)
						c.JSON(http.StatusOK, notification)
					} else {
						c.AbortWithStatus(http.StatusNotFound)
					}
				} else {
					c.AbortWithStatus(http.StatusBadRequest)
				}
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}
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)
		}
	})
}
Example #5
0
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)
		}
	})
}
Example #6
0
func PutPost(db gorm.DB, router *gin.Engine) {
	// PUT /post
	// Update post data by id
	router.PUT("/post/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			var postData model.PostData
			if err := c.BindJSON(&postData); err == nil {
				post := &model.Post{
					PostData: postData,
					PostId:   model.PostId{Id: id},
				}
				if err := checkDataPost(post.PostData); err {
					checkPost := &model.Post{
						PostData: postData,
						PostId:   model.PostId{Id: id},
					}
					if err := db.First(checkPost).Error; err == nil {
						db.Save(&post)
						c.JSON(http.StatusOK, post)
					} else {
						c.AbortWithStatus(http.StatusNotFound)
					}
				} else {
					c.AbortWithStatus(http.StatusBadRequest)
				}
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}
Example #7
0
func PutModuleEnabled(db gorm.DB, router *gin.Engine) {
	// PUT /module_enabled
	// Update module_enabled data by id
	router.PUT("/module_enabled/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			var module_enabledData model.ModuleEnabledData
			if err := c.BindJSON(&module_enabledData); err == nil {
				module_enabled := &model.ModuleEnabled{
					ModuleEnabledData: module_enabledData,
					ModuleEnabledId:   model.ModuleEnabledId{Id: id},
				}
				if err := checkDataModuleEnabled(module_enabled.ModuleEnabledData); err {
					checkModuleEnabled := &model.ModuleEnabled{
						ModuleEnabledData: module_enabledData,
						ModuleEnabledId:   model.ModuleEnabledId{Id: id},
					}
					if err := db.First(checkModuleEnabled).Error; err == nil {
						db.Save(&module_enabled)
						c.JSON(http.StatusOK, module_enabled)
					} else {
						c.AbortWithStatus(http.StatusNotFound)
					}
				} else {
					c.AbortWithStatus(http.StatusBadRequest)
				}
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}
Example #8
0
func PutContent(db gorm.DB, router *gin.Engine) {
	// PUT /content
	// Update content data by id
	router.PUT("/content/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			var contentData model.ContentData
			if err := c.BindJSON(&contentData); err == nil {
				content := &model.Content{
					ContentData: contentData,
					ContentId:   model.ContentId{Id: id},
				}
				if err := checkDataContent(content.ContentData); err {
					checkContent := &model.Content{
						ContentData: contentData,
						ContentId:   model.ContentId{Id: id},
					}
					if err := db.First(checkContent).Error; err == nil {
						db.Save(&content)
						c.JSON(http.StatusOK, content)
					} else {
						c.AbortWithStatus(http.StatusNotFound)
					}
				} else {
					c.AbortWithStatus(http.StatusBadRequest)
				}
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}
Example #9
0
func PutUrlOembed(db gorm.DB, router *gin.Engine) {
	// PUT /url_oembed
	// Update url_oembed data by id
	router.PUT("/url_oembed/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			var url_oembedData model.UrlOembedData
			if err := c.BindJSON(&url_oembedData); err == nil {
				url_oembed := &model.UrlOembed{
					UrlOembedData: url_oembedData,
					UrlOembedId:   model.UrlOembedId{Id: id},
				}
				if err := checkDataUrlOembed(url_oembed.UrlOembedData); err {
					checkUrlOembed := &model.UrlOembed{
						UrlOembedData: url_oembedData,
						UrlOembedId:   model.UrlOembedId{Id: id},
					}
					if err := db.First(checkUrlOembed).Error; err == nil {
						db.Save(&url_oembed)
						c.JSON(http.StatusOK, url_oembed)
					} else {
						c.AbortWithStatus(http.StatusNotFound)
					}
				} else {
					c.AbortWithStatus(http.StatusBadRequest)
				}
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}
Example #10
0
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)
		}
	})
}
Example #11
0
func PutSpaceSetting(db gorm.DB, router *gin.Engine) {
	// PUT /space_setting
	// Update space_setting data by id
	router.PUT("/space_setting/:id", func(c *gin.Context) {
		_id := c.Param("id")
		if id, err := strconv.ParseUint(_id, 10, 64); err == nil {
			var space_settingData model.SpaceSettingData
			if err := c.BindJSON(&space_settingData); err == nil {
				space_setting := &model.SpaceSetting{
					SpaceSettingData: space_settingData,
					SpaceSettingId:   model.SpaceSettingId{Id: id},
				}
				if err := checkDataSpaceSetting(space_setting.SpaceSettingData); err {
					checkSpaceSetting := &model.SpaceSetting{
						SpaceSettingData: space_settingData,
						SpaceSettingId:   model.SpaceSettingId{Id: id},
					}
					if err := db.First(checkSpaceSetting).Error; err == nil {
						db.Save(&space_setting)
						c.JSON(http.StatusOK, space_setting)
					} else {
						c.AbortWithStatus(http.StatusNotFound)
					}
				} else {
					c.AbortWithStatus(http.StatusBadRequest)
				}
			}
		} else {
			log.Print(err)
			c.AbortWithError(http.StatusBadRequest, err)
		}
	})
}
Example #12
0
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)
		}
	})
}
Example #13
0
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 findTodo(db *gorm.DB, predicate *todo) (*todo, error) {
	t := new(todo)
	err := db.First(t, predicate).Error
	if err != nil {
		return nil, err
	}
	return t, nil
}
func ProjectGet(db gorm.DB, r render.Render, params martini.Params) {
	var project models.Project
	if err := db.First(&project, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Project not found"})
		return
	}
	r.JSON(http.StatusOK, project)
}
Example #16
0
func MediaUpdate(db gorm.DB, r render.Render, params martini.Params, updatedMedia models.Media) {
	var media models.Media
	if err := db.First(&media, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Media not found"})
		return
	}
	db.Model(&media).Update(&updatedMedia)
	r.JSON(http.StatusOK, media)
}
Example #17
0
func MediaDelete(db gorm.DB, r render.Render, params martini.Params) {
	var media models.Media
	if err := db.First(&media, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Media not found"})
		return
	}
	db.Delete(media)
	r.JSON(http.StatusNoContent, nil)
}
Example #18
0
File: main.go Project: nsf/sqlrace
func naiveMethod(db *gorm.DB, num int, done chan bool) {
	for i := 0; i < num; i++ {
		var tt TestTable
		panicOnError(db.First(&tt, 1).Error)
		tt.Counter -= 1
		panicOnError(db.Save(&tt).Error)
	}
	done <- true
}
Example #19
0
func ormTest(db gorm.DB) []model.User {
	user := model.User{Name: "Jinzhu", Age: 18, Birthday: time.Now()}
	db.NewRecord(user) // => returns `true` if primary key is blank
	db.Create(&user)
	db.NewRecord(user) // => return `false` after `user` created
	users := []model.User{}
	db.First(&users)
	return users
}
Example #20
0
func GroupDelete(db gorm.DB, r render.Render, params martini.Params) {
	var group models.Group
	if err := db.First(&group, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Group not found"})
		return
	}
	db.Delete(group)
	r.JSON(http.StatusNoContent, nil)
}
Example #21
0
func GroupUpdate(db gorm.DB, r render.Render, params martini.Params, updatedGroup models.Group) {
	var group models.Group
	if err := db.First(&group, params["id"]).Error; err != nil {
		r.JSON(http.StatusNotFound, map[string]interface{}{"error": "Group not found"})
		return
	}
	db.Model(&group).Update(&updatedGroup)
	r.JSON(http.StatusOK, group)
}
Example #22
0
func MediaHead(db gorm.DB, r render.Render, params martini.Params) {
	media := models.Media{}
	id, _ := strconv.Atoi(params["id"])
	if err := db.First(&media, id).Error; err != nil {
		r.Error(http.StatusNotFound)
		return
	}
	r.Redirect(media.Url)
}
Example #23
0
func MediaPlay(db gorm.DB, r render.Render, params martini.Params) {
	media := models.Media{}
	id, _ := strconv.Atoi(params["id"])
	if err := db.First(&media, id).Error; err != nil {
		r.Error(http.StatusNotFound)
		return
	}
	db.Model(&media).Update(&models.Media{Played: media.Played + 1})
	r.Redirect(media.Url)
}
Example #24
0
// BeforeUpdate ensures that friendship balance is kept in sync
func (t *Transaction) BeforeUpdate(db *gorm.DB) (err error) {
	if t.RelatedObjectType != "Friendship" {
		return
	}
	var curTransaction Transaction
	db.First(&curTransaction, t.ID)
	ReverseTransaction(&curTransaction, db)
	// Now the AfterSave callback will use the new updated transaction
	// and update the balance accordingly
	return
}
Example #25
0
// GetSummariesByBranch retrieves the the Summary by repo and branch
func GetSummariesByBranch(db *gorm.DB, repoID string, branchID string) []Summary {
	var repo repo.Repository
	db.First(&repo, repoID)

	var sums []Summary
	// Latest summary
	db.Where(&Summary{
		BranchID:   branchID,
		Repository: repo,
	}).Order("summary_id").Find(&sums)
	return sums
}
Example #26
0
// GetComment returns one comment
func GetComment(params martini.Params, r render.Render, db *gorm.DB) {
	id := params["id"]

	var comment Comment
	db.First(&comment, id)

	if comment.ID == 0 {
		r.JSON(404, Error{404, "Comment was not found."})
	}

	r.JSON(200, comment)
}
Example #27
0
// GetSelection returns one selection
func GetSelection(params martini.Params, r render.Render, db *gorm.DB) {
	id := params["id"]

	var selection Selection
	db.First(&selection, id)

	if selection.ID == 0 {
		r.JSON(404, Error{404, "Selection was not found."})
	}

	r.JSON(200, selection)
}
Example #28
0
// UpdateStats Handles updating statistics relevant to our tracker.
func UpdateStats(dbConn *gorm.DB, uploaded uint64, downloaded uint64) {
	dbConn = assertOpenConnection(dbConn)

	ts := &schemas.TrackerStats{}
	dbConn.First(&ts)
	dbConn.Model(&ts).Updates(
		schemas.TrackerStats{
			Uploaded:   ts.Uploaded + int64(uploaded),
			Downloaded: ts.Downloaded + int64(downloaded),
		})

	return
}
Example #29
0
// UpdateTorrentStats Handles updating statistics relevant to our tracker.
func UpdateTorrentStats(dbConn *gorm.DB, seederDelta int64, leecherDelta int64) {
	dbConn = assertOpenConnection(dbConn)

	t := &schemas.Torrent{}
	dbConn.First(&t)
	dbConn.Model(&t).Updates(
		schemas.TrackerStats{
			Uploaded:   t.Seeders + seederDelta,
			Downloaded: t.Leechers + leecherDelta,
		})

	return
}
Example #30
0
// UpdatePeerStats handles updating peer info like hits per ip, downloaded
// amount, uploaded amounts.
func UpdatePeerStats(dbConn *gorm.DB, uploaded uint64, downloaded uint64, ip string) {
	dbConn = assertOpenConnection(dbConn)

	ps := &schemas.PeerStats{Ip: ip}
	dbConn.First(&ps)
	fmt.Printf("%v", *ps)
	dbConn.Model(&ps).UpdateColumn(map[string]interface{}{
		"Uploaded":   ps.Uploaded + int64(uploaded),
		"Downloaded": ps.Downloaded + int64(downloaded),
	})

	return
}