help for my project

[gradingunza]

Hello comminity i'm a speaking country man but i try english a little if the answer could be in french it will be better but if not no problem. My issue is about my application of presence. I built an application wich provides the manager to follow presences of his men heaven at home. But i have a big problem, the authentification of administrator. For simple users, i allow them to be redirect to the home after login or registration but for admin who is the manager i don't know how can i do to redict him to the dashboard which i already create to follow presence of his men or workers. I'm using adonisJs 6 please i'm waiting for your reactions

[renztoygwapo]

Hi, do you want some help ?

please share details so I can help with you.

Regards,

Florence

[gradingunza]

thank you in advance here's my authController : import type { HttpContext } from '@adonisjs/core/http';
import User from '#models/user';
import { createUserValidator } from '#validators/user';

export default class AuthController {
async loginPost({ view }: HttpContext) {
return view.render('pages/loginPost');
}

public async login({ request, auth, session, response }: HttpContext) {
const { email, password } = request.only(['email', 'password']);

try {
  const user = await User.verifyCredentials(email, password);
  await auth.use('web').login(user);

  session.flash('success', 'Connexion réussie');
  return response.redirect().toRoute('home');
} catch (error) {
  session.flash('error', 'Identifiants incorrects');
  return response.redirect().toRoute('registerPost');
}

}

public async registerPost({ view }: HttpContext) {
return view.render('pages/registerPost');
}

// Fonction d'enregistrement d'utilisateur améliorée
public async register({ request, auth, session, response }: HttpContext) {
try {
// Valider les données de la requête en utilisant le validateur
const data = await request.validateUsing(createUserValidator);

  // Créer un nouvel utilisateur dans la base de données
  const user = await User.create({
    firstName: data.firstName,
    name: data.name,
    email: data.email,
    password: data.password, 
  });

  // Connecter l'utilisateur nouvellement enregistré
  await auth.use('web').login(user);

  // Ajouter un message flash de succès
  session.flash('success', 'Inscription réussie!');

  // Rediriger vers la page d'accueil
  return response.redirect().toRoute('home');
} catch (error) {
  {
    console.error('Erreur lors de l\'inscription:', error); // Pour déboguer
    session.flash('error', 'Erreur lors de l\'inscription. Veuillez réessayer.');
  }
  return response.redirect().toRoute('registerPost'); // Rester sur la page d'inscription
}

}

public async logout({ auth, session, response }: HttpContext) {
await auth.use('web').logout();
session.flash('success', 'Déconnexion réussie');
return response.redirect().toRoute('loginPost');
}
}
ok here's my adminController : import type { HttpContext } from '@adonisjs/core/http'
import User from '#models/user'
import Presence from '#models/presence'
import { DateTime } from 'luxon'

