add

wangpengfei

2023-07-07 045199a75fceedea2e310d8798922c302f317849

add

saleStage 商机类型
add, Delete, update, list

 api/v1/index.go

@@ -27,6 +27,7 @@
    FollowRecordApi
    SaleChanceApi
    SaleStageApi
    SaleTypeApi
}

var ApiGroup = new(Group)
@@ -53,4 +54,5 @@
    followRecordService      = service.ServiceGroup.FollowRecordService
    saleChanceService        = service.ServiceGroup.SaleChanceService
    saleStageService         = service.ServiceGroup.SaleStageService
    saleTypeService          = service.ServiceGroup.SaleTypeService
)

 api/v1/saleType.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 SaleTypeApi struct{}

// Add
//
// @Tags SaleType
// @Summary 添加销售类型
// @Produce application/json
// @Param object body request.AddSaleType true "查询参数"
// @Success 200 {object} contextx.Response{}
// @Router /api/saleType/add [post]
func (s *SaleTypeApi) Add(c *gin.Context) {
    var params request.AddSaleType
    ctx, ok := contextx.NewContext(c, &params)
    if !ok {
        return
    }

    saleType := new(model.SaleType)
    saleType.Name = params.Name

    errCode := saleTypeService.AddSaleType(saleType)
    if errCode != ecode.OK {
        ctx.Fail(errCode)
        return
    }

    ctx.Ok()
}

// Delete
//
// @Tags SaleType
// @Summary 删除销售类型
// @Produce application/json
// @Param id path int true "查询参数"
// @Success 200 {object} contextx.Response{}
// @Router /api/saleType/delete/{id} [delete]
func (s *SaleTypeApi) Delete(c *gin.Context) {
    ctx, ok := contextx.NewContext(c, nil)
    if !ok {
        return
    }

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

    ctx.Ok()
}

// Update
//
// @Tags SaleType
// @Summary 更新销售类型
// @Produce application/json
// @Param object body request.UpdateSaleTypes true "查询参数"
// @Success 200 {object} contextx.Response{}
// @Router /api/saleType/update [put]
func (s *SaleTypeApi) Update(c *gin.Context) {
    var params request.UpdateSaleTypes
    ctx, ok := contextx.NewContext(c, &params)
    if !ok {
        return
    }

    errCode := saleTypeService.UpdateSaleType(params.SaleTypes)
    if errCode != ecode.OK {
        ctx.Fail(errCode)
        return
    }

    ctx.Ok()
}

// List
//
// @Tags SaleType
// @Summary 获取销售类型列表
// @Produce application/json
// @Success 200 {object} contextx.Response{data=response.SaleTypeResponse}
// @Router /api/saleType/list [get]
func (s *SaleTypeApi) List(c *gin.Context) {
    ctx, ok := contextx.NewContext(c, nil)
    if !ok {
        return
    }

    saleTypes, errCode := saleTypeService.GetSaleTypeList()
    if errCode != ecode.OK {
        ctx.Fail(errCode)
        return
    }

    ctx.OkWithDetailed(response.SaleTypeResponse{
        List: saleTypes,
    })
}

 docs/docs.go

