/// <summary>
/// Login
/// </summary>
/// <param name="emailAddress"></param>
/// <param name="password"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Customer Login(string emailAddress, string password, out TransactionalBase transaction)
{
transaction = new TransactionalBase();
Customer customer = new Customer();
try
{
customer = _customerDataService.GetAll().Where(a => a.EmailAddress == emailAddress).FirstOrDefault();
if (customer == null || customer.Password != password)
{
transaction.ReturnMessage.Add("Invalid Login .... Please Try Again");
transaction.ReturnStatus = false;
return(customer);
}
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Successfully Logged In ....");
}
catch (Exception ex)
{
string errorMessage = ex.Message;
transaction.ReturnMessage.Add(errorMessage);
transaction.ReturnStatus = false;
}
finally
{
}
return(customer);
}
/// <summary>
/// Authenicate
/// </summary>
/// <param name="userID"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Customer Authenticate(Guid customerID, out TransactionalBase transaction)
{
transaction = new TransactionalBase();
Customer customer = new Customer();
try
{
customer = _customerDataService.GetAll().Where(a => a.Id == customerID).FirstOrDefault();
if (customer == null)
{
transaction.ReturnMessage.Add("Invalid session");
transaction.ReturnStatus = false;
return(customer);
}
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Valid session.");
}
catch (Exception ex)
{
string errorMessage = ex.Message;
transaction.ReturnMessage.Add(errorMessage);
transaction.ReturnStatus = false;
}
finally
{
}
return(customer);
}
public IActionResult Login(HttpRequestMessage request, [FromBody] CustomerModel customerModel)
{
TransactionalBase transaction = new TransactionalBase();
string emailAddress = customerModel.EmailAddress;
string password = customerModel.Password;
CustomerBusinessService customerBusinessService = new CustomerBusinessService(_customerDataService);
Customer customer = customerBusinessService.Login(emailAddress, password, out transaction);
if (transaction.ReturnStatus == false)
{
return(new ObjectResult(transaction));
}
string tokenString = TokenManager.CreateToken(customer.Id);
customerModel.Id = customer.Id;
customerModel.EmailAddress = customer.EmailAddress;
customerModel.FirstName = customer.FirstName;
customerModel.LastName = customer.LastName;
customerModel.IsAuthenticated = true;
customerModel.Token = tokenString;
customerModel.ReturnStatus = true;
customerModel.ReturnMessage = transaction.ReturnMessage;
customerModel.Token = tokenString;
return(new ObjectResult(customerModel));
}
public IActionResult DeleteAddress(HttpRequestMessage request, [FromBody] AddressModel addressInformation)
{
TransactionalBase transaction = new TransactionalBase();
AddressBusinessService addressBusinessService = new AddressBusinessService(_addressDataService);
addressBusinessService.DeleteAddress(addressInformation, out transaction);
return(new ObjectResult(transaction));
}
/// <summary>
/// Register Customer
/// </summary>
/// <param name="customerInformation"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public void RegisterCustomer(CustomerModel customerModel, out Guid custID, out TransactionalBase transaction)
{
transaction = new TransactionalBase();
Customer customer = new Customer();
try
{
customer.EmailAddress = customerModel.EmailAddress;
customer.FirstName = customerModel.FirstName;
customer.LastName = customerModel.LastName;
customer.Password = customerModel.Password;
customer.MobileNumber = customerModel.MobileNumber;
customer.CreatedByIp = customerModel.IpAddress;
customer.CreatedOn = DateTime.Now;
customer.UpdatedByIp = null;
customer.UpdatedOn = null;
customer.VisitCount = 1;
customer.IsEmailVerified = false;
customer.TransCount = 0;
customer.LastLogin = DateTime.Now;
CustomerBusinessRules customerBusinessRules = new CustomerBusinessRules(_customerDataService, customer);
ValidationResult results = customerBusinessRules.Validate(customer);
bool validationSucceeded = results.IsValid;
IList <ValidationFailure> failures = results.Errors;
if (validationSucceeded == false)
{
transaction = ValidationErrors.PopulateValidationErrors(failures);
}
_customerDataService.Add(customer);
_customerDataService.Commit();
custID = customer.Id;
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Customer successfully Added.");
}
catch (Exception ex)
{
string errorMessage = ex.Message;
transaction.ReturnMessage.Add(errorMessage);
transaction.ReturnStatus = false;
}
finally
{
}
}
public void DeleteAddress(AddressModel addressInformation, out TransactionalBase transaction)
{
transaction = new TransactionalBase();
try
{
_addressDataService.DeleteWhere(a => a.Id == addressInformation.Id);
_addressDataService.Commit();
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Address Deletee updated.");
}
catch (Exception ex)
{
transaction.ReturnStatus = false;
transaction.ReturnMessage.Add(ex.Message);
}
}
public IActionResult UpdateProfile(HttpRequestMessage request, [FromBody] CustomerModel customerInformation)
{
TransactionalBase transaction = new TransactionalBase();
if (request.Headers.Authorization == null)
{
transaction.ReturnMessage.Add("Your are not authorized");
transaction.ReturnStatus = false;
return(new ObjectResult(transaction));
}
string tokenString = request.Headers.Authorization.ToString();
ClaimsPrincipal principal = TokenManager.ValidateToken(tokenString);
if (principal == null)
{
transaction.ReturnMessage.Add("Your are not authorized");
transaction.ReturnStatus = false;
return(new ObjectResult(transaction));
}
Guid userID = TokenManager.GetUserID(Request.Headers["Authorization"].ToString());
if (userID == Guid.Empty)
{
transaction.ReturnMessage.Add("Your are not authorized");
transaction.ReturnStatus = false;
return(new ObjectResult(transaction));
}
customerInformation.Id = userID;
CustomerBusinessService userBusinessService = new CustomerBusinessService(_customerDataService);
userBusinessService.UpdateProfile(customerInformation, out transaction);
if (transaction.ReturnStatus == false)
{
return(new ObjectResult(transaction));
}
customerInformation.ReturnStatus = transaction.ReturnStatus;
customerInformation.ReturnMessage = transaction.ReturnMessage;
customerInformation.Token = tokenString;
return(new ObjectResult(customerInformation));
}
/// <summary>
/// Populate Validation Errors
/// </summary>
/// <param name="failures"></param>
/// <returns></returns>
public static TransactionalBase PopulateValidationErrors(IList <ValidationFailure> failures)
{
TransactionalBase transaction = new TransactionalBase();
transaction.ReturnStatus = false;
foreach (ValidationFailure error in failures)
{
if (transaction.ValidationErrors.ContainsKey(error.PropertyName) == false)
{
transaction.ValidationErrors.Add(error.PropertyName, error.ErrorMessage);
}
transaction.ReturnMessage.Add(error.ErrorMessage);
}
return(transaction);
}
public IActionResult UpdateAddress(HttpRequestMessage request, [FromBody] AddressModel addressInformation)
{
TransactionalBase transaction = new TransactionalBase();
addressInformation.IpAddress = request.GetClientIpAddress();
AddressBusinessService addressBusinessService = new AddressBusinessService(_addressDataService);
Address address = addressBusinessService.ManipulateAddress(addressInformation, out transaction);
if (transaction.ReturnStatus == false)
{
return(new ObjectResult(transaction));
}
addressInformation.Id = address.Id;
addressInformation.ReturnStatus = true;
addressInformation.ReturnMessage = transaction.ReturnMessage;
return(new ObjectResult(addressInformation));
}
/// <summary>
/// Update Profile
/// </summary>
/// <param name="userInformation"></param>
/// <param name="transaction"></param>
public void UpdateProfile(CustomerModel customerInformation, out TransactionalBase transaction)
{
transaction = new TransactionalBase();
Customer existingUser = _customerDataService.GetAll().Where(a => a.Id == customerInformation.Id).FirstOrDefault();
try
{
existingUser.FirstName = customerInformation.FirstName;
existingUser.LastName = customerInformation.LastName;
existingUser.MobileNumber = customerInformation.MobileNumber;
existingUser.UpdatedByIp = customerInformation.IpAddress;
existingUser.UpdatedOn = DateTime.Now;
CustomerBusinessRules customerBusinessRules = new CustomerBusinessRules();
ValidationResult results = customerBusinessRules.Validate(existingUser);
bool validationSucceeded = results.IsValid;
IList <ValidationFailure> failures = results.Errors;
if (validationSucceeded == false)
{
transaction = ValidationErrors.PopulateValidationErrors(failures);
return;
}
_customerDataService.Update(existingUser);
_customerDataService.Commit();
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Your profile was successfully updated.");
}
catch (Exception ex)
{
string errorMessage = ex.Message;
transaction.ReturnMessage.Add(errorMessage);
transaction.ReturnStatus = false;
}
finally
{
}
return;
}
public IActionResult RegisterCustomer(HttpRequestMessage request, [FromBody] CustomerModel customerInformation)
{
TransactionalBase transaction = new TransactionalBase();
Guid customerID = new Guid();
customerInformation.IpAddress = request.GetClientIpAddress();
CustomerBusinessService userBusinessService = new CustomerBusinessService(_customerDataService);
userBusinessService.RegisterCustomer(customerInformation, out customerID, out transaction);
if (transaction.ReturnStatus == false)
{
return(new ObjectResult(transaction));
}
customerInformation.ReturnStatus = true;
customerInformation.ReturnMessage = transaction.ReturnMessage;
customerInformation.Token = TokenManager.CreateToken(customerID);
customerInformation.IsAuthenticated = true;
return(new ObjectResult(customerInformation));
}
/// <summary>
///
/// </summary>
/// <param name="addressInformation"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public Address ManipulateAddress(AddressModel addressInformation, out TransactionalBase transaction)
{
transaction = new TransactionalBase();
Address address = _addressDataService.GetAll().Where(a => a.Id == addressInformation.Id).FirstOrDefault();
try
{
if (address == null)
{
address = new Address();
address.CreatedByIp = addressInformation.IpAddress;
address.CreatedOn = DateTime.Now;
}
else
{
address.UpdatedByIp = addressInformation.IpAddress;
address.UpdatedOn = DateTime.Now;
}
address.Name = addressInformation.Name;
address.AddressLine1 = addressInformation.AddressLine1;
address.AddressLine2 = addressInformation.AddressLine2;
address.City = addressInformation.City;
address.State = addressInformation.State;
address.Country = addressInformation.Country;
address.ZipCode = addressInformation.ZipCode;
address.MobileNumber = addressInformation.MobileNumber;
address.Customer = new Customer()
{
Id = addressInformation.CustomerId
};
AddressBusinessRules customerBusinessRules = new AddressBusinessRules(_addressDataService, address);
ValidationResult results = customerBusinessRules.Validate(address);
bool validationSucceeded = results.IsValid;
IList <ValidationFailure> failures = results.Errors;
if (validationSucceeded == false)
{
transaction = ValidationErrors.PopulateValidationErrors(failures);
return(address);
}
if (address.Id == Guid.Empty)
{
_addressDataService.Add(address);
}
_addressDataService.Commit();
transaction.ReturnStatus = true;
transaction.ReturnMessage.Add("Address successfully updated.");
}
catch (Exception ex)
{
string errorMessage = ex.Message;
transaction.ReturnMessage.Add(errorMessage);
transaction.ReturnStatus = false;
}
finally
{
}
return(address);
}
