예제 #1
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            var obj = JObject.Load(reader);
            OrderModel orderModel;

            var type = obj["Type"];
            if (type == null)
            {
                throw new ArgumentNullException("Type", "Order type is null");
            }

            string orderType = type.Value<string>();
            switch (orderType)
            {
                case OrderTypes.Ride:
                    orderModel = new RideOrder();
                    break;
                case OrderTypes.Delivery:
                    orderModel = new DeliveryOrder();
                    break;
                case OrderTypes.ClassifiedDelivery:
                    orderModel = new ClassifiedDeliveryOrder();
                    break;
                default:
                    throw new NotSupportedException(string.Concat("Order Entry type invalid/not supported - ", orderType));
            }

            serializer.Populate(obj.CreateReader(), orderModel);
            return orderModel;

        }
예제 #2
0
        private async Task <Job> PostOrderToJob(OrderModel model, string adminUserId = null)
        {
            UserModel userModel      = new UserModel(await accountManager.FindByIdAsync(model.UserId));
            UserModel adminUserModel = null;

            Vendor vendor = default(Vendor);

            if (!string.IsNullOrWhiteSpace(model.VendorId))
            {
                vendor = await vendorService.Get(model.VendorId);
            }

            if (!string.IsNullOrWhiteSpace(adminUserId))
            {
                adminUserModel = new UserModel(await accountManager.FindByIdAsync(adminUserId));
            }

            JobShop    jobShop = new JobShop();
            JobBuilder builder;

            switch (model.Type)
            {
            case OrderTypes.ClassifiedDelivery:
            {
                ClassifiedDeliveryOrder classifiedDeliveryOrderModel = model as ClassifiedDeliveryOrder;
                if (!string.IsNullOrWhiteSpace(classifiedDeliveryOrderModel.BuyerInfo?.UserRef))
                {
                    var user = await accountManager.FindByIdAsync(classifiedDeliveryOrderModel.BuyerInfo.UserRef);

                    classifiedDeliveryOrderModel.BuyerInfo.PhoneNumber = user.PhoneNumber;
                    classifiedDeliveryOrderModel.BuyerInfo.Address     = user.Profile.Address;
                    classifiedDeliveryOrderModel.BuyerInfo.Name        = GetNameFromProfile(user);
                }
                if (!string.IsNullOrWhiteSpace(classifiedDeliveryOrderModel.SellerInfo?.UserRef))
                {
                    var user = await accountManager.FindByIdAsync(classifiedDeliveryOrderModel.SellerInfo.UserRef);

                    classifiedDeliveryOrderModel.SellerInfo.PhoneNumber = user.PhoneNumber;
                    classifiedDeliveryOrderModel.SellerInfo.Address     = user.Profile.Address;
                    classifiedDeliveryOrderModel.SellerInfo.Name        = GetNameFromProfile(user);
                }
                builder = GetDeliveryJobBuilder(userModel, adminUserModel, classifiedDeliveryOrderModel, vendor);
                break;
            }

            case OrderTypes.Delivery:
            {
                DeliveryOrder deliveryOrderModel = model as DeliveryOrder;
                builder = GetDeliveryJobBuilder(userModel, adminUserModel, deliveryOrderModel, vendor);
                break;
            }

            default:
                throw new InvalidOperationException("Invalid/Not supported Order Type Provided");
            }
            var result = await ConstructAndRegister(jobShop, builder);

            this.jobSearchIndexService.OnNext(result);
            return(result);
        }
예제 #3
0
        private async Task <Data.Entity.Job> PostNewOrder(ClassifiedDeliveryOrder taskcatOrder)
        {
            var createdJob = await this.repository.PostOrder(taskcatOrder);

            var referenceUserForActivityLog = new ReferenceUser(taskcatOrder.UserId, createdJob.User.UserName);

            activitySubject.OnNext(new JobActivity(createdJob, JobActivityOperationNames.Create, referenceUserForActivityLog));
            return(createdJob);
        }
