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