scott/crabfit
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Refactor backend to import/export syntax and update deps

Browse source
This commit is contained in:
Ben Grant 2022-08-20 21:35:38 +10:00
parent 1463773480
commit 7d0f3898de
20 changed files with 3168 additions and 685 deletions
Download patch file Download diff file Expand all files Collapse all files

105
crabfit-backend/routes/createEvent.js
View file

@ -1,81 +1,84 @@
const dayjs = require('dayjs');
const punycode = require('punycode/');
import dayjs from 'dayjs'
import punycode from 'punycode/'
const adjectives = require('../res/adjectives.json');
const crabs = require('../res/crabs.json');
import adjectives from '../res/adjectives.json'
import crabs from '../res/crabs.json'
const capitalize = string => string.charAt(0).toUpperCase() + string.slice(1);
const capitalize = string => string.charAt(0).toUpperCase() + string.slice(1)
// Generate a random name based on an adjective and a crab species
const generateName = () => {
return `${capitalize(adjectives[Math.floor(Math.random() * adjectives.length)])} ${crabs[Math.floor(Math.random() * crabs.length)]} Crab`;
};
const generateName = () =>
`${capitalize(adjectives[Math.floor(Math.random() * adjectives.length)])} ${crabs[Math.floor(Math.random() * crabs.length)]} Crab`
// Generate a slug for the crab fit
const generateId = name => {
let id = punycode.encode(name.trim().toLowerCase()).trim().replace(/[^A-Za-z0-9 ]/g, '').replace(/\s+/g, '-');
let id = punycode.encode(name.trim().toLowerCase()).trim().replace(/[^A-Za-z0-9 ]/g, '').replace(/\s+/g, '-')
if (id.replace(/-/g, '') === '') {
id = generateName().trim().toLowerCase().replace(/[^A-Za-z0-9 ]/g, '').replace(/\s+/g, '-');
id = generateName().trim().toLowerCase().replace(/[^A-Za-z0-9 ]/g, '').replace(/\s+/g, '-')
}
const number = Math.floor(100000 + Math.random() * 900000);
return `${id}-${number}`;
};
const number = Math.floor(100000 + Math.random() * 900000)
return `${id}-${number}`
}
module.exports = async (req, res) => {
const { event } = req.body;
const createEvent = async (req, res) => {
const { event } = req.body
try {
const name = event.name.trim() === '' ? generateName() : event.name.trim();
let eventId = generateId(name);
const currentTime = dayjs().unix();
try {
const name = event.name.trim() === '' ? generateName() : event.name.trim()
let eventId = generateId(name)
const currentTime = dayjs().unix()
// Check if the event ID already exists, and if so generate a new one
let eventResult;
let eventResult
do {
const query = req.datastore.createQuery(req.types.event)
.select('__key__')
.filter('__key__', req.datastore.key([req.types.event, eventId]));
.filter('__key__', req.datastore.key([req.types.event, eventId]))
eventResult = (await req.datastore.runQuery(query))[0][0];
eventResult = (await req.datastore.runQuery(query))[0][0]
if (eventResult !== undefined) {
eventId = generateId(name);
eventId = generateId(name)
}
} while (eventResult !== undefined);
} while (eventResult !== undefined)
const entity = {
key: req.datastore.key([req.types.event, eventId]),
data: {
name: name,
created: currentTime,
times: event.times,
timezone: event.timezone,
},
};
key: req.datastore.key([req.types.event, eventId]),
data: {
name: name,
created: currentTime,
times: event.times,
timezone: event.timezone,
},
}
await req.datastore.insert(entity);
await req.datastore.insert(entity)
res.status(201).send({
id: eventId,
name: name,
created: currentTime,
times: event.times,
res.status(201).send({
id: eventId,
name: name,
created: currentTime,
times: event.times,
timezone: event.timezone,
});
})
// Update stats
let eventCountResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'eventCount'])))[0] || null;
const eventCountResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'eventCount'])))[0] || null
if (eventCountResult) {
eventCountResult.value++;
await req.datastore.upsert(eventCountResult);
await req.datastore.upsert({
...eventCountResult,
value: eventCountResult.value + 1,
})
} else {
await req.datastore.insert({
key: req.datastore.key([req.types.stats, 'eventCount']),
data: { value: 1 },
});
await req.datastore.insert({
key: req.datastore.key([req.types.stats, 'eventCount']),
data: { value: 1 },
})
}
} catch (e) {
console.error(e);
res.sendStatus(400);
}
};
} catch (e) {
console.error(e)
res.sendStatus(400)
}
}
export default createEvent

