public override async Task <WorkResult> Delete(string userName)
{
if (userName == null)
{
return(WorkResult.Failed("Wrong param.Entity is null"));
}
try
{
// Check is userId owned by Employer
User user = await UnitOfWork.UserRepository.FindByUserName(userName);
if (user.Employer != null)
{
UnitOfWork.UserRepository.Remove(user);
int result = await UnitOfWork.SaveChanges();
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
return(WorkResult.Failed("userId isn't owned by Employer"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public override async Task <WorkResult> Delete(CancellationToken cancellationToken, string userName)
{
if (!string.IsNullOrEmpty(userName))
{
return(WorkResult.Failed("Wrong param.Entity is null"));
}
try
{
// Check is userId owned Admin
User user = await UnitOfWork.UserRepository.FindByUserName(cancellationToken, userName);
if (user.Admin != null)
{
UnitOfWork.UserRepository.Remove(user);
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
return(WorkResult.Failed("userId isn't owned by Admin"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> RemoveAnswer(CancellationToken cancellationToken, Answer answer, Question question)
{
if ((question == null) || (answer == null))
{
return(WorkResult.Failed("Answer or question cannot be null"));
}
try
{
if (question.Answers.Contains(answer))
{
question.Answers.Remove(answer);
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned 0"));
}
return(WorkResult.Failed("Current question not have this answer"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> DeleteAllPages(CancellationToken cancellationToken)
{
List <Page> pages = await UnitOfWork.PageRepository.GetAll(cancellationToken);
if (pages == null || pages.Count == 0)
{
return(WorkResult.Failed("Page cannot be null or empty"));
}
try
{
foreach (var page in pages)
{
UnitOfWork.PageRepository.Remove(page);
}
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned 0"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> AddAnswer(Answer answer, Question question)
{
if ((question == null) || (answer == null))
{
return(WorkResult.Failed("Answer or question cannot be null"));
}
try
{
if (!question.Answers.Contains(answer))
{
question.Answers.Add(answer);
int result = await UnitOfWork.SaveChanges();
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned 0"));
}
return(WorkResult.Failed("Current question hold this answer"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> RemoveQuestion(CancellationToken cancellationToken, Question question, Page page)
{
if ((question == null) || (page == null))
{
return(WorkResult.Failed("Page or question cannot be null"));
}
try
{
if (page.Questions.Contains(question))
{
page.Questions.Remove(question);
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned 0"));
}
return(WorkResult.Failed("Current page hold this question"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public override async Task <WorkResult> Delete(CancellationToken cancellationToken, Guid userId)
{
if (userId == Guid.Empty)
{
return(WorkResult.Failed("Wrong param.Entity is null"));
}
try
{
// Check is userId owned Admin
Admin admin = await UnitOfWork.AdminRepository.FindById(cancellationToken, userId);
if (admin != null)
{
UnitOfWork.UserRepository.Remove(admin.User);
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
return(WorkResult.Failed("userId isn't owned by Admin"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> UpdateEmployee(CancellationToken cancellationToken, Employee employee)
{
if (employee != null)
{
UnitOfWork.EmployeeRepository.Update(employee);
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
return(WorkResult.Failed("Wrong param.Entity is null"));
}
public async Task <WorkResult> CreateEmployee(Employee employee)
{
if (employee != null)
{
UnitOfWork.EmployerRepository.AddEmployee(employee);
int result = await UnitOfWork.SaveChanges();
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
return(WorkResult.Failed("Wrong param.Entity is null"));
}
public async Task <WorkResult> UpdateQuestion(CancellationToken cancellationToken, Question question)
{
if (question == null)
{
return(WorkResult.Failed("Question cannot be null"));
}
try
{
UnitOfWork.QuestionRepository.Update(question);
await UnitOfWork.SaveChanges(cancellationToken);
return(WorkResult.Success());
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> AddPages(CancellationToken cancellationToken, IEnumerable <Page> pages)
{
if (pages == null)
{
return(WorkResult.Failed("Pages cannot be null"));
}
try
{
UnitOfWork.PageRepository.AddRange(pages);
await UnitOfWork.SaveChanges(cancellationToken);
return(WorkResult.Success());
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public override async Task <WorkResult> Create(Admin entity)
{
if (entity == null)
{
return(WorkResult.Failed("Wrong param. Entity is null"));
}
try
{
UnitOfWork.UserRepository.AddAdmin(entity);
int result = await UnitOfWork.SaveChanges();
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> DeletePage(CancellationToken cancellationToken, Page page)
{
if (page == null)
{
return(WorkResult.Failed("Page cannot be null"));
}
try
{
UnitOfWork.PageRepository.Remove(page);
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned 0"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> UpdatePage(Page page)
{
if (page == null)
{
return(WorkResult.Failed("Page cannot be null"));
}
try
{
UnitOfWork.PageRepository.Update(page);
int result = await UnitOfWork.SaveChanges();
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned 0"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
/// <summary>
/// Sends mails with reports to recievers
/// </summary>
/// <param name="word">Word doc</param>
/// <param name="pdf">Pdf doc</param>
/// <returns>Operation result</returns>
private async Task <WorkResult> SendMailsAsync(byte[] word, string wordName, byte[] pdf, string pdfName)
{
var adminMail = new ReportCompltdAdminMessageBuilder(_employee);
var employerMail = new ReportCompltdEmplMessageBuilder(_employee);
var admins = await _adminManager.GetAll();
var result =
await _mailService.SendMailAsync(adminMail.Body, adminMail.Subject, word, wordName,
admins.Select(a => a.User.Email).ToArray());
if (!result.HasError)
{
result = await _mailService.SendMailAsync(employerMail.Body, employerMail.Subject, pdf, pdfName, _employee.Employer.User.Email);
}
if (result.HasError)
{
return(WorkResult.Failed(result.ErrorMessage));
}
return(WorkResult.Success());
}
public override async Task <WorkResult> Update(CancellationToken cancellationToken, Admin entity)
{
if (entity == null)
{
WorkResult.Failed("Wrong param.Entity is null");
}
try
{
UnitOfWork.AdminRepository.Update(entity);
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public override async Task <WorkResult> DeleteEmployee(Employee employee)
{
if (employee == null)
{
return(WorkResult.Failed("Employee name null"));
}
try
{
UnitOfWork.EmployeeRepository.Remove(employee);
int result = await UnitOfWork.SaveChanges();
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> UpdateAnswer(CancellationToken cancellationToken, Answer answer)
{
if (answer == null)
{
return(WorkResult.Failed("Answer cannot be null"));
}
try
{
UnitOfWork.AnswerRepository.Update(answer);
int result = await UnitOfWork.SaveChanges(cancellationToken);
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned 0"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public async Task <WorkResult> AddReport(Guid?employeeId)
{
if (employeeId == null)
{
return(WorkResult.Failed("Wrong param. Employee id is null"));
}
try
{
var employee = await _unitOfWork.EmployeeRepository.FindById(employeeId);
if (employee == null)
{
return(WorkResult.Failed("Employee wasn't found. Possible uncorrect id"));
}
var report = new Report
{
ReportId = Guid.NewGuid(),
CreatedDate = DateTime.Now,
Employee = employee
};
_unitOfWork.ReportRepository.Add(report);
int result = await _unitOfWork.SaveChanges();
if (result > 0)
{
return(WorkResult.Success());
}
return(WorkResult.Failed("SaveChanges returned result 0"));
}
catch (Exception e)
{
return(WorkResult.Failed(e.Message));
}
}