Merge pull request #96 from SLNE-Development/feat/remove-cloud-and-update-with-after-cloud-stuff

Feat/remove cloud and update with after cloud stuff

Author: TheBjoRedCraft

surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/DenylistAction.kt

@@ -57,14 +57,6 @@ interface SurfChatApi {
      */
     fun getUser(uuid: UUID): User?
 
-    /**
-     * Creates a new user in the system.
-     *
-     * @param name The name of the user.
-     * @param uuid The UUID of the user.
-     * @return The created user object.
-     */
-    fun createUser(name: String, uuid: UUID): User
 
     /**
      * Looks up chat history based on a filter.

surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/SurfChatApi.kt

@@ -1,7 +1,7 @@
 package dev.slne.surf.chat.api.channel
 
-import dev.slne.surf.chat.api.entity.ChannelMember
 import dev.slne.surf.chat.api.entity.User
+import dev.slne.surf.chat.api.surfChatApi
 import it.unimi.dsi.fastutil.objects.ObjectSet
 import java.util.*
 
@@ -16,21 +16,23 @@ import java.util.*
  * @property visibility The visibility status of the channel.
  * @property createdAt The timestamp (in milliseconds since epoch) when the channel was created.
  */
-interface Channel {
-    val channelUuid: UUID
-    val channelName: String
-    val members: ObjectSet<ChannelMember>
-    val bannedPlayers: ObjectSet<User>
-    val invitedPlayers: ObjectSet<User>
-    var visibility: ChannelVisibility
+data class Channel(
+    val channelUuid: UUID,
+    val channelName: String,
+    val members: ObjectSet<ChannelMember>,
+    val bannedPlayers: ObjectSet<UUID>,
+    val invitedPlayers: ObjectSet<UUID>,
+    var visibility: ChannelVisibility,
     val createdAt: Long
-
+) {
     /**
      * Allows a user to join the channel.
      *
      * @param user The user attempting to join the channel.
      */
-    fun join(user: User)
+    fun join(user: User) {
+        members.add(ChannelMember(user.uuid, user.name, ChannelRole.MEMBER))
+    }
 
     /**
      * Removes a member from the channel.
@@ -71,82 +73,135 @@ interface Channel {
      *
      * @param member The member to transfer ownership to.
      */
-    fun transfer(member: ChannelMember)
+    fun transfer(member: ChannelMember) {
+        members.removeIf { it.role == ChannelRole.OWNER }
+        members.removeIf { it.uuid == member.uuid }
+        members.add(ChannelMember(member.uuid, member.name, ChannelRole.OWNER))
+    }
 
     /**
      * Leaves the channel and transfers ownership to another member.
      *
      * @param member The member to transfer ownership to.
      */
-    fun leaveAndTransfer(member: ChannelMember)
+    fun leaveAndTransfer(member: ChannelMember) {
+        if (this.isOwner(member)) {
+            var nextOwner =
+                this.members.firstOrNull { it.hasModeratorPermissions() && it.uuid != member.uuid }
+
+            if (nextOwner == null) {
+                nextOwner = this.members.firstOrNull { it.uuid != member.uuid }
+            }
+
+            if (nextOwner == null) {
+                surfChatApi.deleteChannel(this)
+                return
+            }
+
+            this.transfer(nextOwner)
+        }
+
+        this.removeMember(member)
+    }
 
     /**
      * Checks if a user is invited to the channel.
      *
      * @param user The user to check.
      * @return `true` if the user is invited, otherwise `false`.
      */
-    fun isInvited(user: User) = invitedPlayers.contains(user)
+    fun isInvited(user: User) = invitedPlayers.contains(user.uuid)
 
     /**
      * Invites a user to the channel.
      *
      * @param user The user to invite.
      * @return `true` if the user was successfully invited, otherwise `false`.
      */
-    fun invite(user: User) = invitedPlayers.add(user)
+    fun invite(user: User) = invitedPlayers.add(user.uuid)
 
     /**
      * Revokes an invitation for a user.
      *
      * @param user The user whose invitation is to be revoked.
      * @return `true` if the invitation was successfully revoked, otherwise `false`.
      */
-    fun revoke(user: User) = invitedPlayers.remove(user)
+    fun revoke(user: User) = invitedPlayers.remove(user.uuid)
 
     /**
      * Promotes a member to a higher role in the channel.
      *
      * @param member The member to promote.
      * @return `true` if the promotion was successful, otherwise `false`.
      */
-    fun promote(member: ChannelMember): Boolean
+    fun promote(member: ChannelMember): Boolean {
+        if (member.role == ChannelRole.MODERATOR) {
+            return false
+        }
+
+        member.role = ChannelRole.MODERATOR
+
+        members.remove(member)
+        return members.add(member)
+    }
 
     /**
      * Demotes a member to a lower role in the channel.
      *
      * @param member The member to demote.
      * @return `true` if the demotion was successful, otherwise `false`.
      */
-    fun demote(member: ChannelMember): Boolean
+    fun demote(member: ChannelMember): Boolean {
+        if (member.role == ChannelRole.MEMBER) {
+            return false
+        }
+
+        member.role = ChannelRole.MEMBER
+
+        members.remove(member)
+        return members.add(member)
+    }
 
     /**
      * Bans a user from the channel.
      *
      * @param user The user to ban.
      */
-    fun ban(user: User)
+    fun ban(user: User) {
+        if (this.isBanned(user)) {
+            return
+        }
+
+        members.removeIf { it.uuid == user.uuid }
+        bannedPlayers.add(user.uuid)
+    }
 
     /**
      * Unbans a user from the channel.
      *
      * @param user The user to unban.
      * @return `true` if the user was successfully unbanned, otherwise `false`.
      */
-    fun unban(user: User) = bannedPlayers.remove(user)
+    fun unban(user: User) = bannedPlayers.remove(user.uuid)
 
     /**
      * Checks if a user is banned from the channel.
      *
      * @param user The user to check.
      * @return `true` if the user is banned, otherwise `false`.
      */
-    fun isBanned(user: User): Boolean = bannedPlayers.contains(user)
+    fun isBanned(user: User): Boolean = bannedPlayers.contains(user.uuid)
 
     /**
      * Kicks a member from the channel.
      *
      * @param member The member to kick.
      */
-    fun kick(member: ChannelMember)
+    fun kick(member: ChannelMember) {
+        if (!members.contains(member)) {
+            return
+        }
+
+        leaveAndTransfer(member)
+    }
 }

surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/channel/Channel.kt

@@ -1,6 +1,5 @@
-package dev.slne.surf.chat.api.entity
+package dev.slne.surf.chat.api.channel
 
-import dev.slne.surf.chat.api.channel.ChannelRole
 import java.util.*
 
 /**
@@ -10,11 +9,11 @@ import java.util.*
  * @property name The name of the channel member.
  * @property role The role of the channel member in the chat channel.
  */
-interface ChannelMember {
-    val uuid: UUID // The unique ID of the member
-    val name: String // The name of the member
-    var role: ChannelRole // The role of the member in the channel
-
+data class ChannelMember(
+    val uuid: UUID,
+    val name: String,
+    var role: ChannelRole
+) {
     /**
      * Checks if the member has moderator permissions.
      *

…ne/surf/chat/api/entity/ChannelMember.kt …e/surf/chat/api/channel/ChannelMember.ktsurf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/entity/ChannelMember.kt renamed to surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/channel/ChannelMember.kt surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/entity/ChannelMember.kt renamed to surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/channel/ChannelMember.kt

@@ -0,0 +1,13 @@
+package dev.slne.surf.chat.api.denylist
+
+/**
+ * Represents an action to be applied to a user in the denylist system.
+ * This action is typically used for enforcement of chat rules
+ * and allows specifying the type of action, its duration, and the reason for it.
+ */
+data class DenylistAction(
+    val name: String,
+    val actionType: DenylistActionType,
+    val reason: String,
+    val duration: Long
+)

surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/denylist/DenylistAction.kt

@@ -1,4 +1,4 @@
-package dev.slne.surf.chat.api.entry
+package dev.slne.surf.chat.api.denylist
 
 /**
  * Represents the type of action to be taken for a denylist entry.

…urf/chat/api/entry/DenylistActionType.kt …/chat/api/denylist/DenylistActionType.ktsurf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/entry/DenylistActionType.kt renamed to surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/denylist/DenylistActionType.kt surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/entry/DenylistActionType.kt renamed to surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/denylist/DenylistActionType.kt

@@ -0,0 +1,18 @@
+package dev.slne.surf.chat.api.denylist
+
+/**
+ * Represents an entry in the denylist system.
+ *
+ * This interface defines the structure and details associated with a denylist entry.
+ * It includes information about the word triggering the denylist, the reason for
+ * its presence in the denylist, and metadata about who added it and when it was added.
+ * The associated action specifies the type of moderation enforcement to apply when
+ * the denylist entry is triggered.
+ */
+data class DenylistEntry(
+    val word: String,
+    val reason: String,
+    val addedBy: String,
+    val addedAt: Long,
+    val action: DenylistAction
+)

surf-chat-api/src/main/kotlin/dev/slne/surf/chat/api/denylist/DenylistEntry.kt

@@ -1,38 +1,24 @@
 package dev.slne.surf.chat.api.entity
 
-import dev.slne.surf.chat.api.channel.Channel
+import dev.slne.surf.chat.api.entry.IgnoreListEntry
+import kotlinx.serialization.Contextual
+import kotlinx.serialization.Serializable
 import java.util.*
 
+@Serializable
 /**
  * Represents a user in the chat system.
  *
  * @property name The name of the user.
  * @property uuid The unique identifier of the user.
  */
-interface User {
-    val name: String
-    val uuid: UUID
+data class User(
+    val name: String,
+    val uuid: @Contextual UUID,
 
-    /**
-     * Checks if the user has a specific permission.
-     *
-     * @param permission The permission to check.
-     * @return `true` if the user has the specified permission, otherwise `false`.
-     */
-    fun hasPermission(permission: String): Boolean
+    var directMessagesEnabled: Boolean = true,
+    var channelInviteMessagesEnabled: Boolean = true,
+    var chatPingsEnabled: Boolean = true,
 
-    /**
-     * Provides a configurable interface for the user.
-     *
-     * @return An instance of `ConfigurableUser` to manage user settings.
-     */
-    fun configure(): ConfigurableUser
-
-    /**
-     * Retrieves the user's membership in a specific channel.
-     *
-     * @param channel The channel to check membership for.
-     * @return An instance of `ChannelMember` if the user is a member of the channel, otherwise `null`.
-     */
-    fun channelMember(channel: Channel): ChannelMember?
-}
+    val ignorelist: MutableList<IgnoreListEntry> = mutableListOf()
+)