add

wangpengfei

2023-07-21 6a8a20e02f0530284296d3373d44aa218fc85210

add

solveRate  解决率模块
add, Delete, update, list

 api/v1/index.go

@@ -5,6 +5,7 @@
)

type Group struct {
    SolveRateApi
    TimelyRateApi
    BaseApi
    JwtApi
@@ -102,4 +103,5 @@
    vettingService              = service.ServiceGroup.VettingService
    satisfactionService         = service.ServiceGroup.SatisfactionService
    timelyRateService           = service.ServiceGroup.TimelyRateService
    solveRateService            = service.ServiceGroup.SolveRateService
)

 api/v1/serviceFollowup.go

@@ -141,7 +141,7 @@
        PlanId:         serviceFollowup.PlanId,
        SatisfactionId: serviceFollowup.Satisfaction,
        TimelyRateId:   serviceFollowup.TimelyRate,
        SolveRate:      serviceFollowup.SolveRate,
        SolveRateId:    serviceFollowup.SolveRate,
        IsVisit:        serviceFollowup.IsVisit,
        OldMemberId:    serviceFollowup.OldMemberId,
        Remark:         serviceFollowup.Remark,

 api/v1/solveRate.go

New file
@@ -0,0 +1,112 @@
package v1

import (
    "aps_crm/model"
    "aps_crm/model/request"
    "aps_crm/model/response"
    "aps_crm/pkg/contextx"
    "aps_crm/pkg/ecode"
    "github.com/gin-gonic/gin"
    "strconv"
)

type SolveRateApi struct{}

// Add
//
//    @Tags        SolveRate
//    @Summary    添加解决率
//    @Produce    application/json
//    @Param        object    body        request.AddSolveRate    true    "查询参数"
//    @Success    200        {object}    contextx.Response{}
//    @Router        /api/solveRate/add [post]
func (s *SolveRateApi) Add(c *gin.Context) {
    var params request.AddSolveRate
    ctx, ok := contextx.NewContext(c, &params)
    if !ok {
        return
    }

    solveRate := new(model.SolveRate)
    solveRate.Name = params.Name

    errCode := solveRateService.AddSolveRate(solveRate)
    if errCode != ecode.OK {
        ctx.Fail(errCode)
        return
    }

    ctx.Ok()
}

// Delete
//
//    @Tags        SolveRate
//    @Summary    删除解决率
//    @Produce    application/json
//    @Param        id    path        int    true    "查询参数"
//    @Success    200    {object}    contextx.Response{}
//    @Router        /api/solveRate/delete/{id} [delete]
func (s *SolveRateApi) Delete(c *gin.Context) {
    ctx, ok := contextx.NewContext(c, nil)
    if !ok {
        return
    }

    id, _ := strconv.Atoi(c.Param("id"))
    errCode := solveRateService.DeleteSolveRate(id)
    if errCode != ecode.OK {
        ctx.Fail(errCode)
        return
    }

    ctx.Ok()
}

// Update
//
//    @Tags        SolveRate
//    @Summary    更新解决率
//    @Produce    application/json
//    @Param        object    body        request.UpdateSolveRates    true    "查询参数"
//    @Success    200        {object}    contextx.Response{}
//    @Router        /api/solveRate/update [put]
func (s *SolveRateApi) Update(c *gin.Context) {
    var params request.UpdateSolveRates
    ctx, ok := contextx.NewContext(c, &params)
    if !ok {
        return
    }

    errCode := solveRateService.UpdateSolveRate(params.SolveRates)
    if errCode != ecode.OK {
        ctx.Fail(errCode)
        return
    }

    ctx.Ok()
}

// List
//
//    @Tags        SolveRate
//    @Summary    获取解决率列表
//    @Produce    application/json
//    @Success    200    {object}    contextx.Response{data=response.SolveRateResponse}
//    @Router        /api/solveRate/list [get]
func (s *SolveRateApi) List(c *gin.Context) {
    ctx, ok := contextx.NewContext(c, nil)
    if !ok {
        return
    }

    solveRates, errCode := solveRateService.GetSolveRateList()
    if errCode != ecode.OK {
        ctx.Fail(errCode)
        return
    }

    ctx.OkWithDetailed(response.SolveRateResponse{
        List: solveRates,
    })
}

 docs/docs.go

