property-system/impl/v1/garden/approve.go

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

package garden

import (
	"context"
	"encoding/json"
	"fmt"
	"gorm.io/gorm"
	"property-system/errors"
	"property-system/impl/v1/permission"
	dbmodel "property-system/model"
	"property-system/pb"
	pb_v1 "property-system/pb/v1"
	"strings"
	"time"

	"git.getensh.com/common/gopkgs/database"
	"git.getensh.com/common/gopkgs/logger"
	"go.uber.org/zap"
	"google.golang.org/grpc/status"
)

func checkGardenApproveParam(req *pb_v1.GardenApproveRequest) error {
	switch {
	case req.Id == 0:
		return status.Error(10003, "小区不能为空")
	}
	return nil
}

func addSuperGroup(db *gorm.DB, gardenId int64, cid int64) error {
	now := time.Now()
	group := &dbmodel.TGroup{
		GardenId:        gardenId,
		Cid:             cid,
		PermissionCodes: "",
		IsSuper:         1,
		GroupName:       "超级管理组",
		UpdatedAt:       now,
		CreatedAt:       now,
		GroupDesc:       "超级管理组",
	}
	err := group.Insert(db)

	if err != nil {
		return errors.DataBaseError
	}

	return nil
}

func initDb(gardenId int64) error {
	mreq := pb_v1.GardenInitDbRequest{GardenId: gardenId}
	_, err := pb.Garden.GardenInitDb(context.Background(), &mreq)
	return err
}

