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));
}
}
/// <summary>
/// Send mails with reports to recievers
/// </summary>
/// <returns>Operation result</returns>
public async Task <WorkResult> SendMailsToRecieversAsync()
{
if (_employee == null || _pages == null || _pages.Count == 0)
{
return(WorkResult.Failed("Params are not valid."));
}
byte[] pdfReport, wordReport;
Document pdf, docx;
try
{
pdf = new PdfDocument(_pages, _employee);
docx = new WordDocument(_pages, _employee);
pdfReport = pdf.GetDocument();
wordReport = docx.GetDocument();
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.ToString()));
}
if (pdfReport.Length == 0 && wordReport.Length == 0)
{
return(WorkResult.Failed("Length of file is 0"));
}
return(await SendMailsAsync(wordReport, docx.Name, pdfReport, pdf.Name));
}
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 by Employer
Employer employer = await UnitOfWork.EmployerRepository.FindById(cancellationToken, userId);
if (employer != null)
{
UnitOfWork.UserRepository.Remove(employer.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 Employer"));
}
catch (Exception ex)
{
return(WorkResult.Failed(ex.Message));
}
}
public override async Task <WorkResult> Delete(CancellationToken cancellationToken, Admin entity)
{
if (entity != null)
{
return(await Delete(cancellationToken, entity.AdminId));
}
return(WorkResult.Failed("Admin cannot be null"));
}
public override async Task <WorkResult> Delete(Advisor entity)
{
if (entity != null)
{
return(await Delete(entity.AdvisorId));
}
return(WorkResult.Failed("Admin cannot be null"));
}
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 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));
}
}
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 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));
}
}
/// <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> 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));
}
}