예제 #4
0
        public static OrderModel CreateOrderInstance(string orderType)
        {
            OrderModel orderModel = default(OrderModel);

            switch (orderType)
            {
            case OrderTypes.Delivery:
                orderModel = new DeliveryOrder();
                break;

            case OrderTypes.ClassifiedDelivery:
                orderModel = new ClassifiedDeliveryOrder();
                break;

            default:
                throw new NotSupportedException(string.Concat("Order Entry type invalid/not supported - ", orderType));
            }

            return(orderModel);
        }
예제 #5
0
        public static ClassifiedDeliveryOrder ToClassifiedDeliveryOrder(
            this Order infiniOrder,
            Decimal serviceCharge,
            ProprietorSettings defaultAddressSettings,
            string userId)
        {
            if (infiniOrder == null)
            {
                throw new ArgumentNullException(nameof(infiniOrder));
            }

            if (defaultAddressSettings == null)
            {
                throw new ArgumentNullException(nameof(defaultAddressSettings));
            }

            if (userId == null)
            {
                throw new ArgumentNullException(nameof(userId));
            }

            const string            orderPrefix  = "IFA";
            ClassifiedDeliveryOrder taskcatOrder = new ClassifiedDeliveryOrder(
                orderPrefix + "-" + infiniOrder.id)
            {
                IsAutogenerated  = true,
                ReferenceOrderId = infiniOrder.id.ToString(),
                Description      = GenerateTaskCatJobDescription(infiniOrder),

                PaymentMethod = CashOnDeliveryPaymentMethod.PaymentMethodKey,

                OrderCart = new OrderDetails
                {
                    ServiceCharge = serviceCharge,
                    SubTotal      = infiniOrder.total
                }
            };

            taskcatOrder.OrderCart.TotalToPay  = infiniOrder.total + taskcatOrder.OrderCart.ServiceCharge;
            taskcatOrder.OrderCart.PackageList = new List <ItemDetails>();

            taskcatOrder.OrderCart.PackageList.Add(new ItemDetails()
            {
                Item     = infiniOrder.product,
                Price    = infiniOrder.unit_price,
                Quantity = infiniOrder.qty
            });

            // Infini doesn't provide a from address for now. We are setting it to a configured default
            if (infiniOrder.vendor_address == null || !infiniOrder.vendor_address.Any())
            {
                taskcatOrder.From       = defaultAddressSettings.Address;
                taskcatOrder.SellerInfo = new PersonInfo()
                {
                    Name        = defaultAddressSettings.Name,
                    PhoneNumber = defaultAddressSettings.PhoneNumber
                };
            }
            else
            {
                var vendorAddress = infiniOrder.vendor_address.First();
                taskcatOrder.From = new DefaultAddress()
                {
                    AddressLine1 = vendorAddress.address1,
                    AddressLine2 = String.IsNullOrWhiteSpace(vendorAddress.address3) ? vendorAddress.address2 : string.Join(" ", vendorAddress.address2, vendorAddress.address3),
                };

                taskcatOrder.SellerInfo = new PersonInfo()
                {
                    Name        = string.Join(" ", vendorAddress.firstname, vendorAddress.lastname),
                    PhoneNumber = vendorAddress.phone_no
                };
            }

            taskcatOrder.UserId = userId;

            taskcatOrder.To = new DefaultAddress(
                addressLine1: infiniOrder.user_address.address1,
                addressLine2: string.IsNullOrWhiteSpace(infiniOrder.user_address.address3) ? infiniOrder.user_address.address2 : string.Join(" ", infiniOrder.user_address.address2, infiniOrder.user_address.address3),
                locality: infiniOrder.user_address.zone,
                postcode: infiniOrder.user_address.postcode,
                city: infiniOrder.user_address.city,
                country: "Bangladesh", // TODO: Infini sends back a country code, either we need to parse it or find a way to make this nice
                point: null);

            taskcatOrder.BuyerInfo = new PersonInfo()
            {
                Name        = string.Join(" ", infiniOrder.user_address.firstname, infiniOrder.user_address.lastname),
                PhoneNumber = infiniOrder.user_address.phone_no
            };

            taskcatOrder.Variant = DeliveryOrderVariants.EnterpriseDelivery;

            return(taskcatOrder);
        }