// Update inserts a new friendship in database
func Update(c *echo.Context) (int, interface{}) {
digitsID, ok := c.Get("digitsID").(int64)
if !ok {
return msg.Forbidden("session required")
}
friendID, err := strconv.Atoi(c.Param("id"))
if err != nil {
return msg.BadRequest(err)
}
// Bind body request to friend
var friend models.FriendUpdate
err = c.Bind(&friend)
if err != nil {
return msg.BadRequest(err)
}
// Validate input
err = validator.Validate(friend)
if err != nil {
return msg.BadRequest(err)
}
// Insert into database
err = mangos.Update(constants.CFriends, bson.M{"friend_id": int64(friendID), "digits_id": digitsID}, friend)
if err != nil {
return msg.InternalError(err)
}
return msg.Ok(friend)
}
// deleteBot получает команду от веб-клиента (удалить бота) и перенаправляет ее менеджеру ботов
func deleteBot(c *echo.Context) error {
id := c.Param("id")
action := "delete"
MB.SendActionToBot(id, action, nil)
return c.String(http.StatusOK, "ok\n")
}
func RemoveTodo(c echo.Context) error {
id := c.Param("id")
tododao.DeleteTodo(id)
return c.String(http.StatusOK, "")
}
func getPunchesHandler(c echo.Context) error {
id, err := strconv.ParseInt(c.Param("userID"), 10, 64)
if err != nil {
return err
}
return nil
}
func (s *Server) handleGetTransferResultsByIP(c echo.Context) error {
ip := net.ParseIP(c.Param("IP"))
res := s.registry.TransferResultsByIP(ip)
return c.JSON(200, res)
}
func postDevicePairing(c *echo.Context) error {
groupID := c.Get("GroupID").(string)
deviceID := c.Param("device-id")
_, _ = groupID, deviceID
var pairingKey struct {
Key string
}
err := c.Bind(&pairingKey) // читаем ключ из запроса
if err != nil || len(pairingKey.Key) < 4 {
return echo.NewHTTPError(http.StatusBadRequest)
}
var deviceIDResp string
err = nce.Request(serviceNamePairingKey, pairingKey.Key, &deviceIDResp, natsRequestTimeout)
if err != nil {
llog.Error("NATS Pairing Key response error: %v", err)
return err
}
if deviceIDResp == "" {
return echo.NewHTTPError(http.StatusNotFound)
}
if deviceIDResp == deviceID {
// TODO: реально связать в базе
return echo.NewHTTPError(http.StatusOK)
}
if deviceID == "" {
return c.JSON(http.StatusOK, map[string]string{"ID": deviceIDResp})
}
return echo.NewHTTPError(http.StatusBadRequest)
}
func (r *EnvironmentResource) Update(c echo.Context) error {
name := c.Param("name")
environment, err := r.store.GetEnvironmentByName(name)
if err != nil {
if err == store.ErrNoRows {
return NotFound(c)
}
return InternalServerError(c, err)
}
input := struct {
Name string `json:"name"`
}{}
if err := c.Bind(&input); err != nil {
return BadRequest(c, "Payload must be a valid JSON object")
}
if input.Name != "" {
environment.Name = input.Name
}
if err := r.store.UpdateEnvironment(environment); err != nil {
return InternalServerError(c, err)
}
return OK(c, environment)
}
// Delete deletes the resume.
//
// Method POST
//
// Route /resume/delete/:id
//
// Restrictions Yes
//
// Template None
func Delete(ctx *echo.Context) error {
var flashMessages = flash.New()
id, err := utils.GetInt(ctx.Param("id"))
if err != nil {
utils.SetData(ctx, "Message", tmpl.BadRequestMessage)
return ctx.Render(http.StatusBadRequest, tmpl.ErrBadRequest, utils.GetData(ctx))
}
user := ctx.Get("User").(*models.Person)
resume, err := query.GetResumeByID(id)
if err != nil {
utils.SetData(ctx, "Message", tmpl.NotFoundMessage)
return ctx.Render(http.StatusNotFound, tmpl.ErrNotFoundTpl, tmpl.NotFoundMessage)
}
// Users are allowed to delete resumes that they don't own.
if resume.PersonID != user.ID {
utils.SetData(ctx, "Message", tmpl.BadRequestMessage)
return ctx.Render(http.StatusBadRequest, tmpl.ErrBadRequest, utils.GetData(ctx))
}
err = query.Delete(resume)
if err != nil {
utils.SetData(ctx, "Message", tmpl.ServerErrorMessage)
return ctx.Render(http.StatusInternalServerError, tmpl.ErrServerTpl, utils.GetData(ctx))
}
flashMessages.Success("resume successful deleted")
flashMessages.Save(ctx)
ctx.Redirect(http.StatusFound, "/resume/")
return nil
}
// DelAdmin removes a member from an existing group
func DelAdmin(c *echo.Context) (int, interface{}) {
digitsID, ok := c.Get("digitsID").(int64)
if !ok {
return msg.Forbidden("session required")
}
// Get group id and convert from string to objectId
rawMID := c.Param("mid")
if !bson.IsObjectIdHex(rawMID) {
return msg.BadRequest("bad id: not a ObjectId")
}
// find the group
memberID := bson.ObjectIdHex(rawMID)
// Get group id and convert from string to objectId
rawGID := c.Param("gid")
if !bson.IsObjectIdHex(rawGID) {
return msg.BadRequest("bad id: not a ObjectId")
}
// find the group
groupID := bson.ObjectIdHex(rawGID)
err := mangos.Update(constants.CGroups, bson.M{
"$and": []bson.M{
bson.M{"_id": groupID},
bson.M{"admins": digitsID},
},
}, bson.M{"$pull": bson.M{"admins": memberID}})
if err != nil {
return msg.InternalError(err)
}
return msg.Ok("deleted admin")
}
// Make an application unusable
func UnpublishApplication(c *echo.Context) error {
appId := c.Param("app_id")
if len(appId) < 1 {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "App id must be specified",
},
},
})
}
err := apps.UnpublishApp(appId)
if err == apps.UnpublishFailed {
return c.JSON(http.StatusInternalServerError, hash{
"error": [1]hash{
hash{
"detail": err.Error(),
},
},
})
}
return c.JSON(http.StatusOK, hash{
"data": hash{
"success": true,
},
})
}
// Update patches a group in database
func Update(c *echo.Context) (int, interface{}) {
digitsID, ok := c.Get("digitsID").(int64)
if !ok {
return msg.Forbidden("session required")
}
// Bind request body to a group update
var group models.GroupUpdate
err := c.Bind(&group)
if err != nil {
return msg.BadRequest(err)
}
// Get group id and convert from string to objectId
rawGID := c.Param("gid")
if !bson.IsObjectIdHex(rawGID) {
return msg.BadRequest("bad id: not a ObjectId")
}
// Update the object, only if its a admin
groupID := bson.ObjectIdHex(rawGID)
err = mangos.Update(constants.CGroups, bson.M{
"$and": []bson.M{
bson.M{"_id": groupID},
bson.M{"admins": digitsID},
},
}, bson.M{"$set": group})
if err != nil {
return msg.InternalError(err)
}
return msg.Ok(group)
}
func (app *App) putValues(ctx *echo.Context) (err error) {
key := ctx.Param("key")
value, err := readBody(ctx.Request())
if err != nil {
return err
}
app.Lock()
entry, ok := app.store[key]
if !ok {
entry = newEntry()
entry.Lock()
app.store[key] = entry
} else {
entry.Lock()
}
app.Unlock()
entry.value = value
entry.lockID = generateID(32)
app.cond.Broadcast()
entry.Unlock()
response := map[string]interface{}{}
response["lock_id"] = entry.lockID
ctx.JSON(200, response)
return
}
func getGroupHandler(ctx *echo.Context) error {
g, err := getGroup(dbFromContext(ctx), ctx.Param("id"))
if err != nil {
return err
}
return ctx.JSON(200, g)
}
// Make an application unusable
func UnpublishApplication(c *echo.Context) error {
user := c.Get("user").(*users.User)
appId := c.Param("app_id")
if len(appId) < 1 {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "App id must be specified",
},
},
})
}
err := apps.UnpublishApp(user, appId)
if err == apps.UnpublishFailed {
return c.JSON(http.StatusInternalServerError, hash{
"error": [1]hash{
hash{
"detail": err.Error(),
},
},
})
}
return c.JSON(http.StatusOK, hash{
"meta": hash{},
})
}
/**
* @api {put} /topics/{id} Updates a topic
* @apiName UpdateTopic
* @apiGroup Topics
*
* @apiParam {Number} id The id of the topic to update
* @apiParam {String} [name] The new name of the topic
*/
func (tc *TopicsController) Update(c *echo.Context) error {
resp := response.New(c)
defer resp.Render()
// Getting params
id, err := strconv.ParseInt(c.Param("id"), 10, 64)
if err != nil {
resp.SetResponse(http.StatusBadRequest, nil)
return nil
}
// Loading the topic
topic := new(models.Topic)
err = topic.Load(id)
if err != nil {
resp.SetResponse(http.StatusNotFound, nil)
return nil
}
name := c.Form("name")
if name != "" {
topic.Name = name
}
err = topic.Update()
if err != nil {
resp.SetResponse(http.StatusInternalServerError, nil)
return nil
}
resp.SetResponse(http.StatusOK, topic)
return nil
}
func httpTimeline(c *echo.Context) error {
r := c.Request()
w := c.Response()
e := c.Get("engine").(storage.Engine)
domain := c.Param("domain")
iter, code, err := domainIteratorResource(domain, r, e)
if err != nil {
return c.JSON(code, map[string]interface{}{
"error": fmt.Sprint(err),
})
}
events, err := view.Timeline(iter, view.Descending)
if err != nil {
return c.JSON(code, map[string]interface{}{
"error": fmt.Sprint(err),
})
}
return json.NewEncoder(w).Encode(events)
}
func saveSite(c *echo.Context) error {
id, iderr := strconv.Atoi(c.Param("id"))
if iderr != nil {
return c.String(http.StatusNotAcceptable, "Invalid ID")
}
site := new(SiteType)
if binderr := c.Bind(site); binderr != nil {
log.Println(binderr.Error())
return binderr
}
log.Println(site)
_, err := ExecDb(db,
`update site
set name=$2,
address=$3,
phone=$4,
contactname=$5
where id=$1`,
id,
site.Name,
site.Address,
site.Phone,
site.ContactName)
if err != nil {
log.Println(err.Error())
}
return c.JSON(http.StatusOK, site)
}
func GetUser(c *echo.Context) error {
userId := c.Param("id")
if userId == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "User id needed to retrieve account informations",
},
},
})
}
user, err := users.GetUser(userId)
if err != nil {
return err
}
if user == nil {
return c.JSON(http.StatusNotFound, hash{
"error": [1]hash{
hash{
"detail": "User Not Found",
},
},
})
}
return c.JSON(http.StatusOK, hash{
"data": hash{
"id": user.Id,
"type": "user",
"attributes": user,
},
})
}
func (as ApiService) deleteService(c echo.Context) error {
if err := as.balancer.DeleteService(c.Param("service_name")); err != nil {
return err
}
return c.NoContent(http.StatusNoContent)
}
// 消息列表
func (MessageController) ReadList(ctx echo.Context) error {
user := ctx.Get("user").(*model.Me)
msgtype := ctx.Param("msgtype")
if msgtype == "" {
msgtype = "system"
}
curPage := goutils.MustInt(ctx.QueryParam("p"), 1)
paginator := logic.NewPaginator(curPage)
var (
messages []map[string]interface{}
total int64
)
switch msgtype {
case "system":
messages = logic.DefaultMessage.FindSysMsgsByUid(ctx, user.Uid, paginator)
total = logic.DefaultMessage.SysMsgCount(ctx, user.Uid)
case "inbox":
messages = logic.DefaultMessage.FindToMsgsByUid(ctx, user.Uid, paginator)
total = logic.DefaultMessage.ToMsgCount(ctx, user.Uid)
case "outbox":
messages = logic.DefaultMessage.FindFromMsgsByUid(ctx, user.Uid, paginator)
total = logic.DefaultMessage.FromMsgCount(ctx, user.Uid)
default:
return ctx.Redirect(http.StatusSeeOther, "/")
}
pageHtml := paginator.SetTotal(total).GetPageHtml(fmt.Sprintf("/message/%s", msgtype))
return render(ctx, "messages/list.html", map[string]interface{}{"messages": messages, "msgtype": msgtype, "page": template.HTML(pageHtml)})
}
func StartVM(c *echo.Context) error {
name := c.Param("id")
if name == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "No VM name provided",
},
},
})
}
err := Start(name)
if err != nil {
log.Error("Error while starting VM")
return c.JSON(http.StatusInternalServerError, hash{
"error": [1]hash{
hash{
"detail": err.Error(),
},
},
})
}
return c.JSON(http.StatusOK, hash{
"success": true,
})
}
func StopVM(c *echo.Context) error {
name := c.Param("id")
if name == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "No VM name provided",
},
},
})
}
err := Stop(name)
if err != nil {
return c.JSON(http.StatusInternalServerError, hash{
"error": [1]hash{
hash{
"detail": "Unable to stop the specified VM",
},
},
})
}
return c.JSON(http.StatusOK, hash{
"success": true,
})
}
// Retrieve writes the requested group from database
func Retrieve(c *echo.Context) (int, interface{}) {
digitsID, ok := c.Get("digitsID").(int64)
if !ok {
return msg.Forbidden("session required")
}
// Get group id and convert it from string to objectid
rawGID := c.Param("gid")
if !bson.IsObjectIdHex(rawGID) {
return msg.BadRequest("bad id: not a ObjectId")
}
// find the group
groupID := bson.ObjectIdHex(rawGID)
var group models.Group
err := mangos.FindOne(constants.CGroups, bson.M{"_id": groupID}, &group)
if err != nil {
return msg.InternalError(err)
}
// check if user is member (is not part of the query because we need to light bson query)
for _, member := range group.Members {
if member == digitsID {
return msg.Ok(group)
}
}
return msg.Forbidden("you must be part of the group")
}
func saveEquipType(c *echo.Context) error {
id, iderr := strconv.Atoi(c.Param("id"))
if iderr != nil {
return c.String(http.StatusNotAcceptable, "Invalid ID")
}
et := new(EquipType)
if binderr := c.Bind(et); binderr != nil {
log.Println(binderr.Error())
return binderr
}
//log.Println(et)
_, err := ExecDb(db,
`update equip_type
set name=$2,
is_consumable=$3,
is_asset=$4
where id=$1`,
id,
et.Name,
et.Consumable,
et.Asset)
if err != nil {
log.Println(err.Error())
}
return c.JSON(http.StatusOK, et)
}
// ArchiveView shows a list of posts arranged by its date
func ArchiveView(c *echo.Context) error {
id := c.Param("id")
var err error
// Get archive data
var archive models.Archive
err = database.Current.Get(&archive, database.Queries.ArchiveBySignature, id)
if err != nil {
log.Println("Cannot get archive by signature", err)
return echo.NewHTTPError(http.StatusInternalServerError)
}
// Get related posts
var posts []models.AuthoredPost
err = database.Current.Select(&posts, database.Queries.ArchiveAuthoredPosts, id)
if err != nil {
log.Println("Cannot select posts", err)
return echo.NewHTTPError(http.StatusInternalServerError)
}
// Create our render context and fill base data
ac := archiveContext{
Archive: archive,
RelatedPosts: posts,
}
err = fillBlogContext(c, &ac.blogContext)
if err != nil {
log.Println("Cannot fill blog context", err)
return echo.NewHTTPError(http.StatusInternalServerError)
}
return c.Render(200, "archive", ac)
}
// Retrieve writes profile public information, if requested id is the same as the
// session, then full data is written.
func Retrieve(c *echo.Context) (int, interface{}) {
reqid, _ := strconv.ParseInt(c.Param("id"), 10, 64)
attid, _ := c.Get("digitsID").(int64)
if reqid == attid {
// Serve private profile
var profile models.Profile
log.Printf("Awaiting for [Profile = %d] fetch", reqid)
err := mangos.FindOne(collection, bson.M{"_id": reqid}, &profile)
if err != nil {
log.Printf("Cannot retrieve [Profile = %d]: %s", reqid, err)
return msg.InternalError(err)
}
log.Printf("Served profile ->\n%s", msg.Detail(profile))
return msg.Ok(profile)
}
// Serve public profile
var public models.PublicProfile
log.Printf("Awaiting for [PublicProfile = %d] fetch", reqid)
err := mangos.FindOne(collection, bson.M{"_id": reqid}, &public)
if err != nil {
log.Printf("Cannot retrieve [PublicProfile = %d]: %s", reqid, err)
return msg.InternalError(err)
}
log.Printf("Served PublicProfile ->\n%s", msg.Detail(public))
return msg.Ok(public)
}
func GetUser(c *echo.Context) error {
userId := c.Param("id")
if userId == "" {
return c.JSON(http.StatusBadRequest, hash{
"error": [1]hash{
hash{
"detail": "User id needed to retrieve account informations",
},
},
})
}
user, err := users.GetUser(userId)
if err != nil {
return err
}
if user == nil {
return c.JSON(http.StatusNotFound, hash{
"error": [1]hash{
hash{
"detail": "User Not Found",
},
},
})
}
return utils.JSON(c, http.StatusOK, user)
}
func putHandler(c echo.Context) error {
var val map[string]interface{}
if err := c.Bind(&val); err != nil {
return err
}
cfg := c.Get("config").(*Config)
key := c.Param("key")
obj, err := Put(cfg, key, val)
if err != nil {
// Failed validation.
if errs, ok := err.(ResultErrors); ok {
return c.JSON(StatusUnprocessableEntity, errs)
}
return err
}
// No change.
if obj == nil {
return c.NoContent(http.StatusNoContent)
}
return c.JSON(http.StatusOK, obj)
}
func httpLog(c *echo.Context) error {
r := c.Request()
w := c.Response()
e := c.Get("engine").(storage.Engine)
domain := c.Param("domain")
iter, code, err := domainIteratorResource(domain, r, e)
if err != nil {
return c.JSON(code, map[string]interface{}{
"error": fmt.Sprint(err),
})
}
facts, err := origins.ReadAll(iter)
if err != nil {
return c.JSON(code, map[string]interface{}{
"error": fmt.Sprint(err),
})
}
return json.NewEncoder(w).Encode(facts)
}
// path /update/account/:DeviceID/:ID?field1=value1&&field2=value2
// example /update/account/device10/12?Weight=17.3&&Height=20.69&&BodyFat=100.44
func setAccount(c *echo.Context, isInsert bool) error {
deviceid := c.Param("DeviceID")
id, err := strconv.ParseUint(c.Param("ID"), 10, 64)
if err != nil {
return jsonResp(c, err.Error())
}
acc := Account{DeviceID: deviceid, ID: id}
has, err := g_engine.Get(&acc)
if err != nil {
return jsonResp(c, err.Error())
}
if isInsert && has {
return jsonResp(c, "exists")
}
if !isInsert && !has {
return jsonResp(c, "not exists")
}
for _, field := range []string{"Weight", "Height", "BodyFat"} {
switch field {
case "Weight":
tmp, err := strconv.ParseFloat(c.Query(field), 32)
acc.Weight = JSONFloat64(tmp)
if err != nil {
return jsonResp(c, err.Error())
}
case "Height":
tmp, err := strconv.ParseFloat(c.Query(field), 32)
acc.Height = JSONFloat64(tmp)
if err != nil {
return jsonResp(c, err.Error())
}
case "BodyFat":
tmp, err := strconv.ParseFloat(c.Query(field), 32)
acc.BodyFat = JSONFloat64(tmp)
if err != nil {
return jsonResp(c, err.Error())
}
}
}
if isInsert {
_, err = g_engine.Insert(&acc)
} else {
_, err = g_engine.Update(&acc)
}
if err != nil {
return jsonResp(c, err.Error())
}
if err = updateOrInsert(&SyncTime{DeviceID: deviceid}); err != nil {
return jsonResp(c, err.Error())
}
return jsonResp(c, "success")
}