public static TBEmail[] GetTarget_AccountEmails(TBRAccountRoot accountRoot) { var emails = accountRoot.Account.Emails.CollectionContent.ToArray(); return(emails); }
public static void ExecuteMethod_UpdateAccountToEmails(TBRAccountRoot accountRoot, TBREmailRoot[] accountEmails) { foreach(var accountEmail in accountEmails) { accountEmail.Account = accountRoot.Account; } }
public static void ExecuteMethod_UpdateAccountToLogins(TBRAccountRoot accountRoot, TBRLoginRoot[] accountLogins) { foreach (var accountLogin in accountLogins) { accountLogin.Account = accountRoot.Account; } }
public bool PerformAddOperation(string commandName, InformationSourceCollection sources, string requesterLocation, HttpFileCollection files) { if (GroupName == "") { throw new InvalidDataException("Group name must be given"); } //throw new NotImplementedException("Old implementation not converted to managed group structures"); //AccountContainer container = (AccountContainer) sources.GetDefaultSource(typeof(AccountContainer).FullName).RetrieveInformationObject(); VirtualOwner owner = VirtualOwner.FigureOwner(this); if (owner.ContainerName != "acc") { throw new NotSupportedException("Group creation only supported from account"); } string accountID = owner.LocationPrefix; TBRAccountRoot accountRoot = TBRAccountRoot.RetrieveFromDefaultLocation(accountID); TBAccount account = accountRoot.Account; if (account.Emails.CollectionContent.Count == 0) { throw new InvalidDataException("Account needs to have at least one email address to create a group"); } CreateGroup.Execute(new CreateGroupParameters { AccountID = accountID, GroupName = this.GroupName }); this.GroupName = ""; return(true); }
public static void ExecuteMethod_UpdateAccountContainerMemberships(TBRGroupRoot groupRoot, Group currGroup, GroupSummaryContainer groupSummaryContainer, TBRAccountRoot accountRoot, AccountContainer accountContainer) { string currRootId = groupRoot.Group.ID; string currReferenceUrlPrefix = String.Format("/auth/grp/{0}/", currRootId); var currRoles = accountContainer.AccountModule.Roles; currRoles.MemberInGroups.CollectionContent.RemoveAll( refToInfo => refToInfo.URL.StartsWith(currReferenceUrlPrefix)); currRoles.ModeratorInGroups.CollectionContent.RemoveAll( refToInfo => refToInfo.URL.StartsWith(currReferenceUrlPrefix)); foreach (var acctRole in accountRoot.Account.GroupRoleCollection.CollectionContent.Where(role => role.GroupID == currRootId)) { ReferenceToInformation reference = ReferenceToInformation.CreateDefault(); reference.URL = string.Format("/auth/grp/{0}/website/oip-group/oip-layout-groups-edit.phtml", currRootId); reference.Title = currGroup.GroupName + " - " + acctRole.GroupRole; switch (acctRole.GroupRole.ToLower()) { case "initiator": case "moderator": currRoles.ModeratorInGroups.CollectionContent.Add(reference); break; case "collaborator": case "viewer": currRoles.MemberInGroups.CollectionContent.Add(reference); break; } } currRoles.ModeratorInGroups.CollectionContent.Sort(ReferenceToInformation.CompareByReferenceTitle); currRoles.MemberInGroups.CollectionContent.Sort(ReferenceToInformation.CompareByReferenceTitle); // TODO: Update account summary //accountContainer.AccountSummary.GroupSummary }
public static void ExecuteMethod_SynchronizeLoginGroupRoots(TBRAccountRoot accountRoot, TBRLoginGroupRoot[] loginGroupRoots) { //throw new NotImplementedException(); //TBRLoginGroupRoot loginGroupRoot = TBRLoginGroupRoot.CreateDefault(); //string loginGroupID = TBRLoginGroupRoot.GetLoginGroupID(groupRoleItem.GroupID, loginRootID); var accountLogins = accountRoot.Account.Logins.CollectionContent; var accountGroupRoles = accountRoot.Account.GroupRoleCollection.CollectionContent; List<TBRLoginGroupRoot> currentLoginGroupRoots = new List<TBRLoginGroupRoot>(); foreach (var groupRoleItem in accountGroupRoles.Where(agr => TBCollaboratorRole.IsRoleStatusValidMember(agr.RoleStatus))) { foreach (var loginItem in accountLogins) { string loginRootID = TBLoginInfo.GetLoginIDFromLoginURL(loginItem.OpenIDUrl); string loginGroupID = TBRLoginGroupRoot.GetLoginGroupID(groupRoleItem.GroupID, loginRootID); TBRLoginGroupRoot loginGroupRoot = loginGroupRoots.FirstOrDefault(lgr => lgr.ID == loginGroupID); if (loginGroupRoot == null) { loginGroupRoot = TBRLoginGroupRoot.CreateDefault(); loginGroupRoot.ID = loginGroupID; loginGroupRoot.UpdateRelativeLocationFromID(); } loginGroupRoot.GroupID = groupRoleItem.GroupID; loginGroupRoot.Role = groupRoleItem.GroupRole; currentLoginGroupRoots.Add(loginGroupRoot); } } var loginRootsToDelete = loginGroupRoots. Where(lgr => currentLoginGroupRoots.Exists(currLgr => currLgr.ID == lgr.ID) == false); foreach(var loginRootToDelete in loginRootsToDelete) { loginRootToDelete.DeleteInformationObject(); } foreach (var currLoginRoot in currentLoginGroupRoots) currLoginRoot.StoreInformation(); }
public static TBREmailRoot[] GetTarget_AccountEmails(TBRAccountRoot accountRoot) { var emailIDs = accountRoot.Account.Emails.CollectionContent.Select(email => TBREmailRoot.GetIDFromEmailAddress(email.EmailAddress)); var emailRoots = emailIDs.Select(emailAddress => TBREmailRoot.RetrieveFromDefaultLocation(emailAddress)).ToArray(); return emailRoots; }
public static void ExecuteMethod_UpdateAccountToEmails(TBRAccountRoot accountRoot, TBREmailRoot[] accountEmails) { foreach (var accountEmail in accountEmails) { accountEmail.Account = accountRoot.Account; } }
public static void Execute(UnlinkEmailAddressParameters parameters) { PrepareParameters(parameters); TBRAccountRoot AccountRootBeforeGroupRemoval = UnlinkEmailAddressImplementation.GetTarget_AccountRootBeforeGroupRemoval(parameters.AccountID); string EmailAddress = UnlinkEmailAddressImplementation.GetTarget_EmailAddress(parameters.AccountContainerBeforeGroupRemoval, parameters.EmailAddressID); TBRGroupRoot[] GroupRoots = UnlinkEmailAddressImplementation.GetTarget_GroupRoots(AccountRootBeforeGroupRemoval, EmailAddress); UnlinkEmailAddressImplementation.ExecuteMethod_RemoveGroupMemberships(EmailAddress, GroupRoots); TBRAccountRoot AccountRootAfterGroupRemoval = UnlinkEmailAddressImplementation.GetTarget_AccountRootAfterGroupRemoval(parameters.AccountID); TBREmailRoot EmailRoot = UnlinkEmailAddressImplementation.GetTarget_EmailRoot(EmailAddress); UnlinkEmailAddressImplementation.ExecuteMethod_RemoveEmailFromAccountRoot(AccountRootAfterGroupRemoval, EmailAddress); UnlinkEmailAddressImplementation.ExecuteMethod_DeleteEmailRoot(EmailRoot); UnlinkEmailAddressImplementation.ExecuteMethod_StoreObjects(AccountRootAfterGroupRemoval); { // Local block to allow local naming UpdateAccountContainerFromAccountRootParameters operationParameters = UnlinkEmailAddressImplementation.UpdateAccountContainer_GetParameters(parameters.AccountID); UpdateAccountContainerFromAccountRoot.Execute(operationParameters); } // Local block closing { // Local block to allow local naming UpdateAccountRootToReferencesParameters operationParameters = UnlinkEmailAddressImplementation.UpdateAccountRoot_GetParameters(parameters.AccountID); UpdateAccountRootToReferences.Execute(operationParameters); } // Local block closing }
public static void ExecuteMethod_UpdateAccountToLogins(TBRAccountRoot accountRoot, TBRLoginRoot[] accountLogins) { foreach(var accountLogin in accountLogins) { accountLogin.Account = accountRoot.Account; } }
public static AccountRootAndContainer[] GetTarget_AccountRootsAndContainers(TBRGroupRoot groupRoot) { var accountIDs = groupRoot.Group.Roles.CollectionContent. Select(role => role.Email.EmailAddress). Select(email => { string emailRootID = TBREmailRoot.GetIDFromEmailAddress(email); TBREmailRoot emailRoot = TBREmailRoot.RetrieveFromDefaultLocation(emailRootID); return(emailRoot.Account.ID); }).Distinct().ToArray(); List <AccountRootAndContainer> result = new List <AccountRootAndContainer>(); foreach (var accountID in accountIDs) { TBRAccountRoot accountRoot = TBRAccountRoot.RetrieveFromDefaultLocation(accountID); VirtualOwner owner = new VirtualOwner("acc", accountID); var accountContainer = AccountContainer.RetrieveFromOwnerContent(owner, "default"); AccountRootAndContainer accountRootAndContainer = new AccountRootAndContainer { AccountContainer = accountContainer, AccountRoot = accountRoot }; result.Add(accountRootAndContainer); } return(result.ToArray()); }
public static TBRLoginRoot[] GetTarget_AccountLogins(TBRAccountRoot accountRoot) { var loginRootIDs = accountRoot.Account.Logins.CollectionContent.Select( login => TBLoginInfo.GetLoginIDFromLoginURL(login.OpenIDUrl)).ToArray(); var loginRoots = loginRootIDs.Select(loginID => TBRLoginRoot.RetrieveFromDefaultLocation(loginID)).ToArray(); return loginRoots; }
public static string GetTarget_EmailAddress(TBRGroupRoot groupRoot, TBRAccountRoot accountRoot) { var emailAddresses = accountRoot.Account.Emails.CollectionContent.Select(email => email.EmailAddress).ToArray(); var emailAddress = emailAddresses.First( email => groupRoot.Group.Roles.CollectionContent.Any(role => role.Email.EmailAddress == email)); return emailAddress; }
public static void Execute(UpdateLoginGroupPermissionsParameters parameters) { PrepareParameters(parameters); TBRAccountRoot AccountRoot = UpdateLoginGroupPermissionsImplementation.GetTarget_AccountRoot(parameters.AccountID); TBRLoginGroupRoot[] LoginGroupRoots = UpdateLoginGroupPermissionsImplementation.GetTarget_LoginGroupRoots(AccountRoot); UpdateLoginGroupPermissionsImplementation.ExecuteMethod_SynchronizeLoginGroupRoots(AccountRoot, LoginGroupRoots); }
public static void Execute(UpdateAccountRootGroupMembershipParameters parameters) { PrepareParameters(parameters); TBRAccountRoot AccountRoot = UpdateAccountRootGroupMembershipImplementation.GetTarget_AccountRoot(parameters.AccountID); UpdateAccountRootGroupMembershipImplementation.ExecuteMethod_UpdateAccountRootGroupMemberships(parameters.GroupRoot, AccountRoot); UpdateAccountRootGroupMembershipImplementation.ExecuteMethod_StoreObjects(AccountRoot); }
public static TBREmailRoot[] GetTarget_AccountEmails(TBRAccountRoot accountRoot) { var emailIDs = accountRoot.Account.Emails.CollectionContent.Select(email => TBREmailRoot.GetIDFromEmailAddress(email.EmailAddress)); var emailRoots = emailIDs.Select(emailAddress => TBREmailRoot.RetrieveFromDefaultLocation(emailAddress)).ToArray(); return(emailRoots); }
public static TBRAccountRoot CreateAndStoreNewAccount() { TBRAccountRoot accountRoot = TBRAccountRoot.CreateDefault(); accountRoot.ID = accountRoot.Account.ID; accountRoot.UpdateRelativeLocationFromID(); StorageSupport.StoreInformation(accountRoot); return(accountRoot); }
public static string GetTarget_EmailAddress(TBRGroupRoot groupRoot, TBRAccountRoot accountRoot) { var emailAddresses = accountRoot.Account.Emails.CollectionContent.Select(email => email.EmailAddress).ToArray(); var emailAddress = emailAddresses.First( email => groupRoot.Group.Roles.CollectionContent.Any(role => role.Email.EmailAddress == email)); return(emailAddress); }
public static TBRLoginRoot[] GetTarget_AccountLogins(TBRAccountRoot accountRoot) { var loginRootIDs = accountRoot.Account.Logins.CollectionContent.Select( login => TBLoginInfo.GetLoginIDFromLoginURL(login.OpenIDUrl)).ToArray(); var loginRoots = loginRootIDs.Select(loginID => TBRLoginRoot.RetrieveFromDefaultLocation(loginID)).ToArray(); return(loginRoots); }
public static void Execute(UpdateAccountContainerFromAccountRootParameters parameters) { PrepareParameters(parameters); TBRAccountRoot AccountRoot = UpdateAccountContainerFromAccountRootImplementation.GetTarget_AccountRoot(parameters.AccountID); AccountContainer AccountContainer = UpdateAccountContainerFromAccountRootImplementation.GetTarget_AccountContainer(AccountRoot); UpdateAccountContainerFromAccountRootImplementation.ExecuteMethod_UpdateAccountContainerLogins(AccountRoot, AccountContainer); UpdateAccountContainerFromAccountRootImplementation.ExecuteMethod_UpdateAccountContainerEmails(AccountRoot, AccountContainer); UpdateAccountContainerFromAccountRootImplementation.ExecuteMethod_StoreObjects(AccountContainer); }
public static TBRAccountRoot GetTarget_AccountRoot(string accountID) { var accountRoot = TBRAccountRoot.RetrieveFromDefaultLocation(accountID); if (accountRoot == null) { throw new InvalidDataException("AccountRoot not found for: " + accountID); } return(accountRoot); }
public static TBRGroupRoot[] GetTarget_GroupRoots(TBRAccountRoot accountRoot, string emailAddress) { var groupIDs = accountRoot.Account.GroupRoleCollection.CollectionContent.Select(grpRole => grpRole.GroupID).ToArray(); var groups = groupIDs.Select(groupID => TBRGroupRoot.RetrieveFromDefaultLocation(groupID)).ToArray(); var groupsContainingEmail = groups.Where( grp => grp.Group.Roles.CollectionContent.Any(role => role.Email.EmailAddress == emailAddress)). ToArray(); return groupsContainingEmail; }
public static void Execute(UpdateAccountRootToReferencesParameters parameters) { PrepareParameters(parameters); TBRAccountRoot AccountRoot = UpdateAccountRootToReferencesImplementation.GetTarget_AccountRoot(parameters.AccountID); TBRLoginRoot[] AccountLogins = UpdateAccountRootToReferencesImplementation.GetTarget_AccountLogins(AccountRoot); TBREmailRoot[] AccountEmails = UpdateAccountRootToReferencesImplementation.GetTarget_AccountEmails(AccountRoot); UpdateAccountRootToReferencesImplementation.ExecuteMethod_UpdateAccountToLogins(AccountRoot, AccountLogins); UpdateAccountRootToReferencesImplementation.ExecuteMethod_UpdateAccountToEmails(AccountRoot, AccountEmails); UpdateAccountRootToReferencesImplementation.ExecuteMethod_StoreObjects(AccountLogins, AccountEmails); }
public static AccountContainer GetTarget_AccountContainer(TBRAccountRoot accountRoot) { TBAccount account = accountRoot.Account; AccountContainer accountContainer = AccountContainer.RetrieveFromOwnerContent(account, "default"); if (accountContainer == null) { accountContainer = AccountContainer.CreateDefault(); accountContainer.SetLocationAsOwnerContent(account, "default"); } return accountContainer; }
public static string GetTarget_MemberEmailAddress(string emailAddress, TBRAccountRoot accountRoot, TBRGroupRoot groupRoot) { if (emailAddress != null) return emailAddress; var groupEmails = groupRoot.Group.Roles.CollectionContent.Select(role => role.Email.EmailAddress).ToArray(); var matchingEmail = accountRoot.Account.Emails.CollectionContent.FirstOrDefault( email => groupEmails.Contains(email.EmailAddress)); if(matchingEmail == null) throw new InvalidDataException("Account email not found on group in RemoveMemberFromGroupImplementation"); return matchingEmail.EmailAddress; }
public static TBRGroupRoot[] GetTarget_GroupRoots(TBRAccountRoot accountRoot, string emailAddress) { var groupIDs = accountRoot.Account.GroupRoleCollection.CollectionContent.Select(grpRole => grpRole.GroupID).ToArray(); var groups = groupIDs.Select(groupID => TBRGroupRoot.RetrieveFromDefaultLocation(groupID)).ToArray(); var groupsContainingEmail = groups.Where( grp => grp.Group.Roles.CollectionContent.Any(role => role.Email.EmailAddress == emailAddress)). ToArray(); return(groupsContainingEmail); }
public static AccountContainer GetTarget_AccountContainer(TBRAccountRoot accountRoot) { TBAccount account = accountRoot.Account; AccountContainer accountContainer = AccountContainer.RetrieveFromOwnerContent(account, "default"); if (accountContainer == null) { accountContainer = AccountContainer.CreateDefault(); accountContainer.SetLocationAsOwnerContent(account, "default"); } return(accountContainer); }
public static void ExecuteMethod_RemoveEmailAddressesFromAccountToBeMerged(TBRAccountRoot accountToBeMerged) { var accountID = accountToBeMerged.ID; var emailAddresses = accountToBeMerged.Account.Emails.CollectionContent.Select(emObj => emObj.EmailAddress).ToArray(); foreach (string emailAddress in emailAddresses) { UnregisterEmailAddress.Execute(new UnregisterEmailAddressParameters { AccountID = accountID, EmailAddress = emailAddress }); } }
public static void ExecuteMethod_RemoveAccountToBeMergedFromAllGroups(TBRAccountRoot accountToBeMerged, TBAccountCollaborationGroup[] groupAccessToBeMerged) { var accountID = accountToBeMerged.ID; var groupIDs = groupAccessToBeMerged.Select(colGrp => colGrp.GroupID).ToArray(); foreach (var groupID in groupIDs) { RemoveMemberFromGroup.Execute(new RemoveMemberFromGroupParameters { AccountID = accountID, GroupID = groupID }); } }
public static void Execute(UpdateAccountContainersGroupMembershipParameters parameters) { PrepareParameters(parameters); GroupContainer GroupContainer = UpdateAccountContainersGroupMembershipImplementation.GetTarget_GroupContainer(parameters.GroupRoot); Group Group = UpdateAccountContainersGroupMembershipImplementation.GetTarget_Group(GroupContainer); TBRAccountRoot AccountRoot = UpdateAccountContainersGroupMembershipImplementation.GetTarget_AccountRoot(parameters.AccountID); AccountContainer AccountContainer = UpdateAccountContainersGroupMembershipImplementation.GetTarget_AccountContainer(parameters.AccountID); GroupSummaryContainer GroupSummaryContainer = UpdateAccountContainersGroupMembershipImplementation.GetTarget_GroupSummaryContainer(parameters.AccountID); UpdateAccountContainersGroupMembershipImplementation.ExecuteMethod_UpdateGroupSummaryContainerMemberships(parameters.GroupRoot, Group, AccountRoot, GroupSummaryContainer); UpdateAccountContainersGroupMembershipImplementation.ExecuteMethod_UpdateAccountContainerMemberships(parameters.GroupRoot, Group, GroupSummaryContainer, AccountRoot, AccountContainer); UpdateAccountContainersGroupMembershipImplementation.ExecuteMethod_StoreObjects(AccountContainer, GroupSummaryContainer); }
public static void Execute(RemoveMemberFromGroupParameters parameters) { PrepareParameters(parameters); TBRGroupRoot GroupRoot = RemoveMemberFromGroupImplementation.GetTarget_GroupRoot(parameters.GroupID); string AccountIDOfEmail = RemoveMemberFromGroupImplementation.GetTarget_AccountIDOfEmail(parameters.EmailAddress, parameters.AccountID); TBRAccountRoot AccountRoot = RemoveMemberFromGroupImplementation.GetTarget_AccountRoot(AccountIDOfEmail); string MemberEmailAddress = RemoveMemberFromGroupImplementation.GetTarget_MemberEmailAddress(parameters.EmailAddress, AccountRoot, GroupRoot); RemoveMemberFromGroupImplementation.ExecuteMethod_RemoveMemberFromGroup(MemberEmailAddress, GroupRoot); RemoveMemberFromGroupImplementation.ExecuteMethod_StoreObjects(GroupRoot); { // Local block to allow local naming RefreshAccountGroupMembershipsParameters operationParameters = RemoveMemberFromGroupImplementation.RefreshAccountAndGroupContainers_GetParameters(GroupRoot, AccountIDOfEmail); RefreshAccountGroupMemberships.Execute(operationParameters); } // Local block closing }
public static void Execute(CreateGroupParameters parameters) { PrepareParameters(parameters); TBRGroupRoot GroupRoot = CreateGroupImplementation.GetTarget_GroupRoot(parameters.GroupName); TBRAccountRoot AccountRoot = CreateGroupImplementation.GetTarget_AccountRoot(parameters.AccountID); TBEmail[] AccountEmails = CreateGroupImplementation.GetTarget_AccountEmails(AccountRoot); CreateGroupImplementation.ExecuteMethod_AddAsInitiatorToGroupRoot(GroupRoot, AccountEmails); CreateGroupImplementation.ExecuteMethod_StoreObjects(GroupRoot); CreateGroupImplementation.ExecuteMethod_InitializeGroupContentAndMasters(GroupRoot); { // Local block to allow local naming RefreshAccountGroupMembershipsParameters operationParameters = CreateGroupImplementation.RefreshAccountAndGroupContainers_GetParameters(parameters.AccountID, GroupRoot); RefreshAccountGroupMemberships.Execute(operationParameters); } // Local block closing }
public static void ExecuteMethod_UpdateGroupSummaryContainerMemberships(TBRGroupRoot groupRoot, Group currGroup, TBRAccountRoot accountRoot, GroupSummaryContainer groupSummaryContainer) { string currRootId = groupRoot.Group.ID; string currGroupID = currGroup.ID; bool isMember = accountRoot.Account.GroupRoleCollection.CollectionContent.Exists( grp => grp.GroupID == currRootId); groupSummaryContainer.GroupCollection.CollectionContent.RemoveAll( grp => grp.ID == currGroupID); if(isMember) { groupSummaryContainer.GroupCollection.CollectionContent.Add(currGroup); currGroup.UpdateReferenceToInformation(currRootId); } groupSummaryContainer.GroupCollection.CollectionContent.Sort(Group.CompareByGroupName); }
public static string GetTarget_MemberEmailAddress(string emailAddress, TBRAccountRoot accountRoot, TBRGroupRoot groupRoot) { if (emailAddress != null) { return(emailAddress); } var groupEmails = groupRoot.Group.Roles.CollectionContent.Select(role => role.Email.EmailAddress).ToArray(); var matchingEmail = accountRoot.Account.Emails.CollectionContent.FirstOrDefault( email => groupEmails.Contains(email.EmailAddress)); if (matchingEmail == null) { throw new InvalidDataException("Account email not found on group in RemoveMemberFromGroupImplementation"); } return(matchingEmail.EmailAddress); }
public static void ExecuteMethod_AddEmailAddressesToPrimaryAccount(TBRAccountRoot primaryAccountToStay, TBEmail[] emailAddressesToBeMerged) { primaryAccountToStay.Account.Emails.CollectionContent.AddRange(emailAddressesToBeMerged); foreach (var email in emailAddressesToBeMerged) { string emailRootID = TBREmailRoot.GetIDFromEmailAddress(email.EmailAddress); TBREmailRoot emailRoot = TBREmailRoot.RetrieveFromDefaultLocation(emailRootID); if (emailRoot == null) { emailRoot = TBREmailRoot.CreateDefault(); emailRoot.ID = emailRootID; emailRoot.UpdateRelativeLocationFromID(); } emailRoot.Account = primaryAccountToStay.Account; StorageSupport.StoreInformation(emailRoot); } }
public static TBRLoginGroupRoot[] GetTarget_LoginGroupRoots(TBRAccountRoot accountRoot) { var openIDUrlsWithoutHttps = accountRoot.Account.Logins.CollectionContent.Select(login => login.OpenIDUrl.Substring(HttpsPrefixLength)).OrderBy(str => str). ToArray(); var blobList = StorageSupport.CurrActiveContainer.ListBlobsWithPrefix(SearchPrefix, new BlobRequestOptions() {UseFlatBlobListing = true}); List<CloudBlockBlob> foundBlobs = new List<CloudBlockBlob>(); foreach(CloudBlockBlob blob in blobList) { string loginPartName = blob.Name.Substring(LoginStartIndex); int foundIndex = Array.BinarySearch(openIDUrlsWithoutHttps, loginPartName); if(foundIndex >= 0) foundBlobs.Add(blob); } return foundBlobs.Select(blob => TBRLoginGroupRoot.RetrieveTBRLoginGroupRoot(blob.Name)).ToArray(); }
public static void Execute(AssignCollaboratorRoleParameters parameters) { PrepareParameters(parameters); TBRGroupRoot GroupRoot = AssignCollaboratorRoleImplementation.GetTarget_GroupRoot(parameters.GroupID); Collaborator Collaborator = AssignCollaboratorRoleImplementation.GetTarget_Collaborator(parameters.GroupContainer, parameters.CollaboratorID); string AccountID = AssignCollaboratorRoleImplementation.GetTarget_AccountID(Collaborator); TBRAccountRoot AccountRoot = AssignCollaboratorRoleImplementation.GetTarget_AccountRoot(AccountID); string EmailAddress = AssignCollaboratorRoleImplementation.GetTarget_EmailAddress(GroupRoot, AccountRoot); TBCollaboratorRole TBCollaboratorRole = AssignCollaboratorRoleImplementation.GetTarget_TBCollaboratorRole(GroupRoot, EmailAddress); AssignCollaboratorRoleImplementation.ExecuteMethod_AssignCollaboratorRole(parameters.RoleToAssign, TBCollaboratorRole); AssignCollaboratorRoleImplementation.ExecuteMethod_StoreObjects(GroupRoot); { // Local block to allow local naming RefreshAccountGroupMembershipsParameters operationParameters = AssignCollaboratorRoleImplementation.RefreshAccountAndGroupContainers_GetParameters(GroupRoot, AccountID); RefreshAccountGroupMemberships.Execute(operationParameters); } // Local block closing }
public static TBRLoginRoot GetOrCreateLoginRootWithAccount(string loginUrl, bool isAccountRequest) { string loginRootID = TBLoginInfo.GetLoginIDFromLoginURL(loginUrl); var loginRoot = RetrieveFromDefaultLocation(loginRootID); if (loginRoot == null) { // Storing loginroot loginRoot = TBRLoginRoot.CreateDefault(); loginRoot.ID = loginRootID; loginRoot.UpdateRelativeLocationFromID(); StorageSupport.StoreInformation(loginRoot); // Creating login info for account and storing the account TBLoginInfo loginInfo = TBLoginInfo.CreateDefault(); loginInfo.OpenIDUrl = loginUrl; TBRAccountRoot accountRoot = TBRAccountRoot.CreateAndStoreNewAccount(); accountRoot.Account.Logins.CollectionContent.Add(loginInfo); string accountID = accountRoot.ID; accountRoot.StoreInformation(); UpdateAccountRootToReferences.Execute(new UpdateAccountRootToReferencesParameters { AccountID = accountID }); UpdateAccountContainerFromAccountRoot.Execute(new UpdateAccountContainerFromAccountRootParameters { AccountID = accountID }); // If this request is for account, we propagate the pages immediately bool useBackgroundWorker = isAccountRequest == false; RenderWebSupport.RefreshAccountTemplates(accountRoot.ID, useBackgroundWorker); if (isAccountRequest) { accountRoot.Account.InitializeAndConnectMastersAndCollections(); } } loginRoot = RetrieveFromDefaultLocation(loginRootID); return(loginRoot); }
public static void ExecuteMethod_UpdateAccountRootGroupMemberships(TBRGroupRoot groupRoot, TBRAccountRoot accountRoot) { string[] accountEmailAddresses = accountRoot.Account.Emails.CollectionContent.Select(email => email.EmailAddress).ToArray(); var accountRoles = groupRoot.Group.Roles.CollectionContent.Where( role => accountEmailAddresses.Contains(role.Email.EmailAddress)).ToArray(); accountRoot.Account.GroupRoleCollection.CollectionContent.RemoveAll( currRole => currRole.GroupID == groupRoot.Group.ID); var acctCollaborationRoles = accountRoles. Select(grpRole => { TBAccountCollaborationGroup acctGroup = TBAccountCollaborationGroup.CreateDefault(); acctGroup.GroupID = groupRoot.Group.ID; acctGroup.GroupRole = grpRole.Role; acctGroup.RoleStatus = grpRole.RoleStatus; return acctGroup; }); accountRoot.Account.GroupRoleCollection.CollectionContent.AddRange(acctCollaborationRoles); }
public static void ExecuteMethod_SynchronizeLoginGroupRoots(TBRAccountRoot accountRoot, TBRLoginGroupRoot[] loginGroupRoots) { //throw new NotImplementedException(); //TBRLoginGroupRoot loginGroupRoot = TBRLoginGroupRoot.CreateDefault(); //string loginGroupID = TBRLoginGroupRoot.GetLoginGroupID(groupRoleItem.GroupID, loginRootID); var accountLogins = accountRoot.Account.Logins.CollectionContent; var accountGroupRoles = accountRoot.Account.GroupRoleCollection.CollectionContent; List <TBRLoginGroupRoot> currentLoginGroupRoots = new List <TBRLoginGroupRoot>(); foreach (var groupRoleItem in accountGroupRoles.Where(agr => TBCollaboratorRole.IsRoleStatusValidMember(agr.RoleStatus))) { foreach (var loginItem in accountLogins) { string loginRootID = TBLoginInfo.GetLoginIDFromLoginURL(loginItem.OpenIDUrl); string loginGroupID = TBRLoginGroupRoot.GetLoginGroupID(groupRoleItem.GroupID, loginRootID); TBRLoginGroupRoot loginGroupRoot = loginGroupRoots.FirstOrDefault(lgr => lgr.ID == loginGroupID); if (loginGroupRoot == null) { loginGroupRoot = TBRLoginGroupRoot.CreateDefault(); loginGroupRoot.ID = loginGroupID; loginGroupRoot.UpdateRelativeLocationFromID(); } loginGroupRoot.GroupID = groupRoleItem.GroupID; loginGroupRoot.Role = groupRoleItem.GroupRole; currentLoginGroupRoots.Add(loginGroupRoot); } } var loginRootsToDelete = loginGroupRoots. Where(lgr => currentLoginGroupRoots.Exists(currLgr => currLgr.ID == lgr.ID) == false); foreach (var loginRootToDelete in loginRootsToDelete) { loginRootToDelete.DeleteInformationObject(); } foreach (var currLoginRoot in currentLoginGroupRoots) { currLoginRoot.StoreInformation(); } }
public static TBRLoginGroupRoot[] GetTarget_LoginGroupRoots(TBRAccountRoot accountRoot) { var openIDUrlsWithoutHttps = accountRoot.Account.Logins.CollectionContent.Select(login => login.OpenIDUrl.Substring(HttpsPrefixLength)).OrderBy(str => str). ToArray(); var blobList = StorageSupport.CurrActiveContainer.ListBlobsWithPrefix(SearchPrefix, new BlobRequestOptions() { UseFlatBlobListing = true }); List <CloudBlockBlob> foundBlobs = new List <CloudBlockBlob>(); foreach (CloudBlockBlob blob in blobList) { string loginPartName = blob.Name.Substring(LoginStartIndex); int foundIndex = Array.BinarySearch(openIDUrlsWithoutHttps, loginPartName); if (foundIndex >= 0) { foundBlobs.Add(blob); } } return(foundBlobs.Select(blob => TBRLoginGroupRoot.RetrieveTBRLoginGroupRoot(blob.Name)).ToArray()); }
public static void ExecuteMethod_AddPrimaryAccountToAllGroupsWhereItsMissing(TBRAccountRoot primaryAccountToStay, TBAccountCollaborationGroup[] groupAccessToBeMerged) { string memberEmailAddress = primaryAccountToStay.Account.Emails.CollectionContent.FirstOrDefault().EmailAddress; foreach (var groupAccess in groupAccessToBeMerged) { TBRGroupRoot groupRoot = TBRGroupRoot.RetrieveFromDefaultLocation(groupAccess.GroupID); TBCollaboratorRole role = groupRoot.Group.Roles.CollectionContent.FirstOrDefault( candidate => candidate.Email.EmailAddress == memberEmailAddress); if (role != null) { continue; } else { role = TBCollaboratorRole.CreateDefault(); role.Email.EmailAddress = memberEmailAddress; role.Role = TBCollaboratorRole.CollaboratorRoleValue; role.SetRoleAsMember(); groupRoot.Group.Roles.CollectionContent.Add(role); } groupRoot.StoreInformation(); } }
public static void ExecuteMethod_AddLoginsToPrimaryAccount(TBRAccountRoot primaryAccountToStay, TBLoginInfo[] loginAccessToBeMerged) { primaryAccountToStay.Account.Logins.CollectionContent.AddRange(loginAccessToBeMerged); }
public static TBEmail[] GetTarget_AccountEmails(TBRAccountRoot accountRoot) { var emails = accountRoot.Account.Emails.CollectionContent.ToArray(); return emails; }
public static void ExecuteMethod_RemoveEmailFromAccountRoot(TBRAccountRoot accountRoot, string emailAddress) { accountRoot.Account.Emails.CollectionContent.RemoveAll(email => email.EmailAddress == emailAddress); }
public static void ExecuteMethod_StorePrimaryAccount(TBRAccountRoot primaryAccountToStay) { primaryAccountToStay.StoreInformation(); }
public static void ExecuteMethod_UpdateAccountContainerLogins(TBRAccountRoot accountRoot, AccountContainer accountContainer) { accountContainer.AccountModule.Security.LoginInfoCollection = accountRoot.Account.Logins; }
public static void ExecuteMethod_StoreObjects(TBRAccountRoot accountRoot) { accountRoot.StoreInformation(); }
public static TBLoginInfo[] GetTarget_LoginAccessToBeMerged(TBRAccountRoot accountToBeMerged) { return accountToBeMerged.Account.Logins.CollectionContent.ToArray(); }
public static void ExecuteMethod_UpdateAccountContainerEmails(TBRAccountRoot accountRoot, AccountContainer accountContainer) { accountContainer.AccountModule.Security.EmailCollection = accountRoot.Account.Emails; }
public static void ExecuteMethod_UpdateGroupSummaryContainerMemberships(TBRGroupRoot groupRoot, Group currGroup, TBRAccountRoot accountRoot, GroupSummaryContainer groupSummaryContainer) { string currRootId = groupRoot.Group.ID; string currGroupID = currGroup.ID; bool isMember = accountRoot.Account.GroupRoleCollection.CollectionContent.Exists( grp => grp.GroupID == currRootId); groupSummaryContainer.GroupCollection.CollectionContent.RemoveAll( grp => grp.ID == currGroupID); if (isMember) { groupSummaryContainer.GroupCollection.CollectionContent.Add(currGroup); currGroup.UpdateReferenceToInformation(currRootId); } groupSummaryContainer.GroupCollection.CollectionContent.Sort(Group.CompareByGroupName); }
public static void ExecuteMethod_StoreObjects(TBRAccountRoot accountRoot) { accountRoot.StoreInformation(); }
public static TBAccountCollaborationGroup[] GetTarget_GroupInitiatorAccessToBeTransfered(TBRAccountRoot accountToBeMerged) { var initiatorRights = accountToBeMerged.Account.GroupRoleCollection.CollectionContent .Where(grpRole => TBCollaboratorRole.HasInitiatorRights(grpRole.GroupRole)) .ToArray(); return initiatorRights; }
public static TBAccountCollaborationGroup[] GetTarget_GroupAccessToBeMerged(TBRAccountRoot accountToBeMerged) { var nonInitiatorRigths = accountToBeMerged.Account.GroupRoleCollection.CollectionContent .Where(grpRole => TBCollaboratorRole.HasInitiatorRights(grpRole.GroupRole) == false) .ToArray(); return nonInitiatorRigths; }
public static TBEmail[] GetTarget_EmailAddressesToBeMerged(TBRAccountRoot accountToBeMerged) { return accountToBeMerged.Account.Emails.CollectionContent.ToArray(); }
public static TBRAccountRoot GetTarget_AccountRoot(string accountID) { return(TBRAccountRoot.RetrieveFromDefaultLocation(accountID)); }
public static void ExecuteMethod_UpdateAccountRootGroupMemberships(TBRGroupRoot groupRoot, TBRAccountRoot accountRoot) { string[] accountEmailAddresses = accountRoot.Account.Emails.CollectionContent.Select(email => email.EmailAddress).ToArray(); var accountRoles = groupRoot.Group.Roles.CollectionContent.Where( role => accountEmailAddresses.Contains(role.Email.EmailAddress)).ToArray(); accountRoot.Account.GroupRoleCollection.CollectionContent.RemoveAll( currRole => currRole.GroupID == groupRoot.Group.ID); var acctCollaborationRoles = accountRoles. Select(grpRole => { TBAccountCollaborationGroup acctGroup = TBAccountCollaborationGroup.CreateDefault(); acctGroup.GroupID = groupRoot.Group.ID; acctGroup.GroupRole = grpRole.Role; acctGroup.RoleStatus = grpRole.RoleStatus; return(acctGroup); }); accountRoot.Account.GroupRoleCollection.CollectionContent.AddRange(acctCollaborationRoles); }
public static TBRAccountRoot GetOwningAccountRoot(IInformationObject informationObject) { string accountID = StorageSupport.GetAccountIDFromLocation(informationObject.RelativeLocation); return(TBRAccountRoot.RetrieveFromDefaultLocation(accountID)); }
public static void ExecuteMethod_RemoveLoginsFromAccountToBeMerged(TBRAccountRoot accountToBeMerged) { var loginURLs = accountToBeMerged.Account.Logins.CollectionContent.Select(login => login.OpenIDUrl).ToArray(); var loginIDs = loginURLs.Select(loginURL => TBLoginInfo.GetLoginIDFromLoginURL(loginURL)).ToArray(); foreach (var loginID in loginIDs) { var loginRoot = TBRLoginRoot.RetrieveFromDefaultLocation(loginID); // Don't delete account login roots - as they're going to be merged later on //loginRoot.DeleteInformationObject(); } }