public async Task AcceptReplacement(
Request request,
DateTimeOffset acceptTime,
int userId,
int?impersonatorId,
InterpreterLocation interpreterLocation,
decimal?expectedTravelCosts,
string expectedTravelCostInfo,
DateTimeOffset?latestAnswerTimeForCustomer,
string brokerReferenceNumber
)
{
NullCheckHelper.ArgumentCheckNull(request, nameof(AcceptReplacement), nameof(RequestService));
CheckSetLatestAnswerTimeForCustomerValid(latestAnswerTimeForCustomer, nameof(AcceptReplacement));
request.Order.InterpreterLocations = await _tolkDbContext.OrderInterpreterLocation.GetOrderedInterpreterLocationsForOrder(request.Order.OrderId).ToListAsync();
request.AcceptReplacementOrder(
acceptTime,
userId,
impersonatorId,
expectedTravelCostInfo,
interpreterLocation,
_priceCalculationService.GetPrices(request, (CompetenceAndSpecialistLevel)request.CompetenceLevel, expectedTravelCosts),
latestAnswerTimeForCustomer,
brokerReferenceNumber
);
_notificationService.RequestReplamentOrderAccepted(request);
}
public static IEnumerable <ReportComplaintRow> GetComplaintsExcelFileRows(ReportComplaintModel complaintModel, ReportType reportType)
{
var isBroker = EnumHelper.Parent <ReportType, ReportGroup>(reportType) == ReportGroup.BrokerReport;
NullCheckHelper.ArgumentCheckNull(complaintModel, nameof(GetComplaintsExcelFileRows), nameof(StatisticsService));
return(complaintModel.Complaints
.Select(c => new ReportComplaintRow
{
OrderNumber = c.OrderNumber,
ReportDate = c.ReportDate,
BrokerName = c.BrokerName,
Language = c.Language,
Region = c.Region,
Status = c.ComplaintStatus.GetDescription(),
InterpreterId = c.InterpreterId,
AssignmentDate = c.AssignmentDate,
CustomerName = c.CustomerName,
AssignmentType = c.AssignmentType.GetDescription(),
InterpreterCompetenceLevel = (CompetenceAndSpecialistLevel?)c.CompetenceLevel ?? CompetenceAndSpecialistLevel.NoInterpreter,
ComplaintType = c.ComplaintType.GetDescription(),
CustomerUnitName = c.CustomerUnitName,
ReportPersonToDisplay = c.ReportPerson,
Department = c.Department,
ReferenceNumber = c.ReferenceNumber,
InterpreterLocation = c.InterpreterLocation.HasValue ? ((InterpreterLocation)c.InterpreterLocation.Value).GetDescription() : string.Empty,
AllowExceedingTravelCost = c.AllowExceedingTravelCost.HasValue ? isBroker ? EnumHelper.Parent <AllowExceedingTravelCost, TrueFalse>(c.AllowExceedingTravelCost.Value).GetDescription() : c.AllowExceedingTravelCost.Value.GetDescription() : string.Empty
}).ToList().OrderBy(row => row.OrderNumber));
}
public async Task AcknowledgeGroup(RequestGroup requestGroup, DateTimeOffset acknowledgeTime, int userId, int?impersonatorId)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(AcknowledgeGroup), nameof(RequestService));
requestGroup.Requests ??= await _tolkDbContext.Requests.GetRequestsForRequestGroup(requestGroup.RequestGroupId).ToListAsync();
requestGroup.Received(acknowledgeTime, userId, impersonatorId);
}
public void Refute(Complaint complaint, int userId, int?impersonatorId, string message)
{
NullCheckHelper.ArgumentCheckNull(complaint, nameof(Refute), nameof(ComplaintService));
complaint.AnswerDispute(_clock.SwedenNow, userId, impersonatorId, message, ComplaintStatus.DisputePendingTrial);
_logger.LogDebug($"Refuted complaint {complaint.ComplaintId}, pending trial");
_notificationService.ComplaintDisputePendingTrial(complaint);
}
public void AcceptDispute(Complaint complaint, int userId, int?impersonatorId, string message)
{
NullCheckHelper.ArgumentCheckNull(complaint, nameof(AcceptDispute), nameof(ComplaintService));
complaint.AnswerDispute(_clock.SwedenNow, userId, impersonatorId, message, ComplaintStatus.TerminatedAsDisputeAccepted);
_logger.LogDebug($"Accepted dispute on complaint {complaint.ComplaintId}");
_notificationService.ComplaintTerminatedAsDisputeAccepted(complaint);
}
public void Accept(Complaint complaint, int userId, int?impersonatorId, string message = null)
{
NullCheckHelper.ArgumentCheckNull(complaint, nameof(Accept), nameof(ComplaintService));
complaint.Answer(_clock.SwedenNow, userId, impersonatorId, message, ComplaintStatus.Confirmed);
_logger.LogDebug($"Accepted complaint {complaint.ComplaintId}");
_notificationService.ComplaintConfirmed(complaint);
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
NullCheckHelper.ArgumentCheckNull(bindingContext, nameof(TimeSpanModelBinder));
var timeValue = bindingContext.ValueProvider.GetValue($"{bindingContext.ModelName}");
if (timeValue == ValueProviderResult.None ||
string.IsNullOrWhiteSpace(timeValue.FirstValue))
{
return(Task.CompletedTask);
}
string timeValueSanitized;
if (timeValue.FirstValue == "0" ||
timeValue.FirstValue == "00")
{
timeValueSanitized = "00:00";
}
else
{
timeValueSanitized = timeValue.FirstValue.ContainsSwedish(":")
? timeValue.FirstValue
: timeValue.FirstValue.Insert(timeValue.FirstValue.Length - 2, ":"); // Add colon to time if not exists
}
var model = timeValueSanitized.ToSwedishTimeSpan();
bindingContext.Result = ModelBindingResult.Success(model);
return(Task.CompletedTask);
}
public async Task Decline(
Request request,
DateTimeOffset declinedAt,
int userId,
int?impersonatorId,
string message,
bool notify = true,
bool createNewRequest = true)
{
NullCheckHelper.ArgumentCheckNull(request, nameof(Decline), nameof(RequestService));
request.Decline(declinedAt, userId, impersonatorId, message);
if (!request.Order.ReplacingOrderId.HasValue)
{
if (createNewRequest)
{
await _orderService.CreateRequest(request.Order, request, notify : notify);
}
if (notify)
{
_notificationService.RequestDeclinedByBroker(request);
}
}
else
{
if (notify)
{
_notificationService.RequestReplamentOrderDeclinedByBroker(request);
}
}
}
private void AcceptRequest(Request request, DateTimeOffset acceptTime, int userId, int?impersonatorId, InterpreterBroker interpreter, InterpreterLocation interpreterLocation, CompetenceAndSpecialistLevel competenceLevel, List <OrderRequirementRequestAnswer> requirementAnswers, List <RequestAttachment> attachedFiles, decimal?expectedTravelCosts, string expectedTravelCostInfo, VerificationResult?verificationResult, DateTimeOffset?latestAnswerTimeForCustomer, string brokerReferenceNumber, bool overrideRequireAccept = false)
{
NullCheckHelper.ArgumentCheckNull(request, nameof(AcceptRequest), nameof(RequestService));
//Get prices
var prices = _priceCalculationService.GetPrices(request, competenceLevel, expectedTravelCosts);
request.Accept(acceptTime, userId, impersonatorId, interpreter, interpreterLocation, competenceLevel, requirementAnswers, attachedFiles, prices, expectedTravelCostInfo, latestAnswerTimeForCustomer, brokerReferenceNumber, verificationResult, overrideRequireAccept);
}
public void CreateValidationMetadata(ValidationMetadataProviderContext context)
{
NullCheckHelper.ArgumentCheckNull(context, nameof(ValidationMetadataProvider));
if (context.Attributes.OfType <ClientRequiredAttribute>().Any())
{
context.ValidationMetadata.IsRequired = true;
}
}
public async Task Review(Requisition requisition, int userId, int?impersonatorId)
{
NullCheckHelper.ArgumentCheckNull(requisition, nameof(Review), nameof(RequisitionService));
requisition.Review(_clock.SwedenNow, userId, impersonatorId);
await _dbContext.SaveChangesAsync();
_logger.LogDebug($"Requisition reviewed {requisition.RequisitionId}");
await _notificationService.RequisitionReviewed(requisition);
}
public IModelBinder GetBinder(ModelBinderProviderContext context)
{
NullCheckHelper.ArgumentCheckNull(context, nameof(CheckboxGroupModelBinderProvider));
if (context.Metadata.ModelType == typeof(CheckboxGroup))
{
return(new BinderTypeModelBinder(typeof(CheckboxGroupModelBinder)));
}
return(null);
}
public async Task <RequestGroup> AddListsForRequestGroup(RequestGroup requestGroup)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(AddListsForRequestGroup), nameof(RequestService));
await AddRequestsWithConfirmationListsToRequestGroup(requestGroup);
await AddPriceRowsToRequestsInGroup(requestGroup);
await AddRequirementAnswersToRequestsInGroup(requestGroup);
return(requestGroup);
}
public async Task Comment(Requisition requisition, int userId, int?impersonatorId, string message)
{
NullCheckHelper.ArgumentCheckNull(requisition, nameof(Comment), nameof(RequisitionService));
requisition.Comment(_clock.SwedenNow, userId, impersonatorId, message);
await _dbContext.SaveChangesAsync();
_logger.LogDebug($"Requisition commented {requisition.RequisitionId}");
_notificationService.RequisitionCommented(requisition);
}
public async Task ConfirmCancellation(
Request request,
DateTimeOffset confirmedAt,
int userId,
int?impersonatorId)
{
NullCheckHelper.ArgumentCheckNull(request, nameof(ConfirmCancellation), nameof(RequestService));
request.ConfirmCancellation(confirmedAt, userId, impersonatorId);
await _tolkDbContext.SaveChangesAsync();
}
public async Task ConfirmGroupNoAnswer(
RequestGroup requestGroup,
DateTimeOffset confirmedAt,
int userId,
int?impersonatorId)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(ConfirmGroupNoAnswer), nameof(RequestService));
requestGroup.ConfirmNoAnswer(confirmedAt, userId, impersonatorId);
await _tolkDbContext.SaveChangesAsync();
}
public async Task ConfirmNoReview(Requisition requisition, int userId, int?impersonatorId)
{
NullCheckHelper.ArgumentCheckNull(requisition, nameof(ConfirmNoReview), nameof(RequisitionService));
requisition.RequisitionStatusConfirmations = await _dbContext.RequisitionStatusConfirmations.GetRequisitionStatusConfirmationsForRequisition(requisition.RequisitionId).ToListAsync();
requisition.CofirmNoReview(_clock.SwedenNow, userId, impersonatorId);
await _dbContext.SaveChangesAsync();
_logger.LogDebug($"Requisition confirmed with no review {requisition.RequisitionId}");
}
public IModelBinder GetBinder(ModelBinderProviderContext context)
{
NullCheckHelper.ArgumentCheckNull(context, nameof(DateTimeOffsetModelBinderProvider));
if (context.Metadata.ModelType == typeof(DateTimeOffset) ||
context.Metadata.ModelType == typeof(DateTimeOffset?))
{
return(new BinderTypeModelBinder(typeof(DateTimeOffsetModelBinder)));
}
return(null);
}
public async Task ConfirmOrderChange(
Request request,
List <int> confirmedOrderChangeLogEntriesId,
DateTimeOffset confirmedAt,
int userId,
int?impersonatorId)
{
NullCheckHelper.ArgumentCheckNull(request, nameof(ConfirmOrderChange), nameof(RequestService));
request.ConfirmOrderChange(confirmedOrderChangeLogEntriesId, confirmedAt, userId, impersonatorId);
await _tolkDbContext.SaveChangesAsync();
}
public async Task <RequestGroup> AddRequestsWithConfirmationListsToRequestGroup(RequestGroup requestGroup)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(AddRequestsWithConfirmationListsToRequestGroup), nameof(RequestService));
requestGroup.StatusConfirmations = await _tolkDbContext.RequestGroupStatusConfirmations.GetStatusConfirmationsForRequestGroup(requestGroup.RequestGroupId).ToListAsync();
requestGroup.Requests = await _tolkDbContext.Requests.GetRequestsForRequestGroup(requestGroup.RequestGroupId).ToListAsync();
var requestStatusConfirmations = await _tolkDbContext.RequestStatusConfirmation.GetRequestStatusConfirmationsForRequestGroup(requestGroup.RequestGroupId).ToListAsync();
requestGroup.Requests.ForEach(r => r.RequestStatusConfirmations = requestStatusConfirmations.Where(rsc => rsc.RequestId == r.RequestId).ToList());
return(requestGroup);
}
public async Task SetTemporaryEmail(AspNetUser user, string newEmail, int updatedById, int?impersonatingCreatorId = null)
{
NullCheckHelper.ArgumentCheckNull(user, nameof(SetTemporaryEmail), nameof(UserService));
var emailUser = await _dbContext.Users.GetUserByIdWithTemporaryEmail(user.Id);
var entry = emailUser.TemporaryChangedEmailEntry ?? new TemporaryChangedEmailEntry();
entry.EmailAddress = newEmail;
entry.ExpirationDate = _clock.SwedenNow.AddDays(7);
entry.UpdatedByUserId = updatedById;
entry.ImpersonatingUpdatedByUserId = impersonatingCreatorId;
emailUser.TemporaryChangedEmailEntry = entry;
await _dbContext.SaveChangesAsync();
}
public async Task <int?> GetOtherInterpreterIdForSameOccasion(Request request)
{
NullCheckHelper.ArgumentCheckNull(request, nameof(GetOtherInterpreterIdForSameOccasion), nameof(RequestService));
List <Request> requests = null;
if (request.Order.IsExtraInterpreterForOrder != null)
{
requests = await _tolkDbContext.Requests.GetRequestsForOrder(request.Order.IsExtraInterpreterForOrder.OrderId).ToListAsync();
}
else if (request.Order.ExtraInterpreterOrder != null)
{
requests = await _tolkDbContext.Requests.GetRequestsForOrder(request.Order.ExtraInterpreterOrder.OrderId).ToListAsync();
}
return(requests?.Where(r => r.Status == RequestStatus.Accepted || r.Status == RequestStatus.AcceptedNewInterpreterAppointed || r.Status == RequestStatus.Approved).SingleOrDefault()?.InterpreterBrokerId);
}
public async Task DeclineGroup(
RequestGroup requestGroup,
DateTimeOffset declinedAt,
int userId,
int?impersonatorId,
string message)
{
NullCheckHelper.ArgumentCheckNull(requestGroup, nameof(DeclineGroup), nameof(RequestService));
requestGroup.Requests = await _tolkDbContext.Requests.GetRequestsForRequestGroup(requestGroup.RequestGroupId).ToListAsync();
requestGroup.OrderGroup.Orders = await _tolkDbContext.Orders.GetOrdersForOrderGroup(requestGroup.OrderGroupId).ToListAsync();
requestGroup.OrderGroup.RequestGroups = await _tolkDbContext.RequestGroups.GetRequestGroupsForOrderGroup(requestGroup.OrderGroupId).ToListAsync();
requestGroup.Decline(declinedAt, userId, impersonatorId, message);
await _orderService.CreateRequestGroup(requestGroup.OrderGroup, requestGroup);
_notificationService.RequestGroupDeclinedByBroker(requestGroup);
}
public async Task Accept(
Request request,
DateTimeOffset acceptTime,
int userId,
int?impersonatorId,
InterpreterBroker interpreter,
InterpreterLocation interpreterLocation,
CompetenceAndSpecialistLevel competenceLevel,
List <OrderRequirementRequestAnswer> requirementAnswers,
List <RequestAttachment> attachedFiles,
decimal?expectedTravelCosts,
string expectedTravelCostInfo,
DateTimeOffset?latestAnswerTimeForCustomer,
string brokerReferenceNumber
)
{
NullCheckHelper.ArgumentCheckNull(request, nameof(Accept), nameof(RequestService));
NullCheckHelper.ArgumentCheckNull(interpreter, nameof(Accept), nameof(RequestService));
//maybe should be moved to AcceptRequest depending on ordergroup requesting each...
request.Order.Requirements = await _tolkDbContext.OrderRequirements.GetRequirementsForOrder(request.Order.OrderId).ToListAsync();
request.Order.InterpreterLocations = await _tolkDbContext.OrderInterpreterLocation.GetOrderedInterpreterLocationsForOrder(request.Order.OrderId).ToListAsync();
request.Order.CompetenceRequirements = await _tolkDbContext.OrderCompetenceRequirements.GetOrderedCompetenceRequirementsForOrder(request.Order.OrderId).ToListAsync();
CheckSetLatestAnswerTimeForCustomerValid(latestAnswerTimeForCustomer, nameof(Accept));
AcceptRequest(request, acceptTime, userId, impersonatorId, interpreter, interpreterLocation, competenceLevel, requirementAnswers, attachedFiles, expectedTravelCosts, expectedTravelCostInfo, await VerifyInterpreter(request.OrderId, interpreter, competenceLevel), latestAnswerTimeForCustomer: latestAnswerTimeForCustomer, brokerReferenceNumber);
//Create notification
switch (request.Status)
{
case RequestStatus.Accepted:
_notificationService.RequestAccepted(request);
break;
case RequestStatus.Approved:
_notificationService.RequestAnswerAutomaticallyApproved(request);
break;
default:
throw new NotImplementedException("NOT OK!!");
}
}
public async Task Create(Request request, int userId, int?impersonatorId, string message, ComplaintType type)
{
NullCheckHelper.ArgumentCheckNull(request, nameof(Create), nameof(ComplaintService));
request.Complaints = await _dbContext.Complaints.GetComplaintsForRequest(request.RequestId).ToListAsync();
var complaint = new Complaint
{
Request = request,
ComplaintType = type,
ComplaintMessage = message,
Status = ComplaintStatus.Created,
CreatedAt = _clock.SwedenNow,
CreatedBy = userId,
ImpersonatingCreatedBy = impersonatorId
};
request.CreateComplaint(complaint, _clock.SwedenNow);
_notificationService.ComplaintCreated(complaint);
_logger.LogDebug($"Created complaint for request {request.RequestId}");
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
NullCheckHelper.ArgumentCheckNull(bindingContext, nameof(RadioButtonGroupModelBinder));
var value = bindingContext.ValueProvider.GetValue($"{bindingContext.ModelName}");
if (value == ValueProviderResult.None)
{
return(Task.CompletedTask);
}
RadioButtonGroup model = new RadioButtonGroup {
SelectedItem = new SelectListItem {
Value = value.FirstValue
}
};
bindingContext.Result = ModelBindingResult.Success(model);
return(Task.CompletedTask);
}
public OrderGroup(AspNetUser createdByUser, AspNetUser createdByImpersonator, CustomerOrganisation customerOrganisation, DateTimeOffset createdAt, IEnumerable <Order> orders, bool requireSameInterpreter = true)
{
NullCheckHelper.ArgumentCheckNull(customerOrganisation, nameof(OrderGroup), nameof(OrderGroup));
//Verify that all orders have the same customer, region and language
Validate.Ensure(orders.GroupBy(o => o.CustomerOrganisationId).Count() == 1, "A group cannot have orders connected to several customers.");
Validate.Ensure(orders.GroupBy(o => o.LanguageId).Count() == 1, "A group cannot have orders connected to several languages.");
Validate.Ensure(orders.GroupBy(o => o.RegionId).Count() == 1, "A group cannot have orders connected to several regions.");
Orders = orders.ToList();
CustomerOrganisation = customerOrganisation;
CustomerOrganisationId = customerOrganisation.CustomerOrganisationId;
CreatedAt = createdAt;
CreatedByUser = createdByUser;
CreatedByImpersonator = createdByImpersonator;
RequestGroups = new List <RequestGroup>();
RequireSameInterpreter = requireSameInterpreter;
Status = OrderStatus.Requested;
Requirements = new List <OrderGroupRequirement>();
InterpreterLocations = new List <OrderGroupInterpreterLocation>();
CompetenceRequirements = new List <OrderGroupCompetenceRequirement>();
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
NullCheckHelper.ArgumentCheckNull(bindingContext, nameof(CheckboxGroupModelBinder));
var selectedValues = bindingContext.ValueProvider.GetValue($"{bindingContext.ModelName}");
if (selectedValues == ValueProviderResult.None)
{
return(Task.CompletedTask);
}
var model = new CheckboxGroup
{
SelectedItems = selectedValues.Select(sv => new SelectListItem {
Value = sv
})
};
bindingContext.Result = ModelBindingResult.Success(model);
return(Task.CompletedTask);
}
public Task BindModelAsync(ModelBindingContext bindingContext)
{
NullCheckHelper.ArgumentCheckNull(bindingContext, nameof(DateTimeOffsetModelBinder));
var dateValue = bindingContext.ValueProvider.GetValue($"{bindingContext.ModelName}.Date");
var timeValue = bindingContext.ValueProvider.GetValue($"{bindingContext.ModelName}.TimeOfDay");
var timeHourValue = bindingContext.ValueProvider.GetValue($"{bindingContext.ModelName}.Hour");
var timeMinuteValue = bindingContext.ValueProvider.GetValue($"{bindingContext.ModelName}.Minute");
// Date and time always required
if (!ValueDefinedAndUsed(dateValue) || (!ValueDefinedAndUsed(timeValue) && (!ValueDefinedAndUsed(timeHourValue))))
{
return(Task.CompletedTask);
}
string timeValueSanitized;
if (ValueDefinedAndUsed(timeValue))
{
if (timeValue.FirstValue == "0" ||
timeValue.FirstValue == "00")
{
timeValueSanitized = "00:00";
}
else
{
timeValueSanitized = timeValue.FirstValue.ContainsSwedish(":")
? timeValue.FirstValue
: timeValue.FirstValue.Insert(timeValue.FirstValue.Length - 2, ":"); // Add colon to time if not exists
}
}
else
{
timeValueSanitized = $"{timeHourValue.FirstValue}:{timeMinuteValue.FirstValue}";
}
DateTime dateTime = $"{dateValue.FirstValue} {timeValueSanitized}".ToSwedishDateTime();
var model = dateTime.ToDateTimeOffsetSweden();
bindingContext.Result = ModelBindingResult.Success(model);
return(Task.CompletedTask);
}
public async Task SendChangedEmailLink(AspNetUser user, string newEmailAddress, string resetLink, bool changedByAdmin = false)
{
NullCheckHelper.ArgumentCheckNull(user, nameof(SendChangedEmailLink), nameof(UserService));
string message = changedByAdmin ? $"Om du har begärt att få din e-postadress ändrad för '{user.FullName}' så logga in i {Constants.SystemName} med din gamla e-post {user.Email} och klicka eller klistra därefter in länken nedan i webbläsaren för att verifiera ändringen." : $"Om du har bytt e-postadress för '{user.FullName}' så klicka på länken Verifiera e-postadress, om du då får upp en inloggningssida så behöver du logga in med din gamla e-postadress och det vanliga lösenordet, är du redan inloggad i webbläsaren så får du direkt ett meddelande om att e-postadressen är uppdaterad.";
var bodyPlain =
$@"Ändring av e-postadress för {Constants.SystemName}
{message}
{resetLink}
Om du inte har bytt/begärt byte av e-postadress kan du radera det här
meddelandet och kontakta
supporten på {_options.Support.FirstLineEmail}.";
var bodyHtml =
$@"<h2>Ändring av e-postadress för {Constants.SystemName} </h2>
<div>{message}</div>
<div>{HtmlHelper.GetButtonDefaultLargeTag(resetLink.AsUri(), "Verifiera e-postadress")}</div>
<div>Om du inte har bytt/begärt byte av e-postadress kan du radera det här
meddelandet och kontakta
supporten på {_options.Support.FirstLineEmail}.</div>";
_notificationService.CreateEmail(
newEmailAddress,
$"Ändring av e-postadress för {Constants.SystemName}",
bodyPlain,
bodyHtml,
NotificationType.ChangedEmailVerification,
false,
false);
await _dbContext.SaveChangesAsync();
_logger.LogInformation("Verification link for changed email sent to {email} for {userId}",
newEmailAddress, user.Id);
}
