electricity_bill_calc_service/service/end_user.go

package service

import (
	"electricity_bill_calc/config"
	"electricity_bill_calc/excel"
	"electricity_bill_calc/exceptions"
	"electricity_bill_calc/global"
	"electricity_bill_calc/model"
	"fmt"
	"io"

	"github.com/samber/lo"
	"github.com/shopspring/decimal"
	"xorm.io/builder"
	"xorm.io/xorm"
	"xorm.io/xorm/schemas"
)

type _EndUserService struct{}

var EndUserService _EndUserService

func (_EndUserService) SearchEndUserRecord(reportId, keyword string, page int) ([]model.EndUserDetail, int64, error) {
	cond := builder.NewCond().And(builder.Eq{"report_id": reportId})
	if len(keyword) > 0 {
		cond = cond.And(
			builder.Like{"customer_name", keyword}.
				Or(builder.Like{"contact_name", keyword}).
				Or(builder.Like{"contact_phone", keyword}).
				Or(builder.Like{"meter_04kv_id", keyword}),
		)
	}
	total, err := global.DBConn.
		Table(&model.EndUserDetail{}).
		Where(cond).
		Count()
	if err != nil {
		return make([]model.EndUserDetail, 0), -1, err
	}
	startItem := (page - 1) * config.ServiceSettings.ItemsPageSize
	endUsers := make([]model.EndUserDetail, 0)
	err = global.DBConn.
		Where(cond).
		Limit(config.ServiceSettings.ItemsPageSize, startItem).
		Asc("seq").
		Find(&endUsers)
	return endUsers, total, err
}

func (_EndUserService) AllEndUserRecord(reportId string) ([]model.EndUserDetail, error) {
	users := make([]model.EndUserDetail, 0)
	err := global.DBConn.
		Where(builder.Eq{"report_id": reportId}).
		Asc("seq").
		Find(&users)
	return users, err
}

func (_EndUserService) FetchSpecificEndUserRecord(reportId, parkId, meterId string) (*model.EndUserDetail, error) {
	record := new(model.EndUserDetail)
	_, err := global.DBConn.
		ID(schemas.NewPK(reportId, parkId, meterId)).
		NoAutoCondition().
		Get(record)
	return record, err
}

func (_EndUserService) UpdateEndUserRegisterRecord(tx *xorm.Session, record model.EndUserDetail) (err error) {
	record.CalculatePeriod()
	_, err = tx.ID(schemas.NewPK(record.ReportId, record.ParkId, record.MeterId)).
		Cols(
			"current_period_overall",
			"adjust_overall",
			"current_period_critical",
			"current_period_peak",
			"current_period_flat",
			"current_perios_valley",
			"adjust_critical",
			"adjust_peak",
			"adjust_flat",
			"adjust_valley",
			"overall",
			"critical",
			"peak",
			"flat",
			"valley",
		).
		Update(record)
	return
}

func (_EndUserService) newVirtualExcelAnalysisError(err error) *excel.ExcelAnalysisError {
	return &excel.ExcelAnalysisError{Col: -1, Row: -1, Err: excel.AnalysisError{Err: err}}
}

func (es _EndUserService) BatchImportNonPVRegister(reportId string, file io.Reader) *exceptions.BatchError {
	errs := exceptions.NewBatchError()
	users, err := es.AllEndUserRecord(reportId)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	indexedUsers := lo.Reduce(
		users,
		func(acc map[string]model.EndUserDetail, elem model.EndUserDetail, index int) map[string]model.EndUserDetail {
			acc[elem.MeterId] = elem
			return acc
		},
		make(map[string]model.EndUserDetail, 0),
	)
	analyzer, err := excel.NewEndUserNonPVExcelAnalyzer(file)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	imports, excelErrs := analyzer.Analysis(*new(model.EndUserImport))
	if len(excelErrs) > 0 {
		for _, e := range excelErrs {
			errs.AddError(e)
		}
		return errs
	}
	tx := global.DBConn.NewSession()
	if err = tx.Begin(); err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	defer tx.Close()

	for _, im := range imports {
		if elem, ok := indexedUsers[im.MeterId]; ok {
			elem.CurrentPeriodOverall = im.CurrentPeriodOverall
			elem.AdjustOverall = im.AdjustOverall
			elem.CurrentPeriodCritical = decimal.Zero
			elem.CurrentPeriodPeak = decimal.Zero
			elem.CurrentPeriodValley = decimal.Zero
			elem.AdjustCritical = decimal.Zero
			elem.AdjustPeak = decimal.Zero
			elem.AdjustValley = decimal.Zero
			err := es.UpdateEndUserRegisterRecord(tx, elem)
			if err != nil {
				errs.AddError(es.newVirtualExcelAnalysisError(err))
			}
		} else {
			errs.AddError(exceptions.NewNotFoundError(fmt.Sprintf("表计 %s 未找到", im.MeterId)))
		}
	}
	if errs.Len() > 0 {
		tx.Rollback()
		return errs
	}

	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		errs.AddError(es.newVirtualExcelAnalysisError(err))
	}
	return errs
}

func (es _EndUserService) BatchImportPVRegister(reportId string, file io.Reader) *exceptions.BatchError {
	errs := exceptions.NewBatchError()
	users, err := es.AllEndUserRecord(reportId)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	indexedUsers := lo.Reduce(
		users,
		func(acc map[string]model.EndUserDetail, elem model.EndUserDetail, index int) map[string]model.EndUserDetail {
			acc[elem.MeterId] = elem
			return acc
		},
		make(map[string]model.EndUserDetail, 0),
	)
	analyzer, err := excel.NewEndUserNonPVExcelAnalyzer(file)
	if err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	imports, excelErrs := analyzer.Analysis(*new(model.EndUserImport))
	if len(excelErrs) > 0 {
		for _, e := range excelErrs {
			errs.AddError(e)
		}
		return errs
	}
	tx := global.DBConn.NewSession()
	if err = tx.Begin(); err != nil {
		errs.AddError(es.newVirtualExcelAnalysisError(err))
		return errs
	}
	defer tx.Close()

	for _, im := range imports {
		if elem, ok := indexedUsers[im.MeterId]; ok {
			elem.CurrentPeriodOverall = im.CurrentPeriodOverall
			elem.AdjustOverall = im.AdjustOverall
			elem.CurrentPeriodCritical = im.CurrentPeriodCritical.Decimal
			elem.CurrentPeriodPeak = im.CurrentPeriodPeak.Decimal
			elem.CurrentPeriodValley = im.CurrentPeriodValley.Decimal
			elem.AdjustCritical = im.AdjustCritical.Decimal
			elem.AdjustPeak = im.AdjustPeak.Decimal
			elem.AdjustValley = im.AdjustValley.Decimal
			err := es.UpdateEndUserRegisterRecord(tx, elem)
			if err != nil {
				errs.AddError(es.newVirtualExcelAnalysisError(err))
			}
		} else {
			errs.AddError(es.newVirtualExcelAnalysisError(exceptions.NewNotFoundError(fmt.Sprintf("表计 %s 未找到", im.MeterId))))
		}
	}
	if errs.Len() > 0 {
		tx.Rollback()
		return errs
	}

	err = tx.Commit()
	if err != nil {
		tx.Rollback()
		errs.AddError(es.newVirtualExcelAnalysisError(err))
	}
	return errs
}