102
crabfit-backend/routes/createPerson.js
View file

@ -1,61 +1,65 @@
const dayjs = require('dayjs');
const bcrypt = require('bcrypt');
import dayjs from 'dayjs'
import bcrypt from 'bcrypt'
module.exports = async (req, res) => {
const { eventId } = req.params;
const { person } = req.body;
const createPerson = async (req, res) => {
const { eventId } = req.params
const { person } = req.body
try {
const event = (await req.datastore.get(req.datastore.key([req.types.event, eventId])))[0];
const query = req.datastore.createQuery(req.types.person)
.filter('eventId', eventId)
.filter('name', person.name);
let personResult = (await req.datastore.runQuery(query))[0][0];
try {
const event = (await req.datastore.get(req.datastore.key([req.types.event, eventId])))[0]
const query = req.datastore.createQuery(req.types.person)
.filter('eventId', eventId)
.filter('name', person.name)
const personResult = (await req.datastore.runQuery(query))[0][0]
if (event) {
if (person && personResult === undefined) {
const currentTime = dayjs().unix();
if (event) {
if (person && personResult === undefined) {
const currentTime = dayjs().unix()
// If password
let hash = null;
if (person.password) {
hash = await bcrypt.hash(person.password, 10);
}
// If password
let hash = null
if (person.password) {
hash = await bcrypt.hash(person.password, 10)
}
const entity = {
key: req.datastore.key(req.types.person),
data: {
name: person.name.trim(),
password: hash,
eventId: eventId,
created: currentTime,
availability: [],
},
};
const entity = {
key: req.datastore.key(req.types.person),
data: {
name: person.name.trim(),
password: hash,
eventId: eventId,
created: currentTime,
availability: [],
},
}
await req.datastore.insert(entity);
await req.datastore.insert(entity)
res.sendStatus(201);
res.sendStatus(201)
// Update stats
let personCountResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'personCount'])))[0] || null;
const personCountResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'personCount'])))[0] || null
if (personCountResult) {
personCountResult.value++;
await req.datastore.upsert(personCountResult);
await req.datastore.upsert({
...personCountResult,
value: personCountResult.value + 1,
})
} else {
await req.datastore.insert({
key: req.datastore.key([req.types.stats, 'personCount']),
data: { value: 1 },
});
await req.datastore.insert({
key: req.datastore.key([req.types.stats, 'personCount']),
data: { value: 1 },
})
}
} else {
res.sendStatus(400);
}
} else {
res.sendStatus(404);
}
} catch (e) {
console.error(e);
res.sendStatus(400);
}
};
} else {
res.sendStatus(400)
}
} else {
res.sendStatus(404)
}
} catch (e) {
console.error(e)
res.sendStatus(400)
}
}
export default createPerson

44
crabfit-backend/routes/getEvent.js
View file

@ -1,25 +1,29 @@
const dayjs = require('dayjs');
import dayjs from 'dayjs'
module.exports = async (req, res) => {
const { eventId } = req.params;
const getEvent = async (req, res) => {
const { eventId } = req.params
try {
let event = (await req.datastore.get(req.datastore.key([req.types.event, eventId])))[0];
try {
const event = (await req.datastore.get(req.datastore.key([req.types.event, eventId])))[0]
if (event) {
res.send({
id: eventId,
...event,
});
if (event) {
res.send({
id: eventId,
...event,
})
// Update last visited time
event.visited = dayjs().unix();
await req.datastore.upsert(event);
} else {
res.sendStatus(404);
}
} catch (e) {
console.error(e);
res.sendStatus(404);
}
};
await req.datastore.upsert({
...event,
visited: dayjs().unix()
})
} else {
res.sendStatus(404)
}
} catch (e) {
console.error(e)
res.sendStatus(404)
}
}
export default getEvent

36
crabfit-backend/routes/getPeople.js
View file

@ -1,20 +1,20 @@
module.exports = async (req, res) => {
const { eventId } = req.params;
const getPeople = async (req, res) => {
const { eventId } = req.params
try {
const query = req.datastore.createQuery(req.types.person).filter('eventId', eventId);
let people = (await req.datastore.runQuery(query))[0];
people = people.map(person => ({
name: person.name,
availability: person.availability,
created: person.created,
}));
try {
const query = req.datastore.createQuery(req.types.person).filter('eventId', eventId)
let people = (await req.datastore.runQuery(query))[0]
people = people.map(person => ({
name: person.name,
availability: person.availability,
created: person.created,
}))
res.send({
people,
});
} catch (e) {
console.error(e);
res.sendStatus(404);
}
};
res.send({ people })
} catch (e) {
console.error(e)
res.sendStatus(404)
}
}
export default getPeople

