Feat/bot discord

.env

@@ -1,15 +1,15 @@
 PORT = 3002
 HTTPS = TRUE
 
-TYPEORM_CONNECTION = sqlite
-TYPEORM_HOST = localhost
-TYPEORM_USERNAME = root
-TYPEORM_PASSWORD = admin
-TYPEORM_DATABASE = database/lol-stalker.db
-TYPEORM_PORT = 3000
-TYPEORM_SYNCHRONIZE = false
-TYPEORM_ENTITIES = **/entities/*.js
-TYPEORM_MIGRATIONS_DIR = migration
-TYPEORM_MIGRATIONS = migration/*.js
+#TYPEORM_CONNECTION = sqlite
+#TYPEORM_HOST = localhost
+#TYPEORM_USERNAME = root
+#TYPEORM_PASSWORD = admin
+#TYPEORM_DATABASE = $Env:APPDATA/LoL-stalker/database/lol-stalker.dev.db
+#TYPEORM_PORT = 3000
+#TYPEORM_SYNCHRONIZE = false
+#TYPEORM_ENTITIES = **/entities/*.js
+#TYPEORM_MIGRATIONS_DIR = electron/migration
+#TYPEORM_MIGRATIONS = migration/*.js
 
-TYPEORM_LOGGING = false
+#TYPEORM_LOGGING = false

electron/db.ts

@@ -1,16 +1,36 @@
 import isDev from "electron-is-dev";
 import path from "path";
+import fs from "fs/promises";
 import sqlite3 from "sqlite3";
 
 import { createConnection } from "typeorm";
-const dbUrl = path.join(__dirname, "database", "lol-stalker.db");
-// export const db = new sqlite3.Database(dbUrl);
+import { app } from "electron";
+const dbFolder = path.join(app.getPath("userData"), "database");
+const dbUrl = path.join(dbFolder, isDev ? "lol-stalker.dev.db" : "lol-stalker.db");
 
-export const makeDb = () =>
-    isDev
-        ? createConnection()
-        : createConnection({
-              type: "sqlite",
-              database: dbUrl,
-              entities: [path.join(__dirname, "entities/*")],
-          });
+export const makeDb = async () => {
+    try {
+        await fs.stat(dbFolder);
+    } catch (e) {
+        await fs.mkdir(dbFolder);
+    }
+    try {
+        await fs.stat(dbUrl);
+    } catch (e) {
+        await createDbFile();
+        console.log(`db file ${dbUrl} does not exist, creating it`);
+    }
+
+    return createConnection({
+        type: "sqlite",
+        database: dbUrl,
+        entities: [path.join(__dirname, "entities/*")],
+        migrationsRun: true,
+        migrations: [path.join(__dirname, "migration/*")],
+    });
+};
+
+const createDbFile = () =>
+    new Promise((resolve, reject) => {
+        new sqlite3.Database(dbUrl, (err) => (err ? reject(err) : resolve(true)));
+    });

electron/entities/Friend.ts

@@ -35,6 +35,9 @@ export class Friend {
     @Column("datetime", { name: "createdAt", default: () => "CURRENT_TIMESTAMP" })
     createdAt: Date;
 
+    @Column("text", { name: "subscription", nullable: true })
+    subscription: string;
+
     @Column("boolean", { name: "isCurrentSummoner", default: () => "false" })
     isCurrentSummoner: boolean;
 

electron/features/autoLaunch.ts

@@ -0,0 +1,39 @@
+import AutoLaunch from "auto-launch";
+import electronIsDev from "electron-is-dev";
+import { editStoreEntry, store } from "./store";
+
+export const initAutoLauch = async () => {
+    const autoLaunch = new AutoLaunch({ name: "LoL Stalker" });
+    await editStoreEntry("autoLaunch", autoLaunch);
+
+    if (electronIsDev) return console.log("AutoLaunch doesn't work in development");
+    const isEnabled = await autoLaunch.isEnabled();
+
+    if (store.config.autoLaunch && !isEnabled) autoLaunch.enable();
+    else if (isEnabled) autoLaunch.disable();
+};
+
+export const enableAutoLaunch = async () => {
+    console.log("enabling autolaunch...");
+    if (electronIsDev) return console.log("AutoLaunch doesn't work in development");
+    const autoLaunch = store.autoLaunch;
+    if (!autoLaunch) return;
+
+    const isEnabled = await autoLaunch.isEnabled();
+
+    if (isEnabled) return;
+    autoLaunch.enable();
+    console.log("autolaunch enabled");
+};
+
+export const disableAutoLauch = async () => {
+    console.log("disabling autolaunch...");
+    const autoLaunch = store.autoLaunch;
+    if (!autoLaunch) return;
+
+    const isEnabled = await autoLaunch.isEnabled();
+
+    if (!isEnabled) return;
+    autoLaunch.disable();
+    console.log("autolaunch disabled");
+};

electron/LCU/lcu.ts → electron/features/lcu/lcu.ts

@@ -2,36 +2,37 @@ import { pick } from "@pastable/core";
 import axios, { AxiosInstance } from "axios";
 import https from "https";
 import LCUConnector from "lcu-connector";
-import { Friend } from "../entities/Friend";
-import { sendInvalidate } from "../routes";
-import { addOrUpdateFriends, getSelectedFriends } from "../routes/friends";
-import { selectedFriends } from "../selection";
-import { sendToClient, Tier } from "../utils";
+import { Friend } from "../../entities/Friend";
+import { sendToClient, Tier } from "../../utils";
 import { CurrentSummoner, FriendDto, MatchDto, Queue, RankedStats } from "./types";
+import { editStoreEntry, Locale, store } from "../store";
+import { addOrUpdateFriends } from "../routes/friends";
 
 const httpsAgent = new https.Agent({ rejectUnauthorized: false });
 export const connector = new LCUConnector();
-export const connectorStatus = {
-    current: null as any,
-    api: null as unknown as AxiosInstance,
-};
 
-export const sendConnectorStatus = () => sendToClient("lcu/connection", connectorStatus.current);
+export const sendConnectorStatus = () => sendToClient("lcu/connection", store.connectorStatus);
 
 connector.on("connect", async (data) => {
-    connectorStatus.current = data;
+    editStoreEntry("connectorStatus", data);
     const { protocol, username, password, address, port } = data;
     const baseURL = `${protocol}://${username}:${password}@${address}:${port}`;
-    connectorStatus.api = axios.create({
+    store.lcu = axios.create({
         baseURL,
         httpsAgent,
         headers: { Authorization: `Basic ${data.password}` },
     });
     console.log("connected to riot client");
+
+    try {
+        const locale = await getRegionLocale();
+        await editStoreEntry("locale", locale);
+    } catch (e) {
+        console.log(e);
+    }
 });
 connector.on("disconnect", () => {
-    connectorStatus.current = null;
-    sendInvalidate("lcuStatus");
+    editStoreEntry("connectorStatus", null);
 });
 
 export interface AuthData {
@@ -57,13 +58,14 @@ export const compareFriends = async (oldFriends: FriendStats[], newFriends: Frie
         if (
             newFriend.division !== oldFriend.division ||
             newFriend.tier !== oldFriend.tier ||
-            newFriend.leaguePoints !== oldFriend.leaguePoints
+            newFriend.leaguePoints !== oldFriend.leaguePoints ||
+            newFriend.miniSeriesProgress !== oldFriend.miniSeriesProgress
         ) {
             changes.push({
                 ...newFriend,
                 oldFriend,
                 toNotify: !!oldFriend.division,
-                windowsNotification: selectedFriends.current?.has(newFriend.puuid),
+                windowsNotification: store.selectedFriends?.has(newFriend.puuid),
             });
         }
     });
@@ -85,7 +87,7 @@ export const postMessage = (payload: { summonerName: string; message: string })
     const url = `/lol-game-client-chat/v1/instant-messages?summonerName=${encodeURI(
         payload.summonerName
     )}&message=${encodeURI(payload.message)}`;
-    return connectorStatus.api.post(url);
+    return store.lcu?.post(url);
 };
 
 export const getAllApexLeague = async () => {
@@ -103,6 +105,7 @@ export const getApexLeague = (tier: RankedStats["queues"][0]["tier"]) =>
 ///lol-ranked-stats/v1/stats/{summonerId}
 export const getHelp = () => request("/help?format=Console");
 export const getBuild = () => request("/system/v1/builds");
+export const getRegionLocale = () => request<Locale>("/riotclient/region-locale");
 export const getCurrentSummoner = () =>
     request<CurrentSummoner>("/lol-summoner/v1/current-summoner");
 export const getFriends = () => request<FriendDto[]>("/lol-chat/v1/friends");
@@ -153,4 +156,4 @@ export const getSwagger = () => request("/swagger/v2/swagger.json");
 
 type AxiosMethod = "get" | "post" | "put" | "delete" | "patch";
 export const request = async <T>(uri: string, method: AxiosMethod = "get") =>
-    (await connectorStatus.api[method]<T>(uri)).data as T;
+    (await store.lcu?.[method]<T>(uri))?.data as T;

electron/LCU/types.ts → electron/features/lcu/types.ts

@@ -1,4 +1,4 @@
-import { Friend } from "../entities/Friend";
+import { Friend } from "../../entities/Friend";
 
 export interface FriendDto extends Friend {
     availability: string;

electron/routes/friends.ts → electron/features/routes/friends.ts

@@ -2,12 +2,11 @@ import { pick } from "@pastable/core";
 import debug from "debug";
 import { getManager } from "typeorm";
 import { sendFriendList, sendInvalidate } from ".";
-import { Friend } from "../entities/Friend";
-import { FriendName } from "../entities/FriendName";
-import { Ranking } from "../entities/Ranking";
-import { FriendDto } from "../LCU/types";
-import { editSelectedFriends, persistSelectedFriends, selectedFriends } from "../selection";
-import { sendToClient } from "../utils";
+import { Friend } from "../../entities/Friend";
+import { FriendName } from "../../entities/FriendName";
+import { Ranking } from "../../entities/Ranking";
+import { FriendDto } from "../lcu/types";
+import { editStoreEntry, store } from "../store";
 
 const friendFields: (keyof FriendDto)[] = [
     "gameName",
@@ -44,10 +43,17 @@ export const getFriendsAndRankingsFromDb = () => {
 };
 
 export const getFriendAndRankingsFromDb = (puuid: Friend["puuid"]) =>
-    getManager().findOne(Friend, {
-        where: { puuid },
-        relations: ["rankings", "friendNames", "notifications"],
-    });
+    getManager()
+        .createQueryBuilder(Friend, "friend")
+        .leftJoinAndSelect("friend.rankings", "rankings")
+        .leftJoinAndSelect("friend.friendNames", "friendNames")
+        .leftJoinAndSelect("friend.notifications", "notifications")
+        .orderBy("rankings.createdAt", "DESC")
+        .orderBy("notifications.createdAt", "DESC")
+        .orderBy("friendNames.createdAt", "DESC")
+        .where("friend.puuid = :puuid", { puuid })
+        .getOne();
+
 export const getFriendsAndLastRankingFromDb = async () => {
     const friends = await getFriendsAndRankingsFromDb();
     return friends.map((friend) => {
@@ -62,18 +68,19 @@ export const getFriendsAndLastRankingFromDb = async () => {
     });
 };
 
-export const getSelectedFriends = async () => Array.from(selectedFriends.current!);
-export const toggleSelectFriends = async (puuids: Friend["puuid"][], newState: boolean) =>
-    editSelectedFriends(() =>
-        puuids.forEach((puuid) => selectedFriends.current?.[newState ? "add" : "delete"](puuid))
-    );
+export const toggleSelectFriends = async (puuids: Friend["puuid"][], newState: boolean) => {
+    const newSelectedFriends = new Set(store.selectedFriends);
+
+    puuids.forEach((puuid) => newSelectedFriends?.[newState ? "add" : "delete"](puuid));
+    await editStoreEntry("selectedFriends", newSelectedFriends);
+};
+
 export const selectAllFriends = async (select: boolean) => {
     const friends = await getFriendsFromDb();
-    return editSelectedFriends(() =>
-        friends.forEach((friend) =>
-            selectedFriends.current?.[select ? "add" : "delete"](friend.puuid)
-        )
-    );
+    const newSelectedFriends = new Set(store.selectedFriends);
+
+    friends.forEach((friend) => newSelectedFriends?.[select ? "add" : "delete"](friend.puuid));
+    await editStoreEntry("selectedFriends", newSelectedFriends);
 };
 
 const friendDtoToFriend = (friendDto: FriendDto): Partial<Friend> => ({
@@ -91,10 +98,6 @@ const friendDtoToFriend = (friendDto: FriendDto): Partial<Friend> => ({
     ]),
 });
 
-export const inGameFriends: { current: any[] } = {
-    current: null as any,
-};
-
 export const addOrUpdateFriends = async (friends: FriendDto[]) => {
     const existingFriends = await getFriendsFromDb();
     const manager = getManager();
@@ -103,13 +106,15 @@ export const addOrUpdateFriends = async (friends: FriendDto[]) => {
 
     for (const friend of friends) {
         if (
-            friend.lol.gameStatus !== "outOfGame" &&
+            !["outOfGame", "hosting_RANKED_SOLO_5x5", "spectating"].includes(
+                friend.lol.gameStatus
+            ) &&
             friend.lol.gameQueueType === "RANKED_SOLO_5x5"
         ) {
             currentInGame.push({
-                ...pick(friend, ["puuid", "gameName", "icon"]),
+                ...pick(friend, ["puuid", "gameName", "icon", "name"]),
                 ...pick(friend.lol, ["championId", "timeStamp", "gameStatus"]),
-            }); // championId: friend.lol.championId});
+            });
         }
         const friendDto = pick(friend, friendFields);
         const existingFriend = existingFriends.find((ef) => ef.puuid === friend.puuid);
@@ -138,7 +143,8 @@ export const addOrUpdateFriends = async (friends: FriendDto[]) => {
             await manager.save(manager.create(Friend, friendDtoToFriend(friendDto)));
         }
     }
-    inGameFriends.current = [...currentInGame];
+
+    await editStoreEntry("inGameFriends", [...currentInGame]);
     sendInvalidate("friendList/in-game");
     sendFriendList();
     debug("add or update ended");
@@ -159,7 +165,6 @@ export const friendsApi = {
     getFriendsAndRankingsFromDb,
     getFriendAndRankingsFromDb,
     getFriendsAndLastRankingFromDb,
-    getSelectedFriends,
     toggleSelectFriends,
     addOrUpdateFriends,
     addRanking,