lims-extend/controller/company.go

package controller

import (
	"fmt"
	"github.com/gin-gonic/gin"
	"lims-extend/common"
	"lims-extend/model"
	"lims-extend/response"
	"lims-extend/util"
	"strconv"
	"time"
)

func SubmitCompanyCreateRequest(c *gin.Context) {

	db := common.GetDB()
	db.AutoMigrate(&model.CompanyCreateRequest{})
	// 获取数据
	companyName := c.PostForm("company_name")
	creatorId := c.PostForm("user_id")
	certificateFile, err := c.FormFile("business_license")
	// 数据验证
	if err != nil {
		response.Fail(c, nil, "营业执照上传发生错误")
		return
	}
	logoFile, err := c.FormFile("logo")
	if err != nil {
		response.Fail(c, nil, "公司logo上传发生错误")
		return
	}
	var request model.CompanyCreateRequest
	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("name = ?", companyName).First(&request).Error; err == nil || request.Name != "" {
		response.Fail(c, nil, "该公司已存在，无法重复提交申请")
		return
	}
	timestamp := strconv.FormatInt(time.Now().Unix(), 10)
	// 将获取到的图片文件保存到本地
	logoURL := "files/logo/" + timestamp + "_" + logoFile.Filename
	certificateURL := "files/cert/" + timestamp + "_" + certificateFile.Filename
	err = c.SaveUploadedFile(logoFile, logoURL)
	err = c.SaveUploadedFile(certificateFile, certificateURL)
	baseURL := util.GetHTTPHead()
	if err != nil {
		response.Fail(c, nil, "保存文件出错")
		return
	}

	// 查询创建者信息
	var user model.User
	if err := db.Model(&model.User{}).Where("id = ?", creatorId).First(&user).Error; err != nil {
		response.Fail(c, nil, "用户不存在")
		return
	}

	// 创建公司创建请求实体
	request = model.CompanyCreateRequest{
		Name:           companyName,
		LogoUrl:        baseURL + logoURL,
		CertificateUrl: baseURL + certificateURL,
		State:          0, //状态0表示未审核
		CreatorId:      creatorId,
		CreatorName:    user.Username,
		CreatedAt:      model.Time{},
		UpdatedAt:      model.Time{},
	}

	// 提交至数据库
	if err := db.Model(&model.CompanyCreateRequest{}).Create(&request).Error; err != nil {
		response.Fail(c, nil, "公司创建请求出现问题，请检查")
		return
	}

	// 返回创建成功提醒
	response.Success(c, gin.H{"company": request}, "公司创建请求提交成功，请等待审核！")

}

func GetCompanyCreateRequest(c *gin.Context) {
	db := common.GetDB()
	creatorId := c.Params.ByName("creator_id")
	var request model.CompanyCreateRequest
	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("creator_id = ?", creatorId).First(&request).Error; err != nil {
		response.Fail(c, nil, "查无此创建公司请求")
		return
	}
	response.Success(c, gin.H{"request": request}, "查询成功")
}

func GetCompanyCreateRequestsList(c *gin.Context) {
	db := common.GetDB()
	//creatorId := c.Params.ByName("creator_id")
	var requestList []model.CompanyCreateRequest
	if err := db.Model(&model.CompanyCreateRequest{}).
		Find(&requestList).Error; err != nil {
		response.Fail(c, nil, "查询出错")
		return
	}
	response.Success(c, gin.H{"requestList": requestList}, "查询成功")
}

func RejectCompanyCreateRequest(c *gin.Context) {
	db := common.GetDB()
	requestId := c.Params.ByName("request_id")
	var request model.CompanyCreateRequest

	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("id = ?", requestId).
		First(&request).Error; err != nil {
		response.Fail(c, nil, "该创建请求不存在，请检查！")
		return
	}
	if request.State != 0 {
		response.Fail(c, nil, "该创建请求状态不为【未审核】，无法再次变更状态！")
		return
	}
	request.State = 2
	request.UpdatedAt = model.Time{}
	if err := db.Model(&model.CompanyCreateRequest{}).Where("id = ?", requestId).
		Updates(&request).Error; err != nil {
		response.Fail(c, nil, "拒绝失败，数据库错误！")
		return
	}
	response.Success(c, gin.H{"requestList": request}, "该申请已被驳回！")
}

