How to use

GitlabProject

in

org.gitlab.api.models

@Override
public GitCommit commit(String refName) throws GitException {
  checkProject();
  try {
    List<GitlabCommit> lastCommits = connect.getLastCommits(project.getId(), refName);
    GitlabCommit gitlabCommit = lastCommits.get(0);
    String commitId = gitlabCommit.getId();
    String commitMessage = gitlabCommit.getMessage();
    String commitAuthorEmail = gitlabCommit.getAuthorEmail();
    return new GitCommit(commitId, commitMessage, commitAuthorEmail);
  } catch (IOException e) {
    throw new GitException(e.getMessage());
  }
}

@Override
public List<GitProject> projects() throws GitException {
  try {
    List<GitlabProject> projects = connect.getMembershipProjects();
    List<GitProject> results = new ArrayList<>(projects.size());
    for (GitlabProject project : projects) {
      Integer id = project.getId();
      String name = project.getName();
      String fullName = project.getNameWithNamespace();
      results.add(new GitProject(id.toString(), name, fullName));
    }
    return results;
  } catch (IOException e) {
    throw new GitException(e.getMessage());
  }
}

  @Override
  public int compare(GitlabProject o1, GitlabProject o2) {
    GitlabNamespace namespace1 = o1.getNamespace();
    String n1 = namespace1 != null ? namespace1.getName().toLowerCase() : "Default";
    GitlabNamespace namespace2 = o2.getNamespace();
    String n2 = namespace2 != null ? namespace2.getName().toLowerCase() : "Default";
    int compareNamespace = n1.compareTo(n2);
    return compareNamespace != 0 ? compareNamespace : o1.getName().toLowerCase().compareTo(o2.getName().toLowerCase());
  }
});

/**
 * Returns the list of build triggers for a project.
 *
 * @param project the project
 * @return list of build triggers
 * @throws IllegalStateException if jobs are not enabled for the project
 */
public List<GitlabTrigger> getPipelineTriggers(GitlabProject project) {
  if (!project.isJobsEnabled()) {
    // if the project has not allowed jobs, you will only get a 403 forbidden message which is
    // not helpful.
    throw new IllegalStateException("Jobs are not enabled for " + project.getNameWithNamespace());
  } else {
    return retrieve().getAll(GitlabProject.URL + "/" + project.getId() + GitlabTrigger.URL + PARAM_MAX_ITEMS_PER_PAGE, GitlabTrigger[].class);
  }
}

    .appendIf("name", project.getName())
    .appendIf("path", project.getPath())
    .appendIf("default_branch", project.getDefaultBranch())
    .appendIf("description", project.getDescription())
    .appendIf("issues_enabled", project.isIssuesEnabled())
    .appendIf("merge_requests_enabled", project.isMergeRequestsEnabled())
    .appendIf("jobs_enabled", project.isJobsEnabled())
    .appendIf("wiki_enabled", project.isWikiEnabled())
    .appendIf("snippets_enabled", project.isSnippetsEnabled())
    .appendIf("container_registry_enabled", project.isContainerRegistryEnabled())
    .appendIf("shared_runners_enabled", project.isSharedRunnersEnabled())
    .appendIf("visibility", project.getVisibility())
    .appendIf("public_jobs", project.hasPublicJobs())
    .appendIf("import_url", project.getImportUrl())
    .appendIf("only_allow_merge_if_pipeline_succeeds", project.getOnlyAllowMergeIfPipelineSucceeds())
    .appendIf("only_allow_merge_if_all_discussions_are_resolved", project.getOnlyAllowMergeIfAllDiscussionsAreResolved())
    .appendIf("lfs_enabled", project.isLfsEnabled())
    .appendIf("request_access_enabled", project.isRequestAccessEnabled())
    .appendIf("repository_storage", project.getRepositoryStorage())
    .appendIf("approvals_before_merge", project.getApprovalsBeforeMerge())
    .appendIf("printing_merge_request_link_enabled", project.isPrintingMergeRequestLinkEnabled());
