public Product GetProductById(int id)
{
try
{
using (var connection = new SqlConnection(_connectionString))
{
var commandText = "SELECT * FROM Products WHERE Id = @Id";
var command = new SqlCommand(commandText, connection);
command.Parameters.AddWithValue("@Id", id);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(null);
}
return(ProviderUtility.DataReaderMapToObject <Product>(reader));
}
}
}
catch (Exception)
{
throw;
}
}
public UserCredential GetUserCredentialByRefreshToken(string token)
{
try
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand(UserStoredProcedures.GetUserCredentialByRefreshToken, connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@RefreshToken", token);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(null);
}
return(ProviderUtility.DataReaderMapToObject <UserCredential>(reader));
}
}
}
catch (Exception)
{
throw;
}
}
public List <Product> GetList()
{
try
{
using (var connection = new SqlConnection(_connectionString))
{
var commandText = "SELECT * FROM Products";
var command = new SqlCommand(commandText, connection);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(null);
}
return(ProviderUtility.DataReaderMapToList <Product>(reader));
}
}
}
catch (Exception)
{
throw;
}
}
public Product GetFeaturedProduct()
{
try
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand(ProductStoredProcedures.FeaturedProduct, connection);
command.CommandType = CommandType.StoredProcedure;
connection.Open();
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(null);
}
return(ProviderUtility.DataReaderMapToObject <Product>(reader));
}
}
}
catch (Exception)
{
throw;
}
}
public List <Product> Search(string query)
{
try
{
using (var connection = new SqlConnection(_connectionString))
{
var command = new SqlCommand(ProductStoredProcedures.Search, connection);
command.CommandType = CommandType.StoredProcedure;
command.Parameters.AddWithValue("@Query", query);
connection.Open();
using (var reader = command.ExecuteReader())
{
if (!reader.HasRows)
{
return(null);
}
var results = ProviderUtility.DataReaderMapToList <Product>(reader);
return(results);
}
}
}
catch (Exception)
{
throw;
}
}
public Expression CreateInitialization(MutableType declaringType, Func <InitializationBodyContext, Expression> initializationProvider)
{
ArgumentUtility.CheckNotNull("declaringType", declaringType);
ArgumentUtility.CheckNotNull("initializationProvider", initializationProvider);
var context = new InitializationBodyContext(declaringType, isStatic: false, initializationSemantics: declaringType.Initialization.Semantics);
return(ProviderUtility.GetNonNullValue(initializationProvider, context, "initializationProvider"));
}
public void GetNonNullValue_ThrowsForNullReturningProvider()
{
Func <string, object> provider = ctx => null;
Assert.That(
() => ProviderUtility.GetNonNullValue(provider, "", "argumentName"),
Throws.ArgumentException
.With.ArgumentExceptionMessageEqualTo(
"Provider must not return null.", "argumentName"));
}
public static Expression GetTypedBody <TContext> (Type expectedType, Func <TContext, Expression> bodyProvider, TContext context)
where TContext : BodyContextBase
{
ArgumentUtility.CheckNotNull("expectedType", expectedType);
ArgumentUtility.CheckNotNull("bodyProvider", bodyProvider);
ArgumentUtility.CheckNotNull("context", context);
var body = ProviderUtility.GetNonNullValue(bodyProvider, context, "bodyProvider");
return(ExpressionTypeUtility.EnsureCorrectType(body, expectedType));
}
public void GetNonNullValue()
{
var context = "hello";
var value = new object();
Func <string, object> provider = ctx =>
{
Assert.That(ctx, Is.SameAs(context));
return(value);
};
var result = ProviderUtility.GetNonNullValue(provider, context, providerArgumentName: "does not matter");
Assert.That(result, Is.SameAs(value));
}
private MethodSignatureItems GetMethodSignatureItems(
MutableType declaringType,
IEnumerable <GenericParameterDeclaration> genericParameters,
Func <GenericParameterContext, Type> returnTypeProvider,
Func <GenericParameterContext, IEnumerable <ParameterDeclaration> > parameterProvider)
{
var genericParameterDeclarations = genericParameters.ToList();
var genericParams = genericParameterDeclarations
.Select((p, i) => new MutableGenericParameter(i, p.Name, declaringType.Namespace, p.Attributes)).ToList();
var genericParameterContext = new GenericParameterContext(genericParams.Cast <Type>());
foreach (var paraAndDecl in genericParams.Zip(genericParameterDeclarations, (p, d) => new { Parameter = p, Declaration = d }))
{
paraAndDecl.Parameter.SetGenericParameterConstraints(paraAndDecl.Declaration.ConstraintProvider(genericParameterContext));
}
var returnType = ProviderUtility.GetNonNullValue(returnTypeProvider, genericParameterContext, "returnTypeProvider");
var parameters = ProviderUtility.GetNonNullValue(parameterProvider, genericParameterContext, "parameterProvider").ToList();
return(new MethodSignatureItems(genericParams, returnType, parameters));
}
public void GetNonNullValue_ThrowsForNullReturningProvider()
{
Func <string, object> provider = ctx => null;
ProviderUtility.GetNonNullValue(provider, "", "argumentName");
}
