private async Task <VatPayerType?> GetVatPayerTypeAsync(ChangeOfChargesTransaction chargeMessage)
{
return(string.IsNullOrWhiteSpace(chargeMessage.MktActivityRecord?.ChargeType?.VatPayer)
? throw new ArgumentException($"Fails as {nameof(chargeMessage.MktActivityRecord.ChargeType.VatPayer)} is invalid")
: await _chargesDatabaseContext.VatPayerType.SingleOrDefaultAsync(type =>
type.Name == chargeMessage.MktActivityRecord.ChargeType.VatPayer).ConfigureAwait(false));
}
private static ChangeOfChargesTransaction GetValidChangeOfChargesMessage()
{
var transaction = new ChangeOfChargesTransaction
{
MRid = "chargeMRid",
ChargeTypeMRid = "chargeTypeMRid",
CorrelationId = "correlationId",
LastUpdatedBy = "lastUpdatedBy",
Type = KnownChargeType,
ChargeTypeOwnerMRid = KnownChargeOwner,
MktActivityRecord = new MktActivityRecord
{
ChargeType = new Domain.ChangeOfCharges.Transaction.ChargeType
{
VatPayer = KnownVatPayer, Name = "shortDescription", Description = "longDescription",
},
},
Period = new ChargeTypePeriod
{
Resolution = KnownResolutionType,
Points = { new Point {
Position = 1, PriceAmount = 1m, Time = SystemClock.Instance.GetCurrentInstant(),
} },
},
};
return(transaction);
}
private async Task <MarketParticipant?> GetChargeTypeOwnerMRidAsync(ChangeOfChargesTransaction chargeMessage)
{
return(string.IsNullOrWhiteSpace(chargeMessage.ChargeTypeOwnerMRid)
? throw new ArgumentException($"Fails as {nameof(chargeMessage.ChargeTypeOwnerMRid)} is invalid")
: await _chargesDatabaseContext.MarketParticipant.SingleOrDefaultAsync(type =>
type.MRid == chargeMessage.ChargeTypeOwnerMRid).ConfigureAwait(false));
}
public ChargeTransactionReceived(
string correlationId,
[NotNull] ChangeOfChargesTransaction transaction)
{
CorrelationId = correlationId;
Transaction = transaction;
Filter = transaction.GetType().Name;
}
public async Task <HubRequestValidationResult> ValidateAsync([NotNull] ChangeOfChargesTransaction changeOfChargesTransaction)
{
var result = await _inputValidationRuleEngine.ValidateAsync(changeOfChargesTransaction).ConfigureAwait(false);
var hubRequestValidationResult = new HubRequestValidationResult(changeOfChargesTransaction.ChargeTypeMRid);
foreach (var error in result)
{
hubRequestValidationResult.Add(new ValidationError(error.RuleNumber, error.Message));
}
return(hubRequestValidationResult);
}
public async Task <ChargeStorageStatus> StoreChargeAsync(ChangeOfChargesTransaction transaction)
{
if (transaction == null)
{
throw new ArgumentNullException(nameof(transaction));
}
var chargeType = await GetChargeTypeAsync(transaction).ConfigureAwait(false);
if (chargeType == null)
{
return(ChargeStorageStatus.CreateFailure($"No charge type for {transaction.Type}"));
}
var resolutionType = await GetResolutionTypeAsync(transaction).ConfigureAwait(false);
if (resolutionType == null)
{
return(ChargeStorageStatus.CreateFailure($"No resolution type for {transaction.Period?.Resolution}"));
}
var vatPayerType = await GetVatPayerTypeAsync(transaction).ConfigureAwait(false);
if (vatPayerType == null)
{
return(ChargeStorageStatus.CreateFailure($"No VAT payer type for {transaction.MktActivityRecord?.ChargeType?.VatPayer}"));
}
var chargeTypeOwnerMRid = await GetChargeTypeOwnerMRidAsync(transaction).ConfigureAwait(false);
if (chargeTypeOwnerMRid == null)
{
return(ChargeStorageStatus.CreateFailure($"No market participant for {transaction.ChargeTypeOwnerMRid}"));
}
var charge = ChangeOfChargesMapper.MapChangeOfChargesTransactionToCharge(transaction, chargeType, chargeTypeOwnerMRid, resolutionType, vatPayerType);
await _chargesDatabaseContext.Charge.AddAsync(charge).ConfigureAwait(false);
await _chargesDatabaseContext.SaveChangesAsync().ConfigureAwait(false);
return(ChargeStorageStatus.CreateSuccess());
}
public ChangeOfChargesTransaction Build()
{
var test = new ChangeOfChargesTransaction
{
ChargeTypeMRid = _mrid,
MktActivityRecord = new MktActivityRecord
{
Status = (MktActivityRecordStatus)_status,
ValidityStartDate = _validityStartDate,
ChargeType = new ChargeType
{
VatPayer = _vatPayer,
TaxIndicator = _taxIndicator,
},
},
ChargeTypeOwnerMRid = _owner,
};
return(test);
}
private static ChangeOfChargesTransaction GetCommandFromChangeOfChargeTransaction(ChangeOfChargesTransaction transaction)
{
return(transaction.Type switch
{
"D01" => new FeeCreate
{
Period = transaction.Period,
Type = transaction.Type,
CorrelationId = transaction.CorrelationId,
MarketDocument = transaction.MarketDocument,
RequestDate = transaction.RequestDate,
LastUpdatedBy = transaction.LastUpdatedBy,
MktActivityRecord = transaction.MktActivityRecord,
ChargeTypeMRid = transaction.ChargeTypeMRid,
ChargeTypeOwnerMRid = transaction.ChargeTypeOwnerMRid,
},
_ => new TariffCreate
{
Period = transaction.Period,
Type = transaction.Type,
CorrelationId = transaction.CorrelationId,
MarketDocument = transaction.MarketDocument,
RequestDate = transaction.RequestDate,
LastUpdatedBy = transaction.LastUpdatedBy,
MktActivityRecord = transaction.MktActivityRecord,
ChargeTypeMRid = transaction.ChargeTypeMRid,
ChargeTypeOwnerMRid = transaction.ChargeTypeOwnerMRid,
}
});
public static Charge MapChangeOfChargesTransactionToCharge(
[NotNull] ChangeOfChargesTransaction changeOfChargeTransaction,
ChargeType chargeType,
MarketParticipant chargeTypeOwnerMRid,
ResolutionType resolutionType,
VatPayerType vatPayerType)
{
if (changeOfChargeTransaction == null)
{
throw new ArgumentNullException(nameof(changeOfChargeTransaction));
}
if (string.IsNullOrWhiteSpace(changeOfChargeTransaction.ChargeTypeMRid))
{
throw new ArgumentException($"{nameof(changeOfChargeTransaction.ChargeTypeMRid)} must have value");
}
if (string.IsNullOrWhiteSpace(changeOfChargeTransaction.CorrelationId))
{
throw new ArgumentException($"{nameof(changeOfChargeTransaction.CorrelationId)} must have value");
}
if (string.IsNullOrWhiteSpace(changeOfChargeTransaction.LastUpdatedBy))
{
throw new ArgumentException($"{nameof(changeOfChargeTransaction.LastUpdatedBy)} must have value");
}
if (changeOfChargeTransaction.MktActivityRecord?.ChargeType == null)
{
throw new ArgumentException($"{nameof(changeOfChargeTransaction.MktActivityRecord.ChargeType)} can't be null");
}
if (string.IsNullOrWhiteSpace(changeOfChargeTransaction.MktActivityRecord.ChargeType.Name))
{
throw new ArgumentException($"{nameof(changeOfChargeTransaction.MktActivityRecord.ChargeType.Name)} must have value");
}
if (string.IsNullOrWhiteSpace(changeOfChargeTransaction.MktActivityRecord.ChargeType.Description))
{
throw new ArgumentException($"{nameof(changeOfChargeTransaction.MktActivityRecord.ChargeType.Description)} must have value");
}
if (changeOfChargeTransaction.Period == null)
{
throw new ArgumentException($"{nameof(changeOfChargeTransaction.Period)} can't be null");
}
if (changeOfChargeTransaction.Period.Points == null)
{
throw new ArgumentException($"{nameof(changeOfChargeTransaction.Period.Points)} can't be null");
}
var charge = new Charge
{
ChargeType = chargeType,
ChargeTypeOwner = chargeTypeOwnerMRid,
Description = changeOfChargeTransaction.MktActivityRecord.ChargeType.Description,
LastUpdatedBy = changeOfChargeTransaction.LastUpdatedBy,
LastUpdatedByCorrelationId = changeOfChargeTransaction.CorrelationId,
LastUpdatedByTransactionId = changeOfChargeTransaction.MRid,
Name = changeOfChargeTransaction.MktActivityRecord.ChargeType.Name,
RequestDateTime = changeOfChargeTransaction.RequestDate.ToUnixTimeTicks(),
ResolutionType = resolutionType,
StartDate = changeOfChargeTransaction.MktActivityRecord.ValidityStartDate.ToUnixTimeTicks(),
EndDate = changeOfChargeTransaction.MktActivityRecord.ValidityEndDate?.ToUnixTimeTicks(),
Status = (int)changeOfChargeTransaction.MktActivityRecord.Status,
TaxIndicator = changeOfChargeTransaction.MktActivityRecord.ChargeType.TaxIndicator,
TransparentInvoicing = changeOfChargeTransaction.MktActivityRecord.ChargeType.TransparentInvoicing,
VatPayer = vatPayerType,
MRid = changeOfChargeTransaction.ChargeTypeMRid,
Currency = "DKK",
};
foreach (var point in changeOfChargeTransaction.Period.Points)
{
var newChargePrice = new ChargePrice
{
Time = point.Time.ToUnixTimeTicks(),
Amount = point.PriceAmount,
LastUpdatedByCorrelationId = changeOfChargeTransaction.CorrelationId,
LastUpdatedByTransactionId = changeOfChargeTransaction.MRid,
LastUpdatedBy = changeOfChargeTransaction.LastUpdatedBy,
RequestDateTime = changeOfChargeTransaction.RequestDate.ToUnixTimeTicks(),
};
charge.ChargePrices.Add(newChargePrice);
}
return(charge);
}
private async Task <ResolutionType?> GetResolutionTypeAsync(ChangeOfChargesTransaction chargeMessage)
{
return(string.IsNullOrWhiteSpace(chargeMessage.Period?.Resolution)
? throw new ArgumentException($"Fails as {nameof(chargeMessage.Period.Resolution)} is invalid")
: await _chargesDatabaseContext.ResolutionType.SingleOrDefaultAsync(type => type.Name == chargeMessage.Period.Resolution).ConfigureAwait(false));
}
public async Task HandleAsync([NotNull] ChangeOfChargesTransaction transaction)
{
var localEvent = new ChargeTransactionReceived(transaction.CorrelationId !, transaction);
await _localEventPublisher.PublishAsync(localEvent).ConfigureAwait(false);
}