GitlabNamespace namespace = project.getNamespace();
if (namespace != null) {
  query.appendIf("namespace_id", namespace.getId());

public Optional<GitlabProject> resolveProject(ProjectState projectState, GitRemote remote, GitRepository repository) {
  String remoteProjectName = remote.getName();
  String remoteUrl = remote.getFirstUrl();
  if(projectState.getProjectId(remoteUrl) == null) {
    try {
      Collection<GitlabProject> projects = settingsState.api(repository).getProjects();
      for (GitlabProject gitlabProject : projects) {
        if (gitlabProject.getName().toLowerCase().equals(remoteProjectName.toLowerCase()) || urlMatch(remoteUrl, gitlabProject.getSshUrl()) || urlMatch(remoteUrl, gitlabProject.getHttpUrl())) {
          Integer projectId = gitlabProject.getId();
          projectState.setProjectId(remoteUrl, projectId);
          return Optional.of(gitlabProject);
        }
      }
    } catch (Throwable throwable) {
      throw new GitLabException("Cannot match project.", throwable);
    }
  } else {
    try {
      return Optional.of(settingsState.api(repository).getProject(projectState.getProjectId(remoteUrl)));
    } catch (Exception e) {
      projectState.setProjectId(remoteUrl, null);
    }
  }
  return Optional.empty();
}

public Collection<ProjectDto> loadProjects(GitlabServer server) throws Throwable {
  ApiFacade apiFacade = api(server);
  Collection<ProjectDto> projects = getProjects();
  if(projects == null) {
    projects = new ArrayList<>();
  }
  for (GitlabProject gitlabProject : apiFacade.getProjects()) {
    ProjectDto projectDto = new ProjectDto();
    projectDto.setName(gitlabProject.getName());
    projectDto.setNamespace(gitlabProject.getNamespace().getName());
    projectDto.setHttpUrl(gitlabProject.getHttpUrl());
    projectDto.setSshUrl(gitlabProject.getSshUrl());
    projects.add(projectDto);
  }
  this.setProjects(projects);
  return projects;
}

if (sourceProject == null || sourceProject.getId() == null || sourceProject.getName() == null) {
  try {
    GitlabAPI api = builder.getGitlab().get();

@Test
public void testCreateDeleteFork() throws Exception {
  String projectName = randVal("Fork-me");
  String password = randVal("$%password");
  GitlabUser gitUser = api.createUser(randVal("testEmail@gitlabapitest.com"),
      password,
      randVal("userName"),
      randVal("fullName"),
      randVal("skypeId"),
      randVal("linkedin"),
      randVal("twitter"),
      "http://" + randVal("url.com"),
      10,
      randVal("externuid"),
      randVal("externprovidername"),
      randVal("bio"),
      false,
      false,
      false,
      false);
  String namespace = api.getNamespaces().get(0).getPath();
  GitlabProject project = api.createUserProject(gitUser.getId(), projectName);
  GitlabProject fork = api.createFork(namespace, project);
  assertNotNull(fork);
  assertEquals(project.getId(), fork.getForkedFrom().getId());
  assertEquals(project.getNamespace(), namespace);
  api.deleteProject(project.getId());
  api.deleteProject(fork.getId());
  api.deleteUser(gitUser.getId());
}

@Nullable
GitLabProject updateRepository(@NotNull GitlabProject project) throws IOException, SVNException {
 if (!tagsMatch(project)) {
  removeRepository(project.getId(), project.getPathWithNamespace());
  return null;
 }
 final String projectName = project.getPathWithNamespace();
 final String projectKey = StringHelper.normalizeDir(projectName);
 final GitLabProject oldProject = mapping.get(projectKey);
 if (oldProject == null || oldProject.getProjectId() != project.getId()) {
  final File basePath = ConfigHelper.joinPath(context.getBasePath(), config.getPath());
  final File repoPath = ConfigHelper.joinPath(basePath, project.getPathWithNamespace() + ".git");
  final LocalContext local = new LocalContext(context, project.getPathWithNamespace());
  local.add(VcsAccess.class, new GitLabAccess(local, config, project.getId()));
  final VcsRepository repository = config.getTemplate().create(local, repoPath);
  final GitLabProject newProject = new GitLabProject(local, repository, project.getId());
  if (mapping.compute(projectKey, (key, value) -> value != null && value.getProjectId() == project.getId() ? value : newProject) == newProject) {
   return newProject;
  }
 }
 return null;
}

public String getSourceName() {
  return sourceProject.getPathWithNamespace();
}

public Optional<GitLabIssue> getIssue(String projectName, Integer matchedIssue)
  throws GitChangelogIntegrationException {
 GitlabAPI gitLabApi = GitlabAPI.connect(hostUrl, apiToken);
 GitlabProject project;
 try {
  project = gitLabApi.getProject(projectName);
 } catch (Exception e) {
  throw new GitChangelogIntegrationException(
    "Unable to find project \""
      + projectName
      + "\". It should be \"tomas.bjerre85/violations-test\" for a repo like: https://gitlab.com/tomas.bjerre85/violations-test",
    e);
 }
 Integer projectId = project.getId();
 String httpUrl = project.getHttpUrl();
 try {
  List<GitlabIssue> issues =
    cache.get(new GitLabProjectIssuesCacheKey(hostUrl, apiToken, projectId));
  for (GitlabIssue candidate : issues) {
   if (candidate.getIid() == matchedIssue) {
    return Optional.of(createGitLabIssue(httpUrl, candidate));
   }
  }
  return Optional.absent();
 } catch (Exception e) {
  throw new GitChangelogIntegrationException(e.getMessage(), e);
 }
}

@Test
public void testGetProject() throws IOException {
 List<GitlabProject> list = api.getAllProjects();
 for(GitlabProject project:list){
   System.err.println(project.getName());
   //GitlabUser gu= new GitlabUser();
   // api.addProjectMember(project,)
 }
}

public void update() throws IOException {
  ArrayList<GitlabProjectMember> memberList = new ArrayList<GitlabProjectMember>();
  milestones = api().getMilestones(project);
  memberList.addAll(api().getProjectMembers(project));
  // This might fail sometimes, because the namespace is not an actual namespace.
  // If the "namespace" is a user namespace, it will fail
  try {
    memberList.addAll(api().getNamespaceMembers(project.getNamespace()));
  } catch(Exception e) {
  } catch(Error e) {
  }
  members = Collections.unmodifiableList(memberList);
}

public String getSourceRepository() {
  if (builder.getTrigger().getUseHttpUrl()) {
    return sourceProject.getHttpUrl();
  } else {
    return sourceProject.getSshUrl();
  }
}

    .appendIf("name", project.getName())
    .appendIf("path", project.getPath())
    .appendIf("default_branch", project.getDefaultBranch())
    .appendIf("description", project.getDescription())
    .appendIf("issues_enabled", project.isIssuesEnabled())
    .appendIf("merge_requests_enabled", project.isMergeRequestsEnabled())
    .appendIf("jobs_enabled", project.isJobsEnabled())
    .appendIf("wiki_enabled", project.isWikiEnabled())
    .appendIf("snippets_enabled", project.isSnippetsEnabled())
    .appendIf("container_registry_enabled", project.isContainerRegistryEnabled())
    .appendIf("shared_runners_enabled", project.isSharedRunnersEnabled())
    .appendIf("visibility", project.getVisibility())
    .appendIf("public_jobs", project.hasPublicJobs())
    .appendIf("import_url", project.getImportUrl())
    .appendIf("only_allow_merge_if_pipeline_succeeds", project.getOnlyAllowMergeIfPipelineSucceeds())
    .appendIf("only_allow_merge_if_all_discussions_are_resolved", project.getOnlyAllowMergeIfAllDiscussionsAreResolved())
    .appendIf("lfs_enabled", project.isLfsEnabled())
    .appendIf("request_access_enabled", project.isRequestAccessEnabled())
    .appendIf("repository_storage", project.getRepositoryStorage())
    .appendIf("approvals_before_merge", project.getApprovalsBeforeMerge())
    .appendIf("printing_merge_request_link_enabled", project.isPrintingMergeRequestLinkEnabled());
GitlabNamespace namespace = project.getNamespace();
if (namespace != null) {
  query.appendIf("namespace_id", namespace.getId());

/**
 * Returns the list of build triggers for a project.
 *
 * @param project the project
 * @return list of build triggers
 * @throws IllegalStateException if jobs are not enabled for the project
 */
public List<GitlabTrigger> getPipelineTriggers(GitlabProject project) {
  if (!project.isJobsEnabled()) {
    // if the project has not allowed jobs, you will only get a 403 forbidden message which is
    // not helpful.
    throw new IllegalStateException("Jobs are not enabled for " + project.getNameWithNamespace());
  } else {
    return retrieve().getAll(GitlabProject.URL + "/" + project.getId() + GitlabTrigger.URL + PARAM_MAX_ITEMS_PER_PAGE, GitlabTrigger[].class);
  }
}

private String generateMergeRequestUrl(GitlabServer server, GitlabMergeRequest mergeRequest) {
  final String hostText = server.getApiUrl();
  StringBuilder helpUrl = new StringBuilder();
  helpUrl.append(hostText);
  if (!hostText.endsWith("/")) {
    helpUrl.append("/");
  }
  helpUrl.append(gitlabProject.getPathWithNamespace());
  helpUrl.append("/merge_requests/");
  helpUrl.append(mergeRequest.getIid());
  return helpUrl.toString();
}

@Override
public boolean initializeTaskData(TaskRepository repository, TaskData data,
    ITaskMapping mapping, IProgressMonitor monitor) throws CoreException {
  createDefaultAttributes(data, false);
  GitlabConnection connection = ConnectionManager.get(repository);
  TaskAttribute root = data.getRoot();
  root.getAttribute(GitlabAttribute.PROJECT.getTaskKey()).setValue(connection.project.getName());
  root.getAttribute(GitlabAttribute.LABELS.getTaskKey()).setValue("");
  root.getAttribute(GitlabAttribute.STATUS.getTaskKey()).setValue("open");
  root.getAttribute(GitlabAttribute.MILESTONE.getTaskKey()).setValue("");
  return true;
}

private static String groupAvatarUrl(GitlabProject project, String connectionName) throws GitLabAPIException {
  GitlabNamespace namespace = project.getNamespace();
  if (namespace.getOwnerId() != null) {
    return null;
  }
  GitLabGroup group = gitLabAPI(connectionName).getGroup(namespace.getId());
  return group.getAvatarUrl();
}