Merge branch 'RolesAndPermissionsMatrix' into dev

AsbCloudApp/Data/PermissionDto.cs

@@ -0,0 +1,9 @@
+namespace AsbCloudApp.Data
+{
+    public class PermissionDto
+    {
+        public int IdUserRole { get; set; }
+        public int IdPermission { get; set; }
+        public int PermissionValue { get; set; }
+    }
+}

AsbCloudApp/Data/PermissionInfoDto.cs

@@ -0,0 +1,12 @@
+using System.Collections.Generic;
+
+namespace AsbCloudApp.Data
+{
+    public class PermissionInfoDto : IId
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+        public string Description { get; set; }
+        public IDictionary<int, string> BitDescription { get; set; }
+    }
+}

AsbCloudApp/Data/UserBaseDto.cs

@@ -4,8 +4,6 @@
     {
         public string Login { get; set; }
 
-        public int? Level { get; set; }
-
         public string Name { get; set; }
 
         public string Surname { get; set; }

AsbCloudApp/Data/UserDto.cs

@@ -6,8 +6,6 @@
 
         public int? IdCompany { get; set; }
 
-        public int? IdRole { get; set; }
-
         public string Password { get; set; }
 
         public CompanyDto Company { get; set; }

AsbCloudApp/Data/UserRoleDto.cs

@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using System.Text.Json.Serialization;
 
 namespace AsbCloudApp.Data
 {
@@ -6,6 +7,10 @@ namespace AsbCloudApp.Data
     {
         public int Id { get; set; }
         public string Caption { get; set; }
+        public int? IdParent { get; set; }
+        public int IdType { get; set; }
+        public IEnumerable<PermissionDto> Permissions { get; set; }
+        [JsonIgnore]
         public virtual ICollection<UserDto> Users { get; set; }
     }
 }

AsbCloudApp/Data/UserTokenDto.cs

@@ -1,10 +1,13 @@
-namespace AsbCloudApp.Data
+using System.Collections.Generic;
+
+namespace AsbCloudApp.Data
 {
     public class UserTokenDto : UserBaseDto
     {
         public int Id { get; set; }
         public string CompanyName { get; set; }
-        public string RoleName { get; set; }
+        public IEnumerable<string> RoleNames { get; set; }
+        public IDictionary<string, int> Permissions { get; set; }
         public string Token { get; set; }
     }
 }

AsbCloudApp/Services/ICrudService.cs

@@ -8,13 +8,12 @@ namespace AsbCloudApp.Services
         where Tdto : Data.IId
     {
         List<string> Incledes { get; }
-        Task<int> DeleteAsync(int id, CancellationToken token = default);
-        Task<int> DeleteAsync(IEnumerable<int> ids, CancellationToken token = default);
-        Task<IEnumerable<Tdto>> GetAllAsync(CancellationToken token = default);
-        Task<Tdto> GetAsync(int id, CancellationToken token = default);
-        Task<Data.PaginationContainer<Tdto>> GetPageAsync(int skip = 0, int take = 32, CancellationToken token = default);
         Task<int> InsertAsync(Tdto newItem, CancellationToken token = default);
         Task<int> InsertRangeAsync(IEnumerable<Tdto> newItems, CancellationToken token = default);
+        Task<IEnumerable<Tdto>> GetAllAsync(CancellationToken token = default);
+        Task<Tdto> GetAsync(int id, CancellationToken token = default);
         Task<int> UpdateAsync(int id, Tdto item, CancellationToken token = default);
+        Task<int> DeleteAsync(int id, CancellationToken token = default);
+        Task<int> DeleteAsync(IEnumerable<int> ids, CancellationToken token = default);
     }
 }

AsbCloudApp/Services/IPaginationService.cs

@@ -0,0 +1,10 @@
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace AsbCloudApp.Services
+{
+    public interface IPaginationService<Tdto>
+    {
+        Task<Data.PaginationContainer<Tdto>> GetPageAsync(int skip = 0, int take = 32, CancellationToken token = default);
+    }
+}

AsbCloudApp/Services/IPermissionService.cs

@@ -0,0 +1,16 @@
+using AsbCloudApp.Data;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace AsbCloudApp.Services
+{
+    public interface IPermissionService
+    {
+        Task<IEnumerable<PermissionDto>> GetByIdRoleAsync(int idRole, CancellationToken token);
+        Task<int> InsertRangeAsync(IEnumerable<PermissionDto> dtos, CancellationToken token);
+        Task<int> UpdateAsync(PermissionDto dto, CancellationToken token);
+        Task<int> DeleteAsync(int idUserRole, int idPermission, CancellationToken token);
+        Task<int> DeleteAllByRoleAsync(int idUserRole, CancellationToken token);
+    }
+}

AsbCloudApp/Services/IUserRoleService.cs

@@ -0,0 +1,8 @@
+using AsbCloudApp.Data;
+
+namespace AsbCloudApp.Services
+{
+    public interface IUserRoleService: ICrudService<UserRoleDto>
+    {
+    }
+}

AsbCloudApp/Services/IWellCompositeService.cs

@@ -1,8 +1,5 @@
 using AsbCloudApp.Data;
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 

AsbCloudDb/Migrations/20211123130153_Add_UserRoles_Permissions.cs

@@ -0,0 +1,184 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace AsbCloudDb.Migrations
+{
+    public partial class Add_UserRoles_Permissions : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_t_user_t_user_role_id_role",
+                table: "t_user");
+
+            migrationBuilder.DropIndex(
+                name: "IX_t_user_id_role",
+                table: "t_user");
+
+            migrationBuilder.DropColumn(
+                name: "id_role",
+                table: "t_user");
+
+            migrationBuilder.DropColumn(
+                name: "level",
+                table: "t_user");
+
+            migrationBuilder.AddColumn<int>(
+                name: "id_parent",
+                table: "t_user_role",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                comment: "От какой роли унаследована данная роль");
+
+            migrationBuilder.AddColumn<int>(
+                name: "role_type",
+                table: "t_user_role",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                comment: "0-роль из стандартной матрицы, \n1-специальная роль для какого-либо пользователя");
+
+            migrationBuilder.CreateTable(
+                name: "t_permission",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    caption = table.Column<string>(type: "character varying(255)", maxLength: 255, nullable: true, comment: "Название"),
+                    type = table.Column<int>(type: "integer", nullable: false, comment: "1-чтение, 2-запись, 3-чтение и запись")
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_t_permission", x => x.id);
+                },
+                comment: "Разрешения на доступ к данным");
+
+            migrationBuilder.CreateTable(
+                name: "t_relation_user_user_role",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    id_user = table.Column<int>(type: "integer", nullable: false),
+                    id_user_role = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_t_relation_user_user_role", x => x.id);
+                    table.ForeignKey(
+                        name: "FK_t_relation_user_user_role_t_user_id_user",
+                        column: x => x.id_user,
+                        principalTable: "t_user",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_t_relation_user_user_role_t_user_role_id_user_role",
+                        column: x => x.id_user_role,
+                        principalTable: "t_user_role",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                },
+                comment: "Отношение пользователей и ролей");
+
+            migrationBuilder.CreateTable(
+                name: "t_relation_user_role_permission",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    id_user_role = table.Column<int>(type: "integer", nullable: false),
+                    id_permission = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_t_relation_user_role_permission", x => x.id);
+                    table.ForeignKey(
+                        name: "FK_t_relation_user_role_permission_t_permission_id_permission",
+                        column: x => x.id_permission,
+                        principalTable: "t_permission",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_t_relation_user_role_permission_t_user_role_id_user_role",
+                        column: x => x.id_user_role,
+                        principalTable: "t_user_role",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                },
+                comment: "Отношение ролей пользователей и разрешений доступа");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_relation_user_role_permission_id_permission",
+                table: "t_relation_user_role_permission",
+                column: "id_permission");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_relation_user_role_permission_id_user_role",
+                table: "t_relation_user_role_permission",
+                column: "id_user_role");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_relation_user_user_role_id_user",
+                table: "t_relation_user_user_role",
+                column: "id_user");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_relation_user_user_role_id_user_role",
+                table: "t_relation_user_user_role",
+                column: "id_user_role");
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "t_relation_user_role_permission");
+
+            migrationBuilder.DropTable(
+                name: "t_relation_user_user_role");
+
+            migrationBuilder.DropTable(
+                name: "t_permission");
+
+            migrationBuilder.DropColumn(
+                name: "id_parent",
+                table: "t_user_role");
+
+            migrationBuilder.DropColumn(
+                name: "role_type",
+                table: "t_user_role");
+
+            migrationBuilder.AddColumn<int>(
+                name: "id_role",
+                table: "t_user",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.AddColumn<int>(
+                name: "level",
+                table: "t_user",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.UpdateData(
+                table: "t_user",
+                keyColumn: "id",
+                keyValue: 1,
+                columns: new[] { "id_role", "level" },
+                values: new object[] { 1, 2147483647 });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_user_id_role",
+                table: "t_user",
+                column: "id_role");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_t_user_t_user_role_id_role",
+                table: "t_user",
+                column: "id_role",
+                principalTable: "t_user_role",
+                principalColumn: "id",
+                onDelete: ReferentialAction.Restrict);
+        }
+    }
+}

AsbCloudDb/Migrations/20211129122956_Fixed_Role_Permissions_Value.cs