export default class AdminController {
public async index({ view }: HttpContext) {
try {
return view.render('pages/dashboard')
} catch (error) {
console.error('Erreur dans AdminController.index:', error)
return view.render('pages/home', { message: 'Erreur lors de l'accès au tableau de bord.' })
}
}

public async dashboard({ view, session, response }: HttpContext) {
try {
const users = await User.all()
return view.render('pages/dashboard', { users })
} catch (error) {
session.flash('error', 'Identifiants incorrects')
return response.redirect().toRoute('admin.dashboard')
}
}

public async deleteUser({ params, response, session }: HttpContext) {
try {
const user = await User.findOrFail(params.id)
await user.delete()
return response.redirect().back()
} catch (error) {
console.error('Erreur dans AdminController.deleteUser:', error)
session.flash('error', 'Erreur lors de la suppression de l'utilisateur.')
return response.redirect().back()
}
}

public async viewDailyPresences({ view }: HttpContext) {
try {
const today = DateTime.now().toFormat('dd/MM/yyyy')
const todayStart = DateTime.now().startOf('day').toSQLDate()

  const presencesRaw = await Presence.query()
    .preload('user')
    .whereRaw('DATE(check_in) = ?', [todayStart])
    .orderBy('check_in', 'desc')

  const presences = presencesRaw.map((presence) => {
    let duration = '-'
    if (presence.checkIn && presence.checkOut) {
      const start = presence.checkIn.toJSDate()
      const end = presence.checkOut.toJSDate()
      const diff = Math.abs(end.getTime() - start.getTime())
      const hours = Math.floor(diff / (1000 * 60 * 60))
      const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60))
      duration = `${hours}h${String(minutes).padStart(2, '0')}`
    }

    return {
      ...presence.serialize(),
      duration,
      user: presence.user.serialize(),
    }
  })

  return view.render('pages/daily_presences', {
    presences,
    today,
  })
} catch (error) {
  console.error('Erreur dans AdminController.viewDailyPresences:', error)
  return view.render('pages/error', { message: 'Erreur lors de la récupération des présences quotidiennes.' })
}

}
} welle here's my admin middleware import { HttpContext } from '@adonisjs/core/http';
import User from '#models/user';

export default class IsAdminMiddleware {
async handle(ctx: HttpContext, next: () => Promise) {
if (!ctx.auth.isAuthenticated) {
ctx.session.flash('error', 'Vous devez être connecté pour accéder à cette page.');
return ctx.response.redirect().toPath('/login');
}

const user = ctx.auth.user as User | null;
if (!user) {
  ctx.session.flash('error', 'Utilisateur non trouvé.');
  return ctx.response.redirect().toPath('/login');
}

await user.load('role');
if (user.role?.roleName !== 'Admin') {
  ctx.session.flash('error', 'Accès refusé.  Réservé aux administrateurs.');
  return ctx.response.redirect().toPath('/home');
}

await next();

}
} here's my user model import { DateTime } from 'luxon';
import { BaseModel, column, belongsTo, afterFind } from '@adonisjs/lucid/orm';
import hash from '@adonisjs/core/services/hash';
import { withAuthFinder } from '@adonisjs/auth/mixins/lucid';
import type { BelongsTo } from '@adonisjs/lucid/types/relations';
import Role from '#models/role';

const AuthFinder = withAuthFinder(() => hash.use('scrypt'), {
uids: ['email'],
passwordColumnName: 'password',
});

export default class User extends AuthFinder(BaseModel) {
@column({ isPrimary: true })
declare id: number;

@column({ columnName: 'first_name' })
declare firstName: string;

@column()
declare name: string;

@column()
declare email: string;

@column({ serializeAs: null })
declare password: string;

@column()
declare roleId: number;

@column.dateTime({ autoCreate: true })
declare createdAt: DateTime;

@column.dateTime({ autoCreate: true, autoUpdate: true })
declare updatedAt: DateTime | null;

@belongsTo(() => Role)
declare role: BelongsTo;

@afterFind()
public static async setAuthFlags(user: User) {
if (!user.role && user.roleId) {
await user.load('role');
}

// Définit des flags d'authentification
user.$extras.isAdmin = user.role?.roleName === 'Admin'; // Utilisez roleName
user.$extras.isUser = user.role?.roleName === 'User';   // Utilisez roleName

// Optionnel : Stocke le chemin de redirection
user.$extras.redirectPath = user.$extras.isAdmin
  ? '/dashboard'
  : '/home';

}
}
, here's my role model import { DateTime } from 'luxon';
import { BaseModel, column, hasMany } from '@adonisjs/lucid/orm';
import type { HasMany } from '@adonisjs/lucid/types/relations'
import User from '#models/user';

export default class Role extends BaseModel {
@column({ isPrimary: true })
declare id: number;

@column({ columnName: 'role_name' })
declare roleName: string;

@column.dateTime({ autoCreate: true })
declare createdAt: DateTime;

@column.dateTime({ autoCreate: true, autoUpdate: true })
declare updatedAt: DateTime | null;

@hasmany(() => User)
declare users: HasMany
} , end here's my user migration import { BaseSchema } from '@adonisjs/lucid/schema'
import Roles from '../../app/enums/roles.js'

export default class extends BaseSchema {
protected tableName = 'users'

async up() {
this.schema.createTable(this.tableName, (table) => {
table.increments('id').notNullable()
table.string('first_name').notNullable()
table.string('name').notNullable()
table.string('email', 254).notNullable().unique()
table.string('password').notNullable()
table.integer('role_id').references('roles.id').notNullable().defaultTo(Roles.USER) // Supprime la colonne 'role' et garde la relation via role_id

  table.timestamp('created_at').notNullable()
  table.timestamp('updated_at').nullable()
})

}

async down() {
this.schema.dropTable(this.tableName)
}
} and this is my role migration import { BaseSchema } from '@adonisjs/lucid/schema'

export default class extends BaseSchema {
protected tableName = 'roles'

async up() {
this.schema.createTable(this.tableName, (table) => {
table.increments('id')

  table.increments('id')
  table.string('role_name').notNullable()

  table.timestamp('created_at')
  table.timestamp('updated_at')
})

}

async down() {
this.schema.dropTable(this.tableName)
}
} i alredy make login and registration of simple user who will be redirect to the home to make there entrance and departure but i want also to do it for an administrator who will be redirect to the dashboard to follow all presences heaven at office or at home