Add /v convert slash command

- Add `/v convert` slash command
-> Converts a video to a different mimetype, like webm to mp4

- Update media url finding in our utils

Author: cakedan

src/api/endpoints.ts

@@ -240,6 +240,9 @@ export const Api = Object.freeze({
     '/utilities/qr/scan',
   UTILITIES_SCREENSHOT:
     '/utilities/screenshot',
+
+  VIDEO_TOOLS_CONVERT:
+    '/video/tools/convert',
 });
 
 

src/api/index.ts

@@ -1020,3 +1020,11 @@ export async function utilitiesScreenshot(
 ) {
   return raw.utilitiesScreenshot(context, options);
 }
+
+
+export async function videoToolsConvert(
+  context: RequestContext,
+  options: RestOptions.VideoToolsConvertOptions,
+) {
+  return raw.videoToolsConvert(context, options);
+}

src/api/raw.ts

@@ -2127,3 +2127,22 @@ export async function utilitiesScreenshot(
     },
   });
 }
+
+
+export async function videoToolsConvert(
+  context: RequestContext,
+  options: RestOptions.VideoToolsConvertOptions,
+): Promise<Response> {
+  const query = {
+    to: options.to,
+    url: options.url,
+  };
+  return request(context, {
+    dataOnly: false,
+    query,
+    route: {
+      method: HTTPMethods.POST,
+      path: Api.VIDEO_TOOLS_CONVERT,
+    },
+  });
+}

src/api/types.ts

@@ -415,6 +415,15 @@ export namespace RestOptions {
   export interface UtilitiesScreenshot {
     url: string,
   }
+
+
+  export interface VideoBaseOptions {
+    url: string,
+  }
+
+  export interface VideoToolsConvertOptions extends VideoBaseOptions {
+    to: string,
+  }
 }
 
 

src/commands/interactions/basecommand.ts

@@ -214,6 +214,35 @@ export class BaseInteractionImageCommandOption<ParsedArgsFinished = Interaction.
 }
 
 
