Exemple #1
0
        public ManagerResponse <CustomerResult, bool> RemovePartiesFromUser(string userName, string addressExternalId)
        {
            Assert.ArgumentNotNullOrEmpty(addressExternalId, nameof(addressExternalId));

            var getUserResponse = GetUser(userName);

            if (getUserResponse.Result == null)
            {
                var customerResult = new CustomerResult {
                    Success = false
                };
                customerResult.SystemMessages.ToList().AddRange(getUserResponse.ServiceProviderResult.SystemMessages);
                return(new ManagerResponse <CustomerResult, bool>(customerResult, false));
            }

            var customer = new CommerceCustomer {
                ExternalId = getUserResponse.Result.ExternalId
            };
            var parties = new List <CommerceParty> {
                new CommerceParty {
                    ExternalId = addressExternalId
                }
            };

            return(RemoveParties(customer, parties));
        }
Exemple #2
0
        /// <summary>
        /// Removes the parties from current user.
        /// </summary>
        /// <param name="storefront">The storefront.</param>
        /// <param name="visitorContext">The visitor context.</param>
        /// <param name="addressExternalId">The address external identifier.</param>
        /// <returns>
        /// The manager response with the successflag in the Result.
        /// </returns>
        public virtual ManagerResponse <CustomerResult, bool> RemovePartiesFromCurrentUser([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] string addressExternalId)
        {
            Assert.ArgumentNotNull(storefront, "storefront");
            Assert.ArgumentNotNull(visitorContext, "visitorContext");
            Assert.ArgumentNotNullOrEmpty(addressExternalId, "addresseExternalId");

            var getUserResponse = this.GetUser(Context.User.Name);

            if (getUserResponse.Result == null)
            {
                var customerResult = new CustomerResult {
                    Success = false
                };
                customerResult.SystemMessages.ToList().AddRange(getUserResponse.ServiceProviderResult.SystemMessages);
                return(new ManagerResponse <CustomerResult, bool>(customerResult, false));
            }

            var customer = new CommerceCustomer {
                ExternalId = getUserResponse.Result.ExternalId
            };
            var parties = new List <CommerceParty> {
                new CommerceParty {
                    ExternalId = addressExternalId
                }
            };

            return(this.RemoveParties(storefront, customer, parties));
        }
Exemple #3
0
 public void AddParties_IfParameterIsNull_ShouldThrowArgumentNullException(
     CommerceCustomer customer,
     IEnumerable <Party> parties)
 {
     // act & assert
     Assert.Throws <ArgumentNullException>(() => this.accountManager.AddParties(customer, parties));
 }
Exemple #4
0
        public ManagerResponse <GetPartiesResult, IEnumerable <Party> > GetParties(CommerceCustomer customer)
        {
            var request = new GetPartiesRequest(customer);
            var parties = this.customerServiceProvider.GetParties(request);
            IEnumerable <Party> result = !parties.Success || (parties.Parties == null) ? new List <Party>() : parties.Parties;

            return(new ManagerResponse <GetPartiesResult, IEnumerable <Party> >(parties, result));
        }
        public AddPartiesResult AddParties(CommerceCustomer commerceCustomer, IEnumerable <Party> parties)
        {
            Assert.ArgumentNotNull(commerceCustomer, nameof(commerceCustomer));
            Assert.ArgumentNotNull(parties, nameof(parties));

            return(this.Execute(
                       new AddPartiesRequest(commerceCustomer, parties.ToList()),
                       this.customerServiceProvider.AddParties));
        }
Exemple #6
0
        public ManagerResponse <CustomerResult, bool> RemoveParties(CommerceCustomer user, List <CommerceParty> parties)
        {
            Assert.ArgumentNotNull(user, nameof(user));
            Assert.ArgumentNotNull(parties, nameof(parties));

            var request = new RemovePartiesRequest(user, parties.Cast <Party>().ToList());
            var result  = CustomerServiceProvider.RemoveParties(request);

            result.WriteToSitecoreLog();
            return(new ManagerResponse <CustomerResult, bool>(result, result.Success));
        }
