public async Task Existing_Customer_Can_Be_Updated_With_Valid_Data()
{
//
// Arrange
//
var customer = new Customer
{
Id = Guid.NewGuid().ToString(),
FirstName = "cheranga",
LastName = "hatangala",
DateOfBirth = new DateTime(1982, 11, 1)
};
var mockedRepository = new Mock <ICustomerRepository>();
mockedRepository.Setup(x => x.UpdateCustomerAsync(It.IsAny <Customer>())).ReturnsAsync(OperationResult <Customer> .Success(customer));
var customerService = new CustomerService(mockedRepository.Object, Mock.Of <ILogger <CustomerService> >());
var existingCustomer = new CustomerUpdateModel(customer.Id, customer.FirstName, customer.LastName, customer.DateOfBirth);
var updateCustomerRequest = new UpdateCustomerRequest(existingCustomer);
//
// Act
//
var operationResult = await customerService.UpdateCustomerAsync(updateCustomerRequest);
//
// Assert
//
Assert.True(operationResult.Status);
Assert.Equal(existingCustomer.Id, operationResult.Data.Customer.Id);
}
public UpdateCustomerResponse UpdateCustomerByCustomer(UpdateCustomerRequest request)
{
var response = new UpdateCustomerResponse
{
IsSuccessful = false,
Message = ""
};
try
{
var customerToUpdate = _context.Customers
.Where(x => x.Id == request.CustomerToUpdate.Id)
.FirstOrDefault();
if (customerToUpdate != null)
{
customerToUpdate.Email = request.CustomerToUpdate.Email;
customerToUpdate.PhoneNumber = request.CustomerToUpdate.PhoneNumber;
_context.SaveChanges();
response.IsSuccessful = true;
}
}
catch (Exception ex)
{
response.Message = ex.ToString();
}
return(response);
}
public async void Run_GetCustomerTest()
{
ShowTestOnTerminal("GetCustomer");
UpdateCustomerRequest setupRequest = new UpdateCustomerRequest
{
Customer = new Customer
{
FirstName = "Test",
LastName = "Customer",
CompanyName = "Test Company",
EmailAddress = "*****@*****.**",
SmsNumber = "(123) 123-1234",
},
};
output.WriteLine("Setup request: {0}", setupRequest);
CustomerResponse setupResponse = await blockchyp.UpdateCustomerAsync(setupRequest);
output.WriteLine("Setup Response: {0}", setupResponse);
CustomerRequest request = new CustomerRequest
{
CustomerId = setupResponse.Customer.Id,
};
output.WriteLine("Request: {0}", request);
CustomerResponse response = await blockchyp.CustomerAsync(request);
output.WriteLine("Response: {0}", response);
Assert.True(response.Success, "response.Success");
}
public void UpdateCustomerRequestObject()
{
moq::Mock <CloudChannelService.CloudChannelServiceClient> mockGrpcClient = new moq::Mock <CloudChannelService.CloudChannelServiceClient>(moq::MockBehavior.Strict);
mockGrpcClient.Setup(x => x.CreateOperationsClient()).Returns(new moq::Mock <lro::Operations.OperationsClient>().Object);
UpdateCustomerRequest request = new UpdateCustomerRequest
{
Customer = new Customer(),
UpdateMask = new wkt::FieldMask(),
};
Customer expectedResponse = new Customer
{
CustomerName = CustomerName.FromAccountCustomer("[ACCOUNT]", "[CUSTOMER]"),
OrgDisplayName = "org_display_nameb29ddfcb",
OrgPostalAddress = new gt::PostalAddress(),
PrimaryContactInfo = new ContactInfo(),
AlternateEmail = "alternate_email3cdfc6ce",
Domain = "domaine8825fad",
CreateTime = new wkt::Timestamp(),
UpdateTime = new wkt::Timestamp(),
CloudIdentityId = "cloud_identity_idcb2e1526",
LanguageCode = "language_code2f6c7160",
CloudIdentityInfo = new CloudIdentityInfo(),
ChannelPartnerId = "channel_partner_ida548fd43",
};
mockGrpcClient.Setup(x => x.UpdateCustomer(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
CloudChannelServiceClient client = new CloudChannelServiceClientImpl(mockGrpcClient.Object, null);
Customer response = client.UpdateCustomer(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public Task<UpdateCustomerResponse> updateCustomer(UpdateCustomerRequest request)
{
UpdateCustomerCommand command = new UpdateCustomerCommand(
request.Id,
request.Name,
request.Note,
request.CartCode,
request.PhoneNumber,
request.Email,
request.Code,
request.Status,
request.Address.City,
request.Address.Country,
request.Address.District,
request.Address.Street,
request.Address.StreetNumber,
request.Address.Lat.ToString(),
request.Address.Lng.ToString()
);
Task<object> Customer = (Task<object>)Bus.SendCommand(command);
RabbitMQBus.Publish(command);
UpdateCustomerResponse response = new UpdateCustomerResponse();
response = Common<UpdateCustomerResponse>.checkHasNotification(_notifications, response);
if (response.Success)
{
bool result = (bool)Customer.Result;
response.Data = result;
}
return Task.FromResult(response);
}
public static Address SaveNewCustomerAddress(int customerID, Address address)
{
var addressesOnFile = ExigoDAL.GetCustomerAddresses(customerID).Where(c => c.IsComplete);
// Do any of the addresses on file match the one we are using?
// If not, save this address to the next available slot
if (!addressesOnFile.Any(c => c.Equals(address)))
{
var saveAddress = false;
var request = new UpdateCustomerRequest();
request.CustomerID = customerID;
// Main address
if (!addressesOnFile.Any(c => c.AddressType == AddressType.Main))
{
saveAddress = true;
address.AddressType = AddressType.Main;
request.MainAddress1 = address.Address1;
request.MainAddress2 = address.Address2;
request.MainCity = address.City;
request.MainState = address.State;
request.MainZip = address.Zip;
request.MainCountry = address.Country;
}
// Mailing address
else if (!addressesOnFile.Any(c => c.AddressType == AddressType.Mailing))
{
saveAddress = true;
address.AddressType = AddressType.Mailing;
request.MailAddress1 = address.Address1;
request.MailAddress2 = address.Address2;
request.MailCity = address.City;
request.MailState = address.State;
request.MailZip = address.Zip;
request.MailCountry = address.Country;
}
// Other address
else
{
saveAddress = true;
address.AddressType = AddressType.Other;
request.OtherAddress1 = address.Address1;
request.OtherAddress2 = address.Address2;
request.OtherCity = address.City;
request.OtherState = address.State;
request.OtherZip = address.Zip;
request.OtherCountry = address.Country;
}
if (saveAddress)
{
ExigoDAL.WebService().UpdateCustomer(request);
ExigoDAL.PurgeCustomer(customerID);
}
}
return(address);
}
public override void UpdateUser(MembershipUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
var request = new UpdateCustomerRequest(ConvertToCustomer(user))
{
ScopeId = GetCurrentScope()
};
try
{
var customer = _client.Send(request);
user.Email = customer.Email;
user.IsApproved = customer.AccountStatus != AccountStatus.RequiresApproval;
user.LastActivityDate = customer.LastActivityDate;
user.LastLoginDate = customer.LastLoginDate;
}
catch (WebException ex)
{
throw new ProviderException(ex.Message, ex);
}
catch (WebServiceException ex)
{
throw new ProviderException(ex.ErrorMessage, ex);
}
}
public static Address SetCustomerAddressOnFile(int customerID, Address address, AddressType type)
{
var saveAddress = false;
var request = new UpdateCustomerRequest();
request.CustomerID = customerID;
// Attempt to validate the user's entered address if US address
address = GlobalUtilities.ValidateAddress(address) as Address;
// New Addresses
if (type == AddressType.New)
{
return(ExigoDAL.SaveNewCustomerAddress(customerID, address));
}
// Main address
if (type == AddressType.Main)
{
saveAddress = true;
request.MainAddress1 = address.Address1;
request.MainAddress2 = address.Address2 ?? string.Empty;
request.MainCity = address.City;
request.MainState = address.State;
request.MainZip = address.Zip;
request.MainCountry = address.Country;
}
// Mailing address
if (type == AddressType.Mailing)
{
saveAddress = true;
request.MailAddress1 = address.Address1;
request.MailAddress2 = address.Address2 ?? string.Empty;
request.MailCity = address.City;
request.MailState = address.State;
request.MailZip = address.Zip;
request.MailCountry = address.Country;
}
// Other address
if (type == AddressType.Other)
{
saveAddress = true;
request.OtherAddress1 = address.Address1;
request.OtherAddress2 = address.Address2 ?? string.Empty;
request.OtherCity = address.City;
request.OtherState = address.State;
request.OtherZip = address.Zip;
request.OtherCountry = address.Country;
}
if (saveAddress)
{
ExigoDAL.WebService().UpdateCustomer(request);
ExigoDAL.PurgeCustomer(customerID);
}
return(address);
}
public UpdateCustomerResponse UpdateCustomer(UpdateCustomerRequest updateCustomerRequest)
{
try
{
Customer existingCustomer = _customerRepository.FindBy(updateCustomerRequest.Id);
if (existingCustomer != null)
{
Customer assignableProperties = AssignAvailablePropertiesToDomain(updateCustomerRequest.CustomerProperties);
existingCustomer.CustomerAddress = assignableProperties.CustomerAddress;
existingCustomer.Name = assignableProperties.Name;
ThrowExceptionIfCustomerIsInvalid(existingCustomer);
_customerRepository.Update(existingCustomer);
_unitOfWork.Commit();
return(new UpdateCustomerResponse());
}
else
{
return(new UpdateCustomerResponse()
{
Exception = GetStandardCustomerNotFoundException()
});
}
}
catch (Exception ex)
{
return(new UpdateCustomerResponse()
{
Exception = ex
});
}
}
public async Task TestSuccess()
{
// Arrange
Guid id = new Guid("b7c2acaa-ad72-47b3-b858-26357cf14fbb");
Customer customer = new Customer()
{
Id = id, Name = "Customer"
};
Mock <IDataRepository <Customer, Guid> > mockRepository = new Mock <IDataRepository <Customer, Guid> >();
mockRepository.Setup(m => m.FindAsync(id, default)).ReturnsAsync(customer);
string name = "Unit Test";
UpdateCustomerRequest request = new UpdateCustomerRequest()
{
Id = id, Name = name
};
UpdateCustomerCommand sut = new UpdateCustomerCommand(MockHelpers.GetLogger <UpdateCustomerCommand>(), mockRepository.Object);
// Act
UpdateCustomerResponse result = await sut.Handle(request, default);
// Assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.Customer);
Assert.AreEqual(name, result.Customer.Name);
mockRepository.VerifyAll();
mockRepository.Verify(m => m.FindAsync(id, default), Times.Once);
}
public string UpdateCustomerMethod(UpdateCustomerRequest ObjUpdateCustomerRequest)
{
DateTime date = DateTime.Now;
string connectionstring = "data source=.;" + "database=Binoy;" + "Integrated Security=true";
SqlConnection connection = new SqlConnection(connectionstring);
connection.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "updatecustomer_s2por";
cmd.Connection = connection;
cmd.Parameters.AddWithValue("@Customer_ID", ObjUpdateCustomerRequest.Customer_Id);
cmd.Parameters.AddWithValue("@Customer_SSN_ID", ObjUpdateCustomerRequest.Customer_ssn_Id);
cmd.Parameters.AddWithValue("@Customer_Name", ObjUpdateCustomerRequest.Customer_Name);
cmd.Parameters.AddWithValue("@Customer_Age", ObjUpdateCustomerRequest.Customer_Age);
cmd.Parameters.AddWithValue("@Customer_Address", ObjUpdateCustomerRequest.Customer_Address);
cmd.Parameters.AddWithValue("@Customer_State", ObjUpdateCustomerRequest.Customer_State);
cmd.Parameters.AddWithValue("@Customer_City", ObjUpdateCustomerRequest.Customer_City);
cmd.Parameters.AddWithValue("@Update_date", date);
string result = cmd.ExecuteNonQuery().ToString();
connection.Close();
return(result);
}
private bool UpdateUserAccountStatus(string username, AccountStatus newStatus)
{
if (username == null)
{
throw new ArgumentNullException("username");
}
try
{
var customer = GetCustomerByUsername(username);
if (customer == null)
{
throw new InvalidOperationException(string.Format("This customer with username {0} doesn't exist.", username));
}
var updateRequest = new UpdateCustomerRequest(customer)
{
AccountStatus = newStatus,
ScopeId = GetCurrentScope()
};
var updatedCustomer = _client.Send(updateRequest);
return(updatedCustomer.AccountStatus == newStatus);
}
catch (WebException ex)
{
throw new ProviderException(ex.Message, ex);
}
catch (WebServiceException ex)
{
throw new ProviderException(ex.ErrorMessage, ex);
}
}
public async Task UpdateCustomer_ValidRequest_ReturnsResponse()
{
var customerRecord = _customerRecords[0];
var updateRequest = new UpdateCustomerRequest
{
Id = customerRecord.Id,
FirstName = "New first name",
LastName = "New last name",
};
var updateResponse = await Fixture.Customers.UpdateCustomerAsync(updateRequest);
Assert.Equal(updateRequest.Id, updateResponse.Id);
Assert.Equal(updateRequest.FirstName, updateResponse.FirstName);
Assert.Equal(updateRequest.LastName, updateResponse.LastName);
var findRequest = new FindCustomerRequest {
Id = updateRequest.Id
};
var findResponse = await Fixture.Customers.FindCustomerAsync(findRequest);
Assert.Equal(updateResponse.Id, findResponse.Id);
Assert.Equal(updateResponse.FirstName, findResponse.FirstName);
Assert.Equal(updateResponse.LastName, findResponse.LastName);
}
public async Task Cannot_Update_Customer_With_Invalid_Data()
{
//
// Arrange
//
var customerService = GetCustomerService();
var idNullCustomer = new UpdateCustomerRequest(new CustomerUpdateModel(null, "firstname", "lastname", DateTime.Now.AddYears(-20)));
var idEmptyCustomer = new UpdateCustomerRequest(new CustomerUpdateModel("", "firstname", "lastname", DateTime.Now.AddYears(-20)));
var firstNameNullCustomer = new UpdateCustomerRequest(new CustomerUpdateModel(Guid.NewGuid().ToString(), null, "lastname", DateTime.Now.AddYears(-20)));
var lastNameNullCustomer = new UpdateCustomerRequest(new CustomerUpdateModel(Guid.NewGuid().ToString(), "firstname", null, DateTime.Now.AddYears(-20)));
var firstNameEmptyCustomer = new UpdateCustomerRequest(new CustomerUpdateModel(Guid.NewGuid().ToString(), "", "lastname", DateTime.Now.AddYears(-20)));
var lastNameEmptyCustomer = new UpdateCustomerRequest(new CustomerUpdateModel(Guid.NewGuid().ToString(), "firstname", "", DateTime.Now.AddYears(-20)));
var firstNameWithSpacesCustomer = new UpdateCustomerRequest(new CustomerUpdateModel(Guid.NewGuid().ToString(), " ", "lastname", DateTime.Now.AddYears(-20)));
var lastNameWithSpacesCustomer = new UpdateCustomerRequest(new CustomerUpdateModel(Guid.NewGuid().ToString(), "firstname", " ", DateTime.Now.AddYears(-20)));
var futureCustomer = new UpdateCustomerRequest(new CustomerUpdateModel(Guid.NewGuid().ToString(), "firstname", "lastname", DateTime.Now.AddYears(1)));
var invalidRequests = new[]
{
idNullCustomer, idEmptyCustomer,
firstNameNullCustomer, lastNameNullCustomer, firstNameEmptyCustomer, lastNameEmptyCustomer,
firstNameWithSpacesCustomer, lastNameWithSpacesCustomer, futureCustomer
};
//
// Act
//
var tasks = invalidRequests.Select(x => customerService.UpdateCustomerAsync(x));
var operationResults = await Task.WhenAll(tasks);
//
// Assert
//
Assert.False(operationResults.All(x => x.Status));
}
public async Task <GetCustomerResponse> UpdateCustomer(Guid id, UpdateCustomerRequest dto)
{
var customer = await _unitOfWork.Customers.Get(id);
// validate
if (customer is null)
{
throw new KeyNotFoundException();
}
if (!string.IsNullOrEmpty(dto.CompanyName) && customer.CompanyName != dto.CompanyName)
{
if (await _unitOfWork.Customers.GetByCompanyName(dto.CompanyName) is not null)
{
throw new AppException($"Customer '{dto.CompanyName}' already exists.");
}
customer.CompanyName = dto.CompanyName;
}
if (!string.IsNullOrEmpty(dto.VatNumber) && customer.VatNumber != dto.VatNumber)
{
customer.VatNumber = dto.VatNumber;
}
_unitOfWork.Commit();
return(_mapper.Map <GetCustomerResponse>(customer));
}
public UpdateCustomerResponse UpdateCustomer(int id, [FromBody] UpdateCustomerRequest request)
{
return(new UpdateCustomerResponse
{
Error = _customerService.UpdateCustomer(id, request)
});
}
public UpdateCustomerResponse UpdateCustomer(UpdateCustomerRequest request)
{
AdministrationServiceDAO adminDAO = new AdministrationServiceDAO();
bool result = adminDAO.UpdateCustomer(request.customer);
return(new UpdateCustomerResponse(result));
}
public BaseResponse <GetCustomerResponse> UpdateCustomer(string customerId, UpdateCustomerRequest request)
{
var method = HttpMethod.Put;
var endpoint = $"/customers/{customerId}";
return(this.HttpClientUtil.SendRequest <GetCustomerResponse>(method, endpoint, request));
}
private static async Task UpdateCustomer(CustomerServiceDefinition.CustomerServiceDefinitionClient customerClient)
{
var input = new UpdateCustomerRequest {
Id = 2, Name = "CIB2"
};
var reply = await customerClient.UpdateCustomerAsync(input);
}
protected void btnUpdateCreditCard_Click(object sender, EventArgs e)
{
if (!this.CreditCardInput1.IsValid())
{
this.MessageBox1.ShowWarning("Please check your credit card information is valid before attempting to update.");
return;
}
UserAccount u = GetCorrectUser();
var billManager = new BillingManager(this.MTApp);
var updateRequest = new UpdateCustomerRequest();
updateRequest.CreditCard = this.CreditCardInput1.GetCardData();
updateRequest.CustomerId = this.MTApp.CurrentStore.StripeCustomerId;
updateRequest.PostalCode = this.txtZipCode.Text.Trim();
var res = billManager.UpdateCustomer(updateRequest);
if (!res.Success)
{
this.MessageBox1.ShowWarning("Unable to update card: " + res.Message);
return;
}
this.MessageBox1.ShowOk("Credit card information updated!");
}
static async Task Main(string[] args)
{
HelloWorldClient.Hello("Shahid");
await CustomersMaintClient.CreateCustomers(2);
var update = new UpdateCustomerRequest
{
Id = "e3cf5ae6-d149-4b80-8bd8-aea03f2b0754",
FirstName = "Shahid Ali",
LastName = "Khan",
Address = "Charsadda, Pakistan",
Phone = "123490000"
};
await CustomersMaintClient.UpdateCustomer(update);
await CustomersMaintClient.GetAllCustomers();
await CustomersMaintClient.DeleteCustomer("e3cf5ae6-d149-4b80-8bd8-aea03f2b0754");
await CustomersMaintClient.GetAllCustomers();
await CustomersMaintClient.DeleteAllCustomers();
await CustomersMaintClient.GetAllCustomers();
await CustomersMaintClient.CreateCustomers(10);
await CustomersMaintClient.GetAllCustomers();
Console.ReadLine();
}
public ExecuteResult <CustomerInfoResponse> Update(UpdateCustomerRequest request)
{
var user = _customerRepository.GetItem(request.AuthUid);
if (user == null)
{
return(new ExecuteResult <CustomerInfoResponse>(null)
{
StatusCode = StatusCode.ClientError, Message = "参数错误"
});
}
user.Nickname = request.Nickname ?? String.Empty;
user.UpdatedDate = DateTime.Now;
user.UpdatedUser = request.AuthUid;
user.Gender = request.Gender ?? 0;
user.Description = request.Desc ?? String.Empty;
user.Mobile = request.Mobile ?? String.Empty;
_customerRepository.Update(user);
return(GetUserInfo(new GetUserInfoRequest
{
AuthUid = request.AuthUid,
AuthUser = request.AuthUser,
Method = request.Method,
Token = request.Token,
Client_Version = request.Client_Version
}));
}
public string UpdateCustomer(UpdateCustomerRequest ObjUpdateCustomerRequest)
{
CustomerServiceMethods ObjCustomerServiceMethods = new CustomerServiceMethods();
string CustomerId = ObjCustomerServiceMethods.UpdateCustomerMethod(ObjUpdateCustomerRequest);
return(CustomerId);
}
private static void OnUpdateCustomerExecuting(UpdateCustomerRequest request)
{
// Check for permissions if a new shipping address is being added.
if (request.UpdatedCustomer.Addresses.Any(a => a.RecordId == 0))
{
request.RequestContext.Execute <NullResponse>(new CheckAccessServiceRequest(RetailOperation.ShippingAddressAdd));
}
}
/// <summary>
/// Updates the customer.
/// </summary>
/// <param name="request">The request.</param>
/// <returns></returns>
public UpdateCustomerResponse UpdateCustomer(UpdateCustomerRequest request)
{
CustomerService service = new CustomerService();
UpdateCustomerResponse response = new UpdateCustomerResponse();
response.IsFailed = !(service.UpdateCustomer(request.MyCustomer));
return(response);
}
/// <summary>
/// Updates the customer. --Robin
/// </summary>
/// <param name="customerBE">The customer BE.</param>
/// <returns></returns>
public bool UpdateCustomer(CustomerBE customerBE)
{
UpdateCustomerRequest request = new UpdateCustomerRequest();
request.MyCustomer = customerBE;
UpdateCustomerResponse response = MyChannelFactory.CreateChannel().UpdateCustomer(request);
return(!response.IsFailed);
}
public async Task <HttpResponseMessage> UpdateACustomer(UpdateCustomerRequest request)
{
var update = JsonConvert.SerializeObject(request);
var content = new StringContent(update, Encoding.UTF8, "Application/json");
var requestUrl = "https://localhost:44319/api/Customer" + $"/{request.Id}";
var result = await _httpClient.PutAsync(requestUrl, content);
return(result);
}
private UpdateCustomerRequest Request_UpdateCustomerPassword()
{
var request = new UpdateCustomerRequest();
request.CustomerID = Identity.Current.CustomerID;
request.LoginPassword = NewPassword;
return request;
}
private UpdateCustomerRequest Request_UpdateCustomerLoginName()
{
var request = new UpdateCustomerRequest();
request.CustomerID = Identity.Current.CustomerID;
request.LoginName = NewLoginName;
return request;
}
public async Task <Customer> UpdateCustomerAsync(long id, UpdateCustomerRequest updateCustomerRequest)
{
ValidateModel(updateCustomerRequest);
var response = await PutAsJsonAsync($"/customers/{id}", JsonConvert.SerializeObject(updateCustomerRequest)).ConfigureAwait(false);
return(JsonConvert.DeserializeObject <CustomerResponse>(
await response.Content.ReadAsStringAsync().ConfigureAwait(false)).Customer);
}
public void NotAllowLastName_When_FirstName_IsNull()
{
var updateRequest = new UpdateCustomerRequest
{
LastName = "aaaa"
};
_validators.Validate(updateRequest).IsValid.Should().BeFalse();
}
private void btnSave_Click(object sender, EventArgs e)
{
var customer = this.Customer.Clone();
this.CollectData<Customer>(customer);
UpdateCustomerRequest request = new UpdateCustomerRequest();
request.token = Token;
request.form = customer;
SDKSync<CommonResponse>.CreateInstance(this).Execute(request, Save_Callback);
}
public void NotAllowRangeFirstNameMaxLength()
{
var updateRequest = new UpdateCustomerRequest
{
FirstName = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
};
_validators.Validate(updateRequest).IsValid.Should().BeFalse();
}
/// <remarks/>
public void UpdateCustomerAsync(UpdateCustomerRequest UpdateCustomerRequest) {
this.UpdateCustomerAsync(UpdateCustomerRequest, null);
}
private UpdateCustomerRequest Request_UpdateCustomer()
{
var request = new UpdateCustomerRequest();
request.CustomerID = Identity.Current.CustomerID;
request.FirstName = FirstName;
request.LastName = LastName;
request.Company = Company;
request.Email = Email;
request.Phone = Phone;
request.Phone2 = Phone2;
request.MobilePhone = MobilePhone;
request.BirthDate = BirthDate;
request.MainCountry = Country;
request.MainAddress1 = Address1;
request.MainAddress2 = Address2;
request.MainCity = City;
request.MainState = State;
request.MainZip = Zip;
return request;
}
public bool UpdateCustomer(CustomerInformation cinfo)
{
global::CustomerInformation ci = new global::CustomerInformation();
ci.CompanyName = cinfo.CompanyName;
ci.EMail = cinfo.EMail;
ci.FirstName = cinfo.FirstName;
ci.LastModified = Convert.ToDateTime(cinfo.LastModified);
ci.LastModifiedSpecified = true;
ci.LastName = cinfo.LastName;
ci.Notes = cinfo.Notes;
ci.PhoneNumber = cinfo.PhoneNumber;
ci.SQLID = cinfo.SQLID;
ci.SQLIDSpecified = true;
UpdateCustomerRequest ucreq = new UpdateCustomerRequest(ci);
Task<UpdateCustomerResponse> ucres = _sqlService.UpdateCustomerAsync(ucreq);
return ucres.Result.UpdateCustomerResult;
}
/// <summary>
/// Will update the customer record for Field13 (Wealth Club Level) to reflect upgrade/downgrade of Wealth Club Pack
/// </summary>
/// <param name="level"></param>
public void ChangeUserWealthClubLevel(string level, int CustomerID)
{
var context = ExigoApiContext.CreateWebServiceContext();
UpdateCustomerRequest req = new UpdateCustomerRequest();
req.CustomerID = CustomerID;
req.Field13 = level;
SuperUserPermissionLevel_1 = level; // Property ID5
UpdateCustomerResponse res = context.UpdateCustomer(req);
}
/// <remarks/>
public void UpdateCustomerAsync(UpdateCustomerRequest UpdateCustomerRequest, object userState) {
if ((this.UpdateCustomerOperationCompleted == null)) {
this.UpdateCustomerOperationCompleted = new System.Threading.SendOrPostCallback(this.OnUpdateCustomerOperationCompleted);
}
this.InvokeAsync("UpdateCustomer", new object[] {
UpdateCustomerRequest}, this.UpdateCustomerOperationCompleted, userState);
}
