public virtual async Task <ProcessAuthorizationResponse> ProcessAuthorizationAsync(Guid contactId, string marketId, string cartName, string orderId)
        {
            var purchaseOrder = _vippsService.GetPurchaseOrderByOrderId(orderId);

            if (purchaseOrder != null)
            {
                return(new ProcessAuthorizationResponse
                {
                    PurchaseOrder = purchaseOrder,
                    Processed = true
                });
            }

            var cart        = _vippsService.GetCartByContactId(contactId, marketId, cartName);
            var paymentType = GetVippsPaymentType(cart);

            var orderDetails = await _vippsService.GetOrderDetailsAsync(orderId, marketId);

            var result = await _vippsOrderCreator.ProcessOrderDetails(orderDetails, orderId, contactId, marketId, cartName);

            if (result.PurchaseOrder != null)
            {
                return(new ProcessAuthorizationResponse(result)
                {
                    Processed = true
                });
            }

            return(new ProcessAuthorizationResponse(result)
            {
                PaymentType = paymentType,
                Processed = false
            });
        }
        public virtual async Task <LoadOrCreatePurchaseOrderResponse> LoadOrCreatePurchaseOrder(ICart cart, string orderId)
        {
            var mutex = new Mutex(false, orderId);

            mutex.WaitOne();
            try
            {
                var purchaseOrder = _vippsService.GetPurchaseOrderByOrderId(orderId);
                if (purchaseOrder != null)
                {
                    _logger.Information($"Found PurchaseOrder for orderId {orderId}");
                    return(new LoadOrCreatePurchaseOrderResponse
                    {
                        PurchaseOrder = purchaseOrder
                    });
                }

                return(await CreatePurchaseOrder(cart));
            }

            catch (Exception ex)
            {
                _logger.Error($"Error creating/loading PurchaseOrder for vipps orderId {orderId}. Exception {ex.Message}, {ex.StackTrace}");
                return(new LoadOrCreatePurchaseOrderResponse
                {
                    ErrorMessage = ex.Message
                });
            }

            finally
            {
                mutex.ReleaseMutex();
            }
        }
        private ProcessOrderResponse EnsureNoPurchaseOrder(string orderId)
        {
            var purchaseOrder = _vippsService.GetPurchaseOrderByOrderId(orderId);

            if (purchaseOrder == null)
            {
                return(null);
            }

            return(new ProcessOrderResponse
            {
                PurchaseOrder = purchaseOrder
            });
        }
예제 #4
0
        private async Task <ProcessOrderResponse> ProcessOrder(IVippsUserDetails vippsUserDetails, IVippsPaymentDetails paymentDetails, string orderId, Guid contactId, string marketId, string cartName)
        {
            var readLock = _synchronizer.Get(orderId);

            try
            {
                await readLock.WaitAsync();

                var purchaseOrder = _vippsService.GetPurchaseOrderByOrderId(orderId);
                if (purchaseOrder != null)
                {
                    return(new ProcessOrderResponse
                    {
                        PurchaseOrder = purchaseOrder
                    });
                }

                var cart = _vippsService.GetCartByContactId(contactId, marketId, cartName);
                if (cart == null)
                {
                    _logger.Warning($"No cart found for vipps order id {orderId}");
                    return(new ProcessOrderResponse
                    {
                        ProcessResponseErrorType = ProcessResponseErrorType.NOCARTFOUND,
                        ErrorMessage = $"No cart found for vipps order id {orderId}"
                    });
                }

                var payment = cart.GetFirstForm().Payments.FirstOrDefault(x =>
                                                                          x.IsVippsPayment() && x.TransactionID == orderId &&
                                                                          x.TransactionType.Equals(TransactionType.Authorization.ToString()));


                if (TransactionSuccess(paymentDetails))
                {
                    return(await HandleSuccess(cart, payment, paymentDetails, vippsUserDetails, orderId));
                }

                if (TransactionCancelled(paymentDetails))
                {
                    return(HandleCancelled(cart, payment, paymentDetails, orderId));
                }

                if (TransactionFailed(paymentDetails))
                {
                    return(HandleFailed(cart, payment, paymentDetails, orderId));
                }

                return(new ProcessOrderResponse
                {
                    ProcessResponseErrorType = ProcessResponseErrorType.OTHER,
                    ErrorMessage = $"No action taken on order id: {orderId}."
                });
            }

            catch (Exception ex)
            {
                _logger.Error(ex.Message, ex);
                return(new ProcessOrderResponse
                {
                    ErrorMessage = ex.Message,
                    ProcessResponseErrorType = ProcessResponseErrorType.EXCEPTION
                });
            }

            finally
            {
                readLock.Release();

                if (readLock.CurrentCount > 0)
                {
                    _synchronizer.Remove(orderId);
                }
            }
        }