initial commit

app/Controllers/Http/Admin/FileController.ts

@@ -0,0 +1,10 @@
+// import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+// import File from 'App/Models/File';
+// import type { ModelQueryBuilderContract } from '@ioc:Adonis/Lucid/Orm';
+
+// export default class HomeController {
+
+//     public async index({ auth, request, inertia }: HttpContextContract) {
+//         let files: ModelQueryBuilderContract<typeof File, File> = File.query();
+//     }
+// }

app/Controllers/Http/Admin/HomeController.ts

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

app/Controllers/Http/Admin/RoleController.ts

@@ -0,0 +1,143 @@
+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 { schema, rules } from '@ioc:Adonis/Core/Validator';
+
+export default class RoleController {
+    public async index({ auth, request, inertia }: HttpContextContract) {
+        let roles: ModelQueryBuilderContract<typeof Role, Role> = Role.query();
+
+        if (request.input('search')) {
+            // users = users.whereRaw('name like %?%', [request.input('search')])
+            const searchTerm = request.input('search');
+            roles.where('name', 'ilike', `%${searchTerm}%`);
+        }
+
+        if (request.input('sort')) {
+            type SortOrder = 'asc' | 'desc' | undefined;
+            let attribute = request.input('sort');
+            let sort_order: SortOrder = 'asc';
+
+            if (attribute.substr(0, 1) == '-') {
+                sort_order = 'desc';
+                // attribute = substr(attribute, 1);
+                attribute = attribute.substr(1);
+            }
+            roles.orderBy(attribute, sort_order);
+        } else {
+            // users.orderBy('created_at', 'desc');
+            roles.orderBy('id', 'asc');
+        }
+
+        // const users = await User.query().orderBy('login').paginate(page, limit);
+        let rolesResult = await roles;
+
+        return inertia.render('Admin/Role/Index', {
+            // testing: 'this is a test',
+            roles: rolesResult,
+            filters: request.all(),
+            can: {
+                create: await auth.user?.can(['user-create']),
+                edit: await auth.user?.can(['user-edit']),
+                delete: await auth.user?.can(['user-delete']),
+            },
+        });
+    }
+
+    public async create({ inertia }: HttpContextContract) {
+        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) {
+        // node ace make:validator CreateUser
+        try {
+            //  Step 2 - Validate request body against  the schema
+            await request.validate(CreateRoleValidator);
+            // await request.validate({ schema: roleSchema });
+            // console.log({ payload });
+        } catch (error) {
+            // Step 3 - Handle errors
+            // return response.badRequest(error.messages);
+            throw error;
+        }
+        const input = request.only(['name', 'display_name', 'description']);
+        const role = await Role.create(input);
+
+        if (request.input('permissions')) {
+            const permissions: Array<number> = request.input('permissions');
+            await role.related('permissions').attach(permissions);
+        }
+
+        session.flash('message', `Role ${role.name} has been created successfully`);
+        return response.redirect().toRoute('role.index');
+    }
+
+    public async show({ request, inertia }: HttpContextContract): RenderResponse {
+        const id = request.param('id');
+        const role = await Role.query().where('id', id).firstOrFail();
+
+        const permissions = await Permission.query().pluck('name', 'id');
+        // const userHasRoles = user.roles;
+        const rolePermsissions = await role.related('permissions').query().orderBy('name').pluck('id');
+
+        return inertia.render('Admin/Role/Show', {
+            permissions: permissions,
+            role: role,
+            roleHasPermissions: rolePermsissions,
+        });
+    }
+
+    public async edit({ request, inertia }: HttpContextContract) {
+        const id = request.param('id');
+        const role = await Role.query().where('id', id).firstOrFail();
+
+        const permissions = await Permission.query().pluck('name', 'id');
+        // const userHasRoles = user.roles;
+        const rolerHasPermissions = await role.related('permissions').query().orderBy('name').pluck('id');
+
+        return inertia.render('Admin/Role/Edit', {
+            permissions: permissions,
+            role: role,
+            roleHasPermissions: Object.keys(rolerHasPermissions).map((key) => rolerHasPermissions[key]), //convert object to array with role ids
+        });
+    }
+
+    public async update({ request, response, session }: HttpContextContract) {
+        // node ace make:validator UpdateUser
+        const id = request.param('id');
+        const role = await Role.query().where('id', id).firstOrFail();
+
+        // validate update form
+        await request.validate(UpdateRoleValidator);
+
+        // password is optional
+
+        const input = request.only(['name', 'description']);
+        await role.merge(input).save();
+        // await user.save();
+
+        if (request.input('permissions')) {
+            const permissions: Array<number> = request.input('permissions');
+            await role.related('permissions').sync(permissions);
+        }
+
+        session.flash('message', 'Role has been updated successfully');
+        return response.redirect().toRoute('role.index');
+    }
+
+    public async destroy({ request, response, session }: HttpContextContract) {
+        const id = request.param('id');
+        const role = await Role.findOrFail(id);
+        await role.delete();
+
+        session.flash('message', `Role ${role.name} has been deleted.`);
+        return response.redirect().toRoute('role.index');
+    }
+}