func AcceptCompanyCreateRequest(c *gin.Context) {
	db := common.GetDB()
	requestId := c.Params.ByName("request_id")
	var request model.CompanyCreateRequest

	if err := db.Model(&model.CompanyCreateRequest{}).
		Where("id = ?", requestId).
		First(&request).Error; err != nil {
		response.Fail(c, nil, "该创建请求不存在，请检查！")
		return
	}
	if request.State != 0 {
		response.Fail(c, nil, "该创建请求状态不为【未审核】，无法再次变更状态！")
		return
	}

	db.AutoMigrate(&model.Company{})
	// 开始创建公司实体
	company := model.Company{
		Name:           request.Name,
		LogoUrl:        request.LogoUrl,
		CertificateUrl: request.CertificateUrl,
		CreatorId:      request.CreatorId,
		CreatedAt:      model.Time{},
		UpdatedAt:      model.Time{},
	}
	// 创建公司表数据
	if err := db.Model(&model.Company{}).Create(&company).Error; err != nil {
		response.Fail(c, nil, "公司创建失败，数据库错误。")
		return
	}

	// 设置公司创建申请状态为已同意
	request.State = 1
	request.UpdatedAt = model.Time{}
	if err := db.Model(&model.CompanyCreateRequest{}).Where("id = ?", requestId).
		Updates(&request).Error; err != nil {
		response.Fail(c, nil, "同意申请失败，数据库错误！")
		return
	}

	response.Success(c, gin.H{"company": company}, "审批通过！公司创建成功！")
}

func ApplyJoinCompany(c *gin.Context) {
	db := common.GetDB()
	db.AutoMigrate(&model.Company2Users{})
	// 获取加入公司请求
	type JoinCompanyRequest struct {
		UserId      string `json:"user_id"`
		CompanyName string `json:"company_name"`
	}
	var request JoinCompanyRequest
	if err := c.ShouldBind(&request); err != nil {
		response.Fail(c, nil, "参数不完整")
		return
	}
	// 查询公司是否存在
	var company model.Company
	if err := db.Model(&model.Company{}).
		Where("name = ?", request.CompanyName).
		First(&company).Error; err != nil {
		response.Fail(c, nil, "公司不存在，请检查")
		return
	}
	// 查询是否重复申请
	var dupRequest model.Company2Users
	if err := db.Model(model.Company2Users{}).Where("user_id = ?", request.UserId).
		First(&dupRequest).Error; err == nil && dupRequest.UserId != "" {
		response.Fail(c, nil, fmt.Sprintf("该申请已经存在，请勿重复提交申请"))
		return
	}
	// 创建申请
	applyRequest := model.Company2Users{
		CompanyId: company.ID,
		UserId:    request.UserId,
		State:     0,
		CreatedAt: model.Time{},
		UpdatedAt: model.Time{},
	}
	if err := db.Model(&model.Company2Users{}).Create(&applyRequest).Error; err != nil {
		response.Fail(c, nil, "申请创建失败，数据库错误")
		return
	}
	// 创建成功，返回结果
	response.Success(c, gin.H{"applyRequest": applyRequest}, "申请成功，请等待审核！")
}

func AcceptJoinCompany(c *gin.Context) {
	db := common.GetDB()
	userId := c.Params.ByName("userId")
	var request model.Company2Users
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).First(&request).Error; err != nil {
		response.Fail(c, nil, "该用户不存在或没有提交过申请")
		return
	}
	if request.State != 0 {
		response.Fail(c, nil, "无法重复审批申请")
		return
	}
	request.State = 1
	request.UpdatedAt = model.Time{}
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).Updates(&request).Error; err != nil {
		response.Fail(c, nil, "数据库错误，同意申请失败")
		return
	}
	response.Success(c, nil, "同意申请成功")
}

func RejectJoinCompany(c *gin.Context) {
	db := common.GetDB()
	userId := c.Params.ByName("userId")
	var request model.Company2Users
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).First(&request).Error; err != nil {
		response.Fail(c, nil, "该用户不存在或没有提交过申请")
		return
	}
	if request.State != 0 {
		response.Fail(c, nil, "无法重复审批申请")
		return
	}
	request.State = 2
	request.UpdatedAt = model.Time{}
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).Updates(&request).Error; err != nil {
		response.Fail(c, nil, "数据库错误，驳回申请失败")
		return
	}
	response.Success(c, nil, "驳回申请成功")
}

func GetJoinCompanyRequests(c *gin.Context) {
	db := common.GetDB()
	companyId := c.Params.ByName("companyId")

	type result struct {
		model.Company2Users
		CreatorName string `json:"creator_name" gorm:"column:username"`
	}

	var requests []result

	if err := db.Raw("SELECT company_users.id,company_id,username,user_id,"+
		"state,company_users.create_time,company_users.update_time "+
		"FROM `company_users`,`user` WHERE user.id = company_users.user_id and company_id = ?", companyId).
		Find(&requests).Error; err != nil {
		response.Fail(c, nil, "数据库错误")
		return
	}
	response.Success(c, gin.H{"requestList": requests}, "查询成功")
}

func DelCompanyMember(c *gin.Context) {
	db := common.GetDB()
	userId := c.Params.ByName("userId")

	var request model.Company2Users
	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).First(&request).Error; err != nil {
		response.Fail(c, nil, "公司成员不存在，请勿重复删除")
		return
	}

	if err := db.Model(&model.Company2Users{}).Where("user_id = ?", userId).Delete(&request).Error; err != nil {
		response.Fail(c, nil, "数据库错误，删除失败")
		return
	}
	response.Success(c, nil, "删除成功")
}