@@ -2223,6 +2223,125 @@
                }
            }
        },
        "/api/saleType/add": {
            "post": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SaleType"
                ],
                "summary": "添加销售类型",
                "parameters": [
                    {
                        "description": "查询参数",
                        "name": "object",
                        "in": "body",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/request.AddSaleType"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/saleType/delete/{id}": {
            "delete": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SaleType"
                ],
                "summary": "删除销售类型",
                "parameters": [
                    {
                        "type": "integer",
                        "description": "查询参数",
                        "name": "id",
                        "in": "path",
                        "required": true
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/saleType/list": {
            "get": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SaleType"
                ],
                "summary": "获取销售类型列表",
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "allOf": [
                                {
                                    "$ref": "#/definitions/contextx.Response"
                                },
                                {
                                    "type": "object",
                                    "properties": {
                                        "data": {
                                            "$ref": "#/definitions/response.SaleTypeResponse"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                }
            }
        },
        "/api/saleType/update": {
            "put": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SaleType"
                ],
                "summary": "更新销售类型",
                "parameters": [
                    {
                        "description": "查询参数",
                        "name": "object",
                        "in": "body",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/request.UpdateSaleTypes"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/salesLeads/add": {
            "post": {
                "produces": [
@@ -3378,6 +3497,17 @@
                }
            }
        },
        "model.SaleType": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "integer"
                },
                "name": {
                    "type": "string"
                }
            }
        },
        "model.SalesLeads": {
            "type": "object",
            "properties": {
@@ -3907,6 +4037,17 @@
            }
        },
        "request.AddSaleStage": {
            "type": "object",
            "required": [
                "name"
            ],
            "properties": {
                "name": {
                    "type": "string"
                }
            }
        },
        "request.AddSaleType": {
            "type": "object",
            "required": [
                "name"
@@ -4888,6 +5029,35 @@
                }
            }
        },
        "request.UpdateSaleType": {
            "type": "object",
            "required": [
                "id",
                "name"
            ],
            "properties": {
                "id": {
                    "type": "integer"
                },
                "name": {
                    "type": "string"
                }
            }
        },
        "request.UpdateSaleTypes": {
            "type": "object",
            "required": [
                "sale_types"
            ],
            "properties": {
                "sale_types": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/request.UpdateSaleType"
                    }
                }
            }
        },
        "request.UpdateSalesLeads": {
            "type": "object",
            "properties": {
@@ -5171,6 +5341,17 @@
                }
            }
        },
        "response.SaleTypeResponse": {
            "type": "object",
            "properties": {
                "list": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/model.SaleType"
                    }
                }
            }
        },
        "response.SalesLeadsResponse": {
            "type": "object",
            "properties": {

 docs/swagger.json

@@ -2211,6 +2211,125 @@
                }
            }
        },
        "/api/saleType/add": {
            "post": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SaleType"
                ],
                "summary": "添加销售类型",
                "parameters": [
                    {
                        "description": "查询参数",
                        "name": "object",
                        "in": "body",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/request.AddSaleType"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/saleType/delete/{id}": {
            "delete": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SaleType"
                ],
                "summary": "删除销售类型",
                "parameters": [
                    {
                        "type": "integer",
                        "description": "查询参数",
                        "name": "id",
                        "in": "path",
                        "required": true
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/saleType/list": {
            "get": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SaleType"
                ],
                "summary": "获取销售类型列表",
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "allOf": [
                                {
                                    "$ref": "#/definitions/contextx.Response"
                                },
                                {
                                    "type": "object",
                                    "properties": {
                                        "data": {
                                            "$ref": "#/definitions/response.SaleTypeResponse"
                                        }
                                    }
                                }
                            ]
                        }
                    }
                }
            }
        },
        "/api/saleType/update": {
            "put": {
                "produces": [
                    "application/json"
                ],
                "tags": [
                    "SaleType"
                ],
                "summary": "更新销售类型",
                "parameters": [
                    {
                        "description": "查询参数",
                        "name": "object",
                        "in": "body",
                        "required": true,
                        "schema": {
                            "$ref": "#/definitions/request.UpdateSaleTypes"
                        }
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "schema": {
                            "$ref": "#/definitions/contextx.Response"
                        }
                    }
                }
            }
        },
        "/api/salesLeads/add": {
            "post": {
                "produces": [
@@ -3366,6 +3485,17 @@
                }
            }
        },
        "model.SaleType": {
            "type": "object",
            "properties": {
                "id": {
                    "type": "integer"
                },
                "name": {
                    "type": "string"
                }
            }
        },
        "model.SalesLeads": {
            "type": "object",
            "properties": {
@@ -3895,6 +4025,17 @@
            }
        },
        "request.AddSaleStage": {
            "type": "object",
            "required": [
                "name"
            ],
            "properties": {
                "name": {
                    "type": "string"
                }
            }
        },
        "request.AddSaleType": {
            "type": "object",
            "required": [
                "name"
@@ -4876,6 +5017,35 @@
                }
            }
        },
        "request.UpdateSaleType": {
            "type": "object",
            "required": [
                "id",
                "name"
            ],
            "properties": {
                "id": {
                    "type": "integer"
                },
                "name": {
                    "type": "string"
                }
            }
        },
        "request.UpdateSaleTypes": {
            "type": "object",
            "required": [
                "sale_types"
            ],
            "properties": {
                "sale_types": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/request.UpdateSaleType"
                    }
                }
            }
        },
        "request.UpdateSalesLeads": {
            "type": "object",
            "properties": {
@@ -5159,6 +5329,17 @@
                }
            }
        },
        "response.SaleTypeResponse": {
            "type": "object",
            "properties": {
                "list": {
                    "type": "array",
                    "items": {
                        "$ref": "#/definitions/model.SaleType"
                    }
                }
            }
        },
        "response.SalesLeadsResponse": {
            "type": "object",
            "properties": {

 docs/swagger.yaml

@@ -444,6 +444,13 @@
      name:
        type: string
    type: object
  model.SaleType:
    properties:
      id:
        type: integer
      name:
        type: string
    type: object
  model.SalesLeads:
    properties:
      city:
@@ -805,6 +812,13 @@
        type: string
    type: object
  request.AddSaleStage:
    properties:
      name:
        type: string
    required:
    - name
    type: object
  request.AddSaleType:
    properties:
      name:
        type: string
@@ -1480,6 +1494,25 @@
    required:
    - sale_stages
    type: object
  request.UpdateSaleType:
    properties:
      id:
        type: integer
      name:
        type: string
    required:
    - id
    - name
    type: object
  request.UpdateSaleTypes:
    properties:
      sale_types:
        items:
          $ref: '#/definitions/request.UpdateSaleType'
        type: array
    required:
    - sale_types
    type: object
  request.UpdateSalesLeads:
    properties:
      city_id:
@@ -1663,6 +1696,13 @@
      list:
        items:
          $ref: '#/definitions/model.SaleStage'
        type: array
    type: object
  response.SaleTypeResponse:
    properties:
      list:
        items:
          $ref: '#/definitions/model.SaleType'
        type: array
    type: object
  response.SalesLeadsResponse:
@@ -3039,6 +3079,79 @@
      summary: 更新销售阶段
      tags:
      - SaleStage
  /api/saleType/add:
    post:
      parameters:
      - description: 查询参数
        in: body
        name: object
        required: true
        schema:
          $ref: '#/definitions/request.AddSaleType'
      produces:
      - application/json
      responses:
        "200":
          description: OK
          schema:
            $ref: '#/definitions/contextx.Response'
      summary: 添加销售类型
      tags:
      - SaleType
  /api/saleType/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:
      - SaleType
  /api/saleType/list:
    get:
      produces:
      - application/json
      responses:
        "200":
          description: OK
          schema:
            allOf:
            - $ref: '#/definitions/contextx.Response'
            - properties:
                data:
                  $ref: '#/definitions/response.SaleTypeResponse'
              type: object
      summary: 获取销售类型列表
      tags:
      - SaleType
  /api/saleType/update:
    put:
      parameters:
      - description: 查询参数
        in: body
        name: object
        required: true
        schema:
          $ref: '#/definitions/request.UpdateSaleTypes'
      produces:
      - application/json
      responses:
        "200":
          description: OK
          schema:
            $ref: '#/definitions/contextx.Response'
      summary: 更新销售类型
      tags:
      - SaleType
  /api/salesLeads/add:
    post:
      parameters:

 model/index.go

@@ -42,6 +42,7 @@
        SalesLeads{},
        SalesSources{},
        SaleStage{},
        SaleType{},
    )
    return err
}

 model/request/saleType.go