+export class BaseInteractionVideoCommandOption<ParsedArgsFinished = Interaction.ParsedArgs> extends BaseInteractionCommandOption<ParsedArgsFinished> {
+  constructor(data: Interaction.InteractionCommandOptionOptions = {}) {
+    super({
+      ...data,
+      options: [
+        ...(data.options || []),
+        {name: 'video', description: 'Emoji/Media URL/User', label: 'url', default: DefaultParameters.lastVideoUrl, value: Parameters.lastVideoUrl},
+      ],
+    });
+  }
+
+  onBeforeRun(context: Interaction.InteractionContext, args: {url?: null | string}) {
+    if (args.url) {
+      context.metadata = Object.assign({}, context.metadata, {contentUrl: args.url});
+    }
+    return !!args.url;
+  }
+
+  onCancelRun(context: Interaction.InteractionContext, args: {url?: null | string}) {
+    if (args.url === undefined) {
+      return editOrReply(context, '⚠ Unable to find any media in the last 50 messages.');
+    } else if (args.url === null) {
+      return editOrReply(context, '⚠ Unable to find that user or it was an invalid url.');
+    }
+    return super.onCancelRun(context, args);
+  }
+}
+
+
 export class BaseInteractionCommandOptionGroup<ParsedArgsFinished = Interaction.ParsedArgs> extends Interaction.InteractionCommandOption<ParsedArgsFinished> {
   error = 'Slash Command';
   type = ApplicationCommandOptionTypes.SUB_COMMAND_GROUP;

src/commands/interactions/slash/video/convert.ts

@@ -0,0 +1,30 @@
+import { Interaction } from 'detritus-client';
+
+import { Formatter } from '../../../../utils';
+
+import { BaseInteractionVideoCommandOption } from '../../basecommand';
+
+
+export const COMMAND_NAME = 'convert';
+
+export class VideoConvertCommand extends BaseInteractionVideoCommandOption {
+  description = 'Convert a Video';
+  name = COMMAND_NAME;
+
+  constructor() {
+    super({
+      options: [
+        {
+          name: 'to',
+          description: 'Conversion Mimetype',
+          choices: Formatter.Commands.VideoConvert.SLASH_CHOICES,
+          default: Formatter.Commands.VideoConvert.DEFAULT_MIMETYPE,
+        },
+      ],
+    });
+  }
+
+  async run(context: Interaction.InteractionContext, args: Formatter.Commands.VideoConvert.CommandArgs) {
+    return Formatter.Commands.VideoConvert.createMessage(context, args);
+  }
+}

src/commands/interactions/slash/video/index.ts

@@ -0,0 +1,20 @@
+import { Permissions } from 'detritus-client/lib/constants';
+
+import { BaseSlashCommand } from '../../basecommand';
+
+import { VideoConvertCommand } from './convert';
+
+
+export default class VideoGroupCommand extends BaseSlashCommand {
+  description = '.';
+  name = 'v';
+
+  constructor() {
+    super({
+      permissions: [Permissions.ATTACH_FILES],
+      options: [
+        new VideoConvertCommand(),
+      ],
+    });
+  }
+}

src/constants.ts

@@ -541,15 +541,43 @@ export enum Mimetypes {
   IMAGE_JPEG = 'image/jpeg',
   IMAGE_PNG = 'image/png',
   IMAGE_WEBP = 'image/webp',
+  VIDEO_M4V = 'video/x-m4v',
+  VIDEO_MP4 = 'video/mp4',
+  VIDEO_MPEG = 'video/mpeg',
+  VIDEO_QUICKTIME = 'video/quicktime',
+  VIDEO_WEBM = 'video/webm',
+  VIDEO_X_MSVIDEO = 'video/x-msvideo',
 };
 
-export const MIMETYPES_SAFE_EMBED = Object.freeze([
+export const MimetypesToExtension = Object.freeze({
+  [Mimetypes.IMAGE_GIF]: 'gif',
+  [Mimetypes.IMAGE_JPEG]: 'jpg',
+  [Mimetypes.IMAGE_PNG]: 'png',
+  [Mimetypes.IMAGE_WEBP]: 'webp',
+  [Mimetypes.VIDEO_M4V]: 'm4v',
+  [Mimetypes.VIDEO_MP4]: 'mp4',
+  [Mimetypes.VIDEO_MPEG]: 'mpeg',
+  [Mimetypes.VIDEO_QUICKTIME]: 'mov',
+  [Mimetypes.VIDEO_WEBM]: 'webm',
+  [Mimetypes.VIDEO_X_MSVIDEO]: 'avi',
+});
+
+
+export const MIMETYPES_IMAGE_EMBEDDABLE = Object.freeze([
   Mimetypes.IMAGE_GIF,
   Mimetypes.IMAGE_JPEG,
   Mimetypes.IMAGE_PNG,
   Mimetypes.IMAGE_WEBP,
 ]);
 
+export const MIMETYPES_VIDEO_EMBEDDABLE = Object.freeze([
+  Mimetypes.VIDEO_QUICKTIME,
+  Mimetypes.VIDEO_MP4,
+  Mimetypes.VIDEO_WEBM,
+]);
+
+
+export const MIMETYPES_SAFE_EMBED = MIMETYPES_IMAGE_EMBEDDABLE;
 
 export const RatelimitKeys = Object.freeze({
   IMAGE: Math.random().toString(36).substring(7),

src/utils/defaultparameters.ts

@@ -4,7 +4,10 @@ import { GuildExplicitContentFilterTypes } from 'detritus-client/lib/constants';
 import { GoogleLocales, GoogleLocaleFromDiscord } from '../constants';
 import UserStore from '../stores/users';
 
-import { findImageUrlInMessages } from './tools';
+import {
+  findImageUrlInMessages,
+  findMediaUrlInMessages,
+} from './tools';
 
 
 export function applications(context: Command.Context | Interaction.InteractionContext) {
@@ -97,6 +100,73 @@ export async function lastImageUrl(context: Command.Context | Interaction.Intera
 }
 
 
+export async function lastVideoUrl(context: Command.Context | Interaction.InteractionContext): Promise<string | null> {
+  const mediaSearchOptions = {image: false};
+
+  if (context instanceof Command.Context) {
+    {
+      const url = findMediaUrlInMessages([context.message], mediaSearchOptions);
+      if (url) {
+        return url;
+      }
+    }
+
+    {
+      // check reply
+      const { messageReference } = context.message;
+      if (messageReference && messageReference.messageId) {
+        let message = messageReference.message;
+        if (!message && (context.inDm || (context.channel && context.channel.canReadHistory))) {
+          try {
+            message = await context.rest.fetchMessage(messageReference.channelId, messageReference.messageId);
+          } catch(error) {
+            // /shrug
+          }
+        }
+        if (message) {
+          const url = findMediaUrlInMessages([message], mediaSearchOptions);
+          if (url) {
+            return url;
+          }
+        }
+      }
+    }
+  }
+
+  const before = (context instanceof Command.Context) ? context.messageId : undefined;
+  {
+    const beforeId = (before) ? BigInt(before) : null;
+    // we dont get DM channels anymore so we must manually find messages now
+    const messages = context.messages.filter((message) => {
+      if (message.channelId !== context.channelId) {
+        return false;
+      }
+      if (message.interaction && message.hasFlagEphemeral) {
+        return message.interaction.user.id === context.userId;
+      }
+      if (beforeId) {
+        return BigInt(message.id) <= beforeId;
+      }
+      return true;
+    }).reverse();
+    const url = findMediaUrlInMessages(messages, mediaSearchOptions);
+    if (url) {
+      return url;
+    }
+  }
+
+  if (context.inDm || (context.channel && context.channel.canReadHistory)) {
+    const messages = await context.rest.fetchMessages(context.channelId!, {before, limit: 50});
+    const url = findMediaUrlInMessages(messages, mediaSearchOptions);
+    if (url) {
+      return url;
+    }
+  }
+
+  return null;
+}
+
+
 export async function locale(context: Command.Context | Interaction.InteractionContext): Promise<GoogleLocales> {
   const user = await UserStore.getOrFetch(context, context.userId);
   if (user && user.locale) {

src/utils/formatter/commands/index.ts

@@ -40,6 +40,9 @@ import * as ToolsQrScan from './tools.qr.scan';
 import * as ToolsScreenshot from './tools.screenshot';
 import * as ToolsTranslate from './tools.translate';
 
+import * as VideoConvert from './video.convert';
+
+
 export {
   ImageBlur,
   ImageBlurple,
@@ -77,4 +80,5 @@ export {
   ToolsQrScan,
   ToolsScreenshot,
   ToolsTranslate,
+  VideoConvert,
 };