@@ -4638,6 +4638,125 @@
                }
            }
        },
        "/api/solveRate/add": {
            "post": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SolveRate"
                ],
                "summary": "添加解决率",
                "parameters": [
                    {
                        "description": "查询参数",
                        "name": "object",
                        "in": "body",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/request.AddSolveRate"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/solveRate/delete/{id}": {
            "delete": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SolveRate"
                ],
                "summary": "删除解决率",
                "parameters": [
                    {
                        "type": "integer",
                        "description": "查询参数",
                        "name": "id",
                        "in": "path",
                        "required": true
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/solveRate/list": {
            "get": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SolveRate"
                ],
                "summary": "获取解决率列表",
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "allOf": [
                                {
                                    "$ref": "#/definitions/contextx.Response"
                                },
                                {
                                    "type": "object",
                                    "properties": {
                                        "data": {
                                            "$ref": "#/definitions/response.SolveRateResponse"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                }
            }
        },
        "/api/solveRate/update": {
            "put": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SolveRate"
                ],
                "summary": "更新解决率",
                "parameters": [
                    {
                        "description": "查询参数",
                        "name": "object",
                        "in": "body",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/request.UpdateSolveRates"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/status/add": {
            "post": {
                "produces": [
@@ -6586,11 +6705,22 @@
                "serviceId": {
                    "type": "integer"
                },
                "solveRate": {
                "solveRateId": {
                    "type": "integer"
                },
                "timelyRateId": {
                    "type": "integer"
                }
            }
        },
        "model.SolveRate": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "integer"
                },
                "name": {
                    "type": "string"
                }
            }
        },
@@ -7580,6 +7710,17 @@
                },
                "timelyRate": {
                    "type": "integer"
                }
            }
        },
        "request.AddSolveRate": {
            "type": "object",
            "required": [
                "name"
            ],
            "properties": {
                "name": {
                    "type": "string"
                }
            }
        },
@@ -9386,6 +9527,35 @@
                }
            }
        },
        "request.UpdateSolveRate": {
            "type": "object",
            "required": [
                "id",
                "name"
            ],
            "properties": {
                "id": {
                    "type": "integer"
                },
                "name": {
                    "type": "string"
                }
            }
        },
        "request.UpdateSolveRates": {
            "type": "object",
            "required": [
                "solve_rate"
            ],
            "properties": {
                "solve_rate": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/request.UpdateSolveRate"
                    }
                }
            }
        },
        "request.UpdateStatus": {
            "type": "object",
            "required": [
@@ -9704,6 +9874,20 @@
                    "items": {
                        "$ref": "#/definitions/model.Satisfaction"
                    }
                },
                "solve_rate": {
                    "description": "解决率",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/model.SolveRate"
                    }
                },
                "timely_rate": {
                    "description": "及时率",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/model.TimelyRate"
                    }
                }
            }
        },
@@ -10011,6 +10195,17 @@
                }
            }
        },
        "response.SolveRateResponse": {
            "type": "object",
            "properties": {
                "list": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/model.SolveRate"
                    }
                }
            }
        },
        "response.SubOrderResponse": {
            "type": "object",
            "properties": {

 docs/swagger.json

@@ -4626,6 +4626,125 @@
                }
            }
        },
        "/api/solveRate/add": {
            "post": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SolveRate"
                ],
                "summary": "添加解决率",
                "parameters": [
                    {
                        "description": "查询参数",
                        "name": "object",
                        "in": "body",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/request.AddSolveRate"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/solveRate/delete/{id}": {
            "delete": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SolveRate"
                ],
                "summary": "删除解决率",
                "parameters": [
                    {
                        "type": "integer",
                        "description": "查询参数",
                        "name": "id",
                        "in": "path",
                        "required": true
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/solveRate/list": {
            "get": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SolveRate"
                ],
                "summary": "获取解决率列表",
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "allOf": [
                                {
                                    "$ref": "#/definitions/contextx.Response"
                                },
                                {
                                    "type": "object",
                                    "properties": {
                                        "data": {
                                            "$ref": "#/definitions/response.SolveRateResponse"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                }
            }
        },
        "/api/solveRate/update": {
            "put": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SolveRate"
                ],
                "summary": "更新解决率",
                "parameters": [
                    {
                        "description": "查询参数",
                        "name": "object",
                        "in": "body",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/request.UpdateSolveRates"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/status/add": {
            "post": {
                "produces": [
@@ -6574,11 +6693,22 @@
                "serviceId": {
                    "type": "integer"
                },
                "solveRate": {
                "solveRateId": {
                    "type": "integer"
                },
                "timelyRateId": {
                    "type": "integer"
                }
            }
        },
        "model.SolveRate": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "integer"
                },
                "name": {
                    "type": "string"
                }
            }
        },
@@ -7568,6 +7698,17 @@
                },
                "timelyRate": {
                    "type": "integer"
                }
            }
        },
        "request.AddSolveRate": {
            "type": "object",
            "required": [
                "name"
            ],
            "properties": {
                "name": {
                    "type": "string"
                }
            }
        },
@@ -9374,6 +9515,35 @@
                }
            }
        },
        "request.UpdateSolveRate": {
            "type": "object",
            "required": [
                "id",
                "name"
            ],
            "properties": {
                "id": {
                    "type": "integer"
                },
                "name": {
                    "type": "string"
                }
            }
        },
        "request.UpdateSolveRates": {
            "type": "object",
            "required": [
                "solve_rate"
            ],
            "properties": {
                "solve_rate": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/request.UpdateSolveRate"
                    }
                }
            }
        },
        "request.UpdateStatus": {
            "type": "object",
            "required": [
@@ -9692,6 +9862,20 @@
                    "items": {
                        "$ref": "#/definitions/model.Satisfaction"
                    }
                },
                "solve_rate": {
                    "description": "解决率",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/model.SolveRate"
                    }
                },
                "timely_rate": {
                    "description": "及时率",
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/model.TimelyRate"
                    }
                }
            }
        },
