/// <summary>
        /// Gets detailed version of report by id
        /// </summary>
        /// <param name="reportId">Identifier of report</param>
        /// <param name="userId">Identifier of user</param>
        /// <returns>Service result with operation status and object to return</returns>
        public async Task <IServiceResult <ReportDetailsToReturnDto> > GetReportDetailsAsync(int reportId, int userId)
        {
            try
            {
                UserEntity user = await _userManager.Users.Where(x => x.Id == userId).Include(ur => ur.UserRoles).ThenInclude(r => r.Role).FirstOrDefaultAsync();

                string userRole = user.UserRoles.Select(x => x.Role).FirstOrDefault().Name;

                ReportEntity report = await _repository.GetReportById(reportId, userRole, userId);

                if (report != null)
                {
                    ReportDetailsToReturnDto reportToReturn = _reportMapper.Map(report);

                    return(new ServiceResult <ReportDetailsToReturnDto>(ResultType.Correct, reportToReturn));
                }

                return(new ServiceResult <ReportDetailsToReturnDto>(ResultType.Unauthorized));
            }
            catch (Exception)
            {
                return(new ServiceResult <ReportDetailsToReturnDto>(ResultType.Error, new List <string> {
                    "Błąd podczas pobierania zgłoszenia"
                }));
            }
        }
        /// <summary>
        /// Adds new response for report
        /// </summary>
        /// <param name="responseToCreate">Data of new response</param>
        /// <param name="userId">Identifier of currently authorized user</param>
        /// <returns>Service result with operation status and object to return (Updated details of the report)</returns>
        public async Task <IServiceResult <ReportDetailsToReturnDto> > SendResponse(ReportResponseToCreateDto responseToCreate, int userId)
        {
            try
            {
                UserEntity user = await _userManager.Users.Where(x => x.Id == userId).Include(ur => ur.UserRoles).ThenInclude(r => r.Role).FirstOrDefaultAsync();

                string userRole = user.UserRoles.Select(x => x.Role).FirstOrDefault().Name;

                ReportEntity reportToUpdate = await _repository.GetReportById(responseToCreate.ReportId, userRole, userId);

                if (reportToUpdate != null)
                {
                    ResponseEntity response = new ResponseEntity
                    {
                        Date    = DateTime.Now,
                        Message = responseToCreate.Message,
                        UserId  = userId
                    };

                    reportToUpdate.Responses.Add(response);

                    reportToUpdate.ModificationEntries.Add(HistoryEntriesGenerator.GetNewResponseEntry(user.UserName, reportToUpdate.Heading));

                    _repository.SaveChanges();

                    await SendEmployeeRespondedEmail(reportToUpdate.UserId, reportToUpdate.Heading);

                    ReportDetailsToReturnDto reportToReturn = _reportMapper.Map(reportToUpdate);

                    return(new ServiceResult <ReportDetailsToReturnDto>(ResultType.Correct, reportToReturn));
                }

                return(new ServiceResult <ReportDetailsToReturnDto>(ResultType.Failed, new List <string> {
                    "Błąd podczas aktualizacji zgłoszenia"
                }));
            }
            catch (Exception)
            {
                return(new ServiceResult <ReportDetailsToReturnDto>(ResultType.Error, new List <string> {
                    "Błąd podczas aktualizacji zgłoszenia"
                }));
            }
        }
        /// <summary>
        /// Creates and adds new report to database
        /// </summary>
        /// <param name="reportToCreate">Report data from creation form</param>
        /// <param name="userId">Identifier of submitter</param>
        /// <returns>Service result with operation status and object to return</returns>
        public async Task <IServiceResult <ReportDetailsToReturnDto> > CreateAsync(ReportToCreateDto reportToCreate, int userId)
        {
            try
            {
                UserEntity user = await _userManager.Users.Where(x => x.Id == userId).Include(r => r.Reports).FirstOrDefaultAsync();

                ReportEntity report = CreateReport(reportToCreate, userId, user.UserName);

                AttachmentEntity attachment = CreateAttachment(reportToCreate.File, userId);
                report.Attachment = attachment;

                try
                {
                    _repository.AddNew(report);
                }
                catch (Exception)
                {
                    if (report.Attachment != null)
                    {
                        string url = report.Attachment.Url;
                        await _cloudinaryManager.DeleteFileAsync(url.Substring(url.LastIndexOf('/') + 1));
                    }

                    throw;
                }

                ReportDetailsToReturnDto reportToReturn = _reportMapper.Map(report);

                return(new ServiceResult <ReportDetailsToReturnDto>(ResultType.Correct, reportToReturn));
            }
            catch (Exception)
            {
                return(new ServiceResult <ReportDetailsToReturnDto>(ResultType.Error, new List <string> {
                    "Błąd podczas tworzenia nowego zgłoszenia."
                }));
            }
        }
 public ReportEntity Map(ReportDetailsToReturnDto reportDetailsToReturn) => _mapper.Map <ReportEntity>(reportDetailsToReturn);