10
crabfit-backend/routes/index.js Normal file
View file

@ -0,0 +1,10 @@
export { default as stats } from './stats'
export { default as getEvent } from './getEvent'
export { default as createEvent } from './createEvent'
export { default as getPeople } from './getPeople'
export { default as createPerson } from './createPerson'
export { default as login } from './login'
export { default as updatePerson } from './updatePerson'
export { default as taskCleanup } from './taskCleanup'
export { default as taskRemoveOrphans } from './taskRemoveOrphans'

60
crabfit-backend/routes/login.js
View file

@ -1,33 +1,35 @@
const bcrypt = require('bcrypt');
import bcrypt from 'bcrypt'
module.exports = async (req, res) => {
const { eventId, personName } = req.params;
const { person } = req.body;
const login = async (req, res) => {
const { eventId, personName } = req.params
const { person } = req.body
try {
const query = req.datastore.createQuery(req.types.person)
.filter('eventId', eventId)
.filter('name', personName);
let personResult = (await req.datastore.runQuery(query))[0][0];
try {
const query = req.datastore.createQuery(req.types.person)
.filter('eventId', eventId)
.filter('name', personName)
const personResult = (await req.datastore.runQuery(query))[0][0]
if (personResult) {
if (personResult.password) {
const passwordsMatch = person && person.password && await bcrypt.compare(person.password, personResult.password);
if (!passwordsMatch) {
return res.status(401).send('Incorrect password');
}
}
if (personResult) {
if (personResult.password) {
const passwordsMatch = person && person.password && await bcrypt.compare(person.password, personResult.password)
if (!passwordsMatch) {
return res.status(401).send('Incorrect password')
}
}
res.send({
name: personName,
availability: personResult.availability,
created: personResult.created,
});
} else {
res.sendStatus(404);
}
} catch (e) {
console.error(e);
res.sendStatus(404);
}
};
res.send({
name: personName,
availability: personResult.availability,
created: personResult.created,
})
} else {
res.sendStatus(404)
}
} catch (e) {
console.error(e)
res.sendStatus(404)
}
}
export default login

30
crabfit-backend/routes/stats.js
View file

@ -1,27 +1,29 @@
const package = require('../package.json');
import packageJson from '../package.json'
module.exports = async (req, res) => {
let eventCount = null;
let personCount = null;
const stats = async (req, res) => {
let eventCount = null
let personCount = null
try {
const eventResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'eventCount'])))[0] || null;
const personResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'personCount'])))[0] || null;
const eventResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'eventCount'])))[0] || null
const personResult = (await req.datastore.get(req.datastore.key([req.types.stats, 'personCount'])))[0] || null
if (eventResult) {
eventCount = eventResult.value;
eventCount = eventResult.value
}
if (personResult) {
personCount = personResult.value;
personCount = personResult.value
}
} catch (e) {
console.error(e);
}
} catch (e) {
console.error(e)
}
res.send({
eventCount,
personCount,
version: package.version,
});
};
version: packageJson.version,
})
}
export default stats

64
crabfit-backend/routes/taskCleanup.js
View file