@@ -0,0 +1,223 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace AsbCloudDb.Migrations
+{
+    public partial class Fixed_Role_Permissions_Value : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_t_relation_user_user_role",
+                table: "t_relation_user_user_role");
+
+            migrationBuilder.DropIndex(
+                name: "IX_t_relation_user_user_role_id_user",
+                table: "t_relation_user_user_role");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_t_relation_user_role_permission",
+                table: "t_relation_user_role_permission");
+
+            migrationBuilder.DropIndex(
+                name: "IX_t_relation_user_role_permission_id_user_role",
+                table: "t_relation_user_role_permission");
+
+            migrationBuilder.DropColumn(
+                name: "id",
+                table: "t_relation_user_user_role");
+
+            migrationBuilder.DropColumn(
+                name: "type",
+                table: "t_permission");
+
+            migrationBuilder.RenameColumn(
+                name: "role_type",
+                table: "t_user_role",
+                newName: "id_type");
+
+            migrationBuilder.RenameColumn(
+                name: "id",
+                table: "t_relation_user_role_permission",
+                newName: "permission_value");
+
+            migrationBuilder.RenameColumn(
+                name: "caption",
+                table: "t_permission",
+                newName: "name");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "id_parent",
+                table: "t_user_role",
+                type: "integer",
+                nullable: true,
+                comment: "От какой роли унаследована данная роль",
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldComment: "От какой роли унаследована данная роль");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "permission_value",
+                table: "t_relation_user_role_permission",
+                type: "integer",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer")
+                .OldAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            migrationBuilder.AddColumn<string>(
+                name: "bit_description",
+                table: "t_permission",
+                type: "jsonb",
+                nullable: true,
+                comment: "Описание каждого бита разрешений");
+
+            migrationBuilder.AddColumn<string>(
+                name: "description",
+                table: "t_permission",
+                type: "character varying(255)",
+                maxLength: 255,
+                nullable: true,
+                comment: "Краткое описание");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_t_relation_user_user_role",
+                table: "t_relation_user_user_role",
+                columns: new[] { "id_user", "id_user_role" });
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_t_relation_user_role_permission",
+                table: "t_relation_user_role_permission",
+                columns: new[] { "id_user_role", "id_permission" });
+
+            migrationBuilder.InsertData(
+                table: "t_relation_user_user_role",
+                columns: new[] { "id_user", "id_user_role" },
+                values: new object[] { 1, 2 });
+
+            migrationBuilder.UpdateData(
+                table: "t_user_role",
+                keyColumn: "id",
+                keyValue: 1,
+                column: "id_parent",
+                value: null);
+
+            migrationBuilder.UpdateData(
+                table: "t_user_role",
+                keyColumn: "id",
+                keyValue: 2,
+                column: "id_parent",
+                value: null);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_t_relation_user_user_role",
+                table: "t_relation_user_user_role");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_t_relation_user_role_permission",
+                table: "t_relation_user_role_permission");
+
+            migrationBuilder.DeleteData(
+                table: "t_relation_user_user_role",
+                keyColumns: new[] { "id_user", "id_user_role" },
+                keyValues: new object[] { 1, 2 });
+
+            migrationBuilder.DropColumn(
+                name: "bit_description",
+                table: "t_permission");
+
+            migrationBuilder.DropColumn(
+                name: "description",
+                table: "t_permission");
+
+            migrationBuilder.RenameColumn(
+                name: "id_type",
+                table: "t_user_role",
+                newName: "role_type");
+
+            migrationBuilder.RenameColumn(
+                name: "permission_value",
+                table: "t_relation_user_role_permission",
+                newName: "id");
+
+            migrationBuilder.RenameColumn(
+                name: "name",
+                table: "t_permission",
+                newName: "caption");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "id_parent",
+                table: "t_user_role",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                comment: "От какой роли унаследована данная роль",
+                oldClrType: typeof(int),
+                oldType: "integer",
+                oldNullable: true,
+                oldComment: "От какой роли унаследована данная роль");
+
+            migrationBuilder.AddColumn<int>(
+                name: "id",
+                table: "t_relation_user_user_role",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0)
+                .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            migrationBuilder.AlterColumn<int>(
+                name: "id",
+                table: "t_relation_user_role_permission",
+                type: "integer",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer")
+                .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            migrationBuilder.AddColumn<int>(
+                name: "type",
+                table: "t_permission",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0,
+                comment: "1-чтение, 2-запись, 3-чтение и запись");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_t_relation_user_user_role",
+                table: "t_relation_user_user_role",
+                column: "id");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_t_relation_user_role_permission",
+                table: "t_relation_user_role_permission",
+                column: "id");
+
+            migrationBuilder.UpdateData(
+                table: "t_user_role",
+                keyColumn: "id",
+                keyValue: 1,
+                column: "id_parent",
+                value: 0);
+
+            migrationBuilder.UpdateData(
+                table: "t_user_role",
+                keyColumn: "id",
+                keyValue: 2,
+                column: "id_parent",
+                value: 0);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_relation_user_user_role_id_user",
+                table: "t_relation_user_user_role",
+                column: "id_user");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_relation_user_role_permission_id_user_role",
+                table: "t_relation_user_role_permission",
+                column: "id_user_role");
+        }
+    }
+}

AsbCloudDb/Migrations/20211130121716_Renamed_Permissions_Tables.cs

@@ -0,0 +1,214 @@
+using System.Collections.Generic;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+namespace AsbCloudDb.Migrations
+{
+    public partial class Renamed_Permissions_Tables : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "t_relation_user_role_permission");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_t_permission",
+                table: "t_permission");
+
+            migrationBuilder.DropColumn(
+                name: "bit_description",
+                table: "t_permission");
+
+            migrationBuilder.DropColumn(
+                name: "description",
+                table: "t_permission");
+
+            migrationBuilder.DropColumn(
+                name: "name",
+                table: "t_permission");
+
+            migrationBuilder.RenameColumn(
+                name: "id",
+                table: "t_permission",
+                newName: "permission_value");
+
+            migrationBuilder.AlterTable(
+                name: "t_permission",
+                comment: "Отношение ролей пользователей и разрешений доступа",
+                oldComment: "Разрешения на доступ к данным");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "permission_value",
+                table: "t_permission",
+                type: "integer",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer")
+                .OldAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            migrationBuilder.AddColumn<int>(
+                name: "id_user_role",
+                table: "t_permission",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "id_permission",
+                table: "t_permission",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_t_permission",
+                table: "t_permission",
+                columns: new[] { "id_user_role", "id_permission" });
+
+            migrationBuilder.CreateTable(
+                name: "t_permission_info",
+                columns: table => new
+                {
+                    id = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    name = table.Column<string>(type: "character varying(255)", maxLength: 255, nullable: true, comment: "Название"),
+                    description = table.Column<string>(type: "character varying(255)", maxLength: 255, nullable: true, comment: "Краткое описание"),
+                    bit_description = table.Column<IDictionary<int, string>>(type: "jsonb", nullable: true, comment: "Описание каждого бита разрешений")
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_t_permission_info", x => x.id);
+                },
+                comment: "Разрешения на доступ к данным");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_permission_id_permission",
+                table: "t_permission",
+                column: "id_permission");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_t_permission_t_permission_info_id_permission",
+                table: "t_permission",
+                column: "id_permission",
+                principalTable: "t_permission_info",
+                principalColumn: "id",
+                onDelete: ReferentialAction.Cascade);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_t_permission_t_user_role_id_user_role",
+                table: "t_permission",
+                column: "id_user_role",
+                principalTable: "t_user_role",
+                principalColumn: "id",
+                onDelete: ReferentialAction.Cascade);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_t_permission_t_permission_info_id_permission",
+                table: "t_permission");
+
+            migrationBuilder.DropForeignKey(
+                name: "FK_t_permission_t_user_role_id_user_role",
+                table: "t_permission");
+
+            migrationBuilder.DropTable(
+                name: "t_permission_info");
+
+            migrationBuilder.DropPrimaryKey(
+                name: "PK_t_permission",
+                table: "t_permission");
+
+            migrationBuilder.DropIndex(
+                name: "IX_t_permission_id_permission",
+                table: "t_permission");
+
+            migrationBuilder.DropColumn(
+                name: "id_user_role",
+                table: "t_permission");
+
+            migrationBuilder.DropColumn(
+                name: "id_permission",
+                table: "t_permission");
+
+            migrationBuilder.RenameColumn(
+                name: "permission_value",
+                table: "t_permission",
+                newName: "id");
+
+            migrationBuilder.AlterTable(
+                name: "t_permission",
+                comment: "Разрешения на доступ к данным",
+                oldComment: "Отношение ролей пользователей и разрешений доступа");
+
+            migrationBuilder.AlterColumn<int>(
+                name: "id",
+                table: "t_permission",
+                type: "integer",
+                nullable: false,
+                oldClrType: typeof(int),
+                oldType: "integer")
+                .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+            migrationBuilder.AddColumn<string>(
+                name: "bit_description",
+                table: "t_permission",
+                type: "jsonb",
+                nullable: true,
+                comment: "Описание каждого бита разрешений");
+
+            migrationBuilder.AddColumn<string>(
+                name: "description",
+                table: "t_permission",
+                type: "character varying(255)",
+                maxLength: 255,
+                nullable: true,
+                comment: "Краткое описание");
+
+            migrationBuilder.AddColumn<string>(
+                name: "name",
+                table: "t_permission",
+                type: "character varying(255)",
+                maxLength: 255,
+                nullable: true,
+                comment: "Название");
+
+            migrationBuilder.AddPrimaryKey(
+                name: "PK_t_permission",
+                table: "t_permission",
+                column: "id");
+
+            migrationBuilder.CreateTable(
+                name: "t_relation_user_role_permission",
+                columns: table => new
+                {
+                    id_user_role = table.Column<int>(type: "integer", nullable: false),
+                    id_permission = table.Column<int>(type: "integer", nullable: false),
+                    permission_value = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_t_relation_user_role_permission", x => new { x.id_user_role, x.id_permission });
+                    table.ForeignKey(
+                        name: "FK_t_relation_user_role_permission_t_permission_id_permission",
+                        column: x => x.id_permission,
+                        principalTable: "t_permission",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                    table.ForeignKey(
+                        name: "FK_t_relation_user_role_permission_t_user_role_id_user_role",
+                        column: x => x.id_user_role,
+                        principalTable: "t_user_role",
+                        principalColumn: "id",
+                        onDelete: ReferentialAction.Cascade);
+                },
+                comment: "Отношение ролей пользователей и разрешений доступа");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_t_relation_user_role_permission_id_permission",
+                table: "t_relation_user_role_permission",
+                column: "id_permission");
+        }
+    }
+}

