public void CreateOrderAgreementFromRequisition_ValidStatus(RequisitionStatus status)
{
var requisition = MockRequisition;
requisition.Status = status;
requisition.ProcessedAt = DateTime.Now;
var agreement = new OrderAgreementModel(requisition, DateTime.UtcNow, MockEntities.MockRequisitionPriceRows);
Assert.Equal(requisition.Request.Order.OrderNumber, agreement.OrderNumber);
}
private static void SerializeModel(OrderAgreementModel model, StreamWriter writer)
{
XmlSerializerNamespaces ns = new XmlSerializerNamespaces();
ns.Add(nameof(Constants.cac), Constants.cac);
ns.Add(nameof(Constants.cbc), Constants.cbc);
XmlSerializer xser = new XmlSerializer(typeof(OrderAgreementModel), Constants.defaultNamespace);
xser.Serialize(writer, model, ns);
}
public async Task <string> CreateOrderAgreementFromRequest(int requestId, StreamWriter writer, int?previousOrderAgreementIndex = null)
{
_logger.LogInformation("Start serializing order agreement from {requestId}.", requestId);
var request = await _tolkDbContext.Requests.GetRequestForAgreement(requestId);
var model = new OrderAgreementModel(request, _clock.SwedenNow, _tolkDbContext.RequestPriceRows.GetPriceRowsForRequest(requestId).ToList());
SerializeModel(model, writer);
_logger.LogInformation("Finished serializing order agreement from {requestId}.", requestId);
return(model.ID.Value);
}
public async Task <IActionResult> View(int id)
{
var orderAgreementPayload = await _dbContext.OrderAgreementPayloads.GetById(id);
if (orderAgreementPayload != null &&
_cacheService.CustomerSettings.Any(c => c.CustomerOrganisationId == orderAgreementPayload.Request.Order.CustomerOrganisationId && c.UsedCustomerSettingTypes.Any(cs => cs == CustomerSettingType.UseOrderAgreements)) &&
(await _authorizationService.AuthorizeAsync(User, orderAgreementPayload, Policies.View)).Succeeded)
{
return(View(OrderAgreementModel.GetModelFromOrderAgreement(orderAgreementPayload)));
}
return(Forbid());
}
public void CreateOrderAgreementFromRequisition_TestIndex(int?previousIndex, int expectedIndex)
{
var requisition = MockRequisition;
var agreement = new OrderAgreementModel(requisition, DateTime.UtcNow, MockEntities.MockRequisitionPriceRows, previousIndex);
Assert.Equal(agreement.Index, expectedIndex);
Assert.Equal($"{Constants.IdPrefix}{requisition.Request.Order.OrderNumber}-{expectedIndex}", agreement.ID.Value);
if (previousIndex.HasValue)
{
Assert.Equal($"{Constants.IdPrefix}{requisition.Request.Order.OrderNumber}-{previousIndex}", agreement.OrderReference.ID.Value);
}
else
{
Assert.Equal(Constants.NotApplicableNotification, agreement.OrderReference.ID.Value);
}
}
private void CreateOrderAgreementFromRequests_Valid(bool useTwoBrookerFees)
{
var pricerows = useTwoBrookerFees ? MockEntities.MockRequestPriceRowsTwoBrokerFees : MockEntities.MockRequestPriceRows;
var request = MockRequest;
var now = DateTime.UtcNow;
var agreement = new OrderAgreementModel(request, now, pricerows);
Assert.Equal(request.Order.OrderNumber, agreement.SalesOrderID);
Assert.Equal($"{Constants.IdPrefix}{request.Order.OrderNumber}-1", agreement.ID.Value);
Assert.Equal(Constants.Currency, agreement.DocumentCurrencyCode);
Assert.Equal(Constants.NotApplicableNotification, agreement.OrderReference.ID.Value);
Assert.Equal(Constants.NotApplicableNotification, agreement.OrderReference.ID.Value);
Assert.Equal(now.ToString("yyyy-MM-dd"), agreement.IssueDate);
Assert.Equal(now.ToString("HH:mm:ss"), agreement.IssueTime);
Assert.Equal(Constants.ContractNumber, agreement.Contract.ID.Value);
Assert.Equal(request.Order.InvoiceReference, agreement.CustomerReference);
Assert.Equal(Constants.Currency, agreement.DocumentCurrencyCode);
Assert.Equal(OrderAgreementModel.OwnerPeppolId.Value, agreement.BuyerCustomerParty.Party.EndpointID.Value);
Assert.Equal(request.Order.CustomerOrganisation.PeppolId, agreement.BuyerCustomerParty.Party.PartyIdentification.ID.Value);
Assert.Equal(OrderAgreementModel.OwnerPeppolId.Value, agreement.SellerSupplierParty.Party.EndpointID.Value);
Assert.Equal(request.Ranking.Broker.OrganizationNumber, agreement.SellerSupplierParty.Party.PartyIdentification.ID.Value);
decimal sum = pricerows.Where(pr => pr.PriceRowType != PriceRowType.RoundedPrice).Sum(pr => pr.TotalPrice);
Assert.Equal(sum, agreement.OrderLines.Sum(ol => ol.LineItem.Price.PriceAmount.AmountSum));
Assert.Equal(sum, agreement.OrderLines.Sum(ol => ol.LineItem.LineExtensionAmount.AmountSum));
Assert.Equal(sum, agreement.LegalMonetaryTotal.LineExtensionAmount.AmountSum);
Assert.Equal(sum, agreement.LegalMonetaryTotal.TaxExclusiveAmount.AmountSum);
//HARDCODED TEST FOR 25% VAT and the rounded amounts
decimal taxAmount = sum * (decimal)0.25;
decimal totalTaxInclusiveAmount = sum * (decimal)1.25;
Assert.Equal(taxAmount, agreement.TaxTotal.TaxAmount.AmountSum);
Assert.Equal(totalTaxInclusiveAmount, agreement.LegalMonetaryTotal.TaxInclusiveAmount.AmountSum);
decimal rounding = GetRounding(totalTaxInclusiveAmount);
decimal roundedSum = totalTaxInclusiveAmount + rounding;
Assert.Equal(rounding, agreement.LegalMonetaryTotal.PayableRoundingAmount.AmountSum);
Assert.Equal(roundedSum, agreement.LegalMonetaryTotal.PayableAmount.AmountSum);
}
public void CreateOrderAgreementFromRequisition_IssuedDates(RequisitionStatus status, string generatedDateTime, string processedDateTime, bool expectsProcessedAt)
{
var requisition = MockRequisition;
requisition.Status = status;
if (expectsProcessedAt)
{
requisition.ProcessedAt = DateTime.Parse(processedDateTime);
}
var agreement = new OrderAgreementModel(requisition, DateTime.Parse(generatedDateTime), MockEntities.MockRequisitionPriceRows);
if (expectsProcessedAt)
{
Assert.Equal(DateTime.Parse(processedDateTime).ToString("yyyy-MM-dd"), agreement.IssueDate);
Assert.Equal(DateTime.Parse(processedDateTime).ToString("HH:mm:ss"), agreement.IssueTime);
}
else
{
Assert.Equal(DateTime.Parse(generatedDateTime).ToString("yyyy-MM-dd"), agreement.IssueDate);
Assert.Equal(DateTime.Parse(generatedDateTime).ToString("HH:mm:ss"), agreement.IssueTime);
}
}