@@ -9999,6 +10183,17 @@
                }
            }
        },
        "response.SolveRateResponse": {
            "type": "object",
            "properties": {
                "list": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/model.SolveRate"
                    }
                }
            }
        },
        "response.SubOrderResponse": {
            "type": "object",
            "properties": {

 docs/swagger.yaml

@@ -876,10 +876,17 @@
        type: integer
      serviceId:
        type: integer
      solveRate:
      solveRateId:
        type: integer
      timelyRateId:
        type: integer
    type: object
  model.SolveRate:
    properties:
      id:
        type: integer
      name:
        type: string
    type: object
  model.SubOrder:
    properties:
@@ -1549,6 +1556,13 @@
        type: integer
      timelyRate:
        type: integer
    type: object
  request.AddSolveRate:
    properties:
      name:
        type: string
    required:
    - name
    type: object
  request.AddStatus:
    properties:
@@ -2771,6 +2785,25 @@
      timelyRate:
        type: integer
    type: object
  request.UpdateSolveRate:
    properties:
      id:
        type: integer
      name:
        type: string
    required:
    - id
    - name
    type: object
  request.UpdateSolveRates:
    properties:
      solve_rate:
        items:
          $ref: '#/definitions/request.UpdateSolveRate'
        type: array
    required:
    - solve_rate
    type: object
  request.UpdateStatus:
    properties:
      id:
@@ -2986,6 +3019,16 @@
        items:
          $ref: '#/definitions/model.Satisfaction'
        type: array
      solve_rate:
        description: 解决率
        items:
          $ref: '#/definitions/model.SolveRate'
        type: array
      timely_rate:
        description: 及时率
        items:
          $ref: '#/definitions/model.TimelyRate'
        type: array
    type: object
  response.DepartmentResponse:
    properties:
@@ -3179,6 +3222,13 @@
      list:
        items:
          $ref: '#/definitions/model.ServiceFollowup'
        type: array
    type: object
  response.SolveRateResponse:
    properties:
      list:
        items:
          $ref: '#/definitions/model.SolveRate'
        type: array
    type: object
  response.SubOrderResponse:
@@ -6037,6 +6087,79 @@
      summary: 更新服务跟进
      tags:
      - ServiceFollowup
  /api/solveRate/add:
    post:
      parameters:
      - description: 查询参数
        in: body
        name: object
        required: true
        schema:
          $ref: '#/definitions/request.AddSolveRate'
      produces:
      - application/json
      responses:
        "200":
          description: OK
          schema:
            $ref: '#/definitions/contextx.Response'
      summary: 添加解决率
      tags:
      - SolveRate
  /api/solveRate/delete/{id}:
    delete:
      parameters:
      - description: 查询参数
        in: path
        name: id
        required: true
        type: integer
      produces:
      - application/json
      responses:
        "200":
          description: OK
          schema:
            $ref: '#/definitions/contextx.Response'
      summary: 删除解决率
      tags:
      - SolveRate
  /api/solveRate/list:
    get:
      produces:
      - application/json
      responses:
        "200":
          description: OK
          schema:
            allOf:
            - $ref: '#/definitions/contextx.Response'
            - properties:
                data:
                  $ref: '#/definitions/response.SolveRateResponse'
              type: object
      summary: 获取解决率列表
      tags:
      - SolveRate
  /api/solveRate/update:
    put:
      parameters:
      - description: 查询参数
        in: body
        name: object
        required: true
        schema:
          $ref: '#/definitions/request.UpdateSolveRates'
      produces:
      - application/json
      responses:
        "200":
          description: OK
          schema:
            $ref: '#/definitions/contextx.Response'
      summary: 更新解决率
      tags:
      - SolveRate
  /api/status/add:
    post:
      parameters:

 model/index.go

@@ -65,6 +65,7 @@
        Department{},
        Satisfaction{},
        TimelyRate{},
        SolveRate{},
    )
    return err
}

 model/request/solveRate.go

