// create handling the creation of a new character
// curl -H "Content-Type: application/json" -X POST -d '{"name":"asdf"}' http://localhost:8989
func create(c *gin.Context) {
var newName struct {
Name string `json:"name"`
}
ch := NewCharacter{}
if err := c.BindJSON(&newName); err != nil {
c.JSON(http.StatusBadRequest, ErrorResponse{"error while binding newName:" + err.Error()})
return
}
checkSum := sha1.Sum([]byte(newName.Name))
ch.CharacterID = fmt.Sprintf("%x", checkSum)
char := createCharacter(ch.CharacterID, newName.Name)
log.Println("Saving character:", char)
err := mdb.Save(char)
if err != nil {
c.JSON(http.StatusBadRequest, ErrorResponse{"error while saving character:" + err.Error()})
return
}
c.JSON(http.StatusCreated, char)
}
// curl -H "Content-Type: application/json" -X POST -d '{"commentableId":3,"commentableType":"post","body":"the body of a comment"}' http://localhost:9999/comments
// CommentCreate creates a comment, validates that it belongs to something commentable
func CommentCreate(c *gin.Context) {
var comment models.Comment
if c.BindJSON(&comment) == nil {
comment.UserID = 1
if comment.CommentableType == "post" {
_, err := models.GetPost(comment.CommentableID)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"status": "not found"})
return
}
} else if comment.CommentableType == "comment" {
_, err := models.GetComment(comment.CommentableID)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"status": "not found"})
return
}
} else {
c.JSON(http.StatusBadRequest, gin.H{"status": "bad request"})
return
}
// TODO: userID should come from session, commentable id/type maybe from route?
err := models.CreateComment(comment)
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"status": "bad request"})
} else {
// TODO: add location header with new resource url
c.JSON(http.StatusCreated, gin.H{"status": "created"})
}
} else {
c.JSON(http.StatusBadRequest, gin.H{"status": "bad request"})
}
}
func LoginHandler(c *gin.Context) {
var code int
var response gin.H
var loginData loginForm
c.BindJSON(&loginData)
errors := loginData.validate()
if len(errors) == 0 {
user, authErrors := authOrRegisterUser(loginData)
if authErrors["password"] != "" {
code = 422
response = gin.H{"success": false, "errors": authErrors}
} else {
code = 200
response = gin.H{
"success": true,
"new": user.RestoreCode != "",
"auth": gin.H{
"account": user.Email,
"token": createUserToken(user),
"roles": user.Roles,
},
}
}
} else {
code = 422
response = gin.H{"success": false, "errors": errors}
}
c.JSON(code, response)
}
func (ss *schedulerService) CreateOrUpdateShift(c *gin.Context) {
shift := &wiw.Shift{}
if err := c.BindJSON(shift); err != nil {
ss.handleError(c, err)
return
}
if shift.ManagerID == 0 {
//TODO: should use current user id
}
if c.Request.Method == "POST" {
if err := ss.repository.CreateShift(shift); err != nil {
ss.handleError(c, err)
return
}
} else {
shift.ID = uint(c.MustGet("id").(int))
if err := ss.repository.UpdateOrCreateShift(shift); err != nil {
ss.handleError(c, err)
return
}
}
c.JSON(http.StatusOK, gin.H{"shift": shift})
}
func pluginCreate(c *gin.Context) {
plugin := Plugin{}
response := gin.H{}
defer c.JSON(http.StatusOK, response)
if err := c.BindJSON(&plugin); err != nil {
response["code"] = http.StatusBadRequest
response["message"] = err.Error()
return
}
cnt := 0
mydb.Table("plugin").Where("name=?", plugin.Name).Count(&cnt)
if cnt > 0 {
response["code"] = http.StatusBadRequest
response["message"] = "plugin already exists"
return
}
if err := mydb.Set("gorm:save_associations", false).Save(&plugin).Error; err != nil {
response["code"] = http.StatusInternalServerError
response["message"] = err.Error()
return
}
mydb.Model(&plugin).Association("Hosts").Replace(plugin.Hosts).Find(&plugin.Hosts)
response["code"] = http.StatusOK
response["message"] = "user create successful"
response["plugin"] = plugin
}
func changePassword(c *gin.Context) {
request := struct {
ID int `json:'id'`
CurrentPassword string `json:"current_password"`
NewPassword string `json:"new_password"`
}{}
response := gin.H{}
defer c.JSON(http.StatusOK, response)
if err := c.BindJSON(&request); err != nil {
response["code"] = http.StatusBadRequest
response["message"] = err.Error()
return
}
currentUser := GetUser(c)
if !currentUser.IsAdmin() && currentUser.ID != request.ID {
response["code"] = 403
response["message"] = "You don't have permission to access."
return
}
if request.CurrentPassword == request.NewPassword {
response["code"] = http.StatusNotModified
response["message"] = "new password equal current password"
return
}
user := types.User{}
mydb.Table("user").Where("id = ?", request.ID).Find(&user)
if user.Password != utils.Md5(request.CurrentPassword) {
response["code"] = http.StatusNotModified
response["message"] = "current password is incorrect"
return
}
mydb.Table("user").Where("id = ?", request.ID).Update("password", utils.Md5(request.NewPassword))
response["code"] = http.StatusOK
response["message"] = "change password success"
}
func groupCreate(c *gin.Context) {
group := Group{}
response := gin.H{}
defer c.JSON(http.StatusOK, response)
if err := c.BindJSON(&group); err != nil {
response["code"] = http.StatusBadRequest
response["message"] = err.Error()
return
}
cnt := 0
mydb.Table("group").Where("name=?", group.Name).Count(&cnt)
if cnt > 0 {
response["code"] = http.StatusBadRequest
response["message"] = "group already exists"
return
}
if err := mydb.Set("gorm:save_associations", false).Save(&group).Error; err != nil {
response["code"] = http.StatusInternalServerError
response["message"] = err.Error()
return
}
mydb.Model(&group).Association("Hosts").Replace(group.Hosts).Find(&group.Hosts)
response["code"] = http.StatusOK
response["message"] = "group create successful"
response["group"] = group
}
func UpdateConfig(c *gin.Context) {
confWriteMux.Lock()
defer confWriteMux.Unlock()
data := &updateConfigData{}
if err := c.BindJSON(data); err != nil {
Error(c, BAD_POST_DATA, err.Error())
return
}
if err := verifyUpdateConfigData(data); err != nil {
Error(c, BAD_REQUEST, err.Error())
return
}
oldConfig := memConfRawConfigs[data.Key]
if oldConfig.K == data.K && oldConfig.V == data.V && oldConfig.VType == data.VType && oldConfig.Des == data.Des && oldConfig.Status == data.Status {
Success(c, nil)
return
}
config, err := updateConfigWithUpdateData(data, getOpUserKey(c))
if err != nil {
Error(c, SERVER_ERROR, err)
return
}
failedNodes := syncData2SlaveIfNeed(config, getOpUserKey(c))
if len(failedNodes) > 0 {
Success(c, map[string]interface{}{"failed_nodes": failedNodes})
} else {
Success(c, nil)
}
}
func InitUser(c *gin.Context) {
confWriteMux.Lock()
defer confWriteMux.Unlock()
if len(memConfUsers) > 0 {
Error(c, BAD_REQUEST, "users already exists")
return
}
data := &newUserData{}
if err := c.BindJSON(data); err != nil {
Error(c, BAD_POST_DATA, err.Error())
return
}
if err := verifyNewUserData(data); err != nil {
Error(c, BAD_REQUEST, err.Error())
return
}
key := utils.GenerateKey()
user, err := newUserWithNewUserData(data, key, key)
if err != nil {
Error(c, SERVER_ERROR, err.Error())
return
}
failedNodes := syncData2SlaveIfNeed(user, key)
setUserKeyCookie(c, user.Key, user.PassCode)
if len(failedNodes) > 0 {
Success(c, map[string]interface{}{"failed_nodes": failedNodes})
} else {
Success(c, nil)
}
}
func Login(c *gin.Context) {
var data struct {
Name string `json:"name" binding:"required"`
PassCode string `json:"pass_code" binding:"required"`
}
if err := c.BindJSON(&data); err != nil {
Error(c, BAD_POST_DATA, err.Error())
return
}
memConfMux.RLock()
user := memConfUsersByName[data.Name]
memConfMux.RUnlock()
if user == nil {
Error(c, USER_NOT_EXIST)
return
}
if user.PassCode != encryptUserPassCode(data.PassCode) {
Error(c, PASS_CODE_ERROR)
return
}
if user.Status == models.USER_STATUS_INACTIVE {
Error(c, USER_INACTIVE)
return
}
setUserKeyCookie(c, user.Key, user.PassCode)
Success(c, nil)
}
func NewConfig(c *gin.Context) {
confWriteMux.Lock()
defer confWriteMux.Unlock()
data := &newConfigData{}
if err := c.BindJSON(data); err != nil {
Error(c, BAD_POST_DATA, err.Error())
return
}
if err := verifyNewConfigData(data); err != nil {
Error(c, BAD_REQUEST, err.Error())
return
}
config, err := newConfigWithNewConfigData(data, getOpUserKey(c))
if err != nil {
Error(c, SERVER_ERROR, err.Error())
return
}
failedNodes := syncData2SlaveIfNeed(config, getOpUserKey(c))
if len(failedNodes) > 0 {
Success(c, map[string]interface{}{"failed_nodes": failedNodes})
} else {
Success(c, nil)
}
}
func UpdateApp(c *gin.Context) {
confWriteMux.Lock()
defer confWriteMux.Unlock()
var data struct {
Key string `json:"key" binding:"required"`
Name string `json:"name" binding:"required"`
Type string `json:"type" binding:"required"`
AuxInfo string `json:"aux_info"`
}
if err := c.BindJSON(&data); err != nil {
Error(c, BAD_POST_DATA, err.Error())
return
}
if !models.IsValidAppType(data.Type) {
Error(c, BAD_REQUEST, "unknown app type: "+data.Type)
return
}
oldApp := memConfApps[data.Key]
if oldApp == nil {
Error(c, BAD_REQUEST, "app key not exists: "+data.Key)
return
}
if oldApp.Name == data.Name && oldApp.AuxInfo == data.AuxInfo && oldApp.Type == data.Type {
Success(c, nil)
return
}
if oldApp.Type == models.APP_TYPE_TEMPLATE && oldApp.Type != data.Type {
Error(c, BAD_REQUEST, "can not change template app to real app")
return
}
if memConfApps[data.Key].Name != data.Name {
for _, app := range memConfApps {
if app.Name == data.Name {
Error(c, BAD_REQUEST, "appname already exists: "+data.Name)
return
}
}
}
app := *oldApp
app.Name = data.Name
app.AuxInfo = data.AuxInfo
if _, err := updateApp(&app, nil, nil); err != nil {
Error(c, SERVER_ERROR, err.Error())
return
}
failedNodes := syncData2SlaveIfNeed(&app, getOpUserKey(c))
if len(failedNodes) > 0 {
Success(c, map[string]interface{}{"failed_nodes": failedNodes})
} else {
Success(c, nil)
}
}
func UpdateUserPassCode(c *gin.Context) {
confWriteMux.Lock()
defer confWriteMux.Unlock()
var data struct {
PassCode string `json:"pass_code" binding:"required"`
}
if err := c.BindJSON(&data); err != nil {
Error(c, BAD_POST_DATA, err.Error())
return
}
user := *memConfUsers[getOpUserKey(c)]
user.PassCode = encryptUserPassCode(data.PassCode)
if _, err := updateUser(&user, nil); err != nil {
Error(c, SERVER_ERROR, err.Error())
return
}
setUserKeyCookie(c, user.Key, user.PassCode)
failedNodes := syncData2SlaveIfNeed(&user, getOpUserKey(c))
if len(failedNodes) > 0 {
Success(c, map[string]interface{}{"failed_nodes": failedNodes})
} else {
Success(c, nil)
}
}
func UpdateUser(c *gin.Context) {
confWriteMux.Lock()
defer confWriteMux.Unlock()
data := &updateUserData{}
if err := c.BindJSON(data); err != nil {
Error(c, BAD_POST_DATA, err.Error())
return
}
if err := verifyUpdateUserData(data, getOpUserKey(c)); err != nil {
Error(c, BAD_REQUEST, err.Error())
return
}
oldUser := memConfUsers[getOpUserKey(c)]
if oldUser.AuxInfo == data.AuxInfo && oldUser.Name == data.Name {
Success(c, nil)
return
}
user, err := updateUserWithUpdateData(data, getOpUserKey(c))
if err != nil {
Error(c, SERVER_ERROR, err.Error())
return
}
failedNodes := syncData2SlaveIfNeed(user, getOpUserKey(c))
if len(failedNodes) > 0 {
Success(c, map[string]interface{}{"failed_nodes": failedNodes})
} else {
Success(c, nil)
}
}
//DownloadPacket starts the download of a packet
func (dc *DownloadsController) startDirectDownload(c *gin.Context) {
var download models.DirectDownload
c.BindJSON(&download)
dc.IrcClient.AddDirectDownload(&download)
OK(c)
}
//TaskCreate serves the route POST /tasks
func TaskCreate(c *gin.Context) {
models.InTx(func(txn *gorm.DB) bool {
var task models.Task
if err := c.BindJSON(&task); err != nil {
c.JSON(http.StatusBadRequest, err)
return false
}
if valid, errMap := models.ValidStruct(&task); !valid {
c.JSON(http.StatusConflict, errMap)
return false
}
var taskExistent models.Task
models.Gdb.Where("id like ?", task.ID).First(&taskExistent)
var err error
if task.ID != "" && taskExistent.ID != "" {
taskExistent.Periodicity = task.Periodicity
taskExistent.Command = task.Command
err = txn.Save(&taskExistent).Error
} else {
err = txn.Create(&task).Error
}
if err != nil {
c.JSON(http.StatusBadRequest, "Couldn't create the task")
return false
}
c.JSON(http.StatusOK, task)
return true
})
}
func userUpdate(c *gin.Context) {
user := User{}
response := gin.H{}
defer c.JSON(http.StatusOK, response)
if err := c.BindJSON(&user); err != nil {
response["code"] = http.StatusBadRequest
response["message"] = err.Error()
return
}
currentUser := GetUser(c)
if !currentUser.IsAdmin() && currentUser.ID != user.ID {
response["code"] = 403
response["message"] = "You don't have permission to access."
return
}
if err := mydb.Set("gorm:save_associations", false).Table("user").
Select("username", "role", "phone", "mail", "weixin", "status").Save(&user).
Association("Groups").Replace(user.Groups).Error; err != nil {
response["code"] = http.StatusInternalServerError
response["message"] = err.Error()
return
}
response["code"] = http.StatusOK
response["message"] = "user update successful"
}
func (service *metricsService) createMetric(c *gin.Context) {
var entry common.MetricEntry
if err := c.BindJSON(&entry); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err})
c.Abort()
return
}
entry.Time = time.Now().UTC()
b, err := json.Marshal(entry)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": err})
c.Abort()
return
}
if err := service.connector.Publish(b); err != nil {
log.Println("error", err)
c.JSON(http.StatusInternalServerError, gin.H{"error": err})
c.Abort()
return
}
c.JSON(http.StatusOK, entry)
}
func userCreate(c *gin.Context) {
user := User{}
response := gin.H{}
defer c.JSON(http.StatusOK, response)
if err := c.BindJSON(&user); err != nil {
response["code"] = http.StatusBadRequest
response["message"] = err.Error()
return
}
if user.Username == "" || user.Phone == "" {
response["code"] = http.StatusBadRequest
response["message"] = "The username and phone number are not allowed to be empty"
return
}
cnt := 0
mydb.Table("user").Where("username=?", user.Username).Count(&cnt)
if cnt > 0 {
response["code"] = http.StatusBadRequest
response["message"] = "username already exists"
return
}
user.Password = utils.Md5(user.Username)
if err := mydb.Set("gorm:save_associations", false).Save(&user).Error; err != nil {
response["code"] = http.StatusInternalServerError
response["message"] = err.Error()
return
}
mydb.Model(&user).Association("Groups").Replace(user.Groups).Find(&user.Groups)
response["code"] = http.StatusOK
response["message"] = "user create successful"
response["user"] = user
}
func panelCreate(c *gin.Context) {
panel := types.Panel{}
response := gin.H{"code": http.StatusOK}
defer c.JSON(http.StatusOK, response)
if err := c.BindJSON(&panel); err != nil {
response["code"] = http.StatusBadRequest
response["message"] = err.Error()
return
}
if !mydb.Table("panel").Where("user_id = ? and name = ?", GetUser(c).ID, panel.Name).First(&panel).RecordNotFound() {
response["code"] = http.StatusBadRequest
response["message"] = "panel already exists"
return
}
panel.UserID = GetUser(c).ID
if err := mydb.Select("name", "thumbnail", "user_id").Save(&panel).Error; err != nil {
response["code"] = http.StatusInternalServerError
response["message"] = err.Error()
return
}
mydb.Model(&panel).Association("Charts").Replace(panel.Charts)
mydb.Model(&panel).Find(&panel)
for _, chart := range panel.Charts {
mydb.Model(&chart).Related(&chart.Elements)
}
response["panel"] = panel
}
func RegisterUser(c *gin.Context) {
var login Login
if c.BindJSON(&login) == nil {
user, err := models.FindUserByEmail(login.Email)
if err != nil && err.Error() != "not found" {
fmt.Printf("Error looking up user %v", err)
c.JSON(http.StatusInternalServerError, gin.H{"status": "Error Looking Up User."})
return
}
if user.ID.Valid() {
fmt.Printf("User already exists %v ", user)
c.JSON(http.StatusConflict, gin.H{"status": "User Already Exists."})
return
}
salt := makeSalt()
user = models.User{Email: login.Email, Salt: salt, UserName: login.Email, HashedPassword: ComputeHmac256(login.Password, getSecret(salt))}
newUser, err := models.CreateUser(user)
if err != nil || !newUser.ID.Valid() {
fmt.Printf("Error creating user account %v %v ", newUser, err)
c.JSON(http.StatusInternalServerError, gin.H{"status": "Error Creating New User Record."})
}
c.JSON(http.StatusOK, gin.H{"status": "New Subscription Successful"})
return
} else {
c.JSON(http.StatusNotFound, gin.H{"status": "Invalid Registration Information"})
}
}
func panelUpdate(c *gin.Context) {
panel := types.Panel{}
response := gin.H{}
defer c.JSON(http.StatusOK, response)
if err := c.BindJSON(&panel); err != nil {
response["code"] = http.StatusBadRequest
response["message"] = err.Error()
return
}
if mydb.Table("panel").Where("id = ? and user_id = ?", panel.ID, GetUser(c).ID).Find(&types.Panel{}).RecordNotFound() {
response["code"] = http.StatusNotFound
response["message"] = "The panel not found"
return
}
if err := mydb.Model(&panel).Select("name", "thumbnail").Updates(&panel).Error; err != nil {
response["code"] = http.StatusInternalServerError
response["message"] = err.Error()
return
}
mydb.Model(&panel).Association("Charts").Replace(panel.Charts)
for _, chart := range panel.Charts {
mydb.Model(&chart).Related(&chart.Elements)
}
response["code"] = http.StatusOK
response["message"] = "panel update successful"
response["panel"] = panel
}
func UpdateProfileHandler(c *gin.Context) {
user := ContextAuthUser(c)
profile := &ProfileModel{}
DB.C(USERS).FindId(user.Id).One(&profile)
var data profileForm
c.BindJSON(&data)
errors := data.validate()
if len(errors) == 0 {
profile.Name = data.Name
profile.Phone = data.Phone
DB.C(USERS).UpdateId(user.Id, bson.M{"$set": profile})
c.JSON(200, gin.H{
"success": true,
"object": profile,
})
} else {
c.JSON(422, gin.H{
"success": false,
"errors": errors,
})
}
}
// StopAdventure Stop adventuring
func stopAdventure(c *gin.Context) {
//signal channel to stop fight.
var adventurer struct {
Name string `json:"name"`
}
if err := c.BindJSON(&adventurer); err != nil {
c.JSON(http.StatusBadRequest, ErrorResponse{"error while binding adventurer:" + err.Error()})
return
}
char, err := mdb.Load(adventurer.Name)
if err != nil {
c.JSON(http.StatusBadRequest, ErrorResponse{"Error occured while loading character:" + err.Error()})
return
}
log.Println("Loaded adventurer:", char)
adventurersOnQuest.RLock()
adv := adventurersOnQuest.m[char.Name]
adventurersOnQuest.RUnlock()
if !adv {
c.JSON(http.StatusBadRequest, ErrorResponse{"Error occured, adventurer is not adventuring!"})
return
}
select {
case adventureSignal <- true:
default:
}
m := Message{}
m.Message = "Stop adventuring for character: " + char.Name
c.JSON(http.StatusOK, m)
}
func parse(c *gin.Context) {
c.Header("Access-Control-Allow-Origin", "*")
c.Header("Access-Control-Allow-Headers", "origin, content-type, accept")
var json Request
err := c.BindJSON(&json)
if err != nil || json.Link == "" {
c.JSON(http.StatusBadRequest, gin.H{"message": "Incrorrect request"})
return
}
link := json.Link
u, err := url.Parse(link)
if err != nil {
c.JSON(400, gin.H{"message": "Broken link", "link": link})
return
}
id := insertUrl(u.String())
go grab(u, id)
c.JSON(http.StatusCreated, gin.H{"message": "processing", "id": id, "link": link})
}
// StartAdventure starts and adventure in an endless for loop, until a channel signals otherwise
func startAdventure(c *gin.Context) {
var adventurer struct {
Name string `json:"name"`
}
if err := c.BindJSON(&adventurer); err != nil {
c.JSON(http.StatusBadRequest, ErrorResponse{"error while binding adventurer:" + err.Error()})
return
}
char, err := mdb.Load(adventurer.Name)
if err != nil {
c.JSON(http.StatusBadRequest, ErrorResponse{"Error occured while loading character:" + err.Error()})
return
}
adventurersOnQuest.RLock()
adv := adventurersOnQuest.m[char.Name]
adventurersOnQuest.RUnlock()
if adv {
c.JSON(http.StatusBadRequest, ErrorResponse{"Error occured, adventurer is already adventuring!"})
return
}
go adventuring(char.Name)
m := Message{}
m.Message = "Started adventuring for character: " + char.Name
c.JSON(http.StatusOK, m)
}
// DeleteLog deletes a device based on the identifier.
func DeleteLog(c *gin.Context) {
id := c.Params.ByName("id")
if id != "" {
var log models.Log
err := c.BindJSON(&log)
if err == nil {
uid, err := authentication.GetUserID(c)
if err == nil {
log.UserID = uid
count, err := configuration.Dbmap.Delete(&log)
if err == nil && count == 1 {
showSucces(c, fmt.Sprintf("log entry with id %s is deleted", id))
return
}
}
}
showError(c, 400, fmt.Errorf("deleting log entry failed"))
return
}
showError(c, 400, fmt.Errorf("deleting log entry failed due to missing identifier"))
}
//ExecutionCreate serves the route POST /tasks/:task_id/executions
func ExecutionCreate(c *gin.Context) {
models.InTx(func(txn *gorm.DB) bool {
var task models.Task
if txn.Where("id like ? ", c.Param("task_id")).First(&task); task.ID == "" {
c.JSON(http.StatusNotFound, "")
return false
}
var execution models.Execution
if err := c.BindJSON(&execution); err != nil {
c.JSON(http.StatusBadRequest, err)
return false
}
execution.TaskID = task.ID
if valid, errMap := models.ValidStruct(&execution); !valid {
c.JSON(http.StatusConflict, errMap)
return false
}
if txn.Create(&execution).Error != nil {
c.JSON(http.StatusBadRequest, "Execution can't be saved")
return false
}
c.JSON(http.StatusOK, execution)
return true
})
}
// disable user
func (u *User) Active(c *gin.Context) {
if !isGranted(c, "user.active") {
c.JSON(403, utils.NewNoAccessPermissionError(""))
return
}
id := paramInt64(c, "id")
var user models.User
var data models.User
if err := c.BindJSON(&data); err != nil {
c.JSON(400, utils.NewInvalidJsonError())
return
}
if err := models.GetById(id, &user); err != nil {
c.JSON(400, utils.NewNotFoundError())
return
}
fmt.Println("is active", data.IsActive)
user.IsActive = data.IsActive
if err := models.UpdateById(id, &user, "is_active"); err != nil {
c.JSON(400, utils.NewError("update database failed - %s", err.Error()))
return
}
c.JSON(200, gin.H{
"success": true,
})
}
func SetUserSchool(c *gin.Context) {
userId := c.Param("user_id")
if userId != c.MustGet("request_user_id").(string) {
c.Error(errors.NewHttp(http.StatusUnauthorized, "Users can only modify themselves"))
return
}
var request model.ModifySchoolRequest
err := c.BindJSON(&request)
if log.Error(err) {
c.Error(err)
return
}
_, user, err := db.GetUserById(userId)
if log.Error(err) {
c.Error(err)
return
}
user.School = sql.NullString{
String: request.SchoolId,
Valid: true,
}
err = db.UpdateUser(user)
if log.Error(err) {
c.Error(err)
return
}
c.JSON(http.StatusOK, user)
}