internal async Task <OrderBaseModel> AddInformationFromListsToModel(OrderBaseModel model, int orderGroupId)
{
model.AttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForOrderGroup(orderGroupId), "Bifogade filer");
OrderCompetenceRequirement competenceFirst = null;
OrderCompetenceRequirement competenceSecond = null;
var competenceRequirements = _dbContext.OrderGroupCompetenceRequirements.GetOrderedCompetenceRequirementsForOrderGroup(orderGroupId).Select(r => new OrderCompetenceRequirement
{
CompetenceLevel = r.CompetenceLevel,
Rank = r.Rank,
}).ToList();
competenceRequirements = competenceRequirements.OrderBy(r => r.Rank).ToList();
competenceFirst = competenceRequirements.Count > 0 ? competenceRequirements[0] : null;
competenceSecond = competenceRequirements.Count > 1 ? competenceRequirements[1] : null;
model.RequestedCompetenceLevelFirst = competenceFirst?.CompetenceLevel;
model.RequestedCompetenceLevelSecond = competenceSecond?.CompetenceLevel;
model.OrderRequirements = _dbContext.OrderGroupRequirements.GetRequirementsForOrderGroup(orderGroupId).Select(r => new OrderRequirementModel
{
OrderRequirementId = r.OrderGroupRequirementId,
RequirementDescription = r.Description,
RequirementIsRequired = r.IsRequired,
RequirementType = r.RequirementType
}).ToList();
return(model);
}
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);
}
internal async Task <ReplaceOrderModel> AddInformationFromListsToModel(ReplaceOrderModel model)
{
int id = model.ReplacingOrderId;
//LISTS
await GetOrderBaseLists(model, await _dbContext.OrderInterpreterLocation.GetOrderedInterpreterLocationsForOrder(id).ToListAsync(), id);
model.AttachmentListModel = await AttachmentListModel.GetEditableModelFromList(_dbContext.Attachments.GetAttachmentsForOrder(model.ReplacingOrderId), string.Empty, "Möjlighet att bifoga filer som kan vara relevanta vid tillsättning av tolk");
model.Files = model.AttachmentListModel.Files.Any() ? model.AttachmentListModel.Files : null;
return(model);
}
internal async Task <RequisitionViewModel> AddInformationFromListsToModel(RequisitionViewModel model)
{
var requisitions = await _dbContext.Requisitions.GetRequisitionsForRequest(model.RequestId).ToListAsync();
var viewedRequisition = requisitions.SingleOrDefault(r => r.RequisitionId == model.RequisitionId);
viewedRequisition.RequisitionStatusConfirmations = await _dbContext.RequisitionStatusConfirmations.GetRequisitionStatusConfirmationsForRequisition(viewedRequisition.RequisitionId).ToListAsync();
model.AttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForRequisition(viewedRequisition.RequisitionId), "Bifogade filer");
model.CanProcess = viewedRequisition.ProcessAllowed;
model.CanConfirmNoReview = viewedRequisition.CofirmNoReviewAllowed;
model.CanReplaceRequisition = requisitions.All(r => r.Status == RequisitionStatus.Commented) && requisitions.OrderBy(r => r.CreatedAt).Last().RequisitionId == viewedRequisition.RequisitionId;
viewedRequisition.PriceRows = await _dbContext.RequisitionPriceRows.GetPriceRowsForRequisition(viewedRequisition.RequisitionId).ToListAsync();
viewedRequisition.MealBreaks = await _dbContext.MealBreaks.GetMealBreksForRequisition(viewedRequisition.RequisitionId).ToListAsync();
model.ResultPriceInformationModel = PriceInformationModel.GetPriceinformationToDisplayForRequisition(viewedRequisition, false);
model.RequestPriceInformationModel = PriceInformationModel.GetPriceinformationToDisplay(await _dbContext.RequestPriceRows.GetPriceRowsForRequest(model.RequestId).ToListAsync(), PriceInformationType.Request, mealBreakIncluded: model.MealBreakIncluded ?? false, description: "Om rekvisitionen innehåller ersättning för bilersättning och traktamente kan förmedlingen komma att debitera påslag för sociala avgifter för de tolkar som inte är registrerade för F-skatt");
if (requisitions.Count < 2)
{
return(null);
}
var previousRequisition = requisitions
.Where(r => r.Status == RequisitionStatus.Commented || r.Status == RequisitionStatus.DeniedByCustomer)
.OrderByDescending(r => r.CreatedAt)
.First();
model.PreviousRequisitionView = RequisitionViewModel.GetPreviousRequisitionView(previousRequisition.Request);
model.PreviousRequisitionView.AttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForRequisition(previousRequisition.RequisitionId), "Bifogade filer");
previousRequisition.PriceRows = await _dbContext.RequisitionPriceRows.GetPriceRowsForRequisition(previousRequisition.RequisitionId).ToListAsync();
previousRequisition.MealBreaks = await _dbContext.MealBreaks.GetMealBreksForRequisition(previousRequisition.RequisitionId).ToListAsync();
model.PreviousRequisitionView.ResultPriceInformationModel = PriceInformationModel.GetPriceinformationToDisplayForRequisition(previousRequisition, false);
model.PreviousRequisitionView.RequestPriceInformationModel = model.RequestPriceInformationModel;
model.RelatedRequisitions = requisitions
.OrderBy(r => r.CreatedAt)
.Select(r => r.RequisitionId)
.ToList();
return(model);
}
public async Task <IActionResult> View(int id)
{
var request = await _dbContext.Requests.GetRequestForInterpretertById(id);
request.Requisitions = await _dbContext.Requisitions.GetRequisitionsForRequest(request.RequestId).ToListAsync();
request.Order.InterpreterLocations = await _dbContext.OrderInterpreterLocation.GetOrderedInterpreterLocationsForOrder(request.OrderId).ToListAsync();
request.PriceRows = await _dbContext.RequestPriceRows.GetPriceRowsForRequest(request.RequestId).ToListAsync();
var model = AssignmentModel.GetModelFromRequest(request, _clock.SwedenNow);
model.RequestAttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForRequest(request.RequestId, request.RequestGroupId), "Bifogade filer från förmedling");
model.OrderAttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForOrderAndGroup(request.OrderId, request.Order.OrderGroupId), "Bifogade filer från myndighet");
if ((await _authorizationService.AuthorizeAsync(User, request, Policies.View)).Succeeded)
{
return(View(AssignmentModel.GetModelFromRequest(request, _clock.SwedenNow)));
}
return(Forbid());
}
internal async Task <OrderViewModel> AddInformationFromListsToModel(OrderViewModel model)
{
int id = model.OrderId.Value;
//Lists
var orderStatusConfirmations = await _dbContext.OrderStatusConfirmation.GetStatusConfirmationsForOrder(id).ToListAsync();
model.HasNoBrokerAcceptedConfirmation = orderStatusConfirmations.Any(os => os.OrderStatus == OrderStatus.NoBrokerAcceptedOrder);
model.HasResponseNotAnsweredByCreatorConfirmation = orderStatusConfirmations.Any(os => os.OrderStatus == OrderStatus.ResponseNotAnsweredByCreator);
//Locations
var interpreterLocations = await _dbContext.OrderInterpreterLocation.GetOrderedInterpreterLocationsForOrder(id).ToListAsync();
await GetOrderBaseLists(model, interpreterLocations, id);
if (model.UseAttachments)
{
model.AttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForOrderAndGroup(id, model.OrderGroupId), "Bifogade filer från myndighet");
}
model.PreviousRequests = await BrokerListModel.GetFromList(_dbContext.Requests.GetLostRequestsForOrder(id));
model.OrderCalculatedPriceInformationModel = PriceInformationModel.GetPriceinformationToDisplay(await _dbContext.OrderPriceRows.GetPriceRowsForOrder(id).ToListAsync(), PriceInformationType.Order, mealBreakIncluded: model.MealbreakIncluded);
model.Dialect = model.OrderRequirements.SingleOrDefault(r => r.RequirementType == RequirementType.Dialect)?.RequirementDescription;
if (model.RequestId.HasValue)
{
var requestStatusConfirmations = await _dbContext.RequestStatusConfirmation.GetStatusConfirmationsForRequest(model.RequestId.Value).ToListAsync();
model.HasCancelledByBrokerConfirmation = requestStatusConfirmations.Any(rs => rs.RequestStatus == RequestStatus.CancelledByBroker);
model.HasNoRequisitionConfirmation = requestStatusConfirmations.Any(rs => rs.RequestStatus == RequestStatus.Approved);
model.HasDeniedByCreatorConfirmation = requestStatusConfirmations.Any(rs => rs.RequestStatus == RequestStatus.DeniedByCreator);
model.HasResponseNotAnsweredByCreatorBrokerConfirmation = requestStatusConfirmations.Any(rs => rs.RequestStatus == RequestStatus.ResponseNotAnsweredByCreator);
model.HasCancelledByCreatorWhenApprovedConfirmation = requestStatusConfirmations.Any(rs => rs.RequestStatus == RequestStatus.CancelledByCreatorWhenApproved);
model.ActiveRequestPriceInformationModel = PriceInformationModel.GetPriceinformationToDisplay(await _dbContext.RequestPriceRows.GetPriceRowsForRequest(model.RequestId.Value).ToListAsync(), PriceInformationType.Request, mealBreakIncluded: model.MealbreakIncluded);
model.RequestAttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForRequest(model.RequestId.Value, model.RequestGroupId), "Bifogade filer från förmedling");
var requestChecks = await _dbContext.Requests
.Where(r => r.RequestId == model.RequestId.Value)
.Select(r => new
{
LatestComplaintId = r.Complaints.Max(c => (int?)c.ComplaintId),
LatestRequisitionId = r.Requisitions.Max(req => (int?)req.RequisitionId),
HasActiveRequisitions = r.Requisitions.Any(req => req.Status == RequisitionStatus.Reviewed || req.Status == RequisitionStatus.Created),
HasComplaints = r.Complaints.Any(),
}).SingleAsync();
model.HasComplaints = requestChecks.HasComplaints;
model.ComplaintId = requestChecks.LatestComplaintId;
model.RequisitionId = requestChecks.LatestRequisitionId;
model.HasActiveRequisitions = requestChecks.HasActiveRequisitions;
model.ActiveRequest.RequirementAnswers = await RequestRequirementAnswerModel.GetFromList(_dbContext.OrderRequirementRequestAnswer.GetRequirementAnswersForRequest(model.RequestId.Value));
//just for broker
var orderChanges = await _dbContext.OrderChangeLogEntries.GetOrderChangeLogEntitesForOrder(id).Where(oc => oc.BrokerId == model.ActiveRequest.BrokerId && oc.OrderChangeLogType != OrderChangeLogType.ContactPerson && oc.OrderChangeConfirmation == null).ToListAsync();
model.ConfirmedOrderChangeLogEntries = orderChanges.Select(oc => oc.OrderChangeLogEntryId).ToList();
if (orderChanges.Any() && (model.ActiveRequest.Status == RequestStatus.Approved || model.ActiveRequest.Status == RequestStatus.AcceptedNewInterpreterAppointed) && model.StartAtIsInFuture)
{
model.DisplayOrderChangeText = await GetOrderChangeTextToDisplay(model.ActiveRequest.BrokerId, interpreterLocations, model.InterpreterLocationAnswer, orderChanges, model.Description, model.UnitName, model.InvoiceReference, model.CustomerReferenceNumber);
}
if (model.ReplacedByOrderId.HasValue)
{
var request = await _dbContext.Requests.GetLastRequestWithRankingForOrder(model.ReplacedByOrderId.Value);
if (request.Ranking.BrokerId == model.ActiveRequest.BrokerId)
{
model.ActiveRequest.ReplacedByOrderRequestId = request.RequestId;
}
}
if (model.ReplacingOrderId.HasValue)
{
model.ActiveRequest.ReplacingOrderRequestId = (await _dbContext.Requests.GetLastRequestForOrder(model.ReplacingOrderId.Value)).RequestId;
}
//end just for broker
}
return(model);
}
internal async Task <RequestGroupViewModel> AddInformationFromListsToModel(RequestGroupViewModel model)
{
model.AttachmentListModel = await AttachmentListModel.GetReadOnlyModelFromList(_dbContext.Attachments.GetAttachmentsForRequestGroup(model.RequestGroupId), "Bifogade filer");
return(model);
}