AsbCloudDb/Migrations/20211130122321_Renamed_PermissionCollections.cs

@@ -0,0 +1,17 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace AsbCloudDb.Migrations
+{
+    public partial class Renamed_PermissionCollections : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

AsbCloudDb/Migrations/20211201105010_Renamed_Permission_Role_Files.cs

@@ -0,0 +1,17 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace AsbCloudDb.Migrations
+{
+    public partial class Renamed_Permission_Role_Files : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+
+        }
+    }
+}

AsbCloudDb/Migrations/AsbCloudDbContextModelSnapshot.cs

@@ -681,6 +681,63 @@ namespace AsbCloudDb.Migrations
                         });
                 });
 
+            modelBuilder.Entity("AsbCloudDb.Model.Permission", b =>
+                {
+                    b.Property<int>("IdUserRole")
+                        .HasColumnType("integer")
+                        .HasColumnName("id_user_role");
+
+                    b.Property<int>("IdPermission")
+                        .HasColumnType("integer")
+                        .HasColumnName("id_permission");
+
+                    b.Property<int>("PermissionValue")
+                        .HasColumnType("integer")
+                        .HasColumnName("permission_value");
+
+                    b.HasKey("IdUserRole", "IdPermission");
+
+                    b.HasIndex("IdPermission");
+
+                    b.ToTable("t_permission");
+
+                    b
+                        .HasComment("Отношение ролей пользователей и разрешений доступа");
+                });
+
+            modelBuilder.Entity("AsbCloudDb.Model.PermissionInfo", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("integer")
+                        .HasColumnName("id")
+                        .HasAnnotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn);
+
+                    b.Property<IDictionary<int, string>>("BitDescription")
+                        .HasColumnType("jsonb")
+                        .HasColumnName("bit_description")
+                        .HasComment("Описание каждого бита разрешений");
+
+                    b.Property<string>("Description")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)")
+                        .HasColumnName("description")
+                        .HasComment("Краткое описание");
+
+                    b.Property<string>("Name")
+                        .HasMaxLength(255)
+                        .HasColumnType("character varying(255)")
+                        .HasColumnName("name")
+                        .HasComment("Название");
+
+                    b.HasKey("Id");
+
+                    b.ToTable("t_permission_info");
+
+                    b
+                        .HasComment("Разрешения на доступ к данным");
+                });
+
             modelBuilder.Entity("AsbCloudDb.Model.RelationCompanyWell", b =>
                 {
                     b.Property<int>("IdCompany")
@@ -701,6 +758,33 @@ namespace AsbCloudDb.Migrations
                         .HasComment("отношение скважин и компаний");
                 });
 
+            modelBuilder.Entity("AsbCloudDb.Model.RelationUserUserRole", b =>
+                {
+                    b.Property<int>("IdUser")
+                        .HasColumnType("integer")
+                        .HasColumnName("id_user");
+
+                    b.Property<int>("IdUserRole")
+                        .HasColumnType("integer")
+                        .HasColumnName("id_user_role");
+
+                    b.HasKey("IdUser", "IdUserRole");
+
+                    b.HasIndex("IdUserRole");
+
+                    b.ToTable("t_relation_user_user_role");
+
+                    b
+                        .HasComment("Отношение пользователей и ролей");
+
+                    b.HasData(
+                        new
+                        {
+                            IdUser = 1,
+                            IdUserRole = 2
+                        });
+                });
+
             modelBuilder.Entity("AsbCloudDb.Model.ReportProperty", b =>
                 {
                     b.Property<int>("Id")
@@ -1603,14 +1687,6 @@ namespace AsbCloudDb.Migrations
                         .HasColumnType("integer")
                         .HasColumnName("id_company");
 
-                    b.Property<int?>("IdRole")
-                        .HasColumnType("integer")
-                        .HasColumnName("id_role");
-
-                    b.Property<int?>("Level")
-                        .HasColumnType("integer")
-                        .HasColumnName("level");
-
                     b.Property<string>("Login")
                         .HasMaxLength(255)
                         .HasColumnType("character varying(255)")
@@ -1661,8 +1737,6 @@ namespace AsbCloudDb.Migrations
 
                     b.HasIndex("IdCompany");
 
-                    b.HasIndex("IdRole");
-
                     b.HasIndex("Login")
                         .IsUnique();
 
@@ -1676,8 +1750,6 @@ namespace AsbCloudDb.Migrations
                         {
                             Id = 1,
                             IdCompany = 1,
-                            IdRole = 1,
-                            Level = 2147483647,
                             Login = "dev",
                             Name = "Разработчик",
                             PasswordHash = "Vlcj|4fa529103dde7ff72cfe76185f344d4aa87931f8e1b2044e8a7739947c3d18923464eaad93843e4f809c5e126d013072"
@@ -1698,6 +1770,16 @@ namespace AsbCloudDb.Migrations
                         .HasColumnName("caption")
                         .HasComment("Название");
 
+                    b.Property<int?>("IdParent")
+                        .HasColumnType("integer")
+                        .HasColumnName("id_parent")
+                        .HasComment("От какой роли унаследована данная роль");
+
+                    b.Property<int>("IdType")
+                        .HasColumnType("integer")
+                        .HasColumnName("id_type")
+                        .HasComment("0-роль из стандартной матрицы, \n1-специальная роль для какого-либо пользователя");
+
                     b.HasKey("Id");
 
                     b.ToTable("t_user_role");
@@ -1709,12 +1791,14 @@ namespace AsbCloudDb.Migrations
                         new
                         {
                             Id = 1,
-                            Caption = "Администратор"
+                            Caption = "Администратор",
+                            IdType = 0
                         },
                         new
                         {
                             Id = 2,
-                            Caption = "Пользователь"
+                            Caption = "Пользователь",
+                            IdType = 0
                         });
                 });
 
@@ -2505,6 +2589,25 @@ namespace AsbCloudDb.Migrations
                     b.Navigation("Well");
                 });
 
+            modelBuilder.Entity("AsbCloudDb.Model.Permission", b =>
+                {
+                    b.HasOne("AsbCloudDb.Model.PermissionInfo", "PermissionInfo")
+                        .WithMany("Permissions")
+                        .HasForeignKey("IdPermission")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("AsbCloudDb.Model.UserRole", "UserRole")
+                        .WithMany("Permissions")
+                        .HasForeignKey("IdUserRole")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("PermissionInfo");
+
+                    b.Navigation("UserRole");
+                });
+
             modelBuilder.Entity("AsbCloudDb.Model.RelationCompanyWell", b =>
                 {
                     b.HasOne("AsbCloudDb.Model.Company", "Company")
@@ -2526,6 +2629,25 @@ namespace AsbCloudDb.Migrations
                     b.Navigation("Well");
                 });
 
+            modelBuilder.Entity("AsbCloudDb.Model.RelationUserUserRole", b =>
+                {
+                    b.HasOne("AsbCloudDb.Model.User", "User")
+                        .WithMany("RelationUsersUserRoles")
+                        .HasForeignKey("IdUser")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.HasOne("AsbCloudDb.Model.UserRole", "UserRole")
+                        .WithMany("RelationUsersUserRoles")
+                        .HasForeignKey("IdUserRole")
+                        .OnDelete(DeleteBehavior.Cascade)
+                        .IsRequired();
+
+                    b.Navigation("User");
+
+                    b.Navigation("UserRole");
+                });
+
             modelBuilder.Entity("AsbCloudDb.Model.ReportProperty", b =>
                 {
                     b.HasOne("AsbCloudDb.Model.FileInfo", "File")
@@ -2653,13 +2775,7 @@ namespace AsbCloudDb.Migrations
                         .HasConstraintName("t_user_t_company_id_fk")
                         .OnDelete(DeleteBehavior.SetNull);
 
-                    b.HasOne("AsbCloudDb.Model.UserRole", "Role")
-                        .WithMany("Users")
-                        .HasForeignKey("IdRole");
-
                     b.Navigation("Company");
-
-                    b.Navigation("Role");
                 });
 
             modelBuilder.Entity("AsbCloudDb.Model.Well", b =>
@@ -2775,6 +2891,11 @@ namespace AsbCloudDb.Migrations
                     b.Navigation("Measures");
                 });
 
+            modelBuilder.Entity("AsbCloudDb.Model.PermissionInfo", b =>
+                {
+                    b.Navigation("Permissions");
+                });
+
             modelBuilder.Entity("AsbCloudDb.Model.Telemetry", b =>
                 {
                     b.Navigation("Analysis");
@@ -2797,11 +2918,15 @@ namespace AsbCloudDb.Migrations
                     b.Navigation("FileMarks");
 
                     b.Navigation("Files");
+
+                    b.Navigation("RelationUsersUserRoles");
                 });
 
             modelBuilder.Entity("AsbCloudDb.Model.UserRole", b =>
                 {
-                    b.Navigation("Users");
+                    b.Navigation("Permissions");
+
+                    b.Navigation("RelationUsersUserRoles");
                 });
 
             modelBuilder.Entity("AsbCloudDb.Model.Well", b =>

AsbCloudDb/Model/AsbCloudDbContext.cs

@@ -39,6 +39,9 @@ namespace AsbCloudDb.Model
         public virtual DbSet<WellType> WellTypes { get; set; }
         public virtual DbSet<DrillParams> DrillParams { get; set; }
         public virtual DbSet<DrillFlowChart> DrillFlowChart { get; set; }
+        public virtual DbSet<RelationUserUserRole> RelationUserUserRoles { get; set; }
+        public virtual DbSet<Permission> Permissions { get; set; }
+        public virtual DbSet<PermissionInfo> PermissionInfos { get; set; }
 
         //var options = new DbContextOptionsBuilder<AsbCloudDbContext>()
         //    .UseNpgsql("Host=localhost;Database=postgres;Username=postgres;Password=q;Persist Security Info=True")
@@ -245,6 +248,16 @@ namespace AsbCloudDb.Model
                     .OnDelete(DeleteBehavior.Cascade)
                     .HasConstraintName("t_file_mark_t_file_info_fk");
             });
