public ProblemIssueResponse(int problemIssueId, string description, string submittedBy, ProblemResponse problem)
{
ProblemIssueId = problemIssueId;
Description = description;
SubmittedBy = submittedBy;
Problem = problem;
}
public async Task <ProblemResponse> GetPasswordResetTokenAsync(PasswordReset data)
{
ProblemResponse problemResponse = new ProblemResponse()
{
Detail = "Na podany adres mailowy został wysłany link do zresetowania hasła",
Status = 200
};
try
{
Console.WriteLine($"Checking email: {data.Email}");
var user = await _userManager.FindByEmailAsync(data.Email);
if (user is null)
{
problemResponse.Detail = "Na podany adres mailowy został wysłany link do zresetowania hasła";
throw new Exception("Na podany adres mailowy został wysłany link do zresetowania hasła");
}
var code = await _userManager.GeneratePasswordResetTokenAsync(user);
Console.WriteLine(code);
string link = $"{data.HostName}/password-reset/new-email/{user.Id}/{HttpUtility.UrlEncode(code)}";
problemResponse.Data = link;
await _emailSender.SendPasswordResetToken(data.Email, link);
}
catch (Exception e)
{
problemResponse.Detail = e.Message;
problemResponse.Status = 500;
}
return(problemResponse);
}
public async Task <ProblemResponse> SelfResetPassword(PasswordReset data)
{
ProblemResponse problemResponse = new ProblemResponse()
{
Detail = "Coś poszło nie tak",
Status = 500
};
try
{
Console.WriteLine(data.Token);
var user = await _userManager.FindByIdAsync(data.UserId);
if (user is null)
{
throw new Exception("Użytkownik nie został znaleziony w bazie.");
}
var token = await _userManager.GeneratePasswordResetTokenAsync(user);
if (token is null)
{
throw new Exception("Problem przy tworzeniu tokenu do resetowania hasła.");
}
var resetPasswordResult = await _userManager.ResetPasswordAsync(user, token, data.Password);
if (!resetPasswordResult.Succeeded)
{
var errCode = resetPasswordResult.Errors.FirstOrDefault().Code;
throw new Exception($"Coś poszło nie tak podczas resetowania hasła. Kod błędu: {errCode}");
}
problemResponse.Detail = "Hasło zostało pomyślnie zmienione";
problemResponse.Status = 200;
}
catch (Exception e)
{
problemResponse.Detail = e.Message;
problemResponse.Status = 500;
}
return(problemResponse);
}
public ProblemResponse UpdateProduct(Product product, IFormFile picture)
{
string dirPath = "Resources/ProductImgs";
ProblemResponse problemResponse = new ProblemResponse()
{
Detail = "Wystąpił błąd nieznanego pochodzenia",
Status = 500
};
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
try
{
Product updatedProduct;
if (product.ProductId == Guid.Empty)
{
Product newProductTmp = new Product();
var newProduct = _mapper.Map(product, newProductTmp);
_koopDbContext.Products.Add(newProduct);
updatedProduct = newProduct;
}
else
{
var productExist = _koopDbContext.Products.SingleOrDefault(p => p.ProductId == product.ProductId);
if (productExist is null)
{
throw new Exception($"Nie znaleziono produktu o podanym Id: {product.ProductId}");
}
var productUpdated = _mapper.Map(product, productExist);
_koopDbContext.Products.Update(productUpdated);
updatedProduct = productUpdated;
}
_koopDbContext.SaveChanges();
Console.WriteLine($"productID: {updatedProduct.ProductId}");
if (updatedProduct.Category.Any())
{
var currentProductCategories =
_koopDbContext.ProductCategories.Where(p => p.ProductId == product.ProductId).Include(p => p.Category);
var categoriesToAdd = updatedProduct.Category.Where(p => !currentProductCategories.Select(q => q.Category.CategoryName).Contains(p.CategoryName));
var categoriesToRemove = currentProductCategories.Where(p =>
!updatedProduct.Category.Select(q => q.CategoryName).Contains(p.Category.CategoryName));
foreach (var category in categoriesToAdd)
{
ProductCategory productCategory = new ProductCategory()
{
CategoryId = category.CategoryId,
ProductId = updatedProduct.ProductId
};
_koopDbContext.ProductCategories.Add(productCategory);
}
_koopDbContext.ProductCategories.RemoveRange(categoriesToRemove);
}
if (updatedProduct.AvailQuantity.Any())
{
var currentAvailableQuantities =
_koopDbContext.AvailableQuantities.Where(p => p.ProductId == product.ProductId);
var availQuantToAdd = updatedProduct.AvailQuantity.Where(p =>
!currentAvailableQuantities.Select(q => q.Quantity).Contains(p.Quantity));
var availQuantToRemove = currentAvailableQuantities.Where(p =>
!updatedProduct.AvailQuantity.Select(q => q.Quantity).Contains(p.Quantity));
foreach (var quantity in availQuantToAdd)
{
AvailableQuantity availableQuantity = new AvailableQuantity()
{
// AvailableQuantityId = Guid.Empty,
ProductId = updatedProduct.ProductId,
Quantity = quantity.Quantity
};
_koopDbContext.AvailableQuantities.Add(availableQuantity);
}
_koopDbContext.AvailableQuantities.RemoveRange(availQuantToRemove);
}
if (picture is not null && picture.Length > 0)
{
var fileExtension = picture.FileName.Split('.');
if (fileExtension.Length != 2)
{
throw new Exception($"Problem z obrazkiem - za dużo kropek");
}
var fileName = $"{updatedProduct.ProductId}.{fileExtension[1]}";
var fullPath = Path.Combine(dirPath, fileName);
// Remove files with the same name
var filesWithSameName = Directory.GetFiles(dirPath, $"{updatedProduct.ProductId}*");
foreach (var file in filesWithSameName)
{
File.Delete(file);
}
using (var stream = new FileStream(fullPath, FileMode.Create))
{
picture.CopyTo(stream);
}
updatedProduct.Picture = fullPath;
_koopDbContext.Products.Update(updatedProduct);
_koopDbContext.SaveChanges();
}
else
{
if (updatedProduct.Picture is null || updatedProduct.Picture.Equals(String.Empty))
{
var filesWithSameName = Directory.GetFiles(dirPath, $"{updatedProduct.ProductId}*");
foreach (var file in filesWithSameName)
{
File.Delete(file);
}
}
}
_koopDbContext.SaveChanges();
problemResponse.Detail = "Dane zostały poprawnie zapisane";
problemResponse.Status = 200;
scope.Complete();
}
/*public Task<IdentityResult> SignUp([FromBody]UserSignUp userSignUp)
* {
* var user = _mapper.Map<User>(userSignUp);
* return _userManager.CreateAsync(user, userSignUp.Password);
* }*/
public async Task <ProblemResponse> SignUp([FromBody] UserEdit newUser)
{
ProblemResponse problemResponse = new ProblemResponse()
{
Detail = "Jakiś nieznany problem pojawił się w trakcie tworzenia nowego użytkownika",
Status = 500
};
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
try
{
var user = _mapper.Map <User>(newUser);
var isEmailAlreadyPresent = await EmailDuplicationCheck(user.Email.ToUpper());
if (isEmailAlreadyPresent)
{
throw new Exception("Podany adres e-mail już istnieje. Proszę podać inny");
}
var createUserResult = await _userManager.CreateAsync(user, newUser.NewPassword);
if (!createUserResult.Succeeded)
{
var code = createUserResult.Errors.FirstOrDefault().Code;
throw new Exception($"Problem przy tworzeniu użytkownika. Kod błędu: {code}");
}
var createdUser = await _userManager.FindByEmailAsync(newUser.Email);
if (createdUser is null)
{
throw new Exception("Pomimo utworzenia konta użytkownika, w bazie danych nie jest od obecny");
}
var roles = newUser.Role.ToList();
if (!roles.Contains("Default"))
{
roles.Add("Default");
}
var addRolesResult = await _userManager.AddToRolesAsync(createdUser, roles);
if (!addRolesResult.Succeeded)
{
throw new Exception("Błąd w trakcie dodawania roli do użytkownika");
}
problemResponse.Detail = "Konto użytkownika zostało utworzone";
problemResponse.Status = 200;
scope.Complete();
}
catch (Exception e)
{
problemResponse.Detail = e.Message;
problemResponse.Status = 500;
scope.Dispose();
}
return(problemResponse);
}
public async Task <ProblemResponse> EditUser(UserEdit userEdit, Guid userId, Guid authUserId, IEnumerable <string> authUserRoles)
{
ProblemResponse problemResponse = new ProblemResponse()
{
Detail = "Brak wymaganych uprawnień do edycji użytkownika",
Status = 0
};
if (userId == authUserId || authUserRoles.Any(p => p == "Admin"))
{
using var scope = new TransactionScope(TransactionScopeAsyncFlowOption.Enabled);
try
{
var user = await _userManager.FindByIdAsync(userId.ToString());
if (user is not null)
{
if (await EmailCounter(user.Email.ToUpper()) > 1)
{
throw new Exception("Podany adres e-mail już istnieje. Proszę podać inny");
}
var setEmailResult = await _userManager.SetEmailAsync(user, userEdit.Email);
if (!setEmailResult.Succeeded)
{
var code = setEmailResult.Errors.FirstOrDefault().Code;
throw new Exception($"Problem przy zmianie adresu e-mail. Kod błędu: {code}");
}
var setUserNameResult = await _userManager.SetUserNameAsync(user, userEdit.UserName);
if (!setUserNameResult.Succeeded)
{
var code = setUserNameResult.Errors.FirstOrDefault().Code;
if (code is not null && code.Equals("DuplicateUserName."))
{
throw new Exception($"Podana nazwa użytkownika już istnieje. Proszę podać inną");
}
throw new Exception($"Problem przy zmianie nazwy użytkownika. Kod błędu: {code}");
}
var setPhoneNumberResult =
await _userManager.SetPhoneNumberAsync(user, userEdit.PhoneNumber);
if (!setPhoneNumberResult.Succeeded)
{
var code = setPhoneNumberResult.Errors.FirstOrDefault().Code;
throw new Exception($"Problem przy zmianie numeru telefonu. Kod błędu: {code}");
}
if (userEdit.OldPassword is not null)
{
var changePasswordResult = await _userManager.ChangePasswordAsync(user,
userEdit.OldPassword,
userEdit.NewPassword);
if (!changePasswordResult.Succeeded)
{
var code = changePasswordResult.Errors.FirstOrDefault().Code;
if (code is not null && code.Equals("PasswordMismatch"))
{
throw new Exception(
$"Nieprawidłowe hasło. Podaj aktualne hasło dla wybranego użytkownika.");
}
throw new Exception(
$"Błąd podczas zmiany hasła. Kod błędu: {code}");
}
}
user.BasketId = userEdit.BasketId;
user.FundId = userEdit.FundId;
user.Debt = userEdit.Debt;
user.Info = userEdit.Info;
user.FirstName = userEdit.FirstName;
user.LastName = userEdit.LastName;
var updateUserResult = await _userManager.UpdateAsync(user);
if (!updateUserResult.Succeeded)
{
throw new Exception("Nie udało się zaktualizować danych");
}
var currentUserRoles = await GetUserRoleAsync(userId.ToString());
var rolesToAdd = userEdit.Role.Where(p => !currentUserRoles.Contains(p));
var rolesToRemove = currentUserRoles.Where(p => !userEdit.Role.Contains(p));
var addRolesResult = await _userManager.AddToRolesAsync(user, rolesToAdd);
if (!addRolesResult.Succeeded)
{
throw new Exception("Błąd w trakcie dodawania roli do użytkownika");
}
var removeRolesResult = await _userManager.RemoveFromRolesAsync(user, rolesToRemove);
if (!removeRolesResult.Succeeded)
{
throw new Exception("Błąd w trakcie usuwania roli z użytkownika");
}
}
problemResponse.Detail = "Dane użytkownika zostały zaktualizowane";
problemResponse.Status = 200;
scope.Complete();
}
catch (Exception e)
{
problemResponse.Detail = e.Message;
problemResponse.Status = 500;
scope.Dispose();
}
}
return(problemResponse);
}
