AsgardEternal/SquadJSDocker
1
0
Fork 0
mirror of https://github.com/AsgardEternal/SquadJSDocker.git synced 2024-12-30 15:19:18 -06:00
Code Issues Packages Projects Releases Wiki Activity

move to submodules

Browse Source
This commit is contained in:
Skillet 2023-04-03 11:33:56 -04:00
parent 1b9efe67b2
commit 93f4f5a8b8
7 changed files with 12 additions and 1602 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
.gitmodules vendored Normal file
View File

@ -0,0 +1,9 @@
[submodule "squadjsPlugins/mapVote"]
path = squadjsPlugins/mapVote
url = https://github.com/fantinodavide/squad-js-map-vote.git
[submodule "squadjsPlugins/nameVal"]
path = squadjsPlugins/nameVal
url = https://github.com/fantinodavide/squadjs-squad-name-validator.git
[submodule "squadjsPlugins/dblogext"]
path = squadjsPlugins/dblogext
url = https://github.com/AsgardEternal/DBLogExtension.git

283
squadjsPlugins/db-log-addOn.js
View File

@ -1,283 +0,0 @@
import Sequelize from 'sequelize';
import DBLog from './db-log.js';
const {DataTypes} = Sequelize;
const ServerState = {
init: 0,
seeding: 1,
live: 2
};
export default class DBLogPlayerTime extends DBLog {
static get description() {
return (
'replacement add-on to dblog for player join/seeding times'
);
}
static get defaultEnabled() {
return false;
}
static get optionsSpecification() {
return {
...DBLog.optionsSpecification,
seedingThreshold: {
required: false,
description: 'seeding Threshold.',
default: 50
}
};
}
constructor(server, options, connectors) {
super(server, options, connectors);
this.seeding = ServerState.init;
this.createModel(
'PlayerTimeNew',
{
id: {
type: DataTypes.INTEGER,
primaryKey: true,
autoIncrement: true
},
startTime: {
type: DataTypes.DATE
},
endTime: {
type: DataTypes.DATE
},
serverState: {
type: DataTypes.INTEGER
},
session: {
type: DataTypes.INTEGER
}
},
{
charset: 'utf8mb4',
collate: 'utf8mb4_unicode_ci'
}
);
this.models.Server.hasMany(this.models.PlayerTimeNew, {
foreignKey: {name: 'server', allowNull: false},
onDelete: 'CASCADE'
});
this.models.SteamUser.hasMany(this.models.PlayerTimeNew, {
foreignKey: {name: 'player'},
onDelete: 'CASCADE'
});
this.onPlayerConnected = this.onPlayerConnected.bind(this);
this.onPlayerDisconnected = this.onPlayerDisconnected.bind(this);
}
async prepareToMount() {
await super.prepareToMount();
await this.models.PlayerTimeNew.sync();
}
async mount() {
console.log('Mounting db-log');
if(this.server.currentLayer){
if(this.server.currentLayer.gamemode === "Seed"){
console.log('starting to seeding');
this.seeding = ServerState.seeding;
} else {
console.log('starting to Live');
this.seeding = ServerState.live;
}
} else {
if(this.server.currentLayerRcon.layer.includes("Seed")){
console.log('starting to seeding');
this.seeding = ServerState.seeding;
} else {
console.log('starting to Live');
this.seeding = ServerState.live;
}
}
await super.mount();
console.log('finished mounting db-log');
this.server.on('PLAYER_CONNECTED', this.onPlayerConnected);
this.server.on('PLAYER_DISCONNECTED', this.onPlayerDisconnected);
console.log('finished mounting db-log-addOn');
}
async repairDB() {
console.log('starting DB repair');
await super.repairDB();
console.log('starting DB repair for addOn');
const lastTickTime = await this.models.TickRate.findOne({
where: {server: this.options.overrideServerID || this.server.id},
order: [['id', 'DESC']],
logging: console.log
}
);
console.log('last tick found:', lastTickTime);
const lastServerDate = lastTickTime.time;
const lastServerTime = lastServerDate.getFullYear() + '-' + (lastServerDate.getMonth() + 1) + '-' + lastServerDate.getDate() + ' ' + lastServerDate.getHours() + ':' + lastServerDate.getMinutes() + ':' + lastServerDate.getSeconds();
console.log('last time found:', lastServerTime);
const playerOnlineID = [];
playerOnlineID.push(0);
for (const player of this.server.players) {
playerOnlineID.push(player.steamID);
}
console.log('players online:', playerOnlineID);
const {notIn, is} = Sequelize.Op;
const updateVals = {endTime: lastServerTime};
const whereStuff = {
endTime: {[is]: null},
server: this.options.overrideServerID || this.server.id,
player: {[notIn]: playerOnlineID}
};
console.log(updateVals);
console.log(whereStuff);
const rowUpdate = await this.models.PlayerTimeNew.update(
updateVals, {
where: whereStuff,
logging: console.log
}
);
console.log('updated playerTimes row count: %i', rowUpdate[0]);
console.log('finish DB repair');
}
async unmount() {
this.models.PlayerTimeNew.update(
{leaveTime: 0},
{where: {leaveTime: null, server: this.options.overrideServerID || this.server.id}}
);
await super.unmount();
this.server.removeEventListener('PLAYER_CONNECTED', this.onPlayerConnected);
this.server.removeEventListener('PLAYER_DISCONNECTED', this.onPlayerDisconnected);
}
async updateCurrentTimeState(date, oldState, newState){
if(oldState === newState) return;
const timeNow = date.getFullYear() + '-' + (date.getMonth() + 1) + '-' + date.getDate() + ' ' + date.getHours() + ':' + date.getMinutes() + ':' + date.getSeconds();
console.log(timeNow);
const curPlayer = await this.models.PlayerTimeNew.findAll({
where: {
endTime: null,
serverState: oldState,
server: this.options.overrideServerID || this.server.id
}
});
console.log(curPlayer);
let curplayerarr = [];
for (const oneplayer of curPlayer){
console.log(oneplayer);
curplayerarr.push({
startTime: timeNow,
endTime: null,
serverState: newState,
session: oneplayer.session,
server: oneplayer.server,
player: oneplayer.player
});
}
console.log(curplayerarr);
await this.models.PlayerTimeNew.update(
{ endTime: timeNow },
{
where: {
endTime: null,
serverState: oldState,
server: this.options.overrideServerID || this.server.id
}
}
);
await this.models.PlayerTimeNew.bulkCreate(curplayerarr,{
fields: ['startTime', 'endTime','serverState','session','server','player']
});
this.seeding = newState;
}
async onUpdatedA2SInformation(info) {
await super.onUpdatedA2SInformation(info);
// const curDateTime = new Date();
// if ((this.seeding !== ServerState.live) && (info.a2sPlayerCount >= this.options.seedingThreshold)) {
// console.log('switching to Live');
// await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.live);
// } else if (this.seeding === false && (info.a2sPlayerCount - 20) < this.options.seedingThreshold) {
// console.log('switching to seeding');
// await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.seeding);
// }
}
async onNewGame(info){
await super.onNewGame(info);
console.log(info);
const curDateTime = info.time;
if(info.layer){
if(info.layer.gamemode === 'Seed'){
console.log('switching to seeding');
await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.seeding);
} else {
console.log('switching to Live');
await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.live);
}
} else {
if(info.layerClassname.includes("Seed")){
console.log('switching to seeding');
await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.seeding);
} else {
console.log('switching to Live');
await this.updateCurrentTimeState(curDateTime, this.seeding, ServerState.live);
}
}
}
async onPlayerConnected(info) {
console.log(info);
if (info.player) {
await this.models.SteamUser.upsert({
steamID: info.player.steamID,
lastName: info.player.name
});
await this.models.PlayerTimeNew.create({
server: this.options.overrideServerID || this.server.id,
player: info.steamID,
startTime: info.time,
serverState: this.seeding
});
console.log('player connect complete');
} else console.log('player is null');
}
async onPlayerDisconnected(info) {
await new Promise(r => setTimeout(r, 500));
console.log(info);
if (info.player) {
await this.models.SteamUser.upsert({
steamID: info.player.steamID,
lastName: info.player.name
});
}
const rowAffect = await this.models.PlayerTimeNew.update(
{endTime: info.time},
{where:
{
player: info.steamID,
endTime: null,
server: this.options.overrideServerID || this.server.id
}}
);
console.log('player disconnect rows update: %i', rowAffect[0]);
}
}

