/// <summary> /// Handlers for the ComboBox class of controls. /// </summary> /// <param name="sender">The object that originated the event.</param> /// <param name="routedEventArgs">The routed event arguments.</param> private void OnSelectorSelectionChanged(object sender, RoutedEventArgs routedEventArgs) { // The main idea of this handler is to sort out the user generated actions from the machine generated actions. Once // its determined that it was a user action, a background thread is called to change the associated field to the value // selected by the ComboBox. SelectionChangedEventArgs selectionChangedEventArgs = routedEventArgs as SelectionChangedEventArgs; // Handle changes to ComboBox elements. if (selectionChangedEventArgs.OriginalSource is ComboBox) { ComboBox comboBox = selectionChangedEventArgs.OriginalSource as ComboBox; IContent iContent = comboBox.DataContext as IContent; // This filters all the ComboBox events looking for user initiated actions that are bound to the data model. if (InputHelper.IsUserInitiated(comboBox, ComboBox.SelectedValueProperty) && iContent != null && iContent.Key is DataTableCoordinate) { // At this point, a ComboBox was modified by the user and it is connected to a data model field. This will extract // the coordinates of the field in the table. That, in turn, drives the decision about how to update the shared // data model. DataTableCoordinate dataTableCoordiante = iContent.Key as DataTableCoordinate; ExecutionRow executionRow = dataTableCoordiante.DataRow as ExecutionRow; } } }
// exemplo: w1(x)-r2(y)-w2(y)-c2-w1(y) public void History(string entryTransaction, TextBox output, TextBox RunningRow, TextBox WaitingTransaction, TextBox AbortedTransaction, TextBox Queue, TextBox DataLock) { string[] transactionList; // Quebra a string de entrada em um vetor de string transactionList = entryTransaction.Split('-'); OutPut = output; if (ExecutionRow == null) { ExecutionRow = new Queue <string>(transactionList); } if (ExecutionRow.Count > 0) { RunCommand(ExecutionRow.Dequeue()); CheckWaitingQueue(); RunningRow.Text = RetornaRunningRow(); WaitingTransaction.Text = ReturnWaitingTransactions(); AbortedTransaction.Text = ReturnTransactionsAborteds(); Queue.Text = ReturnQueue(); DataLock.Text = ReturnDataLock(); SetFinalPoint(OutPut); RunningRow.Refresh(); WaitingTransaction.Refresh(); AbortedTransaction.Refresh(); DataLock.Refresh(); SetFinalPoint(Queue); } else { OutPut.Text += "\r\nExecução finalizada."; SetFinalPoint(OutPut); } }
public static async Task <IActionResult> Run( [HttpTrigger(AuthorizationLevel.Function, "get", Route = null)] HttpRequest req, [Table("executionsTable", Connection = "StorageAccount")] ICollector <ExecutionRow> outputTable, ILogger log) { log.LogInformation($"{FunctionNames.MortgageCalculatorFunction} start"); // Retrieve loan, interest and numberOfPayments from HTTP Request #region [ Retrieve request parameters ] decimal loan; if (!GetLoanFromQueryString(req, out loan)) { log.LogError($"Loan not valid"); return(new BadRequestObjectResult("Loan not valid")); } double interest; if (!GetInterestFromQueryString(req, out interest)) { log.LogError($"Annual Interest not valid"); return(new BadRequestObjectResult("Annual Interest not valid")); } uint nPayments; if (!GetNumberOfPaymentsFromQueryString(req, out nPayments)) { log.LogError($"Number of payments not valid"); return(new BadRequestObjectResult("Number of payments not valid")); } #endregion [ Retrieve request parameters ] var calculatorResult = await mortgageCalculator.CalculateMontlyRateAsync(loan, interest, nPayments); #region [ Create the response ] var executionRow = new ExecutionRow(DateTime.Now) { AnnualInterest = interest, ErrorCode = calculatorResult.Error?.Code, MonthlyRate = calculatorResult.Result, MortgageLoan = loan, NumberOfPayments = nPayments, Result = calculatorResult.Succeed }; outputTable.Add(executionRow); #endregion [ Create the response ] if (calculatorResult.Succeed) { return(new OkObjectResult(calculatorResult.Result)); } return(new BadRequestObjectResult(calculatorResult.Error.Message)); }
/// <summary> /// Handlers for the Toggle button class of controls. /// </summary> /// <param name="sender">The object that originated the event.</param> /// <param name="routedEventArgs">The routed event arguments.</param> private void OnToggleButtonChange(object sender, RoutedEventArgs routedEventArgs) { // The main idea of this handler is to sort out the user generated actions from the machine generated actions. Once // its determined that it was a user action, a background thread is called to change the associated field to the value // selected by the ToggleButton. ToggleButton toggleButton = routedEventArgs.OriginalSource as ToggleButton; IContent iContent = toggleButton.DataContext as IContent; // This filters all the ToggleButton events looking for user initiated actions that are bound to the data model. if (InputHelper.IsUserInitiated(toggleButton, ToggleButton.IsCheckedProperty) && iContent != null && iContent.Key is DataTableCoordinate) { // At this point, a ToggleButton was modified by the user and it is connected to a data model field. This will // extract the coordinates of the field in the table. That, in turn, drives the decision about how to update the // shared data model. DataTableCoordinate dataTableCoordiante = iContent.Key as DataTableCoordinate; ExecutionRow executionRow = dataTableCoordiante.DataRow as ExecutionRow; } }
private void CheckWaitingQueue() { // Analisa primeiro comando de cada transação. List <int> excludes = new List <int>(); foreach (var TransactionNumber in WaitingTransactionsList.Keys) { TransactionQueueCommand commandsTransactions = WaitingTransactionsList[TransactionNumber]; if (!commandsTransactions.Transaction.LockType.Equals(TransactionTypeLock.Aborted)) { string firstCommand = commandsTransactions.CheckCommand(); LockDataType LockDataType = ReturnLockType(firstCommand.Substring(0, 1)); FreeData freeData = ReturnFreeData(commandsTransactions.Transaction, LockDataType, commandsTransactions.WaitingData); // Se o dado estiver disponivel remove todos os dados da fila e adiciona novamente à fila de execução int RemovedTransaction = 0; string ciclo = ""; string retorno = ""; switch (freeData) { case FreeData.FreeData: case FreeData.SharedTransactionsData: case FreeData.OtherSharedTransactionsData: Queue <string> tempQueue = new Queue <string>(); // Remove tudo que está na fila de execução para adicionar a fila de espera na frente while (ExecutionRow.Count > 0) { tempQueue.Enqueue(ExecutionRow.Dequeue()); } while (commandsTransactions.QueueCommands.Count > 0) { AddOutPut("Comando: " + commandsTransactions.CheckCommand() + " adicionado à fila de execução."); ExecutionRow.Enqueue(commandsTransactions.RemoveCommand()); } // Adiciona os commandos de volta a fila de execução while (tempQueue.Count > 0) { ExecutionRow.Enqueue(tempQueue.Dequeue()); } commandsTransactions.Transaction.LockType = TransactionTypeLock.Executing; // Adiciona à lista de excluídos para remover no final excludes.Add(TransactionNumber); break; case FreeData.ExclusiveOtherTransactionsData: // Realiza validação para analisar se a transação entrou em deadlock retorno = CheckDeadLock(TransactionNumber, commandsTransactions.WaitingData); RemovedTransaction = int.Parse(retorno.Substring(0, retorno.IndexOf("|"))); ciclo = retorno.Substring(retorno.IndexOf("|") + 1); if (RemovedTransaction > -1) { excludes.Add(RemovedTransaction); // Desaloca dados da transação. string msg = ""; Transactions Transactions = TransactionsList[RemovedTransaction]; // Realiza unlock do dado e retira da lista de dados utilizados. string[] usedData = Transactions.ReturnDataUsed(); msg = "----------- DEAD LOCK ----------- " + "\r\n"; msg += ciclo + "\r\n"; msg += "Transação " + RemovedTransaction + " eliminada, pois foi a que executou menos comandos.\r\n"; AddOutPut(msg); foreach (var dado in usedData) { // Adiciona saída unclok para dados liberados AddOutPut(CreateLock(LockDataType.Unlock, Transactions.TransactionNumber, dado, Transactions.ReturnDataLockType(dado))); // Remove dado e transação da lista de dados locks RemoveDataLocksList(Transactions, dado); // Remove dado da lista de transações Transactions.RemoveData(dado); } Transactions.LockType = TransactionTypeLock.Aborted; } break; } } } foreach (var transactionNumber in excludes) { WaitingTransactionsList.Remove(transactionNumber); } }
private bool FilterBlotters(ExecutionRow executionRow) { return(this.blotterList.BinarySearch(executionRow.BlotterId) >= 0); }
private Schema.Execution.Execution MatchSelector(ExecutionRow executionRow) { Schema.Execution.Execution match = new Schema.Execution.Execution(); return(match.Select(executionRow)); }
/// <summary> /// Handler for validating Execution records. /// </summary> /// <param name="sender">The object that originated the event.</param> /// <param name="e">The event arguments.</param> internal static void OnExecutionRowValidate(object sender, ExecutionRowChangeEventArgs e) { DestinationOrderRow destinationOrderRow; Decimal executedQuantity; DataModelTransaction dataModelTransaction; Decimal orderedQuantity; // The Business Rules will be enforced on this Execution. Note that it is locked at the point this handler is called. ExecutionRow executionRow = e.Row; // The action on the row determines which rule to evaluate. switch (e.Action) { case DataRowAction.Add: // This rule will update the status of the owning Destination Order based on the quantity executed. dataModelTransaction = DataModelTransaction.Current; // The aggregate of the quantities executed will determine whether the Destination Order requires a status change. destinationOrderRow = executionRow.DestinationOrderRow; destinationOrderRow.AcquireReaderLock(dataModelTransaction); if (destinationOrderRow.RowState == DataRowState.Detached) { return; } // This calculates the quantity outstanding on an order and the quantity executed on the order. orderedQuantity = destinationOrderRow.OrderedQuantity - destinationOrderRow.CanceledQuantity; executedQuantity = 0.0M; foreach (ExecutionRow siblingRow in destinationOrderRow.GetExecutionRows()) { siblingRow.AcquireReaderLock(dataModelTransaction); executedQuantity += siblingRow.ExecutionQuantity; } // This rule will set the status on the owning Destination Order based on the amont outstanding and the amount ordered. First, if the quantity // executed is greater than the quantity ordered, the Order goes into an error state. We can't reject executions as they come from an external // source, but the order can be flag and put into an error state. if (executedQuantity > orderedQuantity) { if (destinationOrderRow.StatusId != StatusMap.FromCode(Status.Error)) { UpdateDestinationOrderStatus(destinationOrderRow, Status.Error); } } else { // When the total quantity executed is reduced to zero then the order goes back into the initial state. if (executedQuantity == 0.0m) { if (destinationOrderRow.StatusId != StatusMap.FromCode(Status.New)) { UpdateDestinationOrderStatus(destinationOrderRow, Status.New); } } else { // While the executed quantity is still less than the outstanding quantity the order is consdered to be partially filled. Otherwise, // the order is completely filled. if (executedQuantity < orderedQuantity) { if (destinationOrderRow.StatusId != StatusMap.FromCode(Status.PartiallyFilled)) { UpdateDestinationOrderStatus(destinationOrderRow, Status.PartiallyFilled); } } else { if (destinationOrderRow.StatusId != StatusMap.FromCode(Status.Filled)) { UpdateDestinationOrderStatus(destinationOrderRow, Status.Filled); } } } } break; case DataRowAction.Delete: // A middle tier context is required to lock the rows so the quantities can be aggregated. dataModelTransaction = DataModelTransaction.Current; // The aggregate of the quantities executed will determine whether the Destination Order requires a status change. destinationOrderRow = (DestinationOrderRow)executionRow.GetParentRow( DataModel.Execution.DestinationOrderExecutionRelation, DataRowVersion.Original); destinationOrderRow.AcquireReaderLock(dataModelTransaction); if (destinationOrderRow.RowState == DataRowState.Detached) { return; } // This calculates the quantity outstanding on an order and the quantity executed on the order. orderedQuantity = destinationOrderRow.OrderedQuantity - destinationOrderRow.CanceledQuantity; executedQuantity = 0.0M; foreach (ExecutionRow siblingRow in destinationOrderRow.GetExecutionRows()) { siblingRow.AcquireReaderLock(dataModelTransaction); executedQuantity += siblingRow.ExecutionQuantity; } // When the total quantity executed is reduced to zero then the order goes back into the initial state. Note that it is impossible for the // order to transition into a error state by deleting an execution. if (executedQuantity == 0.0m) { if (destinationOrderRow.StatusId != StatusMap.FromCode(Status.New)) { UpdateDestinationOrderStatus(destinationOrderRow, Status.New); } } else { // While the executed quantity is still less than the outstanding quantity the order is consdered to be partially filled. Note that it is // impossible for the order to transition to a filled state by deleting an execution. if (executedQuantity < orderedQuantity) { if (destinationOrderRow.StatusId != StatusMap.FromCode(Status.PartiallyFilled)) { UpdateDestinationOrderStatus(destinationOrderRow, Status.PartiallyFilled); } } } break; } }