New file
@@ -0,0 +1,15 @@

package request

type AddSolveRate struct {
    Name string `  json:"name" binding:"required"`
}

type UpdateSolveRate struct {
    Id   int    `json:"id" binding:"required"`
    Name string `json:"name" binding:"required"`
}

type UpdateSolveRates struct {
    SolveRates []*UpdateSolveRate `json:"solve_rate" binding:"required"`
}

 model/response/response.go

@@ -219,6 +219,8 @@
        Satisfaction []*model.Satisfaction `json:"satisfaction"`
        // 及时率
        TimelyRate []*model.TimelyRate `json:"timely_rate"`
        // 解决率
        SolveRate []*model.SolveRate `json:"solve_rate"`
    }

    DepartmentResponse struct {
@@ -232,4 +234,8 @@
    TimelyRateResponse struct {
        List []*model.TimelyRate `json:"list"`
    }

    SolveRateResponse struct {
        List []*model.SolveRate `json:"list"`
    }
)

 model/serviceFollowup.go

@@ -17,7 +17,7 @@
        PlanId               int                  `json:"planId" gorm:"column:plan_id;type:int;comment:服务计划id"`
        SatisfactionId       int                  `json:"satisfactionId" gorm:"column:satisfaction_id;type:int;comment:满意度id"`
        TimelyRateId         int                  `json:"timelyRateId" gorm:"column:timely_rate_id;type:int;comment:及时率id"`
        SolveRate            int                  `json:"solveRate" gorm:"column:solve_rate;type:int;comment:解决率"`
        SolveRateId          int                  `json:"solveRateId" gorm:"column:solve_rate_id;type:int;comment:解决率id"`
        IsVisit              int                  `json:"isVisit" gorm:"column:is_visit;type:int;comment:服务人员是否来过"`
        OldMemberId          int                  `json:"oldMemberId" gorm:"column:old_member_id;type:int;comment:原服务人员"`
        Remark               string               `json:"remark" gorm:"column:remark;type:text;comment:备注"`

 model/solveRate.go

New file
@@ -0,0 +1,85 @@
package model

import (
    "aps_crm/pkg/mysqlx"
    "gorm.io/gorm"
)

type (
    // SolveRate 商机阶段
    SolveRate struct {
        Id   int    `json:"id" gorm:"column:id;primary_key;AUTO_INCREMENT"`
        Name string `json:"name" gorm:"column:name;type:varchar(255);comment:商机阶段名称"`
    }
   
    SolveRateSearch struct {
        SolveRate
        Orm *gorm.DB
    }
)

func (SolveRate) TableName() string {
    return "solve_rate"
}

func NewSolveRateSearch() *SolveRateSearch {
    return &SolveRateSearch{
        Orm: mysqlx.GetDB(),
    }
}

func (slf *SolveRateSearch) build() *gorm.DB {
    var db = slf.Orm.Model(&SolveRate{})
    if slf.Id != 0 {
        db = db.Where("id = ?", slf.Id)
    }
    if slf.Name != "" {
        db = db.Where("name = ?", slf.Name)
    }

    return db
}

func (slf *SolveRateSearch) Create(record *SolveRate) error {
    var db = slf.build()
    return db.Create(record).Error
}

func (slf *SolveRateSearch) Delete() error {
    var db = slf.build()
    return db.Delete(&SolveRate{}).Error
}

func (slf *SolveRateSearch) Update(record *SolveRate) error {
    var db = slf.build()
    return db.Updates(record).Error
}

func (slf *SolveRateSearch) Find() (*SolveRate, error) {
    var db = slf.build()
    var record = new(SolveRate)
    err := db.First(record).Error
    return record, err
}

func (slf *SolveRateSearch) FindAll() ([]*SolveRate, error) {
    var db = slf.build()
    var records = make([]*SolveRate, 0)
    err := db.Find(&records).Error
    return records, err
}

func (slf *SolveRateSearch) SetId(id int) *SolveRateSearch {
    slf.Id = id
    return slf
}

func (slf *SolveRateSearch) SetName(name string) *SolveRateSearch {
    slf.Name = name
    return slf
}

