public async Task <ReportViewModel> Add(Report entity) { Report data = new Report() { CreatedDate = DateTime.Now, AuthorId = entity.AuthorId, IsApproved = false, ModifiedDate = DateTime.Now, Reason = entity.Reason, ObjectId = entity.ObjectId, }; await reportRepository.AddAsync(data); return(mapper.Map <ReportViewModel>(data)); }
public ReportMutation(IReportRepository repository) { FieldAsync <ReportQueryType>( "addReport", arguments: new QueryArguments(new QueryArgument <NonNullGraphType <ReportCreateViewModel> > { Name = "report" }), resolve: async context => { var report = context.GetArgument <Report>("report"); return(await context.TryAsyncResolve(async _ => await repository.AddAsync(report))); } ); FieldAsync <AccountQueryType>( "removeReport", arguments: new QueryArguments(new QueryArgument <NonNullGraphType <StringGraphType> > { Name = "id" }), resolve: async context => { var id = context.GetArgument <string>("id"); return(await context.TryAsyncResolve( async _ => await repository.RemoveAsync(Guid.Parse(id)) )); } ); }
public async Task CreateOrUpdateReportFromCase(Case currentCase, Report report, Grade grade, int numberOfLVI, string userId, bool isSubmitted = false) { Report previousReport = GetPreviousUserReport(userId); ReportStatistics statistics = null; if (isSubmitted) { statistics = await Task.Run(() => CalculateStatistics(currentCase.PatientAge, currentCase.TumourSize, grade, numberOfLVI, previousReport)); } if (report == null) { int newReportNumber = previousReport != null ? previousReport.UserReportNumber + 1 : 1; Report newReport = new Report(newReportNumber, userId, currentCase.Id, statistics, isSubmitted); newReport.TumourGrade = grade; newReport.NumberofLVI = numberOfLVI; await _reportRepository.AddAsync(newReport); } else { report.TumourGrade = grade; report.NumberofLVI = numberOfLVI; report.Statistics = statistics; await _reportRepository.UpdateAsync(report); } }
public async Task <EntityResponse <Report> > Handle(CreateReportCommand request, CancellationToken cancellationToken) { var response = new EntityResponse <Report> () { ReponseName = nameof(CreateReportCommand), Content = new List <Report> () { } }; var entity = _mapper.Map <Report> (request); var newentity = await _reportRepository.AddAsync(entity); if (newentity == null) { response.Status = ResponseType.Warning; response.Message = $"{nameof(Report)} could not be created."; response.Content = null; } else { response.Status = ResponseType.Success; response.Message = $"{nameof(Report)} created successfully."; response.Content.Add(newentity); } return(response); }
public async Task <ReportDto> Handle(CreateReportCommand request, CancellationToken cancellationToken) { var report = new Report { Message = request.Message, DateReported = DateTime.UtcNow, ReportType = request.ReportType, TelegramUserId = request.TelegramUserId }; var user = await _userRepository.GetAsync(report.TelegramUserId); if (user == null) { throw new NotValidException(nameof(report.TelegramUserId), $"Telegram User with id ({report.TelegramUserId}) does not exist"); } await _reportRepository.AddAsync(report); await _reportRepository.UnitOfWork.SaveChangesAsync(); var result = _mapper.Map <ReportDto>(report); return(result); }
public async Task HandleAsync(RemarkReported @event) { await _handler .Run(async() => { var report = new Report { Id = Guid.NewGuid(), RemarkId = @event.RemarkId, ResourceId = @event.ResourceId, UserId = @event.UserId, Type = @event.Type, CreatedAt = DateTime.UtcNow }; await _reportRepository.AddAsync(report); var remark = await _remarkRepository.GetByIdAsync(@event.RemarkId); switch (@event.Type) { case "activity": remark.Value.States .Single(x => x.Id == @event.ResourceId.Value).ReportsCount++; break; case "comment": remark.Value.Comments .Single(x => x.Id == @event.ResourceId.Value).ReportsCount++; break; case "remark": remark.Value.ReportsCount++; break; } await _remarkRepository.UpdateAsync(remark.Value); await _cache.AddAsync(remark.Value); }) .OnError((ex, logger) => { logger.Error(ex, $"Error occured while handling {@event.GetType().Name} event"); }) .ExecuteAsync(); }
public async Task AddAsync(Guid remarkId, Guid?resourceId, string type, string userId) { Logger.Information($"Adding a report for remark: '{remarkId}', type: '{type}', " + $"resource: '{resourceId}', user: '******'."); if (type.Empty()) { throw new ServiceException(OperationCodes.EmptyReportType, $"Empty report type sent by user: '******' " + $"for remark: '{remarkId}' and resource: '{resourceId}'."); } type = type.ToLowerInvariant(); if (await _reportRepository.ExistsAsync(remarkId, resourceId, type, userId)) { throw new ServiceException(OperationCodes.ReportAlreadySent, $"Report: '{type}' was already sent by user: '******' " + $"for remark: '{remarkId}' and resource: '{resourceId}'."); } Report report = null; switch (type) { case "activity": report = await ReportActivityAsync(remarkId, resourceId, userId); break; case "comment": report = await ReportCommentAsync(remarkId, resourceId, userId); break; case "remark": report = await ReportRemarkAsync(remarkId, userId); break; default: throw new ServiceException(OperationCodes.InvalidReportType, $"Invalid report type: '{type}' sent by user: '******' " + $"for remark: '{remarkId}' and resource: '{resourceId}'."); } await _reportRepository.AddAsync(report); }
public async Task <IActionResult> SubmitReport(string type, string item, string reason, string reasonExplanation) { string[] validTypes = new string[] { "Comment", "Puzzle" }; if (!validTypes.Contains(type)) { return(Json(new { success = false, error = "Unknown report type." })); } if (!validReasonsForType[type].Contains(reason)) { return(Json(new { success = false, error = "Invalid reason" })); } Report report = new Report(Guid.NewGuid().ToString(), type, (await loginHandler.LoggedInUserIdAsync(HttpContext)).Value, item, reason, reasonExplanation, false, null); if (await reportRepository.AddAsync(report)) { return(Json(new { success = true })); } else { return(Json(new { success = false, error = "Reporting failed." })); } }
public async Task <IDataResult <Report> > AddAsync(Report report) { var query = await _reportRepository.AddAsync(report); return(new SuccessDataResult <Report>(query, Messages.ReportAdded)); }