474 lines
15 KiB
TypeScript
474 lines
15 KiB
TypeScript
|
import { BaseGuildRepository } from "./BaseGuildRepository";
|
||
|
|
import { getRepository, In, IsNull, LessThan, Not, Repository } from "typeorm";
|
||
|
|
import { Counter } from "./entities/Counter";
|
||
|
|
import { CounterValue } from "./entities/CounterValue";
|
||
|
|
import { CounterTrigger, TRIGGER_COMPARISON_OPS, TriggerComparisonOp } from "./entities/CounterTrigger";
|
||
|
|
import { CounterTriggerState } from "./entities/CounterTriggerState";
|
||
|
|
import moment from "moment-timezone";
|
||
|
|
import { DAYS, DBDateFormat, HOURS, MINUTES } from "../utils";
|
||
|
|
import { connection } from "./db";
|
||
|
|
|
||
|
|
const comparisonStringRegex = new RegExp(`^(${TRIGGER_COMPARISON_OPS.join("|")})([1-9]\d*)$`);
|
||
|
|
|
||
|
|
/**
|
||
|
|
* @return Parsed comparison op and value, or null if the comparison string was invalid
|
||
|
|
*/
|
||
|
|
export function parseCondition(str: string): [TriggerComparisonOp, number] | null {
|
||
|
|
const matches = str.match(comparisonStringRegex);
|
||
|
|
return matches ? [matches[1] as TriggerComparisonOp, parseInt(matches[2], 10)] : null;
|
||
|
|
}
|
||
|
|
|
||
|
|
export function buildConditionString(comparisonOp: TriggerComparisonOp, comparisonValue: number): string {
|
||
|
|
return `${comparisonOp}${comparisonValue}`;
|
||
|
|
}
|
||
|
|
|
||
|
|
function isValidComparisonOp(op: string): boolean {
|
||
|
|
return TRIGGER_COMPARISON_OPS.includes(op as any);
|
||
|
|
}
|
||
|
|
|
||
|
|
const REVERSE_OPS: Record<TriggerComparisonOp, TriggerComparisonOp> = {
|
||
|
|
"=": "!=",
|
||
|
|
"!=": "=",
|
||
|
|
">": "<=",
|
||
|
|
"<": ">=",
|
||
|
|
">=": "<",
|
||
|
|
"<=": ">",
|
||
|
|
};
|
||
|
|
|
||
|
|
function getReverseComparisonOp(op: TriggerComparisonOp): TriggerComparisonOp {
|
||
|
|
return REVERSE_OPS[op];
|
||
|
|
}
|
||
|
|
|
||
|
|
const DELETE_UNUSED_COUNTERS_AFTER = 1 * DAYS;
|
||
|
|
const DELETE_UNUSED_COUNTER_TRIGGERS_AFTER = 1 * DAYS;
|
||
|
|
|
||
|
|
const MAX_COUNTER_VALUE = 2147483647; // 2^31-1, for MySQL INT
|
||
|
|
|
||
|
|
async function deleteCountersMarkedToBeDeleted(): Promise<void> {
|
||
|
|
await getRepository(Counter)
|
||
|
|
.createQueryBuilder()
|
||
|
|
.where("delete_at <= NOW()")
|
||
|
|
.delete()
|
||
|
|
.execute();
|
||
|
|
}
|
||
|
|
|
||
|
|
async function deleteTriggersMarkedToBeDeleted(): Promise<void> {
|
||
|
|
await getRepository(CounterTrigger)
|
||
|
|
.createQueryBuilder()
|
||
|
|
.where("delete_at <= NOW()")
|
||
|
|
.delete()
|
||
|
|
.execute();
|
||
|
|
}
|
||
|
|
|
||
|
|
setInterval(deleteCountersMarkedToBeDeleted, 1 * HOURS);
|
||
|
|
setInterval(deleteTriggersMarkedToBeDeleted, 1 * HOURS);
|
||
|
|
|
||
|
|
setTimeout(deleteCountersMarkedToBeDeleted, 1 * MINUTES);
|
||
|
|
setTimeout(deleteTriggersMarkedToBeDeleted, 1 * MINUTES);
|
||
|
|
|
||
|
|
export class GuildCounters extends BaseGuildRepository {
|
||
|
|
private counters: Repository<Counter>;
|
||
|
|
private counterValues: Repository<CounterValue>;
|
||
|
|
private counterTriggers: Repository<CounterTrigger>;
|
||
|
|
private counterTriggerStates: Repository<CounterTriggerState>;
|
||
|
|
|
||
|
|
constructor(guildId) {
|
||
|
|
super(guildId);
|
||
|
|
this.counters = getRepository(Counter);
|
||
|
|
this.counterValues = getRepository(CounterValue);
|
||
|
|
this.counterTriggers = getRepository(CounterTrigger);
|
||
|
|
this.counterTriggerStates = getRepository(CounterTriggerState);
|
||
|
|
}
|
||
|
|
|
||
|
|
async findOrCreateCounter(name: string, perChannel: boolean, perUser: boolean): Promise<Counter> {
|
||
|
|
const existing = await this.counters.findOne({
|
||
|
|
where: {
|
||
|
|
guild_id: this.guildId,
|
||
|
|
name,
|
||
|
|
},
|
||
|
|
});
|
||
|
|
|
||
|
|
if (existing) {
|
||
|
|
// If the existing counter's properties match the ones we're looking for, return it.
|
||
|
|
// Otherwise, delete the existing counter and re-create it with the proper properties.
|
||
|
|
if (existing.per_channel === perChannel && existing.per_user === perUser) {
|
||
|
|
return existing;
|
||
|
|
}
|
||
|
|
|
||
|
|
await this.counters.delete({ id: existing.id });
|
||
|
|
}
|
||
|
|
|
||
|
|
const insertResult = await this.counters.insert({
|
||
|
|
guild_id: this.guildId,
|
||
|
|
name,
|
||
|
|
per_channel: perChannel,
|
||
|
|
per_user: perUser,
|
||
|
|
last_decay_at: moment.utc().format(DBDateFormat),
|
||
|
|
});
|
||
|
|
|
||
|
|
return (await this.counters.findOne({
|
||
|
|
where: {
|
||
|
|
id: insertResult.identifiers[0].id,
|
||
|
|
},
|
||
|
|
}))!;
|
||
|
|
}
|
||
|
|
|
||
|
|
async markUnusedCountersToBeDeleted(idsToKeep: number[]): Promise<void> {
|
||
|
|
if (idsToKeep.length === 0) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const deleteAt = moment
|
||
|
|
.utc()
|
||
|
|
.add(DELETE_UNUSED_COUNTERS_AFTER, "ms")
|
||
|
|
.format(DBDateFormat);
|
||
|
|
await this.counters.update(
|
||
|
|
{
|
||
|
|
guild_id: this.guildId,
|
||
|
|
id: Not(In(idsToKeep)),
|
||
|
|
delete_at: IsNull(),
|
||
|
|
},
|
||
|
|
{
|
||
|
|
delete_at: deleteAt,
|
||
|
|
},
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
async deleteCountersMarkedToBeDeleted(): Promise<void> {
|
||
|
|
await this.counters
|
||
|
|
.createQueryBuilder()
|
||
|
|
.where("delete_at <= NOW()")
|
||
|
|
.delete()
|
||
|
|
.execute();
|
||
|
|
}
|
||
|
|
|
||
|
|
async changeCounterValue(id: number, channelId: string | null, userId: string | null, change: number): Promise<void> {
|
||
|
|
if (typeof change !== "number" || Number.isNaN(change) || !Number.isFinite(change)) {
|
||
|
|
throw new Error(`changeCounterValue() change argument must be a number`);
|
||
|
|
}
|
||
|
|
|
||
|
|
channelId = channelId || "0";
|
||
|
|
userId = userId || "0";
|
||
|
|
|
||
|
|
const rawUpdate =
|
||
|
|
change >= 0 ? `value = LEAST(value + ${change}, ${MAX_COUNTER_VALUE})` : `value = GREATEST(value ${change}, 0)`;
|
||
|
|
|
||
|
|
await this.counterValues.query(
|
||
|
|
`
|
||
|
|
INSERT INTO counter_values (counter_id, channel_id, user_id, value)
|
||
|
|
VALUES (?, ?, ?, ?)
|
||
|
|
ON DUPLICATE KEY UPDATE ${rawUpdate}
|
||
|
|
`,
|
||
|
|
[id, channelId, userId, Math.max(change, 0)],
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
async setCounterValue(id: number, channelId: string | null, userId: string | null, value: number): Promise<void> {
|
||
|
|
if (typeof value !== "number" || Number.isNaN(value) || !Number.isFinite(value)) {
|
||
|
|
throw new Error(`setCounterValue() value argument must be a number`);
|
||
|
|
}
|
||
|
|
|
||
|
|
channelId = channelId || "0";
|
||
|
|
userId = userId || "0";
|
||
|
|
|
||
|
|
value = Math.max(value, 0);
|
||
|
|
|
||
|
|
await this.counterValues.query(
|
||
|
|
`
|
||
|
|
INSERT INTO counter_values (counter_id, channel_id, user_id, value)
|
||
|
|
VALUES (?, ?, ?, ?)
|
||
|
|
ON DUPLICATE KEY UPDATE value = ?
|
||
|
|
`,
|
||
|
|
[id, channelId, userId, value, value],
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
async decay(id: number, decayPeriodMs: number, decayAmount: number) {
|
||
|
|
const now = moment.utc().format(DBDateFormat);
|
||
|
|
|
||
|
|
const counter = (await this.counters.findOne({
|
||
|
|
where: {
|
||
|
|
id,
|
||
|
|
},
|
||
|
|
}))!;
|
||
|
|
|
||
|
|
const diffFromLastDecayMs = moment.utc().diff(moment.utc(counter.last_decay_at!), "ms");
|
||
|
|
if (diffFromLastDecayMs < decayPeriodMs) {
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
const decayAmountToApply = Math.round((diffFromLastDecayMs / decayPeriodMs) * decayAmount);
|
||
|
|
|
||
|
|
const rawUpdate =
|
||
|
|
decayAmountToApply >= 0
|
||
|
|
? `GREATEST(value - ${decayAmountToApply}, 0)`
|
||
|
|
: `LEAST(value + ${Math.abs(decayAmountToApply)}, ${MAX_COUNTER_VALUE})`;
|
||
|
|
|
||
|
|
await this.counterValues.update(
|
||
|
|
{
|
||
|
|
counter_id: id,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
value: () => rawUpdate,
|
||
|
|
},
|
||
|
|
);
|
||
|
|
|
||
|
|
await this.counters.update(
|
||
|
|
{
|
||
|
|
id,
|
||
|
|
},
|
||
|
|
{
|
||
|
|
last_decay_at: now,
|
||
|
|
},
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
async markAllTriggersTobeDeleted() {
|
||
|
|
const deleteAt = moment
|
||
|
|
.utc()
|
||
|
|
.add(DELETE_UNUSED_COUNTER_TRIGGERS_AFTER, "ms")
|
||
|
|
.format(DBDateFormat);
|
||
|
|
await this.counterTriggers.update(
|
||
|
|
{},
|
||
|
|
{
|
||
|
|
delete_at: deleteAt,
|
||
|
|
},
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
async deleteTriggersMarkedToBeDeleted(): Promise<void> {
|
||
|
|
await this.counterTriggers
|
||
|
|
.createQueryBuilder()
|
||
|
|
.where("delete_at <= NOW()")
|
||
|
|
.delete()
|
||
|
|
.execute();
|
||
|
|
}
|
||
|
|
|
||
|
|
async initCounterTrigger(
|
||
|
|
counterId: number,
|
||
|
|
comparisonOp: TriggerComparisonOp,
|
||
|
|
comparisonValue: number,
|
||
|
|
): Promise<CounterTrigger> {
|
||
|
|
if (!isValidComparisonOp(comparisonOp)) {
|
||
|
|
throw new Error(`Invalid comparison op: ${comparisonOp}`);
|
||
|
|
}
|
||
|
|
|
||
|
|
if (typeof comparisonValue !== "number") {
|
||
|
|
throw new Error(`Invalid comparison value: ${comparisonValue}`);
|
||
|
|
}
|
||
|
|
|
||
|
|
return connection.transaction(async entityManager => {
|
||
|
|
const existing = await entityManager.findOne(CounterTrigger, {
|
||
|
|
counter_id: counterId,
|
||
|
|
comparison_op: comparisonOp,
|
||
|
|
comparison_value: comparisonValue,
|
||
|
|
});
|
||
|
|
|
||
|
|
if (existing) {
|
||
|
|
// Since all existing triggers are marked as to-be-deleted before they are re-initialized, this needs to be reset
|
||
|
|
await entityManager.update(CounterTrigger, existing.id, { delete_at: null });
|
||
|
|
return existing;
|
||
|
|
}
|
||
|
|
|
||
|
|
const insertResult = await entityManager.insert(CounterTrigger, {
|
||
|
|
counter_id: counterId,
|
||
|
|
comparison_op: comparisonOp,
|
||
|
|
comparison_value: comparisonValue,
|
||
|
|
});
|
||
|
|
|
||
|
|
return (await entityManager.findOne(CounterTrigger, insertResult.identifiers[0].id))!;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if a counter value with the given parameters triggers the specified comparison for the specified counter.
|
||
|
|
* If it does, mark this comparison for these parameters as triggered.
|
||
|
|
* Note that if this comparison for these parameters was already triggered previously, this function will return false.
|
||
|
|
* This means that a specific comparison for the specific parameters specified will only trigger *once* until the reverse trigger is triggered.
|
||
|
|
*
|
||
|
|
* @param counterId
|
||
|
|
* @param comparisonOp
|
||
|
|
* @param comparisonValue
|
||
|
|
* @param userId
|
||
|
|
* @param channelId
|
||
|
|
* @return Whether the given parameters newly triggered the given comparison
|
||
|
|
*/
|
||
|
|
async checkForTrigger(
|
||
|
|
counterTrigger: CounterTrigger,
|
||
|
|
channelId: string | null,
|
||
|
|
userId: string | null,
|
||
|
|
): Promise<boolean> {
|
||
|
|
channelId = channelId || "0";
|
||
|
|
userId = userId || "0";
|
||
|
|
|
||
|
|
return connection.transaction(async entityManager => {
|
||
|
|
const previouslyTriggered = await entityManager.findOne(CounterTriggerState, {
|
||
|
|
trigger_id: counterTrigger.id,
|
||
|
|
user_id: userId!,
|
||
|
|
channel_id: channelId!,
|
||
|
|
});
|
||
|
|
|
||
|
|
if (previouslyTriggered) {
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
const matchingValue = await entityManager
|
||
|
|
.createQueryBuilder(CounterValue, "cv")
|
||
|
|
.leftJoin(
|
||
|
|
CounterTriggerState,
|
||
|
|
"triggerStates",
|
||
|
|
"triggerStates.trigger_id = :triggerId AND triggerStates.user_id = cv.user_id AND triggerStates.channel_id = cv.channel_id",
|
||
|
|
{ triggerId: counterTrigger.id },
|
||
|
|
)
|
||
|
|
.where(`cv.value ${counterTrigger.comparison_op} :value`, { value: counterTrigger.comparison_value })
|
||
|
|
.andWhere("cv.channel_id = :channelId AND cv.user_id = :userId", { channelId, userId })
|
||
|
|
.andWhere("triggerStates.id IS NULL")
|
||
|
|
.getOne();
|
||
|
|
|
||
|
|
if (matchingValue) {
|
||
|
|
await entityManager.insert(CounterTriggerState, {
|
||
|
|
trigger_id: counterTrigger.id,
|
||
|
|
user_id: userId!,
|
||
|
|
channel_id: channelId!,
|
||
|
|
});
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if any counter values of the specified counter match the specified comparison.
|
||
|
|
* Like checkForTrigger(), this can only happen *once* per unique counter value parameters until the reverse trigger is triggered for those values.
|
||
|
|
*
|
||
|
|
* @return Counter value parameters that triggered the condition
|
||
|
|
*/
|
||
|
|
async checkAllValuesForTrigger(
|
||
|
|
counterTrigger: CounterTrigger,
|
||
|
|
): Promise<Array<{ channelId: string; userId: string }>> {
|
||
|
|
return connection.transaction(async entityManager => {
|
||
|
|
const matchingValues = await entityManager
|
||
|
|
.createQueryBuilder(CounterValue, "cv")
|
||
|
|
.leftJoin(
|
||
|
|
CounterTriggerState,
|
||
|
|
"triggerStates",
|
||
|
|
"triggerStates.trigger_id = :triggerId AND triggerStates.user_id = cv.user_id AND triggerStates.channel_id = cv.channel_id",
|
||
|
|
{ triggerId: counterTrigger.id },
|
||
|
|
)
|
||
|
|
.where(`cv.value ${counterTrigger.comparison_op} :value`, { value: counterTrigger.comparison_value })
|
||
|
|
.andWhere("triggerStates.id IS NULL")
|
||
|
|
.getMany();
|
||
|
|
|
||
|
|
if (matchingValues.length) {
|
||
|
|
await entityManager.insert(
|
||
|
|
CounterTriggerState,
|
||
|
|
matchingValues.map(row => ({
|
||
|
|
trigger_id: counterTrigger.id,
|
||
|
|
channelId: row.channel_id,
|
||
|
|
userId: row.user_id,
|
||
|
|
})),
|
||
|
|
);
|
||
|
|
}
|
||
|
|
|
||
|
|
return matchingValues.map(row => ({
|
||
|
|
channelId: row.channel_id,
|
||
|
|
userId: row.user_id,
|
||
|
|
}));
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if a counter value with the given parameters *no longer* matches the specified comparison, and thus triggers a "reverse trigger".
|
||
|
|
* Like checkForTrigger(), this can only happen *once* until the comparison is triggered normally again.
|
||
|
|
*
|
||
|
|
* @param counterId
|
||
|
|
* @param comparisonOp
|
||
|
|
* @param comparisonValue
|
||
|
|
* @param userId
|
||
|
|
* @param channelId
|
||
|
|
* @return Whether the given parameters triggered a reverse trigger for the given comparison
|
||
|
|
*/
|
||
|
|
async checkForReverseTrigger(
|
||
|
|
counterTrigger: CounterTrigger,
|
||
|
|
channelId: string | null,
|
||
|
|
userId: string | null,
|
||
|
|
): Promise<boolean> {
|
||
|
|
channelId = channelId || "0";
|
||
|
|
userId = userId || "0";
|
||
|
|
|
||
|
|
return connection.transaction(async entityManager => {
|
||
|
|
const reverseOp = getReverseComparisonOp(counterTrigger.comparison_op);
|
||
|
|
const matchingValue = await entityManager
|
||
|
|
.createQueryBuilder(CounterValue, "cv")
|
||
|
|
.innerJoin(
|
||
|
|
CounterTriggerState,
|
||
|
|
"triggerStates",
|
||
|
|
"triggerStates.trigger_id = :triggerId AND triggerStates.user_id = cv.user_id AND triggerStates.channel_id = cv.channel_id",
|
||
|
|
{ triggerId: counterTrigger.id },
|
||
|
|
)
|
||
|
|
.where(`cv.value ${reverseOp} :value`, { value: counterTrigger.comparison_value })
|
||
|
|
.getOne();
|
||
|
|
|
||
|
|
if (matchingValue) {
|
||
|
|
await entityManager.delete(CounterTriggerState, {
|
||
|
|
trigger_id: counterTrigger.id,
|
||
|
|
user_id: userId!,
|
||
|
|
channel_id: channelId!,
|
||
|
|
});
|
||
|
|
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
return false;
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Checks if any counter values of the specified counter *no longer* match the specified comparison, and thus triggers a "reverse trigger" for those values.
|
||
|
|
* Like checkForTrigger(), this can only happen *once* per unique counter value parameters until the comparison is triggered normally again.
|
||
|
|
*
|
||
|
|
* @return Counter value parameters that triggered a reverse trigger
|
||
|
|
*/
|
||
|
|
async checkAllValuesForReverseTrigger(
|
||
|
|
counterTrigger: CounterTrigger,
|
||
|
|
): Promise<Array<{ channelId: string; userId: string }>> {
|
||
|
|
return connection.transaction(async entityManager => {
|
||
|
|
const reverseOp = getReverseComparisonOp(counterTrigger.comparison_op);
|
||
|
|
const matchingValues: Array<{
|
||
|
|
id: string;
|
||
|
|
triggerStateId: string;
|
||
|
|
user_id: string;
|
||
|
|
channel_id: string;
|
||
|
|
}> = await entityManager
|
||
|
|
.createQueryBuilder(CounterValue, "cv")
|
||
|
|
.innerJoin(
|
||
|
|
CounterTriggerState,
|
||
|
|
"triggerStates",
|
||
|
|
"triggerStates.trigger_id = :triggerId AND triggerStates.user_id = cv.user_id AND triggerStates.channel_id = cv.channel_id",
|
||
|
|
{ triggerId: counterTrigger.id },
|
||
|
|
)
|
||
|
|
.where(`cv.value ${reverseOp} :value`, { value: counterTrigger.comparison_value })
|
||
|
|
.select([
|
||
|
|
"cv.id AS id",
|
||
|
|
"cv.user_id AS user_id",
|
||
|
|
"cv.channel_id AS channel_id",
|
||
|
|
"triggerStates.id AS triggerStateId",
|
||
|
|
])
|
||
|
|
.getRawMany();
|
||
|
|
|
||
|
|
if (matchingValues.length) {
|
||
|
|
await entityManager.delete(CounterTriggerState, {
|
||
|
|
id: In(matchingValues.map(v => v.triggerStateId)),
|
||
|
|
});
|
||
|
|
}
|
||
|
|
|
||
|
|
return matchingValues.map(row => ({
|
||
|
|
channelId: row.channel_id,
|
||
|
|
userId: row.user_id,
|
||
|
|
}));
|
||
|
|
});
|
||
|
|
}
|
||
|
|
}
|