Exemple #7
0
        public ManagerResponse <GetPartiesResult, IEnumerable <IParty> > GetParties(CommerceCustomer customer)
        {
            Assert.ArgumentNotNull(customer, nameof(customer));

            var request   = new GetPartiesRequest(customer);
            var result    = CustomerServiceProvider.GetParties(request);
            var partyList = result.Success && result.Parties != null?result.Parties.Select(p => p.ToEntity()) : new List <IParty>();

            result.WriteToSitecoreLog();
            return(new ManagerResponse <GetPartiesResult, IEnumerable <IParty> >(result, partyList));
        }
        public ManagerResponse <CustomerResult, IEnumerable <Party> > RemoveParties(CommerceCustomer customer, IEnumerable <Party> parties)
        {
            Assert.ArgumentNotNull(customer, nameof(customer));
            Assert.ArgumentNotNull(parties, nameof(parties));

            var removePartiesRequest = new RemovePartiesRequest(customer, parties.ToList());

            CustomerResult removePartiesResult = this.customerServiceProvider.RemoveParties(removePartiesRequest);

            return(new ManagerResponse <CustomerResult, IEnumerable <Party> >(removePartiesResult, null));
        }
        public ManagerResponse <AddPartiesResult, IEnumerable <Party> > AddParties(CommerceCustomer customer, IEnumerable <Party> parties)
        {
            Assert.ArgumentNotNull(customer, nameof(customer));
            Assert.ArgumentNotNull(parties, nameof(parties));

            var addPartiesRequest = new AddPartiesRequest(customer, parties.ToList());

            AddPartiesResult addPartiesResult = this.customerServiceProvider.AddParties(addPartiesRequest);

            return(new ManagerResponse <AddPartiesResult, IEnumerable <Party> >(addPartiesResult, addPartiesRequest.Parties));
        }
Exemple #10
0
        /// <summary>
        /// Initiates the link to existing customer.
        /// </summary>
        /// <param name="emailOfExistingCustomer">The email of existing customer.</param>
        /// <returns>
        /// The manager response where the customer is returned in the response.
        /// </returns>
        public virtual ManagerResponse <EnableCustomerResult, CommerceCustomer> InitiateLinkToExistingCustomer(string emailOfExistingCustomer)
        {
            Assert.ArgumentNotNullOrEmpty(emailOfExistingCustomer, "emailOfExistingCustomer");

            var customer = new CommerceCustomer()
            {
                Name = emailOfExistingCustomer
            };
            var request = new EnableCustomerRequest(customer);

            request.Comment = "Initiate";
            var result = this.CustomerServiceProvider.EnableCustomer(request);

            return(new ManagerResponse <EnableCustomerResult, CommerceCustomer>(result, result.CommerceCustomer));
        }
        public ActionResult RegisterExistingUser(CommerceCustomer commerceUser)
        {
            try
            {
                Assert.ArgumentNotNull(commerceUser, "commerceUser");
                RegisterBaseResultApiModel result = new RegisterBaseResultApiModel();

                var userResponse = this.AccountManager.GetUser(commerceUser.Name);
                if (userResponse.Result == null)
                {
                    // create the user in Sitecore
                    var inputModel = new RegisterUserInputModel {
                        UserName = commerceUser.Name, Password = System.Web.Security.Membership.GeneratePassword(8, 4)
                    };
                    inputModel.FirstName = commerceUser.Properties["FirstName"] as string ?? string.Empty;
                    inputModel.LastName  = commerceUser.Properties["LastName"] as string ?? string.Empty;
                    var response = this.AccountManager.RegisterUser(inputModel);
                    if (!response.ServiceProviderResult.Success || response.Result == null)
                    {
                        result.SetErrors(response.ServiceProviderResult);
                        return(this.Json(result, JsonRequestBehavior.AllowGet));
                    }
                }

                var isLoggedIn = this.AccountManager.Login(commerceUser.Name, false);
                if (isLoggedIn)
                {
                    return(this.Redirect("/"));
                }
                else
                {
                    result.SetErrors(new List <string> {
                        "Could not create user"
                    });
                }

                return(this.Json(result));
            }
            catch (Sitecore.Commerce.OpenIDConnectionClosedUnexpectedlyException)
            {
                this.CleanNotAuthorizedSession();
                return(this.Redirect("/login"));
            }
            catch (Exception e)
            {
                return(this.Json(new ErrorApiModel("Register", e), JsonRequestBehavior.AllowGet));
            }
        }
