admin/30395
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: admin:master
Branches Tags
admin:master
admin:ai-dev
..
compare: admin:ai-dev
Branches Tags
admin:ai-dev
admin:master

1 Commits
master ... ai-dev

Author SHA1 Message Date
Flatlogic Bot
cb9345c6b9 Auto commit: 2025-04-01T19:09:12.089Z 2025-04-01 19:09:12 +00:00
8 changed files with 6 additions and 576 deletions
Show Stats Expand all files Collapse all files

5
.gitignore vendored
View File

@ -1,3 +1,8 @@
node_modules/ node_modules/
*/node_modules/ */node_modules/
*/build/ */build/
**/node_modules/
**/build/
.DS_Store
.env

0
backend/src/db/api/game.js Normal file
View File

387
backend/src/db/api/games.js
View File

@ -1,387 +0,0 @@
const db = require('../models');
const FileDBApi = require('./file');
const crypto = require('crypto');
const Utils = require('../utils');
const Sequelize = db.Sequelize;
const Op = Sequelize.Op;
module.exports = class GamesDBApi {
static async create(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const games = await db.games.create(
{
id: data.id || undefined,
date_played: data.date_played || null,
result: data.result || null,
score: data.score || null,
importHash: data.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
},
{ transaction },
);
await games.setPlayer(data.player || null, {
transaction,
});
await games.setOpponent(data.opponent || null, {
transaction,
});
return games;
}
static async bulkImport(data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
// Prepare data - wrapping individual data transformations in a map() method
const gamesData = data.map((item, index) => ({
id: item.id || undefined,
date_played: item.date_played || null,
result: item.result || null,
score: item.score || null,
importHash: item.importHash || null,
createdById: currentUser.id,
updatedById: currentUser.id,
createdAt: new Date(Date.now() + index * 1000),
}));
// Bulk create items
const games = await db.games.bulkCreate(gamesData, { transaction });
// For each item created, replace relation files
return games;
}
static async update(id, data, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const games = await db.games.findByPk(id, {}, { transaction });
const updatePayload = {};
if (data.date_played !== undefined)
updatePayload.date_played = data.date_played;
if (data.result !== undefined) updatePayload.result = data.result;
if (data.score !== undefined) updatePayload.score = data.score;
updatePayload.updatedById = currentUser.id;
await games.update(updatePayload, { transaction });
if (data.player !== undefined) {
await games.setPlayer(
data.player,
{ transaction },
);
}
if (data.opponent !== undefined) {
await games.setOpponent(
data.opponent,
{ transaction },
);
}
return games;
}
static async deleteByIds(ids, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const games = await db.games.findAll({
where: {
id: {
[Op.in]: ids,
},
},
transaction,
});
await db.sequelize.transaction(async (transaction) => {
for (const record of games) {
await record.update({ deletedBy: currentUser.id }, { transaction });
}
for (const record of games) {
await record.destroy({ transaction });
}
});
return games;
}
static async remove(id, options) {
const currentUser = (options && options.currentUser) || { id: null };
const transaction = (options && options.transaction) || undefined;
const games = await db.games.findByPk(id, options);
await games.update(
{
deletedBy: currentUser.id,
},
{
transaction,
},
);
await games.destroy({
transaction,
});
return games;
}
static async findBy(where, options) {
const transaction = (options && options.transaction) || undefined;
const games = await db.games.findOne({ where }, { transaction });
if (!games) {
return games;
}
const output = games.get({ plain: true });
output.player = await games.getPlayer({
transaction,
});
output.opponent = await games.getOpponent({
transaction,
});
return output;
}
static async findAll(filter, options) {
const limit = filter.limit || 0;
let offset = 0;
let where = {};
const currentPage = +filter.page;
offset = currentPage * limit;
const orderBy = null;
const transaction = (options && options.transaction) || undefined;
let include = [
{
model: db.users,
as: 'player',
where: filter.player
? {
[Op.or]: [
{
id: {
[Op.in]: filter.player
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
firstName: {
[Op.or]: filter.player
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
{
model: db.users,
as: 'opponent',
where: filter.opponent
? {
[Op.or]: [
{
id: {
[Op.in]: filter.opponent
.split('|')
.map((term) => Utils.uuid(term)),
},
},
{
firstName: {
[Op.or]: filter.opponent
.split('|')
.map((term) => ({ [Op.iLike]: `%${term}%` })),
},
},
],
}
: {},
},
];
if (filter) {
if (filter.id) {
where = {
...where,
['id']: Utils.uuid(filter.id),
};
}
if (filter.date_playedRange) {
const [start, end] = filter.date_playedRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
date_played: {
...where.date_played,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
date_played: {
...where.date_played,
[Op.lte]: end,
},
};
}
}
if (filter.scoreRange) {
const [start, end] = filter.scoreRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
score: {
...where.score,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
score: {
...where.score,
[Op.lte]: end,
},
};
}
}
if (filter.active !== undefined) {
where = {
...where,
active: filter.active === true || filter.active === 'true',
};
}
if (filter.result) {
where = {
...where,
result: filter.result,
};
}
if (filter.createdAtRange) {
const [start, end] = filter.createdAtRange;
if (start !== undefined && start !== null && start !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.gte]: start,
},
};
}
if (end !== undefined && end !== null && end !== '') {
where = {
...where,
['createdAt']: {
...where.createdAt,
[Op.lte]: end,
},
};
}
}
}
const queryOptions = {
where,
include,
distinct: true,
order:
filter.field && filter.sort
? [[filter.field, filter.sort]]
: [['createdAt', 'desc']],
transaction: options?.transaction,
logging: console.log,
};
if (!options?.countOnly) {
queryOptions.limit = limit ? Number(limit) : undefined;
queryOptions.offset = offset ? Number(offset) : undefined;
}
try {
const { rows, count } = await db.games.findAndCountAll(queryOptions);
return {
rows: options?.countOnly ? [] : rows,
count: count,
};
} catch (error) {
console.error('Error executing query:', error);
throw error;
}
}
static async findAllAutocomplete(query, limit, offset) {
let where = {};
if (query) {
where = {
[Op.or]: [
{ ['id']: Utils.uuid(query) },
Utils.ilike('games', 'date_played', query),
],
};
}
const records = await db.games.findAll({
attributes: ['id', 'date_played'],
where,
limit: limit ? Number(limit) : undefined,
offset: offset ? Number(offset) : undefined,
orderBy: [['date_played', 'ASC']],
});
return records.map((record) => ({
id: record.id,
label: record.date_played,
}));
}
};

0
backend/src/db/models/game.js Normal file
View File

75
backend/src/db/models/games.js
View File

@ -1,75 +0,0 @@
const config = require('../../config');
const providers = config.providers;
const crypto = require('crypto');
const bcrypt = require('bcrypt');
const moment = require('moment');
module.exports = function (sequelize, DataTypes) {
const games = sequelize.define(
'games',
{
id: {
type: DataTypes.UUID,
defaultValue: DataTypes.UUIDV4,
primaryKey: true,
},
date_played: {
type: DataTypes.DATE,
},
result: {
type: DataTypes.ENUM,
values: ['win', 'loss'],
},
score: {
type: DataTypes.INTEGER,
},
importHash: {
type: DataTypes.STRING(255),
allowNull: true,
unique: true,
},
},
{
timestamps: true,
paranoid: true,
freezeTableName: true,
},
);
games.associate = (db) => {
/// loop through entities and it's fields, and if ref === current e[name] and create relation has many on parent entity
//end loop
db.games.belongsTo(db.users, {
as: 'player',
foreignKey: {
name: 'playerId',
},
constraints: false,
});
db.games.belongsTo(db.users, {
as: 'opponent',
foreignKey: {
name: 'opponentId',
},
constraints: false,
});
db.games.belongsTo(db.users, {
as: 'createdBy',
});
db.games.belongsTo(db.users, {
as: 'updatedBy',
});
};
return games;
};

0
backend/src/services/game.js Normal file
View File

114
backend/src/services/games.js
View File

@ -1,114 +0,0 @@
const db = require('../db/models');
const GamesDBApi = require('../db/api/games');
const processFile = require('../middlewares/upload');
const ValidationError = require('./notifications/errors/validation');
const csv = require('csv-parser');
const axios = require('axios');
const config = require('../config');
const stream = require('stream');
module.exports = class GamesService {
static async create(data, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await GamesDBApi.create(data, {
currentUser,
transaction,
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async bulkImport(req, res, sendInvitationEmails = true, host) {
const transaction = await db.sequelize.transaction();
try {
await processFile(req, res);
const bufferStream = new stream.PassThrough();
const results = [];
await bufferStream.end(Buffer.from(req.file.buffer, 'utf-8')); // convert Buffer to Stream
await new Promise((resolve, reject) => {
bufferStream
.pipe(csv())
.on('data', (data) => results.push(data))
.on('end', async () => {
console.log('CSV results', results);
resolve();
})
.on('error', (error) => reject(error));
});
await GamesDBApi.bulkImport(results, {
transaction,
ignoreDuplicates: true,
validate: true,
currentUser: req.currentUser,
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async update(data, id, currentUser) {
const transaction = await db.sequelize.transaction();
try {
let games = await GamesDBApi.findBy({ id }, { transaction });
if (!games) {
throw new ValidationError('gamesNotFound');
}
const updatedGames = await GamesDBApi.update(id, data, {
currentUser,
transaction,
});
await transaction.commit();
return updatedGames;
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async deleteByIds(ids, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await GamesDBApi.deleteByIds(ids, {
currentUser,
transaction,
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
static async remove(id, currentUser) {
const transaction = await db.sequelize.transaction();
try {
await GamesDBApi.remove(id, {
currentUser,
transaction,
});
await transaction.commit();
} catch (error) {
await transaction.rollback();
throw error;
}
}
};

1
frontend/json/runtimeError.json Normal file
View File

@ -0,0 +1 @@
{}