Пример #1
0
        public IHttpActionResult GetBalance([FromUri] Models.Address address) {
            List<Models.MosaicBalanceModel> balance = new List<Models.MosaicBalanceModel>();
            var connection = new Connection();
            connection.SetTestnet();
            try
            {
                // To get mosaic information of the account from the address.
                var mosaicClient = new NamespaceMosaicClient(connection);
                var mosaicResult = mosaicClient.BeginGetMosaicsOwned(address.MosaicAddress);
                var mosaicResponse = mosaicClient.EndGetMosaicsOwned(mosaicResult);

                foreach (var data in mosaicResponse.Data)
                {
                    if (data.MosaicId.Name == "tfc")
                    {
                        balance.Add(new Models.MosaicBalanceModel
                        {
                            Name = data.MosaicId.Name,
                            Amount = data.Quantity / 10000

                        });
                    }
                }
            }
            catch (Exception e) { }

            if (balance.Count == 0) {
                return NotFound();
            }

            return Ok(balance);
        }
Пример #2
0
        public async Task <double[]> GetCoords(Models.Address addressToCode)
        {
            //Create a request.
            var request = new GeocodeRequest()
            {
                Address = new SimpleAddress()
                {
                    AddressLine   = addressToCode.Street,
                    Locality      = addressToCode.City,
                    AdminDistrict = addressToCode.State,
                    PostalCode    = addressToCode.Zip
                },
                BingMapsKey = API_Keys.Bing
            };


            // I Want to check the response, but it appears to be skipping over the steps below.

            //Process the request by using the ServiceManager.
            double[] coords   = new double[2];
            var      response = await ServiceManager.GetResponseAsync(request);

            if (response != null &&
                response.ResourceSets != null &&
                response.ResourceSets.Length > 0 &&
                response.ResourceSets[0].Resources != null &&
                response.ResourceSets[0].Resources.Length > 0)
            {
                var result = response.ResourceSets[0].Resources[0] as BingMapsRESTToolkit.Location;

                coords[0] = result.Point.Coordinates[0];
                coords[1] = result.Point.Coordinates[1];
            }
            return(coords);
        }
Пример #3
0
        public async Task <IHttpActionResult> PostBIM()
        {
            //    string[] buildings = resultString.Split(new string[] { "BuildingStoreys" }, StringSplitOptions.None);
            SpacesHandler    SH       = new SpacesHandler(db);
            StoreysHandler   STH      = new StoreysHandler(db);
            BuildingsHandler BH       = new BuildingsHandler(db);
            AddressesHandler AH       = new AddressesHandler(db);
            Building         building = JsonConvert.DeserializeObject <Building>(Request.Content.ReadAsStringAsync().Result);

            Models.Building b = new Models.Building(building.ID, building.Name);
            BH.PostBuilding(b);
            double?longitude = building.Address.Longitude;
            double?latitude  = building.Address.Latitude;

            Models.Address address = new Models.Address(building.Address.Street, building.Address.Number, building.Address.Town, building.Address.PostalCode, building.Address.Region, building.Address.Country, longitude, latitude, b);
            AH.PostAddress(address);
            List <BuildingStorey> storeys = building.BuildingStoreys;

            foreach (BuildingStorey storey in storeys)
            {
                Models.Storey st = new Models.Storey(storey.ID, storey.Name, b);
                STH.PostStorey(st);
                foreach (Space space in storey.Spaces)
                {
                    Models.Space s = new Models.Space(space.ID, space.Name, st);
                    SH.PostSpace(s);
                }
            }
            List <Space> spaces = storeys[0].Spaces;

            return(Ok(building));
        }
Пример #4
0
        public ActionResult Create(FormCollection collection)
        {
            try
            {
                int            id         = int.Parse(Session["user_id"].ToString());
                Models.Profile theProfile = database.Profiles.SingleOrDefault(p => p.user_id == id);

                // TODO: Add insert logic here
                Models.Address newAddress = new Models.Address()
                {
                    city           = collection["city"],
                    country_code   = collection["country_code"],
                    description    = collection["description"],
                    profile_id     = theProfile.profile_id,
                    province_state = collection["province_state"],
                    street         = collection["street"],
                    zip_postal     = collection["zip_postal"]
                };

                database.Addresses.Add(newAddress);
                database.SaveChanges();

                return(RedirectToAction("Index", new { id = newAddress.profile_id }));
            }
            catch
            {
                return(View());
            }
        }
