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)); }