+            
+            modelBuilder.Entity<RelationUserUserRole>(entity =>
+            {
+                entity.HasKey(e => new { e.IdUser, e.IdUserRole });
+            });
+            
+            modelBuilder.Entity<Permission>(entity =>
+            {
+                entity.HasKey(e => new { e.IdUserRole, e.IdPermission });
+            });
 
             FillData(modelBuilder);
         }
@@ -265,14 +278,19 @@ namespace AsbCloudDb.Model
                     new User{
                         Id = 1,
                         IdCompany = 1,
-                        IdRole = 1,
-                        Level = int.MaxValue,
                         Login = "dev",
                         PasswordHash = "Vlcj|4fa529103dde7ff72cfe76185f344d4aa87931f8e1b2044e8a7739947c3d18923464eaad93843e4f809c5e126d013072", // dev
                         Name = "Разработчик",
                     },
                 });
             });
+            
+            modelBuilder.Entity<RelationUserUserRole>(entity =>
+            {
+                entity.HasData(new List<RelationUserUserRole>{
+                    new RelationUserUserRole{ IdUser = 1, IdUserRole = 2, },
+                });
+            });
 
             modelBuilder.Entity<Company>(entity =>
             {
@@ -438,7 +456,8 @@ namespace AsbCloudDb.Model
 
         public IQueryable<User> GetUsersByLogin(string login)
             => Users
-            .Include(e => e.Role)
+            .Include(e => e.RelationUsersUserRoles)
+                .ThenInclude(r => r.UserRole)
             .Include(e => e.Company)
             .Where(e => e.Login == login);
 

AsbCloudDb/Model/IAsbCloudDbContext.cs

@@ -36,6 +36,9 @@ namespace AsbCloudDb.Model
         DbSet<TelemetryDataSpin> TelemetryDataSpin { get; set; }
         DbSet<DrillParams> DrillParams { get; set; }
         DbSet<DrillFlowChart> DrillFlowChart { get; set; }
+        DbSet<RelationUserUserRole> RelationUserUserRoles { get; set; }
+        DbSet<Permission> Permissions { get; set; }
+        DbSet<PermissionInfo> PermissionInfos { get; set; }
 
         DatabaseFacade Database { get; }
 

AsbCloudDb/Model/Permission.cs

@@ -0,0 +1,26 @@
+using Microsoft.EntityFrameworkCore;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace AsbCloudDb.Model
+{
+    [Table("t_permission"), Comment("Отношение ролей пользователей и разрешений доступа")]
+    public class Permission
+    {
+        [Column("id_user_role")]
+        public int IdUserRole { get; set; }
+
+        [Column("id_permission")]
+        public int IdPermission { get; set; }
+        
+        [Column("permission_value")]
+        public int PermissionValue { get; set; }
+
+        [ForeignKey(nameof(IdUserRole))]
+        [InverseProperty(nameof(Model.UserRole.Permissions))]
+        public virtual UserRole UserRole { get; set; }
+
+        [ForeignKey(nameof(IdPermission))]
+        [InverseProperty(nameof(Model.PermissionInfo.Permissions))]
+        public virtual PermissionInfo PermissionInfo { get; set; }
+    }
+}

AsbCloudDb/Model/PermissionInfo.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore;
+using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+
+namespace AsbCloudDb.Model
+{
+    [Table("t_permission_info"), Comment("Разрешения на доступ к данным")]
+    public class PermissionInfo : IId
+    {
+        [Key]
+        [Column("id")]
+        public int Id { get; set; }
+        
+        [Column("name"), Comment("Название")]
+        [StringLength(255)]
+        public string Name { get; set; }
+        
+        [Column("description"), Comment("Краткое описание")]
+        [StringLength(255)]
+        public string Description { get; set; }
+        
+        [Column("bit_description", TypeName = "jsonb"), Comment("Описание каждого бита разрешений")]
+        public IDictionary<int, string> BitDescription { get; set; }
+        
+        [InverseProperty(nameof(Permission.PermissionInfo))]
+        public virtual ICollection<Permission> Permissions { get; set; }
+    }
+}

AsbCloudDb/Model/RelationUserUserRole.cs

@@ -0,0 +1,24 @@
+using Microsoft.EntityFrameworkCore;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.ComponentModel.DataAnnotations;
+
+namespace AsbCloudDb.Model
+{
+    [Table("t_relation_user_user_role"), Comment("Отношение пользователей и ролей")]
+    public class RelationUserUserRole
+    {
+        [Column("id_user")]
+        public int IdUser { get; set; }
+
+        [Column("id_user_role")]
+        public int IdUserRole { get; set; }
+
+        [ForeignKey(nameof(IdUser))]
+        [InverseProperty(nameof(Model.User.RelationUsersUserRoles))]
+        public virtual User User { get; set; }
+
+        [ForeignKey(nameof(IdUserRole))]
+        [InverseProperty(nameof(Model.UserRole.RelationUsersUserRoles))]
+        public virtual UserRole UserRole { get; set; }
+    }
+}

AsbCloudDb/Model/User.cs

@@ -17,9 +17,6 @@ namespace AsbCloudDb.Model
         [Column("id_company")]
         public int? IdCompany { get; set; }
 
-        [Column("id_role")]
-        public int? IdRole { get; set; }
-
         [Column("login")]
         [StringLength(255)]
         public string Login { get; set; }
@@ -31,9 +28,6 @@ namespace AsbCloudDb.Model
         [Column("state"), Comment("состояние:\n100 - удален")]
         public short? State { get; set; }
 
-        [Column("level")]
-        public int? Level { get; set; }
-
         [Column("name"), Comment("имя")]
         [StringLength(255)]
         public string Name { get; set; }
@@ -62,12 +56,10 @@ namespace AsbCloudDb.Model
         [ForeignKey(nameof(IdCompany))]
         [InverseProperty(nameof(Model.Company.Users))]
         public virtual Company Company { get; set; }
-
+        
-        [ForeignKey(nameof(IdRole))]
+        [InverseProperty(nameof(RelationUserUserRole.User))]
-        [InverseProperty(nameof(Model.UserRole.Users))]
+        public virtual ICollection<RelationUserUserRole> RelationUsersUserRoles { get; set; }
-        public virtual UserRole Role { get; set; }
+        
-
-
         [InverseProperty(nameof(FileInfo.Author))]
         public virtual ICollection<FileInfo> Files { get; set; }
         

AsbCloudDb/Model/UserRole.cs

@@ -9,11 +9,6 @@ namespace AsbCloudDb.Model
     [Table("t_user_role"), Comment("Роли пользователей в системе")]
     public class UserRole : IId
     {
-        public UserRole()
-        {
-            Users = new HashSet<User>();
-        }
-
         [Key]
         [Column("id")]
         public int Id { get; set; }
@@ -22,7 +17,17 @@ namespace AsbCloudDb.Model
         [StringLength(255)]
         public string Caption { get; set; }
 
-        [InverseProperty(nameof(User.Role))]
+        [Column("id_type"), Comment("0-роль из стандартной матрицы, \n1-специальная роль для какого-либо пользователя")]
-        public virtual ICollection<User> Users { get; set; }
+        public int IdType { get; set; }
+        
+        [Column("id_parent"), Comment("От какой роли унаследована данная роль")]
+        public int? IdParent { get; set; }
+        
+
+        [InverseProperty(nameof(RelationUserUserRole.UserRole))]
+        public virtual ICollection<RelationUserUserRole> RelationUsersUserRoles { get; set; }
+        
+        [InverseProperty(nameof(Permission.UserRole))]
+        public virtual ICollection<Permission> Permissions { get; set; }
     }
 }

AsbCloudDbDemoData/DbDemoDataFiller.cs

@@ -168,6 +168,38 @@ namespace AsbCloudDevOperations
                     new WellOperation { Id = 51329, IdWell = 1, IdWellSectionType = 1, IdCategory = 1026, IdType = 0, DepthEnd = 1400, DateStart = DateTime.Parse("2021-08-27 08:30"), DurationHours = 3.5 },
                     new WellOperation { Id = 76341, IdWell = 1, IdWellSectionType = 1, IdCategory = 1047, IdType = 0, DepthEnd = 1250, DateStart = DateTime.Parse("2021-08-26 11:30"), DurationHours = 3.5 }
                 );
+                
+                demoContext.PermissionInfos.AddRange(
+                    new PermissionInfo()
+                    {
+                        Id = 1,
+                        Name = "test permission",
+                        Description = "some description",
+                        BitDescription = new Dictionary<int, string>() {{0, "some zero bit description"}}
+                    },
+                    new PermissionInfo()
+                        {
+                            Id = 2,
+                            Name = "second test permission",
+                            Description = "some second description",
+                            BitDescription = new Dictionary<int, string>() {{1, "some first bit description"}}
+                        }
+                );
+
+                demoContext.Permissions.AddRange(
+                    new Permission()
+                    {
+                        IdUserRole = 2,
+                        IdPermission = 1,
+                        PermissionValue = 143
+                    },
+                    new Permission()
+                    {
+                        IdUserRole = 2,
+                        IdPermission = 2,
+                        PermissionValue = 12
+                    }
+                );
 
                 int res = demoContext.SaveChanges();
 

AsbCloudInfrastructure/DependencyInjection.cs

