/// <summary>
/// Sets shipment state for order items.
/// Use this method when you purchased a BOL shipping label.
/// </summary>
/// <param name="orderItemIds">The order item ids.</param>
/// <param name="shipmentReference">The shipment reference.</param>
/// <param name="labelId">The label identifier.</param>
/// <returns>StatusResponse.</returns>
public async Task <IEnumerable <StatusResponse> > ShipOrderItemsAsync(
IEnumerable <string> orderItemIds,
string shipmentReference,
string labelId)
{
var result = new List <StatusResponse>();
var orderItems = orderItemIds.Select(oi => new ItemId(oi));
foreach (var orderItem in orderItems)
{
var shipmentRequest = new ShipmentRequest()
{
OrderItems = new [] { orderItem },
ShipmentReference = shipmentReference,
ShippingLabelId = labelId
};
result.Add(
await GetApiResult <StatusResponse>(
HttpMethod.Put,
$"{EndPoints.BaseUriApiCalls}{EndPoints.Orders}/shipment",
shipmentRequest
)
);
}
return(result);
}
/// <summary>
/// Funciton to log shipment errors in table Cloud_ShipmentErrors
/// </summary>
/// <param name="shipmentReq">ShipmentRequest object</param>
/// <param name="isError">error or warning</param>
/// <param name="errorDetail">error details</param>
/// <param name="errorMessage">error message</param>
/// <param name="session">session object</param>
public static void UpdateShipmentErrors(ShipmentRequest shipmentReq, Boolean isError, String errorDetail, String errorMessage, ISession session, String companyID, String VersionNo = "")
{
try
{
string ComponentsXML = string.Empty;
using (StringWriter sw = new StringWriter())
{
XmlSerializer xs = new XmlSerializer(typeof(List <ShipmentRequestComponents>));
xs.Serialize(sw, shipmentReq.Components);
ComponentsXML = sw.ToString().Replace("utf-16", "utf-8");
}
SqlCommand cmd = (SqlCommand)session.CreateCommand();
cmd.CommandText = "Cloud_UpdateShipmentErrors";
cmd.CommandType = CommandType.StoredProcedure;
cmd.Parameters.AddWithValue("@SysTrxNo", shipmentReq.SysTrxNo);
cmd.Parameters.AddWithValue("@SysLineNo", shipmentReq.SysTrxLine);
cmd.Parameters.AddWithValue("@ComponentsXML", ComponentsXML);
cmd.Parameters.AddWithValue("@UserID", shipmentReq.UserID);
cmd.Parameters.AddWithValue("@ErrorOrWarning", isError);
cmd.Parameters.AddWithValue("@ErrorDetails", errorDetail);
cmd.Parameters.AddWithValue("@ErrorMessage", errorMessage);
cmd.ExecuteNonQuery();
UpdateOrderStatus(session, shipmentReq.SysTrxNo, ApplicationConstants.ErrorStatusCode.Error_In_Shipment, companyID);
}
catch (Exception ex)
{
Logging.LogError(ex);
}
}
/// <summary>
/// Reads a single request from the file opened if one is still available
/// </summary>
public ShipmentRequest GetNextRequest()
{
if (reader.EndOfStream)
{
return(new ShipmentRequest
{
IsLast = true,
IsValid = false
});
}
var line = reader.ReadLine();
var parts = (line ?? string.Empty).Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
var result = new ShipmentRequest
{
IsValid = true,
Source = line,
IsLast = reader.EndOfStream
};
if (!ParseDate(parts[0], ref result) || !ParsePackageSize(parts[1], ref result) || !ParseProviderName(parts[2], ref result))
{
result.IsValid = false;
}
return(result);
}
public void Router_TryGetShipmentPrice_AccumulatedDiscount_DoesntExceedLimit()
{
// arrange
var router = new Router();
router.RegisterProvider(provider1);
var successCount = new Dictionary <bool, int>
{
{ true, 0 },
{ false, 0 }
};
ShipmentPrice lastPrice;
var request = new ShipmentRequest
{
IsValid = true,
ProviderName = "P1",
PackageSize = PackageSize.M,
Date = DateTime.Today
};
// act
successCount[router.TryGetShipmentPrice(request, out lastPrice)]++;
successCount[router.TryGetShipmentPrice(request, out lastPrice)]++;
successCount[router.TryGetShipmentPrice(request, out lastPrice)]++;
successCount[router.TryGetShipmentPrice(request, out lastPrice)]++;
// assert
successCount[true].Should().Be(4);
successCount[false].Should().Be(0);
lastPrice.Price.Should().Be(5);
lastPrice.Discount.Should().Be(1);
}
/// <summary>
/// Calculates the price for the given shipment <paramref name="request"/>
/// </summary>
/// <param name="request">Request to calculate the price for</param>
public virtual ShipmentPrice GetShipmentPrice(ShipmentRequest request)
{
if (!request.IsValid || !request.ProviderName.Equals(ProviderName, StringComparison.OrdinalIgnoreCase) || !SupportedPackageSizes.Contains(request.PackageSize))
{
throw new NotSupportedException($"This provider ({ProviderName}) doesn't support processing {request.ProviderName} provider and/or {request.PackageSize} package size.");
}
if (request.PackageSize == PackageSize.S)
{
var originalPrice = PriceTable[request.PackageSize];
var lowestPrice = Router.GetLowestPriceForPackageSize(request.PackageSize).Item1;
if (lowestPrice > 0)
{
return(new ShipmentPrice
{
Price = lowestPrice,
Discount = originalPrice - lowestPrice
});
}
}
return(new ShipmentPrice
{
Discount = 0,
Price = PriceTable[request.PackageSize]
});
}
/// <summary>
/// Sets shipment state for order items.
/// Use this method when you use your own transporter.
/// </summary>
/// <param name="orderItemIds">The order item ids.</param>
/// <param name="transporterCode">The transporter code.</param>
/// <param name="trackingCode">The tracking code.</param>
/// <returns>StatusResponse.</returns>
public async Task <IEnumerable <StatusResponse> > ShipOrderItemsAsync(
IEnumerable <string> orderItemIds,
TransporterCode transporterCode,
string trackingCode)
{
var result = new List <StatusResponse>();
var orderItems = orderItemIds.Select(oi => new ItemId(oi));
foreach (var orderItem in orderItems)
{
var shipmentRequest = new ShipmentRequest()
{
OrderItems = new[] { orderItem },
Transport = new TransportInstruction()
{
TransporterCode = transporterCode.TransporterCodeValue,
TrackAndTrace = trackingCode
}
};
result.Add(
await GetApiResult <StatusResponse>(
HttpMethod.Put,
$"{EndPoints.BaseUriApiCalls}{EndPoints.Orders}/shipment",
shipmentRequest
)
);
}
return(result);
}
public async Task <IReadOnlyList <Shipment> > GetAllAsync(
int saleId,
ShipmentRequest request,
CancellationToken cancellationToken)
{
var shipmentsLink = await _linkFactory.CreateLinkAsync($"sales/{saleId}/shipments").ConfigureAwait(_halClient);
return(await _halClient.GetAllPagesAsync <Shipment>(shipmentsLink, request, cancellationToken).ConfigureAwait(_halClient));
}
/// <summary>
///
/// </summary>
/// <param name="request"></param>
/// <param name="context"></param>
/// <returns></returns>
public override Task <ShipmentResponse> ProcessShipment(ShipmentRequest request, ServerCallContext context)
{
_logger.Information($"Shipment with PaymentId {request.PaymentId} processed.");
return(Task.FromResult(new ShipmentResponse
{
ShipmentId = Guid.NewGuid().ToString()
}));
}
public void CarrierBatch_Success()
{
var shipments = new List <ShipmentRequest>();
foreach (var transactionNumber in Enumerable.Range(1, 100))
{
var shipment = new ShipmentRequest
{
Sequence = 1,
ShipToAddress1 = "123 SAMPLE STREET",
ShipToCountry = "US",
ShipToName = "JOHN SMITH",
ServiceCode = "GRD",
TransactionNumber = $"TEST {Guid.NewGuid()} {transactionNumber}",
ShipToPostal = "46774",
ShipToCity = "NEW HAVEN",
ShipToStateProvince = "IN",
ShipToPhone = "11111111111",
Packages = new Package[]
{
new Package {
Weight = 2,
BoxHeight = 1,
BoxLength = 12,
BoxWidth = 9,
Items = new Item[]
{
new Item {
Sku = "TST",
LotNumber = "LT1",
SerialNumber = "",
Description = "TEST",
Description2 = "",
Quantity = 1,
UnitPrice = 1,
ExpirationDate = "2099-07-19T17:12:02.731Z",
Uom = "Each",
Supplier = "",
CountryOfOrigin = "US"
}
}
}
},
ClientCode = "Test",
Terms = "SHIPPER"
};
shipments.Add(shipment);
}
var result = new Shipments(_apiKey, _secretKey).CarrierBatch(
duplicateHandling: DuplicateHandling.Overwrite,
shipments: shipments.ToArray()
);
Assert.IsNotNull(result);
}
public ShipmentNote(ShipmentRequest request)
{
var now = DateTime.Now;
this.Request = request;
this.ConfirmationNumber = $"XX-{now.Ticks}";
this.Created = now;
this.IsDelivered = false;
}
public ShipmentResponse CallUPSShipmentRequest(string serviceCode, int ShipmentID)
{
//var dbShipment = ShipmentModule.GetShipmentByID(ShipmentID);
var shipmentDetails = ShipmentModule.GetShipmentShipmentDetails(ShipmentID);
var shpSvc = new ShipService();
var shipmentRequest = new ShipmentRequest();
AddUpsSecurity(shpSvc);
var request = new RequestType();
String[] requestOption = { "1" }; //{ "nonvalidate" };
request.RequestOption = requestOption;
shipmentRequest.Request = request;
var shipment = new ShipmentType();
shipment.Description = "Ship webservice example";
AddShipper(shipment);
AddShipFromAddress(shipment);
AddShipToAddress(shipment);
AddBillShipperAccount(shipment);
//AddPaymentInformation(shipment);
var service = new ServiceType();
service.Code = serviceCode;
shipment.Service = service;
PackageType[] pkgArray;
pkgArray = new PackageType[shipmentDetails.Count];
var i = 0;
foreach (var box in shipmentDetails)
{
AddPackage(box.UnitWeight.Value, Convert.ToInt32(box.UnitPrice), box.DimensionH.Value, box.DimensionD.Value, box.DimensionL.Value, PackagingTypeCode, "USD", pkgArray, i);
i = i + 1;
}
shipment.Package = pkgArray;
var labelSpec = new LabelSpecificationType();
var labelStockSize = new LabelStockSizeType();
labelStockSize.Height = "3";
labelStockSize.Width = "2";
labelSpec.LabelStockSize = labelStockSize;
var labelImageFormat = new LabelImageFormatType();
labelImageFormat.Code = "GIF";//"SPL";
labelSpec.LabelImageFormat = labelImageFormat;
shipmentRequest.LabelSpecification = labelSpec;
shipmentRequest.Shipment = shipment;
var shipmentResponse = shpSvc.ProcessShipment(shipmentRequest);
return(shipmentResponse);
}
private static bool ParsePackageSize(string input, ref ShipmentRequest request)
{
if (input.Length != 1)
{
return(false);
}
request.PackageSize = input[0];
return(true);
}
private static bool ParseDate(string input, ref ShipmentRequest request)
{
if (!DateTime.TryParseExact(input, "yyyy-MM-dd", CultureInfo.InvariantCulture, DateTimeStyles.AssumeLocal, out DateTime date))
{
return(false);
}
request.Date = date;
return(true);
}
private static bool ParseProviderName(string input, ref ShipmentRequest request)
{
if (string.IsNullOrWhiteSpace(input))
{
return(false);
}
request.ProviderName = input;
return(true);
}
public async Task CanCreateShipmentWithOnlyRequiredFields()
{
// the order needs to be autorized to do a shipment on. this can only be done by waiting.
string validOrderId = "XXXXX";
ShipmentRequest shipmentRequest = this.CreateShipmentWithOnlyRequiredFields();
ShipmentResponse result = await this._shipmentClient.CreateShipmentAsync(validOrderId, shipmentRequest);
// Then: Make sure we get a valid shipment response
Assert.IsNotNull(result);
Assert.IsTrue(result.CreatedAt >= DateTime.Now);
}
public async Task <Shipment> CreateAsync(int saleId, ShipmentRequest request, CancellationToken cancellationToken)
{
var createShipmentLink = await _linkFactory.CreateLinkAsync($"sales/{saleId}/shipments").ConfigureAwait(_halClient);
var shipment = await _halClient.PutAsync <Shipment>(createShipmentLink, null, request, cancellationToken)
.ConfigureAwait(_halClient);
// Work-around an issue in the API where the first request's shipment
// isn't populated with links and embedded addresses
return(await _halClient.PutAsync <Shipment>(createShipmentLink, null, request, cancellationToken)
.ConfigureAwait(_halClient));
}
public async Task <IActionResult> Create(Order order)
{
bool isValidOrder = true;
foreach (var orderItem in order.OrderItems)
{
using (HttpClient client = new HttpClient())
{
var stockRequest = new StockRequest {
ItemId = orderItem.ItemId
};
var content = new StringContent(JsonConvert.SerializeObject(stockRequest), Encoding.UTF8, "application/json");
var response = client.PostAsync(_configuration["StockService"], content).Result;
var stockResponse = JsonConvert.DeserializeObject <StockResponse>(await response.Content.ReadAsStringAsync());
if (orderItem.Qty > stockResponse.Stock)
{
isValidOrder = false;
break;
}
}
}
if (isValidOrder)
{
//Send shipment
using (HttpClient client = new HttpClient())
{
var shipmentRequest = new ShipmentRequest
{
CustomerEmail = order.Customer.Email,
CustomerName = order.Customer.Name,
OrderId = order.OrderNr,
ShipmentItems = order.OrderItems.Select(o => new ShipmentItem {
ItemId = o.ItemId, Qty = o.Qty
}).ToList()
};
var content = new StringContent(JsonConvert.SerializeObject(shipmentRequest), Encoding.UTF8, "application/json");
var result = await client.PostAsync(_configuration["ShipmentService"], content);
}
return(Ok());
}
else
{
return(BadRequest("No stock available"));
}
}
public void CarrierShipment_BadRequest()
{
var shipment = new ShipmentRequest
{
Sequence = 1,
ShipToAddress1 = "123 SAMPLE STREET",
ShipToCountry = "US",
ShipToName = "JOHN SMITH",
CarrierCode = "UPSN",
ServiceCode = "STD",
TransactionNumber = "987654321012345678909876543210123456789098765432101234567890987654321012345678909876543210123456789098765432101234567890987654321012345678909876543210123456789098765432101234567890987654321012345678909876543210123456789098765432101234567890987654321012345",
ShipToPostal = "46774",
ShipToCity = "NEW HAVEN",
ShipToStateProvince = "IN",
ShipToPhone = "11111111111",
Packages = new Package[]
{
new Package {
Weight = 2,
BoxHeight = 1,
BoxLength = 12,
BoxWidth = 9,
Items = new Item[]
{
new Item {
Sku = "TST",
LotNumber = "LT1",
SerialNumber = "",
Description = "TEST",
Description2 = "",
Quantity = 1,
UnitPrice = 1,
ExpirationDate = "2099-07-19T17:12:02.731Z",
Uom = "Each",
Supplier = "",
CountryOfOrigin = "US"
}
}
}
},
ClientCode = "Test",
Terms = "SHIPPER"
};
Assert.ThrowsExceptionAsync <ApplicationException>(
async() => await new Shipments(_apiKey, _secretKey).Carrier(
duplicateHandling: DuplicateHandling.Overwrite,
shipment: shipment
)
);
}
public ShipmentRequestTransactionBuilder Begin(long shipmentRequestId, DateTime utcNow)
{
m_shipmentRequest = m_ctx.ShipmentRequests.Where(r => r.ShipmentRequestId == shipmentRequestId).Single();
m_utcNow = utcNow;
m_shipmentRequestTransaction = new ShipmentRequestTransaction()
{
ShipmentRequest = m_shipmentRequest,
TransactionDateTimeUtc = m_utcNow
};
_ = m_ctx.ShipmentRequestTransactions.Add(m_shipmentRequestTransaction);
return(this);
}
public async Task RateShopShipment_Success()
{
var shipment = new ShipmentRequest
{
Sequence = 1,
ShipToAddress1 = "123 SAMPLE STREET",
ShipToCountry = "US",
ShipToName = "JOHN SMITH",
ServiceCode = "GRD",
TransactionNumber = "TEST123456788",
ShipToPostal = "46774",
ShipToCity = "NEW HAVEN",
ShipToStateProvince = "IN",
ShipToPhone = "11111111111",
Packages = new Package[]
{
new Package {
Weight = 2,
BoxHeight = 1,
BoxLength = 12,
BoxWidth = 9,
Items = new Item[]
{
new Item {
Sku = "TST",
LotNumber = "LT1",
SerialNumber = "",
Description = "TEST",
Description2 = "",
Quantity = 1,
UnitPrice = 1,
ExpirationDate = "2099-07-19T17:12:02.731Z",
Uom = "Each",
Supplier = "",
CountryOfOrigin = "US"
}
}
}
},
ClientCode = "Test",
Terms = "SHIPPER"
};
var result = await new Shipments(_apiKey, _secretKey).RateShop(
duplicateHandling: DuplicateHandling.Overwrite,
shipment: shipment
);
Assert.IsNotNull(result.ShipmentId);
}
public IHttpActionResult OrdedrShipment(ShipmentRequest shipmentRequest)
{
if (!shipmentRequestValidator.IsValid(shipmentRequest))
{
return(BadRequest());
}
var shipmentNote = shipmentDispatcher.Add(shipmentRequest);
string routeName = "RouteGetShipment";
object routeValues = new { confirmationNumber = shipmentNote.ConfirmationNumber };
var content = Map(shipmentNote);
return(CreatedAtRoute(routeName, routeValues, content));
}
/// <summary>
/// UpdateShipment
/// Function to update the shipment details
/// </summary>
/// <param name="companyID">Company ID</param>
/// <param name="password">Password</param>
/// <param name="shipmentReq">ShipmentRequest object</param>
/// <returns>ShipmentResponse object</returns>
/// <param name="VersionNo">VersionNo</param>
public ShipmentResponse UpdateShipment(string companyID, string password, ShipmentRequest shipmentReq, String VersionNo = "")
{
ShipmentResponse shipmentResponse = null;
ISession session = null;
try
{
ValidateCustomerLogin(companyID, password, VersionNo);
session = GetSession();
session.BeginTransaction();
shipmentResponse = DALMethods.UpdateShipment(session, shipmentReq, VersionNo);
DALMethods.ClearShipmentErrors(shipmentReq.SysTrxNo, shipmentReq.SysTrxLine, session, VersionNo);
session.CommitTransaction();
CloseSession(session);
}
catch (ApplicationException ex)
{
if (session != null)
{
session.RollbackTransaction();
CloseSession(session);
session = GetSession();
}
//Logging.WriteToFile1("Dinesh 3- ");
//Logging.WriteToFile1("Dinesh 4- ");
DALMethods.UpdateShipmentErrors(shipmentReq, true, ex.StackTrace, ex.Message, session, VersionNo);
throw ex;
}
catch (Exception ex)
{
if (session != null)
{
session.RollbackTransaction();
CloseSession(session);
}
//session = GetSession();
//DALMethods.UpdateShipmentErrors(shipmentReq, true, ex.StackTrace, ex.Message, session, VersionNo);
Logging.LogError(ex);
//Logging.WriteToFile1("Dinesh 4- ");
//shipmentResponse = new ShipmentResponse();
//shipmentResponse.ErrorMessage = ex.Message + " - " + ex.StackTrace;
//Logging.WriteToFile1("Dinesh 5- ");
//return shipmentResponse;
throw ex;
}
return(shipmentResponse);
}
public async Task <IHttpActionResult> AddShipmentStatus(string containerId, [FromBody] ShipmentRequest request)
{
try
{
return(Ok(await Task.Run(async() =>
{
var result = await Constants.UnlockAccount();
var ShipmentStatus = Constants.shipmentContract.GetFunction("ShipmentStatus");
await Constants.web3.Miner.Start.SendRequestAsync();
var transactionhash = await ShipmentStatus.SendTransactionAsync(Constants.senderAddress, new Nethereum.Hex.HexTypes.HexBigInteger("0x3d0900"), null, request.Id, Convert.ToInt32(request.Weight), DateTime.Now.ToString(), request.Desc, request.Status, Constants.trackingaddress, request.ContainerName, request.Source, request.Destination);
var receipt = await Constants.MineAndGetReceiptAsync(Constants.web3, transactionhash);
return receipt;
})));
}
catch (Exception ex)
{
return(InternalServerError(ex));
}
}
public async Task CreateShipmentRequestAsync(IEnumerable <int> requestIdList, int shipmentId)
{
int i = 1;
foreach (int requestId in requestIdList)
{
var entity = new ShipmentRequest();
entity.RequestId = requestId;
entity.ShipmentId = shipmentId;
entity.RequestOrder = i++;
entity.Note = "";
entity.Status = ShipmentRequestStatus.WAITING;
_uow.GetRepository <IShipmentRequestRepository>().Create(entity);
}
await _uow.SaveChangesAsync();
}
public ShipmentRequestTransactionBuilder Begin(ShipmentRequest dbShipmentRequest, string description, DateTime utcNow)
{
if (string.IsNullOrEmpty(description))
{
throw new ArgumentNullException(nameof(description));
}
m_shipmentRequest = dbShipmentRequest;
m_utcNow = utcNow;
m_shipmentRequestTransaction = new ShipmentRequestTransaction()
{
ShipmentRequest = m_shipmentRequest,
TransactionDateTimeUtc = m_utcNow,
Description = description
};
_ = m_ctx.ShipmentRequestTransactions.Add(m_shipmentRequestTransaction);
return(this);
}
public void Router_TryGetShipmentPrice_AccumulatedDiscount_DoesntAffectDifferentMonth()
{
// arrange
var router = new Router();
router.RegisterProvider(provider1);
var successCount = new Dictionary <bool, int>
{
{ true, 0 },
{ false, 0 }
};
ShipmentPrice lastPrice1;
ShipmentPrice lastPrice2;
var request = new ShipmentRequest
{
IsValid = true,
ProviderName = "P1",
PackageSize = PackageSize.M,
Date = DateTime.Today
};
// act
successCount[router.TryGetShipmentPrice(request, out lastPrice1)]++;
successCount[router.TryGetShipmentPrice(request, out lastPrice1)]++;
successCount[router.TryGetShipmentPrice(request, out lastPrice1)]++;
successCount[router.TryGetShipmentPrice(request, out lastPrice1)]++;
successCount[router.TryGetShipmentPrice(request, out lastPrice1)]++;
request.Date = request.Date.AddMonths(1);
successCount[router.TryGetShipmentPrice(request, out lastPrice2)]++;
// assert
successCount[true].Should().Be(6);
successCount[false].Should().Be(0);
lastPrice1.Price.Should().Be(6);
lastPrice1.Discount.Should().Be(0);
lastPrice2.Price.Should().Be(3);
lastPrice2.Discount.Should().Be(3);
}
public async Task <ShipmentResponse> PostShipment(ShipmentRequest shipment)
{
var currentTime = GetCurrentTime();
var hash = CreateHash(_loginId + currentTime + shipment.SenderPostalcode + shipment.RecipientPostalcode, _apiKey);
shipment.LoginId = _loginId;
shipment.Date = currentTime;
shipment.HmacSha256 = hash;
var content = new StringContent(JsonHelper.Serialize(shipment));
var response = await _httpClient.PostAsync("zending.php", content).ConfigureAwait(false);
var jsonResult = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
if (response.IsSuccessStatusCode)
{
return(JsonHelper.Deserialize <ShipmentResponse>(jsonResult));
}
var error = JsonHelper.Deserialize <Error>(jsonResult);
throw new Exception(error.Message);
}
/// <summary>
/// Calculates the price for the given shipment <paramref name="request"/>
/// </summary>
/// <param name="request">Request to calculate the price for</param>
public override ShipmentPrice GetShipmentPrice(ShipmentRequest request)
{
if (request.PackageSize == PackageSize.L)
{
var dateHash = GetDateHash(request.Date);
if (!largePackagesPerMonth.ContainsKey(dateHash))
{
largePackagesPerMonth.Add(dateHash, 0);
}
if (++largePackagesPerMonth[dateHash] == 3)
{
var price = base.GetShipmentPrice(request);
price.Discount = price.Price;
price.Price = 0;
return(price);
}
}
return(base.GetShipmentPrice(request));
}
//Add seed data of Shipment_Request
private static void SeedShipmentRequestData(ApplicationDbContext dbContext)
{
Random ran = new Random();
DateTime RequestEstimateDate = FormatDateTime(DateTime.Now);
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
var shipmentRequest = new ShipmentRequest
{
ShipmentId = i + 1,
RequestId = (i * 5) + j + 1,
RequestOrder = j + 1,
Note = "",
Status = "Waiting",
RequestEstimateDate = RequestEstimateDate.AddDays(ran.Next(0, i % 2 + 1)),
RequestDeliveriedDate = RequestEstimateDate.AddDays(ran.Next(2, i % 7 + 3))
};
dbContext.Add(shipmentRequest);
dbContext.SaveChanges();
}
}
}
public void address_elements_that_have_leading_and_trailing_white_space_should_be_trimed(string testZip, string expectedZip)
{
var example = new ShipmentRequest();
example.ShipTo = new Address()
{
Address1 = "",
Address2 = "",
Email = "*****@*****.**",
Name = "Someone being tested",
Phone = "",
Postcode = testZip,
State = "",
Town = "",
IsoCountry = "DE"
};
example.Shipper = new Shipper();
example.Packages = new System.Collections.Generic.List <Package>();
example.Packages.Add(new Package());
example.Carrier = new Carrier()
{
Extra = "{\"product\":\"V01PAK\", \"accounatNumber\":\"22222222220101\"}"
};
var mapper = new ShipmentOrderMapper();
var mappedOrder = mapper.Map(example, new ConsoleLogger(), "poop", null);
var address = mappedOrder.Shipment.Receiver.Item as ReceiverNativeAddressType;
address.zip.Should().Be(expectedZip);
}