Exemple #12
0
        public ManagerResponse <GetPartiesResult, IEnumerable <Party> > GetCurrentCustomerParties(string shopName, string contactId)
        {
            var getPartiesResult = new GetPartiesResult();

            var user = this.GetUser(contactId);

            if (!user.ServiceProviderResult.Success || (user.Result == null))
            {
                return(new ManagerResponse <GetPartiesResult, IEnumerable <Party> >(getPartiesResult, null));
            }

            var customer = new CommerceCustomer
            {
                ExternalId = user.Result.ExternalId
            };

            return(this.GetParties(customer));
        }
Exemple #13
0
        public ManagerResponse <AddPartiesResult, bool> AddParties(string userName, List <IParty> parties)
        {
            Assert.ArgumentNotNull(userName, nameof(userName));
            Assert.ArgumentNotNull(parties, nameof(parties));

            var getUserResponse = GetUser(userName);

            if (getUserResponse.Result == null)
            {
                throw new ArgumentException("User not found, invalid userName", nameof(userName));
            }
            var customer = new CommerceCustomer {
                ExternalId = getUserResponse.Result.ExternalId
            };
            var request = new AddPartiesRequest(customer, parties.Select(a => a.ToCommerceParty()).ToList());
            var result  = CustomerServiceProvider.AddParties(request);

            result.WriteToSitecoreLog();

            return(new ManagerResponse <AddPartiesResult, bool>(result, result.Success));
        }
        public GetPartiesResult GetCustomerParties(string contactId)
        {
            Assert.ArgumentNotNullOrEmpty(contactId, nameof(contactId));

            var getUserResult = this.GetUser(contactId);

            if (!getUserResult.Success || getUserResult.CommerceUser == null)
            {
                return(new GetPartiesResult
                {
                    Parties = new List <Party>()
                });
            }

            var customer = new CommerceCustomer
            {
                ExternalId = getUserResult.CommerceUser.ExternalId
            };

            return(this.GetParties(customer));
        }
        private ActionResult GetRedirectionBasedOnAssociatedCustomer(string authToken, IdentityProviderType identityProviderType, string email)
        {
            OpenIdConnectUtilities.SetTokenCookie(authToken);

            var customerResult        = this.AccountManager.GetCustomer().ServiceProviderResult;
            CommerceCustomer customer = customerResult.CommerceCustomer;

            if (customerResult.Success && customer != null)
            {
                if (identityProviderType == IdentityProviderType.OpenIdConnect)
                {
                    OpenIdConnectUtilities.RemoveCookie(OpenIdConnectUtilities.CookieState);
                    OpenIdConnectUtilities.RemoveCookie(OpenIdConnectUtilities.CookieNonce);
                }

                return(this.RegisterExistingUser(customer));
            }
            else
            {
                string url = string.Format(CultureInfo.InvariantCulture, "/Register?isActivationPending={0}&email={1}", customerResult.Properties["IsRequestToLinkToExistingCustomerPending"], email);
                return(this.Redirect(url));
            }
        }
Exemple #16
0
        public ManagerResponse <CreateCustomerResult, CommerceCustomer> CreateCustomer(CommerceCustomer commerceCustomer)
        {
            Assert.ArgumentNotNull(commerceCustomer, nameof(commerceCustomer));

            var createCustomerRequest = new CreateCustomerRequest(commerceCustomer);

            var createCustomerResult = this.customerServiceProvider.CreateCustomer(createCustomerRequest);

            if (!createCustomerResult.Success)
            {
                Log.Warn("Create customer failed", this.GetType());
            }

            return(new ManagerResponse <CreateCustomerResult, CommerceCustomer>(
                       createCustomerResult,
                       createCustomerResult.CommerceCustomer));
        }
