smart-enterprise-management-gateway/controller/v1/project.go

// Copyright 2019 github.com. All rights reserved.
// Use of this source code is governed by github.com.

package v1

import (
	"github.com/gin-gonic/gin"
	"github.com/jaryhe/gopkgs/logger"
	"github.com/jaryhe/gopkgs/tasker/httptasker"
	"github.com/jaryhe/gopkgs/util"
	"go.uber.org/zap"
	"net/http"
	"smart-enterprise-management-gateway/errors"
	param_v1 "smart-enterprise-management-gateway/param/v1"
	"smart-enterprise-management-gateway/pb"
	"smart-enterprise-management-gateway/pb/v1"
	"smart-enterprise-management-gateway/utils"
	"strconv"
	"strings"
)

// 项目列表
// @Summary 项目列表
// @Description 项目列表
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query int true " "
// @Param filter query string false " "
// @Param page_size query int false "小于0时代表获取所有"
// @Success 200 {object} v1.ProjectListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project/list [get]
func (c *Controller) ProjectList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectListRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.ProjectListQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectListResponse{}
		rpcReq := &v1.ProjectListRequest{
			Page:req.Page,
			Filter:req.Filter,
			Cid:loginUid,
			PageSize:req.PageSize,
		}
		if req.FilterStatus != "" {
			array := strings.Split(req.FilterStatus, ",")
			for _, v := range array {
				value, _ := strconv.Atoi(v)
				rpcReq.FilterStatus = append(rpcReq.FilterStatus, int32(value))
			}
		}

		reply, err := pb.Enterprise.ProjectList(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectList"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		resp.Data = *reply
		if resp.Data.List == nil {
			resp.Data.List = make([]*v1.ProjectItem, 0)
		}
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 添加项目
// @Summary 添加项目
// @Description 添加项目
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.ProjectAddBody true " "
// @Success 200 {object} v1.ProjectListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project [post]
func (c *Controller) ProjectAdd(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectAddRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.ProjectAddBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid,userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	var projectId int64
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectAddResponse{}
		rpcReq := &v1.ProjectAddRequest{}
		utils.StructCopy(rpcReq, &req.ProjectAddBody, "")
		rpcReq.CompanyId = loginUid

		reply, err := pb.Enterprise.ProjectAdd(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectAdd"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		projectId = reply.Id
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask)
	s, _ := json.MarshalToString(req)
	utils.LogWrite("项目申请", loginUid, userName,  s, err, projectId)
}

// 项目账号列表
// @Summary 项目账号列表
// @Description 项目账号列表
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param page query int true " "
// @Param filter query string false " "
// @Success 200 {object} v1.ProjectUserListResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project/user_list [get]
func (c *Controller) ProjectUserList(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectUserListRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, &req.ProjectUserListQuery, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectUserListResponse{}
		rpcReq := &v1.ProjectUserListRequest{
			Page:req.Page,
			Filter:req.Filter,
			Cid:loginUid,
		}


		reply, err := pb.Enterprise.ProjectUserList(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectUserList"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		resp.Data = *reply
		if resp.Data.List == nil {
			resp.Data.List = make([]*v1.ProjectUserItem, 0)
		}
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}

// 起停用项目账号
// @Summary 起停用项目账号
// @Description 起停用项目账号
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.EnableProjectUserBody true " "
// @Success 200 {object} v1.EnableProjectUserResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project/user [put]
func (c *Controller) EnableProjectUser(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.EnableProjectUserRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.EnableProjectUserBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	var projectId int64
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.EnableProjectUserResponse{}
		rpcReq := &v1.EnableProjectUserRequest{
			Id:req.Id,
			Enable:req.Enable,
		}

		reply, err := pb.Enterprise.EnableProjectUser(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "EnableProjectUser"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		projectId = reply.ProjectId
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask)
	s, _ := json.MarshalToString(req)
	utils.LogWrite("起停用项目账号", loginUid, userName,  s, err, projectId)
}

// 重置项目账号密码
// @Summary 重置项目账号密码
// @Description 重置项目账号密码
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.ProjectUserPasswordResetBody true " "
// @Success 200 {object} v1.ProjectUserPasswordResetResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project/password [put]
func (c *Controller) ProjectUserPasswordReset(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectUserPasswordResetRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.ProjectUserPasswordResetBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid,userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	var projectId int64
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectUserPasswordResetResponse{}
		rpcReq := &v1.ProjectUserPasswordResetRequest{}
		rpcReq.Password = req.Password
		rpcReq.Id = req.Id

		_, err := pb.Enterprise.ProjectUserPasswordReset(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectUserPasswordReset"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask)
	s, _ := json.MarshalToString(req)
	utils.LogWrite("重置项目账号密码", loginUid, userName,  s, err, projectId)
}

// 变更项目
// @Summary变更项目
// @Description 变更项目
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param body body v1.ProjectUpdateBody true " "
// @Success 200 {object} v1.ProjectUpdateResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project [put]
func (c *Controller) ProjectUpdate(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectUpdateRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, nil, nil, &req.ProjectUpdateBody)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid,userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectUpdateResponse{}
		rpcReq := &v1.ProjectUpdateRequest{}
		utils.StructCopy(rpcReq, &req.ProjectUpdateBody, "")

		_, err := pb.Enterprise.ProjectUpdate(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectUpdate"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask)
	s, _ := json.MarshalToString(req)
	utils.LogWrite("项目变更", loginUid, userName,  s, err, req.Id)
}

// 获取省市区
// @Summary获取省市区
// @Description 获取省市区
// @Tags project
// @Accept  json
// @Produce  json
// @Success 200 {object} v1.ProjectDistrictResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project/district [get]
func (c *Controller) ProjectDistrict(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectDistrictRequest{}


	// 业务处理
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectDistrictResponse{}
		rpcReq := &v1.ProjectDistrictRequest{}

		rpcResp, err := pb.Enterprise.ProjectDistrict(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectDistrict"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}

		if rpcResp.List == nil {
			rpcResp.List = []*v1.ProjectDistrictProvince{}
		}
		for i, v := range rpcResp.List {
			if v.List == nil {
				rpcResp.List[i].List = []*v1.ProjectDistrictCity{}
				continue
			}
			for j, z := range rpcResp.List[i].List {
				if z.List == nil {
					rpcResp.List[i].List[j].List = []*v1.ProjectDistrictZone{}
				}
			}
		}
		resp.Data = *rpcResp
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, handleServiceTask)
}

// 项目详情
// @Summary 项目详情
// @Description 项目详情
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param id path int64 true " "
// @Success 200 {object} v1.ProjectInfoResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project/info/{id} [get]
func (c *Controller) ProjectInfo(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectInfoRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, &req.ProjectInfoPath, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectInfoResponse{}
		rpcReq := &v1.ProjectInfoRequest{
			Id:req.Id,
		}

		reply, err := pb.Enterprise.ProjectInfo(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectInfo"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		resp.Data = *reply
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	httptasker.Exec(ctx, parseParamTask, handleServiceTask)
}


// 项目删除
// @Summary 项目删除
// @Description 项目删除
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param id path int64 true " "
// @Success 200 {object} v1.ProjectDelResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project/{id} [delete]
func (c *Controller) ProjectDel(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectDelRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, &req.ProjectDelPath, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	origin := ""
	// 业务处理
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectDelResponse{}
		rpcReq := &v1.ProjectDelRequest{
			Id:req.Id,
		}

		reply, err := pb.Enterprise.ProjectDel(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectDel"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		origin = reply.Origin
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask)
	utils.LogWrite("项目删除", loginUid, userName,  origin, err, req.Id)
}

//
// @Summary 项目完工
// @Description 项目完工
// @Tags project
// @Accept  json
// @Produce  json
// @Param token header string true " "
// @Param id path int64 true " "
// @Success 200 {object} v1.ProjectFinishResponse
// @Failure 500 {object} base.HTTPError
// @Router /api/v1/project/finish/{id} [put]
func (c *Controller) ProjectFinish(ctx *gin.Context) {
	// 解析参数
	req := &param_v1.ProjectFinishRequest{}
	var loginUid int64
	var userName string
	parseParamTask := func() error {
		err := util.ShouldBind(ctx, &req.Header, &req.ProjectFinishPath, nil, nil)
		if err != nil {
			logger.Error("func",
				zap.String("call", "util.ShouldBind"),
				zap.String("error", err.Error()))
			return errors.ParamsError
		}
		loginUid, userName, err = utils.GetJwtIdFromCtx(ctx)
		return nil
	}

	// 业务处理
	handleServiceTask := func() error {
		// 响应数据

		resp := param_v1.ProjectFinishResponse{}
		rpcReq := &v1.ProjectFinishRequest{
			Id:req.Id,
		}

		_, err := pb.Enterprise.ProjectFinish(ctx, rpcReq)
		if err != nil {
			s, _ := json.MarshalToString(req)
			logger.Error("func",
				zap.String("call", "ProjectFinish"),
				zap.String("params", s),
				zap.String("error", err.Error()))

			return errors.ErrorTransForm(err)
		}
		ctx.JSON(http.StatusOK, resp)
		return nil
	}

	// 执行任务
	err := httptasker.Exec(ctx, parseParamTask, handleServiceTask)
	utils.LogWrite("项目完工", loginUid, userName,  "", err, req.Id)
}