private List <ChangeData> CalculateEntities(long changeAmount)
        {
            long changeRest = changeAmount;

            List <ChangeData> changeDataCollection = new List <ChangeData>();

            while (changeRest > 0)
            {
                ChangeData currentData = new ChangeData();

                AbstractProcessor      proc         = ProcessorFactory.CreateProcessor(changeRest);
                Dictionary <int, long> monetaryObjs = proc.CalculateChange(changeRest);

                currentData.Name             = proc.GetName();
                currentData.ChangeDictionary = monetaryObjs.Where(p => p.Value > 0).ToDictionary(p => p.Key, p => p.Value);

                long currentProduct = monetaryObjs.Sum(p => p.Key * p.Value);

                changeRest = changeRest - currentProduct;

                changeDataCollection.Add(currentData);

                // Dispara o evento informando que um processador foi executado.
                if (this.OnProcessorExecuted != null)
                {
                    string nameProcessor = proc.GetName();

                    this.OnProcessorExecuted(this, nameProcessor, currentProduct);
                }
            }

            return(changeDataCollection);
        }
示例#2
0
        public ReturnAmountResponse ReturnAmount(ReturnAmountRequest returnCoinsRequest)
        {
            LogService.Save("Request", returnCoinsRequest);

            ReturnAmountResponse returnAmountResponse = new ReturnAmountResponse();

            try
            {
                // Verifica se os dados recebidos são válidos.
                if (returnCoinsRequest.IsValid == false)
                {
                    returnAmountResponse.OperationReport = returnCoinsRequest.ValidationReport;
                    return(returnAmountResponse);
                }

                long changeAmount        = returnCoinsRequest.PaidAmount - returnCoinsRequest.ProductAmount;
                long currentChangeAmount = changeAmount;

                List <ChangeData> chData = new List <ChangeData>();
                while (currentChangeAmount > 0)
                {
                    AbstractProcessor processor = ProcessorFactory.Create(currentChangeAmount);
                    if (processor == null)
                    {
                        returnAmountResponse.OperationReport.Add(new Report(null, "Não foi possivel processar seu troco."));
                        return(returnAmountResponse);
                    }

                    Dictionary <long, int> result = processor.CalculateChange(currentChangeAmount);
                    long resultTotalAmount        = result.Sum(t => t.Key * t.Value);
                    chData.Add(new ChangeData()
                    {
                        Type        = processor.GetName(),
                        TotalAmount = resultTotalAmount,
                        Changes     = result
                    });
                    currentChangeAmount -= resultTotalAmount;
                }
                returnAmountResponse.TotalAmount = changeAmount;
                returnAmountResponse.Result      = chData;
                returnAmountResponse.Success     = true;
            }
            catch (Exception ex)
            {
                returnAmountResponse.OperationReport.Add(new Report(null, "Ocorreu um erro interno."));

                LogService.Save("Exception", ex.Message);
            }

            LogService.Save("Response", returnAmountResponse);

            return(returnAmountResponse);
        }