public void SetUp()
{
_value = new DateTime(2001, 01, 01);
_includeNull = true;
_column = new ColumnBuilder().Build();
_filter = new DateTimeFilter(_column, DateTime.MinValue, DateTime.MaxValue, _includeNull);
}
public async Task <IEnumerable <NoteModel> > GetNotes(int studentId)
{
const string sql = @"
SELECT n.Id AS StudentId, u.Id AS Id, u.FirstName AS CreatedByFirstName,
u.LastName AS CreatedByLastName, [EntryDate], [Note],
u.Id AS CreatedById
FROM [dbo].[StudentNotes] n
INNER JOIN [dbo].[Users] u ON
[CreatedBy] = u.[Id]
WHERE n.StudentId = @StudentId
ORDER BY [EntryDate] DESC";
List <NoteModel> notes = new List <NoteModel>();
try
{
notes = (await UnitOfWork.Context().QueryAsync <NoteModel>(sql, new { StudentId = studentId })).ToList();
notes.ForEach(x => x.EntryDate = DateTimeFilter.UtcToLocal(x.EntryDate));
}
catch (Exception e)
{
e.Data["SQL"] = e;
ErrorStore.LogException(e, HttpContext.Current);
}
return(notes);
}
public async Task <IEnumerable <PromoViewModel> > GetPromos()
{
List <PromoViewModel> promos = new List <PromoViewModel>();
const string sql = @"
SELECT p.Id AS Id,
[Description],
p.Created,
[PublicToken],
p.Active,
u.FirstName AS CreatedByFirstName,
u.LastName AS CreatedByLastName,
(SELECT COUNT(*) FROM [StudentPromoLog] WHERE [PromoId] = p.Id) AS TotalStudents
FROM [dbo].[UserPromo] p
INNER JOIN [dbo].[Users] u ON
[CreatedBy] = u.id
ORDER BY [Description]";
try
{
promos = (await UnitOfWork.Context().QueryAsync <PromoViewModel>(sql)).ToList();
promos.ForEach(x => x.Created = DateTimeFilter.UtcToLocal(x.Created));
}
catch (Exception e)
{
e.Data["SQL"] = sql;
ErrorStore.LogException(e, HttpContext.Current);
}
return(promos);
}
public override int GetHashCode()
{
int hashCode = -566134060;
if (StateFilter != null)
{
hashCode += StateFilter.GetHashCode();
}
if (DateTimeFilter != null)
{
hashCode += DateTimeFilter.GetHashCode();
}
if (FulfillmentFilter != null)
{
hashCode += FulfillmentFilter.GetHashCode();
}
if (SourceFilter != null)
{
hashCode += SourceFilter.GetHashCode();
}
if (CustomerFilter != null)
{
hashCode += CustomerFilter.GetHashCode();
}
return(hashCode);
}
public override int GetHashCode()
{
int hashCode = 1266972041;
if (LoyaltyAccountFilter != null)
{
hashCode += LoyaltyAccountFilter.GetHashCode();
}
if (TypeFilter != null)
{
hashCode += TypeFilter.GetHashCode();
}
if (DateTimeFilter != null)
{
hashCode += DateTimeFilter.GetHashCode();
}
if (LocationFilter != null)
{
hashCode += LocationFilter.GetHashCode();
}
if (OrderFilter != null)
{
hashCode += OrderFilter.GetHashCode();
}
return(hashCode);
}
public UserFilter(int?id = null, StringFilter name = null, DateTimeFilter created = null, CredentialFilter credential = null)
{
Id = id;
Name = name;
Created = created;
Credential = credential;
}
private IEnumerable <ActivityLogModel> ProcessRows(IEnumerable <dynamic> rows)
{
ICollection <ActivityLogModel> logs = new List <ActivityLogModel>();
foreach (IDictionary <string, object> row in rows)
{
logs.Add(new ActivityLogModel()
{
Id = (int)row["Id"],
Created = DateTimeFilter.UtcToLocal((DateTime)row["Created"]),
CreatedBy = (int)row["CreatedBy"],
Title = row["Title"] as string,
Title2 = row["Title2"] as string,
Title3 = row["Title3"] as string,
Location = row["Location"] as string,
StartDate = DateTimeFilter.UtcToLocal((DateTime)row["StartDate"]),
EndDate = DateTimeFilter.UtcToLocal((DateTime)row["EndDate"]),
Organizers = row["Organizers"] as string,
OnCampus = row["OnCampus"] as bool?,
WebSite = row["WebSite"] as string,
Notes = row["Notes"] as string
});
}
return(logs);
}
public void when_requesting_at_datetime_returns_correct_sql_string()
{
var datetime = new DateTime(2018, 04, 16, 13, 24, 32);
var filter = new DateTimeFilter("timestamp", datetime, DateTimeFilterMode.At);
var result = filter.GetMySqlString();
Assert.That(result, Is.EqualTo("timestamp = '20180416 13:24:32'"));
}
public ProductFilter(IntegerFilter id = null, CategoryFilter category = null, StringFilter name = null, DecimalFilter price = null, DateTimeFilter created = null)
{
this.Id = id;
this.Category = category;
this.Name = name;
this.Price = price;
this.Created = created;
}
public void TestCreateShouldCreateDateRangeFilter()
{
var filter = new DateTimeFilter(null, DateTime.MinValue, DateTime.MaxValue, true);
var result = _factory.Create(filter);
Assert.That(result, Is.TypeOf <DateRangeFilterViewModel>());
Assert.That(result.Filter, Is.EqualTo(filter));
}
/// <summary>
/// Do date time search.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="items"></param>
/// <param name="property"></param>
/// <param name="filter"></param>
/// <returns></returns>
public static IQueryable <T> WithDateTimeSearch <T>(this IQueryable <T> items,
Expression <Func <T, DateTime?> > property,
DateTimeFilter filter)
{
if (filter == null || property == null)
{
return(items);
}
var memberExpression = property.Body as MemberExpression;
if (!(memberExpression?.Member is PropertyInfo))
{
throw new ArgumentException("Property expected", nameof(property));
}
// Value is invalid. No filter is applied.
if (filter.Value == null)
{
return(items);
}
var left = property.Body;
Expression right = Expression.Constant(filter.Value, typeof(DateTime?));
BinaryExpression expression = null;
switch (filter.Operator)
{
case DateTimeComparisonOperators.Equal:
expression = Expression.Equal(left, right);
break;
case DateTimeComparisonOperators.SmallerThan:
expression = Expression.LessThan(left, right);
break;
case DateTimeComparisonOperators.SmallerThanEqualTo:
expression = Expression.LessThanOrEqual(left, right);
break;
case DateTimeComparisonOperators.GreaterThanEqualTo:
expression = Expression.GreaterThanOrEqual(left, right);
break;
case DateTimeComparisonOperators.GreaterThan:
expression = Expression.GreaterThan(left, right);
break;
default:
throw new ArgumentException("Not supported operator", nameof(filter.Operator));
}
var lambda =
Expression.Lambda <Func <T, bool> >(expression, property.Parameters.Single());
return(items.Where(lambda));
}
public void TestCreatePredicateShouldReturnNullableBooleanPredicate()
{
var column = new ColumnBuilder().WithNulls().Build();
_filter = new DateTimeFilter(column, DateTime.MinValue, DateTime.MaxValue, true);
var result = _filter.CreatePredicate();
Assert.That(result, Is.Not.Null);
}
public PropertyFilter(int?id = null, ObjectFilter @object = null, MemberFilter member = null, IntegerFilter integerValue = null, DecimalFilter decimalValue = null, LocalizationFilter stringValue = null, DateTimeFilter dateTimeValue = null)
{
Id = id;
Object = @object;
Member = member;
IntegerValue = integerValue;
DecimalValue = decimalValue;
StringValue = stringValue;
DateTimeValue = dateTimeValue;
}
public void TestSerializeShouldSerializeDateTimeFilters()
{
var filter = new DateTimeFilter(_column, DateTime.MinValue, DateTime.MaxValue, true);
var xFilter = new XElement("datetime-filter");
_mockDateTimeSerializer.Setup(p => p.Serialize(filter)).Returns(xFilter);
var result = _serializer.Serialize(filter);
Assert.That(result, Is.EqualTo(xFilter));
}
public Rule IsDateTime(string errorMsg = "非法日期")
{
var filter = new DateTimeFilter()
{
ErrorMsg = errorMsg
};
Filters.Add(filter);
return(this);
}
public DateTimeFilterTests()
{
items = new[]
{
new GridModel { Date = new DateTime(2013, 01, 01), NDate = null },
new GridModel { Date = new DateTime(2014, 01, 01), NDate = new DateTime(2014, 01, 01) },
new GridModel { Date = new DateTime(2015, 01, 01), NDate = new DateTime(2015, 01, 01) }
}.AsQueryable();
nDateExpression = (model) => model.NDate;
dateExpression = (model) => model.Date;
filter = new DateTimeFilter();
}
public void SetUp()
{
_value = new DateTime(2001, 01, 01);
_column = new ColumnBuilder()
.WithValue(DateTime.MinValue)
.WithValue(DateTime.MaxValue)
.Build();
_filter = new DateTimeFilter(_column, DateTime.MinValue, DateTime.MaxValue, false);
_mockCommandBus = new Mock <ICommandBus>();
_viewModel = new DateRangeFilterViewModel(
_mockCommandBus.Object, _filter);
}
public OrderFilter(int?id = null, OrderStateFilter orderState = null, DeliveryMethodFilter deliveryMethod = null, PaymentMethodFilter paymentMethod = null, StringFilter customerFirstName = null, StringFilter customerLastName = null, StringFilter customerPhone = null, StringFilter customerEmail = null, StringFilter customerAddress = null, StringFilter note = null, DateTimeFilter created = null)
{
Id = id;
OrderState = orderState;
DeliveryMethod = deliveryMethod;
PaymentMethod = paymentMethod;
CustomerFirstName = customerFirstName;
CustomerLastName = customerLastName;
CustomerPhone = customerPhone;
CustomerEmail = customerEmail;
CustomerAddress = customerAddress;
Note = note;
Created = created;
}
public XElement Serialize(DateTimeFilter filter)
{
var xFilter = new XElement(FilterTag);
AddColumn(xFilter, ColumnIdTag, filter.Column);
AddProperty(xFilter, LowerValueTag, filter.LowerValue);
AddProperty(xFilter, UpperValueTag, filter.UpperValue);
AddProperty(xFilter, IncludeNullTag, filter.IncludeNull);
return(xFilter);
}
private IEnumerable <StudyAbroadViewModel> ProcessRecords(IEnumerable <dynamic> rows)
{
ICollection <StudyAbroadViewModel> studyAbroad = new List <StudyAbroadViewModel>();
foreach (IDictionary <string, object> row in rows)
{
StudyAbroadViewModel study = new StudyAbroadViewModel()
{
Id = (int)row["Id"],
StudentId = (int)row["StudentId"],
Semester = (int)row["Semester"],
Year = (int)row["Year"],
CreditBearing = (bool)row["CreditBearing"],
Internship = (bool)row["Internship"],
CountryId = (int)row["CountryId"],
ProgramId = (int)row["ProgramId"],
City = row["City"] as string
};
if (row.ContainsKey("StartDate") && row["StartDate"] != null)
{
study.StartDate = DateTimeFilter.UtcToLocal((DateTime)row["StartDate"]);
}
if (row.ContainsKey("EndDate") && row["EndDate"] != null)
{
study.EndDate = DateTimeFilter.UtcToLocal((DateTime)row["EndDate"]);
}
if (row.ContainsKey("ProgramTypeIds") && row["ProgramTypeIds"] != null)
{
study.ProgramTypes = Array.ConvertAll(((string)row["ProgramTypeIds"]).Split(','), int.Parse);
}
study.Student = new StudentModel()
{
FirstName = (string)row["FirstName"],
MiddleName = row["MiddleName"] as string,
LastName = (string)row["LastName"]
};
studyAbroad.Add(study);
}
return(studyAbroad);
}
public void SetUp()
{
_column = new ColumnBuilder().WithId(1).Build();
_columns = new List <Column> {
_column
};
_filter = new DateTimeFilter(_column, DateTime.MinValue, DateTime.MaxValue, true);
_xFilter = new XElement("datetime-filter",
new XElement("column-id", _column.Id),
new XElement("lower-value", DateTime.MinValue),
new XElement("upper-value", DateTime.MaxValue),
new XElement("include-null", true));
_serializer = new DateTimeFilterSerializer(
new PropertySerializer(null));
}
public async Task <IEnumerable <UserModel> > GetUsers(string username = null)
{
List <UserModel> users = new List <UserModel>();
string sql = @"
SELECT [Id], [FirstName], [LastName],
[Created], [LastLogin], [Email],
[Admin] AS IsAdmin, [Active] AS IsActive, [Login],
[Password]
FROM [dbo].[Users] ";
if (username != null)
{
sql += "WHERE [Login] = @Username";
}
try
{
if (username != null)
{
users = (await UnitOfWork.Context().QueryAsync <UserModel>(sql, new { Username = username })).ToList();
}
else
{
users = (await UnitOfWork.Context().QueryAsync <UserModel>(sql)).ToList();
}
users.ForEach(x =>
{
x.Created = DateTimeFilter.UtcToLocal(x.Created);
x.LastLogin = DateTimeFilter.UtcToLocal(x.LastLogin);
});
// TODO: LastLogin may need to be changed to a nullable type.
}
catch (Exception e)
{
e.Data["SQL"] = sql;
ErrorStore.LogException(e, HttpContext.Current);
throw e;
}
return(users);
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj == this)
{
return(true);
}
return(obj is LoyaltyEventFilter other &&
((LoyaltyAccountFilter == null && other.LoyaltyAccountFilter == null) || (LoyaltyAccountFilter?.Equals(other.LoyaltyAccountFilter) == true)) &&
((TypeFilter == null && other.TypeFilter == null) || (TypeFilter?.Equals(other.TypeFilter) == true)) &&
((DateTimeFilter == null && other.DateTimeFilter == null) || (DateTimeFilter?.Equals(other.DateTimeFilter) == true)) &&
((LocationFilter == null && other.LocationFilter == null) || (LocationFilter?.Equals(other.LocationFilter) == true)) &&
((OrderFilter == null && other.OrderFilter == null) || (OrderFilter?.Equals(other.OrderFilter) == true)));
}
public override bool Equals(object obj)
{
if (obj == null)
{
return(false);
}
if (obj == this)
{
return(true);
}
return(obj is SearchOrdersFilter other &&
((StateFilter == null && other.StateFilter == null) || (StateFilter?.Equals(other.StateFilter) == true)) &&
((DateTimeFilter == null && other.DateTimeFilter == null) || (DateTimeFilter?.Equals(other.DateTimeFilter) == true)) &&
((FulfillmentFilter == null && other.FulfillmentFilter == null) || (FulfillmentFilter?.Equals(other.FulfillmentFilter) == true)) &&
((SourceFilter == null && other.SourceFilter == null) || (SourceFilter?.Equals(other.SourceFilter) == true)) &&
((CustomerFilter == null && other.CustomerFilter == null) || (CustomerFilter?.Equals(other.CustomerFilter) == true)));
}
public DateTimeFilterTests()
{
items = new[]
{
new GridModel {
Date = new DateTime(2013, 01, 01), NDate = null
},
new GridModel {
Date = new DateTime(2014, 01, 01), NDate = new DateTime(2014, 01, 01)
},
new GridModel {
Date = new DateTime(2015, 01, 01), NDate = new DateTime(2015, 01, 01)
}
}.AsQueryable();
nDateExpression = (model) => model.NDate;
dateExpression = (model) => model.Date;
filter = new DateTimeFilter();
}
public static ISqlFilter SqlDateTimeFilter(UserFilterProviderColumn columnFilter)
{
string column = "timestamp";
DateTime?filterValue = null;
while (!filterValue.HasValue)
{
Console.WriteLine(" Inserisci la data in formato standard:");
var str = Console.ReadLine();
if (DateTime.TryParse(str, out var value))
{
filterValue = value;
}
}
DateTimeFilterMode?mode = null; //non è più un enum ma un oggetto che ha un enum ma che può essere nullo
while (mode == null)
{
Console.WriteLine("1. prima");
Console.WriteLine("2. ora esatta");
Console.WriteLine("3. dopo");
var key = Console.ReadKey();
switch (key.KeyChar)
{
case '1':
mode = DateTimeFilterMode.Before;
break;
case '2':
mode = DateTimeFilterMode.At;
break;
case '3':
mode = DateTimeFilterMode.After;
break;
}
}
var filter = new DateTimeFilter(column, filterValue.Value, mode.Value);
return(filter);
}
public void SetUp()
{
models = new[]
{
new GridModel {
Date = new DateTime(2013, 01, 01), NDate = null
},
new GridModel {
Date = new DateTime(2014, 01, 01), NDate = new DateTime(2014, 01, 01)
},
new GridModel {
Date = new DateTime(2015, 01, 01), NDate = new DateTime(2015, 01, 01)
}
}.AsQueryable();
Expression <Func <GridModel, DateTime> > expression = (model) => model.Date;
filter = new DateTimeFilter <GridModel>();
filter.FilteredExpression = expression;
}
public void InvalidDateTimeFilterTests(string submitValue, string filterFieldValue, string operatorType)
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = submitValue
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.DateType,
FieldValue = filterFieldValue,
OperatorProperty = operatorType
};
Assert.Throws <ValidationException>(() => DateTimeFilter.MatchesFilter(expectedValue, filterValue));
}
public void ValidDateTimeFilterTests(string submitValue, string filterFieldValue, string operatorType, bool expectedResult)
{
var expectedValue = new SubmissionMetaDataModel()
{
DisplayName = nameof(String),
Name = nameof(String),
Type = nameof(String),
Value = submitValue
};
var filterValue = new SearchTermModel()
{
FieldName = FilterConstants.FilterFieldTypes.StringType,
FieldType = FilterConstants.FilterFieldTypes.DateType,
FieldValue = filterFieldValue,
OperatorProperty = operatorType
};
var result = DateTimeFilter.MatchesFilter(expectedValue, filterValue);
Assert.Equal(expectedResult, result);
}
public async Task <IEnumerable <DocumentViewModel> > GetActivityLogDocumentsList(int id)
{
const string sql = @"
SELECT [Id], [Title], [Size], [MimeType], [Created]
FROM [dbo].[Documents]
WHERE [ActivityLogId] = @Id AND
[Deleted] IS NULL";
try
{
List <DocumentViewModel> documents = (await UnitOfWork.Context().QueryAsync <DocumentViewModel>(sql,
new { Id = id })).ToList();
documents.ForEach(x => x.Created = DateTimeFilter.UtcToLocal(x.Created));
return(documents);
}
catch (Exception e)
{
e.Data["SQL"] = sql;
ErrorStore.LogException(e, HttpContext.Current);
}
return(Enumerable.Empty <DocumentViewModel>());
}
public async Task <IEnumerable <EventLogViewModel> > GetEvents(int numEvents)
{
ICollection <EventLogViewModel> events = new List <EventLogViewModel>();
const string sql = @"
SELECT TOP(@NumEvents) e.Id, e.Date, e.ModifiedBy,
e.StudentId, e.UserId, e.Type,
e.Action, u.FirstName, u.LastName,
s.FirstName AS StudentFirstName,
s.LastName AS StudentLastName,
us.FirstName AS UserFirstName,
us.LastName AS UserLastName,
IPAddress
FROM [dbo].[EventLog] e
INNER JOIN [dbo].[Users] u ON
[ModifiedBy] = u.id
LEFT OUTER JOIN [dbo].[Students] s ON
e.StudentId = s.id
LEFT OUTER JOIN [dbo].[Users] us ON
e.UserId = us.id
ORDER BY [Date] DESC";
try
{
IEnumerable <dynamic> rows = await UnitOfWork.Context().QueryAsync <dynamic>(sql,
new { NumEvents = numEvents });
foreach (IDictionary <string, object> row in rows)
{
StudentModel student = null;
// TODO: Check for key or does key always exist and value is null?
if (row.ContainsKey("StudentId") && row["StudentId"] != null)
{
student = new StudentModel()
{
Id = (int)row["StudentId"],
FirstName = (string)row["StudentFirstName"],
LastName = (string)row["StudentLastName"]
};
}
EventLogViewModel eventLog = new EventLogViewModel()
{
Id = (int)row["Id"],
EventDate = DateTimeFilter.UtcToLocal((DateTime)row["Date"]),
ModifiedById = (int)row["ModifiedBy"],
ModifiedByFirstName = (string)row["FirstName"],
ModifiedByLastName = (string)row["LastName"],
Student = student,
Type = (int)row["Type"],
Action = (string)row["Action"]
};
if (row.ContainsKey("UserId") && row["UserId"] != null)
{
eventLog.UserId = (int)row["UserId"];
eventLog.UserFirstName = (string)row["UserFirstName"];
eventLog.UserLastName = (string)row["UserLastName"];
}
eventLog.RelativeDate = DateTimeFilter.CalculateRelativeDate(eventLog.EventDate.ToUniversalTime());
events.Add(eventLog);
}
}
catch (Exception e)
{
e.Data["SQL"] = sql;
ErrorStore.LogException(e, HttpContext.Current);
throw e;
}
return(events);
}
