336 lines
10 KiB
Go
336 lines
10 KiB
Go
package calculate
|
||
|
||
import (
|
||
"electricity_bill_calc/model"
|
||
"electricity_bill_calc/model/calculate"
|
||
"electricity_bill_calc/repository"
|
||
"errors"
|
||
"fmt"
|
||
"github.com/shopspring/decimal"
|
||
"log"
|
||
)
|
||
|
||
func CollectMeters(tenements []calculate.PrimaryTenementStatistics, poolings []calculate.Meter, publics []calculate.Meter) (MeterMap, error) {
|
||
meters := make(MeterMap)
|
||
// Collect tenement meters
|
||
for _, t := range tenements {
|
||
for _, m := range t.Meters {
|
||
log.Println("m000000000000000000000000000", m.Code)
|
||
|
||
key := Key{TenementID: t.Tenement.Id, Code: m.Code}
|
||
meters[key] = m
|
||
}
|
||
}
|
||
// Collect poolings
|
||
for _, m := range poolings {
|
||
log.Println("m111111111111111111111111", m.Code)
|
||
key := Key{TenementID: "", Code: m.Code}
|
||
meters[key] = m
|
||
}
|
||
|
||
// Collect publics
|
||
for _, m := range publics {
|
||
log.Println("m222222222222222222222222222", m.Code)
|
||
|
||
key := Key{TenementID: "", Code: m.Code}
|
||
meters[key] = m
|
||
}
|
||
log.Println("m33333333333333333333333333333333333333", meters[Key{Code: "yq00001"}])
|
||
return meters, nil
|
||
}
|
||
|
||
// / 计算基本电费摊薄
|
||
func CalculateBasicPooling(report *model.ReportIndex, summary *calculate.Summary, meters *MeterMap) error {
|
||
switch report.BasisPooled {
|
||
case model.POOLING_MODE_AREA:
|
||
if summary.OverallArea.IsZero() {
|
||
return fmt.Errorf("园区中表计覆盖总面积为零，无法按面积摊薄")
|
||
}
|
||
for _, meter := range *meters {
|
||
meterFee := meter.Overall.Amount.InexactFloat64() * summary.BasicPooledPriceArea.InexactFloat64()
|
||
meter.PooledBasic = model.ConsumptionUnit{
|
||
Amount: meter.Overall.Amount,
|
||
Fee: decimal.NewFromFloat(meterFee),
|
||
Price: summary.BasicPooledPriceArea,
|
||
Proportion: summary.BasicFee,
|
||
}
|
||
}
|
||
case model.POOLING_MODE_CONSUMPTION:
|
||
for _, meter := range *meters {
|
||
meterFee := meter.Overall.Amount.InexactFloat64() * summary.BasicPooledPriceConsumption.InexactFloat64()
|
||
meter.PooledBasic = model.ConsumptionUnit{
|
||
Amount: meter.Overall.Amount,
|
||
Fee: decimal.NewFromFloat(meterFee),
|
||
Price: summary.BasicPooledPriceConsumption,
|
||
Proportion: summary.BasicFee,
|
||
}
|
||
}
|
||
default:
|
||
}
|
||
return nil
|
||
}
|
||
|
||
/// 计算调整电费摊薄
|
||
|
||
func CalculateAdjustPooling(report model.ReportIndex, summary calculate.Summary, meters MeterMap) error {
|
||
var p decimal.Decimal
|
||
switch report.AdjustPooled {
|
||
case model.POOLING_MODE_AREA:
|
||
if summary.OverallArea.IsZero() {
|
||
return fmt.Errorf("园区中表计覆盖总面积为零，无法按面积摊薄")
|
||
}
|
||
|
||
for _, meter := range meters {
|
||
meterFee := meter.Overall.Amount.Mul(summary.AdjustPooledPriceArea)
|
||
if summary.AdjustFee.IsZero() {
|
||
p = decimal.Zero
|
||
} else {
|
||
p = meterFee.Div(summary.AdjustFee)
|
||
}
|
||
meter.PooledAdjust = model.ConsumptionUnit{
|
||
Amount: meter.Overall.Amount,
|
||
Fee: meterFee,
|
||
Price: summary.AdjustPooledPriceArea,
|
||
Proportion: p,
|
||
}
|
||
}
|
||
case model.POOLING_MODE_CONSUMPTION:
|
||
for _, meter := range meters {
|
||
meterFee := meter.Overall.Amount.Mul(summary.AdjustPooledPriceConsumption)
|
||
if summary.AdjustFee.IsZero() {
|
||
p = decimal.Zero
|
||
} else {
|
||
p = meterFee.Div(summary.AdjustFee)
|
||
}
|
||
meter.PooledAdjust = model.ConsumptionUnit{
|
||
Amount: meter.Overall.Amount,
|
||
Fee: meterFee,
|
||
Price: summary.AdjustPooledPriceConsumption,
|
||
Proportion: p,
|
||
}
|
||
}
|
||
default:
|
||
|
||
}
|
||
return nil
|
||
}
|
||
|
||
// 除数问题
|
||
func CalculateLossPooling(report model.ReportIndex, summary calculate.Summary, meters MeterMap) error {
|
||
switch report.LossPooled {
|
||
case model.POOLING_MODE_AREA:
|
||
if summary.OverallArea.IsZero() {
|
||
return fmt.Errorf("园区中表计覆盖总面积为零，无法按面积摊薄")
|
||
}
|
||
for _, meter := range meters {
|
||
pooledLossAmount1 := meter.Detail.Area.Decimal.Div(summary.OverallArea)
|
||
pooledLossAmount := pooledLossAmount1.Mul(summary.AuthoizeLoss.Amount)
|
||
meter.PooledLoss = model.ConsumptionUnit{
|
||
Amount: pooledLossAmount,
|
||
Fee: pooledLossAmount.Mul(summary.LossDilutedPrice),
|
||
Price: summary.LossDilutedPrice,
|
||
Proportion: meter.Detail.Area.Decimal.Div(summary.OverallArea),
|
||
}
|
||
}
|
||
case model.POOLING_MODE_CONSUMPTION:
|
||
for _, meter := range meters {
|
||
pooledLossAmount1 := meter.Detail.Area.Decimal.Div(summary.OverallArea)
|
||
pooledLossAmount := pooledLossAmount1.Mul(summary.AuthoizeLoss.Amount)
|
||
|
||
meter.PooledLoss = model.ConsumptionUnit{
|
||
Amount: pooledLossAmount,
|
||
Fee: pooledLossAmount.Mul(summary.LossDilutedPrice),
|
||
Price: summary.LossDilutedPrice,
|
||
Proportion: meter.Overall.Amount.Div(summary.Overall.Amount),
|
||
}
|
||
}
|
||
default:
|
||
// 其他情况下不做处理
|
||
}
|
||
return nil
|
||
}
|
||
|
||
/// 计算所有商户类型表计的全周期电量。
|
||
|
||
func CalculateTenementConsumptions(meters MeterMap) (map[string]decimal.Decimal, error) {
|
||
consumptions := make(map[string]decimal.Decimal)
|
||
for _, meter := range meters {
|
||
if meter.Detail.MeterType == model.METER_INSTALLATION_TENEMENT {
|
||
amount, ok := consumptions[meter.Code]
|
||
if !ok {
|
||
amount = decimal.Decimal{}
|
||
}
|
||
amount.Add(meter.Overall.Amount).Add(amount)
|
||
consumptions[meter.Code] = amount
|
||
}
|
||
}
|
||
for _, meter := range meters {
|
||
if meter.Detail.MeterType == model.METER_INSTALLATION_TENEMENT {
|
||
amount, ok := consumptions[meter.Code]
|
||
if !ok {
|
||
return nil, errors.New("meter code not found in consumptions")
|
||
}
|
||
|
||
if amount.GreaterThan(decimal.Zero) {
|
||
meter.SharedPoolingProportion = meter.Overall.Amount.Div(amount)
|
||
} else if amount.IsZero() {
|
||
meter.SharedPoolingProportion = decimal.NewFromFloat(1.0)
|
||
} else {
|
||
meter.SharedPoolingProportion = decimal.NewFromFloat(1.0)
|
||
}
|
||
}
|
||
}
|
||
|
||
return consumptions, nil
|
||
}
|
||
|
||
// 计算商户表计的公摊分摊
|
||
func CalculateTenementPoolings(report model.ReportIndex, summary calculate.Summary, meters MeterMap, meterRelations []model.MeterRelation) error {
|
||
switch report.PublicPooled {
|
||
case model.POOLING_MODE_AREA:
|
||
for _, meter := range meters {
|
||
if meter.Detail.MeterType != model.METER_INSTALLATION_TENEMENT {
|
||
var pooleds []struct {
|
||
PooledAmount decimal.Decimal
|
||
ParentAmount decimal.Decimal
|
||
ParentCode string
|
||
}
|
||
for _, relation := range meterRelations {
|
||
if relation.SlaveMeter == meter.Code {
|
||
key := Key{
|
||
Code: relation.MasterMeter,
|
||
}
|
||
parentMeter, ok := meters[key]
|
||
if !ok {
|
||
// 处理未找到父级表计的情况
|
||
continue
|
||
}
|
||
// 计算分摊电量和父级表电量
|
||
pooledAmount := meter.Detail.Area.Decimal.Div(parentMeter.CoveredArea).Mul(parentMeter.Overall.Amount).Mul(meter.SharedPoolingProportion)
|
||
pooleds = append(pooleds, struct {
|
||
PooledAmount decimal.Decimal
|
||
ParentAmount decimal.Decimal
|
||
ParentCode string
|
||
}{
|
||
PooledAmount: pooledAmount,
|
||
ParentAmount: parentMeter.Overall.Amount,
|
||
ParentCode: parentMeter.Code,
|
||
})
|
||
}
|
||
}
|
||
|
||
// 计算总分摊电量和总父级电量
|
||
var consumptions, total decimal.Decimal
|
||
for _, p := range pooleds {
|
||
consumptions = consumptions.Add(p.PooledAmount)
|
||
total = total.Add(p.ParentAmount)
|
||
}
|
||
// 计算并更新公摊分摊信息
|
||
for _, p := range pooleds {
|
||
poolingAmount := p.PooledAmount
|
||
proportion := p.PooledAmount.Div(p.ParentAmount)
|
||
fee := poolingAmount.Mul(summary.Overall.Price)
|
||
|
||
// 更新父级表计的公摊分摊信息
|
||
key := Key{
|
||
Code: p.ParentCode,
|
||
}
|
||
parentMeter := meters[key]
|
||
parentMeter.PooledPublic.Amount = consumptions
|
||
parentMeter.PooledPublic.Fee = consumptions.Mul(summary.Overall.Price)
|
||
parentMeter.PooledPublic.Proportion = consumptions.Div(total)
|
||
meters[Key{Code: p.ParentCode}] = parentMeter
|
||
// 创建并更新分摊信息
|
||
pooling := calculate.Pooling{
|
||
Code: p.ParentCode,
|
||
Detail: model.ConsumptionUnit{
|
||
Amount: poolingAmount,
|
||
Fee: fee,
|
||
Price: summary.Overall.Price,
|
||
Proportion: proportion,
|
||
},
|
||
}
|
||
meter.Poolings = append(meter.Poolings, &pooling)
|
||
}
|
||
}
|
||
}
|
||
|
||
case model.POOLING_MODE_CONSUMPTION:
|
||
for _, meter := range meters {
|
||
if meter.Detail.MeterType == model.METER_INSTALLATION_TENEMENT {
|
||
var pooled []struct {
|
||
PooledAmount decimal.Decimal
|
||
ParentAmount decimal.Decimal
|
||
ParentCode string
|
||
}
|
||
for _, relation := range meterRelations {
|
||
if relation.SlaveMeter == meter.Code {
|
||
parentMeter, ok := meters[Key{Code: relation.MasterMeter}]
|
||
if !ok {
|
||
// 处理未找到父级表计的情况
|
||
continue
|
||
}
|
||
// 计算分摊电量和父级电量
|
||
var pooledAmount decimal.Decimal
|
||
if parentMeter.Overall.Amount.IsZero() {
|
||
relations, err := repository.MeterRepository.ListPooledMeterRelations(report.Park, meter.Code)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
//此处rust版本有误，更新后的解决办法
|
||
pooledAmount = meter.Overall.Amount.Div(decimal.NewFromInt(int64(len(relations)))).Mul(parentMeter.Overall.Amount)
|
||
}
|
||
pooled = append(pooled, struct {
|
||
PooledAmount decimal.Decimal
|
||
ParentAmount decimal.Decimal
|
||
ParentCode string
|
||
}{
|
||
PooledAmount: pooledAmount,
|
||
ParentAmount: parentMeter.Overall.Amount,
|
||
ParentCode: parentMeter.Code,
|
||
})
|
||
}
|
||
}
|
||
|
||
// 计算总分摊电量和总父级表记电量
|
||
var consumptions, total decimal.Decimal
|
||
for _, p := range pooled {
|
||
consumptions = consumptions.Add(p.PooledAmount)
|
||
total = total.Add(p.ParentAmount)
|
||
}
|
||
|
||
// 计算并更新公摊分摊信息
|
||
for _, p := range pooled {
|
||
poolingAmount := p.PooledAmount
|
||
proportion := p.PooledAmount.Div(p.ParentAmount)
|
||
fee := poolingAmount.Mul(summary.Overall.Price)
|
||
|
||
// 更新父级表计的公摊分摊信息
|
||
parentMeter := meters[Key{Code: p.ParentCode}]
|
||
parentMeter.PooledPublic.Amount = consumptions
|
||
parentMeter.PooledPublic.Fee = consumptions.Mul(summary.Overall.Price)
|
||
parentMeter.PooledPublic.Proportion = consumptions.Div(total)
|
||
meters[Key{Code: p.ParentCode}] = parentMeter
|
||
|
||
// 创建并更新分摊信息
|
||
pooling := calculate.Pooling{
|
||
Code: p.ParentCode,
|
||
Detail: model.ConsumptionUnit{
|
||
Amount: poolingAmount,
|
||
Fee: fee,
|
||
Price: summary.Overall.Price,
|
||
Proportion: proportion,
|
||
},
|
||
}
|
||
meter.Poolings = append(meter.Poolings, &pooling)
|
||
}
|
||
}
|
||
}
|
||
|
||
default:
|
||
// 处理其他分摊模式
|
||
}
|
||
|
||
return nil
|
||
}
|