WIP: update user, remove user

jellyfin/handler.ts

@@ -4,6 +4,8 @@ import { Config } from "../server/configuration";
 import { UserApi } from "./api/userApi";
 import { logger } from "../server/logger";
 import { SystemApi } from "./api/systemApi";
+import { CreateUserByNameRequest, UpdateUserPolicyRequest, UpdateUserRequest } from "./api";
+import { Maybe } from "../server/interfaces";
 
 export class JellyfinHandler {
 
@@ -40,20 +42,46 @@ export class JellyfinHandler {
   public async addPermissionsToUserAccount(jfUserAccount: UserDto, guildId: string, requestId: string): Promise<UserDto> {
     throw new Error("Method not implemented.");
   }
-  public async createUserAccountForDiscordUser(discordUser: GuildMember, guildId: string, requestId: string): Promise<UserDto> {
+
+  private generatePasswordForUser(user: GuildMember): string {
+    return user.nickname + user.user.discriminator
+  }
+
+  public async createUserAccountForDiscordUser(discordUser: GuildMember, guildId?: string, requestId?: string): Promise<UserDto> {
     const newUserName = this.generateJFUserName(discordUser)
     logger.info(`New Username for ${discordUser.displayName}: ${newUserName}`, { guildId, requestId })
-    throw new Error("Method not implemented.");
+    const req: CreateUserByNameRequest = {
+      name: newUserName,
+      password: this.generatePasswordForUser(discordUser)
+    }
+    logger.debug(JSON.stringify(req))
+    const createResult = await this.userApi.createUserByName(req, this.authHeader)
+    if (createResult.body)
+      return createResult.body
+    else throw new Error('Could not create User in Jellyfin')
   }
-  public async isUserAlreadyPresent(discordUser: GuildMember, guildId: string, requestId?: string): Promise<boolean> {
+
-    const jfUsernameFromDiscordUsername = this.generateJFUserName(discordUser)
+  public async disableJfUser(user: UserDto, guildId?: string, requestId?: string): Promise<void> {
-    const jfUsers = await this.getCurrentUsers(guildId, requestId)
+    if (user.id) {
-    const currentJfUserNames = jfUsers.map(x => x.name)
+      logger.info(`Trying to disable user: ${user.name}|${user.id}`)
-    logger.debug(`Current JF Usernames: ${JSON.stringify(currentJfUserNames)}`)
+      const r: UpdateUserPolicyRequest = {
-    const presence = currentJfUserNames.find(x => x === jfUsernameFromDiscordUsername)
+        ...user.policy,
-    logger.debug(`Presence for DiscordUser ${discordUser.id}:${presence}`)
+        isDisabled: true
-    return presence !== undefined
+      }
+      await this.userApi.updateUserPolicy(user.id, r, this.authHeader)
+      logger.info(`Succeeded with disabling user: ${user.name}`)
+    }
+    else {
+      logger.error(`Can not disable user ${JSON.stringify(user)}, has no id?!`, { requestId, guildId })
+    }
   }
+
+  public async isUserAlreadyPresent(discordUser: GuildMember, requestId?: string): Promise<boolean> {
+    const jfuser = await this.getUser(discordUser, requestId)
+    logger.debug(`Presence for DiscordUser ${discordUser.id}:${jfuser !== undefined}`)
+    return jfuser !== undefined
+  }
+
   public async getCurrentUsers(guildId: string, requestId?: string): Promise<UserDto[]> {
     try {
       const result = await this.userApi.getUsers(undefined, undefined, this.authHeader)
@@ -64,15 +92,47 @@ export class JellyfinHandler {
     return []
   }
 
-  public async removeUser(newMember: GuildMember) {
+  public async getUser(discordUser: GuildMember, requestId?: string): Promise<Maybe<UserDto>> {
-    logger.error(`Trying to remove user ${newMember.displayName}, but method is not implemented`)
+    const jfUsernameFromDiscordUsername = this.generateJFUserName(discordUser)
+    const jfUsers = await this.getCurrentUsers(discordUser.guild.id, requestId)
+    const foundUser = jfUsers.find(x => x.name === jfUsernameFromDiscordUsername)
+    return foundUser
   }
-  public async upsertUser(newMember: GuildMember, level: string, requestId?: string) {
+
-    logger.error(`Trying to upsert user ${newMember.displayName}, with permissionLevel ${level} but method is not implemented`)
+  public async removeUser(newMember: GuildMember, requestId?: string) {
-    const presence = await this.isUserAlreadyPresent(newMember, newMember.guild.id, requestId)
+    logger.error(`Trying to remove user ${newMember.displayName}, but method is not implemented`)
-    if (presence) {
+    const jfuser = await this.getUser(newMember, requestId)
-      logger.info(`User with name ${newMember.displayName} is already present`)
+    if (jfuser) {
+      await this.disableJfUser(jfuser, newMember.guild.id, requestId)
     }
+  }
+
+  public async enableUser(user: UserDto, guildId?: string, requestId?: string): Promise<void> {
+    if (user.id) {
+      logger.info(`Trying to enable user: ${user.name}|${user.id}`)
+      const r: UpdateUserPolicyRequest = {
+        ...user.policy,
+        isDisabled: false
+      }
+      await this.userApi.updateUserPolicy(user.id, r, this.authHeader)
+      logger.info(`Succeeded with enabling user: ${user.name}`)
+    }
+    else {
+      logger.error(`Can not enable user ${JSON.stringify(user)}, has no id?!`, { requestId, guildId })
+    }
+  }
+
+  public async upsertUser(newMember: GuildMember, level: string, requestId?: string) {
+    logger.error(`Trying to upsert user ${newMember.displayName}, with permissionLevel ${level}`)
+    const jfuser = await this.getUser(newMember, requestId)
+    if (jfuser) {
+      logger.info(`User with name ${newMember.displayName} is already present`)
+      await this.enableUser(jfuser, requestId)
+    } else {
+      this.createUserAccountForDiscordUser(newMember, newMember.guild.id, requestId)
+    }
+
+
 
   }
 }

server/interfaces.ts

@@ -1,7 +1,7 @@
 import { Collection } from "@discordjs/collection"
 import { Role } from "discord.js"
 
-export type Maybe<T> = T | undefined
+export type Maybe<T> = T | undefined | null
 export interface Player {
   name: string
 }