public async Task <Result <OrderOutput> > GetOrderById(string orderId)
{
Order order = await _orderRepository.FindAsync(orderId);
if (order == null)
{
return new Result <OrderOutput>()
{
Success = false
}
}
;
PHOTOnlineUser user = await _userRepository.FindAsync(order.UserId);
OrderOutput result = new OrderOutput()
{
Order = order,
Address = user.Address,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber
};
return(new Result <OrderOutput>()
{
Success = true, Data = result
});
}
public async Task <Result <string> > CreateUserAsync(CreateUserInput input)
{
PHOTOnlineUser user = new PHOTOnlineUser()
{
FirstName = input.FirstName,
LastName = input.LastName,
Address = input.Address,
Email = input.Email,
UserName = input.Username,
PhoneNumber = input.PhoneNumber,
UserType = input.UserType
};
Result <string> result = await
_authService.CreateUserAsync(user, input.Password);
if (input.UserType != UserType.Photograph)
{
await _authService.SignInAsync(input.Email, input.Password);
}
await _authService.AddUserToRoleByEmail(
input.Email, input.UserType.ToString());
return(result);
}
public async Task <Result <PHOTOnlineUser> > GetUserByEmail(string email)
{
PHOTOnlineUser user = await _userManager.FindByEmailAsync(email);
return(new Result <PHOTOnlineUser>()
{
Success = user == null ? false : true,
Data = user
});
}
public async Task <Result> UpdatePassword(
string userId, string oldPassword, string newPassword)
{
PHOTOnlineUser user = await _userManager.FindByIdAsync(userId);
if (user == null)
{
return new Result()
{
Success = false
}
}
;
bool checkPassword = await _userManager
.CheckPasswordAsync(user, oldPassword);
if (!checkPassword)
{
return new Result()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.WrongOldPassword)
}
}
}
;
string passwordToken = await _userManager
.GeneratePasswordResetTokenAsync(user);
IdentityResult passwordResult = await _userManager.ResetPasswordAsync(
user, passwordToken, newPassword);
if (IsPasswordToShort(passwordResult))
{
return(new Result()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.PasswordTooShort)
}
});
}
return(new Result()
{
Success = passwordResult.Succeeded
});
}
public async Task <Result> AddUserToRoleByEmail(string email, string roleName)
{
PHOTOnlineUser user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return new Result()
{
Success = false
}
}
;
return(await AddUserToRoleAsync(user, roleName));
}
public async Task <Result> AddUserToRoleAsync(PHOTOnlineUser user, string roleName)
{
IdentityRole role = await _roleManager.FindByNameAsync(roleName);
if (role == null)
{
await _roleManager.CreateAsync(new IdentityRole(roleName));
}
IdentityResult result = await _userManager.AddToRoleAsync(user, roleName);
return(new Result()
{
Success = result.Succeeded
});
}
public async System.Threading.Tasks.Task <Result> AssignTask(AssignTaskInput input)
{
List <Task> tasks = await _taskRepository.GetAllTasksByUserId(input.PhotographId);
if (tasks.Find(item => item.Date == input.Date) != null)
{
return(new Result()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.PhotographIsNotAvailable)
}
});
}
PHOTOnlineUser user = await _userRepository.FindAsync(input.CustomerId);
Task task = new Task()
{
Date = input.Date,
Time = input.Time,
EventType = input.EventType,
Location = input.Location,
Note = input.Note,
PhotographId = input.PhotographId,
CustomerFirstName = user.FirstName,
CustomerLastName = user.LastName,
CustomerPhoneNumber = user.PhoneNumber
};
await _taskRepository.CreateAsync(task);
await _requestRepository.UpdateRequestStatus(
input.RequestId, RequestStatus.Approved);
await _requestRepository.UpdateRequestNotification(
input.RequestId, input.Notification);
return(new Result()
{
Success = true
});
}
public async Task <Result <string> > CreatePhotographAsync(CreatePhotographInput input)
{
PHOTOnlineUser user = new PHOTOnlineUser()
{
FirstName = input.FirstName,
LastName = input.LastName,
Email = input.Email,
UserName = input.Username,
UserType = UserType.Photograph
};
Result <string> result = await
_authService.CreateUserAsync(user, input.Password);
await _authService.AddUserToRoleByEmail(
input.Email, UserType.Photograph.ToString());
return(result);
}
public async Task <Result <SignInOutput> > SignInAsync(string email, string password)
{
PHOTOnlineUser user = await _userManager.FindByEmailAsync(email);
if (user == null)
{
return(new Result <SignInOutput>()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.WrongEmail)
}
});
}
SignInResult signInResult = await _signInManager.PasswordSignInAsync(
user, password, false, false);
if (signInResult.Succeeded)
{
return(new Result <SignInOutput>()
{
Success = true,
Data = new SignInOutput()
{
Id = user.Id, UserType = user.UserType
}
});
}
else
{
return(new Result <SignInOutput>()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.WrongPassword)
}
});
}
}
public async Task <Result> DeleteUser(string id)
{
PHOTOnlineUser user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return new Result()
{
Success = false
}
}
;
IdentityResult result = await _userManager.DeleteAsync(user);
return(new Result()
{
Success = result.Succeeded
});
}
public async Task <Result> UpdateCredentials(
string currentEmail, string newEmail, string newPassword,
string newAddress, string newPhoneNumber)
{
PHOTOnlineUser user = await _userManager.FindByEmailAsync(currentEmail);
if (user == null)
{
return new Result()
{
Success = false
}
}
;
user.Email = newEmail;
user.Address = newAddress;
user.PhoneNumber = newPhoneNumber;
IdentityResult userResult = await _userManager.UpdateAsync(user);
if (!userResult.Succeeded)
{
return new Result()
{
Success = false
}
}
;
string passwordToken = await _userManager
.GeneratePasswordResetTokenAsync(user);
IdentityResult passwordResult = await _userManager.ResetPasswordAsync(
user, passwordToken, newPassword);
return(new Result()
{
Success = passwordResult.Succeeded
});
}
public async Task <Result <List <OrderOutput> > > GetAllOrdersByUserIdAsync(string userId)
{
List <Order> orders = await _orderRepository.GetOrdersByUserId(userId);
if (orders.Count == 0)
{
return new Result <List <OrderOutput> >()
{
Success = true
}
}
;
PHOTOnlineUser user = await _userRepository.FindAsync(userId);
List <OrderOutput> result = new List <OrderOutput>();
//List<Cart> carts = await _cartRepository.GetAll();
orders.ForEach(order =>
{
//Cart cart = carts.Find(element => element.UserId == user.Id);
result.Add(new OrderOutput()
{
Order = order,
Address = user.Address,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber
});
});
return(new Result <List <OrderOutput> >()
{
Success = true,
Data = result
});
}
public async Task <Result <List <OrderOutput> > > GetAllOrders()
{
List <Order> orders = await _orderRepository.GetAllOrders();
if (orders.Count == 0)
{
return new Result <List <OrderOutput> >()
{
Success = true,
Data = new List <OrderOutput>()
}
}
;
List <PHOTOnlineUser> users = await _userRepository.GetAllUsers();
List <OrderOutput> result = new List <OrderOutput>();
orders.ForEach(order =>
{
PHOTOnlineUser user = users.Find(element => element.Id == order.UserId);
result.Add(new OrderOutput()
{
Order = order,
Address = user.Address,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber
});
});
return(new Result <List <OrderOutput> >()
{
Success = true,
Data = result
});
}
public async Task <Result <string> > CreateUserAsync(PHOTOnlineUser user, string password)
{
var operationResult = default(IdentityResult);
operationResult = await _userManager.CreateAsync(user, password);
if (IsDuplicateEmail(operationResult))
{
return(new Result <string>()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.DuplicateEmail)
}
});
}
if (IsDuplicateUserName(operationResult))
{
return(new Result <string>()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.DuplicateUserName)
}
});
}
if (IsDuplicateEmail(operationResult))
{
return(new Result <string>()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.DuplicateEmail)
}
});
}
if (IsPasswordToShort(operationResult))
{
return(new Result <string>()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.PasswordTooShort)
}
});
}
if (IsInvalidEmail(operationResult))
{
return(new Result <string>()
{
Success = false,
Errors = new List <Error>()
{
new Error(ErrorCode.InvalidEmail)
}
});
}
return(new Result <string>()
{
Success = true, Data = user.Id
});
}