@@ -40,35 +40,37 @@ namespace AsbCloudInfrastructure
             services.AddSingleton<IRequerstTrackerService, RequerstTrackerService>();
 
             services.AddTransient<IAuthService, AuthService>();
-            services.AddTransient<IWellService, WellService>();
             services.AddTransient<IClusterService, ClusterService>();
-            services.AddTransient<ITelemetryService, TelemetryService>();
+            services.AddTransient<IDrillFlowChartService, DrillFlowChartService>();
-            services.AddTransient<IMessageService, MessageService>();
-            services.AddTransient<IEventService, EventService>();
-            services.AddTransient<ITelemetryUserService, TelemetryUserService>();
-            services.AddTransient<IReportService, ReportService>();
-            services.AddTransient<ITelemetryAnalyticsService, TelemetryAnalyticsService>();
-            services.AddTransient<IFileService, FileService>();
-            services.AddTransient<IWellOperationService, WellOperationService>();
-            services.AddTransient<IOperationsStatService, OperationsStatService>();
-            services.AddTransient<IWellOperationImportService, WellOperationImportService>();
-            services.AddTransient<IWellCompositeService, WellCompositeService>();
-            services.AddTransient<IMeasureService, MeasureService>();
             services.AddTransient<IDrillingProgramService, DrillingProgramService>();
             services.AddTransient<IDrillParamsService, DrillParamsService>();
-            services.AddTransient<IDrillFlowChartService, DrillFlowChartService>();
+            services.AddTransient<IEventService, EventService>();
-            services.AddTransient<ITimeZoneService, TimeZoneService>();
+            services.AddTransient<IFileService, FileService>();
+            services.AddTransient<IMeasureService, MeasureService>();
+            services.AddTransient<IMessageService, MessageService>();
+            services.AddTransient<IOperationsStatService, OperationsStatService>();
+            services.AddTransient<IPermissionService, PermissionService>();
+            services.AddTransient<IReportService, ReportService>();
             services.AddTransient<ISetpointsService, SetpointsService>();
+            services.AddTransient<ITelemetryAnalyticsService, TelemetryAnalyticsService>();
+            services.AddTransient<ITelemetryService, TelemetryService>();
+            services.AddTransient<ITelemetryUserService, TelemetryUserService>();
+            services.AddTransient<ITimeZoneService, TimeZoneService>();
+            services.AddTransient<IUserRoleService, UserRoleService>();
+            services.AddTransient<IWellService, WellService>();            
+            services.AddTransient<IWellCompositeService, WellCompositeService>();
+            services.AddTransient<IWellOperationImportService, WellOperationImportService>();
+            services.AddTransient<IWellOperationService, WellOperationService>();
 
             // admin crud services:
-            services.AddTransient<ICrudService<DepositDto>, CrudServiceBase<DepositDto, Deposit>>();
-            services.AddTransient<ICrudService<ClusterDto>, CrudServiceBase<ClusterDto, Cluster>>();
             services.AddTransient<ICrudService<WellDto>, CrudServiceBase<WellDto, Well>>();
-            services.AddTransient<ICrudService<CompanyDto>, CrudServiceBase<CompanyDto, Company>>();
             services.AddTransient<ICrudService<UserDto>, CrudServiceBase<UserDto, User>>();
-            services.AddTransient<ICrudService<UserRoleDto>, CrudServiceBase<UserRoleDto, UserRole>>();
             services.AddTransient<ICrudService<TelemetryDto>, CrudServiceBase<TelemetryDto, Telemetry>>();
+            services.AddTransient<ICrudService<PermissionInfoDto>, CrudServiceBase<PermissionInfoDto, PermissionInfo>>();
             services.AddTransient<ICrudService<DrillParamsDto>, DrillParamsService>();
+            services.AddTransient<ICrudService<DepositDto>, CrudServiceBase<DepositDto, Deposit>>();
+            services.AddTransient<ICrudService<CompanyDto>, CrudServiceBase<CompanyDto, Company>>();
+            services.AddTransient<ICrudService<ClusterDto>, CrudServiceBase<ClusterDto, Cluster>>();
 
             // TelemetryData services
             services.AddTransient<ITelemetryDataService<TelemetryDataSaubDto>, TelemetryDataSaubService>();

AsbCloudInfrastructure/Services/AuthService.cs

