private static final Logger LOG = LoggerFactory.getLogger(GitlabAPI.class);

public static final ObjectMapper MAPPER = new ObjectMapper().configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);

private static final String DEFAULT_API_NAMESPACE = "/api/v4";

private static final String PARAM_SUDO = "sudo";

private static final String PARAM_WITH_PROJECTS = "with_projects";

private static final String PARAM_MAX_ITEMS_PER_PAGE = new Pagination().withPerPage(Pagination.MAX_ITEMS_PER_PAGE).toString();

private final String hostUrl;

private final String apiToken;

private final TokenType tokenType;

private AuthMethod authMethod;

private final String apiNamespace;

private boolean ignoreCertificateErrors = false;

private Proxy proxy;

private int defaultTimeout = 0;

private int readTimeout = defaultTimeout;

private int connectionTimeout = defaultTimeout;

private String userAgent = GitlabAPI.class.getCanonicalName() + "/" + System.getProperty("java.version");

private GitlabAPI(String hostUrl, String apiToken, TokenType tokenType, AuthMethod method, String apiNamespace) {

this.hostUrl = hostUrl.endsWith("/") ? hostUrl.replaceAll("/$", "") : hostUrl;

this.apiToken = apiToken;

this.tokenType = tokenType;

this.authMethod = method;

this.apiNamespace = apiNamespace;

}

private GitlabAPI(String hostUrl, String apiToken, TokenType tokenType, AuthMethod method) {

this(hostUrl, apiToken, tokenType, method, DEFAULT_API_NAMESPACE);

}

public static GitlabSession connect(String hostUrl, String username, String password) throws IOException {

String tailUrl = GitlabSession.URL;

GitlabAPI api = connect(hostUrl, null, null, (AuthMethod) null);

return api.dispatch().with("login", username).with("password", password)

.to(tailUrl, GitlabSession.class);

}

public static GitlabAPI connect(String hostUrl, String apiToken) {

return new GitlabAPI(hostUrl, apiToken, TokenType.PRIVATE_TOKEN, AuthMethod.HEADER);

}

public static GitlabAPI connect(String hostUrl, String apiToken, TokenType tokenType) {

return new GitlabAPI(hostUrl, apiToken, tokenType, AuthMethod.HEADER);

}

public static GitlabAPI connect(String hostUrl, String apiToken, TokenType tokenType, AuthMethod method) {

return new GitlabAPI(hostUrl, apiToken, tokenType, method);

}

public static GitlabAPI connect(String hostUrl, String apiToken, TokenType tokenType, String apiNamespace) {

return new GitlabAPI(hostUrl, apiToken, tokenType, AuthMethod.HEADER, apiNamespace);

}

public static GitlabAPI connect(String hostUrl, String apiToken, TokenType tokenType, AuthMethod method, String apiNamespace) {

return new GitlabAPI(hostUrl, apiToken, tokenType, method, apiNamespace);

}

public GitlabAPI ignoreCertificateErrors(boolean ignoreCertificateErrors) {

this.ignoreCertificateErrors = ignoreCertificateErrors;

return this;

}

public GitlabAPI proxy(Proxy proxy) {

this.proxy = proxy;

return this;

}

public int getResponseReadTimeout() {

return readTimeout;

}

