/// <summary>
/// Helper method to generate the URL needed to contact Confluence.
/// The display way might be nicer.
/// </summary>
/// <param name="confluenceClient">IUserDomain</param>
/// <param name="isCloudServer">boll with some information</param>
/// <param name="userIdentifier">IUserDomain</param>
/// <param name="segments">params with strings</param>
/// <returns>Uri</returns>
private static Uri CreateUserWatchUri(this IUserDomain confluenceClient, bool isCloudServer, IUserIdentifier userIdentifier, params object[] segments)
{
var userWatchContentUri = confluenceClient.ConfluenceApiUri
.AppendSegments("user", "watch")
.AppendSegments(segments);
// If there is no specified accountId, the current user is used
if (userIdentifier == null)
{
return(userWatchContentUri);
}
if (isCloudServer)
{
// Check the account id value.
if (string.IsNullOrEmpty(userIdentifier.AccountId))
{
throw new ArgumentNullException(nameof(userIdentifier), "It seems that there is no account ID supplied.");
}
userWatchContentUri = userWatchContentUri.ExtendQuery("accountId", userIdentifier.AccountId);
}
else
{
// Check the username value.
if (string.IsNullOrEmpty(userIdentifier.Username))
{
throw new ArgumentNullException(nameof(userIdentifier), "It seems that there is no username supplied.");
}
userWatchContentUri = userWatchContentUri.ExtendQuery("username", userIdentifier.Username);
}
return(userWatchContentUri);
}
public static void ToUserDomain(User user, IUserDomain userDomain)
{
userDomain.Id = user.Id;
userDomain.Address = user.Address?.Trim();
userDomain.LastName = user.LastName?.Trim();
userDomain.Name = user.Name?.Trim();
}
/// <summary>
/// Initiate controller with injectors.
/// </summary>
/// <param name="unitOfWork"></param>
/// <param name="mapper"></param>
/// <param name="baseTimeService"></param>
/// <param name="relationalDbService"></param>
/// <param name="encryptionService"></param>
/// <param name="profileService"></param>
/// <param name="systemBaseTimeService"></param>
/// <param name="externalAuthenticationService"></param>
/// <param name="sendMailService"></param>
/// <param name="emailCacheService"></param>
/// <param name="jwtConfigurationOptions"></param>
/// <param name="applicationSettings"></param>
/// <param name="logger"></param>
/// <param name="vgyService"></param>
/// <param name="profileCacheService"></param>
/// <param name="captchaService"></param>
/// <param name="realTimeService"></param>
/// <param name="userDomain"></param>
public UserController(
IAppUnitOfWork unitOfWork,
IMapper mapper,
IBaseTimeService baseTimeService,
IBaseRelationalDbService relationalDbService,
IBaseEncryptionService encryptionService,
IAppProfileService profileService,
IBaseTimeService systemBaseTimeService,
IExternalAuthenticationService externalAuthenticationService,
ISendMailService sendMailService,
IEmailCacheService emailCacheService,
IOptions <AppJwtModel> jwtConfigurationOptions,
IOptions <ApplicationSetting> applicationSettings,
ILogger <UserController> logger,
IVgyService vgyService,
IBaseKeyValueCacheService <int, User> profileCacheService,
ICaptchaService captchaService,
IUserDomain userDomain) : base(
unitOfWork, mapper, baseTimeService,
relationalDbService, profileService)
{
_logger = logger;
_profileService = profileService;
_sendMailService = sendMailService;
_emailCacheService = emailCacheService;
_captchaService = captchaService;
_userDomain = userDomain;
}
/// <summary>
/// Returns a list of users that match the search string.
/// This resource cannot be accessed anonymously.
/// See: https://docs.atlassian.com/jira/REST/latest/#api/2/user-findUsers
/// </summary>
/// <param name="jiraClient">IWorkDomain to bind the extension method to</param>
/// <param name="query">A query string used to search username, name or e-mail address</param>
/// <param name="startAt"></param>
/// <param name="maxResults">Maximum number of results returned, default is 20</param>
/// <param name="includeActive">If true, then active users are included in the results (default true)</param>
/// <param name="includeInactive">If true, then inactive users are included in the results (default false)</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>SearchResults</returns>
public static async Task <IList <User> > SearchAsync(this IUserDomain jiraClient, string query, bool includeActive = true, bool includeInactive = false, int startAt = 0,
int maxResults = 20, CancellationToken cancellationToken = default)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
Log.Debug().WriteLine("Search user {0}", query);
jiraClient.Behaviour.MakeCurrent();
var searchUri = jiraClient.JiraRestUri.AppendSegments("user", "search").ExtendQuery(new Dictionary <string, object>
{
{
"username", query
},
{
"includeActive", includeActive
},
{
"includeInactive", includeInactive
},
{
"startAt", startAt
},
{
"maxResults", maxResults
}
});
var response = await searchUri.GetAsAsync <HttpResponse <IList <User>, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Get user information, introduced with 6.6
/// See: https://docs.atlassian.com/confluence/REST/latest/#user-getUser
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="userIdentifier">IUserIdentifier</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>User</returns>
public static async Task <User> GetUserAsync(this IUserDomain confluenceClient, IUserIdentifier userIdentifier, CancellationToken cancellationToken = default)
{
if (userIdentifier == null)
{
throw new ArgumentNullException(nameof(userIdentifier));
}
var userUri = confluenceClient.ConfluenceApiUri
.AppendSegments("user");
bool isCloudServer = await confluenceClient.IsCloudServer(cancellationToken);
if (isCloudServer)
{
if (string.IsNullOrEmpty(userIdentifier.AccountId))
{
throw new ArgumentNullException(nameof(userIdentifier));
}
userUri = userUri.ExtendQuery("accountId", userIdentifier.AccountId);
}
else
{
if (string.IsNullOrEmpty(userIdentifier.Username))
{
throw new ArgumentNullException(nameof(userIdentifier));
}
userUri = userUri.ExtendQuery("username", userIdentifier.Username);
}
confluenceClient.Behaviour.MakeCurrent();
var response = await userUri.GetAsAsync <HttpResponse <User, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Add the user to the list of users watching the specified space
/// See: https://developer.atlassian.com/cloud/confluence/rest/#api-api-user-watch-space-spaceKey-get
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="spaceKey">string with the space key</param>
/// <param name="userIdentifier">IUserIdentifier for the user (account id), null for the current user</param>
/// <param name="cancellationToken">CancellationToken</param>
public static async Task AddSpaceWatcher(this IUserDomain confluenceClient, string spaceKey, IUserIdentifier userIdentifier = null, CancellationToken cancellationToken = default)
{
if (string.IsNullOrEmpty(spaceKey))
{
throw new ArgumentNullException(nameof(spaceKey));
}
bool isCloudServer = await confluenceClient.IsCloudServer(cancellationToken);
var userWatchSpaceUri = CreateUserWatchUri(confluenceClient, isCloudServer, userIdentifier, "space", spaceKey);
confluenceClient.Behaviour.MakeCurrent();
var response = await userWatchSpaceUri.PostAsync <HttpResponseWithError <Error> >(null, cancellationToken : cancellationToken).ConfigureAwait(false);
if (isCloudServer)
{
// Expect a 204, which is NoContent for the Cloud Server
response.HandleStatusCode(HttpStatusCode.NoContent);
}
else
{
// Expect a 200 for Confluence server
response.HandleStatusCode(HttpStatusCode.OK);
}
}
/// <summary>
/// Retrieves the settings for the specified user
/// </summary>
/// <param name="bitbucketClient">IUserDomain to pin the extension method to</param>
/// <param name="userSlug">Slug from the User object</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>IDictionary with name value pairs</returns>
public static async Task <IDictionary <string, object> > GetSettingsAsync(this IUserDomain bitbucketClient, string userSlug, CancellationToken cancellationToken = new CancellationToken())
{
bitbucketClient.Behaviour.MakeCurrent();
var settingsUri = bitbucketClient.BitbucketUri.AppendSegments("users", userSlug, "settings");
return(await settingsUri.GetAsAsync <IDictionary <string, object> >(cancellationToken).ConfigureAwait(false));
}
/// <summary>
/// Initiate controller with injectors.
/// </summary>
/// <param name="captchaService"></param>
/// <param name="profileCacheService"></param>
/// <param name="userDomain"></param>
public UserController(
ICaptchaService captchaService,
IBaseKeyValueCacheService <int, User> profileCacheService,
IUserDomain userDomain)
{
_captchaService = captchaService;
_userDomain = userDomain;
}
public GiphyController(IUserDomain userDomain,
IGiphyService giphyService,
IImageDomain imageDomain)
{
_userDomain = userDomain;
_giphyService = giphyService;
_imageDomain = imageDomain;
}
public Users(XatarisContext context, IUserDomain userDomain, IEmailSender emailSender, IUserSettings userSettings, IProcedureService procedureService)
{
_context = context;
_userDomain = userDomain;
this.emailSender = emailSender;
_userSettings = userSettings;
_procedureService = procedureService;
}
public void UpdateElement(IUserDomain element)
{
var user = UserAdapter.MapUser(element);
userRepository.UpdateElement(user);
//throw new NotImplementedException();
}
/// <summary>
/// Retrieve the assignable users for the specified project or issue
/// See <a href="https://docs.atlassian.com/jira/REST/cloud/#api/2/user-findAssignableUsers">here</a>
/// </summary>
/// <param name="jiraClient">IProjectDomain</param>
/// <param name="username">optional string with a pattern</param>
/// <param name="projectKey">optional string with the key of the project</param>
/// <param name="issueKey">optional string with the key of the issue</param>
/// <param name="startAt">optional int where to start returning the results</param>
/// <param name="maxResults">optional int with the max of the result</param>
/// <param name="actionDescriptorId">optional int, not documented what this does</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>IEnumerable with User</returns>
public static async Task <IEnumerable <User> > GetAssignableUsersAsync(this IUserDomain jiraClient, string username = null, string projectKey = null, string issueKey = null, int?startAt = null, int?maxResults = null, int?actionDescriptorId = null, CancellationToken cancellationToken = default)
{
var usersSearchUri = jiraClient.JiraRestUri
.AppendSegments("user", "assignable", "search");
if (projectKey != null)
{
usersSearchUri = usersSearchUri.ExtendQuery(new Dictionary <string, object>
{
{ "project", projectKey }
});
}
if (issueKey != null)
{
usersSearchUri = usersSearchUri.ExtendQuery(new Dictionary <string, object>
{
{ "issueKey", issueKey }
});
}
if (username != null)
{
usersSearchUri = usersSearchUri.ExtendQuery(new Dictionary <string, object>
{
{ "username", username }
});
}
if (startAt.HasValue)
{
usersSearchUri = usersSearchUri.ExtendQuery(new Dictionary <string, object>
{
{ "startAt", startAt.Value }
});
}
if (maxResults.HasValue)
{
usersSearchUri = usersSearchUri.ExtendQuery(new Dictionary <string, object>
{
{ "maxResults", maxResults.Value }
});
}
if (actionDescriptorId.HasValue)
{
usersSearchUri = usersSearchUri.ExtendQuery(new Dictionary <string, object>
{
{ "actionDescriptorId", actionDescriptorId.Value }
});
}
jiraClient.Behaviour.MakeCurrent();
var response = await usersSearchUri.GetAsAsync <HttpResponse <IEnumerable <User>, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Get the groups for a user
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="username">string with username</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>List with Groups</returns>
public static async Task <IList <Group> > GetGroupsAsync(this IUserDomain confluenceClient, string username, CancellationToken cancellationToken = default)
{
var groupUri = confluenceClient.ConfluenceApiUri.AppendSegments("user", "memberof").ExtendQuery("username", username);
confluenceClient.Behaviour.MakeCurrent();
var response = await groupUri.GetAsAsync <HttpResponse <Result <Group>, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors()?.Results);
}
/// <summary>
/// Get currrent user information, introduced with 6.6
/// See: https://docs.atlassian.com/confluence/REST/latest/#user-getCurrent
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>User</returns>
public static async Task <User> GetCurrentUserAsync(this IUserDomain confluenceClient, CancellationToken cancellationToken = default)
{
confluenceClient.Behaviour.MakeCurrent();
var myselfUri = confluenceClient.ConfluenceApiUri.AppendSegments("user", "current");
var response = await myselfUri.GetAsAsync <HttpResponse <User, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Get user information, introduced with 6.6
/// See: https://docs.atlassian.com/confluence/REST/latest/#user-getUser
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="username">string with username</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>user information</returns>
public static async Task <User> GetUserAsync(this IUserDomain confluenceClient, string username, CancellationToken cancellationToken = default)
{
var userUri = confluenceClient.ConfluenceApiUri.AppendSegments("user").ExtendQuery("username", username);
confluenceClient.Behaviour.MakeCurrent();
var response = await userUri.GetAsAsync <HttpResponse <User, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Get user information
/// </summary>
/// <param name="bitbucketClient">IUserDomain to pin the extension method to</param>
/// <param name="userSlug">string with userSlug (this might not be the username)</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>User</returns>
public static async Task <User> GetAsync(this IUserDomain bitbucketClient, string userSlug, CancellationToken cancellationToken = new CancellationToken())
{
var userUri = bitbucketClient.BitbucketApiUri.AppendSegments("users", userSlug);
bitbucketClient.Behaviour.MakeCurrent();
var response = await userUri.GetAsAsync <HttpResponse <User, ErrorList> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Get all users
/// </summary>
/// <param name="bitbucketClient">IUserDomain to pin the extension method to</param>
/// <param name="pagingInfo">PagingInfo to get the next page, this should simply be the results object</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Results with User instances</returns>
public static async Task <Results <User> > GetAllAsync(this IUserDomain bitbucketClient, PagingInfo pagingInfo = null, CancellationToken cancellationToken = new CancellationToken())
{
var usersUri = bitbucketClient.BitbucketApiUri.AppendSegments("users");
bitbucketClient.Behaviour.MakeCurrent();
var response = await usersUri.GetAsAsync <HttpResponse <Results <User>, ErrorList> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
public DomainLayerFacade(IUserDomain userDomain, DomainLayerFacadeVerifier verifier
, ILogger <DomainLayerFacade> logger, IExternalServicesManager externalServicesManager
, IUnitOfWork unitOfWork)
{
_userDomain = userDomain;
_verifier = verifier;
_externalServicesManager = externalServicesManager;
_logger = logger;
_unitOfWork = unitOfWork;
}
public GalaryController(IUserDomain userDomain,
IGiphyService giphyService,
IImageDomain imageDomain,
ICategoryDomain categoryDomain)
{
_userDomain = userDomain;
_giphyService = giphyService;
_imageDomain = imageDomain;
_categoryDomain = categoryDomain;
}
/// <summary>
/// Get currrent user information
/// See: https://docs.atlassian.com/jira/REST/latest/#d2e4253
/// </summary>
/// <param name="jiraClient">IWorkDomain to bind the extension method to</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>User</returns>
public static async Task <User> GetMyselfAsync(this IUserDomain jiraClient, CancellationToken cancellationToken = default)
{
Log.Debug().WriteLine("Retieving who I am");
var myselfUri = jiraClient.JiraRestUri.AppendSegments("myself");
jiraClient.Behaviour.MakeCurrent();
var response = await myselfUri.GetAsAsync <HttpResponse <User, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
/// <summary>
/// Get user information
/// See: https://docs.atlassian.com/jira/REST/latest/#d2e5339
/// </summary>
/// <param name="jiraClient">IUserDomain to bind the extension method to</param>
/// <param name="userIdentifier">IUserIdentifier</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>User</returns>
public static Task <User> GetAsync(this IUserDomain jiraClient, IUserIdentifier userIdentifier, CancellationToken cancellationToken = default)
{
if (userIdentifier?.AccountId != null)
{
return(GetByAccountIdAsync(jiraClient, userIdentifier.AccountId, cancellationToken));
}
if (userIdentifier?.Name != null)
{
return(GetByUsernameAsync(jiraClient, userIdentifier.Name, cancellationToken));
}
throw new ArgumentNullException(nameof(userIdentifier), "no users identifier specified");
}
public static IUser MapUser(IUserDomain user)
{
return(new User
{
Id = user.Id,
Address = user.Address,
CreateDate = user.CreateDate,
LastName = user.LastName,
Name = user.Name,
UpdateDate = user.UpdateDate
});
}
/// <summary>
/// Get avatar for the user
/// </summary>
/// <param name="bitbucketClient">IUserDomain to pin the extension method to</param>
/// <param name="userslug">string with userSlug (this might not be the username)</param>
/// <param name="size">optional size</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Bitmap or ImageSource</returns>
public static async Task <TBitmap> GetAvatarAsync <TBitmap>(this IUserDomain bitbucketClient, string userslug, int?size = null, CancellationToken cancellationToken = new CancellationToken())
where TBitmap : class
{
// This doesn't use the API itself!
var avatarUri = bitbucketClient.BitbucketUri.AppendSegments("users", userslug, "avatar.png");
if (size.HasValue)
{
avatarUri = avatarUri.ExtendQuery("s", size.Value);
}
bitbucketClient.Behaviour.MakeCurrent();
return(await avatarUri.GetAsAsync <TBitmap>(cancellationToken).ConfigureAwait(false));
}
public static User ToUser(IUserDomain user)
{
if (user == null)
{
return(null);
}
return(new User
{
Id = user.Id,
Address = user.Address?.Trim() ?? string.Empty,
LastName = user.LastName?.Trim() ?? string.Empty,
Name = user.Name?.Trim() ?? string.Empty
});
}
/// <summary>
/// Check if the user is watching the specified space
/// See: https://developer.atlassian.com/cloud/confluence/rest/#api-api-user-watch-content-contentId-get
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="spaceKey">string with the space key</param>
/// <param name="userIdentifier">IUserIdentifier for the user (account id), null for the current user</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>bool</returns>
public static async Task <bool> IsSpaceWatcher(this IUserDomain confluenceClient, string spaceKey, IUserIdentifier userIdentifier = null, CancellationToken cancellationToken = default)
{
if (string.IsNullOrEmpty(spaceKey))
{
throw new ArgumentNullException(nameof(spaceKey));
}
bool isCloudServer = await confluenceClient.IsCloudServer(cancellationToken);
var userWatchSpaceUri = CreateUserWatchUri(confluenceClient, isCloudServer, userIdentifier, "space", spaceKey);
confluenceClient.Behaviour.MakeCurrent();
var response = await userWatchSpaceUri.GetAsAsync <HttpResponse <UserWatch> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors().IsWatching);
}
/// <summary>
/// Get user information
/// See: https://docs.atlassian.com/jira/REST/latest/#d2e5339
/// </summary>
/// <param name="jiraClient">IWorkDomain to bind the extension method to</param>
/// <param name="username"></param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>User</returns>
public static async Task <User> GetAsync(this IUserDomain jiraClient, string username, CancellationToken cancellationToken = default)
{
if (username == null)
{
throw new ArgumentNullException(nameof(username));
}
Log.Debug().WriteLine("Retrieving user {0}", username);
var userUri = jiraClient.JiraRestUri.AppendSegments("user").ExtendQuery("username", username);
jiraClient.Behaviour.MakeCurrent();
var response = await userUri.GetAsAsync <HttpResponse <User, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors());
}
public static UserDTO ToUserDTO(IUserDomain user)
{
if (user == null)
{
return(null);
}
return(new UserDTO
{
Address = user.Address?.Trim() ?? string.Empty,
LastName = user.LastName?.Trim() ?? string.Empty,
Name = user.Name?.Trim() ?? string.Empty,
CreateDate = user.CreateDate,
UpdateDate = user.UpdateDate,
Id = user.Id
});
}
/// <summary>
/// Check if the user is watching the specified content
/// See: https://developer.atlassian.com/cloud/confluence/rest/#api-api-user-watch-content-contentId-get
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="contentId">long with the ID for the content</param>
/// <param name="userIdentifier">IUserIdentifier for the user (account id), null for the current user</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>bool</returns>
public static async Task <bool> IsContentWatcher(this IUserDomain confluenceClient, long contentId, IUserIdentifier userIdentifier = null, CancellationToken cancellationToken = default)
{
if (contentId == 0)
{
throw new ArgumentNullException(nameof(contentId));
}
bool isCloudServer = await confluenceClient.IsCloudServer(cancellationToken);
var userWatchContentUri = CreateUserWatchUri(confluenceClient, isCloudServer, userIdentifier, "content", contentId);
confluenceClient.Behaviour.MakeCurrent();
var response = await userWatchContentUri.GetAsAsync <HttpResponse <UserWatch> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors().IsWatching);
}
/// <summary>
/// Remove the user from the list of users watching the specified content
/// See: https://developer.atlassian.com/cloud/confluence/rest/#api-api-user-watch-content-contentId-delete
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="contentId">long with the ID for the content</param>
/// <param name="userIdentifier">IUserIdentifier for the user (account id), null for the current user</param>
/// <param name="cancellationToken">CancellationToken</param>
public static async Task RemoveContentWatcher(this IUserDomain confluenceClient, long contentId, IUserIdentifier userIdentifier = null, CancellationToken cancellationToken = default)
{
if (contentId == 0)
{
throw new ArgumentNullException(nameof(contentId));
}
bool isCloudServer = await confluenceClient.IsCloudServer(cancellationToken);
var userWatchContentUri = CreateUserWatchUri(confluenceClient, isCloudServer, userIdentifier, "content", contentId);
confluenceClient.Behaviour.MakeCurrent();
var response = await userWatchContentUri.DeleteAsync <HttpResponseWithError <Error> >(cancellationToken).ConfigureAwait(false);
// Expect a 204, which is NoContent
response.HandleStatusCode(HttpStatusCode.NoContent);
}
/// <summary>
/// Get groups for the specified user, introduced with 6.6
/// See: https://developer.atlassian.com/cloud/confluence/rest/#api-api-user-memberof-get
/// </summary>
/// <param name="confluenceClient">IUserDomain to bind the extension method to</param>
/// <param name="userIdentifier">IUserIdentifier</param>
/// <param name="pagingInformation">PagingInformation</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>List with Groups</returns>
public static async Task <IList <Group> > GetGroupMembershipsAsync(this IUserDomain confluenceClient, IUserIdentifier userIdentifier, PagingInformation pagingInformation = null, CancellationToken cancellationToken = default)
{
if (userIdentifier == null)
{
throw new ArgumentNullException(nameof(userIdentifier));
}
pagingInformation ??= new PagingInformation
{
Limit = 200,
Start = 0
};
var groupUri = confluenceClient.ConfluenceApiUri
.AppendSegments("user", "memberof")
.ExtendQuery(new Dictionary <string, object> {
{
"start", pagingInformation.Start
},
{
"limit", pagingInformation.Limit
}
});
bool isCloudServer = await confluenceClient.IsCloudServer(cancellationToken);
if (isCloudServer)
{
if (string.IsNullOrEmpty(userIdentifier.AccountId))
{
throw new ArgumentNullException(nameof(userIdentifier));
}
groupUri = groupUri.ExtendQuery("accountId", userIdentifier.AccountId);
}
else
{
if (string.IsNullOrEmpty(userIdentifier.Username))
{
throw new ArgumentNullException(nameof(userIdentifier));
}
groupUri = groupUri.ExtendQuery("username", userIdentifier.Username);
}
confluenceClient.Behaviour.MakeCurrent();
var response = await groupUri.GetAsAsync <HttpResponse <Result <Group>, Error> >(cancellationToken).ConfigureAwait(false);
return(response.HandleErrors()?.Results);
}