@ -1,46 +1,48 @@
const dayjs = require('dayjs');
import dayjs from 'dayjs'
module.exports = async (req, res) => {
const taskCleanup = async (req, res) => {
if (req.header('X-Appengine-Cron') === undefined) {
return res.status(400).send('This task can only be run from a cron job');
return res.status(400).send('This task can only be run from a cron job')
}
const threeMonthsAgo = dayjs().subtract(3, 'month').unix();
console.log(`Running cleanup task at ${dayjs().format('h:mma D MMM YYYY')}`);
const threeMonthsAgo = dayjs().subtract(3, 'month').unix()
try {
console.log(`Running cleanup task at ${dayjs().format('h:mma D MMM YYYY')}`)
try {
// Fetch events that haven't been visited in over 3 months
const eventQuery = req.datastore.createQuery(req.types.event).filter('visited', '<', threeMonthsAgo);
let oldEvents = (await req.datastore.runQuery(eventQuery))[0];
const eventQuery = req.datastore.createQuery(req.types.event).filter('visited', '<', threeMonthsAgo)
const oldEvents = (await req.datastore.runQuery(eventQuery))[0]
if (oldEvents && oldEvents.length > 0) {
let oldEventIds = oldEvents.map(e => e[req.datastore.KEY].name);
console.log(`Found ${oldEventIds.length} events to remove`);
if (oldEvents && oldEvents.length > 0) {
const oldEventIds = oldEvents.map(e => e[req.datastore.KEY].name)
console.log(`Found ${oldEventIds.length} events to remove`)
// Fetch availabilities linked to the events discovered
let peopleDiscovered = 0;
await Promise.all(oldEventIds.map(async (eventId) => {
const peopleQuery = req.datastore.createQuery(req.types.person).filter('eventId', eventId);
let oldPeople = (await req.datastore.runQuery(peopleQuery))[0];
let peopleDiscovered = 0
await Promise.all(oldEventIds.map(async eventId => {
const peopleQuery = req.datastore.createQuery(req.types.person).filter('eventId', eventId)
const oldPeople = (await req.datastore.runQuery(peopleQuery))[0]
if (oldPeople && oldPeople.length > 0) {
peopleDiscovered += oldPeople.length;
await req.datastore.delete(oldPeople.map(person => person[req.datastore.KEY]));
peopleDiscovered += oldPeople.length
await req.datastore.delete(oldPeople.map(person => person[req.datastore.KEY]))
}
}));
}))
await req.datastore.delete(oldEvents.map(event => event[req.datastore.KEY]));
await req.datastore.delete(oldEvents.map(event => event[req.datastore.KEY]))
console.log(`Cleanup successful: ${oldEventIds.length} events and ${peopleDiscovered} people removed`);
console.log(`Cleanup successful: ${oldEventIds.length} events and ${peopleDiscovered} people removed`)
res.sendStatus(200);
} else {
console.log(`Found 0 events to remove, ending cleanup`);
res.sendStatus(404);
}
} catch (e) {
console.error(e);
res.sendStatus(404);
}
};
res.sendStatus(200)
} else {
console.log('Found 0 events to remove, ending cleanup')
res.sendStatus(404)
}
} catch (e) {
console.error(e)
res.sendStatus(404)
}
}
export default taskCleanup

68
crabfit-backend/routes/taskLegacyCleanup.js
View file

@ -1,68 +0,0 @@
const dayjs = require('dayjs');
module.exports = async (req, res) => {
if (req.header('X-Appengine-Cron') === undefined) {
return res.status(400).send('This task can only be run from a cron job');
}
const threeMonthsAgo = dayjs().subtract(3, 'month').unix();
console.log(`Running LEGACY cleanup task at ${dayjs().format('h:mma D MMM YYYY')}`);
try {
// Fetch events that haven't been visited in over 3 months
const eventQuery = req.datastore.createQuery(req.types.event).order('created');
let oldEvents = (await req.datastore.runQuery(eventQuery))[0];
oldEvents = oldEvents.filter(event => !event.hasOwnProperty('visited'));
if (oldEvents && oldEvents.length > 0) {
console.log(`Found ${oldEvents.length} events that were missing a visited date`);
// Filter events that are older than 3 months and missing a visited date
oldEvents = oldEvents.filter(event => event.created < threeMonthsAgo);
if (oldEvents && oldEvents.length > 0) {
let oldEventIds = oldEvents.map(e => e[req.datastore.KEY].name);
// Fetch availabilities linked to the events discovered
let eventsRemoved = 0;
let peopleRemoved = 0;
await Promise.all(oldEventIds.map(async (eventId) => {
const peopleQuery = req.datastore.createQuery(req.types.person).filter('eventId', eventId);
let oldPeople = (await req.datastore.runQuery(peopleQuery))[0];
let deleteEvent = true;
if (oldPeople && oldPeople.length > 0) {
oldPeople.forEach(person => {
if (person.created >= threeMonthsAgo) {
deleteEvent = false;
}
});
}
if (deleteEvent) {
if (oldPeople && oldPeople.length > 0) {
peopleRemoved += oldPeople.length;
await req.datastore.delete(oldPeople.map(person => person[req.datastore.KEY]));
}
eventsRemoved++;
await req.datastore.delete(req.datastore.key([req.types.event, eventId]));
}
}));
console.log(`Legacy cleanup successful: ${eventsRemoved} events and ${peopleRemoved} people removed`);
res.sendStatus(200);
} else {
console.log('Found 0 events that are older than 3 months and missing a visited date, ending LEGACY cleanup');
res.sendStatus(404);
}
} else {
console.error('Found no events that are missing a visited date, ending LEGACY cleanup [DISABLE ME!]');
res.sendStatus(404);
}
} catch (e) {
console.error(e);
res.sendStatus(404);
}
};

60
crabfit-backend/routes/taskRemoveOrphans.js
View file

