func fibonacci(c *gin.Context) { nParam := c.Param("n") n, err := strconv.Atoi(nParam) if err != nil || n == 0 { c.JSON(http.StatusBadRequest, errorResponse{ ErrorCode: 1000, Message: "Received inputParameter is not a correct limit value", InputParameters: nParam, }) return } fibelems, err := fibSrv.CountNValues(n) if err != nil { c.JSON(http.StatusInternalServerError, errorResponse{ ErrorCode: 1000, Message: "Unexpected error occurred during fibonacci calculation", InputParameters: nParam, }) return } c.JSON(http.StatusOK, response{N: n, Elems: fibelems.ToString()}) }
func clientHandler(c *gin.Context) { data, err := ioutil.ReadAll(c.Request.Body) if err != nil { log.Println(err) return } log.Printf("[CLIENT] %s\n", string(data)) javaConn, _, err := websocket.DefaultDialer.Dial("ws://localhost:8081", http.Header{}) if err != nil { log.Println(err) return } initialJSON, _ := json.Marshal(map[string]string{"name": c.Param("name")}) javaConn.WriteMessage(websocket.TextMessage, initialJSON) javaConn.ReadMessage() javaConn.WriteMessage(websocket.TextMessage, data) _, p, err := javaConn.ReadMessage() if err != nil { log.Println(err) return } log.Printf("[SPIGOT] %s\n", string(p)) javaConn.Close() c.Writer.Write(p) }
func Generate8bit(c *gin.Context) { name := c.Param("name") gender := c.Param("gender") switch { case gender == "m": gender = "male" case gender == "f": gender = "female" case gender == "male" || gender == "female": //do nothing default: c.AbortWithError(http.StatusInternalServerError, errors.New("Invalid parameters")) return } log.Println(name) InitAssets() img := GenerateIdenticon8bits(gender, []byte(name)) c.Header("Content-Type", "image/png") c.Stream(func(w io.Writer) bool { png.Encode(w, img) return false }) }
//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 }) }
func GetAdminNewsEdit(c *gin.Context) { nw := News{} i, _ := strconv.Atoi(c.Param("kkk")) NewsSession.Find(gin.H{"id": i}).One(&nw) fmt.Println(nw.Short, nw.Id) c.HTML(200, "editn.html", gin.H{"news": nw}) }
func (rc *ResourceController) GetResource(ctx *gin.Context) { var id bson.ObjectId req := ctx.Request resourceType := getResourceType(req.URL) // Validate id as a bson Object ID id, err := toBsonObjectID(ctx.Param("id")) if err != nil { ctx.AbortWithError(http.StatusBadRequest, err) return } logger.Log.WithFields( logrus.Fields{"resource type": resourceType, "id": id}).Info("GetResource") resource, err := rc.LoadResource(resourceType, id) if err != nil { if err == mgo.ErrNotFound { ctx.String(http.StatusNotFound, "Not Found") ctx.Abort() return } else { ctx.AbortWithError(http.StatusBadRequest, err) return } } logger.Log.WithFields(logrus.Fields{"resource": resource}).Info("GetResource") ctx.JSON(http.StatusOK, resource) }
func update(c *gin.Context) { var input Dog c.Bind(&input) log.Print(c) id := c.Param("id") log.Print(id) //check if valid id if bson.IsObjectIdHex(id) == false { c.JSON(400, gin.H{"error": "ID not valid"}) return } bId := bson.ObjectIdHex(id) err := Collection.UpdateId(bId, &Dog{bId, input.Name, input.Owner}) if err != nil { c.JSON(400, "id not found") } else { c.JSON(200, "dog updated") } }
func (p *Engine) showNote(c *gin.Context) (interface{}, error) { u := c.MustGet("user").(*platform.User) id := c.Param("id") var note Note err := p.Db.Where("id = ? AND user_id = ?", id, u.ID).First(¬e).Error return note, err }
// UserOrgIndex retrieves all orgs related to a user. func UserOrgIndex(c *gin.Context) { records, err := store.GetUserOrgs( c, &model.UserOrgParams{ User: c.Param("user"), }, ) if err != nil { logrus.Warnf("Failed to fetch user orgs. %s", err) c.JSON( http.StatusInternalServerError, gin.H{ "status": http.StatusInternalServerError, "message": "Failed to fetch orgs", }, ) c.Abort() return } c.JSON( http.StatusOK, records, ) }
func (self *EnvController) New(c *gin.Context) { username := self.CurrentUser(c) if username == "" { c.Redirect(http.StatusFound, "/") return } appName := c.Param("appName") key := c.PostForm("key") value := c.PostForm("value") err := env.Create(self.etcd, username, appName, key, value) if err != nil { fmt.Fprintf(os.Stderr, "%+v\n", err) c.HTML(http.StatusInternalServerError, "app.tmpl", gin.H{ "alert": true, "error": true, "message": "Failed to add environment variable.", }) return } c.Redirect(http.StatusSeeOther, "/apps/"+appName) }
func (fc *FrontController) ViewCtr(c *gin.Context) { id := c.Param("id") var blog VBlogItem CKey := fmt.Sprintf("blogitem-%d", id) val, ok := Cache.Get(CKey) if val != nil && ok == true { fmt.Println("Ok, we found cache, Cache Len: ", Cache.Len()) blog = val.(VBlogItem) } else { rows, err := DB.Query("Select * from top_article where aid = ?", &id) if err != nil { log.Fatal(err) } defer rows.Close() var () for rows.Next() { err := rows.Scan(&blog.aid, &blog.title, &blog.content, &blog.publish_time, &blog.publish_status) if err != nil { log.Fatal(err) } } err = rows.Err() if err != nil { log.Fatal(err) } Cache.Add(CKey, blog) } c.HTML(http.StatusOK, "view.html", gin.H{ "aid": blog.aid, "title": blog.title.String, "content": template.HTML(blog.content.String), "publish_time": blog.publish_time.String, }) }
func editReplicationController(c *gin.Context) { namespace := c.Param("ns") rcname := c.Param("rc") _, delete := c.GetQuery("delete") rc, err := kubeclient.Get().ReplicationControllers(namespace).Get(rcname) if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } b, err := json.Marshal(rc) if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } var out bytes.Buffer err = json.Indent(&out, b, "", " ") if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } c.HTML(http.StatusOK, "replicationControllerEdit", gin.H{ "title": rcname, "namespace": namespace, "objname": rcname, "json": out.String(), "delete": strconv.FormatBool(delete), }) }
func readPodLog(c *gin.Context) { namespace := c.Param("ns") podname := c.Param("po") _, previous := c.GetQuery("previous") readLog(c, namespace, podname, "", previous) }
func (pc *NodeController) postDeleteNodeAction(c *gin.Context) { id := c.Param("id") node, err := models.NodeMapper.FetchOneById(id) if err != nil { c.HTML(http.StatusInternalServerError, "error_500.html", map[string]interface{}{ "error": err, }) return } if node == nil { c.HTML(http.StatusNotFound, "error_404.html", map[string]interface{}{ "text": "Node not found", }) return } if err := models.NodeMapper.Delete(node); err != nil { c.HTML(http.StatusInternalServerError, "error_500.html", map[string]interface{}{ "error": err, }) return } c.Redirect(http.StatusFound, "/nodes") }
// Status handler for the /status route func OpenWebsocket(c *gin.Context) { userId := c.MustGet("request_user_id").(string) noteId := c.Param("note_id") in, note, err := db.GetNoteById(noteId) if log.Error(err) { c.Error(errors.NewISE()) return } if !in { c.Error(errors.NewHttp(http.StatusNotFound, "The requested note was not found")) return } if userId != note.Owner { c.Error(errors.NewHttp(http.StatusUnauthorized, "Only owners can open websockets into their notes")) return } conn, err := websocketUpgrader.Upgrade(c.Writer, c.Request, nil) if log.Error(err) { c.Error(errors.NewISE()) return } log.Info("Opening ws for user %v on %v", userId, note.Id) bundle := model.NewContext(userId, noteId) WrapWebsocket(conn, bundle) ws.ProcessMessages(bundle) }
func (p *Engine) deleteNote(c *gin.Context) (interface{}, error) { u := c.MustGet("user").(*platform.User) id := c.Param("id") err := p.Db.Where("id = ? AND user_id = ?", id, u.ID).Delete(Note{}).Error return web.OK, err }
func EditReviewFormR(c *gin.Context) { // dependency injection var ( reviewStore = c.MustGet(ReviewStoreKey).(ReviewStore) user = GetUser(c) ) // only authenticated users can perform this action if !user.Authenticated() { c.AbortWithStatus(http.StatusUnauthorized) return } // fetch review id, err := strconv.Atoi(c.Param("id")) if err != nil { c.AbortWithError(http.StatusBadRequest, err) return } review, err := reviewStore.GetReview(id) if err != nil { c.AbortWithError(http.StatusInternalServerError, err) return } c.HTML(http.StatusOK, "review-form.html", gin.H{ "Action": "Edit", "User": user, "Form": review, "Errors": map[string]string{}, }) }
// View handles the file views func View(c *gin.Context) { var err error id := c.Param("uniuri") re := models.Resource{} if err = re.Get(id); err != nil || re.Key == "" { logger.InfoC(c, "server", "Not found", id) c.AbortWithStatus(http.StatusNotFound) return } re.LogFetched(c) f, err := os.Open(path.Join(conf.C.UploadDir, re.Key)) if err != nil { logger.ErrC(c, "server", fmt.Sprintf("Couldn't open %s", re.Key), err) c.AbortWithStatus(http.StatusInternalServerError) return } if conf.C.AlwaysDownload { c.Header("Content-Type", "application/octet-stream") } c.Header("Content-Disposition", "filename=\""+re.Name+"\"") io.Copy(c.Writer, f) if re.Once { re.Delete() re.LogDeleted(c) } }
func handleClaimantsClaimsDelete(c *gin.Context) { claimantID := c.Param("id") if strings.TrimSpace(claimantID) == "" { c.JSON(http.StatusBadRequest, "Bad Request") return } var claim stake.Claim decoder := json.NewDecoder(c.Request.Body) err := decoder.Decode(&claim) if err != nil { c.JSON(http.StatusBadRequest, "Bad Request") return } if strings.TrimSpace(claim.Claim) == "" || strings.TrimSpace(claim.Subject) == "" { c.JSON(http.StatusBadRequest, "Bad Request") return } if strings.TrimSpace(claimantID) == "" || strings.TrimSpace(claim.Claim) == "" || strings.TrimSpace(claim.Subject) == "" { c.JSON(http.StatusBadRequest, "Bad Request") return } result := deleteClaimantsClaimAboutSubject(claimantID, claim.Subject, claim.Claim) if result == success { c.JSON(http.StatusOK, result) } else { c.JSON(http.StatusNotFound, result) } }
/** * 1 - Show a deployment */ func (ctl *DeploymentController) getDeploymentAction(c *gin.Context) { appId := c.Param("app_id") deployId := c.Param("deploy_id") application := ctl.getApplication(c, appId) if application == nil { return } deployment := ctl.getDeployment(c, application, deployId) if deployment == nil { return } karhuURL, _ := url.Parse(env.GetDefault("PUBLIC_HOST", "http://127.0.0.1:8080")) webSocketProto := "ws" if karhuURL.Scheme == "https" { webSocketProto = "wss" } c.HTML(http.StatusOK, "deployment_show.html", map[string]interface{}{ "application": application, "deployment": deployment, "public_host": karhuURL.Host, "websocket_proto": webSocketProto, }) }
/** * 2 - Create a deployment */ func (ctl *DeploymentController) postDeploymentAction(c *gin.Context) { appId := c.Param("app_id") buildId := c.Param("build_id") resp, err := http.Post(fmt.Sprintf("http://localhost:8080/api/apps/%s/builds/%s/deploy", appId, buildId), "json/application", nil) if err != nil { c.HTML(http.StatusInternalServerError, "error_500.html", map[string]interface{}{ "error": err, }) return } defer resp.Body.Close() body, err := ioutil.ReadAll(resp.Body) if err != nil { c.HTML(http.StatusInternalServerError, "error_500.html", map[string]interface{}{ "error": err, }) return } var deployment models.Deployment if err := json.Unmarshal(body, &deployment); err != nil { c.HTML(http.StatusInternalServerError, "error_500.html", map[string]interface{}{ "error": err, }) return } c.Redirect(http.StatusFound, fmt.Sprintf("/application/deployment/%s/%s", appId, deployment.Id.Hex())) }
func GetDeviceCountOfAppLatestConfig(c *gin.Context) { memConfMux.RLock() app := memConfApps[c.Param("app_key")] memConfMux.RUnlock() if app == nil { Error(c, BAD_REQUEST, "app not found for app key: "+c.Param("app_key")) return } q := fmt.Sprintf("SELECT COUNT(DISTINCT(deviceid)) FROM client_request where app = '%s' AND time >= %d", app.Key, app.LastUpdateUTC*int(secondUnit)) resp, err := queryInflux(q) if err != nil { Error(c, SERVER_ERROR, err.Error()) return } if resp.Error() != nil { Error(c, SERVER_ERROR, resp.Error().Error()) return } if len(resp.Results[0].Series) == 0 { Success(c, 0) return } Success(c, resp.Results[0].Series[0].Values[0][1]) }
func EditWhiskyFormR(c *gin.Context) { // dependency injection var ( whiskyStore = c.MustGet(WhiskyStoreKey).(WhiskyStore) user = GetUser(c) ) // only authenticated users can perform this action if !user.Authenticated() { c.AbortWithStatus(http.StatusUnauthorized) return } // fetch whisky to edit id, err := strconv.Atoi(c.Param("id")) if err != nil { c.AbortWithStatus(http.StatusBadRequest) return } whisky, err := whiskyStore.GetWhisky(id) if err != nil { c.AbortWithStatus(http.StatusInternalServerError) return } c.HTML(http.StatusOK, "whisky-form.html", gin.H{ "Action": "Edit", "User": user, "Form": whisky, "Errors": map[string]string{}, }) }
// GroupDelete is used to delete one specific group with a `id` func GroupDelete(c *gin.Context) { var group models.Group database.DBCon.First(&group, c.Param("id")) database.DBCon.Delete(&group) c.JSON(http.StatusOK, gin.H{"success": true}) }
func UserR(c *gin.Context) { // dependency injection var ( whiskyStore = c.MustGet(WhiskyStoreKey).(WhiskyStore) reviewStore = c.MustGet(ReviewStoreKey).(ReviewStore) user = GetUser(c) ) // parse id id, err := strconv.Atoi(c.Param("id")) if err != nil { c.AbortWithError(http.StatusBadRequest, err) return } // fetch whiksy whisky, err := whiskyStore.GetWhisky(id) if err != nil { c.AbortWithError(http.StatusInternalServerError, err) return } // fetch reviews reviews, err := reviewStore.GetAllReviews(id, 30) if err != nil { c.AbortWithError(http.StatusInternalServerError, err) return } c.HTML(http.StatusOK, "whisky.html", gin.H{ "User": user, "Whisky": whisky, "Reviews": reviews, }) }
func editNode(c *gin.Context) { nodename := c.Param("no") _, delete := c.GetQuery("delete") node, err := kubeclient.Get().Nodes().Get(nodename) if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } b, err := json.Marshal(node) if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } var out bytes.Buffer err = json.Indent(&out, b, "", " ") if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } c.HTML(http.StatusOK, "nodeEdit", gin.H{ "title": nodename, "objname": nodename, "json": out.String(), "delete": strconv.FormatBool(delete), }) }
func (pc *NodeController) postNodeAction(c *gin.Context) { id := c.Param("id") var form models.NodeUpdateForm if err := c.Bind(&form); err != nil { c.AbortWithStatus(http.StatusBadRequest) return } node, err := models.NodeMapper.FetchOneById(id) if err != nil { c.HTML(http.StatusInternalServerError, "error_500.html", map[string]interface{}{ "error": err, }) return } if node == nil { c.HTML(http.StatusNotFound, "error_404.html", map[string]interface{}{ "text": "Node not found", }) return } node.Tags = form.Tags node.Description = form.Description models.NodeMapper.Update(node) c.Redirect(http.StatusFound, "/nodes") }
func editEndpoints(c *gin.Context) { namespace := c.Param("ns") epname := c.Param("ep") _, delete := c.GetQuery("delete") ep, err := kubeclient.Get().Endpoints(namespace).Get(epname) if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } b, err := json.Marshal(ep) if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } var out bytes.Buffer err = json.Indent(&out, b, "", " ") if err != nil { c.HTML(http.StatusInternalServerError, "error", gin.H{"error": err.Error()}) return } c.HTML(http.StatusOK, "endpointsEdit", gin.H{ "title": epname, "namespace": namespace, "objname": epname, "json": out.String(), "delete": strconv.FormatBool(delete), }) }
/* 删除文章 DELETE /api/topic/{id} */ func deleteTopic(c *gin.Context) { id := c.Param("id") if id == "" { c.JSON(200, RespResult{ErrCodeParam, "param id is empty", nil}) return } // todo: 鉴权 user := getCurrent(c) if user == nil { c.JSON(200, RespResult{ErrCodeNeePerm, "need permission", nil}) return } post, err := getPostById(id, true) if err != nil { c.JSON(200, RespResult{ErrCodeDBQuery, err.Error(), nil}) return } err = deletePost(post, user, true) if err != nil { c.JSON(200, RespResult{ErrCodeDBQuery, "delete post " + id + " failed: " + err.Error(), nil}) return } c.JSON(200, RespResult{0, "ok", nil}) }
func doGETCache(c *gin.Context) { hash := normalize(c.Param("hash")) file := store.GetCachePath(hash) c.File(file) }