public async Task <IActionResult> EditImage(IndexViewData data)
{
var fileUploadResponse = new DefaultServiceResponse();
var viewModel = new IndexViewData();
if (data.FormFileData != null)
{
var customerData = await UserManager.GetUserAsync(User);
if (customerData != null)
{
fileUploadResponse = await FileManagerService.LoadFileToTheServer(data.FormFileData, customerData.Id);
}
if (fileUploadResponse.ValidationErrors != null)
{
foreach (var error in fileUploadResponse.ValidationErrors)
{
ModelState.AddModelError("", error);
}
}
viewModel.PathToTheInputImage = Path.Combine("../", "CustomersImages",
Path.GetFileName(fileUploadResponse.ResponseData.ToString()));
Logger.LogInformation($"Path to the input image, uploaded by the customer - {viewModel.PathToTheInputImage}");
}
else
{
ModelState.AddModelError("", "In order to edit photo, you should first provide it");
}
return(View(viewModel));
}
/// <summary>
/// Loads customer images to HD to deal with them in future
/// </summary>
/// <param name="file"></param>
public async Task <DefaultServiceResponse> LoadFileToTheServer(IFormFile file, string customerId)
{
var responseModel = new DefaultServiceResponse()
{
ValidationErrors = new List <string>()
};
var fileExtension = Path.GetExtension(file.FileName); // or try to use Name
if (fileExtension != null && (fileExtension == ".jpg" || fileExtension == ".png")) // for now we should work only with this type of files ( can be set-Up in the configuration file )
{
var randomFileName = Path.GetRandomFileName().Replace(".", ""); // replace all the dots to be able to use this files later in the server
var pathToFilesFolder = Configuration.Value.CustomerFilesFolder;
Logger.LogInformation($"Path tp folder - {pathToFilesFolder}");
var systemFileName = Path.Combine(pathToFilesFolder, randomFileName) + fileExtension;
var checkResult = await FileExtensionCheck(file, fileExtension, systemFileName);
if (Configuration.Value.SaveFilesWithWrongFormat) //file type is save, as file extension ( no viruses )
{
DataContext.CustomerImageFiles.Add(new ImageFileModel {
CustomerId = customerId, FullName = systemFileName, Id = new Guid(), UploadTime = DateTime.Now
}); // todo - check file ID!!!! ASAP
await DataContext.SaveChangesAsync();
using (var stream = File.Create(systemFileName))
{
await file.CopyToAsync(stream);
}
responseModel.ResponseData = systemFileName;
return(responseModel);
}
responseModel.ValidationErrors.Add(DefaultResponseMessages.WrongFileFormatProvided);
return(responseModel);
}
else
{
responseModel.ValidationErrors.Add(DefaultResponseMessages.WrongFileFormatProvided);
return(responseModel);
}
}
/// <summary>
/// To store customer files to the DB and map them with other customer data
/// </summary>
/// <param name="file"></param>
public async Task <DefaultServiceResponse> LoadFileToTheDB(IFormFile file, string customerId)
{
var responseModel = new DefaultServiceResponse()
{
ValidationErrors = new List <string>()
};
var fileExtension = Path.GetExtension(file.FileName);
if (fileExtension != null && (fileExtension == ".jpg" || fileExtension == ".png"))
{
var randomFileName = Path.GetRandomFileName().Replace(".", "");
var systemFileName = Path.Combine(Configuration.Value.CustomerFilesFolder, randomFileName, fileExtension);
var checkResult = await FileExtensionCheck(file, fileExtension, systemFileName);
if (Configuration.Value.SaveFilesWithWrongFormat)
{
using (var stream = new MemoryStream())
{
await file.CopyToAsync(stream);
DataContext.AccountLevelFiles.Add(new AccountLevelFile
{
FileId = new Guid(),
CustomerId = customerId,
FullName = systemFileName,
FileData = stream.ToArray(),
});
DataContext.SaveChanges();
}
responseModel.ResponseData = systemFileName;
return(responseModel);
}
responseModel.ValidationErrors.Add(DefaultResponseMessages.WrongFileFormatProvided);
return(responseModel);
}
else
{
responseModel.ValidationErrors.Add(DefaultResponseMessages.WrongFileFormatProvided);
return(responseModel);
}
}
/// <summary>
/// Method to perform customer registration in case, that he provided correct data to us
/// </summary>
/// <returns></returns>
public async Task <DefaultServiceResponse> CompleteRegistration(CustomerViewModel customer)
{
var responseCheckData = new DefaultServiceResponse {
ActionName = "Index", ControllerName = "HomePage", ResponseData = null, StatusCode = StatusCodesEnum.BadDataProvided, ValidationErrors = new List <string>()
};
var userSearchResult = await UserManager.FindByEmailAsync(customer.EmailAddress);
if (userSearchResult == null) // customer has no data in our DB --> he can be registered
{
var user = new ServiceUser
{
Email = customer.EmailAddress,
UserName = customer.FirstName
};
var result = await UserManager.CreateAsync(user, customer.Password);
if (result.Succeeded) // errors will be displayed on validation-summary
{
Logger.LogInformation($"Customer created, account data - {user.Email} - email, {user.UserName} - username");
if (CheckIfWeHaveRole("User"))
{
await UserManager.AddToRoleAsync(user, "User");
}
else
{
await RoleManager.CreateAsync(new IdentityRole { Id = new Guid().ToString(), Name = "User" });
await UserManager.AddToRoleAsync(user, "User");
}
Logger.LogInformation($"Roles added for the user - {user.UserName}");
var currentUser = await UserManager.FindByEmailAsync(user.Email);
var claims = CustomerContext.UserClaims.Select(x => x).ToList();
var newClaimId = claims.Count > 0 ? claims.Last().Id + 1 : 1;
CustomerContext.UserClaims.Add(new IdentityUserClaim <string> {
Id = newClaimId, ClaimType = "UploadPhoto", ClaimValue = "true", UserId = currentUser.Id
});
await CustomerContext.SaveChangesAsync();
Logger.LogInformation($"Claims added for the user - {user.UserName}");
var token = await UserManager.GenerateEmailConfirmationTokenAsync(currentUser);
var emailUrlConfirmation = UrlHelper.Action("ConfirmEmail", "Account", new { Token = token, UserId = currentUser.Id }, Context.HttpContext.Request.Scheme);
var response = await SendEmailService.SendEmail(new ServiceEmail //todo - add there logging to get the response about loggined customers
{
FromEmail = "*****@*****.**",
FromName = "Yevhen",
ToEmail = currentUser.Email,
ToName = currentUser.UserName,
EmailSubject = "Thank you for register!!!",
EmailHtmlText = $"<strong>Hello there! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}</strong>",
EmailText = $"Hello there! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}",
});
responseCheckData.ResponseData = customer.FirstName;
responseCheckData.ActionName = "ConfirmationPage";
responseCheckData.ControllerName = "Registration";
responseCheckData.StatusCode = StatusCodesEnum.RedirectNeeded;
return(responseCheckData);
}
else
{
foreach (var error in result.Errors)
{
responseCheckData.ValidationErrors.Add(error.Description);
}
responseCheckData.StatusCode = StatusCodesEnum.BadDataProvided;
return(responseCheckData);
}
}
else
{
responseCheckData.ValidationErrors.Add(DefaultResponseMessages.AllreadyHasAccount);
responseCheckData.StatusCode = StatusCodesEnum.BadDataProvided;
return(responseCheckData);
}
}
/// <summary>
/// Main method to perform login of the customer
/// </summary>
/// <param name="customer"></param>
/// <param name="returnUrl"></param>
public async Task <DefaultServiceResponse> LoginCustomer(LoginViewModel customer, string returnUrl = null)
{
var validationResponse = new DefaultServiceResponse {
StatusCode = StatusCodesEnum.Ok, ValidationErrors = new List <string>(), ResponseData = null
};
var userData = await UserManager.FindByEmailAsync(customer.EmailAddress);
if (userData != null)
{
var providedData = await SignInManager.CheckPasswordSignInAsync(userData, customer.Password, true);
if (providedData.ToString() == "Failed")
{
validationResponse.StatusCode = StatusCodesEnum.BadDataProvided; // in case of this response --> reload view with validation errors
validationResponse.ValidationErrors.Add(DefaultResponseMessages.WrongPasswordAndEmailCombination);
return(validationResponse);
}
else if (providedData.IsLockedOut)
{
validationResponse.StatusCode = StatusCodesEnum.BadDataProvided;
validationResponse.ValidationErrors.Add(DefaultResponseMessages.AccountIsLockOut);
return(validationResponse);
}
else if (providedData.Succeeded) // Check that customer has a verified email
{
if (userData.EmailConfirmed == false)
{
validationResponse.StatusCode = StatusCodesEnum.BadDataProvided;
validationResponse.ValidationErrors.Add(DefaultResponseMessages.EmailIsNotVerified);
return(validationResponse);
}
else
{
var loginResponse = await SignInManager.PasswordSignInAsync(userData, customer.Password, false, true);
if (loginResponse.Succeeded && returnUrl != null)
{
validationResponse.StatusCode = StatusCodesEnum.RedirectNeeded; // Can be changed in future to valid one ( for now --> simple redirect to home page )
return(validationResponse);
}
else if (loginResponse.Succeeded)
{
validationResponse.StatusCode = StatusCodesEnum.Ok; // no redirect needed --> return URL was not provided
return(validationResponse);
}
}
}
}
validationResponse.StatusCode = StatusCodesEnum.BadDataProvided;
validationResponse.ValidationErrors.Add(DefaultResponseMessages.CustomerIsNotFoundInDb);
return(validationResponse);
}
/// <summary>
/// Method to perform login of the external customer
/// </summary>
/// <param name="returnUrl"></param>
/// <param name="remoteError"></param>
/// <returns></returns>
public async Task <DefaultServiceResponse> ExternalLoginCallBack(string returnUrl = null, string remoteError = null)
{
var loginCallBackResult = new DefaultServiceResponse {
ActionName = "Index", ControllerName = "HomePage", ResponseData = null, StatusCode = StatusCodesEnum.Ok, ValidationErrors = new List <string>()
};
if (remoteError == null)
{
var accountDetailsFromProvider = await SignInManager.GetExternalLoginInfoAsync();
#region Check, that data is provided
if (accountDetailsFromProvider != null)
{
// Search for the customer in our db
var accountData = await UserManager.FindByEmailAsync(accountDetailsFromProvider.Principal.FindFirstValue(ClaimTypes.Email));
#region New account for our DB
if (accountData == null) // new account
{
var serviceUser = new ServiceUser
{
Email = accountDetailsFromProvider.Principal.FindFirstValue(ClaimTypes.Email),
UserName = accountDetailsFromProvider.Principal.FindFirstValue(ClaimTypes.GivenName)
};
var userResponse = await UserManager.CreateAsync(serviceUser);
#region Customer created without any error --> send him email to verify email and add password ( or not )
if (userResponse.Succeeded)
{
if (CheckIfWeHaveRole("User"))
{
await UserManager.AddToRoleAsync(serviceUser, "User");
}
else
{
await RoleManager.CreateAsync(new IdentityRole { Id = new Guid().ToString(), Name = "User", NormalizedName = "USER" });
await UserManager.AddToRoleAsync(serviceUser, "User");
}
var claims = CustomerContext.UserClaims.Select(x => x).ToList();
var newClaimId = claims.Count > 0 ? claims.Last().Id + 1 : 1;
CustomerContext.UserClaims.Add(new IdentityUserClaim <string> {
Id = newClaimId, ClaimType = "UploadPhoto", ClaimValue = "true", UserId = serviceUser.Id
});
await CustomerContext.SaveChangesAsync();
await UserManager.AddLoginAsync(serviceUser, accountDetailsFromProvider); // Creates point in AspNetUserLogins
var token = await UserManager.GenerateEmailConfirmationTokenAsync(serviceUser);
var emailUrlConfirmation = UrlHelper.Action("ConfirmEmail", "Account", new { Token = token, UserId = serviceUser.Id }, Context.HttpContext.Request.Scheme);
await SendEmailService.SendEmail(new ServiceEmail
{
FromEmail = "*****@*****.**",
FromName = "Yevhen",
ToEmail = serviceUser.Email,
ToName = serviceUser.UserName,
EmailSubject = "Thank you for register!!!",
EmailHtmlText = $"<strong>Hello, {serviceUser.UserName}! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}</strong>",
EmailText = $"Hello there! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}",
});
loginCallBackResult.ActionName = "ConfirmPartnerRegister";
loginCallBackResult.ControllerName = "Registration";
loginCallBackResult.ResponseData = serviceUser.UserName;
loginCallBackResult.StatusCode = StatusCodesEnum.RedirectNeeded;
return(loginCallBackResult);
}
#endregion
else
{
loginCallBackResult.ValidationErrors.Add(DefaultResponseMessages.ExternalLoginFailed);
loginCallBackResult.StatusCode = StatusCodesEnum.BadDataProvided;
return(loginCallBackResult);
}
}
#endregion
else
{
#region Customer already has account on our db, but email is not confirmed
if (!accountData.EmailConfirmed)
{
var loginsData = await UserManager.GetLoginsAsync(accountData);
if (loginsData == null)
{
await UserManager.AddLoginAsync(accountData, accountDetailsFromProvider);
}
var token = await UserManager.GenerateEmailConfirmationTokenAsync(accountData);
var emailUrlConfirmation = UrlHelper.Action("ConfirmEmail", "Account", new { Token = token, UserId = accountData.Id }, Context.HttpContext.Request.Scheme);
await SendEmailService.SendEmail(new ServiceEmail
{
FromEmail = "*****@*****.**",
FromName = "Yevhen",
ToEmail = accountData.Email,
ToName = accountData.UserName,
EmailSubject = "Thank you for register!!!",
EmailHtmlText = $"<strong>Hello, {accountData.UserName}! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}</strong>",
EmailText = $"Hello there! Thank you for registering, please confirm your email using this link : {emailUrlConfirmation}",
});
loginCallBackResult.StatusCode = StatusCodesEnum.RedirectNeeded;
loginCallBackResult.ResponseData = accountData.UserName;
loginCallBackResult.ActionName = "ConfirmPartnerRegister";
loginCallBackResult.ControllerName = "Registration";
return(loginCallBackResult);
}
#endregion
#region Email is confirmed but we need to check, that customer has row in ASPNETUSERLOGINS
else
{
var loginReponse = await SignInManager.ExternalLoginSignInAsync(accountDetailsFromProvider.LoginProvider, accountDetailsFromProvider.ProviderKey, false);
if (loginReponse.Succeeded)
{
loginCallBackResult.StatusCode = StatusCodesEnum.Ok;
}
else
{
await UserManager.AddLoginAsync(accountData, accountDetailsFromProvider);
await SignInManager.SignInAsync(accountData, false);
}
loginCallBackResult.ActionName = "Index";
loginCallBackResult.ControllerName = "HomePage";
return(loginCallBackResult);
}
#endregion
}
}
#endregion
#region No data provided from external provider
else
{
loginCallBackResult.ValidationErrors.Add(DefaultResponseMessages.ExternalLoginFailed);
loginCallBackResult.StatusCode = StatusCodesEnum.BadDataProvided;
return(loginCallBackResult);
}
#endregion
}
#region Error from external provider
else
{
loginCallBackResult.ValidationErrors.Add(DefaultResponseMessages.ExternalLoginFailed);
loginCallBackResult.StatusCode = StatusCodesEnum.RedirectNeeded;
loginCallBackResult.ActionName = "Login";
loginCallBackResult.ControllerName = "Account";
return(loginCallBackResult);
}
#endregion
}