//
func GardenApprove(ctx context.Context, req *pb_v1.GardenApproveRequest) (reply *pb_v1.GardenApproveReply, err error) {

	reply = &pb_v1.GardenApproveReply{}

	// 捕获各个task中的异常并返回给调用者
	defer func() {
		if r := recover(); r != nil {
			err = fmt.Errorf("%+v", r)
			e := &status.Status{}
			if er := json.Unmarshal([]byte(err.Error()), e); er != nil {
				logger.Error("err",
					zap.String("system_err", err.Error()),
					zap.Stack("stacktrace"))
			}
		}
	}()

	err = checkGardenApproveParam(req)
	if err != nil {
		return nil, err
	}

	p := dbmodel.TGarden{}
	where := map[string]interface{}{
		"id": req.Id,
	}
	err = p.Find(database.DB(), where)
	if err != nil && err != gorm.ErrRecordNotFound {
		return nil, errors.DataBaseError
	}
	if p.ID == 0 {
		return nil, errors.GardenNotExist
	}
	now := time.Now()
	if !req.Status {
		values := map[string]interface{}{
			"uniq_flag":   nil,
			"status":      GardenStatusApprovedFail,
			"approved_at": now,
			"feedback":    req.Feedback,
		}
		db := database.DB().Begin()
		garden := dbmodel.TGarden{}
		err = garden.Update(db, where, values)
		if err != nil {
			db.Rollback()
			return nil, errors.DataBaseError
		}
		mreq := pb_v1.CompanyGardenDecreaseRequest{Cid: p.Cid}
		_, err := pb.Company.CompanyGardenDecrease(ctx, &mreq)
		if err != nil {
			db.Rollback()
			return nil, err
		}

		pac := dbmodel.TPackageOrder{}
		where := map[string]interface{}{
			"garden_id":  req.Id,
			"order_type": 1,
		}

		values = map[string]interface{}{
			"garden_id": 0,
		}
		err = pac.Update(db, where, values)
		if err != nil {
			db.Rollback()
			return nil, errors.DataBaseError
		}

		db.Commit()
		return reply, nil
	}

	garden := dbmodel.TGardenApproved{
		Province:         p.Province,
		ProvinceCode:     p.ProvinceCode,
		City:             p.City,
		CityCode:         p.CityCode,
		Area:             p.Area,
		AreaCode:         p.AreaCode,
		Street:           p.Street,
		StreetCode:       p.StreetCode,
		Committee:        p.Committee,
		CommitteeCode:    p.CommitteeCode,
		PropertyPerson:   p.PropertyPerson,
		PropertyPhone:    p.PropertyPhone,
		GardenName:       p.GardenName,
		GardenAddr:       p.GardenAddr,
		Cid:              p.Cid,
		InUse:            true,
		GardenDesc:       p.GardenDesc,
		GardenPic:        p.GardenPic,
		UpdatedAt:        now,
		CreatedAt:        now,
		Lat:              p.Lat,
		Lnt:              p.Lnt,
		Appendix:         p.Appendix,
		PayMode:          1,
		GardenPics:       p.GardenPics,
		BuildingStart:    p.BuildingStart,
		BuildingEnd:      p.BuildingEnd,
		PropertyFeeStart: p.PropertyFeeStart,
		PropertyFeeEnd:   p.PropertyFeeEnd,
		GasFeeStart:      p.GasFeeStart,
		GasFeeEnd:        p.GasFeeEnd,
		BuildingArea:     p.BuildingArea,
		BuildingCompany:  p.BuildingCompany,
		CoveredArea:      p.CoveredArea,
		GreenPercent:     p.GreenPercent,
		AreaPercent:      p.AreaPercent,
		SpaceInfo:        p.SpaceInfo,
		SpaceTotal:       p.SpaceTotal,
		HouseTotal:       p.HouseTotal,
		BuildingType:     p.BuildingType,
		WaterType:        p.WaterType,
		ElectricType:     p.ElectricType,
		AvgPrice:         p.AvgPrice,
	}
	db := database.DB().Begin()
	defer func() {
		if err != nil {
			db.Rollback()
		}
	}()

	// 检查套餐
	pac := dbmodel.TPackageOrder{}
	pacwhere := map[string]interface{}{
		"garden_id":  req.Id,
		"status":     2,
		"order_type": 1,
	}
	err = pac.Find(database.DB(), pacwhere)
	if err != nil && err != gorm.ErrRecordNotFound {
		return nil, errors.DataBaseError
	}
	if pac.ID == 0 {
		return nil, errors.ErrRecordNotFound
	}
	pacinfo := pb_v1.PackageInfoReply{}
	json.Unmarshal([]byte(pac.PackageContent), &pacinfo)

	// 填充套餐信息到小区
	garden.HouseCountLimit = pacinfo.HouseCount
	garden.ExpireAt = time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location()).AddDate(int(pac.Period), 0, 0).Unix()
	codes := []string{}
	m := map[string]bool{}
	for _, application := range pacinfo.Applications {
		for _, v := range application.Permissions {
			if m[v.Code] {
				continue
			}
			m[v.Code] = true
			codes = append(codes, v.Code)
		}
	}
	garden.PermissionCodes = strings.Join(codes, ";")

	err = garden.Insert(db)
	if err != nil {
		if strings.Contains(strings.ToLower(err.Error()), "duplicate") {
			return nil, status.Error(10003, "小区已存在")
		}
		return nil, errors.DataBaseError
	}

	values := map[string]interface{}{
		"garden_id": garden.ID,
	}
	err = pac.Update(db, pacwhere, values)
	if err != nil {
		return nil, errors.DataBaseError
	}

	err = p.Delete(db, where)
	if err != nil {
		return nil, errors.DataBaseError
	}

	err = addSuperGroup(db, garden.ID, p.Cid)
	if err != nil {
		return nil, err
	}
	err = initDb(garden.ID)
	if err != nil {
		return nil, err
	}

	mreq := pb_v1.CompanyObjStatisticSetRequest{Cid: garden.Cid, TotalIncrease: 1, ObjType: 3}
	_, err = pb.Company.CompanyObjStatisticSet(ctx, &mreq)
	if err != nil {
		return nil, err
	}

	db.Commit()

	permission.GardenPermissionTreeClearRedis(garden.ID)

	return reply, nil
}