Fixing DbService so it just reads and writes the player

.gitignore

@@ -455,3 +455,4 @@ $RECYCLE.BIN/
 !.vscode/launch.json
 !.vscode/extensions.json
 *.org
+/.paket/load/

Bot/PlayerInteractions.fs

@@ -69,7 +69,7 @@ module Commands =
 //                    do! ctx.Member.RevokeRoleAsync(role)
 //                        |> Async.AwaitTask
 
-            do! DbService.removePlayer ctx.Member.Id
+//            do! DbService.removePlayer ctx.Member.Id
 
             do! ctx.CreateResponseAsync("You are now lame", true)
                 |> Async.AwaitTask
@@ -83,26 +83,26 @@ module Commands =
         Name : string
     }
 
-    let leaderboard (ctx : InteractionContext) =
+//    let leaderboard (ctx : InteractionContext) =
-        async {
+//        async {
 //            do! ctx.CreateResponseAsync(InteractionResponseType.DeferredChannelMessageWithSource) |> Async.AwaitTask
-
+//
-            let builder = DiscordInteractionResponseBuilder()
+//            let builder = DiscordFollowupMessageBuilder()
-            builder.IsEphemeral <- true
+//            builder.IsEphemeral <- true
-
+//
-            let! leaders = DbService.getTopPlayers 10
+//            let! leaders = DbService.getTopPlayers 10
-            let content =
+//            let content =
-                leaders
+//                leaders
-                |> Seq.toArray
+//                |> Seq.toArray
-                |> Array.sortByDescending (fun p -> p.Bank)
+//                |> Array.sortByDescending (fun p -> p.Bank)
-                |> Array.mapi (fun i p -> { Position = string (i + 1) ; Amount = string p.Bank ; Name = p.Name })
+//                |> Array.mapi (fun i p -> { Position = string (i + 1) ; Amount = string p.Bank ; Name = p.Name })
-                |> Formatter.Format
+//                |> Formatter.Format
-            builder.Content <- if not <| String.IsNullOrEmpty content then $"```{content}```" else "There are no active hackers"
+//            builder.Content <- if not <| String.IsNullOrEmpty content then $"```{content}```" else "There are no active hackers"
-            do! ctx.Interaction.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource, builder)
+//            do! ctx.Interaction.CreateFollowupMessageAsync(builder)
-                |> Async.AwaitTask
+//                |> Async.AwaitTask
-                |> Async.Ignore
+//                |> Async.Ignore
-        } |> Async.StartAsTask
+//        } |> Async.StartAsTask
-        :> Task
+//        :> Task
 
     let status (ctx : InteractionContext) =
         async {
@@ -134,7 +134,7 @@ type PlayerInteractions() =
     [<SlashCommand("status", "Get your current status like bank account, and active hacks and defenses")>]
     member this.Status (ctx : InteractionContext) = Commands.status ctx
 
-    [<SlashCommand("leaderboard", "View the current list of players ranked by highest earnings")>]
+//    [<SlashCommand("leaderboard", "View the current list of players ranked by highest earnings")>]
-    member this.Leaderboard (ctx : InteractionContext) = Commands.leaderboard ctx
+//    member this.Leaderboard (ctx : InteractionContext) = Commands.leaderboard ctx
 
 

DbService/DbService.fs

@@ -1,60 +1,55 @@
 module Degenz.DbService
 
 open System
+open System.Collections.Generic
 open Degenz.Shared
 open MongoDB.Bson
+open MongoDB.Bson.Serialization
 open MongoDB.Driver
 
-type PlayerEntry = {
-    Id : BsonObjectId
-    Player : Player
-}
 
-//let connString = "mongodb://localhost:27017"
+let mongo = MongoClient(Environment.GetEnvironmentVariable("CONN_STRING"))
-let connString = "mongodb+srv://joe:mtmu3XXe3crUfXdO@stage.2hyxh.mongodb.net/degenz?retryWrites=true&w=majority"
-
-let mongo = MongoClient(connString)
 let db = mongo.GetDatabase("degenz")
-let players = db.GetCollection<PlayerEntry>("players")
+let players = db.GetCollection<BsonDocument>("players")
 
-let tryFindPlayer (id : uint64) : Async<Player option> =
+let tryFindPlayer (id : uint64) =
     async {
-        let filter = Builders<PlayerEntry>.Filter.Eq((fun e -> e.Player.DiscordId), id)
+        let filter = Builders<BsonDocument>.Filter.Eq("Player.DiscordId", id);
-        let! player = players.FindAsync<PlayerEntry>(filter) |> Async.AwaitTask
+        let! player = players.Find<BsonDocument>(filter).FirstOrDefaultAsync() |> Async.AwaitTask
-        return match player.ToEnumerable() |> Seq.toList with
+        return match player with
-               | []  -> None
+               | null -> None
-               | entry::_ -> Some entry.Player
+               | player ->
+                    player
+                        .GetValue("Player")
+                        .ToBsonDocument()
+                        |> BsonSerializer.Deserialize<Player>
+                        |> Some
     }
 
 let insertNewPlayer (player : Player) =
     async {
-        do! { Id = BsonObjectId(ObjectId.GenerateNewId()) ; Player = player }
+        let dict = [ KeyValuePair("Player" , player.ToBsonDocument() :> Object) ]
+        do! BsonDocument(dict)
             |> players.InsertOneAsync
             |> Async.AwaitTask
     }
 
-let removePlayer (memberId : uint64) =
+let deletePlayer (player : Player) =
     async {
-        // TODO: Check the result of this delete operation
+        let dict = [ KeyValuePair("Player" , player.ToBsonDocument() :> Object) ]
-        return! players.DeleteOneAsync (fun e -> e.Player.DiscordId = memberId)
+        do! BsonDocument(dict)
-                |> Async.AwaitTask
+            |> players.InsertOneAsync
-                |> Async.Ignore
+            |> Async.AwaitTask
     }
 
 let updatePlayer player =
     async {
-        let filter = Builders<PlayerEntry>.Filter.Eq((fun e -> e.Player.DiscordId), player.DiscordId)
+        let filter = Builders<BsonDocument>.Filter.Eq("Player.DiscordId", player.DiscordId)
-        let update = Builders<PlayerEntry>.Update.Set((fun e -> e.Player), player)
+        let update = Builders<BsonDocument>.Update.Set("Player", player)
         return! players.UpdateOneAsync(filter, update) |> Async.AwaitTask |> Async.Ignore
     }
 
-let getTopPlayers number =
+//let getTopPlayers amount =
-    async {
+//    async {
-        let! entries =
+//        return! players.FindAsync()
-            players.Find(fun _ -> true)
+//    }
-                   .Limit(Nullable<int>(number))
-                   .SortBy(fun e -> e.Player.Bank)
-                   .ToListAsync()
-                   |> Async.AwaitTask
-        return entries |> Seq.map (fun e -> e.Player)
-    }