private User GetUser(string email, string passwordMd5) { if (String.IsNullOrEmpty(email)) { throw new ArgumentNullException(nameof(email)); } if (String.IsNullOrEmpty(passwordMd5)) { throw new ArgumentNullException(nameof(passwordMd5)); } DbExpression e = new DbExpression( _ORM.GetColumnName <User>(nameof(User.Id)), DbOperators.GreaterThan, 0); e.PrependAnd(_ORM.GetColumnName <User>(nameof(User.Email)), DbOperators.Equals, email); e.PrependAnd(_ORM.GetColumnName <User>(nameof(User.PasswordMd5)), DbOperators.Equals, passwordMd5); User user = _ORM.SelectFirst <User>(e); if (user != null && user != default(User)) { return(user); } return(null); }
internal void RemoveWriteLock(string url, string userGuid) { if (String.IsNullOrEmpty(url)) { throw new ArgumentNullException(nameof(url)); } DbExpression e = new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.Url)), DbOperators.Equals, url); e.PrependAnd(new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.LockType)), DbOperators.Equals, LockType.Write)); if (!String.IsNullOrEmpty(userGuid)) { e.PrependAnd(new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.UserGUID)), DbOperators.Equals, userGuid)); } List <UrlLock> urlLocks = _ORM.SelectMany <UrlLock>(e); if (urlLocks != null && urlLocks.Count > 0) { foreach (UrlLock curr in urlLocks) { _ORM.Delete <UrlLock>(curr); } } }
internal Obj GetObjectMetadata(string key, long version) { if (String.IsNullOrEmpty(key)) { throw new ArgumentNullException(nameof(key)); } DbExpression eKey = new DbExpression( _ORM.GetColumnName <Obj>(nameof(Obj.Key)), DbOperators.Equals, key); DbExpression eVersion = new DbExpression( _ORM.GetColumnName <Obj>(nameof(Obj.Version)), DbOperators.Equals, version); DbExpression eBucket = new DbExpression( _ORM.GetColumnName <Obj>(nameof(Obj.BucketGUID)), DbOperators.Equals, _Bucket.GUID); eKey.PrependAnd(eVersion); eKey.PrependAnd(eBucket); return(_ORM.SelectFirst <Obj>(eKey)); }
private Entry GetPendingEntryInternal(string accountGuid, string entryGuid) { DbExpression e2 = new DbExpression(_ORM.GetColumnName <Entry>(nameof(Entry.AccountGUID)), DbOperators.Equals, accountGuid); e2.PrependAnd(_ORM.GetColumnName <Entry>(nameof(Entry.IsCommitted)), DbOperators.Equals, false); e2.PrependAnd(_ORM.GetColumnName <Entry>(nameof(Entry.CommittedUtc)), DbOperators.IsNull, null); e2.PrependAnd(_ORM.GetColumnName <Entry>(nameof(Entry.GUID)), DbOperators.Equals, entryGuid); return(_ORM.SelectFirst <Entry>(e2)); }
private List <Entry> GetPendingEntriesInternal(string accountGuid) { DbExpression e = new DbExpression(_ORM.GetColumnName <Entry>(nameof(Entry.AccountGUID)), DbOperators.Equals, accountGuid); e.PrependAnd(_ORM.GetColumnName <Entry>(nameof(Entry.IsCommitted)), DbOperators.Equals, false); e.PrependAnd(_ORM.GetColumnName <Entry>(nameof(Entry.CommittedUtc)), DbOperators.IsNull, null); DbResultOrder[] ro = new DbResultOrder[1]; ro[0] = new DbResultOrder(_ORM.GetColumnName <Entry>(nameof(Entry.CreatedUtc)), DbOrderDirection.Descending); return(_ORM.SelectMany <Entry>(null, null, e, ro)); }
private Permission GetPermission(string apiKey, PermissionType permType, out User user, out ApiKey key) { if (String.IsNullOrEmpty(apiKey)) { throw new ArgumentNullException(nameof(apiKey)); } key = GetApiKey(apiKey, out user); if (key == null || user == null) { return(null); } DbExpression e = new DbExpression( _ORM.GetColumnName <Permission>(nameof(Permission.Id)), DbOperators.GreaterThan, 0); switch (permType) { case PermissionType.Search: e.PrependAnd(new DbExpression(_ORM.GetColumnName <Permission>(nameof(Permission.AllowSearch)), DbOperators.Equals, 1)); break; case PermissionType.CreateDocument: e.PrependAnd(new DbExpression(_ORM.GetColumnName <Permission>(nameof(Permission.AllowCreateDocument)), DbOperators.Equals, 1)); break; case PermissionType.DeleteDocument: e.PrependAnd(new DbExpression(_ORM.GetColumnName <Permission>(nameof(Permission.AllowDeleteDocument)), DbOperators.Equals, 1)); break; case PermissionType.CreateIndex: e.PrependAnd(new DbExpression(_ORM.GetColumnName <Permission>(nameof(Permission.AllowCreateIndex)), DbOperators.Equals, 1)); break; case PermissionType.DeleteIndex: e.PrependAnd(new DbExpression(_ORM.GetColumnName <Permission>(nameof(Permission.AllowDeleteIndex)), DbOperators.Equals, 1)); break; default: throw new ArgumentException("Unknown permission type: " + permType.ToString()); } Permission p = _ORM.SelectFirst <Permission>(e); if (p != null && p != default(Permission)) { return(p); } return(null); }
/// <summary> /// Get document GUIDs that contain supplied terms. /// </summary> /// <param name="terms">List of terms.</param> /// <param name="indexStart">Index of results from which to begin returning records.</param> /// <param name="maxResults">Maximum number of records to return.</param> /// <param name="filter">Database filters.</param> /// <returns>List of document GUIDs.</returns> public List <string> GetDocumentGuidsByTerms(List <string> terms, int?indexStart, int?maxResults, DbExpression filter) { if (terms == null || terms.Count < 1) { throw new ArgumentNullException(nameof(terms)); } List <string> ret = new List <string>(); DbExpression e = new DbExpression(_ORM.GetColumnName <IndexEntry>(nameof(IndexEntry.Term)), DbOperators.In, terms); if (filter != null) { e.PrependAnd(filter); } List <IndexEntry> entries = _ORM.SelectMany <IndexEntry>(indexStart, maxResults, e); if (entries != null && entries.Count > 0) { ret = entries.Select(entry => entry.DocumentGuid).ToList(); ret = ret.Distinct().ToList(); } Log("returning " + ret.Count + " document GUIDs for terms query"); return(ret); }
private void MonitorForExpiredLocks() { while (!_TokenSource.IsCancellationRequested) { DbExpression e = new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.ExpirationUtc)), DbOperators.LessThan, DateTime.Now.ToUniversalTime()); e.PrependAnd(_ORM.GetColumnName <UrlLock>(nameof(UrlLock.ExpirationUtc)), DbOperators.IsNotNull, null); List <UrlLock> expired = _ORM.SelectMany <UrlLock>(e); if (expired != null && expired.Count > 0) { foreach (UrlLock curr in expired) { _Logging.Info(_Header + "lock " + curr.GUID + " expired at " + curr.ExpirationUtc.ToString("s") + ", removing"); _ORM.Delete <UrlLock>(curr); } } Task.Delay(10000).Wait(); } }
internal bool Exists(string userGuid, string name) { if (String.IsNullOrEmpty(userGuid)) { throw new ArgumentNullException(nameof(userGuid)); } if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } DbExpression e = new DbExpression( _ORM.GetColumnName <Container>(nameof(Container.UserGUID)), DbOperators.Equals, userGuid); e.PrependAnd(new DbExpression( _ORM.GetColumnName <Container>(nameof(Container.Name)), DbOperators.Equals, name)); Container container = _ORM.SelectFirst <Container>(e); if (container != null) { return(true); } return(false); }
internal List <ObjectAcl> GetObjectAcl(string key, long version) { if (String.IsNullOrEmpty(key)) { throw new ArgumentNullException(nameof(key)); } Obj obj = GetObjectMetadata(key, version); if (obj == null) { _Logging.Debug("GetAcl unable to find key " + _Bucket.Name + "/" + key + " version " + version); return(null); } DbExpression expr = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.BucketGUID)), DbOperators.Equals, _Bucket.GUID); DbExpression eObj = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.ObjectGUID)), DbOperators.Equals, obj.GUID); expr.PrependAnd(eObj); return(_ORM.SelectMany <ObjectAcl>(expr)); }
internal bool BucketUserAclExists(string userGuid) { if (String.IsNullOrEmpty(userGuid)) { throw new ArgumentNullException(nameof(userGuid)); } DbExpression expr = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.BucketGUID)), DbOperators.Equals, _Bucket.GUID); DbExpression eUser = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.UserGUID)), DbOperators.Equals, userGuid); expr.PrependAnd(eUser); List <BucketAcl> acls = _ORM.SelectMany <BucketAcl>(expr); if (acls != null && acls.Count > 0) { return(true); } return(false); }
internal void DeleteObjectTags(string key, long version) { if (String.IsNullOrEmpty(key)) { throw new ArgumentNullException(nameof(key)); } Obj obj = GetObjectMetadata(key, version); if (obj == null) { _Logging.Debug("Exists unable to find key " + _Bucket.Name + "/" + key + " version " + version); return; } DbExpression eBucket = new DbExpression( _ORM.GetColumnName <ObjectTag>(nameof(ObjectTag.BucketGUID)), DbOperators.Equals, _Bucket.GUID); DbExpression eObj = new DbExpression( _ORM.GetColumnName <ObjectTag>(nameof(ObjectTag.ObjectGUID)), DbOperators.Equals, obj.GUID); eBucket.PrependAnd(eObj); _ORM.DeleteMany <ObjectTag>(eBucket); }
internal void RemoveReadLock(UrlLock urlLock) { if (urlLock == null) { throw new ArgumentNullException(nameof(urlLock)); } DbExpression e = new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.Url)), DbOperators.Equals, urlLock.Url); e.PrependAnd(new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.LockType)), DbOperators.Equals, urlLock.LockType)); List <UrlLock> locks = _ORM.SelectMany <UrlLock>(e); if (locks != null && locks.Count > 0) { foreach (UrlLock curr in locks) { _ORM.Delete <UrlLock>(curr); } } }
internal bool WriteLockExists(string url) { if (String.IsNullOrEmpty(url)) { throw new ArgumentNullException(nameof(url)); } DbExpression e = new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.Url)), DbOperators.Equals, url); e.PrependAnd(new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.LockType)), DbOperators.Equals, LockType.Write)); UrlLock urlLock = _ORM.SelectFirst <UrlLock>(e); if (urlLock != null) { return(true); } return(false); }
internal void DeleteObjectAcl(string key) { if (String.IsNullOrEmpty(key)) { throw new ArgumentNullException(nameof(key)); } Obj obj = GetObjectMetadata(key); if (obj == null) { _Logging.Debug("DeleteAcl unable to find key " + _Bucket.Name + "/" + key); return; } DbExpression expr = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.BucketGUID)), DbOperators.Equals, _Bucket.GUID); DbExpression eObjGuid = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.ObjectGUID)), DbOperators.Equals, obj.GUID); expr.PrependAnd(eObjGuid); _ORM.DeleteMany <ObjectAcl>(expr); }
private ApiKey GetApiKey(string apiKey, out User user) { if (String.IsNullOrEmpty(apiKey)) { throw new ArgumentNullException(nameof(apiKey)); } user = null; DbExpression e = new DbExpression( _ORM.GetColumnName <ApiKey>(nameof(ApiKey.GUID)), DbOperators.Equals, apiKey); e.PrependAnd(_ORM.GetColumnName <ApiKey>(nameof(ApiKey.Active)), DbOperators.Equals, true); ApiKey key = _ORM.SelectFirst <ApiKey>(e); if (key == null || key == default(ApiKey)) { return(null); } e = new DbExpression( _ORM.GetColumnName <User>(nameof(User.GUID)), DbOperators.Equals, key.UserGUID); user = _ORM.SelectFirst <User>(e); if (user == null || user == default(User)) { return(null); } return(key); }
private List <Entry> GetEntriesByGuids(string accountGuid, List <string> guids) { DbExpression e3 = new DbExpression(_ORM.GetColumnName <Entry>(nameof(Entry.AccountGUID)), DbOperators.Equals, accountGuid); e3.PrependAnd(_ORM.GetColumnName <Entry>(nameof(Entry.GUID)), DbOperators.In, guids); return(_ORM.SelectMany <Entry>(e3)); }
/// <summary> /// Retrieve the list of role names to which the user is assigned. /// </summary> /// <param name="username">The name of the user.</param> /// <returns>List of role names.</returns> public List <string> GetUserRoles(string username) { if (String.IsNullOrEmpty(username)) { throw new ArgumentNullException(nameof(username)); } DbExpression e = new DbExpression(_ORM.GetColumnName <UserRole>(nameof(UserRole.Id)), DbOperators.GreaterThan, 0); e.PrependAnd(_ORM.GetColumnName <UserRole>(nameof(UserRole.Username)), DbOperators.Equals, username); List <UserRole> u = _ORM.SelectMany <UserRole>(e); List <string> ret = new List <string>(); if (u.Count > 0) { foreach (UserRole r in u) { ret.Add(r.Rolename); } if (ret.Count > 0) { ret = ret.Distinct().ToList(); } } return(ret); }
internal bool ObjectUserAclExists(string userGuid, string key, long version) { if (String.IsNullOrEmpty(userGuid)) { throw new ArgumentNullException(nameof(userGuid)); } if (String.IsNullOrEmpty(key)) { throw new ArgumentNullException(nameof(key)); } Obj obj = GetObjectMetadata(key, version); if (obj == null) { _Logging.Debug("Exists unable to find key " + _Bucket.Name + "/" + key + " version " + version); return(false); } DbExpression expr = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.BucketGUID)), DbOperators.Equals, _Bucket.GUID); DbExpression eUser = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.UserGUID)), DbOperators.Equals, userGuid); DbExpression eObj = new DbExpression( _ORM.GetColumnName <ObjectAcl>(nameof(ObjectAcl.ObjectGUID)), DbOperators.Equals, obj.GUID); expr.PrependAnd(eUser); expr.PrependAnd(eObj); List <ObjectAcl> acls = _ORM.SelectMany <ObjectAcl>(expr); if (acls != null && acls.Count > 0) { return(true); } return(false); }
/// <summary> /// Determine if a role has permissions defined to access a specified resource using a specific operation. /// </summary> /// <param name="rolename">The name of the role.</param> /// <param name="resource">The resource.</param> /// <param name="operation">The type of operation.</param> /// <returns>True if the role has permissions defined for the specified resource and specified operation.</returns> public bool RolePermissionExists(string rolename, string resource, string operation) { if (String.IsNullOrEmpty(rolename)) { throw new ArgumentNullException(nameof(rolename)); } if (String.IsNullOrEmpty(resource)) { throw new ArgumentNullException(nameof(resource)); } if (String.IsNullOrEmpty(operation)) { throw new ArgumentNullException(nameof(operation)); } DbExpression e = new DbExpression(_ORM.GetColumnName <RolePermission>(nameof(RolePermission.Rolename)), DbOperators.Equals, rolename); e.PrependAnd(_ORM.GetColumnName <RolePermission>(nameof(RolePermission.Resource)), DbOperators.Equals, resource); e.PrependAnd(_ORM.GetColumnName <RolePermission>(nameof(RolePermission.Operation)), DbOperators.Equals, operation); return(_ORM.Exists <RolePermission>(e)); }
/// <summary> /// Remove a permission entry from a role. /// </summary> /// <param name="rolename">The name of the role.</param> /// <param name="resource">The resource.</param> /// <param name="operation">The type of operation.</param> public void RemoveRolePermission(string rolename, string resource, string operation) { if (String.IsNullOrEmpty(rolename)) { throw new ArgumentNullException(nameof(rolename)); } if (String.IsNullOrEmpty(resource)) { throw new ArgumentNullException(nameof(resource)); } if (String.IsNullOrEmpty(operation)) { throw new ArgumentNullException(nameof(operation)); } DbExpression e = new DbExpression(_ORM.GetColumnName <RolePermission>(nameof(RolePermission.Rolename)), DbOperators.Equals, rolename); e.PrependAnd(_ORM.GetColumnName <RolePermission>(nameof(RolePermission.Resource)), DbOperators.Equals, resource); e.PrependAnd(_ORM.GetColumnName <RolePermission>(nameof(RolePermission.Operation)), DbOperators.Equals, operation); _ORM.DeleteMany <RolePermission>(e); }
private List <Account> GetAllAccountsInternal(string searchTerm = null) { DbResultOrder[] ro = new DbResultOrder[1]; ro[0] = new DbResultOrder(_ORM.GetColumnName <Entry>(nameof(Account.CreatedUtc)), DbOrderDirection.Descending); DbExpression e1 = new DbExpression(_ORM.GetColumnName <Account>(nameof(Account.Id)), DbOperators.GreaterThan, 0); if (!String.IsNullOrEmpty(searchTerm)) { e1.PrependAnd(_ORM.GetColumnName <Account>(nameof(Account.Name)), DbOperators.Contains, searchTerm); } return(_ORM.SelectMany <Account>(null, null, e1, ro)); }
internal List <ObjectTag> GetObjectTags(string key, long version) { if (String.IsNullOrEmpty(key)) { throw new ArgumentNullException(nameof(key)); } if (version < 1) { throw new ArgumentException("Version ID must be one or greater."); } Obj obj = GetObjectMetadata(key, version); if (obj == null) { _Logging.Debug("GetTags unable to find key " + _Bucket.Name + "/" + key + " version " + version); return(null); } DbExpression eKey = new DbExpression( _ORM.GetColumnName <Obj>(nameof(Obj.Key)), DbOperators.Equals, key); DbExpression eVersion = new DbExpression( _ORM.GetColumnName <Obj>(nameof(Obj.Version)), DbOperators.Equals, version); DbExpression eBucket = new DbExpression( _ORM.GetColumnName <Obj>(nameof(Obj.BucketGUID)), DbOperators.Equals, _Bucket.GUID); eKey.PrependAnd(eVersion); eKey.PrependAnd(eBucket); return(_ORM.SelectMany <ObjectTag>(eKey)); }
/// <summary> /// List the objects stored in the index. /// </summary> /// <param name="prefix">Prefix upon which to match object keys.</param> /// <param name="indexStart">The index (DedupeObject.Id) from which to begin the enumeration.</param> /// <param name="maxResults">Maximum number of results to retrieve.</param> /// <return>Enumeration result.</return> public override EnumerationResult ListObjects(string prefix, int indexStart, int maxResults) { if (indexStart < 0) { throw new ArgumentException("Starting index must be zero or greater."); } if (maxResults < 1 || maxResults > 100) { throw new ArgumentException("Max results must be greater than zero and less than or equal to 100."); } EnumerationResult ret = new EnumerationResult(prefix, indexStart, indexStart, maxResults, new List <DedupeObject>()); DbExpression e = new DbExpression( _ORM.GetColumnName <DedupeObject>(nameof(DedupeObject.Id)), DbOperators.GreaterThan, indexStart); if (!String.IsNullOrEmpty(prefix)) { e.PrependAnd( _ORM.GetColumnName <DedupeObject>(nameof(DedupeObject.Key)), DbOperators.StartsWith, prefix); } List <DedupeObject> objects = _ORM.SelectMany <DedupeObject>(null, maxResults, e); if (objects != null && objects.Count > 0) { foreach (DedupeObject obj in objects) { obj.Chunks = GetChunks(obj.Key); obj.ObjectMap = GetObjectMap(obj.Key); if (obj.ObjectMap != null && obj.ObjectMap.Count > 0) { obj.ObjectMap = obj.ObjectMap.OrderBy(o => o.ChunkAddress).ToList(); } ret.Objects.Add(obj); } } if (objects != null && objects.Count == maxResults) { ret.NextIndexStart = objects[(objects.Count - 1)].Id; } return(ret); }
internal List <UrlLock> GetWriteLocks() { DbExpression e = new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.Id)), DbOperators.GreaterThan, 0); e.PrependAnd(new DbExpression( _ORM.GetColumnName <UrlLock>(nameof(UrlLock.LockType)), DbOperators.Equals, LockType.Write)); return(_ORM.SelectMany <UrlLock>(e)); }
internal void Delete(string userGuid, string name, bool cleanup) { if (String.IsNullOrEmpty(userGuid)) { throw new ArgumentNullException(nameof(userGuid)); } if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } ContainerClient client = GetContainerClient(userGuid, name); if (client != null) { DbExpression e = new DbExpression( _ORM.GetColumnName <Container>(nameof(Container.UserGUID)), DbOperators.Equals, userGuid); e.PrependAnd(new DbExpression( _ORM.GetColumnName <Container>(nameof(Container.Name)), DbOperators.Equals, name)); Container container = _ORM.SelectFirst <Container>(e); if (container != null) { _ORM.Delete <Container>(container); } if (cleanup) { client.Destroy(); } else { client.Dispose(); } lock (_ContainersLock) { if (_ContainerClients.Contains(client)) { _ContainerClients.Remove(client); } } } }
/// <summary> /// Determine if a user is mapped to a role. /// </summary> /// <param name="username">The name of the user.</param> /// <param name="rolename">The name of the role.</param> /// <returns>True if the user is mapped to the role.</returns> public bool UserRoleExists(string username, string rolename) { if (String.IsNullOrEmpty(username)) { throw new ArgumentNullException(nameof(username)); } if (String.IsNullOrEmpty(rolename)) { throw new ArgumentNullException(nameof(rolename)); } DbExpression e = new DbExpression(_ORM.GetColumnName <UserRole>(nameof(UserRole.Username)), DbOperators.Equals, username); e.PrependAnd(_ORM.GetColumnName <UserRole>(nameof(UserRole.Rolename)), DbOperators.Equals, rolename); return(_ORM.Exists <UserRole>(e)); }
/// <summary> /// Remove a user's mapping to a role. /// </summary> /// <param name="username">The name of the user.</param> /// <param name="rolename">The name of the role.</param> public void RemoveUserRole(string username, string rolename) { if (String.IsNullOrEmpty(username)) { throw new ArgumentNullException(nameof(username)); } if (String.IsNullOrEmpty(rolename)) { throw new ArgumentNullException(nameof(rolename)); } DbExpression e = new DbExpression(_ORM.GetColumnName <UserRole>(nameof(UserRole.Username)), DbOperators.Equals, username); e.PrependAnd(_ORM.GetColumnName <UserRole>(nameof(UserRole.Rolename)), DbOperators.Equals, rolename); _ORM.DeleteMany <UserRole>(e); }
private Entry GetLatestBalanceEntryInternal(string accountGuid) { DbExpression e = new DbExpression(_ORM.GetColumnName <Entry>(nameof(Entry.AccountGUID)), DbOperators.Equals, accountGuid); e.PrependAnd(_ORM.GetColumnName <Entry>(nameof(Entry.Type)), DbOperators.Equals, EntryType.Balance); DbResultOrder[] ro = new DbResultOrder[1]; ro[0] = new DbResultOrder(_ORM.GetColumnName <Entry>(nameof(Entry.CreatedUtc)), DbOrderDirection.Descending); List <Entry> balanceEntries = _ORM.SelectMany <Entry>(null, 1, e, ro); if (balanceEntries != null && balanceEntries.Count == 1) { return(balanceEntries[0]); } return(null); }
internal ContainerClient GetContainerClient(string userGuid, string name) { if (String.IsNullOrEmpty(userGuid)) { throw new ArgumentNullException(nameof(userGuid)); } if (String.IsNullOrEmpty(name)) { throw new ArgumentNullException(nameof(name)); } ContainerClient client = null; lock (_ContainersLock) { client = _ContainerClients.Where(c => c.Container.UserGUID.Equals(userGuid) && c.Container.Name.Equals(name)).FirstOrDefault(); if (client != null && client != default(ContainerClient)) { return(client); } } DbExpression e = new DbExpression( _ORM.GetColumnName <Container>(nameof(Container.UserGUID)), DbOperators.Equals, userGuid); e.PrependAnd(new DbExpression( _ORM.GetColumnName <Container>(nameof(Container.Name)), DbOperators.Equals, name)); Container container = _ORM.SelectFirst <Container>(e); if (container != null) { client = InitializeContainerClient(container); if (client != null) { return(client); } } return(null); }