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) } }) }
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 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 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 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(¬ificationData); 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(¬ification) 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 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) } }) }
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) } }) }
func registerRoutes(e *gin.Engine) { controller := rc.ResourceController{} controller.DatabaseProvider = Database resourceNames := []string{"RecordMatchContext", "RecordMatchSystemInterface", "RecordSet"} for _, name := range resourceNames { e.GET("/"+name+"/:id", controller.GetResource) e.POST("/"+name, controller.CreateResource) e.PUT("/"+name+"/:id", controller.UpdateResource) e.DELETE("/"+name+"/:id", controller.DeleteResource) e.GET("/"+name, controller.GetResources) } e.POST("/AnswerKey", controller.SetAnswerKey) name := "RecordMatchRun" e.GET("/"+name, controller.GetResources) e.GET("/"+name+"/:id", controller.GetResource) e.POST("/"+name, rc.CreateRecordMatchRunHandler(Database)) e.PUT("/"+name+"/:id", controller.UpdateResource) e.DELETE("/"+name+"/:id", controller.DeleteResource) e.GET("/RecordMatchRunMetrics", rc.GetRecordMatchRunMetricsHandler(Database)) e.GET("/RecordMatchRunLinks/:id", rc.GetRecordMatchRunLinksHandler(Database)) e.Static("/ptmatch/api/", "api") }
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) } }) }
func RegisterRoutes(r *gin.Engine) { r.GET("/", func(c *gin.Context) { // c.String(http.StatusOK, "this is our home page") c.HTML(http.StatusOK, "index.html", nil) }) // --------------------------- user apis --------------- r.POST("/v1/users", controllers.User_new) r.GET("/v1/users/:userId", controllers.User_get) r.PUT("/v1/users/:userId", controllers.User_update) r.DELETE("/v1/users/:userId", controllers.User_delete) // --------------------------- system apis --------------- r.GET("/sys/install", controllers.Sys_getInstall) r.POST("/sys/install", controllers.Sys_install) }
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) } }) }
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 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) } }) }
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 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) } }) }
func (h *UserHandlers) RegisterHandlers(g *gin.Engine) { g.GET("/user", h.All) g.GET("/user/:id", h.GetUser) g.PUT("/user", h.CreateUser) g.POST("/user/:id", h.UpdateUser) g.DELETE("/user/:id", h.DeleteUser) g.POST("/user/:id/password", h.ChangePassword) }
// Controller for taxonomies resources func Controller(r *gin.Engine, db *sql.DB) { r.GET("/taxonomies", func(c *gin.Context) { taxonomies, err := ListAllTaxonomies(db) if err != nil { c.AbortWithError(400, err) return } c.Header("Content-Type", "application/json") c.String(200, taxonomies) }) r.POST("/taxonomy", func(c *gin.Context) { tax := new(Taxonomy) err := c.BindJSON(&tax) if err != nil { c.Error(err) return } err = CreateTaxonomy(tax, db) if err != nil { c.AbortWithError(400, err) return } c.String(200, "") }) r.DELETE("/taxonomy/:id", func(c *gin.Context) { defer func() { if r := recover(); r != nil { c.AbortWithError(400, r.(error)) } }() id := getID(c) err := DeleteTaxonomy(id, db) if err != nil { panic(err) } c.String(200, "") }) r.PUT("/taxonomy/:id", func(c *gin.Context) { defer func() { if r := recover(); r != nil { c.AbortWithError(400, r.(error)) } }() id := getID(c) tax := new(Taxonomy) err := c.BindJSON(&tax) if err != nil { panic(err) } err = UpdateTaxonomy(id, tax, db) if err != nil { c.AbortWithError(400, err) return } c.String(200, "") }) }
func (tr *TemplatesResource) RegisterRoutes(c *gin.Engine) { c.GET("/api/templates", tr.Index) c.GET("/api/templates/:id", tr.Show) c.POST("/api/templates", tr.Create) c.POST("/api/templates/:id", tr.Update) c.PUT("/api/templates/:id", tr.Update) c.DELETE("/api/templates/:id", tr.Delete) c.POST("/api/templates/:id/convert", tr.Convert) c.POST("/api/convert", tr.ConvertRaw) }
func Use(router *gin.Engine) { // pets router.GET("/pets", pets.Index) router.GET("/pets/:id", pets.Show) router.POST("/pets", pets.Create) router.PUT("/pets/:id", pets.Update) // owners router.GET("/owners", owners.Index) router.POST("/owners", owners.Create) // tasks router.GET("/tasks", tasks.Index) router.GET("/tasks/:id", tasks.Show) router.POST("/tasks", tasks.Create) router.PUT("/tasks/:id", tasks.Update) }
func Register(r *gin.Engine) { r.Use(func(c *gin.Context) { // Run this on all requests // Should be moved to a proper middleware c.Writer.Header().Set("Access-Control-Allow-Origin", "*") c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type,Token") c.Next() }) r.GET("/", func(c *gin.Context) { c.String(200, "Y'all ready for this? \n\nOh no! They were ready for that.") //c.JSON(200, gin.H{"Pong": "Ping"}) }) //Auth authHandler := new(handlers.CCAuthHandler) r.POST("/auth/login", authHandler.BasicAuth) //Middleware // r.Use(authHandler.TokenAuthMiddleware()) // User routes userApi := new(api.CCUser) r.GET("/user", userApi.Get) r.POST("/user", userApi.Post) r.DELETE("/user", userApi.Delete) // Program routes programApi := new(api.CCProgram) r.GET("/program", programApi.Get) r.POST("/program", programApi.Post) r.DELETE("/program", programApi.Delete) // Event routes eventApi := new(api.CCEvent) r.GET("/event", eventApi.Get) r.POST("/event", eventApi.Post) r.PUT("/event/edit", eventApi.Edit) r.DELETE("/event", eventApi.Delete) // Volunteer routes volunteerApi := new(api.CCVolunteer) r.GET("/event/volunteer", volunteerApi.Get) r.POST("/event/volunteer", volunteerApi.Post) r.PUT("/event/volunteer/log", volunteerApi.LogTime) r.DELETE("/event/volunteer", volunteerApi.Delete) // Moments routes momentApi := new(api.CCMoment) r.GET("/event/moment", momentApi.Get) r.DELETE("/event/moment", momentApi.Delete) r.POST("/event/moment", momentApi.Post) //Rating r.POST("/event/moment/rate", momentApi.Rate) //Credits r.GET("/event/moment/credit", momentApi.Credit) //Image Upload //Auth uploadHandler := new(handlers.CCUploadHandler) r.POST("/upload", uploadHandler.Upload) }
func BindPlayerRoutes(router *gin.Engine) { router.GET("/api/v1/players", GetPlayers) router.POST("/api/v1/players", CreatePlayer) router.PUT("/api/v1/players/:id", UpdatePlayer) }