jellyfin api -> fetch

server/jellyfin/handler.ts

@@ -0,0 +1,152 @@
+import { GuildMember } from "discord.js";
+import { CreateUserByNameOperationRequest, SystemApi, UpdateUserPolicyOperationRequest, UserApi } from "./apis";
+import { UserDto } from "./models/UserDto";
+import { Configuration, ConfigurationParameters } from "./runtime";
+import { CreateUserByNameRequest, UpdateUserPolicyRequest } from "./models";
+import { Config } from "../configuration";
+import { logger } from "../logger";
+import { Maybe } from "../interfaces";
+
+export class JellyfinHandler {
+
+  private userApi: UserApi
+  private systemApi: SystemApi
+  private token: string
+  private authHeader: { headers: { 'X-MediaBrowser-Token': string } }
+  private config: Config
+  private serverName = "";
+
+  public async ServerName(): Promise<string> {
+    if (this.serverName === "") {
+      const info = await this.systemApi.getSystemInfo(this.authHeader)
+      this.serverName = info.serverName ?? this.config.bot.jellyfin_url
+    }
+    return this.serverName
+  }
+  constructor(_config: Config, _userApi?: UserApi, _systemApi?: SystemApi) {
+    this.config = _config
+    const userApiConfigurationParams: ConfigurationParameters = {
+      basePath: this.config.bot.jellyfin_url
+    }
+    const systemApiConfigurationParams: ConfigurationParameters = {
+      basePath: this.config.bot.jellyfin_url
+    }
+    this.userApi = _userApi ?? new UserApi(new Configuration(userApiConfigurationParams))
+    this.systemApi = _systemApi ?? new SystemApi(new Configuration(systemApiConfigurationParams))
+    this.token = this.config.bot.jellfin_token
+    this.authHeader = {
+      headers: {
+        "X-MediaBrowser-Token": this.token
+      }
+    }
+    logger.info(`Initialized Jellyfin handler`, { requestId: 'Init' })
+  }
+
+  private generateJFUserName(discordUser: GuildMember): string {
+    return discordUser.displayName
+  }
+
+  public async addPermissionsToUserAccount(jfUserAccount: UserDto, guildId: string, requestId: string): Promise<UserDto> {
+    throw new Error("Method not implemented.");
+  }
+
+  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 })
+    const req: CreateUserByNameOperationRequest = {
+      createUserByNameRequest: {
+        name: newUserName,
+        password: this.generatePasswordForUser(discordUser),
+      }
+    }
+    logger.debug(JSON.stringify(req))
+    const createResult = await this.userApi.createUserByName(req, this.authHeader)
+    if (createResult)
+      return createResult
+    else throw new Error('Could not create User in Jellyfin')
+  }
+
+  public async disableJfUser(user: UserDto, guildId?: string, requestId?: string): Promise<void> {
+    if (user.id) {
+      logger.info(`Trying to disable user: ${user.name}|${user.id}`)
+      const r: UpdateUserPolicyOperationRequest = {
+        userId: user.id,
+        updateUserPolicyRequest: {
+          isDisabled: true
+        },
+      }
+      await this.userApi.updateUserPolicy(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 {
+      logger.info(`Fetching current users from Jellyfin`, { requestId, guildId })
+      const result = await this.userApi.getUsers(undefined, this.authHeader)
+      return result
+    } catch (error) {
+      logger.error(`Could not fetch current users from jellyfin`, { guildId, requestId })
+    }
+    return []
+  }
+
+  public async getUser(discordUser: GuildMember, requestId?: string): Promise<Maybe<UserDto>> {
+    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 removeUser(newMember: GuildMember, requestId?: string) {
+    logger.error(`Trying to remove user ${newMember.displayName}, but method is not implemented`)
+    const jfuser = await this.getUser(newMember, requestId)
+    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: UpdateUserPolicyOperationRequest = {
+        userId: user.id ?? "",
+        updateUserPolicyRequest: {
+        }
+      }
+      await this.userApi.updateUserPolicy(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)
+    }
+
+
+
+  }
+}
+