Added search subcommand

Author: KuroganeToyama

docs/COMMAND-WIKI.md

@@ -310,7 +310,7 @@
 - **Description:** Handle UWFlow commands.
 - **Examples:**
 - **Options:** None
-- **Subcommands:** `info`, `req`
+- **Subcommands:** `info`, `req`, `search`
 
 ## uwflow info
 - **Aliases:** `information`, `i`
@@ -326,6 +326,13 @@
 - **Options:** 
 - **Subcommands:** None
 
+## uwflow search
+- **Aliases:** None
+- **Description:** Search for courses in specified range
+- **Examples:**<br>`.uwflow search CS 100 200`<br>`.uwflow search cs 100 200`
+- **Options:** 
+- **Subcommands:** None
+
 # SUGGESTION 
 ## suggestion 
 - **Aliases:** ``suggest``

src/commandDetails/uwflow/search.ts

@@ -0,0 +1,93 @@
+import { container } from '@sapphire/framework';
+import {
+  CodeyCommandDetails,
+  CodeyCommandOptionType,
+  SapphireMessageExecuteType,
+  SapphireMessageResponse,
+} from '../../codeyCommand';
+import { searchResults, getSearchResults } from '../../components/uwflow';
+import { EmbedBuilder } from 'discord.js';
+
+const uwflowSearchExecuteCommand: SapphireMessageExecuteType = async (
+  _client,
+  _messageFromUser,
+  args,
+): Promise<SapphireMessageResponse> => {
+  const courseArg = <string>args['course'];
+  const min = <number>args['min'];
+  const max = <number>args['max'];
+
+  // Standardize the course initials (i.e. CS becomes cs for the GraphQL query)
+  const course = courseArg.toLowerCase();
+
+  const results: searchResults[] | number = await getSearchResults(course, min, max);
+
+  // If mistyped course initials or course doesn't exist
+  if (results === -1) {
+    const errorDesc = 'UWFlow returned no data';
+    const courseEmbed = new EmbedBuilder()
+      .setColor('Red')
+      .setTitle(`Information for query of ${course.toUpperCase()} courses in range ${min} - ${max}`)
+      .setDescription(errorDesc);
+    return { embeds: [courseEmbed] };
+  }
+
+  const resultArray = <searchResults[]>results;
+  // If no courses fit the range
+  if (resultArray.length < 1) {
+    const desc = 'No courses suit the query';
+    const embed = new EmbedBuilder()
+      .setColor('Orange')
+      .setTitle(`Information for query of ${course} courses in range ${min} - ${max}`)
+      .setDescription(desc);
+    return { embeds: [embed] };
+  }
+
+  const courseArray: string[] = [];
+  for (const result of resultArray) {
+    courseArray.push(result.code);
+  }
+
+  const desc = courseArray.join(', ');
+
+  const resultEmbed = new EmbedBuilder()
+    .setColor('Green')
+    .setTitle(`Information for query of ${course} courses in range ${min} - ${max}`)
+    .setDescription(desc);
+
+  return { embeds: [resultEmbed] };
+};
+
+export const uwflowSearchCommandDetails: CodeyCommandDetails = {
+  name: 'search',
+  aliases: [],
+  description: 'Search for courses in specified range',
+  detailedDescription: `**Examples:**
+\`${container.botPrefix}uwflow search CS 100 200\`
+\`${container.botPrefix}uwflow search cs 100 200\``,
+
+  isCommandResponseEphemeral: false,
+  messageWhenExecutingCommand: 'Getting information from UWFlow:',
+  executeCommand: uwflowSearchExecuteCommand,
+  options: [
+    {
+      name: 'course',
+      description: 'The initials of the course. Examples: CS, cs, MATH, math',
+      type: CodeyCommandOptionType.STRING,
+      required: true,
+    },
+    {
+      name: 'min',
+      description: 'The minimum code of the course',
+      type: CodeyCommandOptionType.INTEGER,
+      required: true,
+    },
+    {
+      name: 'max',
+      description: 'The maximum code of the course',
+      type: CodeyCommandOptionType.INTEGER,
+      required: true,
+    },
+  ],
+  subcommandDetails: {},
+};

src/commands/uwflow/uwflow.ts

@@ -1,6 +1,7 @@
 import { Command } from '@sapphire/framework';
 import { uwflowInfoCommandDetails } from '../../commandDetails/uwflow/info';
 import { uwflowReqCommandDetails } from '../../commandDetails/uwflow/req';
+import { uwflowSearchCommandDetails } from '../../commandDetails/uwflow/search';
 import { CodeyCommand, CodeyCommandDetails } from '../../codeyCommand';
 
 const uwflowCommandDetails: CodeyCommandDetails = {
@@ -12,6 +13,7 @@ const uwflowCommandDetails: CodeyCommandDetails = {
   subcommandDetails: {
     info: uwflowInfoCommandDetails,
     req: uwflowReqCommandDetails,
+    search: uwflowSearchCommandDetails,
   },
   defaultSubcommandDetails: uwflowInfoCommandDetails,
 };

src/components/uwflow.ts

@@ -58,6 +58,26 @@ export interface courseReqs {
   coreqs: string;
 }
 
+// Search results interface for UWflow
+interface searchResultsFromUrl {
+  data: {
+    search_courses: [
+      {
+        name: string;
+        code: string;
+        has_prereqs: boolean;
+      },
+    ];
+  };
+}
+
+// Search results interface for CodeyBot
+export interface searchResults {
+  name: string;
+  code: string;
+  has_prereqs: boolean;
+}
+
 // Format string
 const formatInput = (input: string | null): string => {
   if (input === null) {
@@ -145,3 +165,50 @@ export const getCourseReqs = async (courseCode: string): Promise<courseReqs | nu
 
   return result;
 };
+
+// Retrieve courses in range of course code
+export const getSearchResults = async (
+  course: string,
+  min: number,
+  max: number,
+): Promise<searchResults[] | number> => {
+  const resultFromUWFLow: searchResultsFromUrl = (
+    await axios.post(uwflowApiUrl, {
+      operationName: 'explore',
+      variables: {
+        query: course,
+        code_only: true,
+      },
+      query: `query explore($query: String, $code_only: Boolean) {
+                search_courses(args: { query: $query, code_only: $code_only })  {
+                    name
+                    code
+                    has_prereqs
+                }
+            }`,
+    })
+  ).data;
+
+  // If no data is found, return -1 to signal error
+  if (resultFromUWFLow.data.search_courses.length < 1) {
+    return -1;
+  }
+
+  // Search results
+  const results = resultFromUWFLow.data.search_courses;
+
+  // Array of courses in range [min, max]
+  const resultArray: searchResults[] = results.filter((result) => {
+    const code = result.code;
+    let numString = '';
+    for (const char of code) {
+      if (!isNaN(parseInt(char))) {
+        numString += char;
+      }
+    }
+    const num = parseInt(numString, 10);
+    return min <= num && num <= max;
+  });
+
+  return resultArray;
+};