public void TestTokens_Create_Get()
{
BbvaAPI bbvaAPI = new BbvaAPI(Constants.API_KEY, Constants.MERCHANT_ID);
List <IParameter> request = new List <IParameter> {
new SingleParameter("holder_name", "Juan Perez Ramirez"),
new SingleParameter("card_number", "4111111111111111"),
new SingleParameter("cvv2", "022"),
new SingleParameter("expiration_month", "12"),
new SingleParameter("expiration_year", "20"),
};
Dictionary <String, Object> tokenDictionary = bbvaAPI.TokenService.Create(request);
ParameterContainer token = new ParameterContainer("token", tokenDictionary);
Assert.IsNotNull(token);
String tokenId = token.GetSingleValue("id").ParameterValue;
Assert.IsNotNull(tokenId);
Assert.IsNotNull(token.GetContainerValue("card"));
tokenDictionary = bbvaAPI.TokenService.Get(tokenId);
token = new ParameterContainer("token", tokenDictionary);
Assert.IsNotNull(token);
Assert.AreEqual(tokenId, token.GetSingleValue("id").ParameterValue);
}
public void TestRefundCharge()
{
BbvaAPI bbvaAPI = new BbvaAPI(Constants.NEW_API_KEY, Constants.NEW_MERCHANT_ID);
Decimal amount = new Decimal(200.00);
Dictionary <String, Object> tokenDictionary = bbvaAPI.TokenService.Create(GetTokenRequest());
ParameterContainer token = new ParameterContainer("token", tokenDictionary);
List <IParameter> request = new List <IParameter> {
new SingleParameter("affiliation_bbva", "720931"),
new SingleParameter("amount", "200.00"),
new SingleParameter("description", "Test Charge"),
new SingleParameter("customer_language", "SP"),
new SingleParameter("capture", "TRUE"),
new SingleParameter("use_3d_secure", "FALSE"),
new SingleParameter("use_card_points", "NONE"),
new SingleParameter("token", token.GetSingleValue("id").ParameterValue),
new SingleParameter("currency", "MXN"),
new SingleParameter("order_id", "oid-00051"),
GetCustomer()
};
Dictionary <String, Object> chargeDictionary = bbvaAPI.ChargeService.Create(request);
ParameterContainer charge = new ParameterContainer("charge", chargeDictionary);
Assert.IsNotNull(charge);
string description = "reembolso desce .Net de " + amount;
Dictionary <String, Object> refund = bbvaAPI.ChargeService.Refund(charge.GetSingleValue("id").ParameterValue, description, amount);
Assert.IsNotNull(refund);
}
public void EqualityComparison()
{
List <Parameter> parameters = new List <Parameter>(10);
parameters.Add(new IntegerParameter("test_int", "text_int", 3));
parameters.Add(new FloatParameter("test_float", "text_float", 565.584f));
parameters.Add(new IntRangeParameter("test_range_int", "text_range_int", 10, 40, 40));
parameters.Add(new FloatRangeParameter("test_range_float", "text_range_float", 2.3f, 4.5f, 3.1f));
parameters.Add(new BooleanParameter("test_boolean", "text_boolean", true));
parameters.Add(new StringParameter("test_string", "text_string", "Hello, world!"));
List <Parameter> parameters2 = new List <Parameter>(10);
parameters2.Add(new IntegerParameter("test_int", "text_int", 3));
parameters2.Add(new FloatParameter("test_float", "text_float", 565.584f));
parameters2.Add(new IntRangeParameter("test_range_int", "text_range_int", 10, 40, 40));
parameters2.Add(new FloatRangeParameter("test_range_float", "text_range_float", 2.3f, 4.5f, 3.1f));
parameters2.Add(new BooleanParameter("test_boolean", "text_boolean", true));
ParameterContainer test = new ParameterContainer(parameters);
ParameterContainer identical = new ParameterContainer(parameters);
ParameterContainer different = new ParameterContainer(parameters2);
Assert.AreEqual(test, identical);
Assert.AreNotEqual(test, different);
Assert.AreEqual(test, test);
}
public int ExecuteNonQuery(string query, ParameterContainer queryParameters = null)
{
using (var command = GetDbCommand(query, queryParameters))
{
return(command.ExecuteNonQuery());
}
}
public void TestGetId()
{
BbvaAPI bbvaAPI = new BbvaAPI(Constants.API_KEY, Constants.MERCHANT_ID);
Decimal amount = new Decimal(200.00);
Dictionary <String, Object> tokenDictionary = bbvaAPI.TokenService.Create(GetTokenRequest());
ParameterContainer token = new ParameterContainer("token", tokenDictionary);
List <IParameter> request = new List <IParameter> {
new SingleParameter("affiliation_bbva", "720931"),
new SingleParameter("amount", "200.00"),
new SingleParameter("description", "Test Charge"),
new SingleParameter("customer_language", "SP"),
new SingleParameter("capture", "false"),
new SingleParameter("use_3d_secure", "false"),
new SingleParameter("use_card_points", "NONE"),
new SingleParameter("token", token.GetSingleValue("id").ParameterValue),
new SingleParameter("currency", "MXN"),
new SingleParameter("order_id", "oid-00051"),
GetCustomer()
};
Dictionary <String, Object> chargeDictionary = bbvaAPI.ChargeService.Create(request);
ParameterContainer charge = new ParameterContainer("charge", chargeDictionary);
Assert.IsNotNull(charge);
String chargeId = charge.GetSingleValue("id").ParameterValue;
chargeDictionary = bbvaAPI.ChargeService.Get(chargeId);
charge = new ParameterContainer("charge", chargeDictionary);
Assert.IsNotNull(charge);
Assert.IsNotNull(charge.GetSingleValue("id").ParameterValue);
}
public async Task <int> ExecuteNonQueryAsync(string query, ParameterContainer queryParameters = null)
{
using (var command = GetDbCommand(query, queryParameters))
{
return(await command.ExecuteNonQueryAsync());
}
}
public void Get_NotFoundParameter_ThrowsArgumentException()
{
BooleanParameter b = new BooleanParameter("id", "caption", true);
ParameterContainer collection = new ParameterContainer(new[] { b });
collection.Get <bool>("none");
}
public void Get_InvalidTypeParameter_ThrowsInvalidCastException()
{
BooleanParameter b = new BooleanParameter("id", "caption", true);
ParameterContainer collection = new ParameterContainer(new[] { b });
collection.Get <String>("id");
}
/// <summary>
/// Adicionar um parametro.
/// </summary>
/// <param name="name">Nome do parametro.</param>
/// <param name="dbtype">Tipo usado na base de dados.</param>
/// <param name="value">parameter value</param>
public ConditionalContainer Add(string name, DbType dbtype, object value)
{
ParameterContainer.Add(new GDAParameter(name, value)
{
DbType = dbtype
});
return(this);
}
public T ExecuteScalar <T>(string query, ParameterContainer queryParameters = null) where T : IEquatable <T>, IConvertible
{
using (var command = GetDbCommand(query, queryParameters))
{
var queryResult = command.ExecuteScalar();
return(new TypeMapper <T>().MapScalar(queryResult));
}
}
public User LoadByName(string userId)
{
using (UsersRepository repo = new UsersRepository(DataContext)){
var __params = new ParameterContainer().Add("UserId", userId)
.ToDictionary();
return(repo.LoadOne <User>(this, repo.GetItems(__params)));
}
}
public IEnumerable <T> ExecuteReader <T>(string query, ParameterContainer queryParameters = null)
{
using (var command = GetDbCommand(query, queryParameters))
{
var reader = command.ExecuteReader();
return(new TypeMapper <T>().MapDataReader(reader));
}
}
public Group LoadByName(string name)
{
using (GroupsRepository repo = new GroupsRepository(DataContext))
{
var __params = new ParameterContainer().Add("Name", name)
.ToDictionary();
return(repo.LoadOne <Group>(this, repo.GetItems(__params)));
}
}
private DbCommand GetDbCommand(string query, ParameterContainer queryparameters)
{
DbCommand command = _connection.CreateCommand();
command.CommandText = query;
command.CommandType = _commandType;
command.AddParameters(queryparameters);
return(command);
}
public void EnumerableConstructor_DuplicatedId_ThrowsArgumentException()
{
var list = new List <Parameter>(2);
list.Add(new IntegerParameter("DUPLICATE", "caption 1", 2));
list.Add(new IntegerParameter("DUPLICATE", "caption 2", 3));
ParameterContainer c = new ParameterContainer(list);
}
/// <summary>
/// Adiciona vários parâmetros para o container.
/// </summary>
/// <param name="parameters">Parâmetros a serem adicionados.</param>
public ConditionalContainer Add(IEnumerable <QueryParameter> parameters)
{
parameters.Require("parameters").NotNull();
foreach (var i in parameters)
{
ParameterContainer.Add(i);
}
return(this);
}
/// <summary>
/// Adds a parameter.
/// </summary>
/// <param name="dbtype">database data type</param>
/// <param name="size">size of the database data type</param>
/// <param name="value">parameter value</param>
public ConditionalContainer Add(DbType dbtype, int size, object value)
{
ParameterContainer.Add(new GDAParameter()
{
DbType = dbtype,
Size = size,
Value = value
});
return(this);
}
public void Save_UnknownParameterTypeAsked_ThrowsInvalidParameterTypeException()
{
XmlParameterContainerParser loader = new XmlParameterContainerParser();
var invalidCollection = new ParameterContainer(new List <Parameter> {
new InvalidParameter()
});
loader.Save(invalidCollection, filename);
}
/// <summary>
/// Creates a new event with the specified start time, end time, type, unknown, and parameters.
/// </summary>
public Event(float startTime, float endTime, int type, int unk04, byte[] parameters, bool isBigEndianParameters)
{
StartTime = startTime;
EndTime = endTime;
Type = type;
Unk04 = unk04;
ParameterBytes = parameters;
if (Template != null)
{
Parameters = new ParameterContainer(isBigEndianParameters, parameters, Template);
}
}
/// <summary>
/// Applies a template to allow editing of the parameters.
/// </summary>
public void ApplyTemplate(bool isBigEndian, Template.EventTemplate template)
{
if (template.ID != Type)
{
throw new ArgumentException($"Template is for event type {template.ID} but this event is type {Type}");
}
if (Parameters != null)
{
CopyParametersToBytes(isBigEndian);
}
Array.Resize(ref ParameterBytes, template.GetAllParametersByteCount());
Parameters = new ParameterContainer(isBigEndian, ParameterBytes, template);
}
public async Task AddAsync(string username, string password)
{
string query = "INSERT INTO users (username, password) VALUES(@username, @password);";
var parameters = new ParameterContainer();
parameters.Add("@username", username);
parameters.Add("@password", password);
await _connection.OpenAsync();
await _connection.ExecuteNonQueryAsync(query, parameters);
_connection.Close();
}
/// <summary>
/// Applies a template to allow editing of the parameters.
/// </summary>
internal void ApplyTemplate(TAE containingTae, Template template,
long animID, int eventIndex, int eventType)
{
if (template[containingTae.EventBank].ContainsKey(Type))
{
if (Parameters != null)
{
CopyParametersToBytes(containingTae.BigEndian);
}
Array.Resize(ref ParameterBytes, template[containingTae.EventBank][Type].GetAllParametersByteCount());
Parameters = new ParameterContainer(animID, eventIndex,
containingTae.BigEndian, ParameterBytes, template[containingTae.EventBank][Type]);
}
}
public void TestMerchant_Get()
{
BbvaAPI bbvaAPI = new BbvaAPI(Constants.API_KEY, Constants.MERCHANT_ID);
Dictionary <String, Object> merchantDictionary = bbvaAPI.MerchantService.Get();
ParameterContainer merchant = new ParameterContainer("merchant", merchantDictionary);
Assert.IsNotNull(merchant);
Assert.IsNotNull(merchant.GetSingleValue("name").ParameterValue);
Assert.IsNotNull(merchant.GetSingleValue("email").ParameterValue);
Assert.IsNotNull(merchant.GetSingleValue("creation_date").ParameterValue);
Assert.IsNotNull(merchant.GetSingleValue("status").ParameterValue);
Assert.IsNull(merchant.GetSingleValue("clabe").ParameterValue);
Assert.IsNotNull(merchant.GetSingleValue("phone").ParameterValue);
}
public async Task <User> GetByIdAsync(long id)
{
string query = "SELECT * FROM users WHERE id=@id;";
var parameters = new ParameterContainer();
parameters.Add("@id", id);
await _connection.OpenAsync();
var user = (await _connection.ExecuteReaderAsync <User>(query, parameters)).FirstOrDefault();
_connection.Close();
return(user);
}
private Text GetText()
{
ParameterContainer rootParameterContainer = nodeGraph.rootGraph.GetComponent <ParameterContainer>();
if (rootParameterContainer == null)
{
return(null);
}
Parameter parameter = rootParameterContainer.GetParam("CurrentGraphText");
if (parameter == null)
{
return(null);
}
return(parameter.objectReferenceValue as Text);
}
internal static void AddParameters(this DbCommand command, ParameterContainer parameters)
{
if (parameters == null)
{
return;
}
command.Parameters.Clear();
foreach (var parameter in parameters)
{
var param = command.CreateParameter();
param.ParameterName = parameter.Key;
param.Value = parameter.Value;
command.Parameters.Add(param);
}
}
public void AddParameterInContainer(ParameterDefinitionWithValue parameter)
{
var parameterInContainer = ParameterContainer.FirstOrDefault(p => p.Name == parameter.Name);
if (parameterInContainer == null)
{
parameterInContainer = new ParameterContainerInfo {
Name = parameter.Name
};
var list = ParameterContainer.ToList();
list.Add(parameterInContainer);
ParameterContainer = list.ToArray();
}
parameterInContainer.Type = parameter.Type;
parameterInContainer.Value = parameter.Value;
}
public void Load_ReturnsCorrectContainer()
{
string defaultSettings = Path.Combine(TestContext.CurrentContext.TestDirectory, "TestData\\default_settings.xml");
ParameterContainer actual = ParameterContainer.Load(defaultSettings);
List <Parameter> parameters = new List <Parameter>(10);
parameters.Add(new IntegerParameter("test_int", "text_int", 3));
parameters.Add(new FloatParameter("test_float", "text_float", 565.584f));
parameters.Add(new IntRangeParameter("test_range_int", "text_range_int", 10, 40, 40));
parameters.Add(new FloatRangeParameter("test_range_float", "text_range_float", 2.3f, 4.5f, 3.1f));
parameters.Add(new BooleanParameter("test_boolean", "text_boolean", true));
parameters.Add(new StringParameter("test_string", "text_string", "Hello, world!"));
ParameterContainer expected = new ParameterContainer(parameters);
Assert.AreEqual(expected, actual);
}
// ####
private Dictionary <String, object> typeContainer(IParameter parameter)
{
var finalValues = new Dictionary <String, object>();
if (parameter is ParameterContainer)
{
var values = new Dictionary <String, object>();
ParameterContainer container = (ParameterContainer)parameter;
foreach (IParameter param in container.ParameterValues)
{
var results = typeSingleParameter(param)
.Union(typeContainer(param))
.ToDictionary(d => d.Key, d => d.Value);
values = values.Union(results).ToDictionary(d => d.Key, d => d.Value);
}
finalValues.Add(container.ParameterName, values);
}
return(finalValues);
}
internal void ChangeTemplateAfterLoading(TAE containingTae, Template template,
long animID, int eventIndex, int eventType)
{
if (template[containingTae.EventBank].ContainsKey(Type))
{
Array.Resize(ref ParameterBytes, template[containingTae.EventBank][Type].GetAllParametersByteCount());
var newParameters = new ParameterContainer(animID, eventIndex,
containingTae.BigEndian, ParameterBytes, template[containingTae.EventBank][Type]);
foreach (var field in template[containingTae.EventBank][Type])
{
if (field.Value.ValueToAssert != null)
{
continue;
}
newParameters[field.Key] = Parameters[field.Key];
}
}
}