Пример #5
0
        public async Task <double> GetTravelTime(Models.Address fromAddress, Models.Address toAddress)
        {
            var request = new RouteRequest()
            {
                Waypoints = new List <SimpleWaypoint>()
                {
                    new SimpleWaypoint(fromAddress.Lat, fromAddress.Lon),
                    new SimpleWaypoint(toAddress.Lat, toAddress.Lon)
                },
                BingMapsKey = Constants.API_Keys.Bing
            };
            double travelTime = 0;
            var    response   = await ServiceManager.GetResponseAsync(request);

            if (response != null &&
                response.ResourceSets != null &&
                response.ResourceSets.Length > 0 &&
                response.ResourceSets[0].Resources != null &&
                response.ResourceSets[0].Resources.Length > 0)
            {
                var result = response.ResourceSets[0].Resources[0] as BingMapsRESTToolkit.Route;

                //Do something with the result.
                travelTime = Convert.ToDouble(result.TravelDuration);
            }
            return(travelTime);
        }
Пример #6
0
 /// <summary>
 /// Initializes a new instance of the <see cref="CreateCustomerRequest"/> class.
 /// </summary>
 /// <param name="idempotencyKey">idempotency_key.</param>
 /// <param name="givenName">given_name.</param>
 /// <param name="familyName">family_name.</param>
 /// <param name="companyName">company_name.</param>
 /// <param name="nickname">nickname.</param>
 /// <param name="emailAddress">email_address.</param>
 /// <param name="address">address.</param>
 /// <param name="phoneNumber">phone_number.</param>
 /// <param name="referenceId">reference_id.</param>
 /// <param name="note">note.</param>
 /// <param name="birthday">birthday.</param>
 public CreateCustomerRequest(
     string idempotencyKey  = null,
     string givenName       = null,
     string familyName      = null,
     string companyName     = null,
     string nickname        = null,
     string emailAddress    = null,
     Models.Address address = null,
     string phoneNumber     = null,
     string referenceId     = null,
     string note            = null,
     string birthday        = null)
 {
     this.IdempotencyKey = idempotencyKey;
     this.GivenName      = givenName;
     this.FamilyName     = familyName;
     this.CompanyName    = companyName;
     this.Nickname       = nickname;
     this.EmailAddress   = emailAddress;
     this.Address        = address;
     this.PhoneNumber    = phoneNumber;
     this.ReferenceId    = referenceId;
     this.Note           = note;
     this.Birthday       = birthday;
 }
Пример #7
0
 public Payment(string id                = null,
                string createdAt         = null,
                string updatedAt         = null,
                Models.Money amountMoney = null,
                Models.Money tipMoney    = null,
                Models.Money totalMoney  = null,
                Models.Money appFeeMoney = null,
                IList <Models.ProcessingFee> processingFee = null,
                Models.Money refundedMoney = null,
                string status        = null,
                string delayDuration = null,
                string delayAction   = null,
                string delayedUntil  = null,
                string sourceType    = null,
                Models.CardPaymentDetails cardDetails = null,
                string locationId                    = null,
                string orderId                       = null,
                string referenceId                   = null,
                string customerId                    = null,
                string employeeId                    = null,
                IList <string> refundIds             = null,
                Models.RiskEvaluation riskEvaluation = null,
                string buyerEmailAddress             = null,
                Models.Address billingAddress        = null,
                Models.Address shippingAddress       = null,
                string note = null,
                string statementDescriptionIdentifier = null,
                string receiptNumber = null,
                string receiptUrl    = null)
 {
     Id                = id;
     CreatedAt         = createdAt;
     UpdatedAt         = updatedAt;
     AmountMoney       = amountMoney;
     TipMoney          = tipMoney;
     TotalMoney        = totalMoney;
     AppFeeMoney       = appFeeMoney;
     ProcessingFee     = processingFee;
     RefundedMoney     = refundedMoney;
     Status            = status;
     DelayDuration     = delayDuration;
     DelayAction       = delayAction;
     DelayedUntil      = delayedUntil;
     SourceType        = sourceType;
     CardDetails       = cardDetails;
     LocationId        = locationId;
     OrderId           = orderId;
     ReferenceId       = referenceId;
     CustomerId        = customerId;
     EmployeeId        = employeeId;
     RefundIds         = refundIds;
     RiskEvaluation    = riskEvaluation;
     BuyerEmailAddress = buyerEmailAddress;
     BillingAddress    = billingAddress;
     ShippingAddress   = shippingAddress;
     Note              = note;
     StatementDescriptionIdentifier = statementDescriptionIdentifier;
     ReceiptNumber = receiptNumber;
     ReceiptUrl    = receiptUrl;
 }
