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();
}
}
