Skip to content

Commit 60ab9f9

Browse files
gambitiergambitier
committed
complete authorization implementation
1 parent 8d83b8e commit 60ab9f9

File tree

5 files changed

+156
-27
lines changed

5 files changed

+156
-27
lines changed

‎Projects/BooksLibrary/src/database/sql/sequelize/models/role.privilege.model.ts‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -43,13 +43,12 @@ export default class RolePrivilege extends Model {
4343
})
4444
Privilege: string;
4545

46-
@IsInt
4746
@ForeignKey(() => Role)
4847
@Column({
49-
type: DataType.INTEGER,
48+
type: DataType.STRING,
5049
allowNull: false,
5150
})
52-
RoleId: number;
51+
RoleId: string;
5352

5453
@Column
5554
@CreatedAt

‎Projects/BooksLibrary/src/database/sql/sequelize/repositories/role.privilege.repo.ts‎

Lines changed: 105 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -1,28 +1,113 @@
1-
import { IRolePrivilegeRepo } from 'database/repository.interfaces/role.privilege.repo.interface';
2-
import { RolePrivilegeDto } from 'domain.types/role/role.privilege.dto';
1+
import { IRolePrivilegeRepo } from '../../../repository.interfaces/role.privilege.repo.interface';
2+
import RolePrivilege from '../models/role.privilege.model';
3+
import { RolePrivilegeDto } from '../../../../domain.types/role/role.privilege.dto';
4+
import { Logger } from '../../../../common/logger';
5+
import { ApiError } from '../../../../common/api.error';
6+
import { Op } from 'sequelize';
7+
8+
///////////////////////////////////////////////////////////////////////
39

410
export class RolePrivilegeRepo implements IRolePrivilegeRepo {
5-
create(entity: any): Promise<RolePrivilegeDto> {
6-
throw new Error('Method not implemented.');
7-
}
11+
create = async (object: any): Promise<RolePrivilegeDto> => {
12+
try {
13+
const entity = {
14+
RoleId: object.RoleId,
15+
Privilege: object.Privilege,
16+
};
17+
const rolePrivilege = await RolePrivilege.create(entity);
18+
const dto: RolePrivilegeDto = {
19+
id: rolePrivilege.id,
20+
RoleId: rolePrivilege.RoleId,
21+
Privilege: rolePrivilege.Privilege,
22+
};
23+
return dto;
24+
} catch (error) {
25+
Logger.instance().log(error.message);
26+
throw new ApiError(500, error.message);
27+
}
28+
};
829

9-
getById(id: string): Promise<RolePrivilegeDto> {
10-
throw new Error('Method not implemented.');
11-
}
30+
getById = async (id: string): Promise<RolePrivilegeDto> => {
31+
try {
32+
const rolePrivilege = await RolePrivilege.findByPk(id);
33+
const dto: RolePrivilegeDto = {
34+
id: rolePrivilege.id,
35+
RoleId: rolePrivilege.RoleId,
36+
Privilege: rolePrivilege.Privilege,
37+
};
38+
return dto;
39+
} catch (error) {
40+
Logger.instance().log(error.message);
41+
throw new ApiError(500, error.message);
42+
}
43+
};
1244

13-
search(): Promise<RolePrivilegeDto[]> {
14-
throw new Error('Method not implemented.');
15-
}
45+
search = async (): Promise<RolePrivilegeDto[]> => {
46+
try {
47+
const rolePrivileges = await RolePrivilege.findAll();
48+
const dtos: RolePrivilegeDto[] = [];
49+
for (let i = 0; i < rolePrivileges.length; i++) {
50+
const rp = rolePrivileges[i];
51+
const dto: RolePrivilegeDto = {
52+
id: rp.id,
53+
RoleId: rp.RoleId,
54+
Privilege: rp.Privilege,
55+
};
56+
dtos.push(dto);
57+
}
58+
return dtos;
59+
} catch (error) {
60+
Logger.instance().log(error.message);
61+
throw new ApiError(500, error.message);
62+
}
63+
};
1664

17-
getPrivilegesForRole(roleId: string): Promise<RolePrivilegeDto[]> {
18-
throw new Error('Method not implemented.');
19-
}
65+
getPrivilegesForRole = async (roleId: string): Promise<RolePrivilegeDto[]> => {
66+
try {
67+
const rolePrivileges = await RolePrivilege.findAll({
68+
where: {
69+
RoleId: roleId,
70+
},
71+
});
72+
const dtos: RolePrivilegeDto[] = [];
73+
for (let i = 0; i < rolePrivileges.length; i++) {
74+
const rp = rolePrivileges[i];
75+
const dto: RolePrivilegeDto = {
76+
id: rp.id,
77+
RoleId: rp.RoleId,
78+
Privilege: rp.Privilege,
79+
};
80+
dtos.push(dto);
81+
}
82+
return dtos;
83+
} catch (error) {
84+
Logger.instance().log(error.message);
85+
throw new ApiError(500, error.message);
86+
}
87+
};
2088

21-
hasPrivilegeForRole(roleId: string, privilege: string): Promise<boolean> {
22-
throw new Error('Method not implemented.');
23-
}
89+
hasPrivilegeForRole = async (roleId: string, privilege: string): Promise<boolean> => {
90+
try {
91+
const rolePrivileges = await RolePrivilege.findAll({
92+
where: {
93+
RoleId: roleId,
94+
Privilege: { [Op.like]: '%' + privilege + '%' },
95+
},
96+
});
97+
return rolePrivileges.length > 0;
98+
} catch (error) {
99+
Logger.instance().log(error.message);
100+
throw new ApiError(500, error.message);
101+
}
102+
};
24103

25-
delete(id: string): Promise<boolean> {
26-
throw new Error('Method not implemented.');
27-
}
104+
delete = async (id: string): Promise<boolean> => {
105+
try {
106+
await RolePrivilege.destroy({ where: { id: id } });
107+
return true;
108+
} catch (error) {
109+
Logger.instance().log(error.message);
110+
throw new ApiError(500, error.message);
111+
}
112+
};
28113
}

