Merge pull request #545 from gskjold/issue_425_projects_columns_cards

Support for projects

pom.xml

@@ -38,6 +38,14 @@
   </properties>
 
   <build>
+    <testResources>
+      <testResource>
+        <directory>src/test/resources</directory>
+        <excludes>
+          <exclude>**/wiremock/**</exclude>
+        </excludes>
+      </testResource>
+    </testResources>
     <plugins>
       <plugin>
         <artifactId>maven-compiler-plugin</artifactId>

src/main/java/org/kohsuke/github/GHOrganization.java

@@ -9,6 +9,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
+import static org.kohsuke.github.Previews.INERTIA;
 
 /**
  * @author Kohsuke Kawaguchi
@@ -193,6 +194,44 @@ public void conceal(GHUser u) throws IOException {
         root.retrieve().method("DELETE").to("/orgs/" + login + "/public_members/" + u.getLogin(), null);
     }
 
+    /**
+     * Returns the projects for this organization.
+     * @param status The status filter (all, open or closed).
+     */
+    public PagedIterable<GHProject> listProjects(final GHProject.ProjectStateFilter status) throws IOException {
+        return new PagedIterable<GHProject>() {
+            public PagedIterator<GHProject> _iterator(int pageSize) {
+                return new PagedIterator<GHProject>(root.retrieve().withPreview(INERTIA)
+                        .with("state", status)
+                        .asIterator(String.format("/orgs/%s/projects", login), GHProject[].class, pageSize)) {
+                    @Override
+                    protected void wrapUp(GHProject[] page) {
+                        for (GHProject c : page)
+                            c.wrap(root);
+                    }
+                };
+            }
+        };
+    }
+
+    /**
+     * Returns all open projects for the organization.
+     */
+    public PagedIterable<GHProject> listProjects() throws IOException {
+        return listProjects(GHProject.ProjectStateFilter.OPEN);
+    }
+
+    /**
+     * Creates a project for the organization.
+     */
+    public GHProject createProject(String name, String body) throws IOException {
+        return root.retrieve().method("POST")
+                .withPreview(INERTIA)
+                .with("name", name)
+                .with("body", body)
+                .to(String.format("/orgs/%s/projects", login), GHProject.class).wrap(root);
+    }
+
     public enum Permission { ADMIN, PUSH, PULL }
 
     /**

src/main/java/org/kohsuke/github/GHProject.java

@@ -0,0 +1,189 @@
+/*
+ * The MIT License
+ *
+ * Copyright 2018 Martin van Zijl.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package org.kohsuke.github;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Locale;
+
+import static org.kohsuke.github.Previews.INERTIA;
+
+/**
+ * A GitHub project.
+ * @see https://developer.github.com/v3/projects/
+ * @author Martin van Zijl
+ */
+public class GHProject extends GHObject {
+    protected GitHub root;
+    protected GHObject owner;
+
+    private String owner_url;
+    private String html_url;
+    private String node_id;
+    private String name;
+    private String body;
+    private int number;
+    private String state;
+    private GHUser creator;
+
+    @Override
+    public URL getHtmlUrl() throws IOException {
+        return GitHub.parseURL(html_url);
+    }
+
+    public GitHub getRoot() {
+        return root;
+    }
+
+    public GHObject getOwner() throws IOException {
+        if(owner == null) {
+            try {
+                if(owner_url.contains("/orgs/")) {
+                    owner = root.retrieve().to(getOwnerUrl().getPath(), GHOrganization.class).wrapUp(root);
+                } else if(owner_url.contains("/users/")) {
+                    owner = root.retrieve().to(getOwnerUrl().getPath(), GHUser.class).wrapUp(root);
+                } else if(owner_url.contains("/repos/")) {
+                    owner = root.retrieve().to(getOwnerUrl().getPath(), GHRepository.class).wrap(root);
+                }
+            } catch (FileNotFoundException e) {
+                return null;
+            }
+        }
+        return owner;
+    }
+
+    public URL getOwnerUrl() {
+        return GitHub.parseURL(owner_url);
+    }
+
+    public String getNode_id() {
+        return node_id;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getBody() {
+        return body;
+    }
+
+    public int getNumber() {
+        return number;
+    }
+
+    public ProjectState getState() {
+        return Enum.valueOf(ProjectState.class, state.toUpperCase(Locale.ENGLISH));
+    }
+
+    public GHUser getCreator() {
+        return creator;
+    }
+
+    public GHProject wrap(GHRepository repo) {
+        this.owner = repo;
+        this.root = repo.root;
+        return this;
+    }
+
+    public GHProject wrap(GitHub root) {
+        this.root = root;
+        return this;
+    }
+
+    private void edit(String key, Object value) throws IOException {
+        new Requester(root).withPreview(INERTIA)._with(key, value).method("PATCH").to(getApiRoute());
+    }
+
+    protected String getApiRoute() {
+        return "/projects/" + id;
+    }
+
+    public void setName(String name) throws IOException {
+        edit("name", name);
+    }
+
+    public void setBody(String body) throws IOException {
+        edit("body", body);
+    }
+
+    public enum ProjectState {
+        OPEN,
+        CLOSED
+    }
+
+    public void setState(ProjectState state) throws IOException {
+        edit("state", state.toString().toLowerCase());
+    }
+
+    public static enum ProjectStateFilter {
+        ALL,
+        OPEN,
+        CLOSED
+    }
+
+    /**
+     * Set the permission level that all members of the project's organization will have on this project.
+     * Only applicable for organization-owned projects.
+     */
+    public void setOrganizationPermission(GHPermissionType permission) throws IOException {
+        edit("organization_permission", permission.toString().toLowerCase());
+    }
+
+    /**
+     * Sets visibility of the project within the organization.
+     * Only applicable for organization-owned projects.
+     */
+    public void setPublic(boolean isPublic) throws IOException {
+        edit("public", isPublic);
+    }
+
+    public void delete() throws IOException {
+        new Requester(root).withPreview(INERTIA).method("DELETE").to(getApiRoute());
+    }
+
+    public PagedIterable<GHProjectColumn> listColumns() throws IOException {
+        final GHProject project = this;
+        return new PagedIterable<GHProjectColumn>() {
+            public PagedIterator<GHProjectColumn> _iterator(int pageSize) {
+                return new PagedIterator<GHProjectColumn>(root.retrieve().withPreview(INERTIA)
+                        .asIterator(String.format("/projects/%d/columns", id), GHProjectColumn[].class, pageSize)) {
+                    @Override
+                    protected void wrapUp(GHProjectColumn[] page) {
+                        for (GHProjectColumn c : page)
+                            c.wrap(project);
+                    }
+                };
+            }
+        };
+    }
+
+    public GHProjectColumn createColumn(String name) throws IOException {
+        return root.retrieve().method("POST")
+                .withPreview(INERTIA)
+                .with("name", name)
+                .to(String.format("/projects/%d/columns", id), GHProjectColumn.class).wrap(this);
+    }
+}

src/main/java/org/kohsuke/github/GHProjectCard.java

@@ -0,0 +1,123 @@
+package org.kohsuke.github;
+
+import org.apache.commons.lang3.StringUtils;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URL;
+
+import static org.kohsuke.github.Previews.INERTIA;
+
+/**
+ * @author Gunnar Skjold
+ */
+public class GHProjectCard extends GHObject {
+	private GitHub root;
+	private GHProject project;
+	private GHProjectColumn column;
+
+	private String note;
+	private GHUser creator;
+	private String content_url, project_url, column_url;
+	private boolean archived;
+
+	public URL getHtmlUrl() throws IOException {
+		return null;
+	}
+
+	public GHProjectCard wrap(GitHub root) {
+		this.root = root;
+		return this;
+	}
+
+	public GHProjectCard wrap(GHProjectColumn column) {
+		this.column = column;
+		this.project = column.project;
+		this.root = column.root;
+		return this;
+	}
+
+	public GitHub getRoot() {
+		return root;
+	}
+
+	public GHProject getProject() throws IOException {
+		if(project == null) {
+			try {
+				project = root.retrieve().to(getProjectUrl().getPath(), GHProject.class).wrap(root);
+			} catch (FileNotFoundException e) {
+				return null;
+			}
+		}
+		return project;
+	}
+
+	public GHProjectColumn getColumn() throws IOException {
+		if(column == null) {
+			try {
+				column = root.retrieve().to(getColumnUrl().getPath(), GHProjectColumn.class).wrap(root);
+			} catch (FileNotFoundException e) {
+				return null;
+			}
+		}
+		return column;
+	}
+
+	public GHIssue getContent() throws IOException {
+		if(StringUtils.isEmpty(content_url))
+			return null;
+		try {
+			if(content_url.contains("/pulls")) {
+				return root.retrieve().to(getContentUrl().getPath(), GHPullRequest.class).wrap(root);
+			} else {
+				return root.retrieve().to(getContentUrl().getPath(), GHIssue.class).wrap(root);
+			}
+		} catch (FileNotFoundException e) {
+			return null;
+		}
+	}
+
+	public String getNote() {
+		return note;
+	}
+
+	public GHUser getCreator() {
+		return creator;
+	}
+
+	public URL getContentUrl() {
+		return GitHub.parseURL(content_url);
+	}
+
+	public URL getProjectUrl() {
+		return GitHub.parseURL(project_url);
+	}
+
+	public URL getColumnUrl() {
+		return GitHub.parseURL(column_url);
+	}
+
+	public boolean isArchived() {
+		return archived;
+	}
+
+	public void setNote(String note) throws IOException {
+		edit("note", note);
+	}
+
+	public void setArchived(boolean archived) throws IOException {
+		edit("archived", archived);
+	}
+
+	private void edit(String key, Object value) throws IOException {
+		new Requester(root).withPreview(INERTIA)._with(key, value).method("PATCH").to(getApiRoute());
+	}
+
+	protected String getApiRoute() {
+		return String.format("/projects/columns/cards/%d", id);
+	}
+
+	public void delete() throws IOException {
+		new Requester(root).withPreview(INERTIA).method("DELETE").to(getApiRoute());
+	}
+}