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));
}