func (slf *SolveRateSearch) Updates(data map[string]interface{}) error {
    var db = slf.build()
    return db.Updates(data).Error
}

 pkg/ecode/code.go

@@ -304,4 +304,9 @@
    TimelyRateSetErr    = 4300004 // 设置及时率失败
    TimelyRateUpdateErr = 4300005 // 更新及时率失败

    SolveRateExist     = 4400001 // 解决率已存在
    SolveRateNotExist  = 4400002 // 解决率不存在
    SolveRateListErr   = 4400003 // 获取解决率列表失败
    SolveRateSetErr    = 4400004 // 设置解决率失败
    SolveRateUpdateErr = 4400005 // 更新解决率失败
)

 router/index.go

@@ -11,6 +11,7 @@
)

type Group struct {
    SolveRateRouter
    TimelyRateRouter
    BaseRouter
    UserRouter
@@ -131,6 +132,7 @@
        routerGroup.InitDepartmentRouter(PrivateGroup)           // 注册department路由
        routerGroup.InitSatisfactionRouter(PrivateGroup)         // 注册satisfaction路由
        routerGroup.InitTimelyRateRouter(PrivateGroup)
        routerGroup.InitSolveRateRouter(PrivateGroup)
    }
    return Router
}

 router/solveRate.go

New file
@@ -0,0 +1,20 @@

package router

import (
    v1 "aps_crm/api/v1"
    "github.com/gin-gonic/gin"
)

type SolveRateRouter struct{}

func (s *SolveRateRouter) InitSolveRateRouter(router *gin.RouterGroup) {
    solveRateRouter := router.Group("solveRate")
    solveRateApi := v1.ApiGroup.SolveRateApi
    {
        solveRateRouter.POST("add", solveRateApi.Add)             // 添加销售阶段
        solveRateRouter.DELETE("delete/:id", solveRateApi.Delete) // 删除销售阶段
        solveRateRouter.PUT("update", solveRateApi.Update)        // 更新销售阶段
        solveRateRouter.GET("list", solveRateApi.List)            // 获取销售阶段列表
    }
}

 service/dataServer.go

@@ -88,7 +88,12 @@
    timelyRateList, _ := ServiceGroup.GetTimelyRateList()
    data.TimelyRate = timelyRateList

    // get SolveRate list
    solveRateList, _ := ServiceGroup.GetSolveRateList()
    data.SolveRate = solveRateList


    errCode = ecode.OK

    return
}
}

 service/index.go

@@ -47,6 +47,7 @@
    VettingService
    SatisfactionService
    TimelyRateService
    SolveRateService
}

var ServiceGroup = new(Group)

 service/solveRate.go

New file
@@ -0,0 +1,69 @@

package service

import (
    "aps_crm/model"
    "aps_crm/model/request"
    "aps_crm/pkg/ecode"
)

type SolveRateService struct{}

func (SolveRateService) AddSolveRate(solveRate *model.SolveRate) int {
    err := model.NewSolveRateSearch().Create(solveRate)
    if err != nil {
        return ecode.SolveRateExist
    }

    return ecode.OK
}

func (SolveRateService) DeleteSolveRate(id int) int {
    _, err := model.NewSolveRateSearch().SetId(id).Find()
    if err != nil {
        return ecode.SolveRateNotExist
    }

    err = model.NewSolveRateSearch().SetId(id).Delete()
    if err != nil {
        return ecode.SolveRateNotExist
    }
    return ecode.OK
}

func (SolveRateService) GetSolveRateList() ([]*model.SolveRate, int) {
    list, err := model.NewSolveRateSearch().FindAll()
    if err != nil {
        return nil, ecode.SolveRateListErr
    }

    return list, ecode.OK
}

func (SolveRateService) UpdateSolveRate(solveRates []*request.UpdateSolveRate) int {
    for _, v := range solveRates {
        // check solveRate exist
        _, err := model.NewSolveRateSearch().SetId(v.Id).Find()
        if err != nil {
            return ecode.SolveRateNotExist
        }

        err = model.NewSolveRateSearch().SetId(v.Id).Updates(map[string]interface{}{
            "name": v.Name,
        })
        if err != nil {
            return ecode.SolveRateSetErr
        }
    }

    return ecode.OK
}

func (SolveRateService) GetSolveRateDetail(id int) (*model.SolveRate, int) {
    solveRate, err := model.NewSolveRateSearch().SetId(id).Find()
    if err != nil {
        return nil, ecode.SolveRateNotExist
    }

    return solveRate, ecode.OK
}