Пример #8
0
        public IActionResult Delete([FromBody] Models.Address value)
        {
            try
            {
                bool dt     = Address.DeleteAddress(value);
                var  resval = dt ? StatusCode(StatusCodes.Status200OK) : StatusCode(StatusCodes.Status204NoContent);
                return(resval);
            }
            catch (Helper.RepositoryException ex)
            {
                switch (ex.Type)
                {
                case UpdateResultType.SQLERROR:
                    return(StatusCode(StatusCodes.Status500InternalServerError, "Internal Server Error"));

                case UpdateResultType.INVALIDEARGUMENT:
                    return(StatusCode(StatusCodes.Status409Conflict, "Conflict"));

                case UpdateResultType.ERROR:
                    return(StatusCode(StatusCodes.Status400BadRequest, "Bad Request"));

                default:
                    return(StatusCode(StatusCodes.Status406NotAcceptable, "Not Acceptable"));
                }
            }
        }
Пример #9
0
        public async Task <IActionResult> PostCreate(Models.Address model)
        {
            model.ClientWebId = int.Parse(HttpContext.Request.Form["ClientWebId"]);

            try
            {
                if (ModelState.IsValid)
                {
                    model.ClientWebId = int.Parse(HttpContext.Request.Form["ClientWebId"]);

                    _context.Add(model);
                    await _context.SaveChangesAsync();

                    HttpContext.Session.SetString("messageAction", "La operación se realizó de manera exitosa");
                }
                else
                {
                    HttpContext.Session.SetString("messageAction", "Ha ocurrido un error");
                }

                return(Redirect("/client/client/list/"));
            }
            catch
            {
                HttpContext.Session.SetString("messageAction", "Ocurrio un error al intentar la operación");

                return(Redirect("/client/client/list/"));
            }
        }
Пример #10
0
 public V1Merchant(string id          = null,
                   string name        = null,
                   string email       = null,
                   string accountType = null,
                   IList <string> accountCapabilities = null,
                   string countryCode                 = null,
                   string languageCode                = null,
                   string currencyCode                = null,
                   string businessName                = null,
                   Models.Address businessAddress     = null,
                   Models.V1PhoneNumber businessPhone = null,
                   string businessType                = null,
                   Models.Address shippingAddress     = null,
                   Models.V1MerchantLocationDetails locationDetails = null,
                   string marketUrl = null)
 {
     Id                  = id;
     Name                = name;
     Email               = email;
     AccountType         = accountType;
     AccountCapabilities = accountCapabilities;
     CountryCode         = countryCode;
     LanguageCode        = languageCode;
     CurrencyCode        = currencyCode;
     BusinessName        = businessName;
     BusinessAddress     = businessAddress;
     BusinessPhone       = businessPhone;
     BusinessType        = businessType;
     ShippingAddress     = shippingAddress;
     LocationDetails     = locationDetails;
     MarketUrl           = marketUrl;
 }
