@winible/winible-typed 1.0.0

package/support/uploadcare.ts

@@ -0,0 +1,191 @@
+import http = require("http");
+import https = require("https");
+import crypto = require("crypto");
+
+function setup_response_handler(
+  res: http.IncomingMessage,
+  callback: (arg0: Error | undefined, arg1?: string | undefined) => void
+) {
+  if (typeof callback !== "function") {
+    return;
+  }
+  var response = "";
+  res.setEncoding("utf8");
+  res.on("data", function (chunk: string) {
+    response += chunk;
+  });
+  res.on("end", function () {
+    var err;
+
+    if (res.statusCode! > 201) {
+      err = new Error(
+        "Unexpected status " + res.statusCode + " from uploadcare.com"
+      );
+    }
+
+    try {
+      response = JSON.parse(response);
+    } catch (e) {
+      return callback(new Error("Invalid JSON from uploadcare.com"), undefined);
+    }
+
+    callback(err, response);
+  });
+}
+
+export default function (
+  public_key: string,
+  private_key: crypto.BinaryLike | crypto.KeyObject,
+  options: {}
+) {
+  var defaults = options || {};
+
+  function _request(
+    method: string,
+    path: string,
+    options: { data?: any; ssl?: any },
+    callback: (err: any, res: any) => void
+  ) {
+    var request_data = JSON.stringify(options.data);
+    if (!options.data) {
+      request_data = "";
+    }
+    var ssl = options.ssl !== false;
+
+    //Prepare headers
+    var content_type = "application/json",
+      //Hash private key
+      content_hash = crypto
+        .createHash("md5")
+        .update(request_data)
+        .digest("hex"),
+      date = new Date().toUTCString(),
+      sign_string = [method, content_hash, content_type, date, path].join("\n"),
+      sign = crypto
+        .createHmac("sha1", private_key)
+        .update(sign_string)
+        .digest("hex"),
+      request_options = {
+        host: "api.uploadcare.com",
+        port: ssl ? 443 : 80,
+        path: path,
+        method: method,
+        headers: {
+          Authentication: "UploadCare " + public_key + ":" + sign,
+          "X-Uploadcare-Date": date,
+          "Content-Type": content_type,
+          "Content-Length": request_data.length,
+        },
+      };
+
+    var req = ssl
+      ? https.request(request_options)
+      : http.request(request_options);
+
+    req.on("response", function (res) {
+      setup_response_handler(res, callback);
+    });
+
+    req.write(request_data);
+    req.end();
+  }
+
+  function _submit(
+    path: any,
+    form: {
+      submit: (
+        arg0: { host: string; port: string; path: any; protocol: string },
+        arg1: (err: any, res: any) => void
+      ) => void;
+    },
+    callback: (arg0: any) => void
+  ) {
+    form.submit(
+      {
+        host: "upload.uploadcare.com",
+        port: "443",
+        path: path,
+        protocol: "https:",
+      },
+      function (err: any, res: any) {
+        if (err) {
+          callback(err);
+        } else {
+          setup_response_handler(res, callback);
+        }
+      }
+    );
+  }
+
+  function post(
+    path: string,
+    options: { data?: any; ssl?: boolean; form?: any },
+    callback: any
+  ) {
+    if (options.form) {
+      _submit(path, options.data, callback);
+    } else {
+      _request("POST", path, options, callback);
+    }
+  }
+
+  function put(path: string, options: {}, callback: any) {
+    _request("PUT", path, options, callback);
+  }
+
+  function get(path: string, callback: any) {
+    _request("GET", path, {}, callback);
+  }
+
+  //
+  // this is a special case when uploading image from URL
+  // you have to check status until you receive a success
+  function upload_fromurl_get_status(
+    token: string,
+    callback: (err: any, file: any) => any
+  ) {
+    var path = "/from_url/status/?token=" + token + "&_=" + Date.now();
+    https.get("https://upload.uploadcare.com" + path, function (res) {
+      setup_response_handler(res, callback);
+    });
+  }
+
+  function remove(path: string, callback: any) {
+    _request("DELETE", path, {}, callback);
+  }
+
+  var api = {
+    files: {
+      store: function (fileId: string, callback: any) {
+        post("/files/" + fileId + "/storage/", {}, callback);
+      },
+      storeCustom: function (fileId: any, target: any, callback: any) {
+        post("/files/", { data: { source: fileId, target: target } }, callback);
+      },
+      info: function (fileId: string, callback: any) {
+        get("/files/" + fileId + "/", callback);
+      },
+      remove: function (fileId: string, callback: any) {
+        remove("/files/" + fileId + "/", callback);
+      },
+      removeMultiple: function (fileIds: any, callback: any) {
+        _request("DELETE", "/files/storage/", { data: fileIds }, callback);
+      },
+    },
+    videos: {
+      convert: function (fileId: string, callback: any) {
+        post(
+          "/convert/video/",
+          {
+            data: {
+              store: 1,
+              paths: [`${fileId}/video/-/format/mp4/`],
+            },
+          },
+          callback
+        );
+      },
+    },
+  };
+  return api;
+}

