public async Task <CreateShipmentResponseModel> Handle(CreateShipmentCommand request, CancellationToken cancellationToken)
{
var shipment = _mapping.Map <CreateShipmentRequestModel, Infrastructure.Entities.Shipment>(request.CreateShipmentRequest);
var response = await _dbContext.AddAsync(shipment);
await _dbContext.SaveChangesAsync();
return(_mapping.Map <Infrastructure.Entities.Shipment, CreateShipmentResponseModel>(response.Entity));
}
public ActionResult Index(UserLoginModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
// begin session
var userSession = _mapper.Map <UserSessionModel>(model);
_userSession.EnstablishSession(userSession);
return(Redirect(_redirectUrlProvider.RedirectUrl));
}
public PipelineExecutionResult Execute(IPipelineArgs <AddAddressRequest, AddAddressResult> subject)
{
if (subject.Request.Properties.ContainsKey("FromUCommerce"))
{
if (!(bool)subject.Request.Properties["FromUCommerce"])
{
return(PipelineExecutionResult.Success);
}
}
var cartServiceProvider = new CartServiceProvider();
var cart = _mappingLibraryInternal.MapPurchaseOrderToCart(subject.Request.PurchaseOrder);
var party = _orderAddressMapper.Map(subject.Response.OrderAddress);
var partyList = new List <Party> {
party
};
if (subject.Request.ExistingOrderAddress == null)
{
var addPartiesRequest = new AddPartiesRequest(cart, partyList);
addPartiesRequest.Properties["FromUCommerce"] = true;
var addPartiesResult = cartServiceProvider.AddParties(addPartiesRequest);
return(PipelineExecutionResult.Success);
}
var updatePartiesRequest = new UpdatePartiesRequest(cart, partyList);
updatePartiesRequest.Properties["FromUCommerce"] = true;
var updatePartiesResult = cartServiceProvider.UpdateParties(updatePartiesRequest);
return(PipelineExecutionResult.Success);
}
public async Task <ListLogEntriesServiceResponse> Handle(ListLogEntriesServiceRequest request)
{
var items = _context.LogEntries.AsQueryable();
if (request.From.HasValue)
{
items = items.Where(item => item.CreatedAt >= request.From);
}
if (request.To.HasValue)
{
items = items.Where(item => item.CreatedAt <= request.To);
}
if (request.Level != null)
{
items = items.Where(item => item.Level == request.Level);
}
if (!string.IsNullOrEmpty(request.Content))
{
items = items.Where(item =>
item.Text.IndexOf(request.Content) >= 0 ||
item.Title.IndexOf(request.Content) >= 0);
}
var result = await items.ToListAsync();
var projection = _mapper.Map <List <ListLogEntriesServiceResponse.Item> >(result);
return(new ListLogEntriesServiceResponse
{
Items = projection
});
}
internal override void FillDestination(object source, object destination)
{
var sourceValue = sourceInfo.GetValue(source);
var mappedSourceValue = mapping.Map(sourceValue);
destinationInfo.SetValue(destination, mappedSourceValue);
}
public override void Process(ServicePipelineArgs args)
{
RemovePaymentInfoRequest request;
RemovePaymentInfoResult result;
using (new DisposableThreadLifestyleScope())
{
CheckParametersAndSetupRequestAndResult(args, out request, out result);
Assert.ArgumentNotNull(request.Payments, "request.Payments");
Assert.ArgumentNotNull(request.Cart, "request.Cart");
var purchaseOrder = _basketService.GetBasketByCartExternalId(request.Cart.ExternalId).PurchaseOrder;
foreach (var paymentInfo in request.Payments)
{
RemovePayment(purchaseOrder, paymentInfo);
}
PipelineFactory.Create <PurchaseOrder>("Basket").Execute(purchaseOrder);
var paymentInfos = _paymentMapper.Map(purchaseOrder.Payments);
result.Payments = new ReadOnlyCollection <PaymentInfo>(paymentInfos);
result.Cart = _purchaseOrderMapper.Map(purchaseOrder);
}
}
public void MapValues(Payment source, PaymentInfoWithAmount target)
{
target.ExternalId = source.Id.ToString();
target.LineIDs = new ReadOnlyCollection <string>(source.PurchaseOrder.OrderLines.Select(x => x.OrderLineId.ToString()).ToList());
target.PaymentMethodID = source.PaymentMethod.PaymentMethodId.ToString();
target.PartyID = _orderAddressToParty.Map(source.PurchaseOrder.BillingAddress).PartyId;
target.Amount = source.Amount;
}
public void OnHandleChatHeadNotification(NotificationEventArgs args)
{
args.Handled = true;
var item = _mapping.Map <Notification, ChatHeadItemViewModel>(args.Notification);
Add(item);
}
public void MapValues(PurchaseOrder purchaseOrder, Cart cart)
{
cart.Adjustments = new ReadOnlyCollection <CartAdjustment>(_purchaseOrderToAdjustments.Map(purchaseOrder));
cart.Total = _purchaseOrderToTotal.Map(purchaseOrder);
cart.Lines = new ReadOnlyCollection <CartLine>(_orderLinesToCartLines.Map(purchaseOrder.OrderLines));
cart.Parties = new ReadOnlyCollection <Party>(_orderAddressesToParties.Map(purchaseOrder.OrderAddresses));
cart.Shipping = new ReadOnlyCollection <ShippingInfo>(_shipmentsToShipping.Map(purchaseOrder.Shipments));
cart.Payment = new ReadOnlyCollection <PaymentInfo>(_paymentsToPayment.Map(purchaseOrder.Payments));
}
public void MapValues(OrderLine source, CartLine target)
{
target.ExternalCartLineId = source.OrderLineId.ToString();
target.Adjustments = new ReadOnlyCollection <CartAdjustment>(_orderLineToAdjustments.Map(source));
target.Product = _orderLineToProduct.Map(source);
target.Quantity = Convert.ToUInt32(source.Quantity);
target.Total = _orderLineToTotal.Map(source);
//SubLines =
}
public void MapValues(OrderLine source, Total target)
{
target.Amount = source.Total.GetValueOrDefault();
if (source.PurchaseOrder.BillingCurrency != null)
{
target.CurrencyCode = source.PurchaseOrder.BillingCurrency.ISOCode;
}
target.TaxTotal = _orderLineToTaxTotal.Map(source);
}
public T Read(QueryResult queryResult)
{
var graph = TypeInstanceFactory.CreateInstance <T>();
var outputWriter = TypeReaderWriterFactory.CreateGraphWriter <T>(graph);
var inputReader = new QueryGraphReader(queryResult);
_mapping.Map(inputReader, outputWriter);
return(graph);
}
public void MapValues(PurchaseOrder source, Total target)
{
target.Amount = source.OrderTotal.GetValueOrDefault();
if (source.BillingCurrency != null)
{
target.CurrencyCode = source.BillingCurrency.ISOCode;
}
target.TaxTotal = _purchaseOrderToTaxTotal.Map(source);
//target.Description =
}
public async Task <CreateOrderResponseModel> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
var order = _mapping.Map <CreateOrderRequestModel, Infrastructure.Entities.Order>(request.CreateOrderRequest);
order.OrderStatus = (int)OrderStatus.Pending;
var response = await _dbContext.AddAsync(order);
if (await _dbContext.SaveChangesAsync() > 0)
{
await _bus.PubSub.PublishAsync(new UpdateStockEvent
{
CorrelationId = Guid.NewGuid(),
ProductId = order.ProductId,
Quantity = order.Quantity,
OrderId = order.Id
});
}
return(_mapping.Map <Infrastructure.Entities.Order, CreateOrderResponseModel>(response.Entity));
}
public override void Process(ServicePipelineArgs args)
{
AddShippingInfoRequest request;
AddShippingInfoResult result;
using (new DisposableThreadLifestyleScope())
{
CheckParametersAndSetupRequestAndResult(args, out request, out result);
Assert.ArgumentNotNull(request.ShippingInfo, "request.ShippingInfo");
Assert.ArgumentNotNull(request.Cart, "request.Cart");
Assert.ArgumentCondition(request.ShippingInfo.Count != 0, "request.ShippingInfo",
"request.ShippingInfo cannot be empty");
Assert.ArgumentCondition(request.ShippingInfo.Count == 1, "request.ShippingInfo",
"request.ShippingInfo cannot contain more than 1 ShippingInfo");
var shipments = new List <Shipment>();
var purchaseOrder = _basketService.GetBasketByCartExternalId(request.Cart.ExternalId).PurchaseOrder;
if (!IsFromUcommerce(request))
{
var createShipmentPipeline = PipelineFactory.Create <IPipelineArgs <CreateShipmentRequest, CreateShipmentResult> >("CreateShipment");
var createShipmentPipelineArgs = new CreateShipmentPipelineArgs(new CreateShipmentRequest()
{
ShippingMethod = GetShippingMethod(request.ShippingInfo.First()),
OverwriteExisting = false,
PurchaseOrder = purchaseOrder,
ShippingAddress = GetOrderAddress(GetPartyFromCart(request.ShippingInfo.First(), request.Cart))
}, new CreateShipmentResult());
createShipmentPipelineArgs.Request.Properties["FromUCommerce"] = false;
createShipmentPipeline.Execute(createShipmentPipelineArgs);
shipments.Add(createShipmentPipelineArgs.Response.Shipment);
PipelineFactory.Create <PurchaseOrder>("Basket").Execute(purchaseOrder);
}
else
{
shipments.Add(purchaseOrder.Shipments.Last());
}
var shippingInfos = _shipmentMapper.Map(shipments);
result.ShippingInfo = new ReadOnlyCollection <ShippingInfo>(shippingInfos);
result.Cart = _purchaseOrderMapper.Map(purchaseOrder);
}
}
public async Task <CreateOrderResponseModel> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
var order = _mapping.Map <CreateOrderRequestModel, Infrastructure.Entities.Order>(request.CreateOrderRequest);
order.OrderStatus = (int)OrderStatus.Pending;
var response = await _dbContext.AddAsync(order);
if (await _dbContext.SaveChangesAsync() > 0)
{
await _sendEndpoint.Send(new OrderSagaEventModel
{
OrderId = order.Id,
Quantity = request.CreateOrderRequest.Quantity,
ProductId = request.CreateOrderRequest.ProductId
});
}
else
{
throw new Exception("Create Order Failed!");
}
return(_mapping.Map <Infrastructure.Entities.Order, CreateOrderResponseModel>(response.Entity));
}
public List <KellerDevice> GetRegisteredDevices(Gateway gateway)
{
var uriBuilder = new UriBuilder("", gateway.GatewayIp, gateway.GatewayPort, ApiUrl);
var channel = new Channel(uriBuilder.ToString(), ChannelCredentials.Insecure);
var client = new Kiwi.Api.DeviceService.DeviceServiceClient(channel);
var reply = client.List(new ListDeviceRequest());
channel.ShutdownAsync().Wait();
return(_mapper.Map(reply));
}
public async Task <IncreaseStockResponseModel> Handle(IncreaseStockCommand request, CancellationToken cancellationToken)
{
var stock = await _dbContext.Stocks.FirstOrDefaultAsync(x => x.ProductId == request.IncreaseStockRequest.ProductId);
if (stock == null)
{
throw new System.Exception("Product not found!");
}
stock.Quantity += request.IncreaseStockRequest.Quantity;
_dbContext.Stocks.Attach(stock);
_dbContext.Entry(stock).Property(x => x.Quantity).IsModified = true;
await _dbContext.SaveChangesAsync();
return(_mapping.Map <Infrastructure.Entities.Stock, IncreaseStockResponseModel>(stock));
}
public MeasurementFileFormat GetMeasurements(Gateway gateway, KellerDevice device)
{
var reply = SendGetMeasurementRequest(gateway, device);
var kellerFormat = _mapper.Map(reply);
kellerFormat.Header.SerialNumber = device.SerialNumber;
kellerFormat.Header.DeviceName = device.Name;
kellerFormat.Header.DeviceType = device.DeviceType;
kellerFormat.Header.UniqueSerialNumber = MeasurementFileFormatHelper.GenerateUniqueSerialNumber(kellerFormat.Header, device.EUI);
kellerFormat.Header.RecordId = MeasurementFileFormatHelper.GenerateRecordId(kellerFormat.Header);
kellerFormat.Header.CustomAttributes = new MeasurementFileFormatCustomAttributes
{
RecordName = MeasurementFileFormatHelper.GenerateDefaultRecordName(kellerFormat.Header),
RecordNotes = string.Empty,
};
return(kellerFormat);
}
public void MapValues(OrderLine source, CartProduct target)
{
target.Adjustments = new ReadOnlyCollection <CartAdjustment>(_orderLineToAdjustments.Map(source));
target.ProductId = source.Sku;
target.Price = _orderLineToPrice.Map(source);
if (!string.IsNullOrEmpty(source.VariantSku))
{
target.Properties.Add("VariantSku", source.VariantSku);
}
var productNameProperty = target.GetType().GetProperty("ProductName");
if (productNameProperty != null)
{
productNameProperty.SetValue(target, source.ProductName, null);
}
}
public PipelineExecutionResult Execute(IPipelineArgs <CreateCustomerRequest, CreateCustomerResponse> subject)
{
if (subject.Response.Customer == null)
{
throw new ArgumentException();
}
var commerceCustomer = _customerToCustomer.Map(subject.Response.Customer);
var customerService = new CustomerServiceProvider();
var createCustomerRequest = new global::Sitecore.Commerce.Services.Customers.CreateCustomerRequest(commerceCustomer);
createCustomerRequest.Properties["FromUCommerce"] = true;
customerService.CreateCustomer(createCustomerRequest);
return(PipelineExecutionResult.Success);
}
public override void Process(ServicePipelineArgs args)
{
RemoveShippingInfoRequest request;
RemoveShippingInfoResult result;
using (new DisposableThreadLifestyleScope())
{
CheckParametersAndSetupRequestAndResult(args, out request, out result);
Assert.ArgumentNotNull(request.ShippingInfo, "request.ShippingInfo");
Assert.ArgumentNotNull(request.Cart, "request.Cart");
Assert.ArgumentCondition(request.ShippingInfo.Count != 0, "request.ShippingInfo",
"request.ShippingInfo cannot be empty");
var purchaseOrder = _basketService.GetBasketByCartExternalId(request.Cart.ExternalId).PurchaseOrder;
var removeShipmentPipeline = PipelineFactory.Create <IPipelineArgs <RemoveShipmentRequest, RemoveShipmentResult> >("RemoveShipment");
if (!IsFromUcommerce(request))
{
foreach (var shippingInfo in request.ShippingInfo)
{
var shipment = GetShipmentFromPurchaseOrder(purchaseOrder, shippingInfo);
var removeShipmentPipelineArgs = new RemoveShipmentPipelineArgs(new RemoveShipmentRequest()
{
PurchaseOrder = purchaseOrder,
Shipment = shipment
}, new RemoveShipmentResult());
removeShipmentPipelineArgs.Request.Properties["FromUCommerce"] = false;
removeShipmentPipeline.Execute(removeShipmentPipelineArgs);
}
PipelineFactory.Create <PurchaseOrder>("Basket").Execute(purchaseOrder);
}
var shippinInfo = _shipmentMapper.Map(purchaseOrder.Shipments);
result.ShippingInfo = new ReadOnlyCollection <ShippingInfo>(shippinInfo);
result.Cart = _purchaseOrderMapper.Map(purchaseOrder);
}
}
public void MapValues(CartLine source, OrderLine target)
{
target.Discounts = _adjustMentsToDiscounts.Map(source.Adjustments);
target.Total = source.Total.Amount;
target.Quantity = (int)source.Quantity;
if (source.Product != null)
{
var cartProduct = source.Product;
target.Sku = cartProduct.ProductId;
target.Price = cartProduct.Price.Amount;
target.VariantSku = cartProduct.Properties.GetPropertyOrDefault <string>("VariantSku", "");
var productNameProperty = cartProduct.GetType().GetProperty("ProductName");
if (productNameProperty != null)
{
target.ProductName = (string)productNameProperty.GetValue(cartProduct);
}
}
}
public override void Process(ServicePipelineArgs args)
{
AddPaymentInfoRequest request;
AddPaymentInfoResult result;
using (new DisposableThreadLifestyleScope())
{
CheckParametersAndSetupRequestAndResult(args, out request, out result);
Assert.ArgumentNotNull(request.Payments, "request.Payments");
Assert.ArgumentNotNull(request.Cart, "request.Cart");
var purchaseOrder = _basketService.GetBasketByCartExternalId(request.Cart.ExternalId).PurchaseOrder;
foreach (var paymentInfo in request.Payments)
{
var paymentMethod = GetPaymentMethod(paymentInfo);
var paymentInfoWithAmount = paymentInfo as PaymentInfoWithAmount;
if (paymentInfoWithAmount != null)
{
// If a specific amount was given, create a Payment with that amount.
CreatePayment(purchaseOrder, paymentMethod, paymentInfoWithAmount.Amount);
}
else
{
// If no amount was given, create a payment with the default amount.
CreatePayment(purchaseOrder, paymentMethod, -1);
}
}
global::UCommerce.Pipelines.PipelineFactory.Create <PurchaseOrder>("Basket").Execute(purchaseOrder);
var paymentInfos = _paymentMapper.Map(purchaseOrder.Payments);
result.Payments = new ReadOnlyCollection <PaymentInfo>(paymentInfos);
result.Cart = _purchaseOrderMapper.Map(purchaseOrder);
}
}
public void MapValues(ICollection <Payment> source, IList <CartAdjustment> target)
{
((List <CartAdjustment>)target).AddRange(source.Select(payment => _paymentToAdjustment.Map(payment)).ToList());
}
public CommerceCustomer Map(EntitiesV2.Customer target)
{
var commerceCustomer = new CommerceCustomer();
commerceCustomer.Shops = new ReadOnlyCollection <string>(_productCatalogGroupRepository.Select().Select(x => x.Name).ToList());
commerceCustomer.IsDisabled = false;
commerceCustomer.Name = string.Format("{0} {1}", target.FirstName, target.LastName);
commerceCustomer.Parties = new ReadOnlyCollection <CustomerParty>(target.Addresses.Select(x => _addressToCustomerParty.Map(x)).ToList());
commerceCustomer.ExternalId = target.CustomerId.ToString();
return(commerceCustomer);
}
public virtual Product MapCartProductToProduct(CartProduct cartProduct)
{
return(_mapCartProductToProduct.Map(cartProduct));
}
public virtual Order MapPurchaseOrderToOrder(PurchaseOrder purchaseOrder)
{
return(_mapPurchaseOrderToOrder.Map(purchaseOrder));
}
public virtual OrderLine MapCartLineToOrderLine(CartLine cartLine)
{
return(_mapCartLineToOrderLine.Map(cartLine));
}
public virtual CartLine MapOrderLineToCartLine(OrderLine orderLine)
{
return(_mapOrderLineToCartLine.Map(orderLine));
}
