feat(settings): add battle notifier settings

Author: PabloCorso

.prettierrc.json

@@ -0,0 +1,6 @@
+{
+  "printWidth": 80,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "arrowParens": "avoid"
+}

src/api/player.js

@@ -11,6 +11,7 @@ import {
   LevelStats,
   Level,
   Setting,
+  BnKuskiRule,
 } from '../data/models';
 
 const router = express.Router();
@@ -88,6 +89,86 @@ const ChangeSettings = async data => {
   return 1;
 };
 
+const BnKuskiRuleAttributes = [
+  'BattleTypes',
+  'Designers',
+  'LevelPatterns',
+  'BattleAttributes',
+  'MinDuration',
+  'MaxDuration',
+  'IgnoreList',
+];
+
+const BnSettings = async DiscordId => {
+  const get = await Setting.findOne({
+    where: { DiscordId },
+    attributes: ['KuskiIndex', 'DiscordId', 'BnEnabled'],
+    include: [
+      {
+        model: BnKuskiRule,
+        as: 'BnKuskiRules',
+        attributes: BnKuskiRuleAttributes,
+      },
+    ],
+  });
+  return get;
+};
+
+const AllActiveBnSettings = async () => {
+  const get = await Setting.findAll({
+    attributes: ['KuskiIndex', 'DiscordId', 'BnEnabled'],
+    include: [
+      {
+        model: BnKuskiRule,
+        as: 'BnKuskiRules',
+        attributes: BnKuskiRuleAttributes,
+        required: true,
+      },
+    ],
+  });
+  return get;
+};
+
+const ChangeBnEnabledSettings = async data => {
+  await Setting.update(
+    { BnEnabled: data.BnEnabled ? 1 : 0 },
+    { where: { DiscordId: data.DiscordId } },
+  );
+  return 1;
+};
+
+const ChangeBnSettings = async data => {
+  const setting = await Setting.findOne({
+    where: { DiscordId: data.DiscordId },
+    attributes: ['KuskiIndex'],
+  });
+  if (setting?.KuskiIndex) {
+    // get BnKuskiRules from user, if there are none and it is setting new rules, set BnEnabled to true
+    const rules = await BnKuskiRule.findAll({
+      where: { KuskiIndex: setting.KuskiIndex },
+    });
+    const isFirstTimeSetup = !rules.length && data.BnKuskiRules.length > 0;
+    const BnEnabled = isFirstTimeSetup ? 1 : data.BnEnabled;
+    await Setting.update(
+      { BnEnabled: BnEnabled ? 1 : 0 },
+      { where: { KuskiIndex: setting.KuskiIndex } },
+    );
+
+    // delete all BnKuskiRules from this user
+    await BnKuskiRule.destroy({ where: { KuskiIndex: setting.KuskiIndex } });
+    // for each rule, create a new BnKuskiRule
+    await Promise.all(
+      data.BnKuskiRules.map(async rule => {
+        await BnKuskiRule.create({
+          KuskiIndex: setting.KuskiIndex,
+          ...rule,
+        });
+      }),
+    );
+  }
+  return 1;
+};
+
 const Player = async (IdentifierType, KuskiIdentifier, currentUser) => {
   const query = {
     where: {},
@@ -310,6 +391,34 @@ router
       res.sendStatus(401);
     }
   })
+  .get('/bn/:DiscordId/linked', async (req, res) => {
+    const data = await Setting.findOne({
+      where: { DiscordId: req.params.DiscordId },
+    });
+    res.json(Boolean(data));
+  })
+  .get('/bn/:DiscordId', async (req, res) => {
+    const data = await BnSettings(req.params.DiscordId);
+    res.json(data);
+  })
+  .get('/bn', async (req, res) => {
+    const data = await AllActiveBnSettings();
+    res.json(data);
+  })
+  .post('/bn/:DiscordId/toggle/:BnEnabled', async (req, res) => {
+    const data = await ChangeBnEnabledSettings({
+      DiscordId: req.params.DiscordId,
+      BnEnabled: req.params.BnEnabled,
+    });
+    res.json(data);
+  })
+  .post('/bn/:DiscordId', async (req, res) => {
+    const data = await ChangeBnSettings({
+      ...req.body,
+      DiscordId: req.params.DiscordId,
+    });
+    res.json(data);
+  })
   .post('/ignore/:Kuski', async (req, res) => {
     const auth = authContext(req);
     if (auth.auth) {

src/data/models/BnKuskiRule.js

@@ -0,0 +1,63 @@
+import DataType from 'sequelize';
+import Model from '../sequelize';
+
+const Setting = Model.define('bn_kuski_rule', {
+  BnKuskiRuleIndex: {
+    type: DataType.INTEGER,
+    autoIncrement: true,
+    allowNull: false,
+    primaryKey: true,
+  },
+  KuskiIndex: {
+    type: DataType.INTEGER,
+    allowNull: false,
+    defaultValue: 0,
+  },
+  BattleTypes: {
+    type: DataType.STRING(255),
+    allowNull: true,
+    defaultValue: null,
+  },
+  Designers: {
+    type: DataType.STRING(255),
+    allowNull: true,
+    defaultValue: null,
+  },
+  LevelPatterns: {
+    type: DataType.STRING(255),
+    allowNull: true,
+    defaultValue: null,
+  },
+  BattleAttributes: {
+    type: DataType.STRING(255),
+    allowNull: true,
+    defaultValue: null,
+  },
+  MinDuration: {
+    type: DataType.INTEGER,
+    allowNull: true,
+    defaultValue: null,
+  },
+  MaxDuration: {
+    type: DataType.INTEGER,
+    allowNull: true,
+    defaultValue: null,
+  },
+  IgnoreList: {
+    type: DataType.INTEGER,
+    allowNull: false,
+    defaultValue: 0,
+  },
+  CreatedAt: {
+    type: DataType.INTEGER,
+    allowNull: true,
+    defaultValue: null,
+  },
+  UpdatedAt: {
+    type: DataType.INTEGER,
+    allowNull: true,
+    defaultValue: null,
+  },
+});
+
+export default Setting;

src/data/models/Setting.js

@@ -60,6 +60,11 @@ const Setting = Model.define(
       allowNull: false,
       defaultValue: 1,
     },
+    BnEnabled: {
+      type: DataType.INTEGER,
+      allowNull: false,
+      defaultValue: 0,
+    },
   },
   {
     indexes: [

src/data/models/index.js

@@ -59,6 +59,7 @@ import MultiTimeFile from './MultiTimeFile';
 import Crippled from './Crippled';
 import Recap from './Recap';
 import ReplayLog from './ReplayLog';
+import BnKuskiRule from './BnKuskiRule';
 
 Replay.belongsTo(Kuski, {
   foreignKey: 'DrivenBy',
@@ -511,6 +512,18 @@ Recap.belongsTo(Replay, {
   as: 'ReplayData',
 });
 
+Setting.hasMany(BnKuskiRule, {
+  foreignKey: 'KuskiIndex',
+  sourceKey: 'KuskiIndex',
+  as: 'BnKuskiRules',
+});
+
+BnKuskiRule.belongsTo(Setting, {
+  foreignKey: 'KuskiIndex',
+  targetKey: 'KuskiIndex',
+  as: 'SettingData',
+});
+
 function sync(...args) {
   return sequelize.sync(...args);
 }
@@ -576,4 +589,6 @@ export {
   Crippled,
   Recap,
   ReplayLog,
+  ReplayTags,
+  BnKuskiRule,
 }; // add the data model here as well so it exports