Пример #11
0
        public static async Task SendPostMessageAsync(Models.Address address, string reqUrl)
        {
            var tokenProvider    = TokenProvider.CreateSharedAccessSignatureTokenProvider(KeyName, AccessKey);
            var messagingFactory = MessagingFactory.Create(BaseAddress, tokenProvider);
            var sender           = messagingFactory.CreateMessageSender(QueueName);

            var messageModel = new MessageModel()
            {
                TitleMessage     = "New Address record {" + address.AddressId + "} added for {" + address.CustomerId + "} at " + DateTime.UtcNow,
                CustomerGuid     = address.CustomerId,
                LastModifiedDate = address.LastModifiedDate,
                URL           = reqUrl + "/" + address.AddressId,
                IsNewCustomer = false,
                TouchpointId  = address.LastModifiedTouchpointId
            };

            var msg = new BrokeredMessage(new MemoryStream(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(messageModel))))
            {
                ContentType = "application/json",
                MessageId   = address.CustomerId + " " + DateTime.UtcNow
            };

            //msg.ForcePersistence = true; Required when we save message to cosmos
            await sender.SendAsync(msg);
        }
        public ActionResult Create(int id, FormCollection collection)
        {
            try
            {
                // TODO: Add insert logic here
                Models.Address newAddress = new Models.Address()
                {
                    city         = collection["city"],
                    country_code = collection["country_code"],
                    description  = collection["description"],
                    person_id    = id,
                    prov_state   = collection["prov_state"], // stat_prov
                    street       = collection["street"],     // street
                    zip_postal   = collection["zip_postal"]  // zip_postal
                };
                db.Addresses.Add(newAddress);
                db.SaveChanges();

                return(RedirectToAction("Index", new { id = newAddress.person_id }));
            }
            catch
            {
                return(View());
            }
        }
Пример #13
0
        public async Task <IActionResult> OnGetAsync(int?id)
        {
            string userId = _userManager.GetUserId(User);

            if (id == null)
            {
                return(NotFound());
            }

            var testAdress = await _context.Address
                             .Where(addres =>
                                    addres.Id == id &&
                                    addres.UserId == userId)
                             .FirstOrDefaultAsync();

            if (testAdress == null)
            {
                return(NotFound());
            }

            Address = await _context.Address
                      .Where(a =>
                             a.UserId == userId &&
                             a.Id == id)
                      .FirstOrDefaultAsync();

            if (Address == null)
            {
                return(NotFound());
            }
            return(Page());
        }
Пример #14
0
 public ChargeRequest(string idempotencyKey,
                      Models.Money amountMoney,
                      string cardNonce               = null,
                      string customerCardId          = null,
                      bool?delayCapture              = null,
                      string referenceId             = null,
                      string note                    = null,
                      string customerId              = null,
                      Models.Address billingAddress  = null,
                      Models.Address shippingAddress = null,
                      string buyerEmailAddress       = null,
                      string orderId                 = null,
                      IList <Models.ChargeRequestAdditionalRecipient> additionalRecipients = null,
                      string verificationToken = null)
 {
     IdempotencyKey       = idempotencyKey;
     AmountMoney          = amountMoney;
     CardNonce            = cardNonce;
     CustomerCardId       = customerCardId;
     DelayCapture         = delayCapture;
     ReferenceId          = referenceId;
     Note                 = note;
     CustomerId           = customerId;
     BillingAddress       = billingAddress;
     ShippingAddress      = shippingAddress;
     BuyerEmailAddress    = buyerEmailAddress;
     OrderId              = orderId;
     AdditionalRecipients = additionalRecipients;
     VerificationToken    = verificationToken;
 }
        // TODO - GenerateCreditCardPayment().
        public object GenerateCreditCardPayment(
            Models.Customer loggedInCustomer,
            ShippingInformation shippingInfo,
            Models.Address customerAddress,
            List <CartItem> cartItems,
            CreditCard creditCart)
        {
            try
            {
                SetKeys();

                decimal totalPrice = CalculateTotalPrice(cartItems, shippingInfo);

                Transaction transaction = new Transaction()
                {
                    Amount   = PriceConverter.ConvertDecimalPriceToPriceInCents(totalPrice),
                    Billing  = BillingFactory(loggedInCustomer, customerAddress),
                    Card     = CardFactory(creditCart),
                    Customer = CustomerFactory(loggedInCustomer),
                    Item     = ItemArrayFactory(cartItems),
                    Shipping = ShippingFactory(loggedInCustomer, shippingInfo, customerAddress)
                };

                transaction.Save();

                return(new { TransactionId = transaction.Id });
            }
            catch (Exception e)
            {
                return(new { Error = e.Message });
            }
        }
