diff --git a/src/bot.ts b/src/bot.ts
index 3422880637d950d6ab4e19a1803de1a8561b7f00..6a160ce6da2aa760f384b4b9c9a63ee0c8dd8805 100644
--- a/src/bot.ts
+++ b/src/bot.ts
@@ -208,11 +208,13 @@ export class DiscordBot {
if (!Array.isArray(msg)) {
msg = [msg];
}
- msg.forEach((m) => {
+ msg.forEach((m: Discord.Message) => {
this.sentMessages.push(m.id);
const evt = new DbEvent();
evt.MatrixId = event.event_id;
evt.DiscordId = m.id;
+ evt.GuildId = m.guild.id;
+ evt.ChannelId = m.channel.id;
this.store.Insert(evt);
});
return;
@@ -539,6 +541,8 @@ export class DiscordBot {
const evt = new DbEvent();
evt.MatrixId = res.event_id;
evt.DiscordId = msg.id;
+ evt.ChannelId = msg.channel.id;
+ evt.GuildId = msg.guild.id;
this.store.Insert(evt);
});
});
diff --git a/src/db/dbdataevent.ts b/src/db/dbdataevent.ts
index 3b7e92e7eb99f1ac9608f413af5aafcf72c158e8..f89ef6872150de7632b4b5f4755f834788ea4190 100644
--- a/src/db/dbdataevent.ts
+++ b/src/db/dbdataevent.ts
@@ -5,57 +5,85 @@ import * as log from "npmlog";
export class DbEvent implements IDbData {
public MatrixId: string;
public DiscordId: string;
+ public GuildId: string;
+ public ChannelId: string;
public Result: boolean;
public async RunQuery(store: DiscordStore, params: any): Promise<null> {
log.silly("DiscordStore", "_get_schema_version");
- let row = null;
+ let rowM = null;
if (params.matrix_id) {
- row = await store.db.getAsync(`
+ rowM = await store.db.getAsync(`
SELECT *
FROM event_store
WHERE matrix_id = $id`, {
$id: params.matrix_id,
});
} else if (params.discord_id) {
- row = await store.db.getAsync(`
+ rowM = await store.db.getAsync(`
SELECT *
FROM event_store
WHERE discord_id = $id`, {
$id: params.discord_id,
});
} else {
- throw new Error("Unknown row given as a param");
+ throw new Error("Unknown/incorrect id given as a param");
}
- this.Result = row !== undefined;
+ this.Result = rowM !== undefined;
if (this.Result) {
- this.MatrixId = row.matrix_id;
- this.DiscordId = row.discord_id;
+ this.MatrixId = rowM.matrix_id;
+ this.DiscordId = rowM.discord_id;
+ const rowD = await store.db.getAsync(`
+ SELECT *
+ FROM discord_msg_store
+ WHERE msg_id = $id`, {
+ $id: rowM.discord_id,
+ });
+ if (rowD !== undefined) {
+ this.GuildId = rowD.guild_id;
+ this.ChannelId = rowD.guild_id;
+ } else {
+ this.Result = false;
+ throw new Error("Could not find discord event data in discord_msg_store");
+ }
}
return null;
}
- public Insert(store: DiscordStore): Promise<null> {
- return store.db.runAsync(`
+ public async Insert(store: DiscordStore): Promise<null> {
+ await store.db.runAsync(`
INSERT INTO event_store
(matrix_id,discord_id)
VALUES ($matrix_id,$discord_id);`, {
$matrix_id: this.MatrixId,
$discord_id: this.DiscordId,
});
+ return store.db.runAsync(`
+ INSERT INTO discord_msg_store
+ (msg_id, guild_id, channel_id)
+ VALUES ($msg_id, $guild_id, $channel_id);`, {
+ $msg_id: this.DiscordId,
+ $guild_id: this.GuildId,
+ $channel_id: this.ChannelId,
+ });
}
public Update(store: DiscordStore): Promise<null> {
throw new Error("Update is not implemented");
}
- public Delete(store: DiscordStore): Promise<null> {
- return store.db.runAsync(`
+ public async Delete(store: DiscordStore): Promise<null> {
+ await store.db.runAsync(`
DELETE FROM event_store
WHERE matrix_id = $matrix_id
AND discord_id = $discord_id;`, {
$matrix_id: this.MatrixId,
$discord_id: this.DiscordId,
});
+ return store.db.runAsync(`
+ DELETE FROM discord_msg_store
+ WHERE msg_id = $discord_id;`, {
+ $discord_id: this.DiscordId,
+ });
}
}
diff --git a/src/db/dbdatainterface.ts b/src/db/dbdatainterface.ts
index 5f16794336797558883dd18d98665a1e976de65b..74ab8d7afdc0c56ae4105adb2823276d0985607d 100644
--- a/src/db/dbdatainterface.ts
+++ b/src/db/dbdatainterface.ts
@@ -2,8 +2,8 @@ import { DiscordStore } from "../store";
export interface IDbData {
Result: boolean;
- RunQuery(store: DiscordStore, params: any): Promise<null>;
- Insert(store: DiscordStore): Promise<null>;
- Update(store: DiscordStore): Promise<null>;
- Delete(store: DiscordStore): Promise<null>;
+ RunQuery(store: DiscordStore, params: any): Promise<null|Error>;
+ Insert(store: DiscordStore): Promise<null|Error>;
+ Update(store: DiscordStore): Promise<null|Error>;
+ Delete(store: DiscordStore): Promise<null|Error>;
}
diff --git a/src/db/schema/v5.ts b/src/db/schema/v5.ts
index 433eb996c5d1f890661e737045a356423fda5dbc..8d6320dd3413d1772b6268463db24951ec4f176b 100644
--- a/src/db/schema/v5.ts
+++ b/src/db/schema/v5.ts
@@ -17,7 +17,7 @@ export class Schema implements IDbSchema {
public rollBack(store: DiscordStore): Promise <null> {
return store.db.execAsync(
- `DROP TABLE IF EXISTS guild_emoji;`,
+ `DROP TABLE IF EXISTS event_store;`,
);
}
}
diff --git a/src/db/schema/v6.ts b/src/db/schema/v6.ts
new file mode 100644
index 0000000000000000000000000000000000000000..d1c5882cc06ec290de3e547aeb0024e95005bc9a
--- /dev/null
+++ b/src/db/schema/v6.ts
@@ -0,0 +1,34 @@
+import {IDbSchema} from "./dbschema";
+import {DiscordStore} from "../../store";
+import {DiscordClientFactory} from "../../clientfactory";
+import * as log from "npmlog";
+import * as Bluebird from "bluebird";
+
+export class Schema implements IDbSchema {
+ public description = "create event_store and discord_msg_store tables";
+ public async run(store: DiscordStore): Promise<Error> {
+ await store.db.execAsync(
+ `DROP TABLE IF EXISTS event_store;`,
+ );
+ await store.create_table(`
+ CREATE TABLE event_store (
+ matrix_id TEXT NOT NULL,
+ discord_id TEXT NOT NULL,
+ PRIMARY KEY(matrix_id, discord_id)
+ );`, "event_store");
+ return await store.create_table(`
+ CREATE TABLE discord_msg_store (
+ msg_id TEXT NOT NULL,
+ guild_id TEXT NOT NULL,
+ channel_id TEXT NOT NULL,
+ PRIMARY KEY(msg_id)
+ );`, "discord_msg_store");
+ }
+
+ public rollBack(store: DiscordStore): Promise <null> {
+ return store.db.execAsync(
+ `DROP TABLE IF EXISTS event_store;`,
+ `DROP TABLE IF EXISTS discord_msg_store;`,
+ );
+ }
+}
diff --git a/src/store.ts b/src/store.ts
index a003de5eabb45cd4fb08bac577952212b02e7d19..2ea8267beac650e17d78bf1f8a25e3a71677449b 100644
--- a/src/store.ts
+++ b/src/store.ts
@@ -4,7 +4,7 @@ import * as Bluebird from "bluebird";
import * as fs from "fs";
import { IDbSchema } from "./db/schema/dbschema";
import { IDbData} from "./db/dbdatainterface";
-const CURRENT_SCHEMA = 5;
+const CURRENT_SCHEMA = 6;
/**
* Stores data for specific users and data not specific to rooms.
*/
@@ -22,7 +22,7 @@ export class DiscordStore {
public backup_database(): Promise<null> {
if (this.filepath === ":memory:") {
- log.warn("DiscordStore", "Can't backup a :memory: database.");
+ log.info("DiscordStore", "Can't backup a :memory: database.");
return Promise.resolve();
}
const BACKUP_NAME = this.filepath + ".backup";
diff --git a/test/test_store.ts b/test/test_store.ts
index 0b3c3f7a0389dd29bb9a705c0573e66ed0dd657c..46287b08cf44a79091a4aacc1ec17beaf68dbe5b 100644
--- a/test/test_store.ts
+++ b/test/test_store.ts
@@ -10,7 +10,7 @@ Chai.use(ChaiAsPromised);
const expect = Chai.expect;
log.level = "warn";
-const TEST_SCHEMA = 5;
+const TEST_SCHEMA = 6;
// const assert = Chai.assert;
@@ -18,14 +18,8 @@ describe("DiscordStore", () => {
describe("init", () => {
it("can create a db", () => {
const store = new DiscordStore(":memory:");
- return store.init(-1);
+ return store.init();
});
- for (let i = 1; i < TEST_SCHEMA; i++) {
- it("update schema to v" + i, () => {
- const store = new DiscordStore(":memory:");
- return store.init(i);
- });
- }
});
describe("add_user_token", () => {
it("should not throw when adding an entry", () => {
@@ -93,6 +87,8 @@ describe("DiscordStore", () => {
const event = new DbEvent();
event.MatrixId = "123";
event.DiscordId = "456";
+ event.GuildId = "123";
+ event.ChannelId = "123";
return store.Insert(event);
})).to.eventually.be.fulfilled;
});
@@ -102,19 +98,25 @@ describe("DiscordStore", () => {
const event = new DbEvent();
event.MatrixId = "123";
event.DiscordId = "456";
+ event.GuildId = "123";
+ event.ChannelId = "123";
await store.Insert(event);
const getEventDiscord = await store.Get(DbEvent, {discord_id: "456"});
Chai.assert.equal(getEventDiscord.MatrixId, "123");
Chai.assert.equal(getEventDiscord.DiscordId, "456");
+ Chai.assert.equal(getEventDiscord.GuildId, "123");
+ Chai.assert.equal(getEventDiscord.ChannelId, "123");
const getEventMatrix = await store.Get(DbEvent, {matrix_id: "123"});
- Chai.assert.equal(getEventDiscord.MatrixId, "123");
- Chai.assert.equal(getEventDiscord.DiscordId, "456");
+ Chai.assert.equal(getEventMatrix.MatrixId, "123");
+ Chai.assert.equal(getEventMatrix.DiscordId, "456");
+ Chai.assert.equal(getEventMatrix.GuildId, "123");
+ Chai.assert.equal(getEventMatrix.ChannelId, "123");
});
- it("should not return nonexistant emoji", async () => {
+ it("should not return nonexistant event", async () => {
const store = new DiscordStore(":memory:");
await store.init();
- const getEmoji = await store.Get(DbEvent, {matrix_id: "123"});
- Chai.assert.isFalse(getEmoji.Result);
+ const getMessage = await store.Get(DbEvent, {matrix_id: "123"});
+ Chai.assert.isFalse(getMessage.Result);
});
it("should delete successfully", async () => {
const store = new DiscordStore(":memory:");
@@ -122,6 +124,8 @@ describe("DiscordStore", () => {
const event = new DbEvent();
event.MatrixId = "123";
event.DiscordId = "456";
+ event.GuildId = "123";
+ event.ChannelId = "123";
await store.Insert(event);
await store.Delete(event);
const getEvent = await store.Get(DbEvent, {matrix_id: "123"});