1
squadjsPlugins/dblogext Submodule

@ -0,0 +1 @@
Subproject commit 7aec03da686b6f76c16ae223826c55897cd1449c

1
squadjsPlugins/mapVote Submodule

@ -0,0 +1 @@
Subproject commit 322d1889f87bb634b6a363fc07068c592d0d4e39

1161
squadjsPlugins/mapvote.js
View File

File diff suppressed because it is too large Load Diff

1
squadjsPlugins/nameVal Submodule

@ -0,0 +1 @@
Subproject commit 60763d744f22721cbdf1a5288fb8d910f67ffa3a

158
squadjsPlugins/squad-name-validator.js
View File

@ -1,158 +0,0 @@
//from https://github.com/fantinodavide/squadjs-squad-name-validator
import DiscordBasePlugin from './discord-base-plugin.js';
export default class SquadNameValidator extends DiscordBasePlugin {
static get description() {
return "Squad Name Validator plugin";
}
static get defaultEnabled() {
return true;
}
static get optionsSpecification() {
return {
...DiscordBasePlugin.optionsSpecification,
channelID: {
required: true,
description: 'The ID of the channel to log admin broadcasts to.',
default: '',
example: '667741905228136459'
},
warningMessage: {
required: false,
description: "",
default: "Your squad has been disbanded due to non-compliant name.\n\nForbidden: %FORBIDDEN%",
},
rules: {
required: false,
description: "",
default: [
{
type: "regex",
logic: "match=allow",
rule: /a-z\d=\$\[\]\!\.\s\-/
}
],
example: [
{
type: "regex",
logic: "match=disband",
logic: "match=allow",
rule: /[^a-z\d=\$\[\]\!\.\s\-]/
},
{
type: "equals",
rule: "ARMOUR"
},
{
type: "includes",
rule: "F*CK"
}
]
}
};
}
constructor(server, options, connectors) {
super(server, options, connectors);
this.onSquadCreated = this.onSquadCreated.bind(this)
this.discordLog = this.discordLog.bind(this)
this.broadcast = (msg) => { this.server.rcon.broadcast(msg); };
this.warn = (steamid, msg) => { this.server.rcon.warn(steamid, msg); };
}
async mount() {
this.server.on('SQUAD_CREATED', this.onSquadCreated);
}
onSquadCreated(info) {
let disband = false;
let rule = null;
for (let r of this.options.rules) {
switch (r.type.toLowerCase()) {
case 'regex':
r.rule = r.rule.replace(/^\//, '').replace(/\/$/, '')
const reg = new RegExp(r.rule, "gi");
const regRes = info.squadName.match(reg)
switch (r.logic.toLowerCase()) {
case 'match=allow':
if (!regRes) disband = info.squadName;
break;
case 'match=disband':
default:
if (regRes) disband = regRes.join(', ')
}
// this.verbose(1, "Testing rule", info.squadName, reg, disband)
break;
case 'equals':
disband = info.squadName.toLowerCase() === r.rule.toLowerCase() ? info.squadName : false;
break;
case 'includes':
disband = info.squadName.toLowerCase().includes(r.rule.toLowerCase()) ? r.rule : false
break;
case 'startsWith':
disband = info.squadName.toLowerCase().startsWith(r.rule.toLowerCase()) ? r.rule : false
break;
case 'endsWith':
disband = info.squadName.toLowerCase().endsWith(r.rule.toLowerCase()) ? r.rule : false
break;
default:
}
rule = r;
if (disband) break
}
this.verbose(1, "Squad Created:", info.player.teamID, info.player.squadID, disband)
if (disband) {
const disbandMessage = rule.warningMessage || this.options.warningMessage;
this.server.rcon.execute(`AdminDisbandSquad ${info.player.teamID} ${info.player.squadID}`);
this.warn(info.player.steamID, disbandMessage.replace(/\%FORBIDDEN\%/ig, disband))
this.discordLog(info, disband, rule)
}
}
async discordLog(info, forbidden, rule = null) {
let regex = rule ? new RegExp(rule.rule, "gi").toString() : null;
await this.sendDiscordMessage({
embed: {
title: `Squad Disbanded: ${info.squadName}`,
color: "ee1111",
fields: [
{
name: 'Creator\'s Username',
value: info.player.name,
inline: true
},
{
name: 'Creator\'s SteamID',
value: `[${info.player.steamID}](https://steamcommunity.com/profiles/${info.player.steamID})`,
inline: true
},
{
name: 'Team & Squad',
value: `Team: ${info.player.teamID}, Squad: ${info.player.squadID || 'Unassigned'}`
},
{
name: 'Forbidden Chars/Word',
value: forbidden
},
(regex ? { name: 'Logic', value: rule.logic.toLowerCase(), inline: true } : null),
(regex ? { name: 'Regex', value: regex.toString(), inline: true } : null)
].filter(e => e),
timestamp: info.time.toISOString()
}
});
}
async unmount() {
this.verbose(1, 'Squad Name Validator was un-mounted.');
}
}