app/Controllers/Http/Admin/UsersController.ts

@@ -0,0 +1,204 @@
+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 { schema, rules } from '@ioc:Adonis/Core/Validator';
+
+export default class UsersController {
+	public async index({ auth, request, inertia }: HttpContextContract) {
+		const page = request.input('page', 1);
+		// const limit = 10
+
+		let users: ModelQueryBuilderContract<typeof User, User> = User.query();
+
+		if (request.input('search')) {
+			// users = users.whereRaw('name like %?%', [request.input('search')])
+			const searchTerm = request.input('search');
+			users.where('login', 'ilike', `%${searchTerm}%`);
+		}
+
+		if (request.input('sort')) {
+			type SortOrder = 'asc' | 'desc' | undefined;
+			let attribute = request.input('sort');
+			let sort_order: SortOrder = 'asc';
+
+			// if (strncmp($attribute, '-', 1) === 0) {
+			if (attribute.substr(0, 1) == '-') {
+				sort_order = 'desc';
+				// attribute = substr(attribute, 1);
+				attribute = attribute.substr(1);
+			}
+			// $users->orderBy($attribute, $sort_order);
+			users.orderBy(attribute, sort_order);
+		} else {
+			// users.orderBy('created_at', 'desc');
+			users.orderBy('id', 'asc');
+		}
+
+		// const users = await User.query().orderBy('login').paginate(page, limit);
+
+		let usersResult = await users // User.query()
+			// .orderBy('login')
+			// .filter(qs)
+			// .preload('focusInterests')
+			// .preload('role')
+			.paginate(page, 5);
+
+		// var test = request.all();
+
+		return inertia.render('Admin/User/Index', {
+			// testing: 'this is a test',
+			users: usersResult.toJSON(),
+			filters: request.all(),
+			can: {
+				create: await auth.user?.can(['user-create']),
+				edit: await auth.user?.can(['user-edit']),
+				delete: await auth.user?.can(['user-delete']),
+			},
+		});
+	}
+
+	public async create({ inertia }: HttpContextContract) {
+		// let rolesPluck = {};
+		// (await Role.query().select('id', 'name')).forEach((user) => {
+		// 	rolesPluck[user.id] = user.name;
+		// });
+		const roles = await Role.query().select('id', 'name').pluck('name', 'id');
+
+		return inertia.render('Admin/User/Create', {
+			roles: roles,
+		});
+	}
+
+	public async store({ request, response, session }: HttpContextContract) {
+		// node ace make:validator CreateUser
+		try {
+			//  Step 2 - Validate request body against  the schema
+			await request.validate(CreateUserValidator);
+			// console.log({ payload });
+		} catch (error) {
+			// Step 3 - Handle errors
+			// return response.badRequest(error.messages);
+			throw error;
+		}
+		const input = request.only(['login', 'email', 'password']);
+		const user = await User.create(input);
+		if (request.input('roles')) {
+			const roles: Array<number> = request.input('roles');
+			await user.related('roles').attach(roles);
+		}
+
+		session.flash('message', 'User has been created successfully');
+		return response.redirect().toRoute('user.index');
+	}
+
+	public async show({ request, inertia }: HttpContextContract) {
+		const id = request.param('id');
+		const user = await User.query().where('id', id).firstOrFail();
+
+		const roles = await Role.query().pluck('name', 'id');
+		// const userHasRoles = user.roles;
+		const userRoles = await user.related('roles').query().orderBy('name').pluck('id');
+
+		return inertia.render('Admin/User/Show', {
+			roles: roles,
+			user: user,
+			userHasRoles: userRoles,
+		});
+	}
+
+	public async edit({ request, inertia }: HttpContextContract) {
+		const id = request.param('id');
+		const user = await User.query().where('id', id).firstOrFail();
+
+		const roles = await Role.query().pluck('name', 'id');
+		// const userHasRoles = user.roles;
+		const userHasRoles = await user.related('roles').query().orderBy('name').pluck('id');
+
+		return inertia.render('Admin/User/Edit', {
+			roles: roles,
+			user: user,
+			userHasRoles: Object.keys(userHasRoles).map((key) => userHasRoles[key]), //convert object to array with role ids
+		});
+	}
+
+	public async update({ request, response, session }: HttpContextContract) {
+		// node ace make:validator UpdateUser
+		const id = request.param('id');
+		const user = await User.query().where('id', id).firstOrFail();
+
+		// validate update form
+		await request.validate(UpdateUserValidator);
+
+		// password is optional
+		let input;
+		if (request.input('password')) {
+			input = request.only(['login', 'email', 'password']);
+		} else {
+			input = request.only(['login', 'email']);
+		}
+		await user.merge(input).save();
+		// await user.save();
+
+		if (request.input('roles')) {
+			const roles: Array<number> = request.input('roles');
+			await user.related('roles').sync(roles);
+		}
+
+		session.flash('message', 'User has been updated successfully');
+		return response.redirect().toRoute('user.index');
+	}
+
+	public async destroy({ request, response, session }: HttpContextContract) {
+		const id = request.param('id');
+		const user = await User.findOrFail(id);
+		await user.delete();
+
+		session.flash('message', `User ${user.login} has been deleted.`);
+		return response.redirect().toRoute('user.index');
+	}
+
+	/**
+	 * Show the user a form to change their personal information & password.
+	 *
+	 * @return — \Inertia\Response
+	 */
+	public accountInfo({  inertia, auth }: HttpContextContract): RenderResponse {
+		const user = auth.user;
+		// const id = request.param('id');
+		// const user = await User.query().where('id', id).firstOrFail();
+
+		return inertia.render('Admin/User/AccountInfo', {
+			user: user,
+		});
+	}
+
+	/**
+	 * Save the modified personal information for a user.
+	 *
+	 * @param  HttpContextContract ctx
+	 * @return : RedirectContract
+	 */
+	public async accountInfoStore({ request, response, auth, session }: HttpContextContract) {
+		// validate update form
+		await request.validate(UpdateUserValidator);
+
+		const payload = request.only(['login', 'email']);
+		auth.user?.merge(payload);
+		const user = await auth.user?.save();
+		//   $user = \Auth::user()->update($request->except(['_token']));
+		let message;
+		if (user) {
+			message = 'Account updated successfully.';
+		} else {
+			message = 'Error while saving. Please try again.';
+		}
+
+		session.flash(message);
+		return response.redirect().toRoute('admin.account.info');
+		//->with('message', __($message));
+	}
+}