@ -1,46 +1,48 @@
const dayjs = require('dayjs');
import dayjs from 'dayjs'
module.exports = async (req, res) => {
const taskRemoveOrphans = async (req, res) => {
if (req.header('X-Appengine-Cron') === undefined) {
return res.status(400).send('This task can only be run from a cron job');
return res.status(400).send('This task can only be run from a cron job')
}
const threeMonthsAgo = dayjs().subtract(3, 'month').unix();
const threeMonthsAgo = dayjs().subtract(3, 'month').unix()
console.log(`Running orphan removal task at ${dayjs().format('h:mma D MMM YYYY')}`);
console.log(`Running orphan removal task at ${dayjs().format('h:mma D MMM YYYY')}`)
try {
try {
// Fetch people that are older than 3 months
const peopleQuery = req.datastore.createQuery(req.types.person).filter('created', '<', threeMonthsAgo);
let oldPeople = (await req.datastore.runQuery(peopleQuery))[0];
const peopleQuery = req.datastore.createQuery(req.types.person).filter('created', '<', threeMonthsAgo)
const oldPeople = (await req.datastore.runQuery(peopleQuery))[0]
if (oldPeople && oldPeople.length > 0) {
console.log(`Found ${oldPeople.length} people older than 3 months, checking for events`);
if (oldPeople && oldPeople.length > 0) {
console.log(`Found ${oldPeople.length} people older than 3 months, checking for events`)
// Fetch events linked to the people discovered
let peopleWithoutEvents = 0;
await Promise.all(oldPeople.map(async (person) => {
let event = (await req.datastore.get(req.datastore.key([req.types.event, person.eventId])))[0];
let peopleWithoutEvents = 0
await Promise.all(oldPeople.map(async person => {
const event = (await req.datastore.get(req.datastore.key([req.types.event, person.eventId])))[0]
if (!event) {
peopleWithoutEvents++;
await req.datastore.delete(person[req.datastore.KEY]);
peopleWithoutEvents++
await req.datastore.delete(person[req.datastore.KEY])
}
}));
}))
if (peopleWithoutEvents > 0) {
console.log(`Orphan removal successful: ${oldEventIds.length} events and ${peopleDiscovered} people removed`);
res.sendStatus(200);
console.log(`Orphan removal successful: ${peopleWithoutEvents} people removed`)
res.sendStatus(200)
} else {
console.log(`Found 0 people without events, ending orphan removal`);
res.sendStatus(404);
console.log('Found 0 people without events, ending orphan removal')
res.sendStatus(404)
}
} else {
console.log(`Found 0 people older than 3 months, ending orphan removal`);
res.sendStatus(404);
}
} catch (e) {
console.error(e);
res.sendStatus(404);
}
};
} else {
console.log('Found 0 people older than 3 months, ending orphan removal')
res.sendStatus(404)
}
} catch (e) {
console.error(e)
res.sendStatus(404)
}
}
export default taskRemoveOrphans

65
crabfit-backend/routes/updatePerson.js
View file

@ -1,37 +1,40 @@
const bcrypt = require('bcrypt');
import bcrypt from 'bcrypt'
module.exports = async (req, res) => {
const { eventId, personName } = req.params;
const { person } = req.body;
const updatePerson = async (req, res) => {
const { eventId, personName } = req.params
const { person } = req.body
try {
const query = req.datastore.createQuery(req.types.person)
.filter('eventId', eventId)
.filter('name', personName);
let personResult = (await req.datastore.runQuery(query))[0][0];
try {
const query = req.datastore.createQuery(req.types.person)
.filter('eventId', eventId)
.filter('name', personName)
const personResult = (await req.datastore.runQuery(query))[0][0]
if (personResult) {
if (person && person.availability) {
if (personResult.password) {
const passwordsMatch = person.password && await bcrypt.compare(person.password, personResult.password);
if (!passwordsMatch) {
return res.status(401).send('Incorrect password');
}
}
if (personResult) {
if (person && person.availability) {
if (personResult.password) {
const passwordsMatch = person.password && await bcrypt.compare(person.password, personResult.password)
if (!passwordsMatch) {
return res.status(401).send('Incorrect password')
}
}
personResult.availability = person.availability;
await req.datastore.upsert({
...personResult,
availability: person.availability,
})
await req.datastore.upsert(personResult);
res.sendStatus(200)
} else {
res.sendStatus(400)
}
} else {
res.sendStatus(404)
}
} catch (e) {
console.error(e)
res.sendStatus(400)
}
}
res.sendStatus(200);
} else {
res.sendStatus(400);
}
} else {
res.sendStatus(404);
}
} catch (e) {
console.error(e);
res.sendStatus(400);
}
};
export default updatePerson