public async Task <Terminal> Get(Guid guid, Graph.Common.NeuronQuery neuronQuery, CancellationToken cancellationToken = default(CancellationToken)) { Terminal result = null; NeuronRepository.FillWithDefaults(neuronQuery, this.settingsService); using (var db = ArangoDatabase.CreateWithSetting(this.settingsService.DatabaseName)) { AssertionConcern.AssertStateTrue(await Helper.GraphExists(db), Constants.Messages.Error.GraphNotInitialized); var t = await db.DocumentAsync <Terminal>(guid.ToString()); if ( t != null && ( neuronQuery.TerminalActiveValues.Value.HasFlag(Graph.Common.ActiveValues.All) || ( Helper.TryConvert(neuronQuery.TerminalActiveValues.Value, out bool activeValue) && t.Active == activeValue ) ) ) { result = t.CloneExcludeSynapticPrefix(); } } return(result); }
public async Task Clear() { using (var db = ArangoDatabase.CreateWithSetting(this.settingsService.DatabaseName)) { await Helper.Clear(db, nameof(Settings)); } }
private async Task UpdateUser(User userToUpdate) { using (var db = ArangoDatabase.CreateWithSetting()) { await db.UpdateByIdAsync <User>(userToUpdate.Id, userToUpdate); } }
public async Task Clear() { using (var db = ArangoDatabase.CreateWithSetting(this.settingsService.DatabaseName)) { await Helper.Clear(db, nameof(Terminal), CollectionType.Edge); } }
public async Task Save(Settings dto, CancellationToken cancellationToken = default(CancellationToken)) { if (dto.Id != Guid.Empty.ToString()) { throw new ArgumentException("Invalid 'Settings' document id."); } using (var db = ArangoDatabase.CreateWithSetting(this.settingsService.DatabaseName)) { if (!db.ListCollections().Any(c => c.Name == nameof(Settings))) { throw new InvalidOperationException( $"Collection '{nameof(Settings)}' not initialized." ); } if (await db.DocumentAsync <Settings>(dto.Id) == null) { await db.InsertAsync <Settings>(dto); } else { await db.ReplaceByIdAsync <Settings>(dto.Id, dto); } } }
static void Main(string[] args) { var creds = new NetworkCredential("root", "123456"); ArangoDatabase.ChangeSetting(s => { s.Database = "IdentityTest"; s.Url = "http://localhost:8529/"; s.Credential = creds; s.SystemDatabaseCredential = creds; }); // Keys must be saved without encoding but // retrieved with UrlEncoding. // using (var database = ArangoDatabase.CreateWithSetting()) { database.Collection("Hello").Insert(new Hello { Key = ToBase64UrlFromString("hello/world"), Text = "Hello world" }); var data = database.Collection("Hello").Document <Hello>(ToBase64UrlFromString("hello/world")); //var grant = database.Collection("PersistedGrants").Document<PersistedGrants>(WebUtility.UrlEncode("gmzAS+Gw3zjqPNU0sFvRBC9AGkZqXyNxRx+HQhPiUvs=")); //Console.WriteLine(grant.Key); } }
public async Task <ActionResult> GetUserInfo(string userId) { using (var db = ArangoDatabase.CreateWithSetting()) { var user = await(from u in db.Query <User>() where u.Key == userId select new { u.Username, u.RealName, u.Email, u.Description, u.Birthday, u.Occupation, u.Key }) .FirstOrDefaultAsync(); if (user == null) { return(NotFound()); } return(Ok(new { user.Username, user.RealName, user.Email, user.Description, user.Birthday, user.Occupation, user.Key, ProfilePicture = $"{Configuration["AppSettings:DefaultURL"]}/api/users/{user.Key}/profile.jpeg" })); } }
public async Task StoreAsync(PersistedGrant grant) { using (var database = ArangoDatabase.CreateWithSetting()) { var collection = database.Collection(_arangoDBConfig.Collections.PersistedGrants); var encodedKey = ToBase64UrlFromString(grant.Key); if (await collection.ExistsAsync(encodedKey)) { return; } await collection .InsertAsync( new ArangoDBPersistedGrant { Key = encodedKey, GrantKey = grant.Key, ClientId = grant.ClientId, CreationTime = grant.CreationTime, Data = grant.Data, Expiration = grant.Expiration, SubjectId = grant.SubjectId, Type = grant.Type } ); } }
public void deleteDB(string name) { this.connect(); using (var db = ArangoDatabase.CreateWithSetting()) { db.DropDatabase(name); } }
public dataBaseManager(string urlWithPort, string database, string adminName, string password) { this.urlWithPort = urlWithPort; this.database = database; this.adminName = adminName; this.password = password; this.connect(); this.db = ArangoDatabase.CreateWithSetting(); }
public async Task RemoveAsync(string key) { using (var database = ArangoDatabase.CreateWithSetting()) { var encodedKey = WebUtility.UrlEncode(key); await database.Collection(_arangoDBConfig.Collections.PersistedGrants) .RemoveByIdAsync(encodedKey); } }
private async Task <User> GetUserWithId(string userId) { using (var db = ArangoDatabase.CreateWithSetting()) { var selectedUser = await(from u in db.Query <Models.Users.User>() where u.Key == userId select u).FirstOrDefaultAsync(); return(selectedUser); } }
public void createDB(string name) { this.connect(); using (var db = ArangoDatabase.CreateWithSetting()) { db.CreateDatabase(name); //var currentDatabaseInfo = db.CurrentDatabaseInformation(); //Console.WriteLine(currentDatabaseInfo.Path); } }
public async Task RemoveAllAsync(string subjectId, string clientId, string type) { using (var database = ArangoDatabase.CreateWithSetting()) { await database.Query <ArangoDBPersistedGrant>() .Where(pg => pg.SubjectId == subjectId && pg.ClientId == clientId && pg.Type == type) .Remove() .ToListAsync(); } }
public IActionResult GetAllUsers([FromQuery] UsersQueryOptions options) { using (var db = ArangoDatabase.CreateWithSetting()) { var query = from u in db.Query <User>() select new { u.Key, u.Username, u.RealName, u.Email, u.Description, u.Occupation, birthday = AQL.DateFormat(u.Birthday, "%dd/%mm/%yyyy") }; if (options.Name != null) { query = query.Where(u => AQL.Contains(AQL.Lower(u.Username), AQL.Lower(options.Name))); } if (options.Email != null) { query = from u in query where AQL.Lower(u.Email) == AQL.Lower(options.Email) select u; } if (options.Limit.HasValue) { query = query.Take(options.Limit.Value); } if (options.Sorted.HasValue && options.Sorted.Value == true) { query = query.OrderBy(user => user.Username); } var defaultValue = query.FirstOrDefault(); var queryCount = query.Count(); if (query.Count() >= 250 || options.Page.HasValue) { var skipValue = (options.Page ?? 0) * 250; query = query.Skip(skipValue).Take(250).Select(u => u); } if (options.MaxElements.HasValue && options.MaxElements.Value > 0) { query = query.Take(options.MaxElements.Value); } return(Ok(query)); } }
public ArrangoDbWriter(string url, string Database, string UserName, string Password) { ArangoDatabase.ChangeSetting(s => { s.Database = Database; s.Url = url; s.Credential = new NetworkCredential(UserName, Password); s.SystemDatabaseCredential = new NetworkCredential(UserName, Password); }); db = ArangoDatabase.CreateWithSetting(); }
public Task ExecuteAsync(CancellationToken cancellationToken) { var task = new Task(() => { using (var db = ArangoDatabase.CreateWithSetting()) { db.Query <User>().Where(u => u.Username == null).Remove().Execute(); } }); task.Start(); return(task); }
public async Task <IActionResult> AddUserToChat(string chatId, AddUserToChatRequest request) { using (var db = ArangoDatabase.CreateWithSetting()) { var usersInChatGraph = db.Graph("ChatsUserGraph"); var edge = new ChatMembers { Chat = chatId, User = request.UserId }; await usersInChatGraph.InsertEdgeAsync <ChatMembers>(edge); return(Ok()); } }
public static void Connect(string collectionName) { if (Collection != null) { throw new TraceStateException("Connection already established."); } ArangoDatabase.ChangeSetting(s => { s.Database = "test"; s.Url = "http://localhost:8529"; // you can set other settings if you need s.Credential = new NetworkCredential("root", ""); s.SystemDatabaseCredential = new NetworkCredential("root", ""); }); client = ArangoDatabase.CreateWithSetting(); //client.CreateDatabase(Dns.GetHostName()); //just to update the description state var databases = client.ListDatabases(); if (client.Connection == null) { throw new TraceStateException("Local db is unreachable."); } //client.CreateCollection("logggs"); Collection = client.Collection(collectionName); Buffers = new LogBuffer[NumberOfBuffers]; for (int i = 0; i < NumberOfBuffers; i++) { Buffers[i] = new LogBuffer(); } Arbiter = new Arbiter2(Buffers); //I create a new delegate in order to call a method with a Conditional Attribute Arbiter.OnAllBuffersFilled += delegate { Flush(); }; timer = new Timer(2000); timer.AutoReset = true; timer.Elapsed += delegate { Timer_Elapsed(null, null); }; timer.Start(); }
public async Task <IActionResult> GetUserNotificationPreferences() { using (var db = ArangoDatabase.CreateWithSetting()) { var user = await(from u in db.Query <User>() where u.Key == HttpContext.User.Identity.Name select u).FirstOrDefaultAsync(); if (user == null) { return(NotFound()); } return(Ok(new { Preferences = user.NotificationPreference })); } }
public Task ExecuteAsync(CancellationToken cancellationToken) { Task task = new Task(() => { using (var db = ArangoDatabase.CreateWithSetting()) { var dateTimeNow = DateTime.UtcNow; db.Query <RefreshToken>() .Where(t => t.Expires <= dateTimeNow) .Remove() .Execute(); } }); task.Start(); return(task); }
public async Task <IActionResult> SetUserNotificationPreferences([FromBody] NotificationPreference newPreference) { using (var db = ArangoDatabase.CreateWithSetting()) { var user = await(from u in db.Query <User>() where u.Key == HttpContext.User.Identity.Name select u).FirstOrDefaultAsync(); if (user == null) { return(NotFound()); } user.NotificationPreference = newPreference; await db.UpdateByIdAsync <User>(user.Key, user); return(Ok()); } }
public async Task <IActionResult> GetChatById(string chatId) { using (var db = ArangoDatabase.CreateWithSetting()) { var chat = await db.Query <Chat>() .Where(c => c.Key == chatId) .Select(c => c) .FirstOrDefaultAsync(); if (chat == null) { return(NotFound()); } var filteredChat = (await db.CreateStatement <Chat>(@" FOR c in Chat FILTER c._key == " + $"'{chatId}'" + @" LET messages = ( FOR m in c.messages FOR u in User FILTER m.sender == u._key return MERGE(m, {sender: u.username, senderId: m.sender}) ) return MERGE(c, {messages: messages})" ).ToListAsync()).Select(c => new { c.Key, c.Name, c.Messages, c.IsGroup, c.ProjectId }); var traversalResult = await db.TraverseAsync <User, Chat>(new TraversalConfig { StartVertex = chat.Id, GraphName = "ChatsUsersGraph", Direction = EdgeDirection.Outbound, MinDepth = 1, MaxDepth = 1 }); var chats = traversalResult.Visited.Vertices; // si el usuario no esta en ese chat entonces lo descartamos if (chats.Find(u => u.Key == HttpContext.User.Identity.Name) == null) { return(NotFound()); } return(Ok(filteredChat.FirstOrDefault())); } }
public async Task <IEnumerable <PersistedGrant> > GetAllAsync(string subjectId) { using (var database = ArangoDatabase.CreateWithSetting()) { return(await database.Query <ArangoDBPersistedGrant>() .Where(pg => pg.SubjectId == subjectId) .Select(grant => new PersistedGrant { Key = grant.GrantKey, ClientId = grant.ClientId, CreationTime = grant.CreationTime, Data = grant.Data, Expiration = grant.Expiration, SubjectId = grant.SubjectId, Type = grant.Type }) .ToListAsync()); } }
public async Task <Settings> Get(Guid dtoGuid, CancellationToken cancellationToken = default(CancellationToken)) { if (dtoGuid != Guid.Empty) { throw new ArgumentException("Invalid 'Settings' document id."); } Settings result = null; using (var db = ArangoDatabase.CreateWithSetting(this.settingsService.DatabaseName)) { if ((await db.ListCollectionsAsync()).Any(c => c.Name == nameof(Settings))) { result = await db.DocumentAsync <Settings>(dtoGuid.ToString()); } } return(result); }
private static Domain.Model.QueryResult GetNeuronResults(Guid?centralGuid, Guid?relativeGuid, string settingName, NeuronQuery neuronQuery, CancellationToken token = default(CancellationToken)) { Domain.Model.QueryResult result = null; using (var db = ArangoDatabase.CreateWithSetting(settingName)) { var queryResult = db.CreateStatement <Domain.Model.NeuronResult>( NeuronRepository.CreateQuery(centralGuid, relativeGuid, neuronQuery, out List <QueryParameter> queryParameters), queryParameters, options: new QueryOption() { FullCount = true } ); var neurons = queryResult.AsEnumerable().ToArray(); if (centralGuid.HasValue) { neurons.ToList().ForEach(nr => nr.Terminal = nr.Terminal.CloneExcludeSynapticPrefix()); } var fullCount = (int)queryResult.Statistics.Extra.Stats.FullCount; if ( neuronQuery.Page.Value != 1 && fullCount == NeuronRepository.CalculateOffset(neuronQuery.Page.Value, neuronQuery.PageSize.Value) && neurons.Length == 0 ) { throw new ArgumentOutOfRangeException("Specified/Default Page is invalid."); } result = new Domain.Model.QueryResult() { Count = fullCount, Neurons = neurons }; } return(result); }
public override async Task InsertTest() { ArangoDatabase.ChangeSetting(s => { s.Database = "benchmark"; s.Url = "http://localhost:8529"; // you can set other settings if you need s.Credential = new NetworkCredential("root", "pass.123"); s.SystemDatabaseCredential = new NetworkCredential("root", "pass.123"); }); var fakesUsers = UserUtility.GetFakeUsers(Times); using (var db = ArangoDatabase.CreateWithSetting()) { foreach (var userList in UserUtility.SpiltBySize(fakesUsers, 10000)) { db.Collection("Users").InsertMultiple(userList); } } }
public async Task <PersistedGrant> GetAsync(string key) { using (var database = ArangoDatabase.CreateWithSetting()) { var encodedKey = ToBase64UrlFromString(key); var grant = await database.Collection(_arangoDBConfig.Collections.PersistedGrants) .DocumentAsync <ArangoDBPersistedGrant>(encodedKey); return(new PersistedGrant { Key = grant.GrantKey, ClientId = grant.ClientId, CreationTime = grant.CreationTime, Data = grant.Data, Expiration = grant.Expiration, SubjectId = grant.SubjectId, Type = grant.Type }); } }
internal static async Task Save(object value, string collectionName, string databaseName) { using (var db = ArangoDatabase.CreateWithSetting(databaseName)) { AssertionConcern.AssertStateTrue(await Helper.GraphExists(db), Constants.Messages.Error.GraphNotInitialized); var txnParams = new List <object> { value }; string[] collections = new string[] { collectionName }; // https://docs.arangodb.com/3.1/Manual/Appendix/JavaScriptModules/ArangoDB.html // This 'ArangoDB' module should not be confused with the arangojs JavaScript driver. var r = await db.ExecuteTransactionAsync <object>( new TransactionData() { Collections = new TransactionCollection() { Read = collections, Write = collections }, Action = $@" function (params) {{ const db = require('@arangodb').db; if (db.{collectionName}.exists(params[0])) {{ db.{collectionName}.remove(params[0]); }} db.{collectionName}.save(params[0]); }}", Params = txnParams } ); } }
internal async static Task CreateDatabase(ISettingsService settingsService) { ArangoDatabase.ChangeSetting( settingsService.DatabaseName, s => { s.Database = settingsService.DatabaseName; s.Url = settingsService.DbUrl; s.Credential = new System.Net.NetworkCredential(settingsService.DbUsername, settingsService.DbPassword); s.SystemDatabaseCredential = s.Credential; // this ensures that dates are not parsed during jsonserialization // src/ArangoDB.Client/Serialization/DocumentSerializer.cs - DeserializeSingleResult does not use created serializer // src/ArangoDB.Client/Http/HttpCommand.cs - (line 141) setting EnabledChangeTracking to false ensures that Deserialize is called instead of DeserializeSingleResult s.DisableChangeTracking = true; } ); using (var db = ArangoDatabase.CreateWithSetting(settingsService.DatabaseName)) { if (!(await db.ListDatabasesAsync()).Any(s => s == settingsService.DatabaseName)) { await db.CreateDatabaseAsync(settingsService.DatabaseName); } } }