Finished implementing NetworkService

src/services/authService.test.ts

@@ -4,8 +4,9 @@ import {VerificationTypeEmail} from "../domain/authService.schema";
 import {faker} from "@faker-js/faker/locale/en";
 
 describe("AuthService", () => {
+    const service = new AuthService();
+
     it("should return authMethods", async () => {
-        const service = new AuthService();
         const methods = await service.getAuthMethods("")
         expect(methods.sms).toBeFalsy()
         expect(methods.email).toBeTruthy()
@@ -13,57 +14,47 @@ describe("AuthService", () => {
     })
 
     it("should send OTP code", async () => {
-        const service = new AuthService();
         const code = await service.otpSendCode("bob@example.com", VerificationTypeEmail)
         expect(code).toBe(5000)
     })
 
     it("should send password reset code", async () => {
-        const service = new AuthService();
         const code = await service.resetPassword("bob@example.com")
         expect(code).toBe(5000)
     })
 
     it("should send PLE code", async () => {
-        const service = new AuthService();
         const code = await service.pleSendVCode("bob@example.com", VerificationTypeEmail)
         expect(code).toBe(5000)
     })
 
     it("should throw on wrong OTP code", async () => {
-        const service = new AuthService();
         await expect(service.otpVerifyCode("bob@example.com", VerificationTypeEmail, 9999)).rejects.toThrow()
     })
 
     it("should throw on wrong password reset code", async () => {
-        const service = new AuthService();
         await expect(service.verifyPasswordReset("bob@example.com", 9999, "newPassword")).rejects.toThrow()
     })
 
     it("should throw on wrong PLE code", async () => {
-        const service = new AuthService();
         await expect(service.pleVerifyCode("bob@example.com", VerificationTypeEmail, 9999)).rejects.toThrow()
     })
 
     it("should throw on wrong password", async () => {
-        const service = new AuthService();
         await expect(service.loginPasswordAuth("bob@example.com", "wrongPasswd")).rejects.toThrow();
     })
 
     it("should detect taken username", async () => {
-        const service = new AuthService();
         const taken = await service.isUsernameUsed("username")
         expect(taken).toBeTruthy()
     })
 
     it("should detect taken e-mail address", async () => {
-        const service = new AuthService();
         const taken = await service.isEmailUsed("taken@example.com")
         expect(taken).toBeTruthy()
     })
 
     it("should register passwordless account", async () => {
-        const service = new AuthService();
         const username = faker.internet.username()
         const displayName = faker.internet.displayName()
         const userData = await service.finishPLEAccount(

src/services/authService.ts

@@ -164,6 +164,7 @@ export class AuthService {
             });
             return resp.data.authCode
         } catch (e) {
+            console.log(e)
             if (isAxiosError<GenericErrorBody>(e)) {
                 throw e;
             }

src/services/networkService.test.ts

@@ -0,0 +1,66 @@
+import {describe, expect, it} from "vitest";
+import {NetworkService} from "./networkService";
+import {DatabaseMock} from "../mocks/storage/database";
+import {faker} from "@faker-js/faker/locale/en";
+import {getClient} from "../core/http";
+import {environment, SDKConfig} from "../core/environment";
+
+describe("NetworkService", () => {
+    const service = new NetworkService("", "", "", new DatabaseMock(), getClient())
+
+    it('should get invites', async () => {
+        const invites = await service.getInvites();
+        expect(invites[0].inviteId).toBe("inviteId")
+    });
+
+    it('should create a network', async () => {
+        const netName = faker.internet.displayName()
+        const network = await service.create(
+            netName,
+            "private",
+            null
+        );
+        expect(network.name).toBe(netName)
+        expect(network.visibility).toBe("private")
+    });
+
+    it('should create a category', async () => {
+        const catName = faker.internet.displayName()
+        const catDesc = faker.lorem.sentence()
+        const category = await service.createCategory(
+            catName,
+            catDesc
+        );
+        expect(category.name).toBe(catName)
+        expect(category.desc).toBe(catDesc)
+    });
+
+    it('should create an invite', async () => {
+        const invite = await service.createInvite(
+            "once",
+        );
+        expect(invite.onetime).toBeTruthy()
+    });
+
+    it('should get permission overwrites', async () => {
+        const ow = await service.getOverwrites("", "");
+        expect(ow[0].permissionNumber).toBe(5000)
+    });
+
+    it('should get channel permission overwrites', async () => {
+        const ow = await service.getChannelOverwrites("", "", "");
+        expect(ow[0].permissionNumber).toBe(5000)
+    });
+
+    it('should get banned members', async () => {
+        const bannedMembers = await service.getBannedMembers();
+        expect(bannedMembers[0].username).toBe("bob")
+        expect(bannedMembers[0].displayName).toBe("Bob")
+    });
+
+    it('should get the detailed member list', async () => {
+        const members = await service.getMembers();
+        expect(members[0].name).toBe("Test rank")
+        expect(members[0].members[0].displayName).toBe("Bob")
+    });
+})

src/services/networkService.ts

@@ -1,4 +1,884 @@
+import {DatabaseAPI} from "../storage/database";
+import {AuthMethods} from "../domain/authService.schema";
+import {getClient} from "../core/http";
+import {AxiosInstance, isAxiosError} from "axios";
+import {GenericErrorBody} from "../domain/http.schema";
+import {
+    AcceptInviteReq, AssignRankToMemberReq, BanMemberReq, ChangeVisibilityReq, CreateCategoryReq, CreateChannelReq,
+    CreateInviteReq,
+    CreateNetworkReq, CreateRankReq, DeleteCategoryReq,
+    DeleteChannelReq, DeleteNetworkReq, DeleteRankReq,
+    DetailedMemberList, EditCategoryReq, EditChannelReq, EditNameReq, EditRankReq,
+    GetBannedMembersReq, GetChannelOverwritesReq, GetMembersReq,
+    GetNetworksReq, GetOverwritesReq, JoinPublicNetworkReq, JoinWebSocketRoomReq, KickMemberReq, LeaveNetworkReq,
+    ModifyPermissionsReq, MoveCategoryReq, MoveRankReq,
+    Network, NetworkCategory, NetworkChannel, NetworkDiscovery,
+    NetworkInvite, NetworkRank, OverwriteChannelPermissionReq, OverwritePermissionReq, PermissionUpdate, POW,
+    RemoveRankFromMemberReq, ToggleCategoryMuteReq, ToggleChannelNetworkMuteReq, ToggleNetworkMuteReq,
+    UnbanMemberReq, UploadNewPictureReq
+} from "../domain/networkService.schema";
+import {PublicUserData, RGB} from "../domain/common.schema";
+import {http} from "msw";
+
 export class NetworkService {
-    constructor(networkId: string) {
+    userid: string;
+    networkId: string;
+    database: DatabaseAPI;
+    client: AxiosInstance
+
+    constructor(userid: string, token: string, networkId: string, database: DatabaseAPI, httpClientOverwrite: AxiosInstance | null) {
+        this.userid = userid;
+        this.networkId = networkId;
+        this.database = database;
+        this.client = (httpClientOverwrite ?? getClient()).create({
+            headers: {
+                "Authorization": token
+            }
+        })
+    }
+
+    /**
+     * Fetches all invites created for the network
+     */
+    async getInvites(): Promise<NetworkInvite[]> {
+        try {
+            const resp = await this.client.get<NetworkInvite[]>(`network/invites?networkId=${this.networkId}&userid=${this.userid}`);
+            return resp.data
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Creates a new network
+     * @param name Provided by the user
+     * @param visibility name Provided by the user
+     * @param data Optional base-64 encoded image for a custom network picture
+     */
+    async create(name: string, visibility: "public" | "private", data: string | null): Promise<Network> {
+        try {
+            const resp = await this.client.post<Network>("network/create", <CreateNetworkReq>{
+                userid: this.userid,
+                data: data,
+                name: name,
+                visibility: visibility,
+                isImage: data != null,
+                monogramLetter: name[0]
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets all networks the user is in
+     */
+    async get(): Promise<Network[]> {
+        try {
+            const resp = await this.client.post<Network[]>("network/get", <GetNetworksReq>{
+                userid: this.userid,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Accepts the invite and joins the network
+     * @param inviteId
+     */
+    async acceptInvite(inviteId: string): Promise<void> {
+        try {
+            const resp = await this.client.post("network/acceptInvite", <AcceptInviteReq>{
+                userid: this.userid,
+                inviteId: inviteId,
+            });
+            return
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Joins a public network
+     * @param networkId
+     */
+    async joinPublicNetwork(networkId: string): Promise<void> {
+        try {
+            const resp = await this.client.post("network/joinNetworkDiscovery", <JoinPublicNetworkReq>{
+                userid: this.userid,
+                networkId: networkId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Creates a new category in the network
+     * @param name Provided by the user
+     * @param description Provided by the user
+     */
+    async createCategory(name: string, description: string): Promise<NetworkCategory> {
+        try {
+            const resp = await this.client.post<NetworkCategory>("network/createCategory", <CreateCategoryReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                name: name,
+                description: description
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes the selected category
+     * @param categoryId
+     */
+    async deleteCategory(categoryId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/deleteCategory", <DeleteCategoryReq>{
+                userid: this.userid,
+                categoryId: categoryId,
+                networkId: this.networkId,
+            });
+            return
+        } catch (e) {
+            console.log(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Moves a category from a specific place to another
+     * @param from The category that will be moved
+     * @param to The place where to category will be moved to
+     */
+    async moveCategory(from: number, to: number): Promise<void> {
+        try {
+            await this.client.patch("network/moveCategory", <MoveCategoryReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                from: from,
+                to: to,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Leaves the network
+     */
+    async leave(): Promise<void> {
+        try {
+            await this.client.post("network/leave", <LeaveNetworkReq>{
+                userid: this.userid,
+                networkId: this.networkId
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes the network (Must be owned by the user)
+     */
+    async delete(): Promise<void> {
+        try {
+            await this.client.post("network/delete", <DeleteNetworkReq>{
+                userid: this.userid,
+                networkId: this.networkId
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Creates a new rank
+     * @param name Provided by the user
+     * @param colors Provided by the user
+     * @param icon Optionally provided by the user
+     */
+    async createRank(name: string, colors: RGB, icon: string | null): Promise<NetworkRank> {
+        try {
+            const resp = await this.client.post<NetworkRank>("network/createRank", <CreateRankReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                colors: colors,
+                icon: icon,
+                name: name,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Creates a new invite
+     * @param times Whether the invite should be used once or unlimited times
+     */
+    async createInvite(times: "once" | "unlimited"): Promise<NetworkInvite> {
+        try {
+            const resp = await this.client.post<NetworkInvite>("network/createInvite", <CreateInviteReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                times: times,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Moves a rank from a specific place to another
+     * @param from The rank that will be moved
+     * @param to The place where to rank will be moved to
+     */
+    async moveRank(from: number, to: number): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/moveRank", <MoveRankReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                from: from,
+                to: to,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Kicks a specific member
+     * @param memberId
+     */
+    async kickMember(memberId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/kickMember", <KickMemberReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                memberId: memberId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Bans a specific member
+     * @param memberId
+     */
+    async banMember(memberId: string): Promise<void> {
+        try {
+            const resp = await this.client.patch("network/banMember", <BanMemberReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                memberId: memberId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Modifies the permissions of the selected rank
+     * @param permissionChanges
+     * @param rankId
+     */
+    async modifyRankPermissions(permissionChanges: PermissionUpdate[], rankId: string): Promise<void> {
+        try {
+            await this.client.patch("network/modifyPermissions", <ModifyPermissionsReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                permissionChanges: permissionChanges,
+                rankId: rankId
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Creates a permission overwrite for a category
+     * @param permissionNumber
+     * @param to
+     * @param rankId
+     * @param categoryId
+     */
+    async overwritePermission(permissionNumber: number, to: string, rankId: string, categoryId: string): Promise<void> {
+        try {
+            await this.client.patch("network/overwritePermission", <OverwritePermissionReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                permissionNumber: permissionNumber,
+                rankId: rankId,
+                categoryId: categoryId,
+                category: categoryId,
+                to: to,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Creates a permission overwrite for a specific channel
+     * @param permissionNumber
+     * @param to
+     * @param rankId
+     * @param categoryId
+     * @param channelId
+     */
+    async overwriteChannelPermission(permissionNumber: number, to: string, rankId: string, categoryId: string, channelId: string): Promise<void> {
+        try {
+            await this.client.patch("network/overwriteChannelPermission", <OverwriteChannelPermissionReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                permissionNumber: permissionNumber,
+                rankId: rankId,
+                categoryId: categoryId,
+                to: to,
+                channelId: channelId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Fetches all permission overwrites made for a category
+     * @param rankId
+     * @param categoryId
+     */
+    async getOverwrites(rankId: string, categoryId: string): Promise<POW[]> {
+        try {
+            const resp = await this.client.patch<POW[]>("network/getOverwrites", <GetOverwritesReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                rankId: rankId,
+                categoryId: categoryId,
+                category: categoryId,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     Fetches all permission overwrites made for a channel
+     * @param rankId
+     * @param categoryId
+     * @param channelId
+     */
+    async getChannelOverwrites(rankId: string, categoryId: string, channelId: string): Promise<POW[]> {
+        try {
+            const resp = await this.client.patch<POW[]>("network/getChannelOverwrites", <GetChannelOverwritesReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                rankId: rankId,
+                categoryId: categoryId,
+                category: categoryId,
+                channelId: channelId
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Modifies the name and/or description of a channel
+     * @param categoryId
+     * @param name
+     * @param desc
+     */
+    async editCategory(categoryId: string, name: string, desc: string): Promise<void> {
+        try {
+            await this.client.patch("network/editCategory", <EditCategoryReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                categoryId: categoryId,
+                name: name,
+                desc: desc,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Unbans a specific member
+     * @param memberId
+     */
+    async unbanMember(memberId: string): Promise<void> {
+        try {
+            await this.client.patch("network/unbanMember", <UnbanMemberReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                memberId: memberId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets all banned members public user data
+     */
+    async getBannedMembers(): Promise<PublicUserData[]> {
+        try {
+            const resp = await this.client.patch<PublicUserData[]>("network/getBannedMembers", <GetBannedMembersReq>{
+                userid: this.userid,
+                networkId: this.networkId
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes a specific rank
+     * @param rankId
+     */
+    async deleteRank(rankId: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/deleteRank", <DeleteRankReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                rankId: rankId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Modifies the name, colors and/or the icon of a specific rank
+     * @param rankId
+     * @param name
+     * @param colors
+     * @param icon
+     */
+    async editRank(rankId: string, name: string, colors: RGB, icon: string | null): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/editRank", <EditRankReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                rankId: rankId,
+                colors: colors,
+                icon: icon,
+                name: name,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Deletes a specific channel
+     * @param categoryId
+     * @param channelId
+     */
+    async deleteChannel(categoryId: string, channelId: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/deleteChannel", <DeleteChannelReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                categoryId: categoryId,
+                channelId: channelId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Edits a specific channel
+     * @param categoryId
+     * @param channelId
+     * @param name
+     * @param desc
+     */
+    async editChannel(categoryId: string, channelId: string, name: string, desc: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/editChannel", <EditChannelReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                categoryId: categoryId,
+                channelId: channelId,
+                name: name,
+                desc: desc,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Removes a rank from a specific member
+     * @param targetUserId
+     * @param rankId
+     */
+    async removeRankFromMember(targetUserId: string, rankId: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/removeRankFromMember", <RemoveRankFromMemberReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                rankId: rankId,
+                targetUserId: targetUserId,
+                userId: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Assigns a rank to a specific member
+     * @param targetUserId
+     * @param rankId
+     */
+    async assignRankToMember(targetUserId: string, rankId: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/assignRankToMember", <AssignRankToMemberReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                rankId: rankId,
+                targetUserId: targetUserId,
+                userId: this.userid,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Gets a detailed member list with all ranks and members inside them
+     */
+    async getMembers(): Promise<DetailedMemberList[]> {
+        try {
+            const resp = await this.client.patch<DetailedMemberList[]>("network/getMembers", <GetMembersReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+            });
+            return resp.data
+        } catch (e) {
+            console.error(e)
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Uploads a new network picture
+     * @param picId
+     */
+    async uploadNewPic(picId: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/uploadNewPic", <UploadNewPictureReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                picId: picId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Changes the visibility of the network
+     * @param to
+     */
+    async changeVisibility(to: "public" | "private"): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/changeVisibility", <ChangeVisibilityReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                to: to,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Edits the name of the network
+     * @param name
+     */
+    async editName(name: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/editName", <EditNameReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                name: name,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Creates a new channel inside a category in the network
+     * @param categoryId
+     * @param type
+     * @param description
+     * @param name
+     */
+    async createChannel(categoryId: string, type: "message" | "broadcast" | "voice", description: string, name: string): Promise<NetworkChannel> {
+        try {
+            const resp = await this.client.patch<NetworkChannel>("network/createChannel", <CreateChannelReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                categoryId: categoryId,
+                name: name,
+                description: description,
+                type: type,
+            });
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * (un)mutes the network
+     */
+    async toggleMute(): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/toggleMute", <ToggleNetworkMuteReq>{
+                userid: this.userid,
+                networkId: this.networkId
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * (un)mutes a category inside the network
+     * @param categoryId
+     */
+    async toggleCategoryMute(categoryId: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/toggleCatMute", <ToggleCategoryMuteReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                categoryId: categoryId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * (un)mutes a channel inside a category in the network
+     * @param channelId
+     */
+    async toggleChannelMute(channelId: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("network/toggleChanMute", <ToggleChannelNetworkMuteReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                channelId: channelId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Starts listening for live changes inside the network
+     * @param connId
+     */
+    async joinWebSocketRoom(connId: string): Promise<void> {
+        try {
+            await this.client.patch<PublicUserData[]>("v2/network/joinWebSocketRoom", <JoinWebSocketRoomReq>{
+                userid: this.userid,
+                networkId: this.networkId,
+                connId: connId,
+            });
+            return
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Fetches network data from an invite
+     * @param inviteId
+     */
+    async getFromInvite(inviteId: string): Promise<Network> {
+        try {
+            const resp = await this.client.get<Network>(`network/fromInvite?inviteId=${inviteId}`);
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
+    }
+
+    /**
+     * Fetches network discovery (A list of public networks)
+     */
+    async getDiscovery(): Promise<NetworkDiscovery[]> {
+        try {
+            const resp = await this.client.get<NetworkDiscovery[]>("network/discovery");
+            return resp.data
+        } catch (e) {
+            if (isAxiosError<GenericErrorBody>(e)) {
+                throw e;
+            }
+            throw new Error("Unexpected error")
+        }
     }
 }