@@ -12,12 +12,17 @@ using System.Security.Cryptography;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using AsbCloudInfrastructure.Services.Cache;
 
 namespace AsbCloudInfrastructure.Services
 {
     public class AuthService : IAuthService
     {
         private readonly IAsbCloudDbContext db;
+        private readonly CacheTable<UserRole> cacheUserRoles;
+        private readonly CacheTable<RelationUserUserRole> cacheUsersUserRoles;
+        private readonly CacheTable<PermissionInfo> cachePermissions;
+        private readonly CacheTable<Permission> cacheUserRolesPermissions;
 
         public const string issuer = "a";
         public const string audience = "a";
@@ -32,15 +37,19 @@ namespace AsbCloudInfrastructure.Services
         private readonly HashAlgorithm hashAlgoritm;
         private readonly Random rnd;
 
-        public AuthService(IAsbCloudDbContext db)
+        public AuthService(IAsbCloudDbContext db, CacheDb cacheDb)
         {
             this.db = db;
+            cacheUserRoles = cacheDb.GetCachedTable<UserRole>((AsbCloudDbContext)db);
+            cacheUsersUserRoles = cacheDb.GetCachedTable<RelationUserUserRole>((AsbCloudDbContext)db);
+            cachePermissions = cacheDb.GetCachedTable<PermissionInfo>((AsbCloudDbContext)db);
+            cacheUserRolesPermissions = cacheDb.GetCachedTable<Permission>((AsbCloudDbContext)db);
             hashAlgoritm = SHA384.Create();
             rnd = new Random((int)(DateTime.Now.Ticks % 2147480161));
         }
 
         public async Task<UserTokenDto> LoginAsync(string login, string password,
-            CancellationToken token = default)
+            CancellationToken token)
         {
             var (identity, user) = await GetClaimsUserAsync(login, password, token)
                 .ConfigureAwait(false);
@@ -48,15 +57,19 @@ namespace AsbCloudInfrastructure.Services
             if (identity == default || user.State == 0)
                 return null;
 
+            var userRoles = GetUserRoles(user.Id);
+            
+            var roleNames = userRoles.Select(r => r.Caption);
+
             return new UserTokenDto
             {
                 Id = user.Id,
                 Name = user.Name,
                 CompanyName = user.Company.Caption,
-                Level = user.Level,
                 Login = user.Login,
                 Patronymic = user.Patronymic,
-                RoleName = user.Role.Caption,
+                RoleNames = roleNames,
+                Permissions = GetUserPermissions(userRoles),
                 Surname = user.Surname,
                 Token = MakeToken(identity.Claims),
             };
@@ -94,7 +107,6 @@ namespace AsbCloudInfrastructure.Services
             var newUser = new User
             {
                 IdCompany = userDto.IdCompany,
-                IdRole = userDto.IdRole ?? 2, // simple user
                 State = 0,
                 Name = userDto.Name,
                 Surname = userDto.Surname,
@@ -102,15 +114,21 @@ namespace AsbCloudInfrastructure.Services
                 Email = userDto.Email,
                 Phone = userDto.Phone,
                 Position = userDto.Position,
-                Level = userDto.Level,
                 Login = userDto.Login,
                 PasswordHash = salt + ComputeHash(salt, userDto.Password),
             };
 
             db.Users.Add(newUser);
+            
             try
             {
                 db.SaveChanges();
+                db.RelationUserUserRoles.Add(new RelationUserUserRole()
+                {
+                    IdUser = newUser.Id,
+                    IdUserRole = 2
+                });
+                db.SaveChanges();
             }
             catch //(Exception ex)
             {
@@ -159,6 +177,28 @@ namespace AsbCloudInfrastructure.Services
             return new JwtSecurityTokenHandler().WriteToken(jwt);
         }
 
+        private IEnumerable<UserRole> GetUserRoles(int idUser)
+        {
+            var userRolesIds = cacheUsersUserRoles.Where(r =>
+                r.IdUser == idUser).Select(r => r.IdUserRole);
+
+            return cacheUserRoles.Where(r => userRolesIds.Contains(r.Id));
+        }
+
+        private IDictionary<string, int> GetUserPermissions(IEnumerable<UserRole> userRoles)
+        {
+            var rolesIds = userRoles.Select(r => r.Id);
+            var userPermissionsInfo = cacheUserRolesPermissions.Where(p => 
+                rolesIds.Contains(p.IdUserRole))
+                .Select(perm => new { perm.IdPermission, perm.PermissionValue });
+
+            return userPermissionsInfo.Select(p => new
+            {
+                PermissionName = cachePermissions.FirstOrDefault(c => c.Id == p.IdPermission)?.Name,
+                PermissionValue = p.PermissionValue
+            }).ToDictionary(k => k.PermissionName, v => v.PermissionValue);
+        }
+
         private async Task<(ClaimsIdentity Identity, User User)> GetClaimsUserAsync(string login,
             string password, CancellationToken token = default)
         {
@@ -174,13 +214,16 @@ namespace AsbCloudInfrastructure.Services
             if (!CheckPassword(user.PasswordHash, password))
                 return default;
 
+            var userRolesNames = GetUserRoles(user.Id)
+                .Select(r => r.Caption);
+            
             var claims = new List<Claim>
                 {
                     new Claim(claimIdUser, user.Id.ToString()),
                     new Claim(ClaimsIdentity.DefaultNameClaimType, user.Login),
-                    new Claim(ClaimsIdentity.DefaultRoleClaimType, user.Role?.Caption??"GUEST"),
                     new Claim(claimNameidCompany, user.IdCompany.ToString()),
                 };
+
             var claimsIdentity = new ClaimsIdentity(claims, "Token", ClaimsIdentity.DefaultNameClaimType, ClaimsIdentity.DefaultRoleClaimType);
             return (claimsIdentity, user);
         }

AsbCloudInfrastructure/Services/Cache/CacheTable.cs

@@ -14,7 +14,7 @@ namespace AsbCloudInfrastructure.Services.Cache
     {
         private const int semaphoreTimeout = 5_000;
         private static readonly SemaphoreSlim semaphore = new(1);
-        private static readonly TimeSpan minPeriodRefresh = TimeSpan.FromSeconds(5);        
+        private static readonly TimeSpan minPeriodRefresh = TimeSpan.FromSeconds(5);
         private static readonly string nameOfTEntity = typeof(TEntity).Name;
 
         private readonly CacheTableDataStore data;
@@ -37,7 +37,7 @@ namespace AsbCloudInfrastructure.Services.Cache
                         result = result.Include(include);
                     return result;
                 };
-            
+
 
             cached = (List<TEntity>)data.Entities;
             if ((cached.Count == 0) || data.IsObsolete)
@@ -47,7 +47,7 @@ namespace AsbCloudInfrastructure.Services.Cache
         internal CacheTable(DbContext context, CacheTableDataStore data, Func<DbSet<TEntity>, IQueryable<TEntity>> configureDbSet = null)
         {
             this.context = context;
-            this.data = data;            
+            this.data = data;
             this.configureDbSet = configureDbSet;
 
             dbSet = context.Set<TEntity>();
@@ -65,15 +65,17 @@ namespace AsbCloudInfrastructure.Services.Cache
         /// It may be needed to avoid multiple operations like Refresh().
         /// </summary>
         /// <param name="action">(wasFree) => {...}</param>
-        /// <returns>false - semaphore.Wait returned by timeout</returns>
+        /// <returns>default if semaphoreTimeout. Or result of func(..)</returns>
-        private static bool Sync(Action<bool> action)
+        private static T Sync<T>(Func<bool, T> func)
         {
             var wasFree = semaphore.CurrentCount > 0;
-            if (!semaphore.Wait(semaphoreTimeout))
+            T result = default;
-                return false;
+            if (func is null || !semaphore.Wait(semaphoreTimeout))
+                return result;
+
             try
             {
-                action?.Invoke(wasFree);
+                result = func.Invoke(wasFree);
             }
             catch (Exception ex)
             {
@@ -85,7 +87,7 @@ namespace AsbCloudInfrastructure.Services.Cache
             {
                 semaphore.Release();
             }
-            return true;
+            return result;
         }
 
         /// <summary>
@@ -94,15 +96,18 @@ namespace AsbCloudInfrastructure.Services.Cache
         /// It may be needed to avoid multiple operations like Refresh().
         /// </summary>
         /// <param name="action">(wasFree) => {...}</param>
-        /// <returns>false - semaphore.Wait returned by timeout</returns>
+        /// <returns>default if semaphoreTimeout. Or result of func(..)</returns>
-        private static async Task<bool> SyncAsync(Func<bool, CancellationToken, Task> task, CancellationToken token = default)
+        private static async Task<T> SyncAsync<T>(Func<bool, CancellationToken, Task<T>> funcAsync, CancellationToken token = default)
         {
             var wasFree = semaphore.CurrentCount > 0;
-            if (!await semaphore.WaitAsync(semaphoreTimeout, token).ConfigureAwait(false))
+            T result = default;
-                return false;
+
+            if (funcAsync is null || !await semaphore.WaitAsync(semaphoreTimeout, token).ConfigureAwait(false))
+                return result;
+
             try
             {
-                await task?.Invoke(wasFree, token);
+                result = await funcAsync.Invoke(wasFree, token);
             }
             catch (Exception ex)
             {
@@ -114,10 +119,10 @@ namespace AsbCloudInfrastructure.Services.Cache
             {
                 semaphore.Release();
             }
-            return true;
+            return result;
         }
 
-        private void InternalRefresh(bool force)
+        private int InternalRefresh(bool force)
         {
             if (force || data.LastResreshDate + minPeriodRefresh < DateTime.Now)
             {
@@ -126,11 +131,12 @@ namespace AsbCloudInfrastructure.Services.Cache
                 var entities = query.AsNoTracking().ToList();
                 //Trace.WriteLine($"CacheTable<{nameOfTEntity}> refresh");
                 cached.AddRange(entities);
-                data.LastResreshDate = DateTime.Now;  
+                data.LastResreshDate = DateTime.Now;
             }
+            return cached.Count;
         }
 
-        private async Task InternalRefreshAsync(bool force, CancellationToken token = default)
+        private async Task<int> InternalRefreshAsync(bool force, CancellationToken token = default)
         {
             if (force || data.LastResreshDate + minPeriodRefresh < DateTime.Now)
             {
@@ -142,24 +148,18 @@ namespace AsbCloudInfrastructure.Services.Cache
                 cached.AddRange(entities);
                 data.LastResreshDate = DateTime.Now;
             }
+            return cached.Count;
         }
 
         public int Refresh(bool force)
-        {
+        => Sync((wasFree) => wasFree ? InternalRefresh(force) : 0);
-            Sync((wasFree) => {
-                if (wasFree)
-                    InternalRefresh(force);
-                });
-            return cached.Count;
-        }
 
-        public async Task<int> RefreshAsync(bool force, CancellationToken token = default)
+        public Task<int> RefreshAsync(bool force, CancellationToken token = default)
         {
-            await SyncAsync(async (wasFree, token) => {
+            return SyncAsync(async (wasFree, token) =>
-                if (wasFree)
+            {
-                    await InternalRefreshAsync(force, token).ConfigureAwait(false);
+                return wasFree ? await InternalRefreshAsync(force, token).ConfigureAwait(false) : 0;
-            }, token).ConfigureAwait(false);
+            }, token);
-            return cached.Count;
         }
 
         public bool Contains(Func<TEntity, bool> predicate)
@@ -169,25 +169,22 @@ namespace AsbCloudInfrastructure.Services.Cache
             => await FirstOrDefaultAsync(predicate, token) != default;
 
         public TEntity GetOrCreate(Func<TEntity, bool> predicate, Func<TEntity> makeNew)
+        => Sync(wasFree =>
         {
-            TEntity result = default;
+            var result = cached.FirstOrDefault(predicate);
-            Sync(wasFree => {
+            if (result != default)
-                result = cached.FirstOrDefault(predicate);
+                return result;
-                if (result != default)
-                    return;
 
-                InternalRefresh(true);                
+            InternalRefresh(true);
-                result = cached.FirstOrDefault(predicate);
+            result = cached.FirstOrDefault(predicate);
-                if (result != default)
+            if (result != default)
-                    return;
+                return result;
 
-                var entry = dbSet.Add(makeNew());
+            var entry = dbSet.Add(makeNew());
-                context.SaveChanges();
+            context.SaveChanges();
-                InternalRefresh(true);
+            InternalRefresh(true);
-                result = entry.Entity;                
+            return entry.Entity;
-            });
+        });
-            return result;
-        }
 
         public TEntity FirstOrDefault()
         {
@@ -206,7 +203,7 @@ namespace AsbCloudInfrastructure.Services.Cache
                 return result;
 
             await RefreshAsync(false, token);
-            return cached.FirstOrDefault();            
+            return cached.FirstOrDefault();
         }
 
         public TEntity FirstOrDefault(Func<TEntity, bool> predicate)
@@ -263,11 +260,11 @@ namespace AsbCloudInfrastructure.Services.Cache
             return result;
         }
 
-        public void Upsert(TEntity entity)
+        public int Upsert(TEntity entity)
         {
             if (entity == default)
-                return;
+                return 0;
-            Sync((wasFree) =>
+            return Sync((wasFree) =>
             {
                 if (dbSet.Contains(entity))
                     dbSet.Update(entity);
@@ -276,46 +273,51 @@ namespace AsbCloudInfrastructure.Services.Cache
                 var affected = context.SaveChanges();
                 if (affected > 0)
                     InternalRefresh(true);
-            });                
+                return affected;
+            });
         }
 
-        public Task UpsertAsync(TEntity entity, CancellationToken token = default)
+        public Task<int> UpsertAsync(TEntity entity, CancellationToken token = default)
-        => SyncAsync(async (wasFree, token) => {
+        => SyncAsync(async (wasFree, token) =>
-                if (dbSet.Contains(entity))
+        {
-                    dbSet.Update(entity);
+            if (dbSet.Contains(entity))
-                else
+                dbSet.Update(entity);
-                    dbSet.Add(entity);
+            else
-                var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
+                dbSet.Add(entity);
-                if(affected > 0)
+            var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
-                    await InternalRefreshAsync(true, token).ConfigureAwait(false);
+            if (affected > 0)
-            }, token);
+                await InternalRefreshAsync(true, token).ConfigureAwait(false);
+            return affected;
+        }, token);
 
-        public void Upsert(IEnumerable<TEntity> entities)
+        public int Upsert(IEnumerable<TEntity> entities)
         {
             if (!entities.Any())
-                return;
+                return 0;
 
-            Sync((wasFree) =>
+            return Sync((wasFree) =>
             {
                 foreach (var entity in entities)
                 {
                     if (dbSet.Contains(entity)) // TODO: это очень ммедленно
                         dbSet.Update(entity);
                     else
-                        dbSet.Add(entity);                 
+                        dbSet.Add(entity);
                 }
                 var affected = context.SaveChanges();
                 if (affected > 0)
                     InternalRefresh(true);
+                return affected;
             });
         }
 
-        public async Task UpsertAsync(IEnumerable<TEntity> entities, CancellationToken token = default)
+        public Task<int> UpsertAsync(IEnumerable<TEntity> entities, CancellationToken token = default)
         {
             if (!entities.Any())
-                return;            
+                return Task.FromResult(0);
 
-            await SyncAsync(async (wasFree, token) => {
+            return SyncAsync(async (wasFree, token) =>
+            {
                 var upsertedEntries = new List<TEntity>(entities.Count());
                 foreach (var entity in entities)
                 {
@@ -327,76 +329,76 @@ namespace AsbCloudInfrastructure.Services.Cache
                 var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
                 if (affected > 0)
                     await InternalRefreshAsync(true, token).ConfigureAwait(false);
+                return affected;
             }, token);
         }
 
-        public void Remove(Func<TEntity, bool> predicate)
+        public int Remove(Func<TEntity, bool> predicate)
         => Sync(_ =>
             {
                 dbSet.RemoveRange(dbSet.Where(predicate));
                 var affected = context.SaveChanges();
                 if (affected > 0)
                     InternalRefresh(true);
+                return affected;
             });
-        
+
-        public Task RemoveAsync(Func<TEntity, bool> predicate, CancellationToken token = default)
+        public Task<int> RemoveAsync(Func<TEntity, bool> predicate, CancellationToken token = default)
-            => SyncAsync(async (wasFree, token) => {
+            => SyncAsync(async (wasFree, token) =>
+            {
                 dbSet.RemoveRange(dbSet.Where(predicate));
                 var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
                 if (affected > 0)
                     await InternalRefreshAsync(true, token).ConfigureAwait(false);
+                return affected;
             }, token);
 
         public TEntity Insert(TEntity entity)
         {
-            TEntity result = default;
+            return Sync(_ =>
-            Sync(_ =>
             {
                 var entry = dbSet.Add(entity);
                 var affected = context.SaveChanges();
                 if (affected > 0)
                     InternalRefresh(true);
-                result = entry.Entity;
+                return entry.Entity;
             });
-            return result;
         }
 
-        public async Task<TEntity> InsertAsync(TEntity entity, CancellationToken token = default)
+        public Task<TEntity> InsertAsync(TEntity entity, CancellationToken token = default)
         {
-            TEntity result = default;
+            return SyncAsync(async (wasFree, token) =>
-            await SyncAsync(async (wasFree, token) =>
+                {
-            {
+                    var entry = dbSet.Add(entity);
-                var entry = dbSet.Add(entity);
+                    var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
-                var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
+                    if (affected > 0)
-                if (affected > 0)
+                        await InternalRefreshAsync(true, token).ConfigureAwait(false);
-                    await InternalRefreshAsync(true, token).ConfigureAwait(false);
+                    return entry.Entity;
-                result = entry.Entity;
+                }, token);
-            }, token);
-            return result;
         }
 
         public int Insert(IEnumerable<TEntity> newEntities)
         {
-            int result = 0;
+            return Sync(_ =>
-            Sync(_ => {
+                {
-                dbSet.AddRange(newEntities);
+                    dbSet.AddRange(newEntities);
-                result = context.SaveChanges();
+                    var affected = context.SaveChanges();
-                if (result > 0)
+                    if (affected > 0)
-                    InternalRefresh(true);
+                        InternalRefresh(true);
-            });            
+                    return affected;
-            return result;
+                });
         }
 
-        public async Task<int> InsertAsync(IEnumerable<TEntity> newEntities, CancellationToken token = default)
+        public Task<int> InsertAsync(IEnumerable<TEntity> newEntities, CancellationToken token = default)
         {
-            int result = 0;
+            return SyncAsync(async (wasFree, token) =>
-            await SyncAsync(async (wasFree, token) => {
+            {
                 dbSet.AddRange(newEntities);
-                result = await context.SaveChangesAsync(token).ConfigureAwait(false);
+                var affected = await context.SaveChangesAsync(token).ConfigureAwait(false);
-                if (result > 0)
+                if (affected > 0)
                     await InternalRefreshAsync(true, token).ConfigureAwait(false);
+                return affected;
             }, token);
-            return result;
         }
 
         public IEnumerator<TEntity> GetEnumerator() => Where().GetEnumerator();

AsbCloudInfrastructure/Services/CrudServiceBase.cs

@@ -81,12 +81,13 @@ namespace AsbCloudInfrastructure.Services
             return dto;
         }
 
-        public virtual Task<int> InsertAsync(TDto item, CancellationToken token = default)
+        public virtual async Task<int> InsertAsync(TDto item, CancellationToken token = default)
         {
             var entity = Convert(item);
             entity.Id = 0;
             dbSet.Add(entity);
-            return context.SaveChangesAsync(token);
+            await context.SaveChangesAsync(token);
+            return entity.Id;
         }
 
         public virtual Task<int> InsertRangeAsync(IEnumerable<TDto> items, CancellationToken token = default)
@@ -101,11 +102,15 @@ namespace AsbCloudInfrastructure.Services
             return context.SaveChangesAsync(token);
         }
 
-        public virtual Task<int> UpdateAsync(int id, TDto item, CancellationToken token = default)
+        public virtual async Task<int> UpdateAsync(int id, TDto item, CancellationToken token = default)
         {
+            var existingEntity = await dbSet.AsNoTracking().FirstOrDefaultAsync(e => e.Id == id).ConfigureAwait(false);
+            if (existingEntity is null)
+                return 0;
             var entity = Convert(item);
+            entity.Id = id;
             dbSet.Update(entity);
-            return context.SaveChangesAsync(token);
+            return await context.SaveChangesAsync(token);
         }
 
         public virtual Task<int> DeleteAsync(int id, CancellationToken token = default)

AsbCloudInfrastructure/Services/PermissionService.cs

@@ -0,0 +1,81 @@
+using AsbCloudApp.Data;
+using AsbCloudApp.Services;
+using AsbCloudDb.Model;
+using AsbCloudInfrastructure.Services.Cache;
+using Mapster;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace AsbCloudInfrastructure.Services
+{
+    public class PermissionService : IPermissionService, IConverter<PermissionDto, Permission>
+    {
+        private readonly CacheTable<Permission> cachePermission;
+
+        public PermissionService(IAsbCloudDbContext db, CacheDb cacheDb)
+        {
+            cachePermission = cacheDb.GetCachedTable<Permission>(
+                (AsbCloudDbContext)db,
+                new string[] { nameof(Permission.PermissionInfo) });
+        }
+
+        public async Task<IEnumerable<PermissionDto>> GetByIdRoleAsync(int idRole, CancellationToken token)
+        {
+            var entities = await cachePermission
+                .WhereAsync(p => p.IdUserRole == idRole, token)
+                .ConfigureAwait(false);
+            var dto = entities.Select(Convert);
+            return dto;
+        }
+
+        public Task<int> InsertRangeAsync(IEnumerable<PermissionDto> dtos, CancellationToken token)
+        {
+            var entities = dtos.Select(Convert);
+            return cachePermission.InsertAsync(entities, token);
+        }
+
+        public async Task<int> UpdateAsync(PermissionDto dto, CancellationToken token)
+        {
+            var entity = Convert(dto);
+            await cachePermission.UpsertAsync(entity, token)
+                .ConfigureAwait(false);
+            return 1;
+        }
+
+        public Task<int> DeleteAsync(int idUserRole, int idPermission, CancellationToken token)
+        {
+            bool predicate(Permission p) => p.IdUserRole == idUserRole && p.IdPermission == idPermission;
+            return DeleteAsync(predicate, token);
+        }
+
+        public Task<int> DeleteAllByRoleAsync(int idUserRole, CancellationToken token)
+        {
+            bool predicate(Permission p) => p.IdUserRole == idUserRole;
+            return DeleteAsync(predicate, token);
+        }
+
+        private async Task<int> DeleteAsync(Func<Permission, bool> predicate, CancellationToken token)
+        {
+            var count = (await cachePermission.WhereAsync(predicate, token).ConfigureAwait(false)).Count();
+            if (count > 0)
+                await cachePermission.RemoveAsync(predicate, token)
+                    .ConfigureAwait(false);
+            return count;
+        }
+
+        public Permission Convert(PermissionDto src)
+        {
+            var entity = src.Adapt<Permission>();
+            return entity;
+        }
+
+        public PermissionDto Convert(Permission src)
+        {
+            var dto = src.Adapt<PermissionDto>();
+            return dto;
+        }
+    }
+}

AsbCloudInfrastructure/Services/UserRoleService.cs

@@ -0,0 +1,139 @@
+using System.Diagnostics;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using AsbCloudApp.Data;
+using AsbCloudDb.Model;
+using AsbCloudInfrastructure.Services.Cache;
+using Mapster;
+using AsbCloudApp.Services;
+
+namespace AsbCloudInfrastructure.Services
+{
+    public class UserRoleService : IUserRoleService
+    {
+        private readonly CacheTable<UserRole> cacheUserRoles;
+        private readonly IPermissionService permissionService;
+
+        public List<string> Incledes { get; } = new();
+
+        public UserRoleService(IAsbCloudDbContext context, CacheDb cacheDb, IPermissionService permissionService)
+        {
+            cacheUserRoles = cacheDb.GetCachedTable<UserRole>((AsbCloudDbContext)context, new string[] { nameof(UserRole.Permissions) });
+            this.permissionService = permissionService;
+        }
+
+        public async Task<IEnumerable<UserRoleDto>> GetAllAsync(CancellationToken token = default)
+        {
+            var entities = await cacheUserRoles.WhereAsync(token)
+                .ConfigureAwait(false);
+            var dtos = entities.Adapt<UserRoleDto>();
+            return dtos;
+        }
+
+        public async Task<UserRoleDto> GetAsync(int id, CancellationToken token = default)
+        {
+            var entity = await cacheUserRoles.FirstOrDefaultAsync(r=>r.Id == id, token)
+                .ConfigureAwait(false);
+            var dto = entity?.Adapt<UserRoleDto>();
+            return dto;
+        }
+
+        public async Task<int> InsertAsync(UserRoleDto dto, CancellationToken token = default)
+        {
+            var entity = dto.Adapt<UserRole>();
+            var updatedEntity = await cacheUserRoles.InsertAsync(entity, token).ConfigureAwait(false);
+            if (dto.Permissions?.Any() == true)
+            {
+                foreach (var permission in dto.Permissions)
+                    permission.IdUserRole = updatedEntity.Id;
+                await permissionService.InsertRangeAsync(dto.Permissions, token).ConfigureAwait(false);
+                await cacheUserRoles.RefreshAsync(true, token)
+                    .ConfigureAwait(false);
+            }
+            return updatedEntity?.Id ?? 0;
+        }
+
+        public async Task<int> InsertRangeAsync(IEnumerable<UserRoleDto> dtos, CancellationToken token = default)
+        {
+            var entities = dtos.Adapt<UserRole>();
+            return await cacheUserRoles.InsertAsync(entities, token).ConfigureAwait(false);
+        }
+
+        public async Task<int> UpdateAsync(int id, UserRoleDto dto, CancellationToken token = default)
+        {
+            var entity = dto.Adapt<UserRole>();
+            entity.Id = id;
+            await cacheUserRoles.UpsertAsync(entity, token)
+                .ConfigureAwait(false);
+
+            if(dto.Permissions is not null)
+            {
+                await permissionService.DeleteAllByRoleAsync(id, token)
+                    .ConfigureAwait(false);
+
+                if (dto.Permissions.Any())
+                {
+                    foreach (var permission in dto.Permissions)
+                        permission.IdUserRole = id;
+
+                    await permissionService.InsertRangeAsync(dto.Permissions, token)
+                        .ConfigureAwait(false);
+                }
+
+                await cacheUserRoles.RefreshAsync(true, token)
+                    .ConfigureAwait(false);
+            }
+
+            return id;
+        }
+
+        private IEnumerable<Permission> GetNestedPermissions(UserRole role, int counter = 10)
+        {
+            List<Permission> permissions = role.Permissions.ToList();
+            if (role.IdParent is not null)
+            {
+                if (counter == 0)
+                {
+                    Trace.WriteLine($"User role with id: {role.Id} has more than 10 nested childs");
+                    return permissions;
+                }
+                var parentRole = cacheUserRoles.FirstOrDefault(r => r.Id == role.IdParent);
+
+                if (parentRole is null)
+                    return permissions;
+
+                var parentPermissions = GetNestedPermissions(parentRole, counter--);
+                Merge(ref permissions, parentPermissions);
+            }
+            return permissions;
+        }
+
+        private static void Merge(ref List<Permission> permissions, IEnumerable<Permission> newPermissions)
+        {
+            foreach (var newPermission in newPermissions)
+            {
+                var permissionIndex = permissions.FindIndex(p => p.IdPermission == newPermission.IdPermission);
+                if (permissionIndex == -1)
+                    permissions.Add(newPermission);
+                else
+                {
+                    var permission = permissions[permissionIndex];
+                    permissions[permissionIndex] = new Permission
+                    {
+                        IdPermission = permission.IdPermission,
+                        IdUserRole = permission.IdUserRole,
+                        PermissionValue = permission.PermissionValue | newPermission.PermissionValue,
+                    };
+                }
+            }
+        }
+
+        public Task<int> DeleteAsync(int id, CancellationToken token = default)
+        => cacheUserRoles.RemoveAsync(r => r.Id == id, token);
+
+        public Task<int> DeleteAsync(IEnumerable<int> ids, CancellationToken token = default)
+        => cacheUserRoles.RemoveAsync(r => ids.Contains(r.Id), token);
+    }
+}

AsbCloudWebApi/Controllers/AdminPermissionController.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using AsbCloudApp.Data;
+using AsbCloudApp.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AsbCloudWebApi.Controllers
+{
+    [Route("api/admin/permission")]
+    [ApiController]
+    [Authorize]
+    public class AdminPermissionController : ControllerBase
+    {
+        private readonly IPermissionService permissionService;
+        
+        public AdminPermissionController(IPermissionService permissionService)
+        {
+            this.permissionService = permissionService;
+        }
+        
+        /// <summary>
+        /// Получает список всех разрешений для роли
+        /// </summary>
+        /// <param name="idRole"> id роли </param>
+        /// <param name="token"> Токен отмены задачи </param>
+        /// <returns></returns>
+        [HttpGet]
+        [ProducesResponseType(typeof(IEnumerable<PermissionDto>), (int)System.Net.HttpStatusCode.OK)]
+        public async Task<IActionResult> GetByIdRoleAsync(int idRole, CancellationToken token = default)
+        {
+            var result = await permissionService.GetByIdRoleAsync(idRole, token);
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Добавляет разрешения для роли
+        /// </summary>
+        /// <param name="dtos"> Объекты новых разрешений для справочника </param>
+        /// <param name="token"> Токен отмены задачи </param>
+        /// <returns></returns>
+        [HttpPost]
+        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
+        public async Task<IActionResult> InsertRangeAsync(IEnumerable<PermissionDto> dtos, 
+            CancellationToken token = default)
+        {
+            var result = await permissionService.InsertRangeAsync(dtos, token);
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Обновляет разрешение для роли
+        /// </summary>
+        /// <param name="dto"> Объект разрешения для справочника </param>
+        /// <param name="token"> Токен отмены задачи </param>
+        /// <returns></returns>
+        [HttpPut]
+        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
+        public async Task<IActionResult> UpdateAsync(PermissionDto dto, 
+            CancellationToken token = default)
+        {
+            var result = await permissionService.UpdateAsync(dto, token);
+            return Ok(result);
+        }
+
+        /// <summary>
+        /// Удаляет разрешение для роли
+        /// </summary>
+        /// <param name="idPermission"> id разрешения </param>
+        /// <param name="idUserRole"> id роли для удаления разрешения </param>
+        /// <param name="token"> Токен отмены задачи </param>
+        /// <returns></returns>
+        [HttpDelete("{idPermission}/{idUserRole}")]
+        [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
+        public async Task<IActionResult> DeleteAsync(int idUserRole, int idPermission, 
+            CancellationToken token = default)
+        {
+            var result = await permissionService.DeleteAsync(idUserRole, idPermission, token);
+            return Ok(result);
+        }
+    }
+}

AsbCloudWebApi/Controllers/AdminPermissionInfoController.cs

@@ -0,0 +1,17 @@
+using AsbCloudApp.Data;
+using AsbCloudApp.Services;
+using Microsoft.AspNetCore.Authorization;
+using Microsoft.AspNetCore.Mvc;
+
+namespace AsbCloudWebApi.Controllers
+{
+    [Route("api/admin/permissionInfo")]
+    [ApiController]
+    [Authorize]
+    public class AdminPermissionInfoController : CrudController<PermissionInfoDto, ICrudService<PermissionInfoDto>>
+    {        
+        public AdminPermissionInfoController(ICrudService<PermissionInfoDto> permissionInfoService)
+            :base(permissionInfoService)
+        {}        
+    }
+}

AsbCloudWebApi/Controllers/AdminUserRoleController.cs

@@ -5,15 +5,14 @@ using Microsoft.AspNetCore.Mvc;
 
 namespace AsbCloudWebApi.Controllers
 {
-    [Route("api/admin/user/role")]
+    [Route("api/admin/role")]
     [ApiController]
     [Authorize]
-    public class AdminUserRoleController : CrudController<UserRoleDto, ICrudService<UserRoleDto>>
+    public class AdminUserRoleController :  CrudController<UserRoleDto, ICrudService<UserRoleDto>>
     {
-        public AdminUserRoleController(ICrudService<UserRoleDto> service)
+        public AdminUserRoleController(IUserRoleService service)
-            : base(service)
+            :base(service)
         {
-
         }
     }
 }

AsbCloudWebApi/Controllers/CrudController.cs

@@ -31,20 +31,17 @@ namespace AsbCloudWebApi.Controllers
         }
 
         /// <summary>
-        /// Получить страницу с записями в PaginationContainer
+        /// Получить все записи
         /// </summary>
-        /// <param name="skip">пропустить skip записей</param>
-        /// <param name="take">получить take записей</param>
         /// <param name="token">CancellationToken</param>
-        /// <returns>страница с записями в PaginationContainer</returns>
+        /// <returns>все записи</returns>
-        [HttpGet()]
+        [HttpGet("all")]
-        public virtual async Task<ActionResult<PaginationContainer<T>>> GetPage(int skip = 0, int take = 32, 
+        public virtual async Task<ActionResult<IEnumerable<T>>> GetAll(CancellationToken token = default)
-            CancellationToken token = default)
         {
             if (!Roles.Any(role => User.IsInRole(role)))
                 return Forbid();
 
-            var result = await service.GetPageAsync(skip, take, token).ConfigureAwait(false);
+            var result = await service.GetAllAsync(token).ConfigureAwait(false);
             return Ok(result);
         }
 
@@ -69,7 +66,7 @@ namespace AsbCloudWebApi.Controllers
         /// </summary>
         /// <param name="value">запись</param>
         /// <param name="token"></param>
-        /// <returns>1 - добавлено, 0 - нет</returns>
+        /// <returns>id</returns>
         [HttpPost]
         [ProducesResponseType(typeof(int), (int)System.Net.HttpStatusCode.OK)]
         public virtual async Task<IActionResult> Insert([FromBody] T value, CancellationToken token = default)
@@ -96,6 +93,8 @@ namespace AsbCloudWebApi.Controllers
                 return Forbid();
 
             var result = await service.UpdateAsync(id, value, token).ConfigureAwait(false);
+            if (result == 0)
+                return BadRequest($"id:{id} does not exist in the db");
             return Ok(result);
         }
 
@@ -116,4 +115,6 @@ namespace AsbCloudWebApi.Controllers
             return Ok(result);
         }
     }
+
+
 }