‎Projects/BooksLibrary/src/domain.types/role/role.privilege.dto.ts‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
1-
21
export interface RolePrivilegeDto {
3-
id : string,
4-
RoleId : number;
2+
id: string;
3+
RoleId: string;
54
Privilege: string;
65
}

‎Projects/BooksLibrary/src/seed.data/role.privileges.json‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,10 @@
1+
[
2+
{
3+
"Role": "User",
4+
"Privileges": ["User.getById"]
5+
},
6+
{
7+
"Role": "Admin",
8+
"Privileges": ["User.getById", "User.create"]
9+
}
10+
]

‎Projects/BooksLibrary/src/startup/seeder.ts‎

Lines changed: 37 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1,25 +1,61 @@
11
import { Logger } from 'common/logger';
2+
import { IRolePrivilegeRepo } from 'database/repository.interfaces/role.privilege.repo.interface';
23
import { IUserRepo } from 'database/repository.interfaces/user.repo.intrerface';
34
import { IRoleRepo } from 'database/repository.interfaces/user.role.repo.interface';
45
import { RoleDto } from 'domain.types/role/role.dto';
56
import { Roles } from 'domain.types/role/role.types';
67
import { UserDomainModel } from 'domain.types/user/user.domain.model';
78
import { UserDetailsDto } from 'domain.types/user/user.dto';
89
import { inject, injectable } from 'tsyringe';
10+
import * as RolePrivilegesList from '../seed.data/role.privileges.json';
911

1012
@injectable()
1113
export class Seeder {
12-
constructor(@inject('IUserRepo') private _userRepo: IUserRepo, @inject('IRoleRepo') private _roleRepo: IRoleRepo) {}
14+
constructor(
15+
@inject('IUserRepo') private _userRepo: IUserRepo,
16+
@inject('IRolePrivilegeRepo') private _rolePrivilegeRepo: IRolePrivilegeRepo,
17+
@inject('IRoleRepo') private _roleRepo: IRoleRepo
18+
) {}
1319

1420
public init = async (): Promise<void> => {
1521
try {
1622
await this.seedDefaultRoles();
1723
await this.seedDefaultAdmin();
24+
await this.seedRolePrivileges();
1825
} catch (error) {
1926
Logger.instance().log(error.message);
2027
}
2128
};
2229

30+
private seedRolePrivileges = async () => {
31+
const rolePrivileges = await this._rolePrivilegeRepo.search();
32+
if (rolePrivileges.length > 0) {
33+
return;
34+
}
35+
try {
36+
const arr = RolePrivilegesList['default'];
37+
for (let i = 0; i < arr.length; i++) {
38+
const rp = arr[i];
39+
const roleName = rp['Role'];
40+
const privileges = rp['Privileges'];
41+
42+
const role = await this._roleRepo.getByName(roleName);
43+
if (role == null) {
44+
continue;
45+
}
46+
for (const p of privileges) {
47+
await this._rolePrivilegeRepo.create({
48+
RoleId: role.id,
49+
Privilege: p,
50+
});
51+
}
52+
}
53+
} catch (error) {
54+
Logger.instance().log('Error occurred while seeding role-privileges!');
55+
}
56+
Logger.instance().log('Seeded role-privileges successfully!');
57+
};
58+
2359
seedDefaultAdmin = async () => {
2460
const adminRole: RoleDto = await this._roleRepo.getByName(Roles.Admin);
2561
const admins: UserDetailsDto[] = await this._userRepo.findUsersByRoleId(adminRole.id);

0 commit comments

Comments
 (0)