Beispiel #1
0
        public async Task <bool> InsertAsync(CurrencyConverterInsert command)
        {
            string query = @"INSERT INTO TRANSACTIONCURRENCY VALUES
                           (
                           null, @IdUser, @CurrencyFrom, @CurrencyTo,
                           @ValueFrom, @ValueTo, @RateConversionUsed, @Date
                            )";

            Dictionary <string, object> parameters = new Dictionary <string, object>
            {
                { "Id", null },
                { "IdUser", command.IdUser },
                { "CurrencyFrom", command.CurrencyFrom },
                { "CurrencyTo", command.CurrencyTo },
                { "ValueFrom", command.ValueFrom },
                { "ValueTo", command.ValueTo },
                { "RateConversionUsed", command.RateConversionUsed },
                { "Date", DateTime.Now }
            };

            try
            {
                return(IntExtension.TryParse(
                           await _sqlDataContext.ExecuteScalar(NameDataBase, query, parameters)) > 0);
            }
            catch (Exception ex)
            {
                throw new ArgumentException("Error requisition to DatabAse!", "insert table => TRANSACTIONCURRENCY", ex);
            }
        }
        public async Task <ActionResult> InsertAsync([Required][FromBody] CurrencyConverterInsert command)
        {
            try
            {
                var result = await _currencyConverterServices.InsertAsync(command);

                if (!result.Success)
                {
                    return(BadRequest(result));
                }

                return(Ok(result));
            }
            catch (Exception ex)
            {
                return(StatusCode(StatusCodes.Status500InternalServerError, ex));
            }
        }
        public async Task <ReturnGeneric> InsertAsync(CurrencyConverterInsert command)
        {
            try
            {
                var commandCurrency = new CurrencyInsert(command.CurrencyFrom, command.CurrencyTo);

                if (!commandCurrency.Validate())
                {
                    return(new ReturnGeneric(false, Constants.VALIDATION_GENERIC_ERROR, commandCurrency.Notifications));
                }

                dynamic result = await GetExchangeRate(command.CurrencyFrom, command.CurrencyTo);

                if (result == null)
                {
                    return(new ReturnGeneric(false, "Currency no data.", command.Notifications));
                }

                dynamic data = JsonConvert.DeserializeObject(result.Data.ToString(), typeof(object));

                if (data != null)
                {
                    foreach (var item in data.rates)
                    {
                        command.RateConversionUsed = item.Value;
                        command.ValueTo            = item.Value * command.ValueFrom;
                    }
                }

                if (!command.Validate())
                {
                    return(new ReturnGeneric(false, Constants.VALIDATION_GENERIC_ERROR, command.Notifications));
                }

                return(new ReturnGeneric(true, "Insert Success.", await _currencyConverterRepository.InsertAsync(command)));
            }
            catch (Exception ex)
            {
                return(new ReturnGeneric(false, ex.Message, ex.Data));
            }
        }