geolba/tethys.backend
geolba/tethys.backend
2
0
Fork 2
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

- update to AdonisJS 6
Some checks failed
CI Pipeline / japa-tests (push) Failing after 1m15s
Details

Browse source
This commit is contained in:
Kaimbacher 2024-03-14 20:25:27 +01:00
parent f828ca4491
commit cb51a4136f
167 changed files with 21485 additions and 21212 deletions
Download patch file Download diff file Expand all files Collapse all files

16
app/Controllers/Http/Admin/HomeController.ts
View file

@ -1,17 +1,17 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import type { HttpContext } from '@adonisjs/core/http';
export default class HomeController {
public async index({}: HttpContextContract) {}
public async index({}: HttpContext) {}
public async create({}: HttpContextContract) {}
public async create({}: HttpContext) {}
public async store({}: HttpContextContract) {}
public async store({}: HttpContext) {}
public async show({}: HttpContextContract) {}
public async show({}: HttpContext) {}
public async edit({}: HttpContextContract) {}
public async edit({}: HttpContext) {}
public async update({}: HttpContextContract) {}
public async update({}: HttpContext) {}
public async destroy({}: HttpContextContract) {}
public async destroy({}: HttpContext) {}
}

28
app/Controllers/Http/Admin/RoleController.ts
View file

