comty.js 0.1.0

package/src/models/livestream/index.js

@@ -0,0 +1,84 @@
+import request from "../../handlers/request"
+
+export default class Livestream {
+    static deleteProfile = async (profile_id) => {
+        const response = await request({
+            method: "DELETE",
+            url: `/tv/streaming/profile`,
+            data: {
+                profile_id
+            }
+        })
+
+        return response.data
+    }
+
+    static postProfile = async (payload) => {
+        const response = await request({
+            method: "POST",
+            url: `/tv/streaming/profile`,
+            data: payload,
+        })
+
+        return response.data
+    }
+
+    static getProfiles = async () => {
+        const response = await request({
+            method: "GET",
+            url: `/tv/streaming/profiles`,
+        })
+
+        return response.data
+    }
+
+    static regenerateStreamingKey = async (profile_id) => {
+        const response = await request({
+            method: "POST",
+            url: `/tv/streaming/regenerate_key`,
+            data: {
+                profile_id
+            }
+        })
+
+        return response.data
+    }
+
+    static getCategories = async (key) => {
+        const response = await request({
+            method: "GET",
+            url: `/tv/streaming/categories`,
+            params: {
+                key,
+            }
+        })
+
+        return response.data
+    }
+
+    static getLivestream = async (payload = {}) => {
+        if (!payload.username) {
+            throw new Error("Username is required")
+        }
+
+        let response = await request({
+            method: "GET",
+            url: `/tv/streams`,
+            params: {
+                username: payload.username,
+                profile_id: payload.profile_id,
+            }
+        })
+
+        return response.data
+    }
+
+    static getLivestreams = async () => {
+        const response = await request({
+            method: "GET",
+            url: `/tv/streams`,
+        })
+
+        return response.data
+    }
+}

package/src/models/playlists/index.js