package/support/utils.ts

@@ -0,0 +1,72 @@
+import dotenv = require("dotenv");
+import UploadCare from "../support/uploadcare";
+dotenv.config();
+
+const uploadcare = UploadCare(
+  "3d93f73d90b8efffadd7",
+  "8fd6cd1136eb7a500164",
+  {}
+);
+
+export const convertVideoToMp4 = async (url: string) => {
+  try {
+    let uuid = url.split("https://ucarecdn.com/")[1];
+    if (!uuid) {
+      console.log("Couldn't parse UUID");
+      return url;
+    }
+    uuid = uuid.split("/")[0];
+    let fileInfo: any = await new Promise((resolve, reject) => {
+      uploadcare.files.info(uuid, (err: any, res: any) => {
+        resolve(res);
+      });
+    });
+
+    let { mime_type } = fileInfo;
+    if (mime_type !== "video/quicktime") {
+      console.log("Not quicktime");
+      return url;
+    }
+    let convertResponse: any = await new Promise((resolve, reject) => {
+      uploadcare.videos.convert(uuid, (err: any, res: any) => {
+        resolve(res);
+      });
+    });
+    let newUUID =
+      convertResponse &&
+      convertResponse.result &&
+      convertResponse.result[0] &&
+      convertResponse.result[0].uuid;
+    if (!newUUID) {
+      return url;
+    }
+    return `https://ucarecdn.com/${newUUID}/`;
+  } catch (err) {
+    console.log(err);
+    return url;
+  }
+};
+
+export const convertImageUrlToImageKit = (url: string, transformation: any) => {
+  if (!url || url.length == 0) {
+    return "";
+  }
+  const rootMappings: any = {
+    "https://paychat-images.s3.amazonaws.com/":
+      "https://ik.imagekit.io/jzv0ymnoihm/paychat-images/",
+    "https://paychat-media.s3.amazonaws.com/":
+      "https://ik.imagekit.io/jzv0ymnoihm/media/",
+    "https://paychat-images.s3.us-west-1.amazonaws.com/":
+      "https://ik.imagekit.io/jzv0ymnoihm/paychat-images/",
+    "https://paychat-media.s3.us-west-1.amazonaws.com/":
+      "https://ik.imagekit.io/jzv0ymnoihm/media/",
+  };
+  let finalUrl = url;
+  for (let key of Object.keys(rootMappings)) {
+    finalUrl = finalUrl.replace(key, rootMappings[key]);
+  }
+  if (transformation) {
+    finalUrl = finalUrl + `?tr=${transformation}`;
+  }
+  return finalUrl;
+};

package/typed-model/asset-category.ts

@@ -0,0 +1,57 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class AssetCategory extends Model<
+  InferAttributes<AssetCategory>,
+  InferCreationAttributes<AssetCategory>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare mediaAssetId: string;
+  declare mediaCategoryId: string;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+AssetCategory.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    mediaAssetId: {
+      type: DataTypes.BIGINT,
+      field: "media_asset_id",
+    },
+    mediaCategoryId: {
+      type: DataTypes.BIGINT,
+      field: "media_category_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "asset_categories",
+    sequelize,
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+export default AssetCategory;

package/typed-model/asset-constent-person.ts

@@ -0,0 +1,82 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+  NonAttribute,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+
+import ConsentPerson from "./consent-person";
+import MediaAsset from "./media-asset";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class AssetConsentPerson extends Model<
+  InferAttributes<AssetConsentPerson>,
+  InferCreationAttributes<AssetConsentPerson>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare consentPersonId: string;
+  declare mediaAssetId: string;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+
+  declare consent_person?: NonAttribute<ConsentPerson>;
+  declare media_asset?: NonAttribute<MediaAsset[]>;
+}
+
+AssetConsentPerson.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: fn("next_id"),
+    },
+    consentPersonId: {
+      type: DataTypes.BIGINT,
+      field: "consent_person_id",
+    },
+    mediaAssetId: {
+      type: DataTypes.BIGINT,
+      field: "media_asset_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    sequelize,
+    tableName: "asset_consent_people",
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+AssetConsentPerson.hasOne(ConsentPerson, {
+  foreignKey: "id",
+  sourceKey: "consentPersonId",
+});
+ConsentPerson.hasMany(AssetConsentPerson, {
+  foreignKey: "consent_person_id",
+  sourceKey: "id",
+});
+
+AssetConsentPerson.hasOne(MediaAsset, {
+  foreignKey: "id",
+  sourceKey: "mediaAssetId",
+});
+MediaAsset.hasMany(AssetConsentPerson, {
+  foreignKey: "media_asset_id",
+  sourceKey: "id",
+});
+
+export default AssetConsentPerson;

package/typed-model/blocked-ip.ts

@@ -0,0 +1,52 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class BlockedIP extends Model<
+  InferAttributes<BlockedIP>,
+  InferCreationAttributes<BlockedIP>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare ipAddress: string;
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+BlockedIP.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    ipAddress: {
+      type: DataTypes.STRING,
+      field: "ip_address",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    tableName: "blocked_ips",
+    sequelize,
+  }
+);
+
+/*
+  ====================================================================
+  Class functions
+  ====================================================================
+  */
+
+export default BlockedIP;

