public async Task EventChangeTest()
{
string resVal1 = null;
ChangeResponse resVal2 = null;
var client = new SocketIO(Uri, new SocketIOOptions
{
Query = new Dictionary <string, string>
{
{ "token", "io" }
}
});
client.OnConnected += async(sender, e) =>
{
await client.EmitAsync("change", new
{
code = 200,
message = "val1"
}, "val2");
};
client.On("change", response =>
{
resVal1 = response.GetValue <string>();
resVal2 = response.GetValue <ChangeResponse>(1);
});
await client.ConnectAsync();
await Task.Delay(200);
await client.DisconnectAsync();
Assert.AreEqual("val2", resVal1);
Assert.AreEqual(200, resVal2.Code);
Assert.AreEqual("val1", resVal2.Message);
}
public IEnumerable <JanusMessageInfo> StoreChanges(ChangeResponse changes, CancellationToken cancelToken)
{
using (var wrapper = new TransactionWrapper(cancelToken))
{
var db = wrapper.Connection;
StoreRatings(db, changes.newRating);
var forumUpdates = from post in changes.newMessages
group post by post.forumId into forumMessages
join forum in db.Forums on forumMessages.Key equals forum.Id
select new
{
ForumId = forum.Id,
NewMessages = from msg in forumMessages
where msg.messageDate.FromRsdnTimeToUtc() > (forum.Posted ?? DateTime.MinValue)
select msg,
OldMessages = from msg in forumMessages
where msg.messageDate.FromRsdnTimeToUtc() <= (forum.Posted ?? DateTime.MinValue) &&
msg.updateDate > DateTime.MinValue
select msg
};
var newMsgs = forumUpdates.SelectMany(fu => fu.NewMessages).ToArray();
var newPosts = mapper.Map <IEnumerable <DbPost> >(newMsgs);
db.Posts.AddRange(newPosts);
var oldMsgs = forumUpdates.SelectMany(fu => fu.OldMessages).ToArray();
var oldPosts = mapper.Map <IEnumerable <DbPost> >(oldMsgs);
db.Posts.UpdateRange(oldPosts);
var orphanMsgs = changes.newMessages.Except(newMsgs).Except(oldMsgs).ToArray();
return(orphanMsgs);
}
}
protected async Task <IActionResult> RunTrigger(HttpRequest req, IDurableOrchestrationClient starter, int version, string entityId, ILogger log)
{
req.ApplyThreadCulture();
var changeRequest = await req.ReadAsObjectAsync <ChangeRequest>(_workforceIntegrationOptions.WorkforceIntegrationSecret).ConfigureAwait(false);
ChangeResponse changeResponse = new ChangeResponse(changeRequest);
if (IsPassThroughRequest(req.Headers))
{
// as this change has occurred as a result of a connector action, bypass all further processing
return(new ChangeSuccessResult(changeResponse));
}
log.LogChangeRequest(changeRequest, entityId);
if (!TryValidateChangeRequest(changeRequest, version, entityId, log, out var validationResponse))
{
return(validationResponse);
}
IActionResult actionResult = null;
try
{
bool handled = false;
foreach (var handler in _handlers)
{
if (handler.CanHandleChangeRequest(changeRequest, out var changeItemRequest))
{
log.LogTrace("Change Request handled by: {handlerName}", handler.GetType().Name);
if (TryValidateChangeItemRequest(changeItemRequest, changeResponse, out validationResponse))
{
actionResult = await handler.HandleRequest(changeRequest, changeItemRequest, changeResponse, entityId, log, starter).ConfigureAwait(false);
}
else
{
actionResult = validationResponse;
}
handled = true;
break;
}
}
if (!handled)
{
// we have no handler for this.
actionResult = new ChangeErrorResult(changeResponse, ErrorCodes.UnsupportedOperation, _stringLocalizer[ErrorCodes.UnsupportedOperation], HttpStatusCode.Forbidden);
}
}
catch (Exception ex)
{
log.LogChangeError(ex, entityId);
actionResult = new ChangeErrorResult(changeResponse, ErrorCodes.InternalError, _stringLocalizer[ErrorCodes.InternalError], HttpStatusCode.InternalServerError);
}
log.LogChangeResult(actionResult);
return(actionResult);
}
public ChangeSuccessResult(ChangeResponse changeResponse, ChangeItemRequest changeItemRequest, string eTag = null)
: base(changeResponse)
{
var changeItemResponse = changeResponse.Responses.First(cir => cir.Id == changeItemRequest.Id);
changeItemResponse.Status = (int)HttpStatusCode.OK;
changeItemResponse.Body.Etag = eTag ?? GenerateEtag(changeItemResponse.Id);
}
/// <summary>
///
/// </summary>
/// <param name="paidAmount"></param>
/// <param name="productAmount"></param>
/// <returns></returns>
private string CalculateChange(string paidAmount, string productAmount)
{
// Limpa mensagem de erro
this.UxTxtOutput.Text = string.Empty;
// Monta o request
ChangeRequest changeRequest = new ChangeRequest();
changeRequest.PaidAmount = int.Parse(paidAmount);
changeRequest.ProductAmount = int.Parse(productAmount);
// Chama o calculo do troco
ChangeManager changeManager = new ChangeManager();
// Assina o evento de conclusão de processador.
changeManager.OnProcessorDone += changeManager_OnProcessorDone;
ChangeResponse changeResponse = changeManager.CalculateChange(changeRequest);
// Verifica se o calculo foi feito corretamente
if (changeResponse.Success == true)
{
// Instancia montador de string
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendFormat("Moedas:");
foreach (ChangeData changeInCoin in changeResponse.ChangeDataCollection)
{
stringBuilder.AppendFormat("\r\n{0} {1}(s) de {2} centavo(s)", changeInCoin.Quantity, changeInCoin.Name, changeInCoin.AmountInCents);
}
// Devolve a mensagem de erro para a interface
this.UxTxtOutput.AppendText(stringBuilder.ToString());
// Retorna troco
return(changeResponse.ChangeAmount.ToString());
}
else
{
// Instancia montador de string
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendFormat("Deu ruim!");
// Varre a coleção de erros
foreach (ErrorReport errorReport in changeResponse.ErrorReport)
{
stringBuilder.AppendFormat("\r\nErro no campo {0}: {1}", errorReport.Field, errorReport.Message);
}
// Devolve a mensagem de erro para a interface
this.UxTxtOutput.AppendText(stringBuilder.ToString());
// Retorna troco vazio
return(string.Empty);
}
}
public static List <ChangeResponse> CalculateRelativeChanges(List <IPrefilterBase> prefilters,
List <ChangeResponse> allChanges, KeyValuePair <Type, string> property)
{
IEnumerable <WherePrefilter> wherePrefilters = prefilters.OfType <WherePrefilter>();
List <ChangeResponse> completeChanges = allChanges.ToList();
List <ChangeResponse> oldValuesUnloadResponses = new List <ChangeResponse>();
List <ChangeResponse> newValuesLoadResponses = new List <ChangeResponse>();
foreach (WherePrefilter wherePrefilter in wherePrefilters)
{
wherePrefilter.Initialize(property.Key);
oldValuesUnloadResponses.AddRange(
allChanges
.Where(change => change.State == ChangeResponse.ChangeState.Modified &&
!wherePrefilter.WhereExpressionCompiled(change.Value) &&
wherePrefilter.WhereExpressionCompiled(change.OriginalValue))
.Select(change =>
{
ChangeResponse newChangeResponse = change.CreateResponse(null, change.Value);
newChangeResponse.State = ChangeResponse.ChangeState.Deleted;
return(newChangeResponse);
})
);
newValuesLoadResponses.AddRange(
allChanges
.Where(change => change.State == ChangeResponse.ChangeState.Modified &&
wherePrefilter.WhereExpressionCompiled(change.Value) &&
!wherePrefilter.WhereExpressionCompiled(change.OriginalValue))
.Select(change =>
{
ChangeResponse newChangeResponse = change.CreateResponse(null, change.Value);
newChangeResponse.State = ChangeResponse.ChangeState.Added;
return(newChangeResponse);
})
);
completeChanges = completeChanges
.Where((change) =>
wherePrefilter.WhereExpressionCompiled(change.Value) &&
(change.State != ChangeResponse.ChangeState.Modified ||
wherePrefilter.WhereExpressionCompiled(change.OriginalValue)))
.ToList();
}
IEnumerable <ChangeResponse> changesForWherePrefilter = oldValuesUnloadResponses
.Concat(newValuesLoadResponses)
.GroupBy(v => v.Value)
.Select(g => g.LastOrDefault());
return(completeChanges.Concat(changesForWherePrefilter).ToList());
}
public ChangeSuccessResult(ChangeResponse changeResponse, ChangeItemRequest changeItemRequest, List <string> data)
: base(changeResponse)
{
var changeItemResponse = changeResponse.Responses.First(cir => cir.Id == changeItemRequest.Id);
changeItemResponse.Status = (int)HttpStatusCode.OK;
changeItemResponse.Body = new ChangeItemDataResponseBody
{
Data = data
};
}
public ChangeSuccessResult(ChangeResponse changeResponse)
: base(changeResponse)
{
foreach (var changeItemResponse in changeResponse.Responses)
{
if (changeItemResponse.Status == 0)
{
changeItemResponse.Status = (int)HttpStatusCode.OK;
if (string.IsNullOrEmpty(changeItemResponse.Body.Etag))
{
changeItemResponse.Body.Etag = GenerateEtag(changeItemResponse.Id);
}
}
}
}
// Token: 0x06000200 RID: 512 RVA: 0x0000597C File Offset: 0x00003B7C
public SyncStatus GetChangeResponseStatus(int index)
{
if (this.ChangeResponses == null || this.ChangeResponses.Count <= index || this.ChangeResponses[index] == null)
{
throw new ArgumentOutOfRangeException("index");
}
ChangeResponse changeResponse = this.ChangeResponses[index];
byte status = changeResponse.Status;
if (!SyncResponse.StatusToEnumMap.ContainsKey(status))
{
return((SyncStatus)status);
}
return(SyncResponse.StatusToEnumMap[status]);
}
public ChangeErrorResult(ChangeResponse changeResponse, string errorCode, string errorMessage, HttpStatusCode statusCode = HttpStatusCode.BadRequest)
: base(changeResponse)
{
foreach (var responseItem in changeResponse.Responses)
{
responseItem.Status = (int)statusCode;
responseItem.Body.Error = new ChangeErrorResponse
{
Code = errorCode,
Message = errorMessage
};
}
// notwithstanding that this is an error result, the status code must still be 200 OK
this.StatusCode = (int)HttpStatusCode.OK;
}
public static List <ChangeResponse> CalculateRelativeAuthenticatedChanges(
ModelAttributesInfo modelAttributesInfo,
List <ChangeResponse> allChanges, KeyValuePair <Type, string> property, HttpInformation connectionInformation,
IServiceProvider requestServiceProvider)
{
if (!modelAttributesInfo.QueryEntryAuthAttributes.Any())
{
return(allChanges);
}
IEnumerable <ChangeResponse> authenticatedChanges = allChanges
.Where(change => property.Key.CanQueryEntry(connectionInformation, requestServiceProvider,
change.Value) &&
(change.State != ChangeResponse.ChangeState.Modified || property.Key.CanQueryEntry(
connectionInformation, requestServiceProvider,
change.OriginalValue)));
IEnumerable <ChangeResponse> oldLoadedNotAllowed = allChanges
.Where(change => change.State == ChangeResponse.ChangeState.Modified &&
!property.Key.CanQueryEntry(connectionInformation, requestServiceProvider,
change.Value) &&
property.Key.CanQueryEntry(connectionInformation, requestServiceProvider,
change.OriginalValue))
.Select(change =>
{
ChangeResponse newChangeResponse = change.CreateResponse(null, change.Value);
newChangeResponse.State = ChangeResponse.ChangeState.Deleted;
return(newChangeResponse);
});
IEnumerable <ChangeResponse> notLoadedNewAllowed = allChanges
.Where(change => change.State == ChangeResponse.ChangeState.Modified &&
property.Key.CanQueryEntry(connectionInformation, requestServiceProvider,
change.Value) &&
!property.Key.CanQueryEntry(connectionInformation, requestServiceProvider,
change.OriginalValue))
.Select(change =>
{
ChangeResponse newChangeResponse = change.CreateResponse(null, change.Value);
newChangeResponse.State = ChangeResponse.ChangeState.Added;
return(newChangeResponse);
});
return(authenticatedChanges.Concat(oldLoadedNotAllowed).Concat(notLoadedNewAllowed).ToList());
}
public void CalculateChange_NegativeProductAmount()
{
ChangeManager changeManager = new ChangeManager();
IocFactory.Register <IConfigurationUtility, ConfigurationUtilityMock>();
ChangeRequest changeRequest = new ChangeRequest();
changeRequest.PaidAmount = 100;
changeRequest.ProductAmount = -100;
ChangeResponse changeResponse = changeManager.CalculateChange(changeRequest);
Assert.IsNotNull(changeResponse);
Assert.IsNotNull(changeResponse.ErrorReport);
Assert.AreEqual(changeResponse.ErrorReport.Count(), 1);
Assert.AreEqual(changeResponse.ErrorReport[0].Field, "ChangeRequest.ProductAmount");
Assert.AreEqual(changeResponse.ChangeAmount, 0);
}
/// <summary>Initializes the status change.</summary>
/// <param name="ownerToken">The owner token.</param>
/// <param name="changeRequest">The change request.</param>
/// <param name="changeResponse"></param>
/// <returns></returns>
public OperationResult InitStatusChange(string ownerToken, ChangeRequest changeRequest, out ChangeResponse changeResponse)
{
changeResponse = new ChangeResponse();
string errorMessage;
// Validate passed status
if (changeRequest?.StatusId == null || !contactDiscoveryDictionary.ContainsKey(changeRequest.StatusId.Value))
{
errorMessage = "Invalid status Id.";
logger.LogError(errorMessage);
return(OperationResult.CreateInstance(StatusCodes.Status500InternalServerError, errorMessage));
}
// Generate new code and check it in DB
string medicalCode;
var attemptCount = 0;
var maxAttemptCount = 10;
bool isInserted;
do
{
medicalCode = GetMedicalCode(contactDiscoveryDictionary[changeRequest.StatusId.Value]);
var changeRequestDto = mapper.Map <StatusChangeRequest>(changeRequest);
isInserted = statusChangeRepository.TryCreateChangeRequest(medicalCode, changeRequestDto, ownerToken);
attemptCount++;
}while (attemptCount < maxAttemptCount && !isInserted);
if (string.IsNullOrEmpty(medicalCode))
{
errorMessage = "Medical code has not been generated after all attempts.";
logger.LogError(errorMessage);
return(OperationResult.CreateInstance(StatusCodes.Status500InternalServerError, errorMessage));
}
if (isInserted)
{
changeResponse.MedicalCode = medicalCode;
changeResponse.ExpirationDate = DateTime.UtcNow.AddHours(expirationPeriodInHours);
}
return(OperationResult.CreateInstance(StatusCodes.Status200OK));
}
public ChangeErrorResult(ChangeResponse changeResponse, ChangeItemRequest changeItemRequest, string errorCode, string errorMessage, bool dataErrorResponse, HttpStatusCode statusCode = HttpStatusCode.BadRequest)
: base(changeResponse)
{
var changeItemResponse = changeResponse.Responses.First(cir => cir.Id == changeItemRequest.Id);
changeItemResponse.Status = (int)statusCode;
if (dataErrorResponse)
{
changeItemResponse.Body = new ChangeItemDataResponseBody();
}
changeItemResponse.Body.Error = new ChangeErrorResponse
{
Code = errorCode,
Message = errorMessage
};
// notwithstanding that this is an error result, the status code must still be 200 OK
this.StatusCode = (int)HttpStatusCode.OK;
}
public ChangeResponse CoinReturn(ChangeRequest transaction)
{
var coinCount = new Change();
coinCount.SilverDollars = transaction.ChangeOwed / 100;
coinCount.Quarters = (transaction.ChangeOwed - coinCount.SilverDollars * 100) / 25;
coinCount.Dimes = (transaction.ChangeOwed - (coinCount.SilverDollars * 100 + coinCount.Quarters * 25)) / 10;
coinCount.Nickels = (transaction.ChangeOwed - (coinCount.SilverDollars * 100 + coinCount.Quarters * 25 + coinCount.Dimes * 10)) / 5;
coinCount.Pennies = (transaction.ChangeOwed -
(coinCount.SilverDollars * 100 + coinCount.Quarters * 25 + coinCount.Dimes * 10 +
coinCount.Nickels * 5));
var changeResponse = new ChangeResponse();
changeResponse.Coins = coinCount;
// changeResponse.Item = transaction.Item;
changeResponse.ChangeOwed = (transaction.ChangeOwed);
changeResponse.Payment = (transaction.Payment);
changeResponse.ChangeOwed = changeResponse.ChangeOwed / 100;
changeResponse.Payment = changeResponse.Payment / 100;
return(changeResponse);
}
public void CalculateChange_WithValidValue()
{
ChangeManager changeManager = new ChangeManager();
ChangeRequest changeRequest = new ChangeRequest();
changeRequest.PaidAmount = 73891;
changeRequest.ProductAmount = 100;
ChangeResponse changeResponse = changeManager.CalculateChange(changeRequest);
Assert.IsNotNull(changeResponse);
Assert.IsNotNull(changeResponse.ChangeDataCollection);
Assert.AreEqual(7, changeResponse.ChangeDataCollection.SingleOrDefault(o => o.AmountInCents == 10000).Quantity);
Assert.AreEqual(1, changeResponse.ChangeDataCollection.SingleOrDefault(o => o.AmountInCents == 2000).Quantity);
Assert.AreEqual(1, changeResponse.ChangeDataCollection.SingleOrDefault(o => o.AmountInCents == 1000).Quantity);
Assert.AreEqual(1, changeResponse.ChangeDataCollection.SingleOrDefault(o => o.AmountInCents == 500).Quantity);
Assert.AreEqual(1, changeResponse.ChangeDataCollection.SingleOrDefault(o => o.AmountInCents == 200).Quantity);
Assert.AreEqual(1, changeResponse.ChangeDataCollection.SingleOrDefault(o => o.AmountInCents == 90).Quantity);
Assert.AreEqual(1, changeResponse.ChangeDataCollection.SingleOrDefault(o => o.AmountInCents == 1).Quantity);
}
private void ChangePrinter(ChangeResponse changeResponse)
{
Console.WriteLine("\nYou've got {0:c} coming to you in the form of: ", (decimal)changeResponse.ChangeOwed / 100);
Console.WriteLine("Silver Dollars - {0}\nQuarters - {1}\nDimes - {2}\nNickels - {3}\nPennies - {4}", changeResponse.Coins.SilverDollars, changeResponse.Coins.Quarters, changeResponse.Coins.Dimes, changeResponse.Coins.Nickels, changeResponse.Coins.Pennies);
}
public override async Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
var swapRequest = await ReadRequestObjectAsync <SwapRequest>(changeItemRequest, teamId).ConfigureAwait(false);
if (swapRequest == null)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.SwapRequestNotFound, _stringLocalizer[ErrorCodes.SwapRequestNotFound]));
}
var connectionModel = await _scheduleConnectorService.GetConnectionAsync(teamId).ConfigureAwait(false);
var wfmSwapRequest = swapRequest.AsWfmSwapRequest();
wfmSwapRequest.BuId = connectionModel.WfmBuId;
var wfmResponse = await _wfmActionService.CancelShiftSwapRequestAsync(wfmSwapRequest, log).ConfigureAwait(false);
var actionResult = WfmResponseToActionResult(wfmResponse, changeItemRequest, changeResponse);
if (wfmResponse.Success)
{
await _requestCacheService.SaveRequestAsync(teamId, changeItemRequest.Id, swapRequest).ConfigureAwait(false);
}
// whether we successfully cancelled the swap request or not, ensure we clear the cache data
await DeleteChangeDataAsync(swapRequest).ConfigureAwait(false);
return(actionResult);
}
public override async Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
if (IsDeletedShift(changeItemRequest))
{
return(await DeleteShiftAsync(changeItemRequest, changeResponse, teamId, log, starter).ConfigureAwait(false));
}
else
{
// the connector does not currently support this operation
return(new ChangeErrorResult(changeResponse, ErrorCodes.UnsupportedOperation, _stringLocalizer[ErrorCodes.UnsupportedOperation], HttpStatusCode.Forbidden));
}
}
private async Task <IActionResult> DeleteShiftAsync(ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
var shift = await ScheduleCacheHelper.FindShiftByTeamsShiftIdAsync(changeItemRequest.Id, teamId, _teamOptions.PastWeeks, _teamOptions.FutureWeeks, _teamOptions.StartDayOfWeek, _scheduleCacheService, _systemTimeService).ConfigureAwait(false);
if (shift != null)
{
var policy = GetConflictRetryPolicy(_teamOptions.RetryMaxAttempts, _teamOptions.RetryIntervalSeconds);
try
{
await policy.ExecuteAsync(() => RemoveShiftFromScheduleAsync(shift, teamId)).ConfigureAwait(false);
await ShareDelete(shift, teamId, starter).ConfigureAwait(false);
}
catch (Exception ex)
{
log.LogDeleteShiftException(ex, shift, teamId);
return(new ChangeErrorResult(changeResponse, ErrorCodes.InternalError, _stringLocalizer[ErrorCodes.InternalError], HttpStatusCode.InternalServerError));
}
log.LogDeleteShiftSuccess(shift, teamId);
}
return(new ChangeSuccessResult(changeResponse));
}
public abstract Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string entityId, ILogger log, IDurableOrchestrationClient starter);
public ChangeResponse CalculateChange(ChangeRequest changeRequest)
{
ChangeResponse changeResponse = new ChangeResponse();
// Instancia os loggers
ILogger fileLogger = LogFactory.Create(LogRepositoryEnum.File);
ILogger databaseLogger = LogFactory.Create(LogRepositoryEnum.Database);
try
{
//Log information.
fileLogger.WriteLog(LogSeverityEnum.Information, "Inicio processamento: ", changeRequest);
// Valida os dados recebidos no request.
if (changeRequest.IsValid == false)
{
changeResponse.ErrorReport = changeRequest.Errors;
changeResponse.Success = false;
//Log information.
databaseLogger.WriteLog(LogSeverityEnum.Error, "Erro na validação dos dados", changeResponse);
return(changeResponse);
}
// Calcula o troco.
int originalChangeAmount = changeRequest.PaidAmount - changeRequest.ProductAmount;
// Instancia coleção de troco
List <ChangeData> changeDataCollection = new List <ChangeData>();
//Log information.
databaseLogger.WriteLog(LogSeverityEnum.Information, "Troco calculado: ", originalChangeAmount);
// enquanto houver troco
int changeAmount = originalChangeAmount;
while (changeAmount > 0)
{
// seleciona o processador
AbstractChangeProcessor processor = ProcessorFactory.Create(changeAmount);
//Log information.
databaseLogger.WriteLog(LogSeverityEnum.Information, string.Format("Processador {0} selecionado", processor.GetName()));
// calcula o troco
List <ChangeData> processorChangeDataCollection = processor.Calculate(changeAmount);
// adiciona o resultado do troco do processador a coleção da resposta
changeDataCollection.AddRange(processorChangeDataCollection);
// Soma o valor de troco processado
int processorChangeAmount = processorChangeDataCollection.Sum(i => i.Quantity * i.AmountInCents);
//Log information.
databaseLogger.WriteLog(LogSeverityEnum.Information, string.Format("Processador {0} processou {1} de troco em centavos.", processor.GetName(), processorChangeAmount), processorChangeDataCollection);
// Dispara um evento informando que o processador terminou o cálculo.
if (this.OnProcessorDone != null)
{
this.OnProcessorDone(this, new ProcessorDoneEventArgs(processor.GetName(), processorChangeAmount));
}
// Diminui do troco o valor processado
changeAmount -= processorChangeAmount;
}
// Atribui a coleção de trocos a resposta
changeResponse.ChangeDataCollection = changeDataCollection;
changeResponse.ChangeAmount = originalChangeAmount;
// Atribui true ao succe
changeResponse.Success = true;
}
catch (Exception ex)
{
ILogger eventLogger = LogFactory.Create(LogRepositoryEnum.WindowsEvent);
ErrorReport errorReport = new ErrorReport();
errorReport.Field = "Internal Error";
errorReport.Message = "Ocorreu um erro interno.";
#if DEBUG
errorReport.Message += " DEBUG:" + ex.ToString();
#endif
changeResponse.ErrorReport.Add(errorReport);
eventLogger.WriteLog(LogSeverityEnum.Error, "Ocorreu um erro interno.", errorReport);
// Retorna sucesso falso
changeResponse.Success = false;
}
finally
{
//Log information.
fileLogger.WriteLog(LogSeverityEnum.Information, "Fim do processamento: ", changeResponse);
}
return(changeResponse);
}
public override Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
return(Task.FromResult <IActionResult>(new ChangeErrorResult(changeResponse, ErrorCodes.UnsupportedOperation, _stringLocalizer[ErrorCodes.UnsupportedOperation], HttpStatusCode.Forbidden)));
}
public override async Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
// get the open shift from the change item
var openShift = changeItemRequest.Body.ToObject <OpenShiftResponse>();
// get the proposed shift to be created from the open shift
var proposedShift = changeRequest.Requests
.Where(r => r.Method.Equals("POST", StringComparison.OrdinalIgnoreCase))
.Select(r => r.Body.ToObject <ShiftResponse>())
.First();
var connectionModel = await _scheduleConnectorService.GetConnectionAsync(teamId).ConfigureAwait(false);
// get the corresponding open shift from cache
var localStartDate = openShift.SharedOpenShift.StartDateTime.ApplyTimeZoneOffset(connectionModel.TimeZoneInfoId);
var weekStartDate = localStartDate.StartOfWeek(_teamOptions.StartDayOfWeek);
var scheduleId = teamId + ApplicationConstants.OpenShiftsSuffix;
var cacheModel = await _scheduleCacheService.LoadScheduleAsync(scheduleId, weekStartDate).ConfigureAwait(false);
var assignedShift = cacheModel.Tracked.FirstOrDefault(o => o.TeamsShiftId == openShift.Id);
if (assignedShift == null)
{
// we didn't find an open shift with this ID
return(new ChangeErrorResult(changeResponse, changeItemRequest, ErrorCodes.NoOpenShiftsFound, _stringLocalizer[ErrorCodes.NoOpenShiftsFound]));
}
// get the employee object for the manager who initiated the change
var manager = await _cacheService.GetKeyAsync <EmployeeModel>(ApplicationConstants.TableNameEmployees, openShift.LastModifiedBy.User.Id).ConfigureAwait(false);
if (manager == null)
{
return(new ChangeErrorResult(changeResponse, changeItemRequest, ErrorCodes.UserCredentialsNotFound, _stringLocalizer[ErrorCodes.UserCredentialsNotFound]));
}
// get the employee object for the user the open shift is assigned to
var employee = await _cacheService.GetKeyAsync <EmployeeModel>(ApplicationConstants.TableNameEmployees, proposedShift.UserId).ConfigureAwait(false);
if (employee == null)
{
return(new ChangeErrorResult(changeResponse, changeItemRequest, ErrorCodes.UserCredentialsNotFound, _stringLocalizer[ErrorCodes.UserCredentialsNotFound]));
}
var wfmResponse = await _wfmActionService.ManagerAssignOpenShiftAsync(assignedShift, manager, employee, connectionModel.WfmBuId, connectionModel.TimeZoneInfoId, log).ConfigureAwait(false);
if (!wfmResponse.Success)
{
return(new ChangeErrorResult(changeResponse, changeItemRequest, wfmResponse.Error.Code, wfmResponse.Error.Message));
}
var policy = GetConflictRetryPolicy(_teamOptions.RetryMaxAttempts, _teamOptions.RetryIntervalSeconds);
// as it has been assigned successfully, decrement the quantity
assignedShift.Quantity--;
// update the open shift in the cache
await policy.ExecuteAsync(() => UpdateCachedOpenShiftsAsync(scheduleId, assignedShift, weekStartDate)).ConfigureAwait(false);
// convert the open shift to a shift and add it to the week shifts cache
assignedShift.Quantity = 1;
assignedShift.WfmEmployeeId = employee.WfmEmployeeId;
assignedShift.TeamsEmployeeId = employee.TeamsEmployeeId;
assignedShift.TeamsShiftId = proposedShift.Id;
assignedShift.WfmShiftId = wfmResponse.NewEntityId;
await policy.ExecuteAsync(() => UpdateCachedShiftsAsync(teamId, assignedShift, weekStartDate)).ConfigureAwait(false);
// finally, set up a deferred action to share the schedule
var deferredActionModel = new DeferredActionModel
{
ActionType = DeferredActionModel.DeferredActionType.ShareTeamSchedule,
DelaySeconds = _teamOptions.DelayedActionSeconds,
ShareStartDate = openShift.SharedOpenShift.StartDateTime.Date,
ShareEndDate = openShift.SharedOpenShift.EndDateTime.Date.AddHours(23).AddMinutes(59),
TeamId = teamId
};
await starter.StartNewAsync(nameof(DeferredActionOrchestrator), deferredActionModel).ConfigureAwait(false);
return(new ChangeSuccessResult(changeResponse));
}
public override async Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
log.LogTrace($"{nameof(SenderSwapRequestHandler)}:{nameof(HandleRequest)}:Started");
var swapRequest = await ReadRequestObjectAsync <SwapRequest>(changeItemRequest, teamId).ConfigureAwait(false);
if (swapRequest == null)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.SwapRequestNotFound, _stringLocalizer[ErrorCodes.SwapRequestNotFound]));
}
// are we already processing a request, if so block premature retries
var changeData = await ReadChangeDataAsync(swapRequest).ConfigureAwait(false);
if (changeData.SenderStatus == ChangeData.RequestStatus.InProgress)
{
changeData = await WaitAndReadChangeDataAsync(swapRequest).ConfigureAwait(false);
if (changeData.SenderStatus == ChangeData.RequestStatus.InProgress)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.RequestInProgress, _stringLocalizer[ErrorCodes.RequestInProgress], HttpStatusCode.Processing));
}
}
if (changeData.SenderStatus == ChangeData.RequestStatus.Complete)
{
// we have already processed this request and it is complete so just return the
// result we received the first time
// before doing so, however, because Teams creates a new swap request ID each time,
// get the previous version of the swap request and update the targetid's of this
// new request and save it and delete the old one
var oldSwapRequest = await _requestCacheService.LoadRequestAsync <SwapRequest>(teamId, changeData.SwapRequestId).ConfigureAwait(false);
swapRequest.FillTargetIds(oldSwapRequest);
await _requestCacheService.DeleteRequestAsync(teamId, changeData.SwapRequestId).ConfigureAwait(false);
await _requestCacheService.SaveRequestAsync(teamId, changeItemRequest.Id, swapRequest).ConfigureAwait(false);
if (changeData.SenderResult.StatusCode == (int)HttpStatusCode.OK)
{
return(new ChangeSuccessResult(changeResponse));
}
return(new ChangeErrorResult(changeResponse, changeItemRequest, changeData.SenderResult.ErrorCode, changeData.SenderResult.ErrorMessage));
}
await MapSwapRequestIdentitiesAsync(swapRequest, teamId, log).ConfigureAwait(false);
if (string.IsNullOrEmpty(swapRequest.TargetSenderShiftId))
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.SenderShiftNotFound, _stringLocalizer[ErrorCodes.SenderShiftNotFound]));
}
else if (string.IsNullOrEmpty(swapRequest.TargetSenderLoginName))
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.UserCredentialsNotFound, _stringLocalizer[ErrorCodes.UserCredentialsNotFound]));
}
else if (string.IsNullOrEmpty(swapRequest.TargetRecipientShiftId))
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.RecipientShiftNotFound, _stringLocalizer[ErrorCodes.RecipientShiftNotFound]));
}
else if (string.IsNullOrEmpty(swapRequest.TargetRecipientLoginName))
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.UserCredentialsNotFound, _stringLocalizer[ErrorCodes.UserCredentialsNotFound]));
}
// set the request in progress and store the swap request id in cache in case this call
// times out and Teams makes a second request
changeData.SenderStatus = ChangeData.RequestStatus.InProgress;
// clear other statuses to avoid blocking subsequent requests for the same two shifts
ResetChangeDataStatuses(changeData);
changeData.SwapRequestId = changeItemRequest.Id;
await SaveChangeDataAsync(swapRequest, changeData).ConfigureAwait(false);
var connectionModel = await _scheduleConnectorService.GetConnectionAsync(teamId).ConfigureAwait(false);
var wfmSwapRequest = swapRequest.AsWfmSwapRequest();
wfmSwapRequest.BuId = connectionModel.WfmBuId;
var wfmResponse = await _wfmActionService.CreateShiftSwapRequestAsync(wfmSwapRequest, log).ConfigureAwait(false);
var actionResult = WfmResponseToActionResult(wfmResponse, changeItemRequest, changeResponse);
if (wfmResponse.Success)
{
swapRequest.TargetSwapRequestId = wfmSwapRequest.SwapRequestId;
await _requestCacheService.SaveRequestAsync(teamId, changeItemRequest.Id, swapRequest).ConfigureAwait(false);
await SaveChangeResultAsync(swapRequest).ConfigureAwait(false);
}
else
{
await SaveChangeResultAsync(swapRequest, HttpStatusCode.BadRequest, wfmResponse.Error.Code, wfmResponse.Error.Message).ConfigureAwait(false);
}
// flag that the swap request creation has now finished
changeData = await ReadChangeDataAsync(swapRequest).ConfigureAwait(false);
changeData.SenderStatus = ChangeData.RequestStatus.Complete;
await SaveChangeDataAsync(swapRequest, changeData).ConfigureAwait(false);
return(actionResult);
}
public override async Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
var swapRequest = await ReadRequestObjectAsync <SwapRequest>(changeItemRequest, teamId).ConfigureAwait(false);
if (swapRequest == null)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.SwapRequestNotFound, _stringLocalizer[ErrorCodes.SwapRequestNotFound]));
}
// are we already processing a request, if so block premature retries
var changeData = await ReadChangeDataAsync(swapRequest).ConfigureAwait(false);
if (changeData.RecipientStatus == ChangeData.RequestStatus.InProgress)
{
changeData = await WaitAndReadChangeDataAsync(swapRequest).ConfigureAwait(false);
if (changeData.RecipientStatus == ChangeData.RequestStatus.InProgress)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.RequestInProgress, _stringLocalizer[ErrorCodes.RequestInProgress], HttpStatusCode.Processing));
}
}
if (changeData.RecipientStatus == ChangeData.RequestStatus.Complete)
{
if (changeData.RecipientResult.StatusCode == (int)HttpStatusCode.OK)
{
return(new ChangeSuccessResult(changeResponse));
}
return(new ChangeErrorResult(changeResponse, changeItemRequest, changeData.RecipientResult.ErrorCode, changeData.RecipientResult.ErrorMessage));
}
changeData.RecipientStatus = ChangeData.RequestStatus.InProgress;
// clear other statuses to avoid blocking subsequent requests for the same two shifts
ResetChangeDataStatuses(changeData);
await SaveChangeDataAsync(swapRequest, changeData).ConfigureAwait(false);
var connectionModel = await _scheduleConnectorService.GetConnectionAsync(teamId).ConfigureAwait(false);
var wfmSwapRequest = swapRequest.AsWfmSwapRequest();
wfmSwapRequest.BuId = connectionModel.WfmBuId;
var approve = swapRequest.EvaluateState(changeItemRequest.Method) == ChangeRequestState.RecipientApproved;
var wfmResponse = await _wfmActionService.RecipientApproveShiftSwapRequestAsync(wfmSwapRequest, approve, log).ConfigureAwait(false);
var actionResult = WfmResponseToActionResult(wfmResponse, changeItemRequest, changeResponse);
if (wfmResponse.Success)
{
await _requestCacheService.SaveRequestAsync(teamId, changeItemRequest.Id, swapRequest).ConfigureAwait(false);
await SaveChangeResultAsync(swapRequest).ConfigureAwait(false);
}
else
{
await SaveChangeResultAsync(swapRequest, HttpStatusCode.BadRequest, wfmResponse.Error.Code, wfmResponse.Error.Message).ConfigureAwait(false);
}
await _requestCacheService.SaveRequestAsync(teamId, changeItemRequest.Id, swapRequest).ConfigureAwait(false);
// flag that the recipient approval has now finished
changeData = await ReadChangeDataAsync(swapRequest).ConfigureAwait(false);
changeData.RecipientStatus = ChangeData.RequestStatus.Complete;
await SaveChangeDataAsync(swapRequest, changeData).ConfigureAwait(false);
// if the auto manager approval feature is enabled, issue it now
if (actionResult is ChangeSuccessResult && _featureOptions.EnableShiftSwapAutoApproval)
{
var deferredActionModel = new DeferredActionModel
{
ActionType = DeferredActionModel.DeferredActionType.ApproveSwapShiftsRequest,
DelaySeconds = _teamOptions.DelayedActionSeconds,
RequestId = swapRequest.Id,
TeamId = teamId,
Message = _stringLocalizer.GetString("ApproveSwapShifts")
};
await starter.StartNewAsync(nameof(DeferredActionOrchestrator), deferredActionModel).ConfigureAwait(false);
}
return(actionResult);
}
public void OnChangeRequestCompleted(ChangeResponse change)
{
var changeResponse = change;
Console.WriteLine(changeResponse);
}
public override async Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string userId, ILogger log, IDurableOrchestrationClient starter)
{
var preferenceRequest = changeItemRequest.Body.ToObject <ShiftPreferenceResponse>();
if (preferenceRequest == null)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.ChangeRequestNotFound, _stringLocalizer[ErrorCodes.ChangeRequestNotFound]));
}
var employee = await _cacheService.GetKeyAsync <EmployeeModel>(ApplicationConstants.TableNameEmployees, userId).ConfigureAwait(false);
if (employee == null)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.UserCredentialsNotFound, _stringLocalizer[ErrorCodes.UserCredentialsNotFound]));
}
// get the conection object which contains TimeZoneInfoId to populate below availabilityModel.
var connection = await _scheduleConnectorService.GetConnectionAsync(employee.TeamIds[0]).ConfigureAwait(false);
// map the preference request to an availability model
var availabilityModel = _availabilityMap.MapAvailability(preferenceRequest.Availability, userId);
availabilityModel.WfmEmployeeId = employee.WfmEmployeeId;
availabilityModel.TimeZoneInfoId = connection.TimeZoneInfoId;
var wfmResponse = await _wfmActionService.UpdateEmployeeAvailabilityAsync(availabilityModel, log).ConfigureAwait(false);
return(WfmResponseToActionResult(wfmResponse, changeItemRequest, changeResponse));
}
public override async Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
var openShiftRequest = await ReadRequestObjectAsync <OpenShiftsChangeRequest>(changeItemRequest, teamId).ConfigureAwait(false);
if (openShiftRequest == null)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.ChangeRequestNotFound, _stringLocalizer[ErrorCodes.ChangeRequestNotFound]));
}
var connectionModel = await _scheduleConnectorService.GetConnectionAsync(teamId).ConfigureAwait(false);
var wfmOpenShiftRequest = openShiftRequest.AsWfmOpenShiftRequest();
wfmOpenShiftRequest.BuId = connectionModel.WfmBuId;
var wfmResponse = await _wfmActionService.CancelOpenShiftRequestAsync(wfmOpenShiftRequest, log).ConfigureAwait(false);
if (wfmResponse.Success)
{
await _requestCacheService.DeleteRequestAsync(teamId, changeItemRequest.Id).ConfigureAwait(false);
return(new ChangeSuccessResult(changeResponse));
}
return(WfmErrorToActionResult(wfmResponse.Error, changeItemRequest, changeResponse));
}
public override async Task <IActionResult> HandleRequest(ChangeRequest changeRequest, ChangeItemRequest changeItemRequest, ChangeResponse changeResponse, string teamId, ILogger log, IDurableOrchestrationClient starter)
{
var openShiftRequest = await ReadRequestObjectAsync <OpenShiftsChangeRequest>(changeItemRequest, teamId).ConfigureAwait(false);
if (openShiftRequest == null)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.ChangeRequestNotFound, _stringLocalizer[ErrorCodes.ChangeRequestNotFound]));
}
if (!await MapOpenShiftRequestIdentitiesAsync(openShiftRequest).ConfigureAwait(false))
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.UserCredentialsNotFound, _stringLocalizer[ErrorCodes.UserCredentialsNotFound]));
}
var openShift = await GetOpenShift(teamId, openShiftRequest.OpenShiftId).ConfigureAwait(false);
if (openShift == null)
{
return(new ChangeErrorResult(changeResponse, ErrorCodes.NoOpenShiftsFound, _stringLocalizer[ErrorCodes.NoOpenShiftsFound]));
}
var connectionModel = await _scheduleConnectorService.GetConnectionAsync(teamId).ConfigureAwait(false);
var wfmOpenShiftRequest = openShiftRequest.AsWfmOpenShiftRequest();
wfmOpenShiftRequest.BuId = connectionModel.WfmBuId;
wfmOpenShiftRequest.TimeZoneInfoId = connectionModel.TimeZoneInfoId;
wfmOpenShiftRequest.WfmOpenShift = openShift;
var wfmResponse = await _wfmActionService.CreateOpenShiftRequestAsync(wfmOpenShiftRequest, log).ConfigureAwait(false);
if (wfmResponse.Success)
{
await _requestCacheService.SaveRequestAsync(teamId, openShiftRequest.Id, openShiftRequest).ConfigureAwait(false);
if (_featureOptions.EnableOpenShiftAutoApproval)
{
await AutoApproveRequestAsync(openShiftRequest, teamId, starter).ConfigureAwait(false);
}
return(new ChangeSuccessResult(changeResponse));
}
return(new ChangeErrorResult(changeResponse, ErrorCodes.ShiftNotAvailableToUser, _stringLocalizer[ErrorCodes.ShiftNotAvailableToUser]));
}
