diff --git a/src/main/java/edu/ksu/canvas/CanvasApiFactory.java b/src/main/java/edu/ksu/canvas/CanvasApiFactory.java index 1e753be0..3f9f2bb1 100644 --- a/src/main/java/edu/ksu/canvas/CanvasApiFactory.java +++ b/src/main/java/edu/ksu/canvas/CanvasApiFactory.java @@ -1,5 +1,7 @@ package edu.ksu.canvas; +import com.google.common.reflect.ClassPath; +import edu.ksu.canvas.annotation.AbstainRegister; import edu.ksu.canvas.impl.*; import edu.ksu.canvas.interfaces.*; import edu.ksu.canvas.net.RestClient; @@ -8,10 +10,13 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import java.io.IOException; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.util.HashMap; import java.util.Map; +import java.util.Set; +import java.util.stream.Collectors; /** * Entry point for using the Canvas API library. It constructs concrete @@ -24,13 +29,14 @@ public class CanvasApiFactory { public static final Integer CANVAS_API_VERSION = 1; private static final Logger LOG = LoggerFactory.getLogger(CanvasApiFactory.class); + private static final String IMPLEMENTATION_PACKAGE = "edu.ksu.canvas.impl"; private static final int DEFAULT_CONNECT_TIMEOUT_MS = 5000; private static final int DEFAULT_READ_TIMEOUT_MS = 120000; - Map, Class> readerMap; - Map, Class> writerMap; - private String canvasBaseUrl; - private int connectTimeout; - private int readTimeout; + private final Map, Class> readerMap = new HashMap<>(); + private final Map, Class> writerMap = new HashMap<>(); + private final String canvasBaseUrl; + private final int connectTimeout; + private final int readTimeout; /** * Construct an API factory for a given instance of Canvas. @@ -41,7 +47,12 @@ public CanvasApiFactory(String canvasBaseUrl) { this.canvasBaseUrl = canvasBaseUrl; this.connectTimeout = DEFAULT_CONNECT_TIMEOUT_MS; this.readTimeout = DEFAULT_READ_TIMEOUT_MS; - setupClassMap(); + try { + setupClassMap(); + } catch (IOException e) { + LOG.error("Error setting up class map", e); + throw new RuntimeException("Error setting up class map", e); + } } /** @@ -55,7 +66,12 @@ public CanvasApiFactory(String canvasBaseUrl, int connectTimeout, int readTimeou this.canvasBaseUrl = canvasBaseUrl; this.connectTimeout = connectTimeout; this.readTimeout = readTimeout; - setupClassMap(); + try { + setupClassMap(); + } catch (IOException e) { + LOG.error("Error setting up class map", e); + throw new RuntimeException("Error setting up class map", e); + } } /** @@ -146,79 +162,29 @@ public T getWriter(Class type, OauthToken oauthToken } } - private void setupClassMap() { - readerMap = new HashMap<>(); - writerMap = new HashMap<>(); - readerMap.put(AccountReader.class, AccountImpl.class); - readerMap.put(AdminReader.class, AdminImpl.class); - readerMap.put(AssignmentOverrideReader.class, AssignmentOverrideImpl.class); - readerMap.put(AssignmentReader.class, AssignmentImpl.class); - readerMap.put(ConversationReader.class, ConversationImpl.class); - readerMap.put(CourseReader.class, CourseImpl.class); - readerMap.put(TabReader.class, TabImpl.class); - readerMap.put(EnrollmentReader.class, EnrollmentImpl.class); - readerMap.put(QuizQuestionReader.class, QuizQuestionImpl.class); - readerMap.put(QuizReader.class, QuizImpl.class); - readerMap.put(QuizSubmissionQuestionReader.class, QuizSubmissionQuestionImpl.class); - readerMap.put(QuizSubmissionReader.class, QuizSubmissionImpl.class); - readerMap.put(SectionReader.class, SectionsImpl.class); - readerMap.put(UserReader.class, UserImpl.class); - readerMap.put(PageReader.class, PageImpl.class); - readerMap.put(EnrollmentTermReader.class, EnrollmentTermImpl.class); - readerMap.put(SubmissionReader.class, SubmissionImpl.class); - readerMap.put(AssignmentGroupReader.class, AssignmentGroupImpl.class); - readerMap.put(RoleReader.class, RoleImpl.class); - readerMap.put(ExternalToolReader.class, ExternalToolImpl.class); - readerMap.put(FileReader.class, FileImpl.class); - readerMap.put(LoginReader.class, LoginImpl.class); - readerMap.put(CalendarReader.class, CalendarEventImpl.class); - readerMap.put(AccountReportSummaryReader.class, AccountReportSummaryImpl.class); - readerMap.put(AccountReportReader.class, AccountReportImpl.class); - readerMap.put(ContentMigrationReader.class, ContentMigrationImpl.class); - readerMap.put(ProgressReader.class, ProgressImpl.class); - readerMap.put(CourseSettingsReader.class, CourseSettingsImpl.class); - readerMap.put(GradingStandardReader.class, GradingStandardImpl.class); - readerMap.put(ModuleReader.class, ModuleImpl.class); - readerMap.put(SisImportReader.class, SisImportImpl.class); - readerMap.put(SelectiveDataReader.class, SelectiveDataImpl.class); - readerMap.put(MigrationIssueReader.class, MigrationIssueImpl.class); - readerMap.put(CommunicationChannelReader.class, CommunicationChannelImpl.class); - readerMap.put(AuthenticationLogReader.class, AuthenticationLogImpl.class); - readerMap.put(FeatureReader.class, FeatureImpl.class); - readerMap.put(FeatureFlagReader.class, FeatureFlagImpl.class); - readerMap.put(RubricReader.class, RubricImpl.class); - - writerMap.put(AccountWriter.class, AccountImpl.class); - writerMap.put(AssignmentOverrideWriter.class, AssignmentOverrideImpl.class); - writerMap.put(AdminWriter.class, AdminImpl.class); - writerMap.put(AssignmentWriter.class, AssignmentImpl.class); - writerMap.put(ConversationWriter.class, ConversationImpl.class); - writerMap.put(CourseWriter.class, CourseImpl.class); - writerMap.put(TabWriter.class, TabImpl.class); - writerMap.put(FileWriter.class, FileImpl.class); - writerMap.put(EnrollmentWriter.class, EnrollmentImpl.class); - writerMap.put(QuizQuestionWriter.class, QuizQuestionImpl.class); - writerMap.put(QuizWriter.class, QuizImpl.class); - writerMap.put(QuizSubmissionQuestionWriter.class, QuizSubmissionQuestionImpl.class); - writerMap.put(QuizSubmissionWriter.class, QuizSubmissionImpl.class); - writerMap.put(UserWriter.class, UserImpl.class); - writerMap.put(PageWriter.class, PageImpl.class); - writerMap.put(SectionWriter.class, SectionsImpl.class); - writerMap.put(SubmissionWriter.class, SubmissionImpl.class); - writerMap.put(AssignmentGroupWriter.class, AssignmentGroupImpl.class); - writerMap.put(RoleWriter.class, RoleImpl.class); - writerMap.put(ExternalToolWriter.class, ExternalToolImpl.class); - writerMap.put(LoginWriter.class, LoginImpl.class); - writerMap.put(CalendarWriter.class, CalendarEventImpl.class); - writerMap.put(AccountReportSummaryWriter.class, AccountReportSummaryImpl.class); - writerMap.put(AccountReportWriter.class, AccountReportImpl.class); - writerMap.put(ContentMigrationWriter.class, ContentMigrationImpl.class); - writerMap.put(ProgressWriter.class, ProgressImpl.class); - writerMap.put(CourseSettingsWriter.class, CourseSettingsImpl.class); - writerMap.put(GradingStandardWriter.class, GradingStandardImpl.class); - writerMap.put(SisImportWriter.class, SisImportImpl.class); - writerMap.put(CommunicationChannelWriter.class, CommunicationChannelImpl.class); - writerMap.put(FeatureFlagWriter.class, FeatureFlagImpl.class); - writerMap.put(RubricWriter.class, RubricImpl.class); + private void setupClassMap() throws IOException { + Set> implClasses = ClassPath.from(this.getClass().getClassLoader()) + .getTopLevelClasses(IMPLEMENTATION_PACKAGE) + .stream() + .map(ClassPath.ClassInfo::load) + .collect(Collectors.toSet()); + + for (Class implClass : implClasses) { + Class[] interfaces = implClass.getInterfaces(); + + for (Class interfaze : interfaces) { + if (interfaze.isAnnotationPresent(AbstainRegister.class)) { + LOG.debug("Skipped registering: {}", implClass.getCanonicalName()); + continue; + } + + if (CanvasReader.class.isAssignableFrom(interfaze) && !interfaze.equals(CanvasReader.class)) { + readerMap.put((Class) interfaze, (Class) implClass); + } else if (CanvasWriter.class.isAssignableFrom(interfaze) && !interfaze.equals(CanvasWriter.class)) { + writerMap.put((Class) interfaze, (Class) implClass); + } + } + } } + } diff --git a/src/main/java/edu/ksu/canvas/TestLauncher.java b/src/main/java/edu/ksu/canvas/TestLauncher.java index 45bd8674..2a7e6dde 100644 --- a/src/main/java/edu/ksu/canvas/TestLauncher.java +++ b/src/main/java/edu/ksu/canvas/TestLauncher.java @@ -2,11 +2,15 @@ import edu.ksu.canvas.interfaces.AccountReader; import edu.ksu.canvas.interfaces.CourseReader; +import edu.ksu.canvas.interfaces.DiscussionTopicReader; import edu.ksu.canvas.model.Account; import edu.ksu.canvas.model.Course; +import edu.ksu.canvas.model.DiscussionTopic; import edu.ksu.canvas.oauth.NonRefreshableOauthToken; import edu.ksu.canvas.oauth.OauthToken; +import edu.ksu.canvas.requestOptions.GetSingleDiscussionTopicOptions; import edu.ksu.canvas.requestOptions.ListCurrentUserCoursesOptions; +import edu.ksu.canvas.requestOptions.ListDiscussionTopicsOptions; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -26,25 +30,13 @@ public class TestLauncher { private static final Logger LOG = LoggerFactory.getLogger(TestLauncher.class); - private String canvasUrl; - private OauthToken oauthToken; + private final String canvasUrl; + private final OauthToken oauthToken; public static void main(String[] args) { - String canvasUrl = null; - String oauthToken = null; - if(args.length != 4) { - LOG.error("Must supply two arguments: --canvas_url http://instance.instructure.com --token [Manually generated token]"); - System.exit(1); - } - for(int i=0; i < args.length; i++) { - if("--canvas_url".equals(args[i])) { - canvasUrl = args[i+1]; - } - if("--token".equals(args[i])) { - oauthToken = args[i+1]; - } - } + String canvasUrl = System.getenv("CANVAS_URL"); + String oauthToken = System.getenv("CANVAS_API_TOKEN"); if(canvasUrl == null || oauthToken == null) { LOG.error("Canvas URL or OAuth token is blank. Must have to continue!"); @@ -53,8 +45,9 @@ public static void main(String[] args) { TestLauncher launcher = new TestLauncher(canvasUrl, oauthToken); try { - launcher.getRootAccount(); + //launcher.getRootAccount(); launcher.getOwnCourses(); + launcher.getDiscussionTopics(); } catch(Exception e) { LOG.error("Problem while executing example methods", e); } @@ -65,6 +58,17 @@ public TestLauncher(String canvasUrl, String tokenString) { this.oauthToken = new NonRefreshableOauthToken(tokenString); } + public void getDiscussionTopics() throws IOException { + CanvasApiFactory apiFactory = new CanvasApiFactory(canvasUrl); + DiscussionTopicReader topicReader = apiFactory.getReader(DiscussionTopicReader.class, oauthToken); + List topics = topicReader.listDiscussionTopics(new ListDiscussionTopicsOptions("141571", ListDiscussionTopicsOptions.IdType.COURSES).onlyAnnouncements()); + System.out.println("Got " + topics.size() + " topics back from Canvas: "); + for (DiscussionTopic topic : topics) { + System.out.println(" topic: " + topic.getTitle()); + System.out.println(topic.getLockInfo()); + } + } + public void getRootAccount() throws IOException { CanvasApiFactory apiFactory = new CanvasApiFactory(canvasUrl); AccountReader acctReader = apiFactory.getReader(AccountReader.class, oauthToken); diff --git a/src/main/java/edu/ksu/canvas/annotation/AbstainRegister.java b/src/main/java/edu/ksu/canvas/annotation/AbstainRegister.java new file mode 100644 index 00000000..c690064a --- /dev/null +++ b/src/main/java/edu/ksu/canvas/annotation/AbstainRegister.java @@ -0,0 +1,11 @@ +package edu.ksu.canvas.annotation; + +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; + +@Target(ElementType.TYPE) +@Retention(RetentionPolicy.RUNTIME) +public @interface AbstainRegister { +} diff --git a/src/main/java/edu/ksu/canvas/impl/DiscussionTopicImpl.java b/src/main/java/edu/ksu/canvas/impl/DiscussionTopicImpl.java new file mode 100644 index 00000000..6b74c18b --- /dev/null +++ b/src/main/java/edu/ksu/canvas/impl/DiscussionTopicImpl.java @@ -0,0 +1,57 @@ +package edu.ksu.canvas.impl; + +import com.google.gson.reflect.TypeToken; +import edu.ksu.canvas.interfaces.DiscussionTopicReader; +import edu.ksu.canvas.interfaces.DiscussionTopicWriter; +import edu.ksu.canvas.model.DiscussionTopic; +import edu.ksu.canvas.net.Response; +import edu.ksu.canvas.net.RestClient; +import edu.ksu.canvas.oauth.OauthToken; +import edu.ksu.canvas.requestOptions.GetSingleDiscussionTopicOptions; +import edu.ksu.canvas.requestOptions.ListDiscussionTopicsOptions; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import java.io.IOException; +import java.lang.reflect.Type; +import java.util.Collections; +import java.util.List; +import java.util.Optional; + +public class DiscussionTopicImpl extends BaseImpl implements DiscussionTopicReader, DiscussionTopicWriter { + + private static final Logger LOG = LoggerFactory.getLogger(DiscussionTopicImpl.class); + + + public DiscussionTopicImpl(String canvasBaseUrl, Integer apiVersion, OauthToken oauthToken, RestClient restClient, int connectTimeout, int readTimeout, Integer paginationPageSize, Boolean serializeNulls) { + super(canvasBaseUrl, apiVersion, oauthToken, restClient, connectTimeout, readTimeout, paginationPageSize, serializeNulls); + } + + + @Override + public List listDiscussionTopics(ListDiscussionTopicsOptions options) throws IOException { + LOG.debug("Getting discussion topics for course/group: {}", options.getCourseOrGroupId()); + String url = buildCanvasUrl(options.getStringIdType() + "/" + options.getCourseOrGroupId() + "/discussion_topics", options.getOptionsMap()); + return getListFromCanvas(url); + } + + @Override + public Optional getDiscussionTopic(GetSingleDiscussionTopicOptions options) throws IOException { + LOG.debug("Getting discussion topic with id: {} for course/group: {}", options.getDiscussionId(), options.getCourseOrGroupId()); + Response response = canvasMessenger.getSingleResponseFromCanvas(oauthToken, buildCanvasUrl(options.getStringIdType() + "/" + options.getCourseOrGroupId() + "/discussion_topics/" + options.getDiscussionId(), options.getOptionsMap())); + if (response.getErrorHappened() || response.getResponseCode() != 200) { + return Optional.empty(); + } + return responseParser.parseToObject(DiscussionTopic.class, response); + } + + @Override + protected Type listType() { + return new TypeToken>(){}.getType(); + } + + @Override + protected Class objectType() { + return DiscussionTopic.class; + } +} \ No newline at end of file diff --git a/src/main/java/edu/ksu/canvas/interfaces/CanvasReader.java b/src/main/java/edu/ksu/canvas/interfaces/CanvasReader.java index ee582ad5..38dfb3d1 100644 --- a/src/main/java/edu/ksu/canvas/interfaces/CanvasReader.java +++ b/src/main/java/edu/ksu/canvas/interfaces/CanvasReader.java @@ -1,6 +1,8 @@ package edu.ksu.canvas.interfaces; +import edu.ksu.canvas.impl.BaseImpl; + import java.util.List; import java.util.function.Consumer; diff --git a/src/main/java/edu/ksu/canvas/interfaces/CourseReader.java b/src/main/java/edu/ksu/canvas/interfaces/CourseReader.java index 05067dfa..cba90903 100644 --- a/src/main/java/edu/ksu/canvas/interfaces/CourseReader.java +++ b/src/main/java/edu/ksu/canvas/interfaces/CourseReader.java @@ -24,7 +24,7 @@ public interface CourseReader extends CanvasReader { List listCurrentUserCourses(ListCurrentUserCoursesOptions options) throws IOException; /** - * Returns the list of active courses for the a user + * Returns the list of active courses for the user * @param options The object holding options for this API call * @return List of courses for the user matching any optional criteria * @throws IOException When there is an error communicating with Canvas diff --git a/src/main/java/edu/ksu/canvas/interfaces/DiscussionTopicReader.java b/src/main/java/edu/ksu/canvas/interfaces/DiscussionTopicReader.java new file mode 100644 index 00000000..6ef9cc6e --- /dev/null +++ b/src/main/java/edu/ksu/canvas/interfaces/DiscussionTopicReader.java @@ -0,0 +1,16 @@ +package edu.ksu.canvas.interfaces; + +import edu.ksu.canvas.model.DiscussionTopic; +import edu.ksu.canvas.requestOptions.GetSingleDiscussionTopicOptions; +import edu.ksu.canvas.requestOptions.ListDiscussionTopicsOptions; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; + +public interface DiscussionTopicReader extends CanvasReader { + + List listDiscussionTopics(ListDiscussionTopicsOptions options) throws IOException; + + Optional getDiscussionTopic(GetSingleDiscussionTopicOptions options) throws IOException; +} \ No newline at end of file diff --git a/src/main/java/edu/ksu/canvas/interfaces/DiscussionTopicWriter.java b/src/main/java/edu/ksu/canvas/interfaces/DiscussionTopicWriter.java new file mode 100644 index 00000000..f691d6e9 --- /dev/null +++ b/src/main/java/edu/ksu/canvas/interfaces/DiscussionTopicWriter.java @@ -0,0 +1,6 @@ +package edu.ksu.canvas.interfaces; + +import edu.ksu.canvas.model.DiscussionTopic; + +public interface DiscussionTopicWriter extends CanvasWriter { +} diff --git a/src/main/java/edu/ksu/canvas/interfaces/EnrollmentTermWriter.java b/src/main/java/edu/ksu/canvas/interfaces/EnrollmentTermWriter.java index 23a3be97..287c889b 100644 --- a/src/main/java/edu/ksu/canvas/interfaces/EnrollmentTermWriter.java +++ b/src/main/java/edu/ksu/canvas/interfaces/EnrollmentTermWriter.java @@ -1,8 +1,10 @@ package edu.ksu.canvas.interfaces; +import edu.ksu.canvas.annotation.AbstainRegister; import edu.ksu.canvas.model.EnrollmentTerm; +@AbstainRegister public interface EnrollmentTermWriter extends CanvasWriter { } diff --git a/src/main/java/edu/ksu/canvas/model/DiscussionTopic.java b/src/main/java/edu/ksu/canvas/model/DiscussionTopic.java new file mode 100644 index 00000000..629b1c0e --- /dev/null +++ b/src/main/java/edu/ksu/canvas/model/DiscussionTopic.java @@ -0,0 +1,316 @@ +package edu.ksu.canvas.model; + +import edu.ksu.canvas.annotation.CanvasField; + +import java.io.Serializable; +import java.util.Date; +import java.util.List; + +public class DiscussionTopic extends BaseCanvasModel implements Serializable { + + public static final long serialVersionUID = 1L; + + private Long id; + private String title; + private String message; + private String htmlUrl; + private Date postedAt; + private Date lastReplyAt; + private Boolean requireInitialPost; + private Boolean userCanSeePosts; + private Long discussionSubentryCount; + private String readState; + private Long unreadCount; + private Boolean subscribed; + private String subscriptionHold; + private Long assignmentId; + private Date delayedPostAt; + private Boolean published; + private Boolean locked; + private Boolean pinned; + private Boolean lockedForUser; + private Object lockInfo; + private String lockExplanation; + private String userName; + // group_topic_children + private Long rootTopicId; + private String podcastUrl; + private String discussionType; + private Long groupCategoryId; + private List attachments; + // permissions + private Boolean allowRating; + private Boolean onlyGradersCanRate; + private Boolean sortByRating; + // TODO: finish adding fields + + @CanvasField(postKey = "id") + public Long getId() { + return id; + } + + public void setId(Long id) { + this.id = id; + } + + @CanvasField(postKey = "title") + public String getTitle() { + return title; + } + + public void setTitle(String title) { + this.title = title; + } + + @CanvasField(postKey = "message") + public String getMessage() { + return message; + } + + public void setMessage(String message) { + this.message = message; + } + + @CanvasField(postKey = "html_url") + public String getHtmlUrl() { + return htmlUrl; + } + + public void setHtmlUrl(String htmlUrl) { + this.htmlUrl = htmlUrl; + } + + @CanvasField(postKey = "posted_at") + public Date getPostedAt() { + return postedAt; + } + + public void setPostedAt(Date postedAt) { + this.postedAt = postedAt; + } + + @CanvasField(postKey = "last_reply_at") + public Date getLastReplyAt() { + return lastReplyAt; + } + + public void setLastReplyAt(Date lastReplyAt) { + this.lastReplyAt = lastReplyAt; + } + + @CanvasField(postKey = "require_initial_post") + public Boolean getRequireInitialPost() { + return requireInitialPost; + } + + public void setRequireInitialPost(Boolean requireInitialPost) { + this.requireInitialPost = requireInitialPost; + } + + @CanvasField(postKey = "user_can_see_posts") + public Boolean getUserCanSeePosts() { + return userCanSeePosts; + } + + public void setUserCanSeePosts(Boolean userCanSeePosts) { + this.userCanSeePosts = userCanSeePosts; + } + + @CanvasField(postKey = "discussion_subentry_count") + public Long getDiscussionSubentryCount() { + return discussionSubentryCount; + } + + public void setDiscussionSubentryCount(Long discussionSubentryCount) { + this.discussionSubentryCount = discussionSubentryCount; + } + + @CanvasField(postKey = "read_state") + public String getReadState() { + return readState; + } + + public void setReadState(String readState) { + this.readState = readState; + } + + @CanvasField(postKey = "unread_count") + public Long getUnreadCount() { + return unreadCount; + } + + public void setUnreadCount(Long unreadCount) { + this.unreadCount = unreadCount; + } + + @CanvasField(postKey = "subscribed") + public Boolean getSubscribed() { + return subscribed; + } + + public void setSubscribed(Boolean subscribed) { + this.subscribed = subscribed; + } + + @CanvasField(postKey = "subscription_hold") + public String getSubscriptionHold() { + return subscriptionHold; + } + + public void setSubscriptionHold(String subscriptionHold) { + this.subscriptionHold = subscriptionHold; + } + + @CanvasField(postKey = "assignment_id") + public Long getAssignmentId() { + return assignmentId; + } + + public void setAssignmentId(Long assignmentId) { + this.assignmentId = assignmentId; + } + + @CanvasField(postKey = "delayed_post_at") + public Date getDelayedPostAt() { + return delayedPostAt; + } + + public void setDelayedPostAt(Date delayedPostAt) { + this.delayedPostAt = delayedPostAt; + } + + @CanvasField(postKey = "published") + public Boolean getPublished() { + return published; + } + + public void setPublished(Boolean published) { + this.published = published; + } + + @CanvasField(postKey = "locked") + public Boolean getLocked() { + return locked; + } + + public void setLocked(Boolean locked) { + this.locked = locked; + } + + @CanvasField(postKey = "pinned") + public Boolean getPinned() { + return pinned; + } + + public void setPinned(Boolean pinned) { + this.pinned = pinned; + } + + @CanvasField(postKey = "locked_for_user") + public Boolean getLockedForUser() { + return lockedForUser; + } + + public void setLockedForUser(Boolean lockedForUser) { + this.lockedForUser = lockedForUser; + } + + @CanvasField(postKey = "lock_info") + public Object getLockInfo() { + return lockInfo; + } + + public void setLockInfo(String lockInfo) { + this.lockInfo = lockInfo; + } + + @CanvasField(postKey = "lock_explanation") + public String getLockExplanation() { + return lockExplanation; + } + + public void setLockExplanation(String lockExplanation) { + this.lockExplanation = lockExplanation; + } + + @CanvasField(postKey = "user_name") + public String getUserName() { + return userName; + } + + public void setUserName(String userName) { + this.userName = userName; + } + + @CanvasField(postKey = "root_topic_id") + public Long getRootTopicId() { + return rootTopicId; + } + + public void setRootTopicId(Long rootTopicId) { + this.rootTopicId = rootTopicId; + } + + @CanvasField(postKey = "podcast_url") + public String getPodcastUrl() { + return podcastUrl; + } + + public void setPodcastUrl(String podcastUrl) { + this.podcastUrl = podcastUrl; + } + + @CanvasField(postKey = "discussion_type") + public String getDiscussionType() { + return discussionType; + } + + public void setDiscussionType(String discussionType) { + this.discussionType = discussionType; + } + + @CanvasField(postKey = "group_category_id") + public Long getGroupCategoryId() { + return groupCategoryId; + } + + public void setGroupCategoryId(Long groupCategoryId) { + this.groupCategoryId = groupCategoryId; + } + + @CanvasField(postKey = "attachments") + public List getAttachments() { + return attachments; + } + + public void setAttachments(List attachments) { + this.attachments = attachments; + } + + @CanvasField(postKey = "allow_rating") + public Boolean getAllowRating() { + return allowRating; + } + + public void setAllowRating(Boolean allowRating) { + this.allowRating = allowRating; + } + + @CanvasField(postKey = "only_graders_can_rate") + public Boolean getOnlyGradersCanRate() { + return onlyGradersCanRate; + } + + public void setOnlyGradersCanRate(Boolean onlyGradersCanRate) { + this.onlyGradersCanRate = onlyGradersCanRate; + } + + @CanvasField(postKey = "sort_by_rating") + public Boolean getSortByRating() { + return sortByRating; + } + + public void setSortByRating(Boolean sortByRating) { + this.sortByRating = sortByRating; + } +} diff --git a/src/main/java/edu/ksu/canvas/requestOptions/GetSingleDiscussionTopicOptions.java b/src/main/java/edu/ksu/canvas/requestOptions/GetSingleDiscussionTopicOptions.java new file mode 100644 index 00000000..357155f9 --- /dev/null +++ b/src/main/java/edu/ksu/canvas/requestOptions/GetSingleDiscussionTopicOptions.java @@ -0,0 +1,41 @@ +package edu.ksu.canvas.requestOptions; + +import java.util.List; + +public class GetSingleDiscussionTopicOptions extends BaseOptions { + + public enum Include { + ALL_DATES, SECTIONS, SECTIONS_USER_COUNT, OVERRIDES + } + + public enum IdType { + COURSES, GROUPS + } + + private final String courseOrGroupId; + private final String discussionId; + private IdType idType; + + public GetSingleDiscussionTopicOptions(String courseOrGroupId, String discussionId, IdType idType) { + this.courseOrGroupId = courseOrGroupId; + this.discussionId = discussionId; + this.idType = idType; + } + + public String getCourseOrGroupId() { + return courseOrGroupId; + } + + public String getDiscussionId() { + return discussionId; + } + + public String getStringIdType() { + return idType.toString().toLowerCase(); + } + + public GetSingleDiscussionTopicOptions includes(List includes) { + addEnumList("include[]", includes); + return this; + } +} \ No newline at end of file diff --git a/src/main/java/edu/ksu/canvas/requestOptions/ListDiscussionTopicsOptions.java b/src/main/java/edu/ksu/canvas/requestOptions/ListDiscussionTopicsOptions.java new file mode 100644 index 00000000..a04dd1de --- /dev/null +++ b/src/main/java/edu/ksu/canvas/requestOptions/ListDiscussionTopicsOptions.java @@ -0,0 +1,77 @@ +package edu.ksu.canvas.requestOptions; + +import java.util.List; + +public class ListDiscussionTopicsOptions extends BaseOptions { + + public enum Include { + ALL_DATES, SECTIONS, SECTIONS_USER_COUNT, OVERRIDES + } + + public enum OrderBy { + POSITION, RECENT_ACTIVITY, DATE + } + + public enum Scope { + LOCKED, UNLOCKED, PINNED, UNPINNED + } + + public enum FilterBy { + ALL, UNREAD + } + + public enum IdType { + COURSES, GROUPS + } + + private final String courseOrGroupId; + private final IdType idType; + + public ListDiscussionTopicsOptions(String courseOrGroupId, IdType idType) { + this.courseOrGroupId = courseOrGroupId; + this.idType = idType; + } + + public String getCourseOrGroupId() { + return courseOrGroupId; + } + + public String getStringIdType() { + return idType.toString().toLowerCase(); + } + + public ListDiscussionTopicsOptions includes(List includes) { + addEnumList("include[]", includes); + return this; + } + + public ListDiscussionTopicsOptions orderBy(OrderBy orderBy) { + addSingleItem("order_by", orderBy.toString()); + return this; + } + + public ListDiscussionTopicsOptions scope(Scope scope) { + addSingleItem("scope", scope.toString()); + return this; + } + + public ListDiscussionTopicsOptions onlyAnnouncements() { + addSingleItem("only_announcements", "true"); + return this; + } + + public ListDiscussionTopicsOptions filterBy(FilterBy filterBy) { + addSingleItem("filter_by", filterBy.toString()); + return this; + } + + public ListDiscussionTopicsOptions searchTerm(String search) { + addSingleItem("search_term", search); + return this; + } + + public ListDiscussionTopicsOptions excludeContextModuleLockedTopics() { + addSingleItem("exclude_context_module_locked_topics", "true"); + return this; + } +}