package/typed-model/category-tag.ts

@@ -0,0 +1,66 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+import PhoneOwner from "./phone-owner";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class CategoryTag extends Model<
+  InferAttributes<CategoryTag>,
+  InferCreationAttributes<CategoryTag>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare ownerId: string;
+  declare name: string;
+
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+CategoryTag.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    ownerId: {
+      type: DataTypes.BIGINT,
+      field: "owner_id",
+    },
+    name: {
+      type: DataTypes.STRING,
+      field: "name",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    sequelize,
+    tableName: "category_tags",
+    // Other model options go here
+  }
+);
+
+PhoneOwner.hasMany(CategoryTag, {
+  foreignKey: "owner_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+CategoryTag.hasOne(PhoneOwner, {
+  foreignKey: "id",
+  sourceKey: "owner_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+export default CategoryTag;

package/typed-model/consent-person.ts

@@ -0,0 +1,78 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+
+import sequelize from "./pb-sequelize";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class ConsentPerson extends Model<
+  InferAttributes<ConsentPerson>,
+  InferCreationAttributes<ConsentPerson>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare ownerId: string;
+  declare fullName: string;
+  declare birthday: Date;
+  declare consentFormKey: string;
+  declare idImageKey: string;
+  declare reviewStatus: "pending" | "approved";
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+ConsentPerson.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: fn("next_id"),
+    },
+    ownerId: {
+      type: DataTypes.BIGINT,
+      field: "owner_id",
+    },
+    fullName: {
+      type: DataTypes.STRING,
+      field: "full_name",
+    },
+    birthday: {
+      type: DataTypes.DATE,
+      field: "birthday",
+    },
+    consentFormKey: {
+      type: DataTypes.STRING,
+      field: "consent_form_key",
+    },
+    idImageKey: {
+      type: DataTypes.STRING,
+      field: "id_image_key",
+    },
+    reviewStatus: {
+      type: DataTypes.STRING,
+      field: "review_status",
+      defaultValue: "pending",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    sequelize,
+    tableName: "consent_people",
+  }
+);
+
+/*
+====================================================================
+Class functions
+====================================================================
+*/
+
+export default ConsentPerson;

package/typed-model/content-category-tag.ts

@@ -0,0 +1,79 @@
+import {
+  Model,
+  InferAttributes,
+  InferCreationAttributes,
+  CreationOptional,
+  DataTypes,
+  fn,
+} from "sequelize";
+import CategoryTag from "./category-tag";
+
+import sequelize from "./pb-sequelize";
+import PremiumContent from "./premium-content";
+
+// order of InferAttributes & InferCreationAttributes is important.
+class ContentCategoryTag extends Model<
+  InferAttributes<ContentCategoryTag>,
+  InferCreationAttributes<ContentCategoryTag>
+> {
+  // 'CreationOptional' is a special type that marks the field as optional
+  // when creating an instance of the model (such as using Model.create()).
+  declare id: CreationOptional<string>;
+  declare contentId: string;
+  declare tagId: string;
+
+  declare createdAt: CreationOptional<Date>;
+  declare updatedAt: CreationOptional<Date>;
+}
+
+ContentCategoryTag.init(
+  {
+    id: {
+      type: DataTypes.BIGINT,
+      primaryKey: true,
+      allowNull: false,
+      defaultValue: sequelize.fn("next_id"),
+    },
+    contentId: {
+      type: DataTypes.BIGINT,
+      field: "content_id",
+    },
+    tagId: {
+      type: DataTypes.BIGINT,
+      field: "tag_id",
+    },
+    createdAt: DataTypes.DATE,
+    updatedAt: DataTypes.DATE,
+  },
+  {
+    sequelize,
+    tableName: "content_category_tags",
+    // Other model options go here
+  }
+);
+
+PremiumContent.hasMany(ContentCategoryTag, {
+  foreignKey: "content_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+ContentCategoryTag.hasOne(PremiumContent, {
+  foreignKey: "id",
+  sourceKey: "content_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+CategoryTag.hasMany(ContentCategoryTag, {
+  foreignKey: "tag_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+ContentCategoryTag.hasOne(CategoryTag, {
+  foreignKey: "id",
+  sourceKey: "tag_id",
+  onDelete: "NO ACTION",
+  constraints: false,
+});
+
+export default ContentCategoryTag;