public async Task <IActionResult> Process(int id)
{
var requestGroup = await _dbContext.RequestGroups.GetRequestGroupToView(id);
if ((await _authorizationService.AuthorizeAsync(User, requestGroup, Policies.Accept)).Succeeded)
{
if (!requestGroup.IsToBeProcessedByBroker)
{
_logger.LogWarning("Wrong status when trying to process request group. Status: {request.Status}, RequestGroupId: {request.RequestGroupId}", requestGroup.Status, requestGroup.RequestGroupId);
return(RedirectToAction(nameof(View), new { id }));
}
if (requestGroup.Status == RequestStatus.Created)
{
await _requestService.AcknowledgeGroup(requestGroup, _clock.SwedenNow, User.GetUserId(), User.TryGetImpersonatorId());
await _dbContext.SaveChangesAsync();
}
OrderGroup orderGroup = await _dbContext.OrderGroups.GetFullOrderGroupById(requestGroup.OrderGroupId);
await _orderService.AddOrdersWithListsForGroup(orderGroup);
await _requestService.AddListsForRequestGroup(requestGroup);
requestGroup.Requests.ForEach(r => r.Order = orderGroup.Orders.Where(o => o.OrderId == r.OrderId).SingleOrDefault());
var model = RequestGroupProcessModel.GetModelFromRequestGroup(requestGroup, Guid.NewGuid(), _options.CombinedMaxSizeAttachments, _options.AllowDeclineExtraInterpreterOnRequestGroups);
await _listToModelService.AddInformationFromListsToModel(model, User.GetUserId());
model.CustomerInformationModel.IsCustomer = false;
model.CustomerInformationModel.UseSelfInvoicingInterpreter = _cacheService.CustomerSettings.Any(c => c.CustomerOrganisationId == requestGroup.OrderGroup.CustomerOrganisationId && c.UsedCustomerSettingTypes.Any(cs => cs == CustomerSettingType.UseSelfInvoicingInterpreter));
//if not first broker in rank (requests are not answered and have no pricerows) we need to get a calculated price with correct broker fee
if (requestGroup.Ranking.Rank != 1)
{
List <OrderOccasionDisplayModel> tempOccasionList = new List <OrderOccasionDisplayModel>();
foreach (OrderOccasionDisplayModel occasion in model.OccasionList.Occasions)
{
var request = requestGroup.Requests.Single(r => r.RequestId == occasion.RouteId);
tempOccasionList.Add(OrderOccasionDisplayModel.GetModelFromOrder(request.Order, GetPriceinformationOrderToDisplay(request, model.RequestedCompetenceLevels.ToList()), request));
}
model.OccasionList.Occasions = tempOccasionList;
}
return(View(model));
}
return(Forbid());
}
public async Task <IActionResult> Process(RequestGroupProcessModel model)
{
var requestGroup = await _dbContext.RequestGroups.GetRequestGroupToProcessById(model.RequestGroupId);
if ((await _authorizationService.AuthorizeAsync(User, requestGroup, Policies.Accept)).Succeeded)
{
if (!requestGroup.IsToBeProcessedByBroker)
{
return(RedirectToAction("Index", "Home", new { ErrorMessage = "Förfrågan är redan behandlad" }));
}
InterpreterAnswerDto interpreterModel = null;
try
{
interpreterModel = await GetInterpreter(model.InterpreterAnswerModel, requestGroup.Ranking.BrokerId);
}
catch (ArgumentException ex)
{
ModelState.AddModelError($"{nameof(model.InterpreterAnswerModel)}.{ex.ParamName}", ex.Message);
}
InterpreterAnswerDto extrainterpreterModel = null;
try
{
extrainterpreterModel = model.ExtraInterpreterAnswerModel != null ? await GetInterpreter(model.ExtraInterpreterAnswerModel, requestGroup.Ranking.BrokerId) : null;
}
catch (ArgumentException ex)
{
ModelState.AddModelError($"{nameof(model.ExtraInterpreterAnswerModel)}.{ex.ParamName}", ex.Message);
}
if (ModelState.IsValid)
{
try
{
await _requestService.AcceptGroup(
requestGroup,
_clock.SwedenNow,
User.GetUserId(),
User.TryGetImpersonatorId(),
model.InterpreterLocation.Value,
interpreterModel,
extrainterpreterModel,
model.Files?.Select(f => new RequestGroupAttachment {
AttachmentId = f.Id
}).ToList(),
(model.SetLatestAnswerTimeForCustomer != null && EnumHelper.Parse <TrueFalse>(model.SetLatestAnswerTimeForCustomer.SelectedItem.Value) == TrueFalse.Yes)?model.LatestAnswerTimeForCustomer : null,
model.BrokerReferenceNumber
);
await _dbContext.SaveChangesAsync();
return(RedirectToAction("Index", "Home", new { message = "Svar har skickats på sammanhållen bokning" }));
}
catch (InvalidOperationException e)
{
_logger.LogError("Process failed for requestgroup, RequestGroupId: {requestGroup.RequestGroupId}, message {e.Message}", requestGroup.RequestGroupId, e.Message);
return(RedirectToAction("Index", "Home", new { errormessage = e.Message }));
}
}
//Should return to Process if error is of a kind that can be handled in the ui.
return(View(nameof(Process), model));
}
return(Forbid());
}
internal async Task <RequestGroupProcessModel> AddInformationFromListsToModel(RequestGroupProcessModel model, int userId)
{
int requestGroupId = model.RequestGroupId;
var orderGroup = await _dbContext.OrderGroups.GetOrderGroupById(model.OrderGroupId);
orderGroup.Requirements = await _dbContext.OrderGroupRequirements.GetRequirementsForOrderGroup(orderGroup.OrderGroupId).ToListAsync();
orderGroup.CompetenceRequirements = await _dbContext.OrderGroupCompetenceRequirements.GetOrderedCompetenceRequirementsForOrderGroup(orderGroup.OrderGroupId).ToListAsync();
model.RequestedCompetenceLevelFirst = orderGroup.CompetenceRequirements.SingleOrDefault(l => l.Rank == 1 || l.Rank == null)?.CompetenceLevel;
model.RequestedCompetenceLevelSecond = orderGroup.CompetenceRequirements.SingleOrDefault(l => l.Rank == 2)?.CompetenceLevel;
model.InterpreterAnswerModel = new InterpreterAnswerModel
{
RequiredRequirementAnswers = orderGroup.Requirements.Where(r => r.IsRequired).Select(r => new RequestRequirementAnswerModel
{
OrderRequirementId = r.OrderGroupRequirementId,
IsRequired = true,
Description = r.Description,
RequirementType = r.RequirementType,
}).ToList(),
DesiredRequirementAnswers = orderGroup.Requirements.Where(r => !r.IsRequired).Select(r => new RequestRequirementAnswerModel
{
OrderRequirementId = r.OrderGroupRequirementId,
IsRequired = false,
Description = r.Description,
RequirementType = r.RequirementType,
}).ToList(),
};
model.ExtraInterpreterAnswerModel = model.HasExtraInterpreter ? new InterpreterAnswerModel
{
RequiredRequirementAnswers = orderGroup.Requirements.Where(r => r.IsRequired).Select(r => new RequestRequirementAnswerModel
{
OrderRequirementId = r.OrderGroupRequirementId,
IsRequired = true,
Description = r.Description,
RequirementType = r.RequirementType,
}).ToList(),
DesiredRequirementAnswers = orderGroup.Requirements.Where(r => !r.IsRequired).Select(r => new RequestRequirementAnswerModel
{
OrderRequirementId = r.OrderGroupRequirementId,
IsRequired = false,
Description = r.Description,
RequirementType = r.RequirementType,
}).ToList(),
} : null;
model.Dialect = orderGroup.Requirements.Any(r => r.RequirementType == RequirementType.Dialect) ? orderGroup.Requirements.Single(r => r.RequirementType == RequirementType.Dialect)?.Description : string.Empty;
var views = await _dbContext.RequestGroupViews.GetActiveViewsForRequestGroup(requestGroupId).ToListAsync();
model.ViewedByUser = views.Any(rv => rv.ViewedBy != userId) ?
views.First(rv => rv.ViewedBy != userId).ViewedByUser.FullName + " håller också på med denna förfrågan"
: string.Empty;
model.AttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForOrderGroup(orderGroup.OrderGroupId), "Bifogade filer");
return(model);
}