Exemple #17
0
        public JsonResult AddressModify(PartyInputModelItem model)
        {
            try
            {
                Assert.ArgumentNotNull(model, "model");

                var validationResult = new BaseJsonResult();
                this.ValidateModel(validationResult);
                if (validationResult.HasErrors)
                {
                    return(Json(validationResult, JsonRequestBehavior.AllowGet));
                }

                var addresses    = new List <CommerceParty>();
                var userResponse = this.AccountManager.GetUser(Context.User.Name);
                var result       = new AddressListItemJsonResult(userResponse.ServiceProviderResult);
                if (userResponse.ServiceProviderResult.Success && userResponse.Result != null)
                {
                    var commerceUser = userResponse.Result;
                    var customer     = new CommerceCustomer {
                        ExternalId = commerceUser.ExternalId
                    };
                    var party = new CommerceParty
                    {
                        ExternalId    = model.ExternalId,
                        Name          = model.Name,
                        Address1      = model.Address1,
                        City          = model.City,
                        Country       = model.Country,
                        State         = model.State,
                        ZipPostalCode = model.ZipPostalCode,
                        PartyId       = model.PartyId,
                        IsPrimary     = model.IsPrimary
                    };

                    if (string.IsNullOrEmpty(party.ExternalId))
                    {
                        // Verify we have not reached the maximum number of addresses supported.
                        int numberOfAddresses = this.AllAddresses(result).Count;
                        if (numberOfAddresses >= StorefrontManager.CurrentStorefront.MaxNumberOfAddresses)
                        {
                            var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.MaxAddressLimitReached);
                            result.Errors.Add(string.Format(CultureInfo.InvariantCulture, message, numberOfAddresses));
                            result.Success = false;
                        }
                        else
                        {
                            var response = this.AccountManager.AddParties(this.CurrentStorefront, customer, new List <CommerceParty> {
                                party
                            });
                            result.SetErrors(response.ServiceProviderResult);
                            if (response.ServiceProviderResult.Success)
                            {
                                addresses = this.AllAddresses(result);
                            }

                            result.Initialize(addresses, null);
                        }
                    }
                    else
                    {
                        var response = this.AccountManager.UpdateParties(this.CurrentStorefront, customer, new List <CommerceParty> {
                            party
                        });
                        result.SetErrors(response.ServiceProviderResult);
                        if (response.ServiceProviderResult.Success)
                        {
                            addresses = this.AllAddresses(result);
                        }

                        result.Initialize(addresses, null);
                    }
                }

                return(Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (Exception e)
            {
                CommerceLog.Current.Error("AddressModify", this, e);
                return(Json(new BaseJsonResult("AddressModify", e), JsonRequestBehavior.AllowGet));
            }
        }
        /// <summary>
        /// Removes the parties from current user.
        /// </summary>
        /// <param name="storefront">The storefront.</param>
        /// <param name="visitorContext">The visitor context.</param>
        /// <param name="addressExternalId">The address external identifier.</param>
        /// <returns>
        /// The manager response with the successflag in the Result.
        /// </returns>
        public virtual ManagerResponse<CustomerResult, bool> RemovePartiesFromCurrentUser([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] string addressExternalId)
        {
            Assert.ArgumentNotNull(storefront, "storefront");
            Assert.ArgumentNotNull(visitorContext, "visitorContext");
            Assert.ArgumentNotNullOrEmpty(addressExternalId, "addresseExternalId");

            var getUserResponse = this.GetUser(Context.User.Name);
            if (getUserResponse.Result == null)
            {
                var customerResult = new CustomerResult { Success = false };
                customerResult.SystemMessages.ToList().AddRange(getUserResponse.ServiceProviderResult.SystemMessages);
                return new ManagerResponse<CustomerResult, bool>(customerResult, false);
            }

            var customer = new CommerceCustomer { ExternalId = getUserResponse.Result.ExternalId };
            var parties = new List<CommerceParty> { new CommerceParty { ExternalId = addressExternalId } };

            return this.RemoveParties(storefront, customer, parties);
        }
        public AddressListItemJsonResult ModifyAddress(PartyInputModelItem model)
        {
            var addresses    = new List <CommerceParty>();
            var userResponse = this.AccountManager.GetUser(Context.User.Name);
            var result       = new AddressListItemJsonResult(userResponse.ServiceProviderResult);

            if (userResponse.ServiceProviderResult.Success && userResponse.Result != null)
            {
                var commerceUser = userResponse.Result;
                var customer     = new CommerceCustomer {
                    ExternalId = commerceUser.ExternalId
                };
                var party = new CommerceParty
                {
                    ExternalId    = model.ExternalId,
                    Name          = model.Name,
                    Address1      = model.Address1,
                    City          = model.City,
                    Country       = model.Country,
                    State         = model.State,
                    ZipPostalCode = model.ZipPostalCode,
                    PartyId       = model.PartyId,
                    IsPrimary     = model.IsPrimary
                };

                if (string.IsNullOrEmpty(party.ExternalId))
                {
                    // Verify we have not reached the maximum number of addresses supported.
                    var numberOfAddresses = this.AllAddresses(result).Count;

                    if (numberOfAddresses >= StorefrontManager.CurrentStorefront.MaxNumberOfAddresses)
                    {
                        var message = StorefrontManager.GetSystemMessage(StorefrontConstants.SystemMessages.MaxAddressLimitReached);
                        result.Errors.Add(string.Format(CultureInfo.InvariantCulture, message, numberOfAddresses));
                        result.Success = false;
                    }
                    else
                    {
                        party.ExternalId = Guid.NewGuid().ToString("B");

                        var response = this.AccountManager.AddParties(this.CurrentStorefront, customer, new List <Sitecore.Commerce.Entities.Party> {
                            party
                        });
                        result.SetErrors(response.ServiceProviderResult);
                        if (response.ServiceProviderResult.Success)
                        {
                            addresses = this.AllAddresses(result);
                        }

                        result.Initialize(addresses, null);
                    }
                }
                else
                {
                    var response = this.AccountManager.UpdateParties(this.CurrentStorefront, customer, new List <Sitecore.Commerce.Entities.Party> {
                        party
                    });
                    result.SetErrors(response.ServiceProviderResult);

                    if (response.ServiceProviderResult.Success)
                    {
                        addresses = this.AllAddresses(result);
                    }

                    result.Initialize(addresses, null);
                }
            }

            return(result);
        }
Exemple #20
0
        /// <summary>
        /// Adds the parties.
        /// </summary>
        /// <param name="storefront">The storefront.</param>
        /// <param name="user">The user.</param>
        /// <param name="parties">The parties.</param>
        /// <returns>The manager result where the success flag is returned as the Result.</returns>
        public virtual ManagerResponse <AddPartiesResult, bool> AddParties([NotNull] CommerceStorefront storefront, [NotNull] CommerceCustomer user, List <CommerceParty> parties)
        {
            Assert.ArgumentNotNull(storefront, "storefront");
            Assert.ArgumentNotNull(user, "user");
            Assert.ArgumentNotNull(parties, "parties");

            var request = new AddPartiesRequest(user, parties.Cast <Party>().ToList());
            var result  = this.CustomerServiceProvider.AddParties(request);

            if (!result.Success)
            {
                Helpers.LogSystemMessages(result.SystemMessages, result);
            }

            return(new ManagerResponse <AddPartiesResult, bool>(result, result.Success));
        }
Exemple #21
0
        /// <summary>
        /// Updates the parties.
        /// </summary>
        /// <param name="storefront">The storefront.</param>
        /// <param name="user">The user.</param>
        /// <param name="parties">The parties.</param>
        /// <returns>The manager result where the success flag is returned as the Result.</returns>
        public virtual ManagerResponse <CustomerResult, bool> UpdateParties([NotNull] CommerceStorefront storefront, [NotNull] CommerceCustomer user, List <Party> parties)
        {
            Assert.ArgumentNotNull(storefront, "storefront");
            Assert.ArgumentNotNull(user, "user");
            Assert.ArgumentNotNull(parties, "parties");

            var request = new UpdatePartiesRequest(user, parties);
            var result  = this._customerServiceProvider.UpdateParties(request);

            //            if (!result.Success)
            //            {
            //                Helpers.LogSystemMessages(result.SystemMessages, result);
            //            }

            return(new ManagerResponse <CustomerResult, bool>(result, result.Success));
        }
Exemple #22
0
        /// <summary>
        /// Gets the parties.
        /// </summary>
        /// <param name="storefront">The storefront.</param>
        /// <param name="user">The user.</param>
        /// <returns>The manager response where the list of parties is returned in the response.</returns>
        public virtual ManagerResponse <GetPartiesResult, IEnumerable <CommerceParty> > GetParties([NotNull] CommerceStorefront storefront, [NotNull] CommerceCustomer user)
        {
            Assert.ArgumentNotNull(storefront, "storefront");
            Assert.ArgumentNotNull(user, "user");

            var request   = new GetPartiesRequest(user);
            var result    = this.CustomerServiceProvider.GetParties(request);
            var partyList = result.Success && result.Parties != null ? (result.Parties).Cast <CommerceParty>() : new List <CommerceParty>();

            if (!result.Success)
            {
                Helpers.LogSystemMessages(result.SystemMessages, result);
            }

            return(new ManagerResponse <GetPartiesResult, IEnumerable <CommerceParty> >(result, partyList));
        }
        public ManagerResponse <UpdateCustomerResult, CommerceCustomer> UpdateCustomer(CommerceCustomer commerceCustomer)
        {
            Assert.ArgumentNotNull(commerceCustomer, nameof(commerceCustomer));

            var updateCustomerRequest = new UpdateCustomerRequest(commerceCustomer);

            UpdateCustomerResult updateCustomerResult =
                this.customerServiceProvider.UpdateCustomer(updateCustomerRequest);

            if (!updateCustomerResult.Success)
            {
                Log.Warn("Update customer failed", this.GetType());
            }

            return(new ManagerResponse <UpdateCustomerResult, CommerceCustomer>(updateCustomerResult, updateCustomerResult.CommerceCustomer));
        }
 public ManagerResponse <AddPartiesResult, bool> AddParties(CommerceStorefront storefront, CommerceCustomer user, List <Party> parties)
 {
     return(new ManagerResponse <AddPartiesResult, bool>(new AddPartiesResult {
         Success = true
     }, true));
 }
 public ManagerResponse <CustomerResult, bool> RemoveParties(CommerceStorefront storefront, CommerceCustomer user, List <CommerceParty> parties)
 {
     return(null);
 }
        public JsonResult AddressModify(PartyInputModelItem model)
        {
            try
            {
                Assert.ArgumentNotNull(model, "model");

                var validationResult = new BaseJsonResult();
                this.ValidateModel(validationResult);
                if (validationResult.HasErrors)
                {
                    return Json(validationResult, JsonRequestBehavior.AllowGet);
                }

                var addresses = new List<Models.CustomCommerceParty>();
                var userResponse = this.AccountManager.GetUser(Context.User.Name);
                var result = new AddressListItemJsonResult(userResponse.ServiceProviderResult);
                if (userResponse.ServiceProviderResult.Success && userResponse.Result != null)
                {
                    var commerceUser = userResponse.Result;
                    var customer = new CommerceCustomer { ExternalId = commerceUser.ExternalId };
                    var party = new Models.CustomCommerceParty
                                {
                                    ExternalId = model.ExternalId,
                                    Name = model.Name,
                                    Address1 = model.Address1,
                                    City = model.City,
                                    Country = model.Country,
                                    State = model.State,
                                    ZipPostalCode = model.ZipPostalCode,
                                    PartyId = model.PartyId,
                                    IsPrimary = model.IsPrimary
                                };

                    if (string.IsNullOrEmpty(party.ExternalId))
                    {
                        // Verify we have not reached the maximum number of addresses supported.
                        int numberOfAddresses = this.AllAddresses(result).Count;
                        if (numberOfAddresses >= StorefrontManager.CurrentStorefront.MaxNumberOfAddresses)
                        {
                            var message = StorefrontManager.GetSystemMessage("MaxAddresseLimitReached");
                            result.Errors.Add(string.Format(CultureInfo.InvariantCulture, message, numberOfAddresses));
                            result.Success = false;
                        }
                        else
                        {
                            var response = this.AccountManager.AddParties(this.CurrentStorefront, customer, new List<Models.CustomCommerceParty> { party });
                        result.SetErrors(response.ServiceProviderResult);
                        if (response.ServiceProviderResult.Success)
                        {
                            addresses = this.AllAddresses(result);
                        }

                        result.Initialize(addresses, null);
                    }
                    }
                    else
                    {
                        var response = this.AccountManager.UpdateParties(this.CurrentStorefront, customer, new List<Models.CustomCommerceParty> { party });
                        result.SetErrors(response.ServiceProviderResult);
                        if (response.ServiceProviderResult.Success)
                        {
                            addresses = this.AllAddresses(result);
                        }

                        result.Initialize(addresses, null);
                    }
                }

                return Json(result, JsonRequestBehavior.AllowGet);
            }
            catch (Exception e)
            {
                CommerceLog.Current.Error("AddressModify", this, e);
                return Json(new BaseJsonResult("AddressModify", e), JsonRequestBehavior.AllowGet);
            }
        }
 public ManagerResponse <CustomerResult, bool> UpdateParties(CommerceStorefront storefront, CommerceCustomer user, List <Party> parties)
 {
     if (parties.Any() && parties.Count(r => r.ExternalId.Equals("fake")) > 0)
     {
         return(new ManagerResponse <CustomerResult, bool>(new AddPartiesResult {
             Success = true
         }, true));
     }
     return(new ManagerResponse <CustomerResult, bool>(new AddPartiesResult {
         Success = false
     }, false));
 }
        public JsonResult AddressModify(PartyInputModelItem model)
        {
            try
            {
                Assert.ArgumentNotNull(model, nameof(model));

                var validationResult = this.CreateJsonResult();
                if (validationResult.HasErrors)
                {
                    return(this.Json(validationResult, JsonRequestBehavior.AllowGet));
                }

                var addresses = new List <IParty>();
                var user      = this.CommerceUserContext.Current;
                var result    = new AddressListItemApiModel();

                var customer = new CommerceCustomer {
                    ExternalId = user.UserId
                };
                var party = new Party
                {
                    ExternalId    = model.ExternalId,
                    FirstName     = model.Name,
                    LastName      = string.Empty,
                    Address1      = model.Address1,
                    City          = model.City,
                    Country       = model.Country,
                    State         = model.State,
                    ZipPostalCode = model.ZipPostalCode,
                    PartyId       = model.PartyId,
                    IsPrimary     = model.IsPrimary
                };

                if (string.IsNullOrEmpty(party.ExternalId))
                {
                    // Verify we have not reached the maximum number of addresses supported.
                    int numberOfAddresses = this.AllAddresses(result).Count;
                    if (numberOfAddresses >= this.MaxNumberOfAddresses)
                    {
                        var message = "Address limit reached";
                        result.Errors.Add(string.Format(CultureInfo.InvariantCulture, message, numberOfAddresses));
                        result.Success = false;
                    }
                    else
                    {
                        var response = this.AccountManager.AddParties(user.UserName, new List <IParty> {
                            model
                        });
                        result.SetErrors(response.ServiceProviderResult);
                        if (response.ServiceProviderResult.Success)
                        {
                            addresses = this.AllAddresses(result);
                        }

                        result.Initialize(addresses, null);
                    }
                }
                else
                {
                    var response = this.AccountManager.UpdateParties(user.UserName, new List <IParty> {
                        model
                    });
                    result.SetErrors(response.ServiceProviderResult);
                    if (response.ServiceProviderResult.Success)
                    {
                        addresses = this.AllAddresses(result);
                    }

                    result.Initialize(addresses, null);
                }

                return(this.Json(result, JsonRequestBehavior.AllowGet));
            }
            catch (OpenIDConnectionClosedUnexpectedlyException e)
            {
                this.CleanNotAuthorizedSession();
                return(this.Json(new ErrorApiModel("Login", e), JsonRequestBehavior.AllowGet));
            }
            catch (Exception e)
            {
                return(this.Json(new ErrorApiModel("AddressModify", e), JsonRequestBehavior.AllowGet));
            }
        }
 public ManagerResponse <GetPartiesResult, IEnumerable <CommerceParty> > GetParties(CommerceStorefront storefront, CommerceCustomer customer)
 {
     return(null);
 }
        public GetPartiesResult GetParties(CommerceCustomer commerceCustomer)
        {
            Assert.ArgumentNotNull(commerceCustomer, nameof(commerceCustomer));

            return(this.Execute(new GetPartiesRequest(commerceCustomer), this.customerServiceProvider.GetParties));
        }