public DbInitializerShould()
{
//Given
var dbOptions = new DbContextOptionsBuilder <ReactAdvantageContext>()
.UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString())
.Options;
var loggerMock = new Mock <ILogger <ReactAdvantageContext> >();
var tenantProviderMock = new Mock <ITenantProvider>();
tenantProviderMock.Setup(x => x.GetTenantId()).Returns((int?)null);
_db = new ReactAdvantageContext(dbOptions, loggerMock.Object, tenantProviderMock.Object);
_envMock = new Mock <IHostingEnvironment>();
_envMock.Setup(x => x.EnvironmentName).Returns("Test");
var userStoreMock = new Mock <IUserStore <User> >();
_userManagerMock = new Mock <UserManager <User> >(userStoreMock.Object, null, null, null, null, null, null, null, null);
var roleStore = new Mock <IRoleStore <Role> >();
_roleManagerMock = new Mock <RoleManager <Role> >(roleStore.Object, null, null, null, null);
_dbInitializer = new DbInitializer(
_db,
_envMock.Object,
_userManagerMock.Object,
_roleManagerMock.Object
);
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IHostingEnvironment env,
ILoggerFactory loggerFactory, ReactAdvantageContext db)
{
if (env.IsDevelopment())
{
app.UseBrowserLink();
app.UseDeveloperExceptionPage();
app.UseDatabaseErrorPage();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.UseDefaultFiles();
app.UseStaticFiles();
app.UseAuthentication();
loggerFactory.AddConsole(Configuration.GetSection("Logging"));
loggerFactory.AddDebug();
app.UseMvc();
db.EnsureSeedData();
app.UseMvc(routes =>
{
routes.MapRoute(
name: "default",
template: "{controller=Home}/{action=Index}/{id?}");
});
}
public ProfileService(
ReactAdvantageContext db,
UserManager <User> userManager,
IUserClaimsPrincipalFactory <User> claimsFactory)
{
_db = db;
_userManager = userManager;
_claimsFactory = claimsFactory;
}
public TaskType(ReactAdvantageContext db)
{
Field(c => c.Id);
Field(c => c.Name, nullable: true);
Field(o => o.Description, nullable: true);
Field(o => o.DueDate, nullable: true);
Field(o => o.Completed, nullable: false);
Field(o => o.CompletionDate, nullable: true);
Field <ProjectType>("project",
resolve: context => db.Projects.FindAsync(context.Source.ProjectId));
}
public async Task <IActionResult> SaveAsync([FromBody] ProjectEditDto project)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var context = new ReactAdvantageContext("ReactAdvantage");
var projectService = new ProjectService(context);
await projectService.CreateAsync(project);
return(CreatedAtAction(nameof(GetByIdAsync), new { id = project.Id }, project));
}
public async Task <IActionResult> GetAll()
{
//This makes controller dependent on implementation of ProjectService
var context = new ReactAdvantageContext("ReactAdvantage");
var projectService = new ProjectService(context);
try
{
return(new ObjectResult(await projectService.GetAllAsync()));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public void HaveAssignedLogger()
{
//Given
var dbLogger = new Mock <ILogger <ReactAdvantageContext> >();
var options = new DbContextOptionsBuilder <ReactAdvantageContext>()
.UseInMemoryDatabase(databaseName: "ReactAdvantage")
.Options;
//When
using (var db = new ReactAdvantageContext(options, dbLogger.Object))
{
//Then
Assert.NotNull(db.Logger);
Assert.Equal(dbLogger.Object, db.Logger);
}
}
public AccountController(
ReactAdvantageContext db,
UserManager <User> userManager,
SignInManager <User> signInManager,
IIdentityServerInteractionService interaction,
IClientStore clientStore,
IAuthenticationSchemeProvider schemeProvider,
IEventService events)
{
_db = db;
_userManager = userManager;
_signInManager = signInManager;
_interaction = interaction;
_clientStore = clientStore;
_schemeProvider = schemeProvider;
_events = events;
}
public async Task <IActionResult> GetByIdAsync(int id)
{
var context = new ReactAdvantageContext("ReactAdvantage");
var projectService = new ProjectService(context);
try
{
var projectDto = await projectService.GetByIdAsync(id);
if (projectDto.NoData)
{
return(NotFound());
}
return(Ok(projectDto));
}
catch (Exception ex)
{
return(StatusCode(500, ex));
}
}
public ReactAdvantageMutation(ReactAdvantageContext db)
{
Field <UserType>(
"addUser",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <UserInputType> > {
Name = "user"
}
),
resolve: context =>
{
var user = context.GetArgument <User>("user");
user.Id = 0;
db.Add(user);
db.SaveChanges();
return(user);
});
Field <UserType>(
"editUser",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <UserInputType> > {
Name = "user"
}
),
resolve: context =>
{
var user = context.GetArgument <User>("user");
var entity = db.Users.Find(user.Id);
db.Entry(entity).CurrentValues.SetValues(user);
db.SaveChanges();
return(user);
});
Field <ProjectType>(
"addProject",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ProjectInputType> > {
Name = "project"
}
),
resolve: context =>
{
var project = context.GetArgument <Project>("project");
project.Id = 0;
db.Add(project);
db.SaveChanges();
return(project);
});
Field <ProjectType>(
"editProject",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ProjectInputType> > {
Name = "project"
}
),
resolve: context =>
{
var project = context.GetArgument <Project>("project");
var entity = db.Projects.Find(project.Id);
db.Entry(entity).CurrentValues.SetValues(project);
db.SaveChanges();
return(project);
});
Field <TaskType>(
"addTask",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TaskInputType> > {
Name = "task"
}
),
resolve: context =>
{
var task = context.GetArgument <Task>("task");
task.Id = 0;
db.Add(task);
db.SaveChanges();
return(task);
});
Field <TaskType>(
"editTask",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TaskInputType> > {
Name = "task"
}
),
resolve: context =>
{
var task = context.GetArgument <Task>("task");
var entity = db.Tasks.Find(task.Id);
db.Entry(entity).CurrentValues.SetValues(task);
db.SaveChanges();
return(task);
});
}
public ProjectService(ReactAdvantageContext dbContext)
{
_dbContext = dbContext;
}
public ReactAdvantageQuery(ReactAdvantageContext db)
{
Name = "Query";
Field <UserType>(
"user",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context => db.Users.FindAsync(context.GetArgument <int>("id"))
);
Field <ListGraphType <UserType> >(
"users",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <IntGraphType> > {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "firstname"
},
new QueryArgument <StringGraphType> {
Name = "lastname"
},
new QueryArgument <StringGraphType> {
Name = "name"
},
new QueryArgument <StringGraphType> {
Name = "email"
},
new QueryArgument <BooleanGraphType> {
Name = "isactive"
}
),
resolve: context => db.Users
.HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) =>
query.Where(x => arg.Contains(x.Id)))
.HandleQueryArgument(new ArgumentGetter <string>("firstname", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.FirstName.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <string>("lastname", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.LastName.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <string>("email", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Email.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <bool>("isactive", context), (arg, query) =>
query.Where(x => x.IsActive == arg))
);
Field <ProjectType>(
"project",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context => db.Projects.FindAsync(context.GetArgument <int>("id"))
);
Field <ListGraphType <ProjectType> >(
"projects",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <IntGraphType> > {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "name"
}
),
resolve: context => db.Projects
.HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) =>
query.Where(x => arg.Contains(x.Id)))
.HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg)))
);
Field <TaskType>(
"task",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context => db.Tasks.FindAsync(context.GetArgument <int>("id"))
);
Field <ListGraphType <TaskType> >(
"tasks",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <IntGraphType> > {
Name = "id"
},
new QueryArgument <IntGraphType> {
Name = "projectid"
},
new QueryArgument <StringGraphType> {
Name = "name"
},
new QueryArgument <BooleanGraphType> {
Name = "iscompleted"
},
new QueryArgument <DateGraphType> {
Name = "duedate"
},
new QueryArgument <DateGraphType> {
Name = "completiondate"
}
),
resolve: context => db.Tasks
.HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) =>
query.Where(x => arg.Contains(x.Id)))
.HandleQueryArgument(new ArgumentGetter <int>("projectid", context), (arg, query) =>
query.Where(x => x.ProjectId == arg))
.HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <bool>("iscompleted", context), (arg, query) =>
query.Where(x => x.Completed == arg))
.HandleQueryArgument(new ArgumentGetter <DateTime>("duedate", context), (arg, query) =>
query.Where(x => x.DueDate >= arg.Date && x.DueDate < arg.Date.AddDays(1)))
.HandleQueryArgument(new ArgumentGetter <DateTime>("completiondate", context), (arg, query) =>
query.Where(x => x.CompletionDate >= arg.Date && x.CompletionDate < arg.Date.AddDays(1)))
);
}
public ReactAdvantageMutation(
ReactAdvantageContext db,
UserManager <User> userManager,
RoleManager <Role> roleManager,
IDbInitializer dbInitializer
)
{
_db = db;
_userManager = userManager;
Field <TenantType>(
"addTenant",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TenantInputType> > {
Name = "tenant"
},
new QueryArgument <NonNullGraphType <UserInputType> > {
Name = "adminUser"
}
),
resolve: context =>
{
context.GetUserContext().EnsureIsInRole(RoleNames.HostAdministrator);
var tenantInput = context.GetArgument <Tenant>("tenant");
//tenantInput.Id = 0;
var tenant = new Tenant();
tenant.UpdateValuesFrom(tenantInput);
db.Add(tenant);
db.SaveChanges();
dbInitializer.SeedTenantRoles(tenant.Id);
using (_db.SetTenantFilterValue(tenant.Id))
{
var adminUser = context.GetArgument <UserInput>("adminUser");
adminUser.UserName = "******";
adminUser.TenantId = tenant.Id;
adminUser.IsActive = true;
adminUser.Roles = adminUser.Roles ?? new List <string>();
adminUser.Roles.Add(RoleNames.Administrator);
AddUser(adminUser);
_userManager.AddToRoleAsync(adminUser, RoleNames.Administrator).GetAwaiter().GetResult();
}
return(tenant);
});
Field <TenantType>(
"editTenant",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TenantInputType> > {
Name = "tenant"
}
),
resolve: context =>
{
context.GetUserContext().EnsureIsInRole(RoleNames.HostAdministrator);
var tenantInput = context.GetArgument <Tenant>("tenant");
var entity = db.Tenants.Find(tenantInput.Id);
entity.UpdateValuesFrom(tenantInput);
db.SaveChanges();
return(tenantInput);
});
Field <UserType>(
"addUser",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <UserInputType> > {
Name = "user"
}
),
resolve: context =>
{
context.GetUserContext().EnsureIsInEitherRole(RoleNames.HostAdministrator, RoleNames.Administrator);
var userInput = context.GetArgument <UserInput>("user");
userInput.SetTenantIdOrThrow(context);
var userDto = AddUser(userInput);
return(userDto);
});
Field <UserType>(
"editUser",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <UserInputType> > {
Name = "user"
}
),
resolve: context =>
{
var userInput = context.GetArgument <UserInput>("user");
var userContext = context.GetUserContext();
var isAdmin = userContext.IsInRole(RoleNames.HostAdministrator) ||
userContext.IsInRole(RoleNames.Administrator);
var isEditingSelf = userContext.Id == userInput.Id;
if (!isAdmin && !isEditingSelf)
{
throw new ExecutionError($"Unauthorized. You have to be a member of {RoleNames.HostAdministrator}"
+ $" or {RoleNames.Administrator} role to be able to edit any user,"
+ $" otherwise you can only edit your own user (id: {userContext.Id}).");
}
if (!isAdmin && userInput.Roles != null)
{
throw new ExecutionError($"Unauthorized. You have to be a member of {RoleNames.HostAdministrator}"
+ $" or {RoleNames.Administrator} role to be able to change user roles.");
}
var userDto = EditUser(userInput);
return(userDto);
});
Field <RoleType>(
"addRole",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <RoleInputType> > {
Name = "role"
}
),
resolve: context =>
{
context.GetUserContext().EnsureIsInEitherRole(RoleNames.HostAdministrator, RoleNames.Administrator);
var role = context.GetArgument <Role>("role");
role.Id = null;
role.IsStatic = false;
role.SetTenantIdOrThrow(context);
roleManager.CreateAsync(role).GetAwaiter().GetResult();
return(role);
});
Field <RoleType>(
"editRole",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <RoleInputType> > {
Name = "role"
}
),
resolve: context =>
{
var roleInput = context.GetArgument <Role>("role");
context.GetUserContext().EnsureIsInEitherRole(RoleNames.HostAdministrator, RoleNames.Administrator);
var role = roleManager.FindByIdAsync(roleInput.Id).GetAwaiter().GetResult();
if (role.IsStatic)
{
throw new ExecutionError("You can't edit static roles");
}
role.UpdateValuesFrom(roleInput);
roleManager.UpdateAsync(role).GetAwaiter().GetResult().ThrowOnError();
return(role);
});
Field <ProjectType>(
"addProject",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ProjectInputType> > {
Name = "project"
}
),
resolve: context =>
{
var project = context.GetArgument <Project>("project");
project.Id = 0;
project.SetTenantIdOrThrow(context);
db.Add(project);
db.SaveChanges();
return(project);
});
Field <ProjectType>(
"editProject",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ProjectInputType> > {
Name = "project"
}
),
resolve: context =>
{
var project = context.GetArgument <Project>("project");
var entity = db.Projects.Find(project.Id);
entity.UpdateValuesFrom(project);
db.SaveChanges();
return(project);
});
Field <TaskType>(
"addTask",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TaskInputType> > {
Name = "task"
}
),
resolve: context =>
{
var task = context.GetArgument <Task>("task");
task.Id = 0;
task.SetTenantIdOrThrow(context);
db.Add(task);
db.SaveChanges();
return(task);
});
Field <TaskType>(
"editTask",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <TaskInputType> > {
Name = "task"
}
),
resolve: context =>
{
var task = context.GetArgument <Task>("task");
var entity = db.Tasks.Find(task.Id);
entity.UpdateValuesFrom(task);
db.SaveChanges();
return(task);
});
}
public ReactAdvantageQuery(ReactAdvantageContext db)
{
Name = "Query";
Field <TenantType>(
"tenant",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context =>
{
var idInput = context.GetArgument <int>("id");
var userContext = context.GetUserContext();
var isHostAdmin = userContext.IsInRole(RoleNames.HostAdministrator);
var isUserFromThisTenant = userContext.TenantId == idInput;
if (!isHostAdmin && !isUserFromThisTenant)
{
throw new ExecutionError($"Unauthorized. You have to be a member of {RoleNames.HostAdministrator}"
+ " role to be able to query any tenant, otherwise you can only query"
+ $" your own tenant (id: {userContext.TenantId}).");
}
return(db.Tenants.Find(idInput));
}
);
Field <ListGraphType <TenantType> >(
"tenants",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <IntGraphType> > {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "name"
}
),
resolve: context =>
{
context.GetUserContext().EnsureIsInRole(RoleNames.HostAdministrator);
return(db.Tenants
.HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) =>
query.Where(x => arg.Contains(x.Id)))
.HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg))));
}
);
Field <UserType>(
"user",
arguments: new QueryArguments(new QueryArgument <StringGraphType> {
Name = "id"
}),
resolve: context => db.Users
.Where(x => x.Id == context.GetArgument <string>("id", null))
.Select(x => new UserDto
{
Id = x.Id,
FirstName = x.FirstName,
LastName = x.LastName,
UserName = x.UserName,
Email = x.Email,
IsActive = x.IsActive,
Roles = x.UserRoles.Select(r => r.Role.Name).ToArray()
})
.FirstOrDefault()
);
Field <ListGraphType <UserType> >(
"users",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <StringGraphType> > {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "firstname"
},
new QueryArgument <StringGraphType> {
Name = "lastname"
},
new QueryArgument <StringGraphType> {
Name = "username"
},
new QueryArgument <StringGraphType> {
Name = "email"
},
new QueryArgument <BooleanGraphType> {
Name = "isactive"
}
),
resolve: context => db.Users
.HandleQueryArgument(new ArgumentGetter <List <string> >("id", context), (arg, query) =>
query.Where(x => arg.Contains(x.Id)))
.HandleQueryArgument(new ArgumentGetter <string>("firstname", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.FirstName.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <string>("lastname", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.LastName.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <string>("username", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.UserName.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <string>("email", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Email.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <bool>("isactive", context), (arg, query) =>
query.Where(x => x.IsActive == arg))
.Select(x => new UserDto
{
Id = x.Id,
FirstName = x.FirstName,
LastName = x.LastName,
UserName = x.UserName,
Email = x.Email,
IsActive = x.IsActive,
Roles = x.UserRoles.Select(r => r.Role.Name).ToArray()
})
);
Field <ListGraphType <RoleType> >(
"roles",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <StringGraphType> > {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "name"
},
new QueryArgument <StringGraphType> {
Name = "isstatic"
}
),
resolve: context => db.Roles
.HandleQueryArgument(new ArgumentGetter <List <string> >("id", context), (arg, query) =>
query.Where(x => arg.Contains(x.Id)))
.HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <bool>("isstatic", context), (arg, query) =>
query.Where(x => x.IsStatic == arg))
);
Field <ProjectType>(
"project",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context => db.Projects.FindAsync(context.GetArgument <int>("id"))
);
Field <ListGraphType <ProjectType> >(
"projects",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <IntGraphType> > {
Name = "id"
},
new QueryArgument <StringGraphType> {
Name = "name"
}
),
resolve: context => db.Projects
.HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) =>
query.Where(x => arg.Contains(x.Id)))
.HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg)))
);
Field <TaskType>(
"task",
arguments: new QueryArguments(new QueryArgument <IntGraphType> {
Name = "id"
}),
resolve: context => db.Tasks.FindAsync(context.GetArgument <int>("id"))
);
Field <ListGraphType <TaskType> >(
"tasks",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <IntGraphType> > {
Name = "id"
},
new QueryArgument <IntGraphType> {
Name = "projectid"
},
new QueryArgument <StringGraphType> {
Name = "name"
},
new QueryArgument <BooleanGraphType> {
Name = "iscompleted"
},
new QueryArgument <DateGraphType> {
Name = "duedate"
},
new QueryArgument <DateGraphType> {
Name = "completiondate"
}
),
resolve: context => db.Tasks
.HandleQueryArgument(new ArgumentGetter <List <int?> >("id", context), (arg, query) =>
query.Where(x => arg.Contains(x.Id)))
.HandleQueryArgument(new ArgumentGetter <int>("projectid", context), (arg, query) =>
query.Where(x => x.ProjectId == arg))
.HandleQueryArgument(new ArgumentGetter <string>("name", context), (arg, query) =>
string.IsNullOrEmpty(arg) ? query : query.Where(x => x.Name.Contains(arg)))
.HandleQueryArgument(new ArgumentGetter <bool>("iscompleted", context), (arg, query) =>
query.Where(x => x.Completed == arg))
.HandleQueryArgument(new ArgumentGetter <DateTime>("duedate", context), (arg, query) =>
query.Where(x => x.DueDate >= arg.Date && x.DueDate < arg.Date.AddDays(1)))
.HandleQueryArgument(new ArgumentGetter <DateTime>("completiondate", context), (arg, query) =>
query.Where(x => x.CompletionDate >= arg.Date && x.CompletionDate < arg.Date.AddDays(1)))
);
}
