mirror of
https://github.com/Paris-est-Ludique/intranet.git
synced 2025-06-08 08:34:20 +02:00
407 lines
14 KiB
TypeScript
407 lines
14 KiB
TypeScript
/* eslint-disable max-classes-per-file */
|
|
import * as _ from "lodash"
|
|
import path from "path"
|
|
import { promises as fs } from "fs"
|
|
import { GoogleSpreadsheet, GoogleSpreadsheetWorksheet } from "google-spreadsheet"
|
|
|
|
const SCOPES = ["https://www.googleapis.com/auth/spreadsheets"]
|
|
const CRED_PATH = path.resolve(process.cwd(), "./access/gsheets.json")
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-types
|
|
export async function getList<Element extends object>(
|
|
sheetName: string,
|
|
specimen: Element
|
|
): Promise<Element[]> {
|
|
type StringifiedElement = Record<keyof Element, string>
|
|
const sheet = await getGSheet(sheetName)
|
|
|
|
// Load sheet into an array of objects
|
|
const rows = (await sheet.getRows()) as StringifiedElement[]
|
|
const elements: Element[] = []
|
|
if (!rows[0]) {
|
|
// TODO: Report format error to database maintainers
|
|
return []
|
|
}
|
|
const types = _.pick(rows[0], Object.keys(specimen)) as Record<keyof Element, string>
|
|
rows.shift()
|
|
rows.forEach((row) => {
|
|
const stringifiedElement = _.pick(row, Object.keys(specimen)) as Record<
|
|
keyof Element,
|
|
string
|
|
>
|
|
const element = parseElement<Element>(stringifiedElement, types, specimen)
|
|
if (element !== undefined) {
|
|
elements.push(element)
|
|
}
|
|
})
|
|
|
|
return elements
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-types
|
|
export async function setList<Element extends object>(
|
|
sheetName: string,
|
|
elements: Element[]
|
|
): Promise<true | undefined> {
|
|
const sheet = await getGSheet(sheetName)
|
|
|
|
// Load sheet into an array of objects
|
|
const rows = await sheet.getRows()
|
|
if (!rows[0]) {
|
|
return undefined
|
|
}
|
|
const types = _.pick(rows[0], Object.keys(elements[0] || {})) as Record<keyof Element, string>
|
|
|
|
// Update received rows
|
|
let rowid = 1
|
|
// eslint-disable-next-line no-restricted-syntax
|
|
for (const element of elements) {
|
|
const row = rows[rowid]
|
|
const stringifiedRow = stringifyElement(element, types)
|
|
|
|
if (stringifiedRow === undefined) {
|
|
return undefined
|
|
}
|
|
|
|
if (!row) {
|
|
// eslint-disable-next-line no-await-in-loop
|
|
await sheet.addRow(stringifiedRow)
|
|
} else {
|
|
const keys = Object.keys(stringifiedRow)
|
|
const sameCells = _.every(
|
|
keys,
|
|
(key: keyof Element) => row[key as string] === stringifiedRow[key]
|
|
)
|
|
if (!sameCells) {
|
|
keys.forEach((key) => {
|
|
row[key] = stringifiedRow[key as keyof Element]
|
|
})
|
|
// eslint-disable-next-line no-await-in-loop
|
|
await row.save()
|
|
}
|
|
}
|
|
|
|
rowid += 1
|
|
}
|
|
|
|
// Delete all following rows
|
|
for (let rowToDelete = sheet.rowCount - 1; rowToDelete >= rowid; rowToDelete -= 1) {
|
|
if (rows[rowToDelete]) {
|
|
// eslint-disable-next-line no-await-in-loop
|
|
await rows[rowToDelete].delete()
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
async function getGSheet(sheetName: string): Promise<GoogleSpreadsheetWorksheet> {
|
|
const doc = new GoogleSpreadsheet("1pMMKcYx6NXLOqNn6pLHJTPMTOLRYZmSNg2QQcAu7-Pw")
|
|
const creds = await fs.readFile(CRED_PATH)
|
|
// Authentication
|
|
await doc.useServiceAccountAuth(JSON.parse(creds.toString()))
|
|
await doc.loadInfo()
|
|
return doc.sheetsByTitle[sheetName]
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-types
|
|
function parseElement<Element extends object>(
|
|
rawElement: Record<keyof Element, string>,
|
|
types: Record<keyof Element, string>,
|
|
specimen: Element
|
|
): Element | undefined {
|
|
const fullElement = _.reduce(
|
|
types,
|
|
(element: any, type: string, prop: string) => {
|
|
if (element === undefined) {
|
|
return undefined
|
|
}
|
|
const rawProp: string = rawElement[prop as keyof Element]
|
|
switch (type) {
|
|
case "string":
|
|
element[prop] = rawProp
|
|
break
|
|
|
|
case "number":
|
|
element[prop] = +rawProp
|
|
break
|
|
|
|
case "boolean":
|
|
element[prop] = rawProp !== "0" && rawProp !== ""
|
|
break
|
|
|
|
case "date":
|
|
// eslint-disable-next-line no-case-declarations
|
|
const matchDate = rawProp.match(/^([0-9]+)\/([0-9]+)\/([0-9]+)$/)
|
|
if (matchDate) {
|
|
element[prop] = new Date(+matchDate[3], +matchDate[2] - 1, +matchDate[1])
|
|
break
|
|
}
|
|
return undefined // TODO: Report format error to database maintainers
|
|
break
|
|
|
|
default:
|
|
// eslint-disable-next-line no-case-declarations
|
|
const matchArrayType = type.match(/^(number|string|boolean|date)\[([^\]]+)\]$/)
|
|
if (!matchArrayType) {
|
|
return undefined
|
|
}
|
|
if (!rawProp) {
|
|
element[prop] = []
|
|
} else {
|
|
const arrayType = matchArrayType[1]
|
|
const delimiter = matchArrayType[2]
|
|
|
|
switch (arrayType) {
|
|
case "string":
|
|
element[prop] = rawProp.split(delimiter)
|
|
break
|
|
|
|
case "number":
|
|
element[prop] = _.map(rawProp.split(delimiter), (val) => +val)
|
|
break
|
|
|
|
case "boolean":
|
|
element[prop] = _.map(
|
|
rawProp.split(delimiter),
|
|
(val) => val !== "0" && val !== ""
|
|
)
|
|
break
|
|
|
|
case "date":
|
|
// eslint-disable-next-line no-case-declarations
|
|
const rawDates = rawProp.split(delimiter)
|
|
element[prop] = []
|
|
// eslint-disable-next-line no-case-declarations
|
|
const rightFormat = rawDates.every((rawDate) => {
|
|
const matchDateArray = rawDate.match(
|
|
/^([0-9]+)\/([0-9]+)\/([0-9]+)$/
|
|
)
|
|
if (!matchDateArray) {
|
|
return false
|
|
}
|
|
element[prop].push(
|
|
new Date(
|
|
+matchDateArray[3],
|
|
+matchDateArray[2] - 1,
|
|
+matchDateArray[1]
|
|
)
|
|
)
|
|
return true
|
|
})
|
|
if (!rightFormat) {
|
|
return undefined
|
|
}
|
|
break
|
|
default:
|
|
}
|
|
}
|
|
}
|
|
return element
|
|
},
|
|
JSON.parse(JSON.stringify(specimen))
|
|
)
|
|
return fullElement
|
|
}
|
|
|
|
// eslint-disable-next-line @typescript-eslint/ban-types
|
|
function stringifyElement<Element extends object>(
|
|
element: Element,
|
|
types: Record<keyof Element, string>
|
|
): Record<keyof Element, string> | undefined {
|
|
const rawElement: Record<keyof Element, string> | undefined = _.reduce(
|
|
types,
|
|
(
|
|
stringifiedElement: Record<keyof Element, string> | undefined,
|
|
type: string,
|
|
prop: string
|
|
) => {
|
|
if (stringifiedElement === undefined) {
|
|
return undefined
|
|
}
|
|
const value = element[prop as keyof Element]
|
|
switch (type) {
|
|
case "string":
|
|
stringifiedElement[prop as keyof Element] = formulaSafe(`${value}`)
|
|
break
|
|
|
|
case "number":
|
|
stringifiedElement[prop as keyof Element] = `${value}`
|
|
break
|
|
|
|
case "boolean":
|
|
stringifiedElement[prop as keyof Element] = value ? "X" : ""
|
|
break
|
|
|
|
case "date":
|
|
if (value instanceof Date) {
|
|
stringifiedElement[prop as keyof Element] = `${value.getDate()}/${
|
|
value.getMonth() + 1
|
|
}/${value.getFullYear()}`
|
|
break
|
|
} else {
|
|
console.error("Wrong date format in stringifyElement")
|
|
return undefined // TODO: Report format error to database maintainers
|
|
}
|
|
|
|
default:
|
|
// eslint-disable-next-line no-case-declarations
|
|
const matchArrayType = type.match(/^(number|string|boolean|date)\[([^\]]+)\]$/)
|
|
if (!matchArrayType || !_.isArray(value)) {
|
|
console.error("Unknown matchArrayType or not an array in stringifyElement")
|
|
return undefined
|
|
}
|
|
// eslint-disable-next-line no-case-declarations
|
|
const arrayType = matchArrayType[1]
|
|
// eslint-disable-next-line no-case-declarations
|
|
const delimiter = matchArrayType[2]
|
|
|
|
switch (arrayType) {
|
|
case "string":
|
|
if (!_.every(value, _.isString)) {
|
|
return undefined
|
|
}
|
|
stringifiedElement[prop as keyof Element] = formulaSafe(
|
|
value.join(delimiter)
|
|
)
|
|
break
|
|
|
|
case "number":
|
|
if (!_.every(value, _.isNumber)) {
|
|
return undefined
|
|
}
|
|
stringifiedElement[prop as keyof Element] = value.join(delimiter)
|
|
break
|
|
|
|
case "boolean":
|
|
if (!_.every(value, _.isBoolean)) {
|
|
return undefined
|
|
}
|
|
stringifiedElement[prop as keyof Element] = _.map(value, (val) =>
|
|
val ? "X" : ""
|
|
).join(delimiter)
|
|
break
|
|
|
|
case "date":
|
|
if (!_.every(value, _.isDate)) {
|
|
return undefined
|
|
}
|
|
stringifiedElement[prop as keyof Element] = _.map(
|
|
value,
|
|
(val) =>
|
|
`${val.getDate()}/${val.getMonth() + 1}/${val.getFullYear()}`
|
|
).join(delimiter)
|
|
break
|
|
|
|
default:
|
|
return undefined
|
|
}
|
|
}
|
|
|
|
return stringifiedElement
|
|
},
|
|
JSON.parse(JSON.stringify(element))
|
|
)
|
|
|
|
return rawElement
|
|
}
|
|
|
|
function formulaSafe(value: string): string {
|
|
return value.replace(/^=+/, "")
|
|
}
|
|
|
|
export { SCOPES }
|
|
|
|
class Test {
|
|
id = 5
|
|
|
|
wishes = ""
|
|
|
|
dateAjout: Date = new Date(0)
|
|
|
|
ignore = false
|
|
|
|
volunteers: number[] = []
|
|
|
|
equipes: string[] = []
|
|
|
|
datesPossibles: Date[] = []
|
|
|
|
tictactoe: boolean[] = []
|
|
}
|
|
|
|
// Can't run it on every test, it requires private access to a google sheet
|
|
async function testGSheetAPi(): Promise<void> {
|
|
const dataset: Test[] = [
|
|
{
|
|
id: 1,
|
|
wishes: "Présenter le festival et son organisation à un nouveau bénévol au téléphone",
|
|
dateAjout: new Date("2021-10-18T22:00:00.000Z"),
|
|
ignore: true,
|
|
volunteers: [2, 5, 6, 4, 2, 7],
|
|
equipes: ["Accueillir les bénévoles"],
|
|
datesPossibles: [
|
|
new Date("2021-11-18T23:00:00.000Z"),
|
|
new Date("2021-11-19T23:00:00.000Z"),
|
|
new Date("2021-11-20T23:00:00.000Z"),
|
|
],
|
|
tictactoe: [true, false, true, false, false, true],
|
|
},
|
|
{
|
|
id: 5,
|
|
wishes: "Créer de jolies pages webs",
|
|
dateAjout: new Date("2021-10-18T22:00:00.000Z"),
|
|
ignore: false,
|
|
volunteers: [7],
|
|
equipes: ["Site Web Public", "Force Orange"],
|
|
datesPossibles: [],
|
|
tictactoe: [],
|
|
},
|
|
{
|
|
id: 6,
|
|
wishes: "Modérer un salon Discord",
|
|
dateAjout: new Date("2021-10-18T22:00:00.000Z"),
|
|
ignore: true,
|
|
volunteers: [],
|
|
equipes: [],
|
|
datesPossibles: [new Date("2024-10-18T22:00:00.000Z")],
|
|
tictactoe: [false, false, false, false, true, true, true, true],
|
|
},
|
|
]
|
|
|
|
// console.log("Lecture des Volunteers...")
|
|
// const datasetVolunteersLu = await getList<Volunteer>("Volunteers", new Volunteer())
|
|
// if (!datasetVolunteersLu) {
|
|
// console.log("ECHEC de la lecture des volunteers", datasetVolunteersLu)
|
|
// return
|
|
// }
|
|
// console.log("Extraction des volunteers réussie")
|
|
// await fs.writeFile("volunteers.json", JSON.stringify(datasetVolunteersLu))
|
|
|
|
console.log("Test d'écriture...")
|
|
const resultatEcriture = await setList<Test>("Tests de l'API", dataset)
|
|
if (!resultatEcriture) {
|
|
console.log("ECHEC de l'écriture")
|
|
return
|
|
}
|
|
console.log("Écriture réussie")
|
|
|
|
console.log("Test de lecture...")
|
|
const datasetLu = await getList<Test>("Tests de l'API", new Test())
|
|
if (!_.isEqual(datasetLu, dataset)) {
|
|
console.log("ECHEC de la lecture", datasetLu, dataset)
|
|
return
|
|
}
|
|
console.log("Lecture réussie")
|
|
|
|
console.log("Effacement des données...")
|
|
const resultatEffacement = await setList<Test>("Tests de l'API", [])
|
|
if (!resultatEffacement) {
|
|
console.log("ECHEC de l'effacement")
|
|
return
|
|
}
|
|
console.log("Effacement réussi")
|
|
}
|
|
|
|
testGSheetAPi().then(() => console.log("Done"))
|