@ -1,14 +1,14 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import Role from 'App/Models/Role';
import Permission from 'App/Models/Permission';
import type { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
import CreateRoleValidator from 'App/Validators/CreateRoleValidator';
import UpdateRoleValidator from 'App/Validators/UpdateRoleValidator';
import { RenderResponse } from '@ioc:EidelLev/Inertia';
import type { HttpContext } from '@adonisjs/core/http';
import Role from '#app/Models/Role';
import Permission from '#app/Models/Permission';
import CreateRoleValidator from '#app/Validators/CreateRoleValidator';
import UpdateRoleValidator from '#app/Validators/UpdateRoleValidator';
import type { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
// import { schema, rules } from '@ioc:Adonis/Core/Validator';
export default class RoleController {
public async index({ auth, request, inertia }: HttpContextContract) {
public async index({ auth, request, inertia }: HttpContext) {
let roles: ModelQueryBuilderContract<typeof Role, Role> = Role.query();
if (request.input('search')) {
@ -48,14 +48,14 @@ export default class RoleController {
});
}
public async create({ inertia }: HttpContextContract) {
public async create({ inertia }: HttpContext) {
const permissions = await Permission.query().select('id', 'name').pluck('name', 'id');
return inertia.render('Admin/Role/Create', {
permissions: permissions,
});
}
public async store({ request, response, session }: HttpContextContract) {
public async store({ request, response, session }: HttpContext) {
// node ace make:validator CreateUser
try {
// Step 2 - Validate request body against the schema
@ -79,7 +79,7 @@ export default class RoleController {
return response.redirect().toRoute('role.index');
}
public async show({ request, inertia }: HttpContextContract): RenderResponse {
public async show({ request, inertia }: HttpContext) {
const id = request.param('id');
const role = await Role.query().where('id', id).firstOrFail();
@ -94,7 +94,7 @@ export default class RoleController {
});
}
public async edit({ request, inertia }: HttpContextContract) {
public async edit({ request, inertia }: HttpContext) {
const id = request.param('id');
const role = await Role.query().where('id', id).firstOrFail();
@ -109,7 +109,7 @@ export default class RoleController {
});
}
public async update({ request, response, session }: HttpContextContract) {
public async update({ request, response, session }: HttpContext) {
// node ace make:validator UpdateUser
const id = request.param('id');
const role = await Role.query().where('id', id).firstOrFail();
@ -132,7 +132,7 @@ export default class RoleController {
return response.redirect().toRoute('settings.role.index');
}
public async destroy({ request, response, session }: HttpContextContract) {
public async destroy({ request, response, session }: HttpContext) {
const id = request.param('id');
const role = await Role.findOrFail(id);
await role.delete();

31
app/Controllers/Http/Admin/UsersController.ts
View file

@ -1,16 +1,15 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import User from 'App/Models/User';
import Role from 'App/Models/Role';
import type { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
import CreateUserValidator from 'App/Validators/CreateUserValidator';
import UpdateUserValidator from 'App/Validators/UpdateUserValidator';
// import { RenderResponse } from '@ioc:EidelLev/Inertia';
import type { HttpContext } from '@adonisjs/core/http';
import User from '#app/Models/User';
import Role from '#app/Models/Role';
import { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
import CreateUserValidator from '#app/Validators/CreateUserValidator';
import UpdateUserValidator from '#app/Validators/UpdateUserValidator';
// import { schema, rules } from '@ioc:Adonis/Core/Validator';
// import Hash from '@ioc:Adonis/Core/Hash';
// import { schema, rules } from '@ioc:Adonis/Core/Validator';
export default class UsersController {
public async index({ auth, request, inertia }: HttpContextContract) {
export default class AdminUserController {
public async index({ auth, request, inertia }: HttpContext) {
const page = request.input('page', 1);
// const limit = 10
@ -48,7 +47,7 @@ export default class UsersController {
// .preload('focusInterests')
// .preload('role')
.paginate(page, 5);
// var test = request.all();
return inertia.render('Admin/User/Index', {
@ -63,7 +62,7 @@ export default class UsersController {
});
}
public async create({ inertia }: HttpContextContract) {
public async create({ inertia }: HttpContext) {
// let rolesPluck = {};
// (await Role.query().select('id', 'name')).forEach((user) => {
// rolesPluck[user.id] = user.name;
@ -75,7 +74,7 @@ export default class UsersController {
});
}
public async store({ request, response, session }: HttpContextContract) {
public async store({ request, response, session }: HttpContext) {
// node ace make:validator CreateUser
try {
// Step 2 - Validate request body against the schema
@ -97,7 +96,7 @@ export default class UsersController {
return response.redirect().toRoute('user.index');
}
public async show({ request, inertia }: HttpContextContract) {
public async show({ request, inertia }: HttpContext) {
const id = request.param('id');
const user = await User.query().where('id', id).firstOrFail();
@ -112,7 +111,7 @@ export default class UsersController {
});
}
public async edit({ request, inertia }: HttpContextContract) {
public async edit({ request, inertia }: HttpContext) {
const id = request.param('id');
const user = await User.query().where('id', id).firstOrFail();
@ -127,7 +126,7 @@ export default class UsersController {
});
}
public async update({ request, response, session }: HttpContextContract) {
public async update({ request, response, session }: HttpContext) {
// node ace make:validator UpdateUser
const id = request.param('id');
const user = await User.query().where('id', id).firstOrFail();
@ -154,7 +153,7 @@ export default class UsersController {
return response.redirect().toRoute('settings.user.index');
}
public async destroy({ request, response, session }: HttpContextContract) {
public async destroy({ request, response, session }: HttpContext) {
const id = request.param('id');
const user = await User.findOrFail(id);
await user.delete();

8
app/Controllers/Http/Api/AuthorsController.ts
View file

@ -1,10 +1,10 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import Person from 'App/Models/Person';
import type { HttpContext } from '@adonisjs/core/http';
import Person from '#app/Models/Person';
// import Dataset from 'App/Models/Dataset';
// node ace make:controller Author
export default class AuthorsController {
public async index({}: HttpContextContract) {
public async index({}: HttpContext) {
// select * from gba.persons
// where exists (select * from gba.documents inner join gba.link_documents_persons on "documents"."id" = "link_documents_persons"."document_id"
// where ("link_documents_persons"."role" = 'author') and ("persons"."id" = "link_documents_persons"."person_id"));
@ -19,7 +19,7 @@ export default class AuthorsController {
return authors;
}
public async persons({ request }: HttpContextContract) {
public async persons({ request }: HttpContext) {
const authors = Person.query().where('status', true);
if (request.input('filter')) {

6
app/Controllers/Http/Api/AvatarController.ts
View file

@ -1,4 +1,4 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import type { HttpContext } from '@adonisjs/core/http';
import { StatusCodes } from 'http-status-codes';
// import * as fs from 'fs';
// import * as path from 'path';
@ -7,7 +7,7 @@ const prefixes = ['von', 'van'];
// node ace make:controller Author
export default class AvatarController {
public async generateAvatar({ request, response }: HttpContextContract) {
public async generateAvatar({ request, response }: HttpContext) {
try {
const { name, background, textColor, size } = request.only(['name', 'background', 'textColor', 'size']);
@ -40,7 +40,7 @@ export default class AvatarController {
}
}
private getInitials(name) {
private getInitials(name: string) {
const parts = name.split(' ');
let initials = '';

10
app/Controllers/Http/Api/DatasetController.ts
View file

@ -1,11 +1,11 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import type { HttpContext } from '@adonisjs/core/http';
// import Person from 'App/Models/Person';
import Dataset from 'App/Models/Dataset';
import Dataset from '#app/Models/Dataset';
import { StatusCodes } from 'http-status-codes';
// node ace make:controller Author
export default class DatasetController {
public async index({}: HttpContextContract) {
public async index({}: HttpContext) {
// select * from gba.persons
// where exists (select * from gba.documents inner join gba.link_documents_persons on "documents"."id" = "link_documents_persons"."document_id"
// where ("link_documents_persons"."role" = 'author') and ("persons"."id" = "link_documents_persons"."person_id"));
@ -14,7 +14,7 @@ export default class DatasetController {
return datasets;
}
public async findAll({ response }: HttpContextContract) {
public async findAll({ response }: HttpContext) {
try {
const datasets = await Dataset.query()
.where('server_state', 'published')
@ -29,7 +29,7 @@ export default class DatasetController {
}
}
public async findOne({ params }: HttpContextContract) {
public async findOne({ params }: HttpContext) {
const datasets = await Dataset.query()
.where('publish_id', params.publish_id)
.preload('titles')

6
app/Controllers/Http/Api/FileController.ts
View file

@ -1,5 +1,5 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import File from 'App/Models/File';
import type { HttpContext } from '@adonisjs/core/http';
import File from '#app/Models/File';
import { StatusCodes } from 'http-status-codes';
import * as fs from 'fs';
import * as path from 'path';
@ -7,7 +7,7 @@ import * as path from 'path';
// node ace make:controller Author
export default class FileController {
// @Get("download/:id")
public async findOne({ response, params }: HttpContextContract) {
public async findOne({ response, params }: HttpContext) {
const id = params.id;
const file = await File.findOrFail(id);
// const file = await File.findOne({

26
app/Controllers/Http/Api/HomeController.ts
View file

@ -1,9 +1,9 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import Database from '@ioc:Adonis/Lucid/Database';
import type { HttpContext } from '@adonisjs/core/http';
import db from '@adonisjs/lucid/services/db';
import { StatusCodes } from 'http-status-codes';
export default class HomeController {
public async findDocumentsPerYear({ response, params }: HttpContextContract) {
public async findDocumentsPerYear({ response, params }: HttpContext) {
const year = params.year;
const from = parseInt(year);
const serverState = 'published';
@ -17,8 +17,8 @@ export default class HomeController {
// .preload('authors')
// .orderBy('server_date_published');
const datasets = await Database.from('documents as doc')
.select(['publish_id', 'server_date_published', Database.raw(`date_part('year', server_date_published) as pub_year`)])
const datasets = await db.from('documents as doc')
.select(['publish_id', 'server_date_published', db.raw(`date_part('year', server_date_published) as pub_year`)])
.where('server_state', serverState)
.innerJoin('link_documents_persons as ba', 'doc.id', 'ba.document_id')
.andWhereRaw(`date_part('year', server_date_published) = ?`, [from])
@ -32,17 +32,17 @@ export default class HomeController {
}
}
public async findYears({ response }: HttpContextContract) {
public async findYears({ response }: HttpContext) {
const serverState = 'published';
// Use raw SQL queries to select all cars which belongs to the user
try {
const datasets = await Database.rawQuery(
const datasets = await db.rawQuery(
'SELECT distinct EXTRACT(YEAR FROM server_date_published) as published_date FROM gba.documents WHERE server_state = ?',
[serverState],
);
// Pluck the ids of the cars
const years = datasets.rows.map((dataset) => dataset.published_date);
const years = datasets.rows.map((dataset: any) => dataset.published_date);
// check if the cars is returned
// if (years.length > 0) {
return response.status(StatusCodes.OK).json(years);
@ -54,7 +54,7 @@ export default class HomeController {
}
}
public async findPublicationsPerMonth({ response }: HttpContextContract) {
public async findPublicationsPerMonth({ response }: HttpContext) {
const serverState = 'published';
// const year = params.year;
// const from = parseInt(year);
@ -70,11 +70,11 @@ export default class HomeController {
const years = [2021, 2022, 2023]; // Add the second year
const result = await Database.from('documents as doc')
const result = await db.from('documents as doc')
.select([
Database.raw(`date_part('year', server_date_published) as pub_year`),
Database.raw(`date_part('month', server_date_published) as pub_month`),
Database.raw('COUNT(*) as count'),
db.raw(`date_part('year', server_date_published) as pub_year`),
db.raw(`date_part('month', server_date_published) as pub_month`),
db.raw('COUNT(*) as count'),
])
.where('server_state', serverState)
// .innerJoin('link_documents_persons as ba', 'doc.id', 'ba.document_id')

10
app/Controllers/Http/Api/UserController.ts
View file

@ -1,15 +1,15 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import type { HttpContext } from '@adonisjs/core/http';
// import TotpSecret from 'App/Models/TotpSecret';
import User from 'App/Models/User';
import TwoFactorAuthProvider from 'App/Services/TwoFactorAuthProvider';
import User from '#app/Models/User';
import TwoFactorAuthProvider from '#app/Services/TwoFactorAuthProvider';
import { StatusCodes } from 'http-status-codes';
import { InvalidArgumentException } from 'node-exceptions';
import { TotpState } from 'Contracts/enums';
import { TotpState } from '#contracts/enums';
// Here we are generating secret and recovery codes for the user that’s enabling 2FA and storing them to our database.
export default class UserController {
public async enable({ auth, response, request }: HttpContextContract) {
public async enable({ auth, response, request }: HttpContext) {
const user = (await User.find(auth.user?.id)) as User;
// await user.load('totp_secret');
// if (!user.totp_secret) {

35
app/Controllers/Http/Auth/AuthController.ts
View file

@ -1,16 +1,20 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import User from 'App/Models/User';
import type { HttpContext } from '@adonisjs/core/http';
import User from '#models/User';
// import Hash from '@ioc:Adonis/Core/Hash';
// import InvalidCredentialException from 'App/Exceptions/InvalidCredentialException';
import AuthValidator from 'App/Validators/AuthValidator';
import AuthValidator from '#app/Validators/AuthValidator';
import TwoFactorAuthProvider from 'App/Services/TwoFactorAuthProvider';
import TwoFactorAuthProvider from '#app/Services/TwoFactorAuthProvider';
// import { Authenticator } from '@adonisjs/auth';
// import { LoginState } from 'Contracts/enums';
// import { StatusCodes } from 'http-status-codes';
// interface MyHttpsContext extends HttpContext {
// auth: Authenticator<User>
// }
export default class AuthController {
// login function
public async login({ request, response, auth, session }: HttpContextContract) {
// login function{ request, auth, response }:HttpContext
public async login({ request, response, auth, session }: HttpContext) {
// console.log({
// registerBody: request.body(),
// });
@ -25,7 +29,9 @@ export default class AuthController {
// // attempt to verify credential and login user
// await auth.use('web').attempt(email, plainPassword);
const user = await auth.use('web').verifyCredentials(email, password);
// const user = await auth.use('web').verifyCredentials(email, password);
const user = await User.verifyCredentials(email, password)
if (user.isTwoFactorEnabled) {
// session.put("login.id", user.id);
// return view.render("pages/two-factor-challenge");
@ -38,8 +44,9 @@ export default class AuthController {
// state: state,
// new_user_id: user.id,
// });
}
await auth.login(user);
}
await auth.use('web').login(user);
} catch (error) {
// if login fails, return vague form message and redirect back
session.flash('message', 'Your username, email, or password is incorrect');
@ -50,7 +57,7 @@ export default class AuthController {
response.redirect('/apps/dashboard');
}
public async twoFactorChallenge({ request, session, auth, response }) {
public async twoFactorChallenge({ request, session, auth, response }: HttpContext) {
const { code, recoveryCode, login_id } = request.only(['code', 'recoveryCode', 'login_id']);
// const user = await User.query().where('id', session.get('login.id')).firstOrFail();
const user = await User.query().where('id', login_id).firstOrFail();
@ -59,7 +66,7 @@ export default class AuthController {
const isValid = await TwoFactorAuthProvider.validate(user, code);
if (isValid) {
// login user and redirect to dashboard
await auth.login(user);
await auth.use('web').login(user);
response.redirect('/apps/dashboard');
} else {
session.flash('message', 'Your tow factor code is incorrect');
@ -70,17 +77,17 @@ export default class AuthController {
if (codes.includes(recoveryCode)) {
user.twoFactorRecoveryCodes = codes.filter((c) => c !== recoveryCode);
await user.save();
await auth.login(user);
await auth.use('web').login(user);
response.redirect('/apps/dashboard');
}
}
}
// logout function
public async logout({ auth, response }: HttpContextContract) {
public async logout({ auth, response }: HttpContext) {
// await auth.logout();
await auth.use('web').logout();
response.redirect('/app/login');
return response.redirect('/app/login');
// return response.status(200);
}
}

28
app/Controllers/Http/Auth/UserController.ts
View file

@ -1,9 +1,9 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import User from 'App/Models/User';
import { RenderResponse } from '@ioc:EidelLev/Inertia';
import TwoFactorAuthProvider from 'App/Services/TwoFactorAuthProvider';
import Hash from '@ioc:Adonis/Core/Hash';
import { schema, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContext } from '@adonisjs/core/http';
import User from '#app/Models/User';
// import { RenderResponse } from '@ioc:EidelLev/Inertia';
import TwoFactorAuthProvider from '#app/Services/TwoFactorAuthProvider';
import hash from '@adonisjs/core/services/hash';
import { schema, rules } from '@adonisjs/validator';
// Here we are generating secret and recovery codes for the user that’s enabling 2FA and storing them to our database.
export default class UserController {
@ -12,7 +12,7 @@ export default class UserController {
*
* @return — \Inertia\Response
*/
public async accountInfo({ inertia, auth }: HttpContextContract): RenderResponse {
public async accountInfo({ inertia, auth }: HttpContext) {
// const user = auth.user;
const user = (await User.find(auth.user?.id)) as User;
// const id = request.param('id');
@ -25,7 +25,7 @@ export default class UserController {
});
}
public async accountInfoStore({ auth, request, response, session }) {
public async accountInfoStore({ auth, request, response, session }: HttpContext) {
const passwordSchema = schema.create({
old_password: schema.string({ trim: true }, [rules.required()]),
new_password: schema.string({ trim: true }, [rules.minLength(8), rules.maxLength(255), rules.confirmed('confirm_password')]),
@ -39,7 +39,7 @@ export default class UserController {
}
try {
const user = await auth.user;
const user = await auth.user as User;
const { old_password, new_password } = request.only(['old_password', 'new_password']);
// if (!(old_password && new_password && confirm_password)) {
@ -47,9 +47,9 @@ export default class UserController {
// }
// Verify if the provided old password matches the user's current password
const isSame = await Hash.verify(user.password, old_password);
const isSame = await hash.verify(user.password, old_password);
if (!isSame) {
return response.flash({ warning: 'Old password is incorrect.' }).redirect().back();
return response.flash('warning', 'Old password is incorrect.').redirect().back();
}
// Hash the new password before updating the user's password
@ -57,7 +57,7 @@ export default class UserController {
await user.save();
// return response.status(200).send({ message: 'Password updated successfully.' });
session.flash('Password updated successfully.');
session.flash({ message: 'Password updated successfully.' });
return response.redirect().toRoute('settings.user.index');
} catch (error) {
// return response.status(500).send({ message: 'Internal server error.' });
@ -65,7 +65,7 @@ export default class UserController {
}
}
public async enableTwoFactorAuthentication({ auth, response, session }: HttpContextContract): Promise<void> {
public async enableTwoFactorAuthentication({ auth, response, session }: HttpContext): Promise<void> {
// const user: User | undefined = auth?.user;
const user = (await User.find(auth.user?.id)) as User;
@ -87,7 +87,7 @@ export default class UserController {
// });
}
public async disableTwoFactorAuthentication({ auth, response, session }): Promise<void> {
public async disableTwoFactorAuthentication({ auth, response, session }: HttpContext): Promise<void> {
const user = auth?.user;
user.twoFactorSecret = null;

59
app/Controllers/Http/Editor/DatasetController.ts
View file

@ -1,22 +1,23 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import type { HttpContext } from '@adonisjs/core/http';
import { Client } from '@opensearch-project/opensearch';
import User from 'App/Models/User';
import Dataset from 'App/Models/Dataset';
import DatasetIdentifier from 'App/Models/DatasetIdentifier';
import XmlModel from 'App/Library/XmlModel';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces';
import User from '#app/Models/User';
import Dataset from '#app/Models/Dataset';
import DatasetIdentifier from '#app/Models/DatasetIdentifier';
import XmlModel from '#app/Library/XmlModel';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces.js';
import { create } from 'xmlbuilder2';
import { readFileSync } from 'fs';
import { transform } from 'saxon-js';
import type { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
import { schema, CustomMessages } from '@ioc:Adonis/Core/Validator';
import SaxonJS from 'saxon-js';
import { schema } from '@adonisjs/validator';
import { DateTime } from 'luxon';
import Index from 'App/Library/Utils/Index';
import { getDomain } from 'App/Utils/utility-functions';
import { DoiClient } from 'App/Library/Doi/DoiClient';
import DoiClientException from 'App/Exceptions/DoiClientException';
import Logger from '@ioc:Adonis/Core/Logger';
import Index from '#app/Library/Utils/Index';
import { getDomain } from '#app/Utils/utility-functions';
import { DoiClient } from '#app/Library/Doi/DoiClient';
import DoiClientException from '#app/Exceptions/DoiClientException';
import logger from '@adonisjs/core/services/logger';
import { HttpException } from 'node-exceptions';
import { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
import { CustomMessages } from "@adonisjs/validator/types";
// Create a new instance of the client
const client = new Client({ node: 'http://localhost:9200' }); // replace with your OpenSearch endpoint
@ -37,7 +38,7 @@ export default class DatasetsController {
}
// public async index({}: HttpContextContract) {}
public async index({ auth, request, inertia }: HttpContextContract) {
public async index({ auth, request, inertia }: HttpContext) {
const user = (await User.find(auth.user?.id)) as User;
const page = request.input('page', 1);
let datasets: ModelQueryBuilderContract<typeof Dataset, Dataset> = Dataset.query();
@ -92,7 +93,7 @@ export default class DatasetsController {
});
}
public async receive({ request, inertia, response }: HttpContextContract) {
public async receive({ request, inertia, response }: HttpContext) {
const id = request.param('id');
const dataset = await Dataset.query()
.where('id', id)
@ -121,7 +122,7 @@ export default class DatasetsController {
});
}
public async receiveUpdate({ auth, request, response }) {
public async receiveUpdate({ auth, request, response }: HttpContext) {
const id = request.param('id');
// const { id } = params;
const dataset = await Dataset.findOrFail(id);
@ -153,7 +154,7 @@ export default class DatasetsController {
}
}
public async approve({ request, inertia, response }) {
public async approve({ request, inertia, response }: HttpContext) {
const id = request.param('id');
// $dataset = Dataset::with('user:id,login')->findOrFail($id);
const dataset = await Dataset.findOrFail(id);
@ -182,7 +183,7 @@ export default class DatasetsController {
});
}
public async approveUpdate({ request, response }) {
public async approveUpdate({ request, response }: HttpContext) {
const approveDatasetSchema = schema.create({
reviewer_id: schema.number(),
});
@ -221,7 +222,7 @@ export default class DatasetsController {
}
}
public async publish({ request, inertia, response }) {
public async publish({ request, inertia, response }: HttpContext) {
const id = request.param('id');
const dataset = await Dataset.query()
@ -250,7 +251,7 @@ export default class DatasetsController {
});
}
public async publishUpdate({ request, response }) {
public async publishUpdate({ request, response }: HttpContext) {
const publishDatasetSchema = schema.create({
publisher_name: schema.string({ trim: true }),
});
@ -287,7 +288,7 @@ export default class DatasetsController {
}
}
public async doiCreate({ request, inertia }: HttpContextContract) {
public async doiCreate({ request, inertia }: HttpContext) {
const id = request.param('id');
const dataset = await Dataset.query()
.where('id', id)
@ -301,7 +302,7 @@ export default class DatasetsController {
});
}
public async doiStore({ request, response }: HttpContextContract) {
public async doiStore({ request, response }: HttpContext) {
const dataId = request.param('publish_id');
const dataset = await Dataset.query()
// .preload('xmlCache')
@ -338,7 +339,7 @@ export default class DatasetsController {
const index_name = 'tethys-records';
await Index.indexDocument(dataset, index_name);
} catch (error) {
Logger.error(`${__filename}: Indexing document ${dataset.id} failed: ${error.message}`);
logger.error(`${__filename}: Indexing document ${dataset.id} failed: ${error.message}`);
// Log the error or handle it as needed
throw new HttpException(error.message);
}
@ -351,12 +352,12 @@ export default class DatasetsController {
// return response.toRoute('editor.dataset.list').flash('message', xmlMeta);
}
public async show({}: HttpContextContract) {}
public async show({}: HttpContext) {}
public async edit({}: HttpContextContract) {}
public async edit({}: HttpContext) {}
// public async update({}: HttpContextContract) {}
public async update({ response }) {
public async update({ response }: HttpContext) {
const id = 273; //request.param('id');
const dataset = await Dataset.query().preload('xmlCache').where('id', id).firstOrFail();
// add xml elements
@ -374,7 +375,7 @@ export default class DatasetsController {
const xmlString = xml.end({ prettyPrint: false });
let doc = '';
try {
const result = await transform({
const result = await SaxonJS.transform({
// stylesheetFileName: `${config.TMP_BASE_DIR}/data-quality/rules/iati.sef.json`,
stylesheetText: this.proc,
destination: 'serialized',
@ -472,7 +473,7 @@ export default class DatasetsController {
}
}
public async destroy({}: HttpContextContract) {}
public async destroy({}: HttpContext) {}
private async createXmlRecord(dataset: Dataset, datasetNode: XMLBuilder) {
const domNode = await this.getDatasetXmlDomNode(dataset);

63
app/Controllers/Http/Oai/OaiController.ts
View file

@ -1,27 +1,31 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import { RequestContract } from '@ioc:Adonis/Core/Request';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces';
import type { HttpContext } from '@adonisjs/core/http';
// import { RequestContract } from '@ioc:Adonis/Core/Request';
import { Request } from '@adonisjs/core/http';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces.js';
import { create } from 'xmlbuilder2';
import dayjs, { Dayjs } from 'dayjs';
import utc from 'dayjs/plugin/utc';
import timezone from 'dayjs/plugin/timezone';
import utc from 'dayjs/plugin/utc.js';
import timezone from 'dayjs/plugin/timezone.js';
import { readFileSync } from 'fs';
import { StatusCodes } from 'http-status-codes';
import { transform } from 'saxon-js';
import SaxonJS from 'saxon-js';
// import { Xslt, xmlParse } from 'xslt-processor'
import { OaiErrorCodes, OaiModelError } from 'App/Exceptions/OaiErrorCodes';
import { OaiModelException, BadOaiModelException } from 'App/Exceptions/OaiModelException';
import Dataset from 'App/Models/Dataset';
import Collection from 'App/Models/Collection';
import { getDomain, preg_match } from 'App/Utils/utility-functions';
import XmlModel from 'App/Library/XmlModel';
import Logger from '@ioc:Adonis/Core/Logger';
import ResumptionToken from 'App/Library/Oai/ResumptionToken';
import { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
import Config from '@ioc:Adonis/Core/Config';
import { inject } from '@adonisjs/fold';
import { OaiErrorCodes, OaiModelError } from '#app/Exceptions/OaiErrorCodes';
import { OaiModelException, BadOaiModelException } from '#app/Exceptions/OaiModelException';
import Dataset from '#app/Models/Dataset';
import Collection from '#app/Models/Collection';
import { getDomain, preg_match } from '#app/Utils/utility-functions';
import XmlModel from '#app/Library/XmlModel';
import logger from '@adonisjs/core/services/logger';
import ResumptionToken from '#app/Library/Oai/ResumptionToken';
// import Config from '@ioc:Adonis/Core/Config';
import config from '@adonisjs/core/services/config'
// import { inject } from '@adonisjs/fold';
import { inject } from '@adonisjs/core'
// import { TokenWorkerContract } from "MyApp/Models/TokenWorker";
import TokenWorkerContract from 'App/Library/Oai/TokenWorker';
import TokenWorkerContract from '#library/Oai/TokenWorkerContract';
import { ModelQueryBuilderContract } from '@adonisjs/lucid/types/model';
interface XslTParameter {
[key: string]: any;
@ -39,7 +43,7 @@ interface ListParameter {
metadataPrefix: string;
}
@inject(['App/Library/Oai/TokenWorkerContract'])
@inject()
export default class OaiController {
private deliveringDocumentStates = ['published', 'deleted'];
private sampleRegEx = /^[A-Za-zäüÄÜß0-9\-_.!~]+$/;
@ -53,6 +57,7 @@ export default class OaiController {
private xml: XMLBuilder;
private proc;
constructor(public tokenWorker: TokenWorkerContract) {
// Load the XSLT file
this.proc = readFileSync('public/assets2/datasetxml2oai.sef.json');
@ -60,12 +65,12 @@ export default class OaiController {
dayjs.extend(timezone);
}
public async index({ response, request }: HttpContextContract): Promise<void> {
public async index({ response, request }: HttpContext): Promise<void> {
this.xml = create({ version: '1.0', encoding: 'UTF-8', standalone: true }, '<root></root>');
// this.proc = new XSLTProcessor();
// const stylesheet = readFileSync(__dirname + "/datasetxml2oai.sef.json");
const xsltParameter = (this.xsltParameter = {});
const xsltParameter: XslTParameter = (this.xsltParameter = {});
let oaiRequest: Dictionary = {};
if (request.method() === 'POST') {
@ -106,7 +111,7 @@ export default class OaiController {
let xmlOutput; // = xmlString;
try {
const result = await transform({
const result = await SaxonJS.transform({
// stylesheetFileName: `${config.TMP_BASE_DIR}/data-quality/rules/iati.sef.json`,
stylesheetText: this.proc,
destination: 'serialized',
@ -130,7 +135,7 @@ export default class OaiController {
response.status(StatusCodes.OK).send(xmlOutput);
}
protected async handleRequest(oaiRequest: Dictionary, request: RequestContract) {
protected async handleRequest(oaiRequest: Dictionary, request: Request) {
// Setup stylesheet
// $this->loadStyleSheet('datasetxml2oai-pmh.xslt');
@ -258,14 +263,14 @@ export default class OaiController {
protected async handleListIdentifiers(oaiRequest: Dictionary) {
!this.tokenWorker.isConnected && (await this.tokenWorker.connect());
const maxIdentifier: number = Config.get('oai.max.listidentifiers', 100);
const maxIdentifier: number = config.get('oai.max.listidentifiers', 100);
await this.handleLists(oaiRequest, maxIdentifier);
}
protected async handleListRecords(oaiRequest) {
protected async handleListRecords(oaiRequest: Dictionary) {
!this.tokenWorker.isConnected && (await this.tokenWorker.connect());
const maxRecords: number = Config.get('oai.max.listrecords', 100);
const maxRecords: number = config.get('oai.max.listrecords', 100);
await this.handleLists(oaiRequest, maxRecords);
}
@ -335,7 +340,7 @@ export default class OaiController {
}
}
private async handleResumptionToken(oaiRequest: Dictionary, maxRecords: number, numWrapper) {
private async handleResumptionToken(oaiRequest: Dictionary, maxRecords: number, numWrapper: ListParameter) {
const resParam = oaiRequest['resumptionToken']; //e.g. "158886496600000"
const token = await this.tokenWorker.get(resParam);
@ -352,7 +357,7 @@ export default class OaiController {
this.xsltParameter['oai_metadataPrefix'] = numWrapper.metadataPrefix;
}
private async handleNoResumptionToken(oaiRequest: Dictionary, numWrapper) {
private async handleNoResumptionToken(oaiRequest: Dictionary, numWrapper: ListParameter) {
// no resumptionToken is given
if ('metadataPrefix' in oaiRequest) {
numWrapper.metadataPrefix = oaiRequest['metadataPrefix'];
@ -622,7 +627,7 @@ export default class OaiController {
const msg = `Invalid SetSpec (data-type='${dataset.type}').
Allowed characters are [${this.sampleRegEx}].`;
// Log::error("OAI-PMH: $msg");
Logger.error(`OAI-PMH: ${msg}`);
logger.error(`OAI-PMH: ${msg}`);
return;
}
const setSpec = 'data-type:' + dataset.type;

31
app/Controllers/Http/Reviewer/DatasetController.ts
View file

@ -1,14 +1,19 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import User from 'App/Models/User';
import Dataset from 'App/Models/Dataset';
import type { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
import Field from 'App/Library/Field';
import BaseModel from 'App/Models/BaseModel';
import type { HttpContext } from '@adonisjs/core/http';
import User from '#app/Models/User';
import Dataset from '#app/Models/Dataset';
import Field from '#app/Library/Field';
import BaseModel from '#app/Models/BaseModel';
import { DateTime } from 'luxon';
import { schema, rules } from '@ioc:Adonis/Core/Validator';
import { schema, rules } from '@adonisjs/validator';
import { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
interface Dictionary {
[index: string]: string;
}
export default class DatasetsController {
public async index({ auth, request, inertia }: HttpContextContract) {
public async index({ auth, request, inertia }: HttpContext) {
const user = (await User.find(auth.user?.id)) as User;
const page = request.input('page', 1);
let datasets: ModelQueryBuilderContract<typeof Dataset, Dataset> = Dataset.query();
@ -55,7 +60,7 @@ export default class DatasetsController {
});
}
public async review({ request, inertia, response }: HttpContextContract) {
public async review({ request, inertia, response }: HttpContext) {
const id = request.param('id');
const dataset = await Dataset.query()
.where('id', id)
@ -79,7 +84,7 @@ export default class DatasetsController {
}
const fieldnames: Array<string> = await dataset.describe();
const fields = {};
const fields: Dictionary = {};
for (const fieldName of fieldnames) {
const field: Field = dataset.getField(fieldName) as Field;
const modelClass = field.getValueModelClass();
@ -154,7 +159,7 @@ export default class DatasetsController {
});
}
public async reviewUpdate({ request, response }) {
public async reviewUpdate({ request, response }: HttpContext) {
const id = request.param('id');
// const { id } = params;
const dataset = await Dataset.findOrFail(id);
@ -185,7 +190,7 @@ export default class DatasetsController {
}
}
public async reject({ request, inertia, response }: HttpContextContract) {
public async reject({ request, inertia, response }: HttpContext) {
const id = request.param('id');
const dataset = await Dataset.query()
.where('id', id)
@ -213,7 +218,7 @@ export default class DatasetsController {
});
}
public async rejectUpdate({ request, response }) {
public async rejectUpdate({ request, response }: HttpContext) {
const id = request.param('id');
const dataset = await Dataset.query()
.where('id', id)

116
app/Controllers/Http/Submitter/DatasetController.ts
View file

@ -1,21 +1,22 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import User from 'App/Models/User';
import Dataset from 'App/Models/Dataset';
import License from 'App/Models/License';
import Project from 'App/Models/Project';
import Title from 'App/Models/Title';
import Description from 'App/Models/Description';
import Language from 'App/Models/Language';
import Coverage from 'App/Models/Coverage';
import Collection from 'App/Models/Collection';
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContext } from '@adonisjs/core/http';
import User from '#app/Models/User';
import Dataset from '#app/Models/Dataset';
import License from '#app/Models/License';
import Project from '#app/Models/Project';
import Title from '#app/Models/Title';
import Description from '#app/Models/Description';
import Language from '#app/Models/Language';
import Coverage from '#app/Models/Coverage';
import Collection from '#app/Models/Collection';
import { schema, rules } from '@adonisjs/validator';
import { CustomMessages } from "@adonisjs/validator/types";
import dayjs from 'dayjs';
import Person from 'App/Models/Person';
import Database from '@ioc:Adonis/Lucid/Database';
import { TransactionClientContract } from '@ioc:Adonis/Lucid/Database';
import Subject from 'App/Models/Subject';
import CreateDatasetValidator from 'App/Validators/CreateDatasetValidator';
import UpdateDatasetValidator from 'App/Validators/UpdateDatasetValidator';
import Person from '#app/Models/Person';
import db from '@adonisjs/lucid/services/db';
import { TransactionClientContract } from "@adonisjs/lucid/types/database";
import Subject from '#app/Models/Subject';
import CreateDatasetValidator from '#app/Validators/CreateDatasetValidator';
import UpdateDatasetValidator from '#app/Validators/UpdateDatasetValidator';
import {
TitleTypes,
DescriptionTypes,
@ -25,20 +26,24 @@ import {
RelationTypes,
DatasetTypes,
SubjectTypes,
} from 'Contracts/enums';
import type { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
import DatasetReference from 'App/Models/DatasetReference';
import { cuid } from '@ioc:Adonis/Core/Helpers';
import File from 'App/Models/File';
} from '#contracts/enums';
import { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
import DatasetReference from '#app/Models/DatasetReference';
import { cuid } from '@adonisjs/core/helpers';
import File from '#app/Models/File';
import ClamScan from 'clamscan';
import { ValidationException } from '@ioc:Adonis/Core/Validator';
import Drive from '@ioc:Adonis/Core/Drive';
import { Exception } from '@adonisjs/core/build/standalone';
import { MultipartFileContract } from '@ioc:Adonis/Core/BodyParser';
import { ValidationException } from '@adonisjs/validator';
// import Drive from '@ioc:Adonis/Core/Drive';
import { Exception } from "@adonisjs/core/exceptions";
import { MultipartFile } from '@adonisjs/core/types/bodyparser';
import * as crypto from 'crypto';
import app from '@adonisjs/core/services/app';
interface Dictionary {
[index: string]: string;
}
export default class DatasetController {
public async index({ auth, request, inertia }: HttpContextContract) {
public async index({ auth, request, inertia }: HttpContext) {
const user = (await User.find(auth.user?.id)) as User;
const page = request.input('page', 1);
let datasets: ModelQueryBuilderContract<typeof Dataset, Dataset> = Dataset.query();
@ -105,7 +110,7 @@ export default class DatasetController {
});
}
public async create({ inertia }: HttpContextContract) {
public async create({ inertia }: HttpContext) {
const licenses = await License.query().select('id', 'name_long').where('active', 'true').pluck('name_long', 'id');
const projects = await Project.query().pluck('label', 'id');
@ -140,7 +145,7 @@ export default class DatasetController {
});
}
public async firstStep({ request, response }: HttpContextContract) {
public async firstStep({ request, response }: HttpContext) {
const newDatasetSchema = schema.create({
language: schema.string({ trim: true }, [
rules.regex(/^[a-zA-Z0-9-_]+$/), //Must be alphanumeric with hyphens or underscores
@ -149,6 +154,7 @@ export default class DatasetController {
rights: schema.string([rules.equalTo('true')]),
});
await request.validate({ schema: newDatasetSchema, messages: this.messages });
try {
// Step 2 - Validate request body against the schema
@ -162,7 +168,7 @@ export default class DatasetController {
return response.redirect().back();
}
public async secondStep({ request, response }: HttpContextContract) {
public async secondStep({ request, response }: HttpContext) {
const newDatasetSchema = schema.create({
// first step
language: schema.string({ trim: true }, [
@ -217,7 +223,7 @@ export default class DatasetController {
return response.redirect().back();
}
public async thirdStep({ request, response }: HttpContextContract) {
public async thirdStep({ request, response }: HttpContext) {
const newDatasetSchema = schema.create({
// first step
language: schema.string({ trim: true }, [
@ -305,7 +311,7 @@ export default class DatasetController {
return response.redirect().back();
}
public async store({ auth, request, response, session }: HttpContextContract) {
public async store({ auth, request, response, session }: HttpContext) {
// node ace make:validator CreateDataset
try {
// Step 2 - Validate request body against the schema
@ -320,7 +326,7 @@ export default class DatasetController {
let trx: TransactionClientContract | null = null;
try {
trx = await Database.transaction();
trx = await db.transaction();
const user = (await User.find(auth.user?.id)) as User;
await this.createDatasetAndAssociations(user, request, trx);
@ -341,7 +347,7 @@ export default class DatasetController {
// return response.redirect().back();
}
private async createDatasetAndAssociations(user: User, request: HttpContextContract['request'], trx: TransactionClientContract) {
private async createDatasetAndAssociations(user: User, request: HttpContext['request'], trx: TransactionClientContract) {
// Create a new instance of the Dataset model:
const dataset = new Dataset();
dataset.type = request.input('type');
@ -422,7 +428,7 @@ export default class DatasetController {
}
// save data files
const uploadedFiles = request.files('files');
const uploadedFiles: MultipartFile[] = request.files('files');
for (const [index, file] of uploadedFiles.entries()) {
try {
await this.scanFileForViruses(file.tmpPath); //, 'gitea.lan', 3310);
@ -439,13 +445,12 @@ export default class DatasetController {
const mimeType = file.headers['content-type'] || 'application/octet-stream'; // Fallback to a default MIME type
const datasetFolder = `files/${dataset.id}`;
// const size = file.size;
await file.moveToDisk(
datasetFolder,
await file.move(
app.makePath( datasetFolder),
{
name: fileName,
overwrite: true, // overwrite in case of conflict
},
'local',
);
// save file metadata into db
const newFile = new File();
@ -476,7 +481,7 @@ export default class DatasetController {
return `file-${randomString1}-${randomString2}-${randomString3}-${randomString4}-${randomString5}.${extension}`;
}
private async scanFileForViruses(filePath, host?: string, port?: number): Promise<void> {
private async scanFileForViruses(filePath: string | undefined, host?: string, port?: number): Promise<void> {
// const clamscan = await (new ClamScan().init());
const opts: ClamScan.Options = {
removeInfected: true, // If true, removes infected files
@ -537,7 +542,7 @@ export default class DatasetController {
// Helper function to extract pivot attributes from a person object
private extractPivotAttributes(person: any) {
const pivotAttributes = {};
const pivotAttributes: Dictionary = {};
for (const key in person) {
if (key.startsWith('pivot_')) {
// pivotAttributes[key] = person[key];
@ -596,7 +601,7 @@ export default class DatasetController {
};
// public async release({ params, view }) {
public async release({ request, inertia, response }: HttpContextContract) {
public async release({ request, inertia, response }: HttpContext) {
const id = request.param('id');
const dataset = await Dataset.query()
@ -623,7 +628,7 @@ export default class DatasetController {
});
}
public async releaseUpdate({ request, response }: HttpContextContract) {
public async releaseUpdate({ request, response }: HttpContext) {
const id = request.param('id');
const dataset = await Dataset.query().preload('files').where('id', id).firstOrFail();
@ -655,7 +660,10 @@ export default class DatasetController {
});
try {
await request.validate({ schema: newSchema });
await request.validate({
schema: newSchema,
// reporter: validator.reporters.vanilla,
});
} catch (error) {
// return response.badRequest(error.messages);
throw error;
@ -698,7 +706,7 @@ export default class DatasetController {
// throw new GeneralException(trans('exceptions.publish.release.update_error'));
}
public async edit({ request, inertia, response }) {
public async edit({ request, inertia, response }: HttpContext) {
const id = request.param('id');
const datasetQuery = Dataset.query().where('id', id);
datasetQuery
@ -789,7 +797,7 @@ export default class DatasetController {
});
}
public async update({ request, response, session }: HttpContextContract) {
public async update({ request, response, session }: HttpContext) {
try {
// await request.validate({ schema: newDatasetSchema, messages: this.messages });
await request.validate(UpdateDatasetValidator);
@ -804,7 +812,7 @@ export default class DatasetController {
let trx: TransactionClientContract | null = null;
try {
trx = await Database.transaction();
trx = await db.transaction();
// const user = (await User.find(auth.user?.id)) as User;
// await this.createDatasetAndAssociations(user, request, trx);
const dataset = await Dataset.findOrFail(id);
@ -897,7 +905,7 @@ export default class DatasetController {
}
// handle new uploaded files:
const uploadedFiles: MultipartFileContract[] = request.files('files');
const uploadedFiles: MultipartFile[] = request.files('files');
if (Array.isArray(uploadedFiles) && uploadedFiles.length > 0) {
for (const [index, fileData] of uploadedFiles.entries()) {
try {
@ -911,7 +919,11 @@ export default class DatasetController {
// move to disk:
const fileName = `file-${cuid()}.${fileData.extname}`;
const datasetFolder = `files/${dataset.id}`;
await fileData.moveToDisk(datasetFolder, { name: fileName, overwrite: true }, 'local');
await fileData.moveToDisk(
datasetFolder,
{ name: fileName, overwrite: true },
'local'
);
// let path = coverImage.filePath;
//save to db:
@ -988,7 +1000,7 @@ export default class DatasetController {
}
}
public async delete({ request, inertia, response, session }) {
public async delete({ request, inertia, response, session }: HttpContext) {
const id = request.param('id');
try {
const dataset = await Dataset.query()
@ -1022,7 +1034,7 @@ export default class DatasetController {
}
}
public async deleteUpdate({ params, session, response }) {
public async deleteUpdate({ params, session, response }: HttpContext) {
try {
const dataset = await Dataset.query().where('id', params.id).preload('files').firstOrFail();
@ -1041,7 +1053,7 @@ export default class DatasetController {
if (folderContents.length === 0) {
await Drive.delete(datasetFolder);
}
// delete dataset wirh relation from db
// delete dataset wirh relation in db
await dataset.delete();
session.flash({ message: 'You have deleted 1 dataset!' });
return response.redirect().toRoute('dataset.list');
@ -1059,7 +1071,7 @@ export default class DatasetController {
} else if (error instanceof Exception) {
// General exception handling
return response
.flash({ errors: { error: error.message } })
.flash('errors', { error: error.message })
.redirect()
.back();
} else {

9
app/Controllers/Http/Submitter/PersonController.ts
View file

@ -1,4 +1,4 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import type { HttpContext } from '@adonisjs/core/http';
// import User from 'App/Models/User';
// import Dataset from 'App/Models/Dataset';
// import License from 'App/Models/License';
@ -10,12 +10,11 @@ import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
// import Collection from 'App/Models/Collection';
// import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
// import dayjs from 'dayjs';
import Person from 'App/Models/Person';
import type { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
import Person from '#app/Models/Person';
import { ModelQueryBuilderContract } from "@adonisjs/lucid/types/model";
export default class PersonController {
public async index({ auth, request, inertia }: HttpContextContract) {
public async index({ auth, request, inertia }: HttpContext) {
// const user = (await User.find(auth.user?.id)) as User;
const page = request.input('page', 1);
let persons: ModelQueryBuilderContract<typeof Person, Person> = Person.query();

80
app/Exceptions/Handler.ts
View file

@ -12,24 +12,53 @@
| properly.
|
*/
import app from '@adonisjs/core/services/app';
import { HttpContext, ExceptionHandler } from '@adonisjs/core/http';
// import logger from '@adonisjs/core/services/logger';
import type { StatusPageRange, StatusPageRenderer } from '@adonisjs/core/types/http';
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import Logger from '@ioc:Adonis/Core/Logger';
import HttpExceptionHandler from '@ioc:Adonis/Core/HttpExceptionHandler';
export default class HttpExceptionHandler extends ExceptionHandler {
/**
* In debug mode, the exception handler will display verbose errors
* with pretty printed stack traces.
*/
protected debug = !app.inProduction;
export default class ExceptionHandler extends HttpExceptionHandler {
protected statusPages = {
'401,403': 'errors/unauthorized',
'404': 'errors/not-found',
'500..599': 'errors/server-error',
/**
* Status pages are used to display a custom HTML pages for certain error
* codes. You might want to enable them in production only, but feel
* free to enable them in development as well.
*/
protected renderStatusPages = true;
// protected statusPages = {
// '401,403': 'errors/unauthorized',
// '404': 'errors/not-found',
// '500..599': 'errors/server-error',
// };
/**
* Status pages is a collection of error code range and a callback
* to return the HTML contents to send as a response.
*/
protected statusPages: Record<StatusPageRange, StatusPageRenderer> = {
'401..403': (error, { view }) => {
return view.render('./errors/unauthorized', { error });
},
'404': (error, { view }) => {
return view.render('./errors/not-found', { error });
},
'500..599': (error, { view }) => {
return view.render('./errors/server-error', { error });
},
};
constructor() {
super(Logger);
}
// constructor() {
// super(logger);
// }
public async handle(error: any, ctx: HttpContextContract) {
const { response, request, inertia } = ctx;
public async handle(error: any, ctx: HttpContext) {
const { response, request, session } = ctx;
/**
* Handle failed authentication attempt
@ -44,11 +73,16 @@ export default class ExceptionHandler extends HttpExceptionHandler {
// }
// https://github.com/inertiajs/inertia-laravel/issues/56
if (request.header('X-Inertia') && [500, 503, 404, 403, 401].includes(response.getStatus())) {
return inertia.render('Error', {
status: response.getStatus(),
message: error.message,
});
// let test = response.getStatus(); //200
// let header = request.header('X-Inertia'); // true
if (request.header('X-Inertia') && [500, 503, 404, 403, 401, 200].includes(response.getStatus())) {
// session.flash('errors', error.messages.errors);
session.flash('errors', error.messages);
return response.redirect().back();
// return inertia.render('Error', {
// status: response.getStatus(),
// message: error.message,
// });
// ->toResponse($request)
// ->setStatusCode($response->status());
}
@ -58,4 +92,14 @@ export default class ExceptionHandler extends HttpExceptionHandler {
*/
return super.handle(error, ctx);
}
/**
* The method is used to report error to the logging service or
* the a third party error monitoring service.
*
* @note You should not attempt to send a response from this method.
*/
async report(error: unknown, ctx: HttpContext) {
return super.report(error, ctx);
}
}

2
app/Exceptions/InternalServerException.ts
View file

@ -1,5 +1,5 @@
import { StatusCodes } from 'http-status-codes';
import HTTPException from './HttpException';
import HTTPException from './HttpException.js';
class InternalServerErrorException extends HTTPException {
constructor(message?: string) {

11
app/Exceptions/InvalidCredentialException.ts
View file

@ -1,4 +1,5 @@
import { Exception } from '@adonisjs/core/build/standalone';
import { Exception } from "@adonisjs/core/exceptions";
import { HttpContext } from "@adonisjs/core/http";
/*
|--------------------------------------------------------------------------
@ -23,21 +24,21 @@ export default class InvalidCredentialException extends Exception {
* Unable to find user
*/
public static invalidUid() {
const error = new this('User not found', 400, 'E_INVALID_AUTH_UID');
const error = new this('User not found', {status: 400, code: 'E_INVALID_AUTH_UID'});
return error;
}
/**
* Invalid user password
*/
public static invalidPassword() {
const error = new this('Password mis-match', 400, 'E_INVALID_AUTH_PASSWORD');
const error = new this('Password mis-match', {status: 400, code: 'E_INVALID_AUTH_PASSWORD'});
return error;
}
/**
* Flash error message and redirect the user back
*/
private respondWithRedirect(error, ctx) {
private respondWithRedirect(error: any, ctx: HttpContext) {
// if (!ctx.session) {
// return ctx.response.status(this.status).send(this.responseText);
// }
@ -59,7 +60,7 @@ export default class InvalidCredentialException extends Exception {
* Handle this exception by itself
*/
public handle(error, ctx) {
public handle(error: any, ctx: HttpContext) {
// return response.status(403).view.render("errors/unauthorized", {
// error: error,
// });

2
app/Exceptions/OaiModelException.ts
View file

@ -1,6 +1,6 @@
import { StatusCodes } from 'http-status-codes';
// import HTTPException from './HttpException';
import { OaiErrorCodes } from './OaiErrorCodes';
import { OaiErrorCodes } from './OaiErrorCodes.js';
export class ErrorCode {
public static readonly Unauthenticated = 'Unauthenticated';

34
app/FlashResponse.ts
View file

@ -1,34 +0,0 @@
import { Response } from '@adonisjs/http-server/build/src/Response';
import { ServerResponse, IncomingMessage } from 'http';
import { RouterContract } from '@ioc:Adonis/Core/Route';
import { EncryptionContract } from '@ioc:Adonis/Core/Encryption';
import { ResponseConfig, ResponseContract } from '@ioc:Adonis/Core/Response';
class FlashResponse extends Response implements ResponseContract {
protected static macros = {};
protected static getters = {};
constructor(
public request: IncomingMessage,
public response: ServerResponse,
flashEncryption: EncryptionContract,
flashConfig: ResponseConfig,
flashRouter: RouterContract,
) {
super(request, response, flashEncryption, flashConfig, flashRouter);
}
public nonce: string;
public flash(key: string, message: any): this {
// Store the flash message in the session
this.ctx?.session.flash(key, message);
return this;
}
public toRoute(route: string): this {
// Redirect to the specified route
super.redirect().toRoute(route);
return this;
}
}
export default FlashResponse;

21
app/Library/Doi/DoiClient.ts
View file

@ -1,11 +1,12 @@
// import { Client } from 'guzzle';
// import { Log } from '@adonisjs/core/build/standalone';
// import { DoiInterface } from './interfaces/DoiInterface';
import DoiClientContract from 'App/Library/Doi/DoiClientContract';
import DoiClientException from 'App/Exceptions/DoiClientException';
import DoiClientContract from '#app/Library/Doi/DoiClientContract';
import DoiClientException from '#app/Exceptions/DoiClientException';
import { StatusCodes } from 'http-status-codes';
import Logger from '@ioc:Adonis/Core/Logger';
import axios, { AxiosResponse } from 'axios';
import logger from '@adonisjs/core/services/logger';
import { AxiosResponse } from 'axios';
import axios from 'axios';
export class DoiClient implements DoiClientContract {
public username: string;
@ -22,7 +23,7 @@ export class DoiClient implements DoiClientContract {
if (this.username === '' || this.password === '' || this.serviceUrl === '') {
const message = 'issing configuration settings to properly initialize DOI client';
Logger.error(message);
logger.error(message);
throw new DoiClientException(StatusCodes.BAD_REQUEST, message);
}
}
@ -49,7 +50,7 @@ export class DoiClient implements DoiClientContract {
'Content-Type': 'application/xml;charset=UTF-8',
};
try {
const metadataResponse = await axios.put(`${this.serviceUrl}/metadata/${doiValue}`, xmlMeta, { auth, headers });
const metadataResponse = await axios.default.put(`${this.serviceUrl}/metadata/${doiValue}`, xmlMeta, { auth, headers });
// Response Codes
// 201 Created: operation successful
@ -60,11 +61,11 @@ export class DoiClient implements DoiClientContract {
// let test = metadataResponse.data; // 'OK (10.21388/TETHYS.213)'
if (metadataResponse.status !== 201) {
const message = `Unexpected DataCite MDS response code ${metadataResponse.status}`;
Logger.error(message);
logger.error(message);
throw new DoiClientException(metadataResponse.status, message);
}
const doiResponse = await axios.put(`${this.serviceUrl}/doi/${doiValue}`, `doi=${doiValue}\nurl=${landingPageUrl}`, {
const doiResponse = await axios.default.put(`${this.serviceUrl}/doi/${doiValue}`, `doi=${doiValue}\nurl=${landingPageUrl}`, {
auth,
headers,
});
@ -77,7 +78,7 @@ export class DoiClient implements DoiClientContract {
// 412 Precondition failed: metadata must be uploaded first.
if (doiResponse.status !== 201) {
const message = `Unexpected DataCite MDS response code ${doiResponse.status}`;
Logger.error(message);
logger.error(message);
throw new DoiClientException(doiResponse.status, message);
}
@ -85,7 +86,7 @@ export class DoiClient implements DoiClientContract {
} catch (error) {
// const message = `request for registering DOI failed with ${error.message}`;
// Handle the error, log it, or rethrow as needed
Logger.error(error.message);
logger.error(error.message);
throw new DoiClientException(error.response.status, error.response.data);
}
}

3
app/Library/Doi/DoiClientContract.ts
View file

@ -1,4 +1,5 @@
// import ResumptionToken from './ResumptionToken';
import { AxiosResponse } from 'axios';
export default interface DoiClientContract {
username: string;
@ -6,7 +7,7 @@ export default interface DoiClientContract {
serviceUrl: string;
// prefix: string;
// base_domain: string;
registerDoi(doiValue: string, xmlMeta: string, landingPageUrl: string);
registerDoi(doiValue: string, xmlMeta: string, landingPageUrl: string): Promise<AxiosResponse<any>>;
// get(key: string): Promise<ResumptionToken | null>;
// set(token: ResumptionToken): Promise<string>;
}

10
app/Library/Oai/TokenWorker.ts
View file

@ -1,10 +0,0 @@
import ResumptionToken from './ResumptionToken';
export default interface TokenWorkerContract {
ttl: number;
isConnected: boolean;
connect();
close();
get(key: string): Promise<ResumptionToken | null>;
set(token: ResumptionToken): Promise<string>;
}

11
app/Library/Oai/TokenWorkerContract.ts Normal file
View file

@ -0,0 +1,11 @@
import ResumptionToken from './ResumptionToken.js';
export default abstract class TokenWorkerContract {
abstract ttl: number;
abstract isConnected: boolean;
abstract connect(): void;
abstract close(): void;
abstract get(key: string): Promise<ResumptionToken | null>;
abstract set(token: ResumptionToken): Promise<string>;
}

6
app/Library/Oai/TokenWorkerSerice.ts
View file

@ -1,9 +1,9 @@
import ResumptionToken from './ResumptionToken';
import ResumptionToken from './ResumptionToken.js';
import { createClient, RedisClientType } from 'redis';
import InternalServerErrorException from 'App/Exceptions/InternalServerException';
import InternalServerErrorException from '#app/Exceptions/InternalServerException';
import { sprintf } from 'sprintf-js';
import dayjs from 'dayjs';
import TokenWorkerContract from './TokenWorker';
import TokenWorkerContract from './TokenWorkerContract.js';
export default class TokenWorkerService implements TokenWorkerContract {
protected filePrefix = 'rs_';

18
app/Library/Strategy.ts
View file

@ -1,8 +1,8 @@
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces.js';
import { create } from 'xmlbuilder2';
import Dataset from 'App/Models/Dataset';
import Field from './Field';
import BaseModel from 'App/Models/BaseModel';
import Dataset from '#app/Models/Dataset';
import Field from './Field.js';
import BaseModel from '#app/Models/BaseModel';
import { DateTime } from 'luxon';
export default class Strategy {
@ -10,7 +10,7 @@ export default class Strategy {
private config;
private xml: XMLBuilder;
constructor(config) {
constructor(config: any) {
this.version = 1.0;
this.config = config;
}
@ -45,11 +45,11 @@ export default class Strategy {
for (const fieldname of fieldsDiff) {
const field = model.getField(fieldname);
this.mapField(field, modelNode);
this.mapField(field as Field, modelNode);
}
}
private mapField(field, modelNode: XMLBuilder) {
private mapField(field: Field, modelNode: XMLBuilder) {
const modelClass = field.getValueModelClass();
let fieldValues = field.getValue();
@ -107,7 +107,7 @@ export default class Strategy {
childNode.att('Timezone', zoneName);
}
private mapModelAttributes(myObject, childNode: XMLBuilder) {
private mapModelAttributes(myObject: any, childNode: XMLBuilder) {
Object.keys(myObject).forEach((prop) => {
let value = myObject[prop];
// console.log(`${prop}: ${value}`);
@ -161,7 +161,7 @@ export default class Strategy {
return fieldValues?.toString().trim();
}
private createModelNode(model) {
private createModelNode(model: Dataset) {
const className = 'Rdr_' + model.constructor.name.split('\\').pop(); //Rdr_Dataset
// return dom.createElement(className);
return this.xml.root().ele(className);

34
app/Library/Utils/Index.ts
View file

@ -1,18 +1,20 @@
import Dataset from 'App/Models/Dataset';
import Dataset from '#app/Models/Dataset';
import { Client } from '@opensearch-project/opensearch';
import { create } from 'xmlbuilder2';
import { transform } from 'saxon-js';
import XmlModel from 'App/Library/XmlModel';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces';
import Logger from '@ioc:Adonis/Core/Logger';
import SaxonJS from 'saxon-js';
import XmlModel from '#app/Library/XmlModel';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces.js';
import logger from '@adonisjs/core/services/logger';
import { readFileSync } from 'fs';
import { DateTime } from 'luxon';
// import Config from '@ioc:Adonis/Core/Config';
import { getDomain } from 'App/Utils/utility-functions';
import { getDomain } from '#app/Utils/utility-functions';
// const opensearchNode = process.env.OPENSEARCH_HOST || 'localhost';
// const client = new Client({ node: `http://${opensearchNode}` }); // replace with your OpenSearch endpoint
interface XslTParameter {
[key: string]: any;
}
export default {
// opensearchNode: process.env.OPENSEARCH_HOST || 'localhost',
client: new Client({ node: `http://${process.env.OPENSEARCH_HOST || 'localhost'}` }), // replace with your OpenSearch endpoint
@ -20,7 +22,7 @@ export default {
async getDoiRegisterString(dataset: Dataset): Promise<string | undefined> {
try {
const proc = readFileSync('public/assets2/doi_datacite.sef.json');
const xsltParameter = {};
const xsltParameter: XslTParameter = {};
let xml = create({ version: '1.0', encoding: 'UTF-8', standalone: true }, '<root></root>');
const datasetNode = xml.root().ele('Dataset');
await createXmlRecord(dataset, datasetNode);
@ -50,7 +52,7 @@ export default {
let xmlOutput; // = xmlString;
try {
const result = await transform({
const result = await SaxonJS.transform({
// stylesheetFileName: `${config.TMP_BASE_DIR}/data-quality/rules/iati.sef.json`,
stylesheetText: proc,
destination: 'serialized',
@ -61,12 +63,12 @@ export default {
});
xmlOutput = result.principalResult;
} catch (error) {
Logger.error('An error occurred while creating the user', error.message);
logger.error('An error occurred while creating the user', error.message);
}
return xmlOutput;
} catch (error) {
Logger.error(`An error occurred while indexing datsaet with publish_id ${dataset.publish_id}.`);
logger.error(`An error occurred while indexing datsaet with publish_id ${dataset.publish_id}.`);
}
},
@ -82,27 +84,27 @@ export default {
body: document,
refresh: true,
});
Logger.info(`dataset with publish_id ${dataset.publish_id} successfully indexed`);
logger.info(`dataset with publish_id ${dataset.publish_id} successfully indexed`);
} catch (error) {
Logger.error(`An error occurred while indexing datsaet with publish_id ${dataset.publish_id}.`);
logger.error(`An error occurred while indexing datsaet with publish_id ${dataset.publish_id}.`);
}
},
async getTransformedString(dataset, proc): Promise<string> {
async getTransformedString(dataset: Dataset, proc: Buffer): Promise<string> {
let xml = create({ version: '1.0', encoding: 'UTF-8', standalone: true }, '<root></root>');
const datasetNode = xml.root().ele('Dataset');
await createXmlRecord(dataset, datasetNode);
const xmlString = xml.end({ prettyPrint: false });
try {
const result = await transform({
const result = await SaxonJS.transform({
stylesheetText: proc,
destination: 'serialized',
sourceText: xmlString,
});
return result.principalResult;
} catch (error) {
Logger.error(`An error occurred while creating the user, error: ${error.message},`);
logger.error(`An error occurred while creating the user, error: ${error.message},`);
return '';
}
},

8
app/Library/XmlModel.ts
View file

@ -1,7 +1,7 @@
import DocumentXmlCache from 'App/Models/DocumentXmlCache';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces';
import Dataset from 'App/Models/Dataset';
import Strategy from './Strategy';
import DocumentXmlCache from '#app/Models/DocumentXmlCache';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces.js';
import Dataset from '#app/Models/Dataset';
import Strategy from './Strategy.js';
import { DateTime } from 'luxon';
import { builder } from 'xmlbuilder2';

67
app/Middleware/Auth.ts
View file

@ -1,67 +0,0 @@
import { AuthenticationException } from '@adonisjs/auth/build/standalone';
import type { GuardsList } from '@ioc:Adonis/Addons/Auth';
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
/**
* Auth middleware is meant to restrict un-authenticated access to a given route
* or a group of routes.
*
* You must register this middleware inside `start/kernel.ts` file under the list
* of named middleware.
*/
export default class AuthMiddleware {
/**
* The URL to redirect to when request is Unauthorized
*/
protected redirectTo = '/app/login';
/**
* Authenticates the current HTTP request against a custom set of defined
* guards.
*
* The authentication loop stops as soon as the user is authenticated using any
* of the mentioned guards and that guard will be used by the rest of the code
* during the current request.
*/
protected async authenticate(auth: HttpContextContract['auth'], guards: (keyof GuardsList)[]) {
/**
* Hold reference to the guard last attempted within the for loop. We pass
* the reference of the guard to the "AuthenticationException", so that
* it can decide the correct response behavior based upon the guard
* driver
*/
let guardLastAttempted: string | undefined;
for (let guard of guards) {
guardLastAttempted = guard;
if (await auth.use(guard).check()) {
/**
* Instruct auth to use the given guard as the default guard for
* the rest of the request, since the user authenticated
* succeeded here
*/
auth.defaultGuard = guard;
return true;
}
}
/**
* Unable to authenticate using any guard
*/
throw new AuthenticationException('Unauthorized access', 'E_UNAUTHORIZED_ACCESS', guardLastAttempted, this.redirectTo);
}
/**
* Handle request
*/
public async handle({ auth }: HttpContextContract, next: () => Promise<void>, customGuards: (keyof GuardsList)[]) {
/**
* Uses the user defined guards or the default guard mentioned in
* the config file
*/
const guards = customGuards.length ? customGuards : [auth.name];
await this.authenticate(auth, guards);
await next();
}
}

28
app/Middleware/Can.ts
View file

@ -1,13 +1,14 @@
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import Config from '@ioc:Adonis/Core/Config';
import Database from '@ioc:Adonis/Lucid/Database';
import User from 'App/Models/User';
import { Exception } from '@adonisjs/core/build/standalone';
import { HttpContext } from '@adonisjs/core/http';
// import Config from '@ioc:Adonis/Core/Config';
import config from '@adonisjs/core/services/config';
import db from '@adonisjs/lucid/services/db';
import User from '#app/Models/User';
import { Exception } from '@adonisjs/core/exceptions';
const permissionTable = Config.get('rolePermission.permission_table', 'permissions');
const rolePermissionTable = Config.get('rolePermission.role_permission_table', 'role_has_permissions');
const roleTable = Config.get('rolePermission.role_table', 'roles');
const userRoleTable = Config.get('rolePermission.user_role_table', 'link_accounts_roles');
const permissionTable = config.get('rolePermission.permission_table', 'permissions');
const rolePermissionTable = config.get('rolePermission.role_permission_table', 'role_has_permissions');
const roleTable = config.get('rolePermission.role_table', 'roles');
const userRoleTable = config.get('rolePermission.user_role_table', 'link_accounts_roles');
/**
* Permission authentication to check if user has any of the specified permissions
@ -18,7 +19,7 @@ export default class Can {
/**
* Handle request
*/
public async handle({ auth, response }: HttpContextContract, next: () => Promise<void>, permissionNames: string[]) {
public async handle({ auth, response }: HttpContext, next: () => Promise<void>, permissionNames: string[]) {
/**
* Check if user is logged-in
*/
@ -31,9 +32,10 @@ export default class Can {
// return response.unauthorized({
// error: `Doesn't have required role(s): ${permissionNames.join(',')}`,
// });
throw new Exception(`Doesn't have required permission(s): ${permissionNames.join(',')}`, 401);
throw new Exception(`Doesn't have required permission(s): ${permissionNames.join(',')}`, { status: 401 });
}
await next();
// await next();
return next();
}
private async checkHasPermissions(user: User, permissionNames: Array<string>): Promise<boolean> {
@ -66,7 +68,7 @@ export default class Can {
rows: {
0: { permissioncount },
},
} = await Database.rawQuery(
} = await db.rawQuery(
'SELECT count("p"."name") as permissionCount FROM ' +
roleTable +
' r INNER JOIN ' +

20
app/Middleware/Is.ts
View file

@ -1,11 +1,12 @@
import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import Config from '@ioc:Adonis/Core/Config';
import Database from '@ioc:Adonis/Lucid/Database';
import User from 'App/Models/User';
import { HttpContext } from '@adonisjs/core/http';
// import Config from '@ioc:Adonis/Core/Config';
import config from '@adonisjs/core/services/config'
import db from '@adonisjs/lucid/services/db';
import User from '#app/Models/User';
// import { Exception } from '@adonisjs/core/build/standalone'
const roleTable = Config.get('rolePermission.role_table', 'roles');
const userRoleTable = Config.get('rolePermission.user_role_table', 'user_roles');
const roleTable = config.get('rolePermission.role_table', 'roles');
const userRoleTable = config.get('rolePermission.user_role_table', 'user_roles');
/**
* Role authentication to check if user has any of the specified roles
@ -16,7 +17,7 @@ export default class Is {
/**
* Handle request
*/
public async handle({ auth, response }: HttpContextContract, next: () => Promise<void>, roleNames: string[]) {
public async handle({ auth, response }: HttpContext, next: () => Promise<void>, roleNames: string[]) {
/**
* Check if user is logged-in or not.
*/
@ -33,7 +34,8 @@ export default class Is {
// 401,
// "E_INVALID_AUTH_UID");
}
await next();
// await next();
return next()
}
private async checkHasRoles(user: User, roleNames: Array<string>): Promise<boolean> {
@ -46,7 +48,7 @@ export default class Is {
0: {
0: { roleCount },
},
} = await Database.rawQuery(
} = await db.rawQuery(
'SELECT count(`ur`.`id`) as roleCount FROM ' +
userRoleTable +
' ur INNER JOIN ' +

24
app/Middleware/Role.ts
View file

@ -1,23 +1,25 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import Database from '@ioc:Adonis/Lucid/Database';
import Config from '@ioc:Adonis/Core/Config';
import User from 'app/Models/User';
import { Exception } from '@adonisjs/core/build/standalone';
import type { HttpContext } from '@adonisjs/core/http';
import db from '@adonisjs/lucid/services/db';
import config from '@adonisjs/core/services/config';
import User from '#app/Models/User';
import { Exception } from '@adonisjs/core/exceptions';
const roleTable = Config.get('rolePermission.role_table', 'roles');
const userRoleTable = Config.get('rolePermission.user_role_table', 'link_accounts_roles');
// const roleTable = Config.get('rolePermission.role_table', 'roles');
const roleTable = config.get('rolePermission.role_table', 'roles');
// const userRoleTable = Config.get('rolePermission.user_role_table', 'link_accounts_roles');
const userRoleTable = config.get('rolePermission.user_role_table', 'user_roles');
// node ace make:middleware role
export default class Role {
// .middleware(['auth', 'role:admin,moderator'])
public async handle({ auth, response }: HttpContextContract, next: () => Promise<void>, userRoles: string[]) {
public async handle({ auth, response }: HttpContext, next: () => Promise<void>, userRoles: string[]) {
// Check if user is logged-in or not.
// let expression = "";
// if (Array.isArray(args)) {
// expression = args.join(" || ");
// }
let user = await auth.user;
let user = auth.user as User;
if (!user) {
return response.unauthorized({ error: 'Must be logged in' });
}
@ -28,7 +30,7 @@ export default class Role {
// error: `Doesn't have required role(s): ${userRoles.join(',')}`,
// // error: `Doesn't have required role(s)`,
// });
throw new Exception(`Doesn't have required role(s): ${userRoles.join(',')}`, 401);
throw new Exception(`Doesn't have required role(s): ${userRoles.join(',')}`, { status: 401 });
}
// code for middleware goes here. ABOVE THE NEXT CALL
@ -62,7 +64,7 @@ export default class Role {
rows: {
0: { rolecount },
},
} = await Database.rawQuery(
} = await db.rawQuery(
'SELECT count("r"."id") as roleCount FROM ' +
roleTable +
' r INNER JOIN ' +

4
app/Middleware/SilentAuth.ts
View file

@ -1,4 +1,4 @@
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import type { HttpContext } from '@adonisjs/core/http';
/**
* Silent auth middleware can be used as a global middleware to silent check
@ -10,7 +10,7 @@ export default class SilentAuthMiddleware {
/**
* Handle request
*/
public async handle({ auth }: HttpContextContract, next: () => Promise<void>) {
public async handle({ auth }: HttpContext, next: () => Promise<void>) {
/**
* Check if user is logged-in or not. If yes, then `ctx.auth.user` will be
* set to the instance of the currently logged in user.

25
app/Middleware/auth_middleware.ts Normal file
View file

@ -0,0 +1,25 @@
import type { HttpContext } from '@adonisjs/core/http'
import type { NextFn } from '@adonisjs/core/types/http'
import type { Authenticators } from '@adonisjs/auth/types'
/**
* Auth middleware is used authenticate HTTP requests and deny
* access to unauthenticated users.
*/
export default class AuthMiddleware {
/**
* The URL to redirect to, when authentication fails
*/
redirectTo = '/app/login'
async handle(
ctx: HttpContext,
next: NextFn,
options: {
guards?: (keyof Authenticators)[]
} = {}
) {
await ctx.auth.authenticateUsing(options.guards, { loginRoute: this.redirectTo })
return next()
}
}

19
app/Middleware/container_bindings_middleware.ts Normal file
View file

@ -0,0 +1,19 @@
import { Logger } from '@adonisjs/core/logger';
import { HttpContext } from '@adonisjs/core/http';
import { NextFn } from '@adonisjs/core/types/http';
/**
* The container bindings middleware binds classes to their request
* specific value using the container resolver.
*
* - We bind "HttpContext" class to the "ctx" object
* - And bind "Logger" class to the "ctx.logger" object
*/
export default class ContainerBindingsMiddleware {
handle(ctx: HttpContext, next: NextFn) {
ctx.containerResolver.bindValue(HttpContext, ctx);
ctx.containerResolver.bindValue(Logger, ctx.logger);
return next();
}
}

27
app/Middleware/guest_middleware.ts Normal file
View file

@ -0,0 +1,27 @@
import type { HttpContext } from '@adonisjs/core/http';
import type { NextFn } from '@adonisjs/core/types/http';
import type { Authenticators } from '@adonisjs/auth/types';
/**
* Guest middleware is used to deny access to routes that should
* be accessed by unauthenticated users.
*
* For example, the login page should not be accessible if the user
* is already logged-in
*/
export default class GuestMiddleware {
/**
* The URL to redirect to when user is logged-in
*/
redirectTo = '/';
async handle(ctx: HttpContext, next: NextFn, options: { guards?: (keyof Authenticators)[] } = {}) {
for (let guard of options.guards || [ctx.auth.defaultGuard]) {
if (await ctx.auth.use(guard).check()) {
return ctx.response.redirect(this.redirectTo, true);
}
}
return next();
}
}

27
app/Middleware/stardust_middleware.ts Normal file
View file

@ -0,0 +1,27 @@
import type { HttpContext } from '@adonisjs/core/http';
import type { NextFn } from '@adonisjs/core/types/http';
export default class StardustMiddleware {
async handle(ctx: HttpContext, next: NextFn): Promise<void> {
/**
* Middleware logic goes here (before the next call)
*/
// console.log(ctx);
const { pathname } = new URL(ctx.request.completeUrl());
globalThis.stardust = {
...globalThis.stardust,
pathname,
};
/**
* Call next method in the pipeline and return its output
*/
const output = await next();
return output;
}
}
// import { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
// export default class StardustMiddleware {
// handle({ request }: HttpContextContract, next: () => Promise<void>): Promise<void>;
// }

8
app/Models/BaseModel.ts
View file

@ -1,4 +1,4 @@
import { BaseModel as LucidBaseModel } from '@ioc:Adonis/Lucid/Orm';
import { BaseModel as LucidBaseModel } from '@adonisjs/lucid/orm';
// import { ManyToManyQueryClient } from '@ioc:Adonis/Lucid/Orm';
// export class CustomManyToManyQueryClient extends ManyToManyQueryClient {
@ -29,6 +29,8 @@ export default class BaseModel extends LucidBaseModel {
*/
// private fillInvoked: boolean = false;
[key: string]: any;
public static fillable: string[] = [];
public fill(attributes: any, allowExtraProperties: boolean = false): this {
@ -47,7 +49,7 @@ export default class BaseModel extends LucidBaseModel {
// this.fillInvoked = true;
return this;
}
/**
* Merge bulk attributes with existing attributes.
*
@ -118,6 +120,8 @@ export default class BaseModel extends LucidBaseModel {
}
}
// export class DatasetRelatedBaseModel extends LucidBaseModel {
// public dataset: BelongsTo<typeof Dataset>;
// }

10
app/Models/Collection.ts
View file

@ -1,7 +1,9 @@
import { column, SnakeCaseNamingStrategy, manyToMany, ManyToMany, belongsTo, BelongsTo } from '@ioc:Adonis/Lucid/Orm';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import CollectionRole from './CollectionRole';
import { column, SnakeCaseNamingStrategy, manyToMany, belongsTo } from '@adonisjs/lucid/orm';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
import CollectionRole from './CollectionRole.js';
import type { ManyToMany } from "@adonisjs/lucid/types/relations";
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
export default class Collection extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

7
app/Models/CollectionRole.ts
View file

@ -1,6 +1,7 @@
import { column, SnakeCaseNamingStrategy, hasMany, HasMany } from '@ioc:Adonis/Lucid/Orm';
import BaseModel from './BaseModel';
import Collection from './Collection';
import { column, SnakeCaseNamingStrategy, hasMany } from '@adonisjs/lucid/orm';
import BaseModel from './BaseModel.js';
import Collection from './Collection.js';
import type { HasMany } from "@adonisjs/lucid/types/relations";
export default class CollectionRole extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

7
app/Models/Coverage.ts
View file

@ -1,7 +1,8 @@
import { column, SnakeCaseNamingStrategy, belongsTo, BelongsTo } from '@ioc:Adonis/Lucid/Orm';
import { column, SnakeCaseNamingStrategy, belongsTo } from '@adonisjs/lucid/orm';
import { DateTime } from 'luxon';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
export default class Coverage extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

40
app/Models/Dataset.ts
View file

@ -2,31 +2,31 @@ import {
column,
SnakeCaseNamingStrategy,
manyToMany,
ManyToMany,
belongsTo,
BelongsTo,
hasMany,
HasMany,
computed,
hasOne,
HasOne,
} from '@ioc:Adonis/Lucid/Orm';
hasOne
} from '@adonisjs/lucid/orm';
import { DateTime } from 'luxon';
import dayjs from 'dayjs';
import Person from './Person';
import User from './User';
import Title from './Title';
import Description from './Description';
import License from './License';
import Subject from './Subject';
import File from './File';
import Coverage from './Coverage';
import DatasetReference from './DatasetReference';
import Collection from './Collection';
import DatasetIdentifier from './DatasetIdentifier';
import Project from './Project';
import DocumentXmlCache from './DocumentXmlCache';
import DatasetExtension from 'App/Models/Traits/DatasetExtension'; // Adjust the import path
import Person from './Person.js';
import User from './User.js';
import Title from './Title.js';
import Description from './Description.js';
import License from './License.js';
import Subject from './Subject.js';
import File from './File.js';
import Coverage from './Coverage.js';
import DatasetReference from './DatasetReference.js';
import Collection from './Collection.js';
import DatasetIdentifier from './DatasetIdentifier.js';
import Project from './Project.js';
import DocumentXmlCache from './DocumentXmlCache.js';
import DatasetExtension from '#app/Models/Traits/DatasetExtension';
import type { ManyToMany } from "@adonisjs/lucid/types/relations";
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
import type { HasMany } from "@adonisjs/lucid/types/relations";
import type { HasOne } from "@adonisjs/lucid/types/relations";
export default class Dataset extends DatasetExtension {
public static namingStrategy = new SnakeCaseNamingStrategy();

7
app/Models/DatasetIdentifier.ts
View file

@ -1,7 +1,8 @@
import { column, SnakeCaseNamingStrategy, belongsTo, BelongsTo } from '@ioc:Adonis/Lucid/Orm';
import { column, SnakeCaseNamingStrategy, belongsTo } from '@adonisjs/lucid/orm';
import { DateTime } from 'luxon';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
export default class DatasetIdentifier extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

7
app/Models/DatasetReference.ts
View file

@ -1,7 +1,8 @@
import { column, SnakeCaseNamingStrategy, belongsTo, BelongsTo } from '@ioc:Adonis/Lucid/Orm';
import { column, SnakeCaseNamingStrategy, belongsTo } from '@adonisjs/lucid/orm';
import { DateTime } from 'luxon';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
export default class DatasetReference extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

7
app/Models/Description.ts
View file

@ -1,6 +1,7 @@
import { column, belongsTo, BelongsTo } from '@ioc:Adonis/Lucid/Orm';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import { column, belongsTo } from '@adonisjs/lucid/orm';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
export default class Description extends BaseModel {
public static primaryKey = 'id';

11
app/Models/DocumentXmlCache.ts
View file

@ -1,9 +1,10 @@
import { column, BaseModel, SnakeCaseNamingStrategy, belongsTo, BelongsTo } from '@ioc:Adonis/Lucid/Orm';
import Dataset from './Dataset';
import { column, BaseModel, SnakeCaseNamingStrategy, belongsTo } from '@adonisjs/lucid/orm';
import Dataset from './Dataset.js';
import { builder, create } from 'xmlbuilder2';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces';
import Database from '@ioc:Adonis/Lucid/Database';
import { XMLBuilder } from 'xmlbuilder2/lib/interfaces.js';
import db from '@adonisjs/lucid/services/db';
import { DateTime } from 'luxon';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
export default class DocumentXmlCache extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();
@ -86,7 +87,7 @@ export default class DocumentXmlCache extends BaseModel {
// Assuming 'DocumentXmlCache' has a table with a 'server_date_modified' column in your database
public static async hasValidEntry(datasetId: number, datasetServerDateModified: DateTime): Promise<boolean> {
const serverDateModifiedString: string = datasetServerDateModified.toFormat('yyyy-MM-dd HH:mm:ss'); // Convert DateTime to ISO string
const query = Database.from(this.table)
const query = db.from(this.table)
.where('document_id', datasetId)
.where('server_date_modified', '>=', serverDateModifiedString) // Check if server_date_modified is newer or equal
.first();

23
app/Models/File.ts
View file

@ -1,13 +1,22 @@
import { DateTime } from 'luxon';
import { column, hasMany, HasMany, belongsTo, BelongsTo, SnakeCaseNamingStrategy, computed } from '@ioc:Adonis/Lucid/Orm';
import HashValue from './HashValue';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import { column, hasMany, belongsTo, SnakeCaseNamingStrategy, computed } from '@adonisjs/lucid/orm';
import HashValue from './HashValue.js';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
// import { Buffer } from 'buffer';
import * as fs from 'fs';
import crypto from 'crypto';
import { TransactionClientContract } from '@ioc:Adonis/Lucid/Database';
import Drive from '@ioc:Adonis/Core/Drive';
// import Drive from '@ioc:Adonis/Core/Drive';
import Drive from '@adonisjs/drive';
import type { HasMany } from "@adonisjs/lucid/types/relations";
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
// import { TransactionClientContract } from "@adonisjs/lucid/database";
import { TransactionClientContract } from '@adonisjs/lucid/types/database';
export default class File extends BaseModel {
// private readonly _data: Uint8Array;
@ -162,7 +171,7 @@ export default class File extends BaseModel {
await super.delete();
}
private async _checksumFile(path, hashName = 'md5'): Promise<string> {
private async _checksumFile(path: string, hashName = 'md5'): Promise<string> {
return new Promise((resolve, reject) => {
const hash = crypto.createHash(hashName);
const stream = fs.createReadStream(path);

5
app/Models/HashValue.ts
View file

@ -1,5 +1,6 @@
import { column, BaseModel, belongsTo, BelongsTo, SnakeCaseNamingStrategy } from '@ioc:Adonis/Lucid/Orm';
import File from './File';
import { column, BaseModel, belongsTo, SnakeCaseNamingStrategy } from '@adonisjs/lucid/orm';
import File from './File.js';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
export default class HashValue extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

4
app/Models/Language.ts
View file

@ -1,5 +1,5 @@
import { column, SnakeCaseNamingStrategy } from '@ioc:Adonis/Lucid/Orm';
import BaseModel from './BaseModel';
import { column, SnakeCaseNamingStrategy } from '@adonisjs/lucid/orm';
import BaseModel from './BaseModel.js';
// import { DateTime } from 'luxon';
export default class Language extends BaseModel {

4
app/Models/License.ts
View file

@ -1,5 +1,5 @@
import { column, SnakeCaseNamingStrategy } from '@ioc:Adonis/Lucid/Orm';
import BaseModel from './BaseModel';
import { column, SnakeCaseNamingStrategy } from '@adonisjs/lucid/orm';
import BaseModel from './BaseModel.js';
export default class License extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

51
app/Models/Permission.ts
View file

@ -1,8 +1,9 @@
import { column, manyToMany, ManyToMany, SnakeCaseNamingStrategy, beforeUpdate, beforeCreate } from '@ioc:Adonis/Lucid/Orm';
import { column, manyToMany, SnakeCaseNamingStrategy } from '@adonisjs/lucid/orm';
import { DateTime } from 'luxon';
import dayjs from 'dayjs';
import Role from 'App/Models/Role';
import BaseModel from './BaseModel';
import Role from '#app/Models/Role';
import BaseModel from './BaseModel.js';
import type { ManyToMany } from "@adonisjs/lucid/types/relations";
export default class Permission extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();
@ -44,12 +45,12 @@ export default class Permission extends BaseModel {
})
public updated_at: DateTime;
@beforeCreate()
@beforeUpdate()
public static async resetDate(role) {
role.created_at = this.formatDateTime(role.created_at);
role.updated_at = this.formatDateTime(role.updated_at);
}
// @beforeCreate()
// @beforeUpdate()
// public static async resetDate(role) {
// role.created_at = this.formatDateTime(role.created_at);
// role.updated_at = this.formatDateTime(role.updated_at);
// }
// public static boot() {
// super.boot()
@ -64,22 +65,22 @@ export default class Permission extends BaseModel {
// })
// }
private static formatDateTime(datetime) {
let value = new Date(datetime);
return datetime
? value.getFullYear() +
'-' +
(value.getMonth() + 1) +
'-' +
value.getDate() +
' ' +
value.getHours() +
':' +
value.getMinutes() +
':' +
value.getSeconds()
: datetime;
}
// private static formatDateTime(datetime) {
// let value = new Date(datetime);
// return datetime
// ? value.getFullYear() +
// '-' +
// (value.getMonth() + 1) +
// '-' +
// value.getDate() +
// ' ' +
// value.getHours() +
// ':' +
// value.getMinutes() +
// ':' +
// value.getSeconds()
// : datetime;
// }
// @belongsTo(() => Role)
// public role: BelongsTo<typeof Role>;

7
app/Models/Person.ts
View file

@ -1,8 +1,9 @@
import { column, SnakeCaseNamingStrategy, computed, manyToMany, ManyToMany } from '@ioc:Adonis/Lucid/Orm';
import { column, SnakeCaseNamingStrategy, computed, manyToMany } from '@adonisjs/lucid/orm';
import { DateTime } from 'luxon';
import dayjs from 'dayjs';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
import type { ManyToMany } from "@adonisjs/lucid/types/relations";
export default class Person extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

4
app/Models/Project.ts
View file

@ -1,6 +1,6 @@
import { column, SnakeCaseNamingStrategy } from '@ioc:Adonis/Lucid/Orm';
import { column, SnakeCaseNamingStrategy } from '@adonisjs/lucid/orm';
import { DateTime } from 'luxon';
import BaseModel from './BaseModel';
import BaseModel from './BaseModel.js';
export default class Project extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

13
app/Models/Role.ts
View file

@ -1,10 +1,11 @@
import { column, SnakeCaseNamingStrategy, manyToMany, ManyToMany, beforeCreate, beforeUpdate } from '@ioc:Adonis/Lucid/Orm';
import BaseModel from './BaseModel';
import { column, SnakeCaseNamingStrategy, manyToMany, beforeCreate, beforeUpdate } from '@adonisjs/lucid/orm';
import BaseModel from './BaseModel.js';
import { DateTime } from 'luxon';
// import moment from 'moment';
import dayjs from 'dayjs';
import User from './User';
import Permission from 'App/Models/Permission';
import User from './User.js';
import Permission from '#app/Models/Permission';
import type { ManyToMany } from "@adonisjs/lucid/types/relations";
export default class Role extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();
@ -46,7 +47,7 @@ export default class Role extends BaseModel {
@beforeCreate()
@beforeUpdate()
public static async resetDate(role) {
public static async resetDate(role: Role) {
role.created_at = this.formatDateTime(role.created_at);
role.updated_at = this.formatDateTime(role.updated_at);
}
@ -64,7 +65,7 @@ export default class Role extends BaseModel {
// });
// }
private static formatDateTime(datetime) {
private static formatDateTime(datetime: any) {
let value = new Date(datetime);
return datetime
? value.getFullYear() +

7
app/Models/Subject.ts
View file

@ -1,9 +1,10 @@
import { column, SnakeCaseNamingStrategy, manyToMany, ManyToMany, computed} from '@ioc:Adonis/Lucid/Orm';
import BaseModel from './BaseModel';
import { column, SnakeCaseNamingStrategy, manyToMany, computed} from '@adonisjs/lucid/orm';
import BaseModel from './BaseModel.js';
import { DateTime } from 'luxon';
import dayjs from 'dayjs';
import Dataset from './Dataset';
import Dataset from './Dataset.js';
import type { ManyToMany } from "@adonisjs/lucid/types/relations";
export default class Subject extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();

8
app/Models/Title.ts
View file

@ -1,6 +1,8 @@
import { column, belongsTo, BelongsTo } from '@ioc:Adonis/Lucid/Orm';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import { column, belongsTo } from '@adonisjs/lucid/orm';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
// import { DatasetRelatedBaseModel } from './BaseModel';
export default class Title extends BaseModel {

16
app/Models/TotpSecret.ts
View file

@ -1,8 +1,10 @@
import { column, BaseModel, SnakeCaseNamingStrategy, belongsTo, BelongsTo } from '@ioc:Adonis/Lucid/Orm';
import User from './User';
import { column, BaseModel, SnakeCaseNamingStrategy, belongsTo } from '@adonisjs/lucid/orm';
import User from './User.js';
import { DateTime } from 'luxon';
import dayjs from 'dayjs';
import Encryption from '@ioc:Adonis/Core/Encryption';
// import Encryption from '@ioc:Adonis/Core/Encryption';
import encryption from '@adonisjs/core/services/encryption';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
export default class TotpSecret extends BaseModel {
public static namingStrategy = new SnakeCaseNamingStrategy();
@ -21,16 +23,16 @@ export default class TotpSecret extends BaseModel {
// public twoFactorSecret: string;
@column({
serializeAs: null,
consume: (value: string) => (value ? JSON.parse(Encryption.decrypt(value) ?? '{}') : null),
prepare: (value: string) => Encryption.encrypt(JSON.stringify(value)),
consume: (value: string) => (value ? JSON.parse(encryption.decrypt(value) ?? '{}') : null),
prepare: (value: string) => encryption.encrypt(JSON.stringify(value)),
})
public twoFactorSecret?: string | null;
// serializeAs: null removes the model properties from the serialized output.
@column({
serializeAs: null,
consume: (value: string) => (value ? JSON.parse(Encryption.decrypt(value) ?? '[]') : []),
prepare: (value: string[]) => Encryption.encrypt(JSON.stringify(value)),
consume: (value: string) => (value ? JSON.parse(encryption.decrypt(value) ?? '[]') : []),
prepare: (value: string[]) => encryption.encrypt(JSON.stringify(value)),
})
public twoFactorRecoveryCodes?: string[] | null;

27
app/Models/Traits/DatasetExtension.ts
View file

@ -1,15 +1,15 @@
import Title from 'App/Models/Title';
import Description from 'App/Models/Description';
import License from 'App/Models/License';
import Person from 'App/Models/Person';
import DatasetReference from 'App/Models/DatasetReference';
import DatasetIdentifier from 'App/Models/DatasetIdentifier';
import Subject from 'App/Models/Subject';
import File from 'App/Models/File';
import Coverage from 'App/Models/Coverage';
import Collection from 'App/Models/Collection';
import { BaseModel as LucidBaseModel } from '@ioc:Adonis/Lucid/Orm';
import Field from 'App/Library/Field';
import Title from '#app/Models/Title';
import Description from '#app/Models/Description';
import License from '#app/Models/License';
import Person from '#app/Models/Person';
import DatasetReference from '#app/Models/DatasetReference';
import DatasetIdentifier from '#app/Models/DatasetIdentifier';
import Subject from '#app/Models/Subject';
import File from '#app/Models/File';
import Coverage from '#app/Models/Coverage';
import Collection from '#app/Models/Collection';
import { BaseModel as LucidBaseModel } from '@adonisjs/lucid/orm';
import Field from '#app/Library/Field';
import { DateTime } from 'luxon';
// @StaticImplements<LucidModel>()
@ -31,11 +31,12 @@ export type DatasetRelatedModel =
| typeof File;
export default abstract class DatasetExtension extends LucidBaseModel {
public abstract id;
public abstract id: number;
public externalFields: Record<string, any> = this.getExternalFields();
// which fields shoud#t be published
protected internalFields: Record<string, any> = {};
protected fields: Record<string, any> = {};
[key: string]: any;
private getExternalFields(): Record<string, any> {
// External fields definition

63
app/Models/User.ts
View file

@ -1,13 +1,25 @@
import { DateTime } from 'luxon';
import { column, beforeSave, manyToMany, ManyToMany, hasMany, HasMany } from '@ioc:Adonis/Lucid/Orm';
import Hash from '@ioc:Adonis/Core/Hash';
import Role from './Role';
import Database from '@ioc:Adonis/Lucid/Database';
import Config from '@ioc:Adonis/Core/Config';
import Dataset from './Dataset';
import BaseModel from './BaseModel';
import Encryption from '@ioc:Adonis/Core/Encryption';
import { TotpState } from 'Contracts/enums';
import { withAuthFinder } from '@adonisjs/auth';
import { column, beforeSave, manyToMany, hasMany } from '@adonisjs/lucid/orm';
import hash from '@adonisjs/core/services/hash';
import Role from './Role.js';
import db from '@adonisjs/lucid/services/db';
// import Config from '@ioc:Adonis/Core/Config';
import config from '@adonisjs/core/services/config';
import Dataset from './Dataset.js';
import BaseModel from './BaseModel.js';
// import Encryption from '@ioc:Adonis/Core/Encryption';
import encryption from '@adonisjs/core/services/encryption';
import { TotpState } from '#contracts/enums';
import type { ManyToMany } from '@adonisjs/lucid/types/relations';
import type { HasMany } from '@adonisjs/lucid/types/relations';
import { compose } from '@adonisjs/core/helpers';
const AuthFinder = withAuthFinder(() => hash.use('laravel'), {
uids: ['email'],
passwordColumnName: 'password',
});
// import TotpSecret from './TotpSecret';
// export default interface IUser {
@ -20,13 +32,14 @@ import { TotpState } from 'Contracts/enums';
// // async (user): Promise<void>;
// }
const permissionTable = Config.get('rolePermission.permission_table', 'permissions');
const rolePermissionTable = Config.get('rolePermission.role_permission_table', 'role_has_permissions');
// const permissionTable = config.get('rolePermission.permission_table', 'permissions');
// const rolePermissionTable = config.get('rolePermission.role_permission_table', 'role_has_permissions');
const roleTable = Config.get('rolePermission.role_table', 'roles');
const userRoleTable = Config.get('rolePermission.user_role_table', 'link_accounts_roles');
// const roleTable = config.get('rolePermission.role_table', 'roles');
// const userRoleTable = config.get('rolePermission.user_role_table', 'link_accounts_roles');
export default class User extends BaseModel {
export default class User extends compose(BaseModel, AuthFinder) {
// export default class User extends BaseModel {
public static table = 'accounts';
@column({ isPrimary: true })
@ -50,16 +63,16 @@ export default class User extends BaseModel {
// serializeAs: null removes the model properties from the serialized output.
@column({
serializeAs: null,
consume: (value: string) => (value ? JSON.parse(Encryption.decrypt(value) ?? '{}') : null),
prepare: (value: string) => Encryption.encrypt(JSON.stringify(value)),
consume: (value: string) => (value ? JSON.parse(encryption.decrypt(value) ?? '{}') : null),
prepare: (value: string) => encryption.encrypt(JSON.stringify(value)),
})
public twoFactorSecret?: string | null;
// serializeAs: null removes the model properties from the serialized output.
@column({
serializeAs: null,
consume: (value: string) => (value ? JSON.parse(Encryption.decrypt(value) ?? '[]') : []),
prepare: (value: string[]) => Encryption.encrypt(JSON.stringify(value)),
consume: (value: string) => (value ? JSON.parse(encryption.decrypt(value) ?? '[]') : []),
prepare: (value: string[]) => encryption.encrypt(JSON.stringify(value)),
})
public twoFactorRecoveryCodes?: string[] | null;
@ -72,14 +85,14 @@ export default class User extends BaseModel {
// public totp_secret: HasOne<typeof TotpSecret>;
@beforeSave()
public static async hashPassword(user) {
public static async hashPassword(user: User) {
if (user.$dirty.password) {
user.password = await Hash.make(user.password);
user.password = await hash.use('laravel').make(user.password);
}
}
public get isTwoFactorEnabled(): boolean {
return Boolean(this?.twoFactorSecret && this.state == TotpState.STATE_ENABLED);
return Boolean(this?.twoFactorSecret && this.state == TotpState.STATE_ENABLED);
// return Boolean(this.totp_secret?.twoFactorSecret);
}
@ -109,6 +122,12 @@ export default class User extends BaseModel {
}
private async checkHasPermissions(user: User, permissionNames: Array<string>): Promise<boolean> {
const permissionTable = config.get('rolePermission.permission_table', 'permissions');
const rolePermissionTable = config.get('rolePermission.role_permission_table', 'role_has_permissions');
const roleTable = config.get('rolePermission.role_table', 'roles');
const userRoleTable = config.get('rolePermission.user_role_table', 'link_accounts_roles');
let permissionPlaceHolder = '(';
let placeholders = new Array(permissionNames.length).fill('?');
permissionPlaceHolder += placeholders.join(',');
@ -118,7 +137,7 @@ export default class User extends BaseModel {
rows: {
0: { permissioncount },
},
} = await Database.rawQuery(
} = await db.rawQuery(
'SELECT count("p"."name") as permissionCount FROM ' +
roleTable +
' r INNER JOIN ' +

10
app/Models/UserRole.ts
View file

@ -1,8 +1,10 @@
import { column, BaseModel, belongsTo, BelongsTo, SnakeCaseNamingStrategy } from '@ioc:Adonis/Lucid/Orm';
import { column, BaseModel, belongsTo, SnakeCaseNamingStrategy } from '@adonisjs/lucid/orm';
import User from 'App/Models/User';
import Role from 'App/Models/Role';
import User from '#app/Models/User';
import Role from '#app/Models/Role';
import { DateTime } from 'luxon';
import type { BelongsTo } from "@adonisjs/lucid/types/relations";
// import moment from 'moment'
export default class UserRole extends BaseModel {
@ -49,7 +51,7 @@ export default class UserRole extends BaseModel {
});
}
private static formatDateTime(datetime) {
private static formatDateTime(datetime: any) {
let value = new Date(datetime);
return datetime
? value.getFullYear() +

35
app/Models/utils.ts
View file

@ -1,19 +1,18 @@
import Database, {
// DatabaseQueryBuilderContract,
QueryClientContract,
TransactionClientContract,
} from '@ioc:Adonis/Lucid/Database';
import Config from '@ioc:Adonis/Core/Config';
// import db from '@adonisjs/lucid/services/db';
// // import Config from '@ioc:Adonis/Core/Config';
// import config from '@adonisjs/core/services/config';
// import { QueryClientContract } from "@adonisjs/lucid/types/database";
// import { TransactionClientContract } from "@adonisjs/lucid/types/database";
export function getUserRoles(userId: number, trx?: TransactionClientContract): Promise<Array<string>> {
const { userRole } = Config.get('acl.joinTables');
return ((trx || Database) as QueryClientContract | TransactionClientContract)
.query()
.from('roles')
.distinct('roles.slug')
.leftJoin(userRole, `${userRole}.role_id`, 'roles.id')
.where(`${userRole}.user_id`, userId)
.then((res) => {
return res.map((r) => r.slug);
});
}
// export function getUserRoles(userId: number, trx?: TransactionClientContract): Promise<Array<string>> {
// const { userRole } = config.get('acl.joinTables');
// return ((trx || db) as QueryClientContract | TransactionClientContract)
// .query()
// .from('roles')
// .distinct('roles.slug')
// .leftJoin(userRole, `${userRole}.role_id`, 'roles.id')
// .where(`${userRole}.user_id`, userId)
// .then((res) => {
// return res.map((r) => r.slug);
// });
// }

11
app/Services/TwoFactorAuthProvider.ts
View file

@ -1,10 +1,11 @@
import Config from '@ioc:Adonis/Core/Config';
import User from 'App/Models/User';
import { generateSecret, verifyToken } from 'node-2fa/dist/index';
// import Config from '@ioc:Adonis/Core/Config';
import config from '@adonisjs/core/services/config'
import User from '#app/Models/User';
import { generateSecret, verifyToken } from 'node-2fa/dist/index.js';
// import cryptoRandomString from 'crypto-random-string';
import QRCode from 'qrcode';
import crypto from 'crypto';
import { TotpState } from 'Contracts/enums';
import { TotpState } from '#contracts/enums';
// npm install node-2fa --save
// npm install crypto-random-string --save
@ -13,7 +14,7 @@ import { TotpState } from 'Contracts/enums';
// npm i --save-dev @types/qrcode
class TwoFactorAuthProvider {
private issuer = Config.get('twoFactorAuthConfig.app.name') || 'TethysCloud';
private issuer: string = config.get('twoFactorAuthConfig.app.name') || 'TethysCloud';
/**
* generateSecret will generate a user-specific 32-character secret.

7
app/Validators/AuthValidator.ts
View file

@ -1,8 +1,9 @@
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import { schema, rules } from '@adonisjs/validator';
import type { HttpContext } from '@adonisjs/core/http';
import { CustomMessages } from "@adonisjs/validator/types";
export default class AuthValidator {
constructor(protected ctx: HttpContextContract) {}
constructor(protected ctx: HttpContext) {}
/*
* Define schema to validate the "shape", "type", "formatting" and "integrity" of data.

13
app/Validators/CreateDatasetValidator.ts
View file

@ -1,10 +1,11 @@
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import { schema, rules } from '@adonisjs/validator';
import type { HttpContext } from '@adonisjs/core/http';
import dayjs from 'dayjs';
import { TitleTypes, DescriptionTypes, RelationTypes, ReferenceIdentifierTypes, ContributorTypes } from 'Contracts/enums';
import { TitleTypes, DescriptionTypes, RelationTypes, ReferenceIdentifierTypes, ContributorTypes } from '#contracts/enums';
import { CustomMessages } from "@adonisjs/validator/types";
export default class CreateDatasetValidator {
constructor(protected ctx: HttpContextContract) {}
constructor(protected ctx: HttpContext) {}
/*
* Define schema to validate the "shape", "type", "formatting" and "integrity" of data.
@ -104,8 +105,8 @@ export default class CreateDatasetValidator {
// }),
files: schema.array([rules.minLength(1)]).members(
schema.file({
size: '100mb',
extnames: ['jpg', 'gif', 'png', 'tif', 'pdf'],
size: '512mb',
extnames: ['jpg', 'gif', 'png', 'tif', 'pdf', 'zip', 'fgb', 'nc', 'qml', 'ovr', 'gpkg', 'gml', 'gpx', 'kml', 'kmz', 'json'],
}),
),
// upload: schema.object().members({

7
app/Validators/CreateRoleValidator.ts
View file

@ -1,8 +1,9 @@
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import { schema, rules } from '@adonisjs/validator';
import type { HttpContext } from '@adonisjs/core/http';
import { CustomMessages } from "@adonisjs/validator/types";
export default class CreateRoleValidator {
constructor(protected ctx: HttpContextContract) {}
constructor(protected ctx: HttpContext) {}
/*
* Define schema to validate the "shape", "type", "formatting" and "integrity" of data.

7
app/Validators/CreateUserValidator.ts
View file

@ -1,8 +1,9 @@
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import { schema, rules } from '@adonisjs/validator';
import type { HttpContext } from '@adonisjs/core/http';
import { CustomMessages } from "@adonisjs/validator/types";
export default class CreateUserValidator {
constructor(protected ctx: HttpContextContract) {}
constructor(protected ctx: HttpContext) {}
/*
* Define schema to validate the "shape", "type", "formatting" and "integrity" of data.

9
app/Validators/UpdateDatasetValidator.ts
View file

@ -1,10 +1,11 @@
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import { schema, rules } from '@adonisjs/validator';
import type { HttpContext } from '@adonisjs/core/http';
import dayjs from 'dayjs';
import { TitleTypes, DescriptionTypes, RelationTypes, ReferenceIdentifierTypes, ContributorTypes } from 'Contracts/enums';
import { TitleTypes, DescriptionTypes, RelationTypes, ReferenceIdentifierTypes, ContributorTypes } from '#contracts/enums';
import { CustomMessages } from "@adonisjs/validator/types";
export default class UpdateDatasetValidator {
constructor(protected ctx: HttpContextContract) {}
constructor(protected ctx: HttpContext) {}
/*
* Define schema to validate the "shape", "type", "formatting" and "integrity" of data.

10
app/Validators/UpdateRoleValidator.ts
View file

@ -1,12 +1,14 @@
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import { schema, rules } from '@adonisjs/validator';
import type { HttpContext } from '@adonisjs/core/http';
import { CustomMessages } from "@adonisjs/validator/types";
// import { Request } from '@adonisjs/core/build/standalone';
export default class UpdateRoleValidator {
protected ctx: HttpContextContract;
protected ctx: HttpContext;
public schema;
constructor(ctx: HttpContextContract) {
constructor(ctx: HttpContext) {
this.ctx = ctx;
this.schema = this.createSchema();
}

10
app/Validators/UpdateUserValidator.ts
View file

@ -1,12 +1,14 @@
import { schema, CustomMessages, rules } from '@ioc:Adonis/Core/Validator';
import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
import { schema, rules } from '@adonisjs/validator';
import type { HttpContext } from '@adonisjs/core/http';
import { CustomMessages } from "@adonisjs/validator/types";
// import { Request } from '@adonisjs/core/build/standalone';
export default class UpdateUserValidator {
protected ctx: HttpContextContract;
protected ctx: HttpContext;
public schema;
constructor(ctx: HttpContextContract) {
constructor(ctx: HttpContext) {
this.ctx = ctx;
this.schema = this.createSchema();
}