app/Controllers/Http/Api/AuthorsController.ts

@@ -0,0 +1,23 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+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) {        	
+	// 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"));
+		const authors =  await Person.query()
+		.whereHas('datasets', (dQuery) => {
+            dQuery.wherePivot('role', 'author')
+        })
+		.withCount('datasets', (query) => {
+			query.as('datasets_count')
+		  });
+        
+		return authors;
+	}
+
+}

app/Controllers/Http/Api/DatasetController.ts

@@ -0,0 +1,23 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+// import Person from 'App/Models/Person';
+import Dataset from 'App/Models/Dataset';
+
+// node ace make:controller Author
+export default class DatasetController {
+
+	public async index({}: HttpContextContract) {        	
+	// 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"));
+		const datasets =  await Dataset
+		.query()
+		.where('server_state', 'published')
+		.orWhere('server_state', 'deleted');
+
+	
+		
+        
+		return datasets;
+	}
+
+}

app/Controllers/Http/Auth/AuthController.ts

@@ -0,0 +1,42 @@
+import type { HttpContextContract } from '@ioc:Adonis/Core/HttpContext';
+// import User from 'App/Models/User';
+// import Hash from '@ioc:Adonis/Core/Hash';
+// import InvalidCredentialException from 'App/Exceptions/InvalidCredentialException';
+import AuthValidator from 'App/Validators/AuthValidator';
+
+export default class AuthController {
+	//   login function
+	public async login({ request, response, auth, session }: HttpContextContract) {
+		// console.log({
+		// 	registerBody: request.body(),
+		// });
+        await request.validate(AuthValidator);
+
+		const plainPassword = await request.input('password');
+		const email = await request.input('email');
+		// grab uid and password values off request body
+		// const { email, password } = request.only(['email', 'password'])
+		
+		
+		
+		try {
+			// attempt to login
+			await auth.use("web").attempt(email, plainPassword);
+		} catch (error) {
+			// if login fails, return vague form message and redirect back
+			session.flash('message', 'Your username, email, or password is incorrect')
+			return response.redirect().back()
+		  }
+
+		// otherwise, redirect todashboard
+		response.redirect('/dashboard');				
+	}
+
+	//   logout function
+	public async logout({ auth, response }: HttpContextContract) {
+		// await auth.logout();
+		await auth.use('web').logout();
+		response.redirect('/app/login');
+		// return response.status(200);
+	}
+}