public async Task WhenGet_Borough_Name_Returns_RestaurantList()
{
var collection = _database.GetCollection<BsonDocument>("restaurants");
var builder = new FilterDefinitionBuilder<BsonDocument>();
var filter = builder.Eq("borough", "Bronx");
var result = await collection.Find(filter).ToListAsync();
Assert.AreEqual(2338, result.Count());
}
public async Task OneStepUpdate(int amount = 1000)
{
var filterDefinitionBuilder = new FilterDefinitionBuilder<Student>();
var updateDefinitionBuilder = new UpdateDefinitionBuilder<Student>();
for (var i = 0; i < amount; i++)
{
await studentsCollection.UpdateOneAsync(
filterDefinitionBuilder.Eq<string>((Student x) => x.Id, $"Students/{i}"),
updateDefinitionBuilder.Inc<int>((Student x) => x.Age, 1));
}
}
public async Task WhenGet_Cuisine_Or_ZipCode_Returns_RestaurantList()
{
var collection = _database.GetCollection<BsonDocument>("restaurants");
var builder = new FilterDefinitionBuilder<BsonDocument>();
var filter = builder.Eq("cuisine", "Bakery") | builder.Eq("address.zipcode", "10462");
var result = await collection.Find(filter).ToListAsync();
Assert.AreEqual(834, result.Count());
}
public IEnumerable <BaseNode> GetBreadcrumbs(Guid itemId)
{
var filter = _filterBase & _builder.Eq("_id", itemId);
var parents = _nodes.Aggregate().Match(filter)
.GraphLookup(_nodes, "ParentId", "_id", "$ParentId", "Parent")
.Unwind("Parent")
.ReplaceRoot <BaseNode>("$Parent")
.ToList();
if (parents.Count() > 0)
{
var result = new List <BaseNode>();
var it = parents.First(p => p.Type == "User");
do
{
result.Add(it);
it = parents.FirstOrDefault(p => p.ParentId == it.Id);
} while (it != null);
return(result);
}
else
{
return(parents);
}
}
public static FilterDefinition <MongoContentEntity> ToFilter(this Query query, Guid schemaId, Status[] status)
{
var filters = new List <FilterDefinition <MongoContentEntity> >
{
Filter.Eq(x => x.IndexedSchemaId, schemaId),
Filter.Ne(x => x.IsDeleted, true)
};
if (status != null)
{
filters.Add(Filter.In(x => x.Status, status));
}
var filter = query.BuildFilter <MongoContentEntity>();
if (filter.Filter != null)
{
if (filter.Last)
{
filters.Add(filter.Filter);
}
else
{
filters.Insert(0, filter.Filter);
}
}
return(Filter.And(filters));
}
public async Task <IReadOnlyList <IConfigurationEntry> > GetEntries(string component, ConfigurationPath pathPrefix, bool forPages = false, bool recursive = true)
{
var filterBuilder = new FilterDefinitionBuilder <MongoDbConfigurationDocument>();
if (string.IsNullOrWhiteSpace(component))
{
component = "root";
}
var filter = filterBuilder.Eq(a => a.Component, component);
if (!ConfigurationPath.IsNullOrEmpty(pathPrefix))
{
filter = recursive ? filterBuilder.Regex(a => a.Path, new Regex(pathPrefix.ToString(asPrefix: true))) : filterBuilder.Eq(a => a.Path, pathPrefix.ToString());
}
if (forPages)
{
filter = filter & filterBuilder.Eq(a => a.VisibleToPages, true);
}
var results = await settingsCollectionData.FindAsync(filter);
var records = await results.ToListAsync();
return(records.Select(doc => RebuildConfigurationEntry(doc)).ToList());
}
private BsonDocument GetBsonFilter(Platforms platform, string platformKey = null)
{
var builder = new FilterDefinitionBuilder <BsonDocument>();
var filter = builder.Eq("Platform", platform.ToString()) & builder.Eq("Key", platformKey);
return(filter.ToBsonDocument());
}
public async Task <Guid> DeleteItemAsync(Guid id)
{
var filter = filterBuilder.Eq(item => item.Id, id);
await itemCollection.DeleteOneAsync(filter);
return(id);
}
public void UserUpdateDoesNotWipeOutIgnoredFields()
{
if (!BsonClassMap.IsClassMapRegistered(typeof(Profile)))
{
BsonClassMap.RegisterClassMap <Profile>();
}
NameValueCollection config = new NameValueCollection();
config.Add("connectionStringName", _connStrName);
config.Add("applicationName", _applicationName);
config.Add("requiresUniqueEmail", "false");
config.Add("passwordFormat", "Clear");
config.Add("enablePasswordRetrieval", "true");
provider.Initialize(null, config);
MembershipCreateStatus status;
Membership.CreateUser("foo", "bar!bar", "*****@*****.**", "question", "answer", true, out status);
// ensure user created correctly
MembershipUser user = Membership.GetUser("foo");
Assert.AreEqual("question", user.PasswordQuestion);
// save Profile over User
var mongoProvider = (MembershipProvider)Membership.Provider;
var profiles = mongoProvider.Database.GetCollection <Profile>(mongoProvider.CollectionName);
var profile = profiles.AsQueryable().First(u => u.LowercaseUsername == "foo");
profile.FirstName = "Neo";
FilterDefinitionBuilder <Profile> fb = new FilterDefinitionBuilder <Profile>();
profiles.ReplaceOne(fb.Eq(p => p.Id, profile.Id), profile);
// ensure profile saved correctly
profile = profiles.Find(fb.Eq(p => p.LowercaseUsername, "foo")).First();
Assert.AreEqual("Neo", profile.FirstName);
Assert.AreEqual("question", profile.PasswordQuestion);
// validate User
var valid = Membership.ValidateUser("foo", "bar!bar");
Assert.AreEqual(true, valid);
// ensure profile fields still in database
profile = profiles.Find(fb.Eq(p => p.LowercaseUsername, "foo")).First();
Assert.AreEqual("Neo", profile.FirstName);
Assert.AreEqual("question", profile.PasswordQuestion);
// update User
user.ChangePassword("bar!bar", "foo!foo");
// ensure profile fields still in database
profile = profiles.Find(fb.Eq(p => p.LowercaseUsername, "foo")).First();
Assert.AreEqual("Neo", profile.FirstName);
Assert.AreEqual("question", profile.PasswordQuestion);
}
public void addOrUpdate(Person p)
{
//var filter = new BsonDocument();
//filter.Add("firstname", p.FirstName);
//filter.Add("lastname", p.LastName);
//var newperson = new bsondocument();
//newperson.add("firstname", p.firstname);
//newperson.add("lastname", p.lastname);
//if (p.phonenumber != null)
//{
// newperson.add("phonenumber", p.phonenumber);
//}
var builder = new FilterDefinitionBuilder <Person>();
var filter = builder.Eq(x => x.FirstName, p.FirstName) & builder.Eq(x => x.LastName, p.LastName);
if (collection.Find <Person>(filter).FirstOrDefault() != null)
{
collection.FindOneAndUpdate <Person>(
//Builders<Person>.Filter.Eq("FirstName", p.FirstName),
filter,
Builders <Person> .Update.Set("PhoneNumber", p.PhoneNumber)
);
}
else
{
collection.InsertOne(p);
}
collection = db.GetCollection <Person>("People");
}
private static void CreateOrderTypeFilter(HeatDataResultRequestDto input, FilterDefinitionBuilder <BsonDocument> builderFilter, List <FilterDefinition <BsonDocument> > filterDefinitions)
{
List <FilterDefinition <BsonDocument> > orderTypeFilterDefinitions = new List <FilterDefinition <BsonDocument> >();
input.OrderType.ForEach(x =>
{
switch (x)
{
case InputOrderType.TotalOrder:
default:
break;
case InputOrderType.ImmediateOrder:
orderTypeFilterDefinitions.Add(builderFilter.Eq("orderType", OrderType.Immediate));
break;
case InputOrderType.BookingOrder:
orderTypeFilterDefinitions.Add(builderFilter.And(builderFilter.Eq("orderType", OrderType.Booking), builderFilter.Eq("orderType2", BookingOrderType.Normal)));
break;
case InputOrderType.PickupOrder:
orderTypeFilterDefinitions.Add(builderFilter.Eq("orderType2", BookingOrderType.Pickup));
break;
case InputOrderType.DropoffOrder:
orderTypeFilterDefinitions.Add(builderFilter.Eq("orderType2", BookingOrderType.Dropoff));
break;
}
});
if (orderTypeFilterDefinitions.Count > 0)
{
filterDefinitions.Add(builderFilter.Or(orderTypeFilterDefinitions));
}
}
public async System.Threading.Tasks.Task <bool> IsUnique(string login, long?id = null, long?teamId = null, string?teamName = null)
{
var filterBuilder = new FilterDefinitionBuilder <User>();
var filter = filterBuilder.Empty;
if (!String.IsNullOrWhiteSpace(login))
{
filter = filter & filterBuilder.Eq("login", login);
}
if (id != null)
{
filter = filter & filterBuilder.Not(filterBuilder.Eq("id", id.Value));
}
if (teamId != null)
{
filter = filter & filterBuilder.Eq("teamId", teamId.Value);
}
if (!String.IsNullOrWhiteSpace(teamName))
{
filter = filter & filterBuilder.Eq("teamName", teamName);
}
var foundUsersList = await Users.Find(filter).ToListAsync();
return(foundUsersList.Count == 0);
}
/// <summary>
/// Find
/// </summary>
/// <param name="requestFilter"></param>
/// <returns></returns>
public async Task <IEnumerable <ArticleContent> > Find(ConditionFilter requestFilter)
{
var skip = 0;
var take = 10;
var filterDefinition = new FilterDefinitionBuilder <ArticleContent>();
var filter = filterDefinition.Eq(x => x.ContentType, requestFilter.ContentType);
if (!requestFilter.Brand.IsNullOrEmpty())
{
filter = filter & filterDefinition.Where(x => x.Brand.Contains(requestFilter.Brand));
}
if (!requestFilter.Category.IsNullOrEmpty())
{
filter = filter & filterDefinition.Eq(x => x.Category.Parent, requestFilter.Category);
}
if (!requestFilter.Language.IsNullOrEmpty())
{
filter = filter & filterDefinition.Eq(x => x.Market, requestFilter.Language);
}
skip = take * (requestFilter.Page - 1);
return(await _repository.FindAsync <ArticleContent>(filter, orderBy : x => x.GetOrderFor(requestFilter.Ordering), skip : skip, take : take));
}
/// <summary>
/// Attempts, for the specified amount of time, to acquire an exclusive lock
/// </summary>
/// <param name="lifetime">A TimeSpan representing the amount of time after which the lock is automatically released</param>
/// <param name="timeout">A TimeSpan representing the amount of time to wait for the lock</param>
/// <returns></returns>
public async Task <IAcquire> AcquireAsync(TimeSpan lifetime, TimeSpan timeout)
{
if (lifetime < TimeSpan.Zero || lifetime > TimeSpan.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(lifetime), "The value of lifetime in milliseconds is negative or is greater than MaxValue");
}
if (timeout < TimeSpan.Zero || timeout > TimeSpan.MaxValue)
{
throw new ArgumentOutOfRangeException(nameof(timeout), "The value of timeout in milliseconds is negative or is greater than MaxValue");
}
Guid acquireId = Guid.NewGuid();
while (await TryUpdate(lifetime, acquireId) == false)
{
using (IAsyncCursor <LockAcquire <T> > cursor = await _locks.FindAsync(_builder.Eq(x => x.Id, _id)))
{
LockAcquire <T> acquire = await cursor.FirstOrDefaultAsync();
if (acquire != null && await WaitSignal(acquire.AcquireId, timeout) == false)
{
return(await TryUpdate(lifetime, acquireId) == false ? new AcquireResult() : new AcquireResult(acquireId));
}
}
}
return(new AcquireResult(acquireId));
}
public static FilterDefinition <MongoAssetEntity> BuildFilter(this ClrQuery query, Guid appId)
{
var filters = new List <FilterDefinition <MongoAssetEntity> >
{
Filter.Eq(x => x.IndexedAppId, appId),
Filter.Eq(x => x.IsDeleted, false)
};
var filter = query.BuildFilter <MongoAssetEntity>(false);
if (filter.Filter != null)
{
if (filter.Last)
{
filters.Add(filter.Filter);
}
else
{
filters.Insert(0, filter.Filter);
}
}
if (filters.Count > 1)
{
return(Filter.And(filters));
}
else if (filters.Count == 1)
{
return(filters[0]);
}
else
{
return(new BsonDocument());
}
}
private List <FilterDefinition <Flight> > CreateClauses(SearchCriteriaModel criteriaModel, FilterDefinitionBuilder <Flight> filterBuilder)
{
var clauses = new List <FilterDefinition <Flight> >();
if (criteriaModel.FromDate != null)
{
var fromDate = DateTime.SpecifyKind(DateTime.Parse(criteriaModel.FromDate), DateTimeKind.Utc);
var clause = filterBuilder.Gte(f => f.FlightDate, fromDate);
clauses.Add(clause);
}
if (criteriaModel.ToDate != null)
{
var toDate = DateTime.SpecifyKind(DateTime.Parse(criteriaModel.ToDate), DateTimeKind.Utc);
var clause = filterBuilder.Lte(f => f.FlightDate, toDate);
clauses.Add(clause);
}
if (criteriaModel.AirlineId != null)
{
var clause = filterBuilder.Eq(f => f.AirlineId, criteriaModel.AirlineId.Value);
clauses.Add(clause);
}
if (criteriaModel.OriginId != null)
{
var clause = filterBuilder.Eq(f => f.OriginAirportId, criteriaModel.OriginId.Value);
clauses.Add(clause);
}
if (criteriaModel.DestinationId != null)
{
var clause = filterBuilder.Eq(f => f.DestinationAirportId, criteriaModel.DestinationId.Value);
clauses.Add(clause);
}
return(clauses);
}
public async virtual Task <PaymentReadModel> GetPaymentDetailsAsync(Guid aggregateId, Guid userId)
{
FilterDefinitionBuilder <PaymentReadModel> builder = Builders <PaymentReadModel> .Filter;
var filter = builder.Eq(p => p.Id, aggregateId) & builder.Eq(p => p.UserId, userId);
return(await _paymentsRead.Find(filter).FirstAsync());
}
async Task <bool> IPersist.ToggleMarkAllAsync(string q, PersistedMessageStatusOptions newMark, PersistedMessageStatusOptions oldMark, CancellationToken token)
{
if (this.serviceDown)
{
throw new ServiceEndpointDownException("Mongo Persist Service is Down");
}
IMongoCollection <PersistedMessage> collection = this.GetCollection();
try {
token.ThrowIfCancellationRequested();
FilterDefinitionBuilder <PersistedMessage> fBuilder = Builders <PersistedMessage> .Filter;
var qfilter = fBuilder.And(fBuilder.Eq(g => g.Status, oldMark), fBuilder.Eq(g => g.Queue, q));
var update = Builders <PersistedMessage> .Update.Set(g => g.Status, newMark);
await collection.UpdateManyAsync(qfilter, update, null, token);
return(true);
} catch (Exception e) {
this.serviceDown = true;
throw new ServiceEndpointDownException("Mongo Persist Service is Down", e);
}
}
public static FilterDefinition <NetstatDocument> GetNetstatForWorker(string worker)
{
// netstat-info.txt used by Windows and netstat-anp.txt used by Linux
var fileSubQuery = Query.Eq("file", "netstat-info.txt") | Query.Eq("file", "netstat-anp.txt");
return(Query.Eq("worker", worker) & fileSubQuery);
}
private async void PublishHits(object state)
{
var hasHit = _queue.TryTake(out var hit);
do
{
if (_stoppingCancellationToken.IsCancellationRequested)
{
return;
}
var filterBuilder = new FilterDefinitionBuilder <BsonDocument>();
var filter = filterBuilder.And(
filterBuilder.Eq("name", hit.Name),
filterBuilder.Eq("size", hit.Size)
);
var updateBuilder = new UpdateDefinitionBuilder <BsonDocument>();
var update = updateBuilder
.Inc("hits", 1)
.Set("last-hit", DateTime.UtcNow);
await _collection.UpdateOneAsync(
filter,
update,
new UpdateOptions { IsUpsert = true },
_stoppingCancellationToken.Token);
} while((hasHit = _queue.TryTake(out hit)));
}
public static FilterDefinition <MongoContentEntity> BuildQuery(ODataUriParser query, Guid schemaId, Schema schema, Status[] status)
{
var filters = new List <FilterDefinition <MongoContentEntity> >
{
Filter.Eq(x => x.SchemaId, schemaId),
Filter.Eq(x => x.IsLatest, true),
Filter.In(x => x.Status, status)
};
var filter = FilterBuilder.Build(query, schema);
if (filter != null)
{
filters.Add(filter);
}
if (filters.Count > 1)
{
return(Filter.And(filters));
}
else if (filters.Count == 1)
{
return(filters[0]);
}
else
{
return(new BsonDocument());
}
}
public IUser Get(string userId)
{
var search = _filter.Eq("UserId", userId);
var user = collection.Find(search).FirstOrDefault();
return(user);
}
public void And()
{
var fb = new FilterDefinitionBuilder <BasicDocument>();
Find(fb.And(fb.Eq(x => x.Id, _item.Id), fb.Eq(x => x.Name, _item.Name)))
.ShouldHaveOneResultMatching(_item);
}
public static FilterDefinition <MongoContentEntity> BuildQuery(ODataUriParser query, Guid schemaId, Status[] status, PropertyCalculator propertyCalculator)
{
var filters = new List <FilterDefinition <MongoContentEntity> >
{
Filter.Eq(x => x.SchemaId, schemaId),
Filter.In(x => x.Status, status),
Filter.Eq(x => x.IsDeleted, false)
};
var filter = query.BuildFilter <MongoContentEntity>(propertyCalculator);
if (filter.Filter != null)
{
if (filter.Last)
{
filters.Add(filter.Filter);
}
else
{
filters.Insert(0, filter.Filter);
}
}
if (filters.Count == 1)
{
return(filters[0]);
}
else
{
return(Filter.And(filters));
}
}
public async System.Threading.Tasks.Task <List <User> > GetUsers(
long?id,
DateTime?date,
string?teamName
)
{
var filterBuilder = new FilterDefinitionBuilder <User>();
var filter = filterBuilder.Empty;
if (id.HasValue)
{
filter = filter & filterBuilder.Eq("id", id.Value);
}
if (date.HasValue)
{
filter = filter & filterBuilder.Eq("date", date.ToString());
}
if (!String.IsNullOrWhiteSpace(teamName))
{
filter = filter & filterBuilder.Eq("teamName", teamName);
}
return(await Users.Find(filter).ToListAsync());
}
public static FilterDefinition <MongoAssetEntity> BuildQuery(ODataUriParser query, Guid appId)
{
var filters = new List <FilterDefinition <MongoAssetEntity> >
{
Filter.Eq(x => x.AppIdId, appId),
Filter.Eq(x => x.IsDeleted, false)
};
var filter = query.BuildFilter <MongoAssetEntity>(PropertyCalculator, false);
if (filter.Filter != null)
{
if (filter.Last)
{
filters.Add(filter.Filter);
}
else
{
filters.Insert(0, filter.Filter);
}
}
if (filters.Count > 1)
{
return(Filter.And(filters));
}
else if (filters.Count == 1)
{
return(filters[0]);
}
else
{
return(new BsonDocument());
}
}
private FilterDefinition <ToDoListEntity> ApplyWhereStatement(FilterDefinitionBuilder <ToDoListEntity> builder, ListQueryDataStructure queryDataStructure)
{
FilterDefinition <ToDoListEntity> filter = builder.Ne(x => x.Status, (int)ToDoListStatus.Archived);
if (queryDataStructure.Id.HasValue)
{
filter = filter & (builder.Eq(x => x.Id, queryDataStructure.Id.Value));
}
if (queryDataStructure.UserId.HasValue)
{
filter = filter & (builder.Eq(x => x.UserId, queryDataStructure.UserId.Value));
}
if (!string.IsNullOrWhiteSpace(queryDataStructure.Name))
{
filter = filter & (builder.Regex(x => x.Name, queryDataStructure.Name));
}
if (queryDataStructure.Statuses != null && queryDataStructure.Statuses.Any())
{
filter = filter & (builder.In(x => x.Status, queryDataStructure.Statuses));
}
return(filter);
}
public async IAsyncEnumerable <Bill> GetAsync(string personId, int?month)
{
FilterDefinitionBuilder <Bill> builder = Builders <Bill> .Filter;
FilterDefinition <Bill> filter = FilterDefinition <Bill> .Empty;
Bill bill;
if (!String.IsNullOrEmpty(personId))
{
filter &= builder.Eq(nameof(bill.PersonId), personId);
}
if (month.HasValue)
{
filter &= builder.Eq(nameof(bill.DueMonth), month);
}
using (IAsyncCursor <Bill> cursor = await _bills.FindAsync(filter))
{
while (await cursor.MoveNextAsync())
{
foreach (Bill currentBill in cursor.Current)
{
yield return(currentBill);
}
}
}
}
public async Task <bool> DeleteAsync(Guid id)
{
var filter = filterBuilder.Eq(item => item.Id, id);
var result = await itemsCollection.DeleteOneAsync(filter);
return(result.DeletedCount > 0);
}
public async Task <long> CountByPlayerIdAsync(int id)
{
FilterDefinitionBuilder <Game> filterBuilder = Builders <Game> .Filter;
FilterDefinition <Game> whiteEq = filterBuilder.Eq("white.userId", id);
FilterDefinition <Game> blackEq = filterBuilder.Eq("black.userId", id);
return(await gameCollection.CountAsync(filterBuilder.Or(whiteEq, blackEq)));
}
/// <summary>
/// 透過帳號密碼取得使用者資訊
/// </summary>
/// <param name="UID"></param>
/// <param name="UserPwd"></param>
/// <returns></returns>
public UserModel GetUser(string UID, string UserPwd)
{
FilterDefinitionBuilder <UserModel> filter = Builders <UserModel> .Filter;
FilterDefinition <UserModel> filters = filter.Eq("UID", UID) & filter.Eq("UserPwd", UserPwd);
return(mongoContext.QueryOne <UserModel>(filters));
}
public async Task DeleteExpenseAsync(Guid id)
{
//Finds the expense to replace
var filter = filterBuilder.Eq(expenseToDelete => expenseToDelete.Id, id);
//Deletes the expense we found
await expensesCollection.DeleteOneAsync(filter);
}
public long CountByPlayerId(int id)
{
FilterDefinitionBuilder <Game> filterBuilder = Builders <Game> .Filter;
FilterDefinition <Game> whiteEq = filterBuilder.Eq("white.userId", id);
FilterDefinition <Game> blackEq = filterBuilder.Eq("black.userId", id);
return(gameCollection.Count(filterBuilder.Or(whiteEq, blackEq)));
}
public async Task Update_Multiple_Restaurants()
{
var collection = _database.GetCollection<BsonDocument>("restaurants");
var builder = new FilterDefinitionBuilder<BsonDocument>();
var filter = builder.Eq("address.zipcode", "10462") & builder.Eq("cuisine", "Other");
var update = Builders<BsonDocument>.Update
.Set("cuisine", "Category TBD")
.CurrentDate("lastModified");
var result = await collection.UpdateOneAsync(filter, update);
Assert.AreEqual(1, result.MatchedCount);
if (result.IsModifiedCountAvailable)
{
Assert.AreEqual(1, result.ModifiedCount);
}
}
public async Task WhenGet_Grade_Letter_Returns_RestaurantList()
{
var collection = _database.GetCollection<BsonDocument>("restaurants");
var builder = new FilterDefinitionBuilder<BsonDocument>();
var filter = builder.Eq("grades.grade", "A");
var result = await collection.Find(filter).ToListAsync();
Assert.AreEqual(23440, result.Count());
}
public async Task OneStepDelete(int amount = 1000)
{
var filterDefinitionBuilder = new FilterDefinitionBuilder<Student>();
for (var i = 0; i < amount; i++)
{
var filter = filterDefinitionBuilder.Eq((Student x) => x.Id, $"Students/{i}");
await studentsCollection.DeleteOneAsync(filter);
}
}
public async Task TwoStepUpdate(int amount =1000)
{
var filterDefinitionBuilder = new FilterDefinitionBuilder<Student>();
for (var i = 0; i < amount; i++)
{
var foundStudent = await studentsCollection.Find<Student>((Student x) => x.Id == $"Students/{i}").FirstAsync();
foundStudent.Age++;
await studentsCollection.ReplaceOneAsync(filterDefinitionBuilder.Eq<string>((Student x) => foundStudent.Id, foundStudent.Id), foundStudent);
}
}
private List<FilterDefinition<Flight>> CreateClauses(SearchCriteriaModel criteriaModel, FilterDefinitionBuilder<Flight> filterBuilder)
{
var clauses = new List<FilterDefinition<Flight>>();
if (criteriaModel.FromDate != null)
{
var fromDate = DateTime.SpecifyKind(DateTime.Parse(criteriaModel.FromDate), DateTimeKind.Utc);
var clause = filterBuilder.Gte(f => f.FlightDate, fromDate);
clauses.Add(clause);
}
if (criteriaModel.ToDate != null)
{
var toDate = DateTime.SpecifyKind(DateTime.Parse(criteriaModel.ToDate), DateTimeKind.Utc);
var clause = filterBuilder.Lte(f => f.FlightDate, toDate);
clauses.Add(clause);
}
if (criteriaModel.AirlineId != null)
{
var clause = filterBuilder.Eq(f => f.AirlineId, criteriaModel.AirlineId.Value);
clauses.Add(clause);
}
if (criteriaModel.OriginId != null)
{
var clause = filterBuilder.Eq(f => f.OriginAirportId, criteriaModel.OriginId.Value);
clauses.Add(clause);
}
if (criteriaModel.DestinationId != null)
{
var clause = filterBuilder.Eq(f => f.DestinationAirportId, criteriaModel.DestinationId.Value);
clauses.Add(clause);
}
return clauses;
}