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<IList<Sharelinker>> GetLinkedUsersOfUserId(string userId, IEnumerable<string> ids = null, bool useNoteName = true)
{
var links = await GetUserlinksOfUserId(userId);
var oids = ids == null ? null : from id in ids where !string.IsNullOrWhiteSpace(id) select new ObjectId(id);
IEnumerable<ObjectId> linkedUserIds = null;
if (oids == null || oids.Count() == 0)
{
linkedUserIds = from l in links select l.SlaveUserObjectId;
}
else
{
linkedUserIds = from l in links where oids.Contains(l.SlaveUserObjectId) select l.SlaveUserObjectId;
}
var filter = new FilterDefinitionBuilder<Sharelinker>().In(s => s.Id, linkedUserIds.ToArray());
var collection = Client.GetDatabase("Sharelink").GetCollection<Sharelinker>("Sharelinker");
var linkedUsers =await (await collection.FindAsync(filter)).ToListAsync();
if (useNoteName)
{
var linkMap = links.ToDictionary(lu => lu.SlaveUserObjectId.ToString());
foreach (var item in linkedUsers)
{
item.NoteName = linkMap[item.Id.ToString()].SlaveUserNoteName;
}
}
return linkedUsers;
}
public void GetSteps(String userId)
{
var filterBuilder = new FilterDefinitionBuilder<AuthenticationToken>();
var filter = filterBuilder.Where(i => i.UserId.Equals(userId));
var user = _mongoRepository.Get<AuthenticationToken>(filter).FirstOrDefault();
if (user != null)
{
StepsModel steps = null;
using (var client = new WebClient())
{
client.Headers.Add("Authorization", "Bearer " + user.Token);
client.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
var url = $"https://api.fitbit.com/1/user/{user.ServiceUserId}/activities/date/{DateTime.Today.ToString("yyyy-MM-dd")}.json";
dynamic activity = Json.Decode(client.DownloadString(url));
steps = new StepsModel
{
Date = DateTime.Today,
Count = activity.summary.steps,
UserId = userId
};
}
_mongoRepository.Insert(steps);
}
}
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 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());
}
private LabMongo()
: base()
{
this.FilterBuiler = Builders<MReport>.Filter;
this.UpdateBuiler = Builders<MReport>.Update;
this.ProjectionBuiler = Builders<MReport>.Projection;
this.LisMDB = MClient.GetDatabase(MongoDBName);
}
public async Task WhenGet_Grade_Score_Greater_Than_Returns_RestaurantList()
{
var collection = _database.GetCollection<BsonDocument>("restaurants");
var builder = new FilterDefinitionBuilder<BsonDocument>();
var filter = builder.Gt("grades.score", 20);
var result = await collection.Find(filter).ToListAsync();
Assert.AreEqual(6332, result.Count());
}
private async void GetUser() {
DBMongo.MongoDBHelper<BsonDocument> mongoHelper = new DBMongo.MongoDBHelper<BsonDocument>("User");
IMongoCollection<BsonDocument> collection = mongoHelper.GetCollection();
// var list = collection.Find<XK.Model.User_Model>(u=>u.Name== "k1199").ToListAsync();
FilterDefinitionBuilder<BsonDocument> builder = new FilterDefinitionBuilder<BsonDocument>();
var define= builder.Lt("Age", 122);
var list = collection.Find<BsonDocument>(define).ToListAsync();
string usernames = "";
list.Result.ForEach(d => usernames += d["Name"]+"</br>");
Response.Write(usernames);
}
public static async void QueryByModel(IMongoDatabase db)
{
string key = "borough";
string value = "Manhattan";
var collection = db.GetCollection <Resturant>("restaurants");
var filter = new FilterDefinitionBuilder <Resturant>().Eq(key, value);
var result = await collection.Find(filter).ToListAsync();
var count = result.Count;
foreach (var resturant in result)
{
var r = resturant;
}
Console.WriteLine("Total For {0} is {1} ", key, count);
}
public async Task <IConfigurationEntry> GetEntry(string component, ConfigurationPath path)
{
var filterBuilder = new FilterDefinitionBuilder <MongoDbConfigurationDocument>();
var filter = filterBuilder.Eq(a => a.Path, path.ToString());
if (string.IsNullOrWhiteSpace(component))
{
component = RootComponentName;
}
filter &= filterBuilder.Eq(a => a.Component, component);
var entries = await settingsCollectionData.FindAsync(filter);
var result = await entries.FirstOrDefaultAsync();
return(result == null ? default : RebuildConfigurationEntry(result));
}
public async Task <List <ScheduledCategoryDto> > GetAll()
{
// filter is empty because we need all data
#region filter
var filter = new FilterDefinitionBuilder <ScheduledCategory>();
var filterDefination = filter.Empty;
#endregion
return(await FindAndProjectAsync(filterDefination, x => new ScheduledCategoryDto
{
Id = x.Id,
Category = x.Category,
}));
}
private static void Query()
{
//创建约束生成器
FilterDefinitionBuilder <BsonDocument> builderFilter = Builders <BsonDocument> .Filter;
var time = new BsonDateTime(Convert.ToDateTime("2017-01-01T00:00:00"));
//约束条件
FilterDefinition <BsonDocument> filter = builderFilter.Gte("timestamp", time);
//获取数据
var result = new RTContext().ProvinceBson.Find <BsonDocument>(filter).ToList();
foreach (var item in result)
{
//取出整条值
Console.WriteLine(item.AsBsonValue);
}
}
/// <summary>
/// Delete Blog Method
/// </summary>
/// <param name="request"></param>
/// <param name="context"></param>
/// <returns></returns>
public override async Task <DeleteBlogResponse> DeleteBlog(DeleteBlogRequest request, ServerCallContext context)
{
var filter = new FilterDefinitionBuilder <BsonDocument>().Eq("_id", new ObjectId(request.BlogId));
var result = await mongoCollection.DeleteOneAsync(filter);
if (result.DeletedCount == 0)
{
throw new RpcException(new Status(StatusCode.NotFound, "The blog id " + request.BlogId + " was not find"));
}
return(new DeleteBlogResponse()
{
BlogId = request.BlogId
});
}
public async Task <List <Vulnerability> > GetVulnerabilitiesByProjectId(int pid)
{
var vulnerabilities = _database.GetCollection <Vulnerability>(VulnerabilityCollection);
var filter = new FilterDefinitionBuilder <Vulnerability>().Eq(v => v.ProjectId, pid);
try
{
var results = await vulnerabilities.Find(filter).ToListAsync();
return(results);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public void AddProfileToUser(string username, Profile dto)
{
var db = client.GetDatabase("LightLinkProfiles");
var collection = db.GetCollection <User>("User");
var filter = new FilterDefinitionBuilder <User>();
var builder = new UpdateDefinitionBuilder <User>();
var user = collection.Find((u) => u.UserName == username).Single();
user.Profiles.Add(dto);
var filterBuilder = new FilterDefinitionBuilder <User>();
collection.ReplaceOne(filterBuilder.Where((u) => u.UserName == username), user);
}
public async Task <LicenseEntity> Handle(GetLicenseByUserIdQuery request, CancellationToken cancellationToken)
{
var filter = new FilterDefinitionBuilder <LicenseEntity>()
.Eq(x => x.UserId, request.UserId);
var projection = new ProjectionDefinitionBuilder <LicenseEntity>()
.Include(x => x.Id)
.Include(x => x.UserId)
.Include(x => x.Key)
.Include(x => x.Products);
return(await _licenseCollection
.Find(filter)
.Project <LicenseEntity>(projection)
.FirstOrDefaultAsync(cancellationToken));
}
public async Task InsertInitialTemplatesAsync(IEnumerable <Template>?values)
{
await _templateCollection.InsertManyIgnoringErrorsAsync(values);
// Adds generic template
var filter = new FilterDefinitionBuilder <Template>().Eq(t => t._id, GenericDecription);
var update = new BsonDocument {
{ "$setOnInsert", new BsonDocument("_id", GenericDecription) }
};
var options = new FindOneAndUpdateOptions <Template>()
{
IsUpsert = true
};
await _templateCollection.FindOneAndUpdateAsync(filter, update, options);
}
public async Task <List <Project> > GetAllProjects()
{
var projects = _database.GetCollection <Project>(ProjectCollection);
var filter = new FilterDefinitionBuilder <Project>().Empty;
try
{
var results = await projects.Find(filter).ToListAsync();
return(results);
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
/// <summary>
/// Find Forum thread by user email
/// </summary>
/// <param name="Eamil"></param>
/// <returns></returns>
public async Task <IEnumerable <ForumThread> > FindForumThreadByEmail(string Eamil)
{
try
{
var filterBuilder = new FilterDefinitionBuilder <ForumThread>();
var findEmail = filterBuilder.Eq(s => s.Email, Eamil.ToString());
_dbFCollection = _mongoContext.GetCollection <ForumThread>(typeof(ForumThread).Name);
var result = await _dbFCollection.FindAsync(findEmail).Result.ToListAsync();
return(result);
}
catch (Exception ex)
{
throw (ex);
}
}
/// <summary>
/// 将所有从TB中下载的主力合约1分钟Bar数据导入到MongoDB中
/// </summary>
static void ImportBarCSVs()
{
DirectoryInfo csvFolder = new DirectoryInfo(projectFilePath + "TB_CSV");
FileInfo[] csvFIs = csvFolder.GetFiles();
foreach (var csvFI in csvFIs)
{
string s = csvFI.Name;
var table = DBFunctions.GetOrCreateTable <Bar>(client, "CTPDB", "Bar_" + s.Substring(0, s.IndexOf('(')));
var v = DBFunctions.GetBarsFromCSV(csvFI.FullName);
FilterDefinitionBuilder <Bar> fdb = new FilterDefinitionBuilder <Bar>();
table.DeleteMany(fdb.Empty);
table.InsertMany(v);
Console.WriteLine(table.CollectionNamespace.CollectionName);
}
}
/// <summary>
/// Find student by Student name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public async Task <IEnumerable <Student> > FindStudent(string name)
{
try
{
var filterBuilder = new FilterDefinitionBuilder <Student>();
var findName = filterBuilder.Eq(s => s.Name, name);
_dbSCollection = _mongoContext.GetCollection <Student>(typeof(Student).Name);
var result = await _dbSCollection.FindAsync(findName).Result.ToListAsync();
return(result);
}
catch (Exception ex)
{
throw (ex);
}
}
/// <summary>
/// Book Usr order infromation
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public async Task <IEnumerable <Order> > OrderInformation(string email)
{
try
{
var filterBuilder = new FilterDefinitionBuilder <Order>();
var orderInfo = filterBuilder.Eq(s => s.UserEmail, email);
_order = _mongoContext.GetCollection <Order>(typeof(Order).Name);
var result = await _order.FindAsync(orderInfo).Result.ToListAsync();
return(result);
}
catch (Exception ex)
{
throw (ex);
}
}
public async Task <IReadOnlyList <IEvent <Guid> > > GetEventsAsync(Guid aggregateId, CancellationToken token)
{
var filter = new FilterDefinitionBuilder <EncryptedEvent <Guid> >().Eq(nameof(Event.AggregateRootId), aggregateId);
var encryptedEvents = await _mongoCollection.Find(filter).ToListAsync(token);
var decryptedEvents = new List <IEvent <Guid> >();
foreach (var encryptedEvent in encryptedEvents)
{
var decrypted = await _encryptionService.DecryptAsync(encryptedEvent, token);
decryptedEvents.Add(decrypted);
}
return(decryptedEvents);
}
private async Task <List <ObservationIdTuple> > FindObservationKeysAsync(List <T> speciesObservations)
{
var filterDef = new FilterDefinitionBuilder <VersionedDocumentObservation <T> >();
var filter = filterDef.In(x => x.CompositeId, speciesObservations.Select(x => $"{x.DataProviderId}_{x.CatalogNumber}"));
var projection = Builders <VersionedDocumentObservation <T> > .Projection
.Include(x => x.DataProviderId)
.Include(x => x.CatalogNumber)
.Exclude("_id"); // _id is special and needs to be explicitly excluded if not needed
var options = new FindOptions <VersionedDocumentObservation <T>, ObservationIdTuple> {
Projection = projection
};
var foundObservationsTuples = await(await Collection.FindAsync(filter, options)).ToListAsync();
return(foundObservationsTuples);
}
/// <summary>
/// Get Product by name
/// </summary>
/// <param name="ProductName"></param>
/// <returns></returns>
public async Task <IEnumerable <Product> > ProductByName(string ProductName)
{
try
{
var filterBuilder = new FilterDefinitionBuilder <Product>();
var productName = filterBuilder.Eq(s => s.ProductName, ProductName.ToString());
_dbproductCollection = _mongoContext.GetCollection <Product>(typeof(Product).Name);
var result = await _dbproductCollection.FindAsync(productName).Result.ToListAsync();
return(result);
}
catch (Exception ex)
{
throw (ex);
}
}
public Task <UserDTO?> ExtractUserAsync(string?token)
{
if (token == null)
{
return(Task.FromResult <UserDTO?>(null));
}
var tokenhandler = new JwtSecurityTokenHandler();
var key = Encoding.UTF8.GetBytes(_envvars.GetJwtSecret());
var parameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(key),
ValidateIssuer = false,
ValidateAudience = false
};
try
{
tokenhandler.ValidateToken(token, parameters, out SecurityToken validated);
var tk = tokenhandler.ReadJwtToken(token);
var nameClaim = tk.Payload.Claims.FirstOrDefault(claim => claim.Type == "unique_name");
var filter = new FilterDefinitionBuilder <User>().Where(user => user.Id == nameClaim.Value);
return(_users
.Find(filter)
.FirstOrDefaultAsync()
.ContinueWith(res =>
{
if (res.Result == null)
{
return null;
}
;
return new UserDTO
{
Email = res.Result.Email,
LastName = res.Result.LastName,
Name = res.Result.Name,
Id = res.Result.Id
};
}));
}
catch (ArgumentNullException) { return(Task.FromResult <UserDTO?>(null)); }
catch (ArgumentException) { return(Task.FromResult <UserDTO?>(null)); }
catch (SecurityTokenEncryptionFailedException) { return(Task.FromResult <UserDTO?>(null)); }
catch (SecurityTokenExpiredException) { return(Task.FromResult <UserDTO?>(null)); }
}
private async Task <(string, TrackedEntity <GeoJsonPoint <GeoJson3DGeographicCoordinates> >)> ComputeDataForUser()
{
var userId = this.GetCurrentUserId();
if (userId == null)
{
return("", null);
}
var userCollection = MongoWrapper.Database.GetCollection <Models.User>(nameof(Models.User));
var userFilterBuilder = new FilterDefinitionBuilder <Models.User>();
var userFilter = userFilterBuilder.Eq(u => u._id, new ObjectId(userId));
var user = (await userCollection.FindAsync(userFilter, new FindOptions <Models.User>
{
AllowPartialResults = true,
Limit = 1
})).SingleOrDefault();
if (user == null)
{
return("", null);
}
var phrase = string.Empty;
if (!string.IsNullOrWhiteSpace(user.About))
{
phrase += user.About.Replace("\"", "");
}
if (user is Musician musician)
{
phrase += musician.InstrumentSkills?.Select
(
kvp => kvp.Key.GetAttribute <DisplayAttribute>().Name
)
.Aggregate
(
string.Empty,
(s1, s2) => s1 + " " + s2
);
}
return(phrase, user.TrackedPosition);
}
public Puzzle GetOneRandomly(List <int> excludedIds, string variant, int?userId, double nearRating = 1500)
{
FilterDefinitionBuilder <Puzzle> filterBuilder = Builders <Puzzle> .Filter;
FilterDefinition <Puzzle> filter = filterBuilder.Nin("_id", excludedIds) & filterBuilder.Eq("inReview", false)
& filterBuilder.Eq("approved", true);
if (variant != "Mixed")
{
filter &= filterBuilder.Eq("variant", variant);
}
if (userId.HasValue)
{
filter &= filterBuilder.Ne("author", userId.Value) & filterBuilder.Nin("reviewers", new int[] { userId.Value });
}
FilterDefinition <Puzzle> lteFilter = filter;
FilterDefinition <Puzzle> gtFilter = filter;
bool higherRated = RandomBoolean();
gtFilter &= filterBuilder.Gt("rating.value", nearRating);
lteFilter &= filterBuilder.Lte("rating.value", nearRating);
var foundGt = puzzleCollection.Find(gtFilter);
var foundLte = puzzleCollection.Find(lteFilter);
if (foundGt == null && foundLte == null)
{
return(null);
}
SortDefinitionBuilder <Puzzle> sortBuilder = Builders <Puzzle> .Sort;
foundGt = foundGt.Sort(sortBuilder.Ascending("rating.value")).Limit(1);
foundLte = foundLte.Sort(sortBuilder.Descending("rating.value")).Limit(1);
Puzzle oneGt = foundGt.FirstOrDefault();
Puzzle oneLte = foundLte.FirstOrDefault();
if (oneGt == null)
{
return(oneLte);
}
else if (oneLte == null)
{
return(oneGt);
}
else
{
return(RandomBoolean() ? oneGt : oneLte);
}
}
public async Task <long> SetDevicesOfflineAsync(DateTime notUpdatedSince)
{
var filter = new FilterDefinitionBuilder <Device>().Lt(d => d.UpdatedAt, notUpdatedSince);
var update = new BsonDocument {
{ "$set", new BsonDocument {
{ "offline", true }
} }
};
var options = new UpdateOptions()
{
IsUpsert = false
};
var updateResult = await _deviceCollection.UpdateManyAsync(filter, update, options);
return(updateResult.IsAcknowledged && updateResult.IsModifiedCountAvailable ? updateResult.MatchedCount : 0);
}
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 Task <IEnumerable <UserData> > GetAsync(string id = null, bool?isActive = true)
{
var filterBuilder = new FilterDefinitionBuilder <UserData>();
var filter = FilterDefinition <UserData> .Empty;
if (!string.IsNullOrWhiteSpace(id))
{
filter &= filterBuilder.Eq <string>(userData => userData.Id, id);
}
if (isActive.HasValue)
{
filter &= filterBuilder.Eq <bool>(userData => userData.IsActive, isActive.Value);
}
return(GetAsync(filter));
}
public void AddSeenMovieToUser(ObjectId movieId, ObjectId userId)
{
var user = GetByObjectId <User>(userId, Const.MongoDbConst.CollectionUsers);
//User hat film schon gesehen
if (user.MoviesWatchedIds.Contains(movieId))
{
return;
}
var collection = GetCollection <User>(Const.MongoDbConst.CollectionUsers);
var filter = new FilterDefinitionBuilder <User>().Eq("_id", userId);
var update = Builders <User> .Update.Push <ObjectId>(u => u.MoviesWatchedIds, movieId);
collection.FindOneAndUpdateAsync(filter, update);
}
public BucketList GetBucketList(ObjectId id)
{
var collection = GetCollection <BsonDocument>(Const.MongoDbConst.CollectionBucketList);
var filter = new FilterDefinitionBuilder <BsonDocument>().Eq("_id", id);
var result = collection.FindSync(filter).FirstOrDefault();
if (result == null)
{
return(null);
}
var bucketList = BsonSerializer.Deserialize <BucketList>(result);
return(bucketList);
}
public static string RenderQuery <T>(UpdateDefinition <T> filterDefinition) where T : TDocument
{
var query = string.Empty;
try
{
IBsonSerializerRegistry registry = BsonSerializer.SerializerRegistry;
IBsonSerializer <T> serializer = BsonSerializer.SerializerRegistry.GetSerializer <T>();
FilterDefinitionBuilder <T> __subject = Builders <T> .Filter;
query = filterDefinition.Render(serializer, registry).ToString();
}
catch (Exception)
{
}
return(query);
}
public void AddBucketListToUser(ObjectId userId, ObjectId bucketListId)
{
var user = GetByObjectId <User>(userId, Const.MongoDbConst.CollectionUsers);
//User hat film schon gesehen
if (user.BucketListsInvolvedIn.Contains(bucketListId))
{
return;
}
var collection = GetCollection <User>(Const.MongoDbConst.CollectionUsers);
var filter = new FilterDefinitionBuilder <User>().Eq("_id", userId);
var update = Builders <User> .Update.Push <ObjectId>(u => u.BucketListsInvolvedIn, bucketListId);
collection.FindOneAndUpdateAsync(filter, update);
}
/// <summary>
/// Get Medicine by Name
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public async Task <IEnumerable <Medicine> > MedicineByName(string name)
{
try
{
var filterBuilder = new FilterDefinitionBuilder <Medicine>();
var findName = filterBuilder.Eq(s => s.Name, name);
var findBrand = filterBuilder.Eq(s => s.Brand, name.ToString());
_dbMCollection = _mongoContext.GetCollection <Medicine> (typeof(Medicine).Name);
var result = await _dbMCollection.FindAsync(findName | findBrand).Result.ToListAsync();
return(result);
}
catch (Exception ex)
{
throw (ex);
}
}
public override List <ProductoDTO> GetProductByName(string palabra)
{
ProductsData data = new ProductsData();
IMongoCollection <BsonDocument> products = data.GetProductDataByName();
FilterDefinitionBuilder <BsonDocument> builder = Builders <BsonDocument> .Filter;
FilterDefinition <BsonDocument> filter = @"{ $or: [{ ""brand"" : {$in: [/$palabra$/] }},{ ""description"" : {$in: [/$palabra$/] }}] }".Replace("$palabra$", palabra);
List <BsonDocument> resultFiltros = products.Find(filter).ToList();
foreach (BsonDocument item in resultFiltros)
{
ProductoDTO myObj = BsonSerializer.Deserialize <ProductoDTO>(item);
listResultDB.Add(myObj);
}
return(listResultDB);
}
public async Task <bool> DeleteExpiredTokensAsync(string userId)
{
try
{
FilterDefinition <User> filter = new FilterDefinitionBuilder <User>().Eq(x => x.Id, userId);
UpdateDefinition <User> update = new UpdateDefinitionBuilder <User>().PullFilter(x => x.Tokens, i => i.RefreshTokenExpiresDateTime < DateTimeOffset.UtcNow);
await mongoDbContext.Users.UpdateManyAsync(filter, update);
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task SetDeviceOfflineAsync(IPAddress ipAddress, bool offline = true)
{
var filter = new FilterDefinitionBuilder <Device>().Eq(d => d.Ipv4Address, ipAddress);
var update = offline
? new BsonDocument {
{ "$set", new BsonDocument {
{ "offline", true }
} }
}
: new BsonDocument {
{ "$unset", new BsonDocument {
{ "offline", true }
} }
};
await _deviceCollection.FindOneAndUpdateAsync(filter, update);
}
public async Task<IDictionary<ObjectId, IEnumerable<SharelinkTag>>> GetLinkersTags(IEnumerable<ObjectId> linkerIds)
{
var result = new Dictionary<ObjectId, IEnumerable<SharelinkTag>>();
var tagCollection = Client.GetDatabase("Sharelink").GetCollection<SharelinkTag>("SharelinkTag");
var filter = new FilterDefinitionBuilder<SharelinkTag>().In(t=>t.UserId, linkerIds);
var tags = await tagCollection.Find(filter).ToListAsync();
var tagsGrouped = from t in tags group t by t.UserId;
foreach (var item in tagsGrouped)
{
result.Add(item.Key, item.ToList());
}
return result;
}
public void RefreshToken(string userId)
{
var filterBuilder = new FilterDefinitionBuilder<AuthenticationToken>();
var filter = filterBuilder.Where(i => i.UserId.Equals(userId));
AuthenticationToken token = _mongoRepository.Get(filter).FirstOrDefault();
if (token != null)
{
var refresherToken = token.RefreshToken;
var parameters = String.Format("grant_type=refresh_token&refresh_token={0}", refresherToken);
using (var client = new WebClient())
{
client.Headers.Add("Authorization", "Basic " + Convert.ToBase64String(Encoding.Default.GetBytes(_basicAuthenticationHeader)));
client.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
dynamic credentials = Json.Decode(client.UploadString(TokenUrl, parameters));
token.Expiration = credentials.expires_in;
token.Token = credentials.access_token;
token.RefreshToken = credentials.refresh_token;
token.Type = credentials.token_type;
}
_mongoRepository.Update(filter, token);
}
}
public async Task<bool> DeleteSharelinkTags(string userId, string[] tagIds)
{
ObjectId userOId = new ObjectId(userId);
var collection = Client.GetDatabase("Sharelink").GetCollection<Sharelinker>("Sharelinker");
var ids = from id in tagIds select new ObjectId(id);
var update = new UpdateDefinitionBuilder<Sharelinker>().PullAll(u => u.SharelinkTags, ids);
var res = await collection.UpdateOneAsync(u => u.Id == userOId ,update);
var tagCollection = Client.GetDatabase("Sharelink").GetCollection<SharelinkTag>("SharelinkTag");
var tagFilter = new FilterDefinitionBuilder<SharelinkTag>().In(t => t.Id, ids);
var uId = new ObjectId();
var tagUpdate = new UpdateDefinitionBuilder<SharelinkTag>().Set(t => t.UserId, uId);
await tagCollection.UpdateManyAsync(tagFilter,tagUpdate);
try
{
return res.ModifiedCount > 0;
}
catch (Exception)
{
return false;
}
}
public static async void InsertOrders(IMongoDatabase db)
{
var collections = db.GetCollection<Orders>("orders");
var data = new Orders()
{
OrderId = 1,
Date = DateTime.Now,
Name = "Irfan",
TotalAmount = 10.0m,
};
var datalist = new List<Orders>()
{
new Orders(){OrderId = 1, Date = DateTime.Now, Name = "Irfan",TotalAmount = 10.0m, },
new Orders(){OrderId = 1, Date = DateTime.Now, Name = "Klayan",TotalAmount = 10.0m, },
new Orders(){OrderId = 1, Date = DateTime.Now, Name = "Khan",TotalAmount = 10.0m, },
};
//Insert Single Document
await collections.InsertOneAsync(data);
Console.WriteLine("Insert Count 1");
//Insert Multiple Documents;
await collections.InsertManyAsync(datalist);
Console.WriteLine("Insert Count Many");
var filter = new FilterDefinitionBuilder<Orders>().Eq("Name", "Irfan");
var result = await collections.Find(filter).ToListAsync();
foreach (var r in result)
{
Console.WriteLine("OrderId {0}, OrderTotal {1}, OrderDate {2}", r.OrderId, r.TotalAmount, r.Date);
}
}
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 void BuildQuerySimple()
{
var client = new MongoClient("mongodb://localhost:27017");
var db = client.GetDatabase("hra");
var items = db.GetCollection<BsonDocument>("incumbent");
var fd = new FilterDefinitionBuilder<BsonDocument>();
var filter1 = fd.All("Job_Family", new List<string> {"Health Care"});
IAggregateFluent<BsonDocument> dd = items.Aggregate();
IAggregateFluent<BsonDocument> ts = dd.Match(filter1);
var ll = ts.Group(x => new {Year = x["Year"], Org = x["org_type"]},
g => new {Key=g.Key, Average=g.Average(x => (double) x["Base_Pay"])});
ll.Project(x => new BsonDocument {new BsonElement("Key",x.Key.Year), new BsonElement("Average",x.Average)});
//ts.Group()
//IAggregateFluent<BsonDocument> gd = ts.Group(x => new {s1 = x["Year"], s2 = x["org_type"]},
// g => new {Key = g.Key, Value = g.Average(x => (double) x["Base_Pay"])}).Project(x => new {Key = new List<string>{x.Key.s1.ToString()}, Value = x.Value});
//dd.Match(filter1)
//.Group(x => new {s1 = x["Year"], s2 = x["org_type"]},
// g => new {Key = g.Key, Value = g.Average(x => (double) x["Base_Pay"])})
//.Project(x => new {Key = new List<string>{x.Key.s1.ToString()}, Value = x.Value});
//var dc = new List<IPipelineStageDefinition>();
//dc.AddRange(dd.Stages);
//var pl = dc.ToArray();
//var zito = pl.ToJson();
//var docs = items.AggregateAsync<BsonDocument>(dc);
var zz = ll.ToListAsync().Result;
Assert.IsTrue(zz.Count > 0);
var pp = "cc";
}
public static async void QueryByModel(IMongoDatabase db)
{
string key = "borough";
string value = "Manhattan"; //restaurants
var collection = db.GetCollection<Resturant>("Restaurant");
var filter = new FilterDefinitionBuilder<Resturant>().Eq(key, value);
var result = await collection.Find(filter).ToListAsync();
var count = result.Count;
foreach (var resturant in result)
{
var r = resturant;
}
Console.WriteLine("Total For {0} is {1} ", key,count);
}
public void GetToken(String code, String userId)
{
AuthenticationToken token = null;
var parameters = String.Format("client_id={0}&grant_type=authorization_code&redirect_uri={1}&code={2}", ClientId, RedirectUrl, code);
using (var client = new WebClient())
{
client.Headers.Add("Authorization",
"Basic " + Convert.ToBase64String(Encoding.Default.GetBytes(_basicAuthenticationHeader)));
client.Headers[HttpRequestHeader.ContentType] = "application/x-www-form-urlencoded";
dynamic credentials = Json.Decode(client.UploadString(TokenUrl, parameters));
var filterBuilder = new FilterDefinitionBuilder<AuthenticationToken>();
var filter = filterBuilder.Where(i => i.UserId.Equals(userId));
if (!_mongoRepository.Exists(filter))
{
token = new AuthenticationToken
{
Expiration = credentials.expires_in,
Token = credentials.access_token,
RefreshToken = credentials.refresh_token,
Type = credentials.token_type,
UserId = userId,
ExpirationDate = DateTime.Now.AddSeconds(credentials.expires_in),
ServiceUserId = credentials.user_id
};
_mongoRepository.Insert(token);
}
}
}
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;
}
public void BuildQuery()
{
var source = GetQueryBuilder();
var jobFamily = source.AvailableFilters.Single(x => x.Column.ColumnName == "Job_Family");
var jobTrack = source.AvailableFilters.Single(x => x.Column.ColumnName == "Job_Track");
var matchBuilder = new FilterDefinitionBuilder<BsonDocument>();
jobFamily.AvailableFilterValues.Add(new FilterValue {Key = "Executive", Value = "Executive", Active=true});
var jobFamilyFilter = matchBuilder.All(jobFamily.Column.ColumnName,
jobFamily.AvailableFilterValues.Where(x=>x.Active).Select(x=>x.Value).ToList());
//take care of grouping key
var groupDoc = new BsonDocument();
var slicers = new List<BsonElement>();
slicers.Add(new BsonElement("s1", new BsonString("$Year")));
slicers.Add(new BsonElement("s2", new BsonString("$orgType")));
var idDoc = new BsonDocument(slicers);
var idElm = new BsonElement("_id", idDoc);
var idDocument = new BsonDocument();
idDocument.Add(idElm);
//take care of grouping val
var factDoc = new BsonDocument();
var factEl = new BsonElement("$avg", new BsonString("$Base_Pay"));
factDoc.Add(factEl);
var factElementDoc = new BsonDocument();
factElementDoc.Add(new BsonElement("f1", factDoc));
var factDocResult = new BsonDocument();
factDocResult.AddRange(factElementDoc);
groupDoc.AddRange(idDocument);
groupDoc.AddRange(factDocResult);
var groupElement = new BsonElement("$group", groupDoc);
var matchDoc = new BsonDocument();
var filter1Element = new BsonElement("Job_Family", new BsonString("Executive"));
var filter1Doc = new BsonDocument();
filter1Doc.Add(filter1Element);
var filterFinalElement = new BsonElement("$match", filter1Doc);
var finalDoc = new BsonDocument();
finalDoc.Add(filterFinalElement);
finalDoc.Add(groupElement);
var dd = finalDoc.ToString();
Console.Out.Write(dd);
var xx = "Y";
// jobTrack.
}
public static async void UpdateOrders(IMongoDatabase db)
{
var collections = db.GetCollection<Orders>("orders");
//var filter = new FilterDefinitionBuilder<Orders>().Eq("Name", "Irfan");
var filter = Builders<Orders>.Filter.Eq("Name", "Irfan");
var update = Builders<Orders>.Update
.Set(c => c.Date, DateTime.Now.AddDays(1))
.Set(c => c.TotalAmount, 25.0m);
var result = await collections.UpdateOneAsync(filter, update);
//var result = await collections.UpdateManyAsync(filter, update);
var res = result;
var searchfilter = new FilterDefinitionBuilder<Orders>().Eq("Name", "Irfan");
var searchresult = await collections.Find(searchfilter).ToListAsync();
foreach (var r in searchresult)
{
Console.WriteLine("OrderId {0}, OrderTotal {1}, OrderDate {2}", r.OrderId, r.TotalAmount, r.Date);
}
var result2 = await collections.UpdateManyAsync(filter, update);
res = result2;
searchfilter = new FilterDefinitionBuilder<Orders>().Eq("Name", "Irfan");
searchresult = await collections.Find(searchfilter).ToListAsync();
foreach (var r in searchresult)
{
Console.WriteLine("Name: {3} OrderId {0}, OrderTotal {1}, OrderDate {2}", r.OrderId, r.TotalAmount, r.Date, r.Name);
}
}
public static async void ListBlogUsers(IMongoDatabase db)
{
string key = "Name";
string value = "*";
var collection = db.GetCollection<User>("users");
var filter = new FilterDefinitionBuilder<User>().Eq(key, value);
var result = await collection.Find(filter).ToListAsync();
result = await collection.AsQueryable().ToListAsync();
result = await collection.Find(e => true).ToListAsync();
var count = result.Count;
foreach (var item in result)
{
Console.WriteLine("Users Name: {0} Email: {1}", item.Name, item.Email);
}
Console.WriteLine("Total Users {0} ", count);
await ListPostsByUser(db);
}
private void insertOrUpdateDbInfo()
{
var dbInfo = this.DbInfo;
if (DbInfo == null)
{
insertDbInfo();
}
else
{
var filter = new FilterDefinitionBuilder<DbInfo>().Eq(x => x.Id, dbInfo.Id);
dbInfo.LastSynchro = DateTime.Now;
this.DbInfos.ReplaceOne(filter, dbInfo);
}
}
public async Task<IList<ShareThing>> GetShares(IEnumerable<ObjectId> shareIds)
{
var shareThingCollection = Client.GetDatabase("Sharelink").GetCollection<ShareThing>("ShareThing");
var fileter = new FilterDefinitionBuilder<ShareThing>().In(s => s.Id, shareIds);
var shareThings = shareThingCollection.Find(fileter);
return await shareThings.ToListAsync();
}