Пример #16
0
 /// <summary>
 /// Initializes a new instance of the <see cref="Card"/> class.
 /// </summary>
 /// <param name="id">id.</param>
 /// <param name="cardBrand">card_brand.</param>
 /// <param name="last4">last_4.</param>
 /// <param name="expMonth">exp_month.</param>
 /// <param name="expYear">exp_year.</param>
 /// <param name="cardholderName">cardholder_name.</param>
 /// <param name="billingAddress">billing_address.</param>
 /// <param name="fingerprint">fingerprint.</param>
 /// <param name="customerId">customer_id.</param>
 /// <param name="referenceId">reference_id.</param>
 /// <param name="enabled">enabled.</param>
 /// <param name="cardType">card_type.</param>
 /// <param name="prepaidType">prepaid_type.</param>
 /// <param name="bin">bin.</param>
 /// <param name="version">version.</param>
 public Card(
     string id                     = null,
     string cardBrand              = null,
     string last4                  = null,
     long?expMonth                 = null,
     long?expYear                  = null,
     string cardholderName         = null,
     Models.Address billingAddress = null,
     string fingerprint            = null,
     string customerId             = null,
     string referenceId            = null,
     bool?enabled                  = null,
     string cardType               = null,
     string prepaidType            = null,
     string bin                    = null,
     long?version                  = null)
 {
     this.Id             = id;
     this.CardBrand      = cardBrand;
     this.Last4          = last4;
     this.ExpMonth       = expMonth;
     this.ExpYear        = expYear;
     this.CardholderName = cardholderName;
     this.BillingAddress = billingAddress;
     this.Fingerprint    = fingerprint;
     this.CustomerId     = customerId;
     this.ReferenceId    = referenceId;
     this.Enabled        = enabled;
     this.CardType       = cardType;
     this.PrepaidType    = prepaidType;
     this.Bin            = bin;
     this.Version        = version;
 }
Пример #17
0
        public IActionResult Get(int id)
        {
            Models.Address dt    = Address.Read(id);
            var            reval = dt != null?StatusCode(StatusCodes.Status200OK, dt) : (IActionResult)StatusCode(StatusCodes.Status204NoContent);

            return(reval);
        }