/**

@Deprecated

public int getRequestTimeout() {

return getResponseReadTimeout();

}

/**

@Deprecated

public GitlabAPI setRequestTimeout(int readTimeout) {

setResponseReadTimeout(readTimeout);

return this;

}

public GitlabAPI setResponseReadTimeout(int readTimeout) {

if (readTimeout < 0) {

LOG.warn("The value of the \"Response Read Timeout\" parameter can not be negative. " +

"The default value [{}] will be used.", defaultTimeout);

this.readTimeout = defaultTimeout;

} else {

this.readTimeout = readTimeout;

}

return this;

}

public int getConnectionTimeout() {

return connectionTimeout;

}

public GitlabAPI setConnectionTimeout(int connectionTimeout) {

if (connectionTimeout < 0) {

LOG.warn("The value of the \"Connection Timeout\" parameter can not be negative. " +

"The default value [{}] will be used.", defaultTimeout);

this.connectionTimeout = defaultTimeout;

} else {

this.connectionTimeout = connectionTimeout;

}

return this;

}

public GitlabHTTPRequestor retrieve() {

return new GitlabHTTPRequestor(this).authenticate(apiToken, tokenType, authMethod);

}

public GitlabHTTPRequestor dispatch() {

return new GitlabHTTPRequestor(this).authenticate(apiToken, tokenType, authMethod).method(POST);

}

public GitlabHTTPRequestor put() {

return new GitlabHTTPRequestor(this).authenticate(apiToken, tokenType, authMethod).method(PUT);

}

public boolean isIgnoreCertificateErrors() {

return ignoreCertificateErrors;

}

public Proxy getProxy() {

return proxy;

}

public URL getAPIUrl(String tailAPIUrl) throws IOException {

if (!tailAPIUrl.startsWith("/")) {

tailAPIUrl = "/" + tailAPIUrl;

}

return new URL(hostUrl + apiNamespace + tailAPIUrl);

}

public URL getUrl(String tailAPIUrl) throws IOException {

if (!tailAPIUrl.startsWith("/")) {

tailAPIUrl = "/" + tailAPIUrl;

}

return new URL(hostUrl + tailAPIUrl);

}

public String getHost() {

return hostUrl;

}

public List<GitlabUser> getUsers() {

String tailUrl = GitlabUser.URL + PARAM_MAX_ITEMS_PER_PAGE;

return retrieve().getAll(tailUrl, GitlabUser[].class);

}

/**

public List<GitlabUser> findUsers(String emailOrUsername) throws IOException {

List<GitlabUser> users = new ArrayList<>();

if (emailOrUsername != null && !emailOrUsername.equals("")) {

String tailUrl = GitlabUser.URL + "?search=" + emailOrUsername;

GitlabUser[] response = retrieve().to(tailUrl, GitlabUser[].class);

users = Arrays.asList(response);

}

return users;

}

/**

public GitlabUser getUser() throws IOException {

String tailUrl = GitlabUser.USER_URL;

return retrieve().to(tailUrl, GitlabUser.class);

}

public GitlabUser getUser(Integer userId) throws IOException {

String tailUrl = GitlabUser.URL + "/" + userId;

return retrieve().to(tailUrl, GitlabUser.class);

}

public GitlabUser getUserViaSudo(String username) throws IOException {

String tailUrl = GitlabUser.USER_URL + "?" + PARAM_SUDO + "=" + username;

return retrieve().to(tailUrl, GitlabUser.class);

}

/**

public GitlabUser createUser(String email, String password, String username,

String fullName, String skypeId, String linkedIn,

String twitter, String website_url, Integer projects_limit,

String extern_uid, String extern_provider_name,

String bio, Boolean isAdmin, Boolean can_create_group,

Boolean skip_confirmation, Boolean external) throws IOException {

Query query = new Query()

.append("email", email)

.appendIf("skip_confirmation", skip_confirmation)

.appendIf("password", password)

.appendIf("username", username)

.appendIf("name", fullName)

.appendIf("skype", skypeId)

.appendIf("linkedin", linkedIn)

.appendIf("twitter", twitter)

.appendIf("website_url", website_url)

.appendIf("projects_limit", projects_limit)

.appendIf("extern_uid", extern_uid)

.appendIf("provider", extern_provider_name)

.appendIf("bio", bio)

.appendIf("admin", isAdmin)

.appendIf("can_create_group", can_create_group)

.appendIf("external", external);

String tailUrl = GitlabUser.USERS_URL + query.toString();

return dispatch().to(tailUrl, GitlabUser.class);

}

/**

public GitlabUser createUser(CreateUserRequest request) throws IOException {

String tailUrl = GitlabUser.USERS_URL + request.toQuery().toString();

return dispatch().to(tailUrl, GitlabUser.class);

}

/**

public GitlabUser updateUser(Integer targetUserId,

String email, String password, String username,

String fullName, String skypeId, String linkedIn,

String twitter, String website_url, Integer projects_limit,

String extern_uid, String extern_provider_name,

String bio, Boolean isAdmin, Boolean can_create_group, Boolean external) throws IOException {

Query query = new Query()

.append("email", email)

.appendIf("password", password)

.appendIf("username", username)

.appendIf("name", fullName)

.appendIf("skype", skypeId)

.appendIf("linkedin", linkedIn)

.appendIf("twitter", twitter)

.appendIf("website_url", website_url)

.appendIf("projects_limit", projects_limit)

.appendIf("extern_uid", extern_uid)

.appendIf("provider", extern_provider_name)

.appendIf("bio", bio)

.appendIf("admin", isAdmin)

.appendIf("can_create_group", can_create_group)

.appendIf("external", external);

String tailUrl = GitlabUser.USERS_URL + "/" + targetUserId + query.toString();

return retrieve().method(PUT).to(tailUrl, GitlabUser.class);

}

/**

public void blockUser(Integer targetUserId) throws IOException {

String tailUrl = GitlabUser.USERS_URL + "/" + targetUserId + GitlabUser.BLOCK_URL;

retrieve().method(POST).to(tailUrl, Void.class);

}

/**

public void unblockUser(Integer targetUserId) throws IOException {

String tailUrl = GitlabUser.USERS_URL + "/" + targetUserId + GitlabUser.UNBLOCK_URL;

retrieve().method(POST).to(tailUrl, Void.class);

}

/**

public GitlabSSHKey createSSHKey(Integer targetUserId, String title, String key) throws IOException {

Query query = new Query()

.append("title", title)

.append("key", key);

String tailUrl = GitlabUser.USERS_URL + "/" + targetUserId + GitlabSSHKey.KEYS_URL + query.toString();

return dispatch().to(tailUrl, GitlabSSHKey.class);

}

/**

public GitlabSSHKey createSSHKey(String title, String key) throws IOException {

Query query = new Query()

.append("title", title)

.append("key", key);

String tailUrl = GitlabUser.USER_URL + GitlabSSHKey.KEYS_URL + query.toString();

return dispatch().to(tailUrl, GitlabSSHKey.class);

}

/**

public void deleteSSHKey(Integer targetUserId, Integer targetKeyId) throws IOException {

String tailUrl = GitlabUser.USERS_URL + "/" + targetUserId + GitlabSSHKey.KEYS_URL + "/" + targetKeyId;

retrieve().method(DELETE).to(tailUrl, Void.class);

}

/**

public List<GitlabSSHKey> getSSHKeys(Integer targetUserId) throws IOException {

String tailUrl = GitlabUser.USERS_URL + "/" + targetUserId + GitlabSSHKey.KEYS_URL;

return Arrays.asList(retrieve().to(tailUrl, GitlabSSHKey[].class));

}

/**

public GitlabSSHKey getSSHKey(Integer keyId) throws IOException {

String tailUrl = GitlabSSHKey.KEYS_URL + "/" + keyId;

return retrieve().to(tailUrl, GitlabSSHKey.class);

}

/**

public void deleteUser(Integer targetUserId) throws IOException {

String tailUrl = GitlabUser.USERS_URL + "/" + targetUserId;

retrieve().method(DELETE).to(tailUrl, Void.class);

}

public GitlabGroup getGroup(Integer groupId) throws IOException {

return getGroup(groupId.toString());

}

public GitlabGroup getGroupWithoutProjects(Integer groupId) throws IOException {

return getGroupWithoutProjects(groupId.toString());

}

/**

public GitlabGroup getGroupWithoutProjects(String path) throws IOException {

return getGroup(path, false);

}

/**

public GitlabGroup getGroup(String path) throws IOException {

return getGroup(path, true);

}

/**

public GitlabGroup getGroup(String path, boolean withProjects) throws IOException {

String tailUrl = GitlabGroup.URL + "/" + URLEncoder.encode(path, "UTF-8");

Query query = new Query()

.append(PARAM_WITH_PROJECTS, "" + withProjects);

return retrieve().to(tailUrl + query.toString(), GitlabGroup.class);

}

public List<GitlabGroup> getGroups() throws IOException {

return getGroupsViaSudo(null, new Pagination().withPerPage(Pagination.MAX_ITEMS_PER_PAGE));

}

public List<GitlabGroup> getGroupsViaSudo(String username, Pagination pagination) throws IOException {

String tailUrl = GitlabGroup.URL;

Query query = new Query()

.appendIf(PARAM_SUDO, username);

if (pagination != null) {

query.mergeWith(pagination.asQuery());

}

return retrieve().getAll(tailUrl + query.toString(), GitlabGroup[].class);

}

/**

public List<GitlabProject> getGroupProjects(GitlabGroup group) {

return getGroupProjects(group.getId());

}

/**

public List<GitlabProject> getGroupProjects(Integer groupId) {

String tailUrl = GitlabGroup.URL + "/" + groupId + GitlabProject.URL + PARAM_MAX_ITEMS_PER_PAGE;

return retrieve().getAll(tailUrl, GitlabProject[].class);

}

/**

public List<GitlabGroupMember> getGroupMembers(GitlabGroup group) {

return getGroupMembers(group.getId());

}

/**

public List<GitlabGroupMember> getGroupMembers(Integer groupId) {

String tailUrl = GitlabGroup.URL + "/" + groupId + GitlabGroupMember.URL + PARAM_MAX_ITEMS_PER_PAGE;

return retrieve().getAll(tailUrl, GitlabGroupMember[].class);

}

/**

public GitlabGroup createGroup(String name) throws IOException {

return createGroup(name, name);

}

/**

public GitlabGroup createGroup(String name, String path) throws IOException {

return createGroup(name, path, null, null, null);

}

/**

public GitlabGroup createGroupViaSudo(String name, String path, GitlabUser sudoUser) throws IOException {

return createGroup(name, path, null, null, sudoUser);

}

/**

public GitlabGroup createGroup(String name, String path, String ldapCn, GitlabAccessLevel ldapAccess) throws IOException {

return createGroup(name, path, ldapCn, ldapAccess, null);

}

/**

public GitlabGroup createGroup(CreateGroupRequest request, GitlabUser sudoUser) throws IOException {

Query query = request.toQuery();

query.appendIf(PARAM_SUDO, sudoUser != null ? sudoUser.getId() : null);

String tailUrl = GitlabGroup.URL + query.toString();

return dispatch().to(tailUrl, GitlabGroup.class);

}

/**

public GitlabGroup createGroup(String name, String path, String ldapCn, GitlabAccessLevel ldapAccess, GitlabUser sudoUser) throws IOException {

return createGroup(name, path, ldapCn, ldapAccess, sudoUser, null);

}

/**

public GitlabGroup createGroup(String name, String path, String ldapCn, GitlabAccessLevel ldapAccess, GitlabUser sudoUser, Integer parentId) throws IOException {

Query query = new Query()

.append("name", name)

.append("path", path)

.appendIf("ldap_cn", ldapCn)

.appendIf("ldap_access", ldapAccess)

.appendIf(PARAM_SUDO, sudoUser != null ? sudoUser.getId() : null)

.appendIf("parent_id", parentId);

String tailUrl = GitlabGroup.URL + query.toString();

return dispatch().to(tailUrl, GitlabGroup.class);

}

/**

public GitlabGroup createGroup(GitlabGroup group, GitlabUser sudoUser) throws IOException {

Query query = new Query()

.append("name", group.getName())

.append("path", group.getPath())

.appendIf("description", group.getDescription())

.appendIf("membership_lock", group.getMembershipLock())

.appendIf("share_with_group_lock", group.getShareWithGroupLock())

.appendIf("visibility", group.getVisibility().toString())

.appendIf("lfs_enabled", group.isLfsEnabled())

.appendIf("request_access_enabled", group.isRequestAccessEnabled())

.appendIf("shared_runners_minutes_limit", group.getSharedRunnersMinutesLimit())

.appendIf("ldap_cn", group.getLdapCn())

.appendIf("ldap_access", group.getLdapAccess())

.appendIf(PARAM_SUDO, sudoUser != null ? sudoUser.getId() : null);

String tailUrl = GitlabGroup.URL + query.toString();

return dispatch().to(tailUrl, GitlabGroup.class);

}

/**

public GitlabGroup updateGroup(GitlabGroup group, GitlabUser sudoUser) throws IOException {

Query query = new Query()

.appendIf("name", group.getName())

.appendIf("path", group.getPath())

.appendIf("description", group.getDescription())

.appendIf("membership_lock", group.getMembershipLock())

.appendIf("share_with_group_lock", group.getShareWithGroupLock())

.appendIf("visibility", group.getVisibility().toString())

.appendIf("lfs_enabled", group.isLfsEnabled())

.appendIf("request_access_enabled", group.isRequestAccessEnabled())

.appendIf("shared_runners_minutes_limit", group.getSharedRunnersMinutesLimit())

.appendIf("ldap_cn", group.getLdapCn())

.appendIf("ldap_access", group.getLdapAccess())

.appendIf(PARAM_SUDO, sudoUser != null ? sudoUser.getId() : null);

String tailUrl = GitlabGroup.URL + "/" + group.getId() + query.toString();

return retrieve().method(PUT).to(tailUrl, GitlabGroup.class);

}

/**

public GitlabGroupMember addGroupMember(GitlabGroup group, GitlabUser user, GitlabAccessLevel accessLevel) throws IOException {

return addGroupMember(group.getId(), user.getId(), accessLevel);

}

/**

public GitlabGroupMember addGroupMember(Integer groupId, Integer userId, GitlabAccessLevel accessLevel) throws IOException {

Query query = new Query()

.appendIf("id", groupId)

.appendIf("user_id", userId)

.appendIf("access_level", accessLevel);

String tailUrl = GitlabGroup.URL + "/" + groupId + GitlabProjectMember.URL + query.toString();

return dispatch().to(tailUrl, GitlabGroupMember.class);

}

/**

public void deleteGroupMember(GitlabGroup group, GitlabUser user) throws IOException {

deleteGroupMember(group.getId(), user.getId());

}

/**

public void deleteGroupMember(Integer groupId, Integer userId) throws IOException {

String tailUrl = GitlabGroup.URL + "/" + groupId + "/" + GitlabGroupMember.URL + "/" + userId;

retrieve().method(DELETE).to(tailUrl, Void.class);

}

/**

public void deleteGroup(Integer groupId) throws IOException {

String tailUrl = GitlabGroup.URL + "/" + groupId;

retrieve().method(DELETE).to(tailUrl, Void.class);

}

/**

public List<GitlabProject> getAllProjects() {

String tailUrl = GitlabProject.URL;

return retrieve().getAll(tailUrl, GitlabProject[].class);

}

/**

public GitlabProject getProject(Serializable projectId) throws IOException {

String tailUrl = GitlabProject.URL + "/" + sanitizeProjectId(projectId);

return retrieve().to(tailUrl, GitlabProject.class);

}

/**

public GitlabProject getProject(String namespace, String projectName) throws IOException {

String tailUrl = GitlabProject.URL + "/" + sanitizeGroupId(namespace) + "%2F" + sanitizeProjectId(projectName);

return retrieve().to(tailUrl, GitlabProject.class);

}

/*

public String getProjectJson(Serializable projectId) throws IOException {

String tailUrl = GitlabProject.URL + "/" + sanitizeProjectId(projectId);

return retrieve().to(tailUrl, String.class);

}

/*

public String getProjectJson(String namespace, String projectName) throws IOException {

String tailUrl = GitlabProject.URL + "/" + sanitizeGroupId(namespace) + "%2F" + sanitizeProjectId(projectName);

return retrieve().to(tailUrl, String.class);

}

/**

public List<GitlabProject> getProjects() {

String tailUrl = GitlabProject.URL + PARAM_MAX_ITEMS_PER_PAGE;

return retrieve().getAll(tailUrl, GitlabProject[].class);

}

/**

public List<GitlabProject> getProjectsWithPagination(int page, int perPage) throws IOException {

Pagination pagination = new Pagination()

.withPage(page)

.withPerPage(perPage);

return getProjectsWithPagination(pagination);

}

/**

public List<GitlabProject> getProjects(ProjectsQuery projectsQuery) {

String tailUrl = GitlabProject.URL + projectsQuery;

return retrieve().getAll(tailUrl, GitlabProject[].class);

}

/**

public List<GitlabProject> getProjectsWithPagination(Pagination pagination) throws IOException {

StringBuilder tailUrl = new StringBuilder(GitlabProject.URL);

if (pagination != null) {

Query query = pagination.asQuery();

tailUrl.append(query.toString());

}

return Arrays.asList(retrieve().method(GET).to(tailUrl.toString(), GitlabProject[].class));

}

/**

public List<GitlabProject> getOwnedProjects() throws IOException {

Query query = new Query().append("owned", "true");

query.mergeWith(new Pagination().withPerPage(Pagination.MAX_ITEMS_PER_PAGE).asQuery());

String tailUrl = GitlabProject.URL + query.toString();

return retrieve().getAll(tailUrl, GitlabProject[].class);

}

/**

public List<GitlabProject> getMembershipProjects() throws IOException {

Query query = new Query().append("membership", "true");

query.mergeWith(new Pagination().withPerPage(Pagination.MAX_ITEMS_PER_PAGE).asQuery());

String tailUrl = GitlabProject.URL + query.toString();

return retrieve().getAll(tailUrl, GitlabProject[].class);

}

/**

public List<GitlabProject> getStarredProjects() throws IOException {

Query query = new Query().append("starred", "true");

query.mergeWith(new Pagination().withPerPage(Pagination.MAX_ITEMS_PER_PAGE).asQuery());

String tailUrl = GitlabProject.URL + query.toString();

return retrieve().getAll(tailUrl, GitlabProject[].class);

}

/**

public List<GitlabProject> getProjectsViaSudo(GitlabUser user) throws IOException {

Query query = new Query()

.appendIf(PARAM_SUDO, user.getId());

query.mergeWith(new Pagination().withPerPage(Pagination.MAX_ITEMS_PER_PAGE).asQuery());

String tailUrl = GitlabProject.URL + query.toString();

return retrieve().getAll(tailUrl, GitlabProject[].class);

}

/**

public List<GitlabProject> getProjectsViaSudoWithPagination(GitlabUser user, int page, int perPage) throws IOException {

Pagination pagination = new Pagination()

.withPage(page)

.withPerPage(perPage);

return getProjectsViaSudoWithPagination(user, pagination);

}

/**

public List<GitlabProject> getProjectsViaSudoWithPagination(GitlabUser user, Pagination pagination) throws IOException {

StringBuilder tailUrl = new StringBuilder(GitlabProject.URL);

Query query = new Query()

.appendIf(PARAM_SUDO, user.getId());

if (pagination != null) {

query.mergeWith(pagination.asQuery());

}

tailUrl.append(query.toString());

return Arrays.asList(retrieve().method(GET).to(tailUrl.toString(), GitlabProject[].class));

}