private static TableBuilderService BuildTableBuilderService(
StatisticsDbContext statisticsDbContext,
IFilterItemRepository?filterItemRepository = null,
IObservationService?observationService = null,
IPersistenceHelper <StatisticsDbContext>?statisticsPersistenceHelper = null,
IResultSubjectMetaService?resultSubjectMetaService = null,
ISubjectRepository?subjectRepository = null,
IUserService?userService = null,
IResultBuilder <Observation, ObservationViewModel>?resultBuilder = null,
IReleaseRepository?releaseRepository = null,
IOptions <TableBuilderOptions>?options = null)
{
return(new(
statisticsDbContext,
filterItemRepository ?? Mock.Of <IFilterItemRepository>(Strict),
observationService ?? Mock.Of <IObservationService>(Strict),
statisticsPersistenceHelper ?? new PersistenceHelper <StatisticsDbContext>(statisticsDbContext),
resultSubjectMetaService ?? Mock.Of <IResultSubjectMetaService>(Strict),
subjectRepository ?? Mock.Of <ISubjectRepository>(Strict),
userService ?? AlwaysTrueUserService().Object,
resultBuilder ?? new ResultBuilder(),
releaseRepository ?? Mock.Of <IReleaseRepository>(Strict),
options ?? DefaultOptions()
));
}
public GraphSchemaIOClient(
IGraphQLRequestExecutor requestExecutor,
IRequestBuilder requestBuilder,
IResultBuilder resultBuilder,
IPartialSchemaProvider partialSchemaProvider,
ISchemaValidator schemaValidator) : base(requestExecutor, requestBuilder, resultBuilder, partialSchemaProvider, schemaValidator)
{
}
public void CreateSubstitutes()
{
ReqExecutor = Substitute.For <IGraphQLRequestExecutor>();
ReqBuilder = Substitute.For <IRequestBuilder>();
ResBuilder = Substitute.For <IResultBuilder>();
SchemaProv = Substitute.For <IPartialSchemaProvider>();
Validator = Substitute.For <ISchemaValidator>();
}
public ParameterValueProvider(IEnumerable<IValueProvider> items,IResultBuilder resultBuilder, IFilter filter, bool required, string name)
{
this.Items = items;
this.ResultBuilder = resultBuilder;
this.Filter = filter;
this.Required = required;
this.Name = name;
}
public void EnqueueMessage(IRequestMessage requestMessage, IResultBuilder resultBuilder = null)
{
_unhandledMessages.Enqueue(requestMessage);
_resultBuilders.Enqueue(resultBuilder);
if (requestMessage is ResetMessage)
{
Interrupt();
}
}
public RegisterUserCommand(
IUsersRepository usersRepository,
IResultBuilder resultBuilder,
IUserUnderRegistration userUnderRegistration)
{
_usersRepository = usersRepository;
_userUnderRegistration = userUnderRegistration;
_resultBuilder = resultBuilder;
}
public IRegisterUserCommand CreateRegisterUserCommand(
UserDto userDto,
IResultBuilder resultBuilder)
{
return(new RegisterUserCommand(
_usersRepository,
resultBuilder,
new UserUnderRegistration(userDto)));
}
public QueryEngineParameterValueProvider(IQueryEngine queryEngine, IResultBuilder resultBuilder, bool required, string name, ILoggerProvider loggerProvider)
{
_queryEngine = queryEngine;
ResultBuilder = resultBuilder;
Required = required;
Name = name;
TimerLogger = loggerProvider.GetLogger(LogHeirarchy.Root.Timer.Value, GetType());
FlowLogger = loggerProvider.GetLogger(LogHeirarchy.Root.Flow.Value, GetType());
}
protected ResultState(IState parentState, IResultBuilder <T> resultBuilder, IActiveState activeState,
Creator <IResultAttributeBuilder> createAttributeBuilder, Creator <IAttributeState, IState, IResultAttributeBuilder> createAttributeState)
{
_parentState = parentState;
_resultBuilder = resultBuilder;
_activeState = activeState;
_createAttributeBuilder = createAttributeBuilder;
_createAttributeState = createAttributeState;
Valid = true;
}
public GraphQLClient(
IGraphQLRequestExecutor requestExecutor,
IRequestBuilder requestBuilder,
IResultBuilder resultBuilder,
IPartialSchemaProvider partialSchemaProvider,
ISchemaValidator schemaValidator
)
{
RequestExecutor = requestExecutor;
RequestBuilder = requestBuilder;
PartialSchemaProvider = partialSchemaProvider;
SchemaValidator = schemaValidator;
ResultBuilder = resultBuilder;
}
public static bool Update(this IDbConnection connection, IResultBuilder result)
{
int o = 0;
connection.On();
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = result.Sql;
command.Parameters.AddRange(result.Parameter);
o = command.ExecuteNonQuery();
command.Parameters.Clear();
}
connection.Off();
return(o > 0);
}
public static bool Insert(this IDbConnection connection, IResultBuilder result)
{
bool status = false;
connection.On();
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = result.Sql;
command.Parameters.AddRange(result.Parameter);
status = (command.ExecuteNonQuery() > 0);
command.Parameters.Clear();
}
connection.Off();
return(status);
}
public static T Insert <T>(this IDbConnection connection, IResultBuilder result)
where T : struct
{
T o;
connection.On();
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = result.Sql;
command.Parameters.AddRange(result.Parameter);
o = (T)command.ExecuteScalar();
command.Parameters.Clear();
}
connection.Off();
return(o);
}
public TableBuilderService(
IObservationService observationService,
IPersistenceHelper <StatisticsDbContext> statisticsPersistenceHelper,
IResultSubjectMetaService resultSubjectMetaService,
ISubjectService subjectService,
IUserService userService,
IResultBuilder <Observation, ObservationViewModel> resultBuilder,
IReleaseService releaseService)
{
_observationService = observationService;
_statisticsPersistenceHelper = statisticsPersistenceHelper;
_resultSubjectMetaService = resultSubjectMetaService;
_subjectService = subjectService;
_userService = userService;
_resultBuilder = resultBuilder;
_releaseService = releaseService;
}
private TableBuilderService BuildTableBuilderService(
IObservationService observationService = null,
IPersistenceHelper <StatisticsDbContext> statisticsPersistenceHelper = null,
IResultSubjectMetaService resultSubjectMetaService = null,
ISubjectService subjectService = null,
IUserService userService = null,
IResultBuilder <Observation, ObservationViewModel> resultBuilder = null,
IReleaseService releaseService = null)
{
return(new TableBuilderService(
observationService ?? new Mock <IObservationService>().Object,
statisticsPersistenceHelper ?? StatisticsPersistenceHelperMock(_subject).Object,
resultSubjectMetaService ?? new Mock <IResultSubjectMetaService>().Object,
subjectService ?? new Mock <ISubjectService>().Object,
userService ?? new Mock <IUserService>().Object,
resultBuilder ?? new ResultBuilder(DataServiceMapperUtils.DataServiceMapper()),
releaseService ?? new Mock <IReleaseService>().Object
));
}
private static TableBuilderResult BuildResult(IEnumerable <IGeographicData> data, ICollection <string> attributes,
IResultBuilder <IGeographicData, ITableBuilderData> resultBuilder)
{
if (!data.Any())
{
return(new TableBuilderResult());
}
var first = data.FirstOrDefault();
return(new TableBuilderResult
{
PublicationId = first.PublicationId,
ReleaseId = first.ReleaseId,
ReleaseDate = first.ReleaseDate,
Level = first.Level,
Result = data.Select(tidyData => resultBuilder.BuildResult(tidyData, attributes))
});
}
public static IList <T> Query <T>(this IDbConnection connection, IResultBuilder result) where T : class, new()
{
IList <T> list = new List <T>();
T model = null;
connection.On();
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = result.Sql;
command.Parameters.AddRange(result.Parameter);
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
model = Activator.CreateInstance <T>();
for (int i = 0; i < reader.FieldCount; i++)
{
PropertyInfo property = model
.GetType()
.GetProperties()
.Where(x => x.Name == reader.GetName(i))
.FirstOrDefault();
if (property == null)
{
throw new Exception("Class different of result");
}
if (!reader.IsDBNull(i))
{
property?.SetValue(model, reader.GetValue(i));
}
}
list.Add(model);
}
command.Parameters.Clear();
}
}
connection.Off();
return(list);
}
public static ArrayList Query(this IDbConnection connection, IResultBuilder result)
{
connection.On();
ArrayList items = new ArrayList();
using (IDbCommand command = connection.CreateCommand())
{
command.CommandText = result.Sql;
command.Parameters.AddRange(result.Parameter);
using (IDataReader reader = command.ExecuteReader())
{
while (reader.Read())
{
object[] param = new object[reader.FieldCount];
reader.GetValues(param);
items.Add(param);
}
}
command.Parameters.Clear();
}
connection.Off();
return(items);
}
static void Main(string[] args)
{
ILayout layout = new LayoutSqlServer();
IResultBuilder result0 = Builders.SelectFrom(layout, "test")
.Columns("column1, column2")
.Where <SqlParameter, int>("column1", 1)
.OrWhere <SqlParameter, int>("column2", 2)
.WhereNull("column1")
.WhereBetween("column1", new SqlParameter("@p1", 1), new SqlParameter("@p2", 1))
.Builder();
IResultBuilder result1 = Builders.InsertFrom(layout, "test")
.Columns("column1", "column2")
.Values(new SqlParameter("@column1", 1), new SqlParameter("@column2", 1))
.Identity()
.Builder();
IResultBuilder result2 = Builders.UpdateFrom(layout, "test")
.SetValue("column1", new SqlParameter("@column1", 1))
.SetValue("column2", new SqlParameter("@column2", 2))
.Where("id", new SqlParameter("@id", 1))
.WhereNull("id")
.Builder();
IResultBuilder result3 = Builders.DeleteFrom(layout, "test")
.Where <SqlParameter, int>("id", 10)
.WhereNull("id")
.WhereBetween("column1", new SqlParameter("@p1", 1), new SqlParameter("@p2", 1))
.Builder();
Console.WriteLine(result0.Sql);
Console.WriteLine(result1.Sql);
Console.WriteLine(result2.Sql);
Console.WriteLine(result3.Sql);
Console.ReadKey();
}
public TableBuilderService(
StatisticsDbContext context,
IFilterItemRepository filterItemRepository,
IObservationService observationService,
IPersistenceHelper <StatisticsDbContext> statisticsPersistenceHelper,
IResultSubjectMetaService resultSubjectMetaService,
ISubjectRepository subjectRepository,
IUserService userService,
IResultBuilder <Observation,
ObservationViewModel> resultBuilder,
IReleaseRepository releaseRepository,
IOptions <TableBuilderOptions> options)
{
_context = context;
_filterItemRepository = filterItemRepository;
_observationService = observationService;
_statisticsPersistenceHelper = statisticsPersistenceHelper;
_resultSubjectMetaService = resultSubjectMetaService;
_subjectRepository = subjectRepository;
_userService = userService;
_resultBuilder = resultBuilder;
_releaseRepository = releaseRepository;
_options = options.Value;
}
static void Main(string[] args)
{
//var builder = FlepperQueryBuilder
// .Insert()
// .Into("Table1")
// .Columns("Column1")
// .Values("Value1")
// .WithScopeIdentity()
// .BuildWithParameters();
IDbConnection dbConnection = new SqlConnection("Server=.\\SqlExpress;Database=QueryBuilderDatabase;User Id=sa;Password=senha;MultipleActiveResultSets=true;");
ILayout layout = new LayoutSqlServer();
#region Layout
SqlParameter Created = new SqlParameter("@Created", SqlDbType.DateTime)
{
IsNullable = true,
SourceColumnNullMapping = true,
Value = DateTime.Now.Date.AddDays(-1) // DBNull.Value
};
SqlParameter Name = new SqlParameter("@Name", SqlDbType.VarChar, 50)
{
Value = "Maria Aparecida Dias Cintra"
};
SqlParameter Id = new SqlParameter("@Id", SqlDbType.Int)
{
Value = 2
};
SqlParameter Active = new SqlParameter("@Active", SqlDbType.Bit)
{
Value = true
};
#endregion
IResultBuilder resultSelect0 = Builders
.SelectFrom(layout, "Owe")
.Where <SqlParameter, int>("Id", 2)
.OrWhere <SqlParameter, int>("Id", 10, "@p1")
.Builder();
IResultBuilder resultSelect1 = Builders
.SelectFrom(layout, "Credit")
.Where <SqlParameter, int>("Id", 100)
.Builder();
var abc = Builders.DeleteFrom(layout, "")
.Where <SqlParameter, int>("Id", 1)
.OrWhere <SqlParameter, int>("Id", 10, "@p00")
.Builder();
var a1 = dbConnection.Query <Owe>(resultSelect0);
var a2 = dbConnection.Query <Credit>(resultSelect1);
var aaa = 100;
//var r = dbConnection.InsertToInt(resultInsert);
//IResultBuilder resultUpdate = Builders.UpdateFrom(layout, "Owe")
// .SetValue("Created", Created)
// .Where("Id", Id)
// .Builder();
////var id = dbConnection.Update(resultUpdate);
//var resultDelete = Builders.DeleteFrom(layout, "Owe")
// .Where("Id", Id)
// .Builder();
//var a = dbConnection.Update(resultDelete);
//Console.WriteLine(a);
//dbConnection.Execute(resultUpdate);
//DynamicParameters parameter = new DynamicParameters();
//parameter.Add("Name", "ccc NULL", DbType.String, ParameterDirection.Input);
//parameter.Add("Created", null, DbType.Date, ParameterDirection.Input);
//parameter.Add("Active", true, DbType.Boolean, ParameterDirection.Input);
//var ra = dbConnection.Execute("INSERT INTO Owe(Name, Created, Active) VALUES(@Name, @Created, @Active)", parameter);
IResultBuilder result = Builders
.SelectFrom(layout, "Owe")
.Builder();
IList <Owe> listOwe = dbConnection.Query <Owe>(result);
var dados = dbConnection.Query(result);
Console.ReadKey();
}
/// <summary> /// Sets the Result Object, further details representing a measured outcome. /// </summary> /// <param name="resultBuilder">A result builder.</param> /// <returns>The statement builder, to continue the fluent configuration.</returns> public IStatementBuilder WithResult(IResultBuilder resultBuilder) => WithResult(resultBuilder.Build());
public void Register(IRequestMessage requestMessage, IResultBuilder resultBuilder = null)
{
_sentMessages.Enqueue(requestMessage);
_resultBuilders.Enqueue(resultBuilder);
}
public void Run(IResultBuilder resultBuilder, string statement, IDictionary <string, object> paramters = null)
{
var runMessage = new RunMessage(statement, paramters);
Enqueue(runMessage, resultBuilder);
}
private void Enqueue(IRequestMessage requestMessage, IResultBuilder resultBuilder = null)
{
_messages.Enqueue(requestMessage);
_responseHandler.EnqueueMessage(requestMessage, resultBuilder);
}
public void PullAll(IResultBuilder resultBuilder)
{
Enqueue(new PullAllMessage(), resultBuilder);
resultBuilder.ReceiveOneFun = () => _client.ReceiveOne(_responseHandler, OnResponseHasError);
}
public void PullAll(IResultBuilder resultBuilder)
{
_connection.PullAll(resultBuilder);
}
public void Run(IResultBuilder resultBuilder, string statement, IDictionary <string, object> parameters = null)
{
_connection.Run(resultBuilder, statement, parameters);
}
public void EnqueueMessage(IRequestMessage requestMessage, IResultBuilder resultBuilder = null)
{
_messageHandler.EnqueueMessage(requestMessage, resultBuilder);
}
public void Register(IRequestMessage requestMessage, IResultBuilder resultBuilder = null)
{
_messageHandler.Register(requestMessage, resultBuilder);
}
public static long InsertToLong(this IDbConnection connection, IResultBuilder result)
{
return(Insert <long>(connection, result));
}
public void SaveIn(IUsersRepository usersRepository, IResultBuilder resultBuilder)
{
usersRepository.Add(_userDto);
resultBuilder.UserAddedSuccessfully(_userDto);
}