@@ -0,0 +1,48 @@
+import request from "../../handlers/request"
+
+export default class PlaylistsModel {
+    static putPlaylist = async (payload) => {
+        if (!payload) {
+            throw new Error("Payload is required")
+        }
+
+        const { data } = await request({
+            method: "PUT",
+            url: `/playlist`,
+            data: payload,
+        })
+
+        return data
+    }
+
+    static getPlaylist = async (id) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/playlist/data/${id}`,
+        })
+
+        return data
+    }
+
+    static getMyReleases = async () => {
+        const { data } = await request({
+            method: "GET",
+            url: `/playlist/self`,
+        })
+
+        return data
+    }
+
+    static deletePlaylist = async (id) => {
+        if (!id) {
+            throw new Error("ID is required")
+        }
+
+        const { data } = await request({
+            method: "DELETE",
+            url: `/playlist/${id}`,
+        })
+
+        return data
+    }
+}

package/src/models/post/index.js

@@ -0,0 +1,169 @@
+import request from "../../handlers/request"
+import Settings from "../../helpers/withSettings"
+
+export default class Post {
+    static get maxPostTextLength() {
+        return 3200
+    }
+
+    static get maxCommentLength() {
+        return 1200
+    }
+
+    static getPostingPolicy = async () => {
+        const { data } = await request({
+            method: "GET",
+            url: "/posting_policy",
+        })
+
+        return data
+    }
+
+    static getPost = async ({ post_id }) => {
+        if (!post_id) {
+            throw new Error("Post ID is required")
+        }
+
+        const { data } = await request({
+            method: "GET",
+            url: `/posts/post/${post_id}`,
+        })
+
+        return data
+    }
+
+    static getPostComments = async ({ post_id }) => {
+        if (!post_id) {
+            throw new Error("Post ID is required")
+        }
+
+        const { data } = await request({
+            method: "GET",
+            url: `/comments/post/${post_id}`,
+        })
+
+        return data
+    }
+
+    static sendComment = async ({ post_id, comment }) => {
+        if (!post_id || !comment) {
+            throw new Error("Post ID and/or comment are required")
+        }
+
+        const request = await request({
+            method: "POST",
+            url: `/comments/post/${post_id}`,
+            data: {
+                message: comment,
+            },
+        })
+
+        return request
+    }
+
+    static deleteComment = async ({ post_id, comment_id }) => {
+        if (!post_id || !comment_id) {
+            throw new Error("Post ID and/or comment ID are required")
+        }
+
+        const request = await request({
+            method: "DELETE",
+            url: `/comments/post/${post_id}/${comment_id}`,
+        })
+
+        return request
+    }
+
+    static getExplorePosts = async ({ trim, limit }) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/posts/explore`,
+            params: {
+                trim: trim ?? 0,
+                limit: limit ?? Settings.get("feed_max_fetch"),
+            }
+        })
+
+        return data
+    }
+
+    static getSavedPosts = async ({ trim, limit }) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/posts/saved`,
+            params: {
+                trim: trim ?? 0,
+                limit: limit ?? Settings.get("feed_max_fetch"),
+            }
+        })
+
+        return data
+    }
+
+    static getUserPosts = async ({ user_id, trim, limit }) => {
+        if (!user_id) {
+            // use current user_id
+            user_id = app.userData?._id
+        }
+
+        const { data } = await request({
+            method: "GET",
+            url: `/posts/user/${user_id}`,
+            params: {
+                trim: trim ?? 0,
+                limit: limit ?? Settings.get("feed_max_fetch"),
+            }
+        })
+
+        return data
+    }
+
+    static toogleLike = async ({ post_id }) => {
+        if (!post_id) {
+            throw new Error("Post ID is required")
+        }
+
+        const { data } = await request({
+            method: "POST",
+            url: `/posts/${post_id}/toogle_like`,
+        })
+
+        return data
+    }
+
+    static toogleSave = async ({ post_id }) => {
+        if (!post_id) {
+            throw new Error("Post ID is required")
+        }
+
+        const { data } = await request({
+            method: "POST",
+            url: `/posts/${post_id}/toogle_save`,
+        })
+
+        return data
+    }
+
+    static create = async (payload) => {
+        const { data } = await request({
+            method: "POST",
+            url: `/posts/new`,
+            data: payload,
+        })
+
+        return data
+    }
+
+    static deletePost = async ({ post_id }) => {
+        if (!post_id) {
+            throw new Error("Post ID is required")
+        }
+
+        const { data } = await request({
+            method: "DELETE",
+            url: `/posts/${post_id}`,
+        })
+
+        return data
+    }
+}

package/src/models/session/index.js

@@ -0,0 +1,126 @@
+import jwt_decode from "jwt-decode"
+import request from "../../handlers/request"
+import Storage from "../../helpers/withStorage"
+
+export default class Session {
+    static storageTokenKey = "token"
+
+    static get token() {
+        return Storage.engine.get(this.storageTokenKey)
+    }
+
+    static set token(token) {
+        return Storage.engine.set(this.storageTokenKey, token)
+    }
+
+    static get user_id() {
+        return this.getDecodedToken()?.user_id
+    }
+
+    static get session_uuid() {
+        return this.getDecodedToken()?.session_uuid
+    }
+
+    static getDecodedToken = () => {
+        const token = this.token
+
+        return token && jwt_decode(token)
+    }
+
+    static getAllSessions = async () => {
+        const response = await request({
+            method: "get",
+            url: "/session/all"
+        })
+
+        return response.data
+    }
+
+    static getCurrentSession = async () => {
+        const response = await request({
+            method: "get",
+            url: "/session/current"
+        })
+
+        return response.data
+    }
+
+    static getTokenValidation = async () => {
+        const session = await Session.token
+
+        const response = await request({
+            method: "get",
+            url: "/session/validate",
+            data: {
+                session: session
+            }
+        })
+
+        return response.data
+    }
+
+    static removeToken() {
+        return Storage.engine.remove(Session.storageTokenKey)
+    }
+
+    static destroyCurrentSession = async () => {
+        const token = await Session.token
+        const session = await Session.getDecodedToken()
+
+        if (!session || !token) {
+            return false
+        }
+
+        const response = await request({
+            method: "delete",
+            url: "/session/current"
+        }).catch((error) => {
+            console.error(error)
+
+            return false
+        })
+
+        Session.removeToken()
+
+        __comty_shared_state.eventBus.emit("session.destroyed")
+
+        return response.data
+    }
+
+    static destroyAllSessions = async () => {
+        const session = await Session.getDecodedToken()
+
+        if (!session) {
+            return false
+        }
+
+        const response = await request({
+            method: "delete",
+            url: "/session/all"
+        })
+
+        Session.removeToken()
+
+        __comty_shared_state.eventBus.emit("session.destroyed")
+
+        return response.data
+    }
+
+    static validSession = async (token) => {
+        const response = await request({
+            method: "POST",
+            url: "/session/validate",
+            data: {
+                token: token
+            }
+        })
+
+        return response.data
+    }
+
+    static isCurrentTokenValid = async () => {
+        const health = await Session.getTokenValidation()
+
+        return health.valid
+    }
+}

package/src/models/sync/cores/spotifyCore.js

@@ -0,0 +1,87 @@
+export default class SpotifySyncModel {
+    static get spotify_redirect_uri() {
+        return window.location.origin + "/callbacks/sync/spotify"
+    }
+
+    static get spotify_authorize_endpoint() {
+        return "https://accounts.spotify.com/authorize?response_type=code&client_id={{client_id}}&scope={{scope}}&redirect_uri={{redirect_uri}}&response_type=code"
+    }
+
+    static async authorizeAccount() {
+        const scopes = [
+            "user-read-private",
+            "user-modify-playback-state",
+            "user-read-currently-playing",
+            "user-read-playback-state",
+            "streaming",
+        ]
+
+        const { client_id } = await SpotifySyncModel.get_client_id()
+
+        const parsedUrl = SpotifySyncModel.spotify_authorize_endpoint
+            .replace("{{client_id}}", client_id)
+            .replace("{{scope}}", scopes.join(" "))
+            .replace("{{redirect_uri}}", SpotifySyncModel.spotify_redirect_uri)
+
+        // open on a new tab
+        window.open(parsedUrl, "_blank")
+    }
+
+    static async get_client_id() {
+        const { data } = await app.cores.api.customRequest( {
+            method: "GET",
+            url: `/sync/spotify/client_id`,
+        })
+
+        return data
+    }
+
+    static async syncAuthCode(code) {
+        const { data } = await app.cores.api.customRequest( {
+            method: "POST",
+            url: `/sync/spotify/auth`,
+            data: {
+                redirect_uri: SpotifySyncModel.spotify_redirect_uri,
+                code,
+            },
+        })
+
+        return data
+    }
+
+    static async unlinkAccount() {
+        const { data } = await app.cores.api.customRequest( {
+            method: "POST",
+            url: `/sync/spotify/unlink`,
+        })
+
+        return data
+    }
+
+    static async isAuthorized() {
+        const { data } = await app.cores.api.customRequest( {
+            method: "GET",
+            url: `/sync/spotify/is_authorized`,
+        })
+
+        return data
+    }
+
+    static async getData() {
+        const { data } = await app.cores.api.customRequest( {
+            method: "GET",
+            url: `/sync/spotify/data`,
+        })
+
+        return data
+    }
+
+    static async getCurrentPlaying() {
+        const { data } = await app.cores.api.customRequest( {
+            method: "GET",
+            url: `/sync/spotify/currently_playing`,
+        })
+
+        return data
+    }
+}

package/src/models/sync/index.js

@@ -0,0 +1,11 @@
+import SpotifySyncModel from "./cores/spotifyCore"
+
+export default class SyncModel {
+    static get bridge() {
+        return window.app?.cores.api.withEndpoints()
+    }
+
+    static get spotifyCore() {
+        return SpotifySyncModel
+    }
+}

package/src/models/user/index.js

@@ -0,0 +1,159 @@
+import SessionModel from "../session"
+import request from "../../handlers/request"
+
+export default class User {
+    static data = async (payload = {}) => {
+        let {
+            username,
+            user_id,
+        } = payload
+
+        if (!username && !user_id) {
+            user_id = SessionModel.user_id
+        }
+
+        if (username && !user_id) {
+            // resolve user_id from username
+            const resolveResponse = await request({
+                method: "GET",
+                url: `/user/user_id/${username}`,
+            })
+
+            user_id = resolveResponse.data.user_id
+        }
+
+        const response = await request({
+            method: "GET",
+            url: `/user/${user_id}/data`,
+        })
+
+        return response.data
+    }
+
+    static updateData = async (payload) => {
+        const response = await request({
+            method: "POST",
+            url: "/user/self/update_data",
+            data: {
+                update: payload,
+            },
+        })
+
+        return response.data
+    }
+
+    static unsetFullName = async () => {
+        const response = await request({
+            method: "DELETE",
+            url: "/user/self/public_name",
+        })
+
+        return response.data
+    }
+
+    static selfRoles = async () => {
+        const response = await request({
+            method: "GET",
+            url: "/roles/self",
+        })
+
+        return response.data
+    }
+
+    static haveRole = async (role) => {
+        const roles = await User.selfRoles()
+
+        if (!roles) {
+            return false
+        }
+
+        return Array.isArray(roles) && roles.includes(role)
+    }
+
+    static haveAdmin = async () => {
+        return User.haveRole("admin")
+    }
+
+    static getUserBadges = async (user_id) => {
+        if (!user_id) {
+            user_id = SessionModel.user_id
+        }
+
+        const { data } = await request({
+            method: "GET",
+            url: `/badge/user/${user_id}`,
+        })
+
+        return data
+    }
+
+    static changePassword = async (payload) => {
+        const { currentPassword, newPassword } = payload
+
+        const { data } = await request({
+            method: "POST",
+            url: "/self/update_password",
+            data: {
+                currentPassword,
+                newPassword,
+            }
+        })
+
+        return data
+    }
+
+    static getUserFollowers = async ({
+        user_id,
+        limit = 20,
+        offset = 0,
+    }) => {
+        // if user_id or username is not provided, set with current user
+        if (!user_id && !username) {
+            user_id = SessionModel.user_id
+        }
+
+        const { data } = await request({
+            method: "GET",
+            url: `/user/${user_id}/followers`,
+            params: {
+                limit,
+                offset,
+            }
+        })
+
+        return data
+    }
+
+    static getConnectedUsersFollowing = async () => {
+        const { data } = await request({
+            method: "GET",
+            url: "/status/connected/following",
+        })
+
+        return data
+    }
+
+    static checkUsernameAvailability = async (username) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/user/username_available`,
+            params: {
+                username,
+            }
+        })
+
+        return data
+    }
+
+    static checkEmailAvailability = async (email) => {
+        const { data } = await request({
+            method: "GET",
+            url: `/user/email_available`,
+            params: {
+                email,
+            }
+        })
+
+        return data
+    }
+}

package/src/models/widget/index.js

@@ -0,0 +1,18 @@
+import request from "../../handlers/request"
+
+export default class WidgetModel {
+    static browse = async ({ limit, offset, keywords } = {}) => {
+        const response = await request({
+            instance: globalThis.__comty_shared_state.instances["marketplace"],
+            method: "GET",
+            url: "/widgets",
+            params: {
+                limit,
+                offset,
+                keywords: JSON.stringify(keywords),
+            },
+        })
+
+        return response.data
+    }
+}