New file
@@ -0,0 +1,14 @@
package request

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

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

type UpdateSaleTypes struct {
    SaleTypes []*UpdateSaleType `json:"sale_types" binding:"required"`
}

 model/response/response.go

@@ -105,4 +105,8 @@
    SaleStageResponse struct {
        List []*model.SaleStage `json:"list"`
    }

    SaleTypeResponse struct {
        List []*model.SaleType `json:"list"`
    }
)

 model/saleType.go

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

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

type (
    SaleType struct {
        Id   int    `json:"id" gorm:"column:id;primary_key;AUTO_INCREMENT"`
        Name string `json:"name" gorm:"column:name;type:varchar(255);comment:商机类型名称"`
    }

    SaleTypeSearch struct {
        SaleType
        Orm *gorm.DB
    }
)

func (SaleType) TableName() string {
    return "sale_type"
}

func NewSaleTypeSearch() *SaleTypeSearch {
    return &SaleTypeSearch{
        Orm: mysqlx.GetDB(),
    }
}

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

    return db
}

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

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

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

func (slf *SaleTypeSearch) Find() (*SaleType, error) {
    var db = slf.build()
    var record = &SaleType{}
    err := db.First(record).Error
    return record, err
}

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

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

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

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

 pkg/ecode/code.go

@@ -148,4 +148,12 @@
    SaleStageNotExist = 2000002 // 销售阶段不存在
    SaleStageListErr  = 2000003 // 获取销售阶段列表失败
    SaleStageSetErr   = 2000004 // 设置销售阶段失败

    SaleTypeExist     = 2100001 // 销售类型已存在
    SaleTypeNotExist  = 2100002 // 销售类型不存在
    SaleTypeListErr   = 2100003 // 获取销售类型列表失败
    SaleTypeSetErr    = 2100004 // 设置销售类型失败
    SaleTypeUpdateErr = 2100005 // 更新销售类型失败
    SaleTypeDeleteErr = 2100006 // 删除销售类型失败

)

 router/index.go