Пример #18
0
        public ActionResult Create(int id, FormCollection collection)
        {
            string countryName = collection["country_name"];

            try
            {
                // TODO: Add insert logic here
                Models.Address newAddress = new Models.Address()
                {
                    city        = collection["city"],
                    description = collection["description"],
                    street      = collection["street"],
                    province    = collection["province"],
                    postal_code = collection["postal_code"],
                    country_id  = (from c in db.Countries
                                   where c.country_name.Equals(countryName)
                                   select c.country_id).FirstOrDefault(),
                    profile_id = id
                };

                db.Addresses.Add(newAddress);
                db.SaveChanges();

                return(RedirectToAction("Index", new { id = id }));
            }
            catch
            {
                ViewBag.countries = new SelectList(from c in db.Countries
                                                   select c.country_name);
                ViewBag.id = id;
                return(View());
            }
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="UpdateCustomerRequest"/> class.
 /// </summary>
 /// <param name="givenName">given_name.</param>
 /// <param name="familyName">family_name.</param>
 /// <param name="companyName">company_name.</param>
 /// <param name="nickname">nickname.</param>
 /// <param name="emailAddress">email_address.</param>
 /// <param name="address">address.</param>
 /// <param name="phoneNumber">phone_number.</param>
 /// <param name="referenceId">reference_id.</param>
 /// <param name="note">note.</param>
 /// <param name="birthday">birthday.</param>
 /// <param name="version">version.</param>
 public UpdateCustomerRequest(
     string givenName       = null,
     string familyName      = null,
     string companyName     = null,
     string nickname        = null,
     string emailAddress    = null,
     Models.Address address = null,
     string phoneNumber     = null,
     string referenceId     = null,
     string note            = null,
     string birthday        = null,
     long?version           = null)
 {
     this.GivenName    = givenName;
     this.FamilyName   = familyName;
     this.CompanyName  = companyName;
     this.Nickname     = nickname;
     this.EmailAddress = emailAddress;
     this.Address      = address;
     this.PhoneNumber  = phoneNumber;
     this.ReferenceId  = referenceId;
     this.Note         = note;
     this.Birthday     = birthday;
     this.Version      = version;
 }
        public static IAddress ToAddress(this SearchResultItem result)
        {
            if (result != null)
            {
                var Address = new Models.Address();

                string FormattedAddress;

                FormattedAddress = result.FieldItems.TryGetValue("FULL_ADDRESS");

                var Index = Math.Max(0, FormattedAddress.IndexOf(result.FieldItems.TryGetValue("STREET") + ","));

                Address.Uprn = long.Parse(result.FieldItems.TryGetValue("UPRN") ?? null);
                //Address.Usrn = long.Parse(result.FieldItems.TryGetValue("USRN") ?? null);
                //Address.Organisation = result.FieldItems.TryGetValue("ORGANISATION");
                Address.Property = (!String.IsNullOrWhiteSpace(FormattedAddress) ? FormattedAddress.Substring(0, Index) : String.Empty).Trim().TrimEnd(',');
                Address.Street   = result.FieldItems.TryGetValue("STREET");
                Address.Locality = result.FieldItems.TryGetValue("LOCALITY");
                Address.Town     = result.FieldItems.TryGetValue("TOWN");
                Address.Area     = result.FieldItems.TryGetValue("POSTTOWN");
                Address.PostCode = result.FieldItems.TryGetValue("POSTCODE");

                return(Address);
            }
            return(null);
        }
Пример #21
0
        public ActionResult Create(int id, FormCollection collection)
        {
            try
            {
                // TODO: Add insert logic here
                Models.Address address = new Models.Address()
                {
                    person_id       = id,
                    description     = collection["description"],
                    street_address  = collection["street_address"],
                    city            = collection["city"],
                    province_state  = collection["province_state"],
                    zip_postal_code = collection["zip_postal_code"],
                    country_id      = Int32.Parse(collection["country_id"])
                };

                db.Addresses.Add(address);
                db.SaveChanges();
                return(RedirectToAction("Index", new { id = id }));
            }
            catch
            {
                return(View());
            }
        }
Пример #22
0
        public virtual async Task DeleteAddressAsync(int id)
        {
            Models.Address address = await GetAddressByIdAsync(id);

            _db.Entry(address).State = EntityState.Deleted;
            await _db.SaveChangesAsync();
        }
Пример #23
0
        public string AddAddress([FromBody] Models.Address address)
        {
            var status = "Adding address failed";

            try
            {
                EFModels.Address addressb = new EFModels.Address()
                {
                    Id                = address.Id,
                    Addressid         = address.Addressid,
                    Userid            = address.Userid,
                    Firstname         = address.Firstname,
                    Lastname          = address.Lastname,
                    Addresslineone    = address.Addresslineone,
                    Addresslinetwo    = address.Addresslinetwo,
                    Landmark          = address.Landmark,
                    City              = address.City,
                    Pincode           = address.Pincode,
                    State             = address.State,
                    Country           = address.Country,
                    Email             = address.Email,
                    Phone             = address.Phone,
                    Isshippingaddress = address.Isshippingaddress,
                };

                status = _UserFacade.AddAddress(addressb);
            }
            catch (Exception e)
            {
                status = e.Message;
                throw e;
            }
            return(status);
        }
Пример #24
0
        protected async Task Hide(Models.Address item)
        {
            await _addressService.HideAsync(item.Id);

            await SaveAsync();

            StateHasChanged();
        }
Пример #25
0
 public ActionResult BillingAddress(Models.Address address)
 {
     //set the billing address for the order to be this address
     this.MyOrder.BillingAddress = address;
     //save changes
     db.SaveChanges();
     return(RedirectToAction("Payment"));
 }
Пример #26
0
 public async Task AddAddress(Models.Address address)
 {
     using (ApplicationDbContext context = new ApplicationDbContext())
     {
         context.Addresses.Add(address);
         await context.SaveChangesAsync();
     }
 }
Пример #27
0
 public void CheckAddress2(Models.Address address)
 {
     // TODO: Create custom exception for required address line 2.
     if (address.AddressLine2 == null)
     {
         throw new Exception($"{nameof(address.AddressLine2)} is a required field for {address.CountryCode} addresses.");
     }
 }
 private PagarMe.Billing BillingFactory(Models.Customer customer, Models.Address address)
 {
     return(new PagarMe.Billing()
     {
         Name = customer.Name,
         Address = AddressFactory(address)
     });
 }
Пример #29
0
 public async Task EditAddress(Models.Address address)
 {
     using (ApplicationDbContext context = new ApplicationDbContext())
     {
         context.Entry(address).State = EntityState.Modified;
         await context.SaveChangesAsync();
     }
 }
Пример #30
0
        protected void Add()
        {
            Model = new Models.Address();

            Model.AppUserId     = UserId;
            _showAdd            = true;
            _isButtonAddVisible = false;
        }
        public ActionResult Shipping(string shippingRecipientName, string shippingStreet, string shippingZipCode, string shippingCity, int shippingCountryId
									, bool sameBillingAddress
									, int addressIndex
									, string billingRecipientName, string billingStreet, string billingZipCode, string billingCity, int billingCountryId
									, Models.RegistrationUser registrationUser
									, string emailConfirmation)
        {
            var cart = CartService.GetCurrentOrderCart(User.GetUserPrincipal());
            if (cart == null || cart.ItemCount == 0)
            {
                return RedirectToERPStoreRoute(ERPStoreRoutes.HOME);
            }

            var user = User.GetUserPrincipal().CurrentUser;
            ViewData.Model = cart;

            var shippingAddress = new Models.Address();
            var billingAddress = new Models.Address();
            Models.RegistrationUser registration = null;

            if (user == null)
            {
                shippingAddress.RecipientName = shippingRecipientName;
                shippingAddress.Street = shippingStreet;
                shippingAddress.ZipCode = shippingZipCode;
                shippingAddress.CountryId = shippingCountryId;
                shippingAddress.City = shippingCity;

                var shippingAddressBrokenrules = AccountService.ValidateUserAddress(shippingAddress, HttpContext);
                foreach (var item in shippingAddressBrokenrules)
                {
                    item.PropertyName = "shipping" + item.PropertyName;
                }
                ViewData.ModelState.AddModelErrors(shippingAddressBrokenrules);

                if (!sameBillingAddress)
                {
                    billingAddress.RecipientName = billingRecipientName;
                    billingAddress.Street = billingStreet;
                    billingAddress.ZipCode = billingZipCode;
                    billingAddress.CountryId = billingCountryId;
                    billingAddress.City = billingCity;

                    var billingAddressBrokenrules = AccountService.ValidateUserAddress(billingAddress, HttpContext);
                    foreach (var item in billingAddressBrokenrules)
                    {
                        item.PropertyName = "billing" + item.PropertyName;
                    }
                    ModelState.AddModelErrors(billingAddressBrokenrules);
                }

                // Pour passer tout test
                registrationUser.Password = (registrationUser.Password.IsNullOrTrimmedEmpty()) ? "1234567489abcdefg" : registrationUser.Password;

                var registrationUserBrokenRules = AccountService.ValidateRegistrationUser(registrationUser, HttpContext);
                ModelState.AddModelErrors(registrationUserBrokenRules);

                registration = AccountService.GetRegistrationUser(User.GetUserPrincipal().VisitorId);
                if (registration == null)
                {
                    // Ce cas ne doit etre possible normalement
                    registration = AccountService.CreateRegistrationUser();
                }

                if (registration.Email.IsNullOrTrimmedEmpty()
                    && (emailConfirmation.IsNullOrTrimmedEmpty()
                    || !registrationUser.Email.Equals(emailConfirmation, StringComparison.InvariantCultureIgnoreCase)))
                {
                    ModelState.AddModelError("emailConfirmation", "L'Email indiqué n'est pas confirmé");
                }

                // Adresse de livraison
                registration.ShippingAddressCity = shippingAddress.City;
                registration.ShippingAddressCountryId = shippingAddress.CountryId;
                registration.ShippingAddressRecipientName = shippingAddress.RecipientName;
                registration.ShippingAddressRegion = shippingAddress.Region;
                registration.ShippingAddressStreet = shippingAddress.Street;
                registration.ShippingAddressZipCode = shippingAddress.ZipCode;

                registration.IsSameBillingAddress = sameBillingAddress;
                if (!sameBillingAddress)
                {
                    // Adresse de facturation
                    registration.BillingAddressCity = billingAddress.City;
                    registration.BillingAddressCountryId = billingAddress.CountryId;
                    registration.BillingAddressRecipientName = billingAddress.RecipientName;
                    registration.BillingAddressRegion = billingAddress.Region;
                    registration.BillingAddressStreet = billingAddress.Street;
                    registration.BillingAddressZipCode = billingAddress.ZipCode;
                }

                // Informations sur la société
                registration.CorporateEmail = registrationUser.CorporateEmail;
                registration.CorporateFaxNumber = registrationUser.CorporateFaxNumber;
                registration.CorporateName = registrationUser.CorporateName;
                registration.CorporatePhoneNumber = registrationUser.CorporatePhoneNumber;
                registration.CorporateSocialStatus = registrationUser.CorporateSocialStatus;
                registration.CorporateWebSite = registrationUser.CorporateWebSite;
                registration.FaxNumber = registrationUser.FaxNumber;
                registration.NAFCode = registrationUser.NAFCode;
                registration.SiretNumber = registrationUser.SiretNumber;
                registration.VATNumber = registrationUser.TVANumber;
                registration.VatMandatory = registrationUser.VatMandatory;
                registration.RcsNumber = registrationUser.RcsNumber;

                // Informations personnelles
                registration.Email = registrationUser.Email;
                registration.FirstName = registrationUser.FirstName;
                registration.LastName = registrationUser.LastName;
                registration.MobileNumber = registrationUser.MobileNumber;
                // registration.Password = registrationUser.Password;
                registration.PhoneNumber = registrationUser.PhoneNumber;
                registration.PresentationId = registrationUser.PresentationId;
                registration.ReturnUrl = registrationUser.ReturnUrl;

                AccountService.SaveRegistrationUser(User.GetUserPrincipal().VisitorId, registration);
                user = AccountService.CreateUserFromRegistration(registration);
            }
            else
            {
                if (addressIndex == -1) // Cas d'une nouvelle adresse
                {
                    shippingAddress.RecipientName = shippingRecipientName;
                    shippingAddress.Street = shippingStreet;
                    shippingAddress.ZipCode = shippingZipCode;
                    shippingAddress.CountryId = shippingCountryId;
                    shippingAddress.City = shippingCity;

                    var shippingAddressBrokenrules = AccountService.ValidateUserAddress(shippingAddress, HttpContext);
                    foreach (var item in shippingAddressBrokenrules)
                    {
                        item.PropertyName = "shipping" + item.PropertyName;
                    }
                    ViewData.ModelState.AddModelErrors(shippingAddressBrokenrules);

                    if (ModelState.IsValid)
                    {
                        AddressService.SaveAddress(user, shippingAddress, true);
                    }
                }
            }

            ViewData["SelectedAddressId"] = addressIndex;

            Models.Address address = null;
            if (addressIndex == -1) // Nouvelle adresse
            {
                address = shippingAddress;
                user.DeliveryAddressList.Add(address);
            }
            else
            {
                address = user.DeliveryAddressList[addressIndex];
            }

            cart.DeliveryAddress = address;

            if (sameBillingAddress)
            {
                cart.BillingAddress = cart.DeliveryAddress;
            }
            else
            {
                cart.BillingAddress = user.DefaultAddress;
            }

            if (!ModelState.IsValid)
            {
                ViewData["RegistrationUser"] = registration;
                if (registration != null)
                {
                    return View("shipping");
                }
                else
                {
                    return View("connectedshipping");
                }
            }

            using (var ts = TransactionHelper.GetNewReadCommitted())
            {
                CartService.Save(cart);
                ts.Complete();
            }

            return RedirectToERPStoreRoute(ERPStoreRoutes.CHECKOUT_CONFIGURATION);
        }