@@ -33,6 +33,7 @@
    FollowRecordRouter
    SaleChanceRouter
    SaleStageRouter
    SaleTypeRouter
}

func InitRouter() *gin.Engine {
@@ -83,6 +84,7 @@
        routerGroup.InitFollowRecordRouter(PrivateGroup)      // 注册followRecord路由
        routerGroup.InitSaleChanceRouter(PrivateGroup)        // 注册saleChance路由
        routerGroup.InitSaleStageRouter(PrivateGroup)         // 注册saleStage路由
        routerGroup.InitSaleTypeRouter(PrivateGroup)          // 注册saleType路由
    }
    return Router
}

 router/saleType.go

New file
@@ -0,0 +1,19 @@
package router

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

type SaleTypeRouter struct{}

func (s *SaleTypeRouter) InitSaleTypeRouter(router *gin.RouterGroup) {
    saleTypeRouter := router.Group("saleType")
    saleTypeApi := v1.ApiGroup.SaleTypeApi
    {
        saleTypeRouter.POST("add", saleTypeApi.Add)             // 添加销售类型
        saleTypeRouter.DELETE("delete/:id", saleTypeApi.Delete) // 删除销售类型
        saleTypeRouter.PUT("update", saleTypeApi.Update)        // 更新销售类型
        saleTypeRouter.GET("list", saleTypeApi.List)            // 获取销售类型列表
    }
}

 service/index.go

@@ -22,6 +22,7 @@
    FollowRecordService
    SaleChanceService
    SaleStageService
    SaleTypeService
}

var ServiceGroup = new(Group)

 service/saleType.go

New file
@@ -0,0 +1,59 @@
package service

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

type SaleTypeService struct{}

func (SaleTypeService) AddSaleType(saleType *model.SaleType) int {
    err := model.NewSaleTypeSearch().Create(saleType)
    if err != nil {
        return ecode.SaleTypeExist
    }

    return ecode.OK
}

func (SaleTypeService) DeleteSaleType(id int) int {
    _, err := model.NewSaleTypeSearch().SetId(id).Find()
    if err != nil {
        return ecode.SaleTypeNotExist
    }

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

func (SaleTypeService) GetSaleTypeList() ([]*model.SaleType, int) {
    list, err := model.NewSaleTypeSearch().FindAll()
    if err != nil {
        return nil, ecode.SaleTypeListErr
    }

    return list, ecode.OK
}

func (SaleTypeService) UpdateSaleType(saleTypes []*request.UpdateSaleType) int {
    for _, v := range saleTypes {
        // check saleType exist
        _, err := model.NewSaleTypeSearch().SetId(v.Id).Find()
        if err != nil {
            return ecode.SaleTypeNotExist
        }

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

    return ecode.OK
}