Генерация тестовых данных для анализа правил доступа в Tessa

# Пользователи мужчины
man_lastname = ['Иванов', 'Смирнов', 'Кузнецов', 'Соколов', 'Попов', 
                'Лебедев', 'Козлов', 'Новиков', 'Морозов', 'Петров', 
                'Волков', 'Соловьёв', 'Васильев', 'Зайцев', 'Павлов', 
                'Семёнов', 'Голубев', 'Виноградов', 'Богданов', 'Воробьёв', 
                'Фёдоров', 'Михайлов', 'Беляев', 'Тарасов', 'Белов', 
                'Комаров', 'Орлов', 'Киселёв', 'Макаров', 'Андреев', 
                'Ковалёв', 'Ильин', 'Гусев', 'Титов', 'Кузьмин', 
                'Кудрявцев', 'Баранов', 'Куликов', 'Алексеев', 'Степанов', 
                'Яковлев', 'Сорокин', 'Сергеев', 'Романов', 'Захаров', 
                'Борисов', 'Королёв', 'Герасимов', 'Пономарёв', 'Григорьев']
initial = ['А.', 'Б.', 'В.', 'Г.', 'Д.', 'Е.', 'И.', 'К.', 'Л.', 'М.', 'О.', 'Р.', 'С.', 'Т.']

columns = [
    ('man_lastname', 'str'),
    ('initial_1', 'str'),
    ('initial_2', 'str')
]

text_substrings = {
    'man_lastname': man_lastname,
    'initial_1': initial,
    'initial_2': initial
}

numeric_ranges = []
bool_probabilities = []

# Генерация DataFrame
df_man = generate_dataframe(
    columns=columns,
    text_substrings=text_substrings,
    numeric_ranges=numeric_ranges,
    bool_probabilities=bool_probabilities,
    text_probability=1.,
    numeric_probability=0.95,
    bool_probability=0.95,
    mean_row_count=100,
    deviation_row_count=10
)

df_man['Имя пользователя'] = df_man['man_lastname'] + ' ' + df_man['initial_1'] + df_man['initial_2']
df_man = df_man.drop(['man_lastname', 'initial_1', 'initial_2'], axis=1)

print(f"\nСгенерировано строк: {len(df_man)}")
print("\nИнформация о данных:")
display(df_man.info())
print("\nПервые 5 строк:")
display(df_man.head())

# Пользователи мужчины
woman_lastname = ['Иванова', 'Смирнова', 'Кузнецова', 'Соколова', 'Попова', 
                  'Васильева', 'Петрова', 'Лебедева', 'Козлова', 'Новикова', 
                  'Морозова', 'Волкова', 'Соловьёва', 'Зайцева', 'Павлова', 
                  'Семёнова', 'Голубева', 'Виноградова', 'Богданова', 'Воробьёва', 
                  'Фёдорова', 'Михайлова', 'Беляева', 'Тарасова', 'Белова', 
                  'Комарова', 'Орлова', 'Киселёва', 'Макарова', 'Андреева', 
                  'Ковалёва', 'Ильина', 'Гусева', 'Титова', 'Кузьмина', 
                  'Кудрявцева', 'Баранова', 'Куликова', 'Алексеева', 'Степанова', 
                  'Яковлева', 'Сорокина', 'Сергеева', 'Романова', 'Захарова', 
                  'Борисова', 'Королёва', 'Герасимова', 'Пономарёва', 'Григорьева']
initial = ['А.', 'Б.', 'В.', 'Г.', 'Д.', 'Е.', 'И.', 'К.', 'Л.', 'М.', 'О.', 'Р.', 'С.', 'Т.']

columns = [
    ('woman_lastname', 'str'),
    ('initial_1', 'str'),
    ('initial_2', 'str')
]

text_substrings = {
    'woman_lastname': woman_lastname,
    'initial_1': initial,
    'initial_2': initial
}

numeric_ranges = []
bool_probabilities = []

# Генерация DataFrame
df_woman = generate_dataframe(
    columns=columns,
    text_substrings=text_substrings,
    numeric_ranges=numeric_ranges,
    bool_probabilities=bool_probabilities,
    text_probability=1.,
    numeric_probability=0.95,
    bool_probability=0.95,
    mean_row_count=100,
    deviation_row_count=10
)

df_woman['Имя пользователя'] = df_woman['woman_lastname'] + ' ' + df_woman['initial_1'] + df_woman['initial_2']
df_woman = df_woman.drop(['woman_lastname', 'initial_1', 'initial_2'], axis=1)

print(f"\nСгенерировано строк: {len(df_woman)}")
print("\nИнформация о данных:")
display(df_woman.info())
print("\nПервые 5 строк:")
display(df_woman.head())

# PersonalRoles

# Пользователи
name = pd.concat([df_man, df_woman], axis=0, ignore_index=True)
name = name['Имя пользователя'].values.tolist()

# Должности
positions = [
    'Менеджер проекта', 'Старший специалист',
    'Специалист', 'Младший специалист', 'Ассистент'
]

# Подразделения
departments = [
    'Руководство', 'IT-отдел', 'Бухгалтерия', 'Отдел продаж', 
    'Юридический отдел', 'Отдел кадров', 'Производственный отдел'
]

columns = [
    ('Имя пользователя', 'str'),
    ('Должность пользователя', 'str'),
    ('Уровень доступа пользователя', 'int'),
    ('Тип учетной записи пользователя', 'int'), 
    ('Блокировка учетной записи пользователя', 'bool'), 
    ('Название роли', 'str')
]

text_substrings = {
    'Имя пользователя': name,
    'Должность пользователя': positions,
    'Название роли': departments
}

numeric_ranges = {
    'Уровень доступа пользователя': (0, 1),
    'Тип учетной записи пользователя': (0, 2)
}

bool_probabilities = {
    'Блокировка учетной записи пользователя': .1
}

# Генерация DataFrame
role_users = generate_dataframe(
    columns=columns,
    text_substrings=text_substrings,
    numeric_ranges=numeric_ranges,
    bool_probabilities=bool_probabilities,
    text_probability=1.,
    numeric_probability=0.95,
    bool_probability=0.75,
    mean_row_count=200,
    deviation_row_count=10
)

print(f"\nСгенерировано строк: {len(role_users)}")
print("\nИнформация о данных:")
display(role_users.info())
print("\nПервые 5 строк:")
display(role_users.head())

# Добавление логина пользователя
trans_dict = {'А':'a', 'Б':'b', 'В':'v', 'Г':'g', 'Д':'d', 'Е':'e', 'Ё':'eo', 
              'Ж':'zh', 'З':'z', 'И':'i', 'Й':'iy', 'К':'k', 'Л':'l', 'М':'m', 'Н':'n', 
              'О':'o', 'П':'p', 'Р':'r', 'С':'s', 'Т':'t', 'У':'u', 'Ф':'f', 
              'Х':'h', 'Ц':'c', 'Ч':'ch', 'Ш':'sh', 'Щ':'shi', 'Ъ':'', 'Ы':'iy', 
              'Ь':'', 'Э':'e', 'Ю':'yu', 'Я':'ya', 
              'а':'a', 'б':'b', 'в':'v', 'г':'g', 'д':'d', 'е':'e', 'ё':'eo', 
              'ж':'zh', 'з':'z', 'и':'i', 'й':'iy', 'к':'k', 'л':'l', 'м':'m', 'н':'n', 
              'о':'o', 'п':'p', 'р':'r', 'с':'s', 'т':'t', 'у':'u', 'ф':'f', 
              'х':'h', 'ц':'c', 'ч':'ch', 'ш':'sh', 'щ':'shi', 'ъ':'', 'ы':'iy', 
              'ь':'', 'э':'e', 'ю':'yu', 'я':'ya'}
trans_table = str.maketrans(trans_dict)
role_users['Логин пользователя'] = role_users['Имя пользователя'].str.translate(trans_table)
role_users['Логин пользователя'] = role_users['Логин пользователя'].str.replace(' ', '')
role_users['Логин пользователя'] = role_users['Логин пользователя'].str.replace('.', '')

print(role_users.info())
role_users.head(5)

# Создание идентификаторов
uniqueidentifier = [str(uuid.uuid4()) for _ in range(len(role_users)*10)]

# Идентификаторы пользьвателей
role_users['ID пользователя'] = uniqueidentifier[0:len(role_users)]

# Идентификаторы ролей
role_users['ID роли'] = uniqueidentifier[len(role_users)+1:len(role_users)*2+1]

print(role_users.info())
role_users.head(5)

# Назначение начальников олтделов
role_users.loc[role_users.groupby('Название роли').head(1).index, 'Должность пользователя'] = 'Начальник отдела'

role_users[role_users['Должность пользователя'] == 'Начальник отдела']

# Назначение директоров
n = -4
for i in ['Генеральный директор', 'Финансовый директор', 'Директор по развитию']:
    role_users.loc[role_users[role_users['Название роли'] == 'Руководство'].iloc[n:n+1].index, 'Должность пользователя'] = i
    n = n + 1

role_users[role_users['Название роли'] == 'Руководство'].iloc[-4:]

# Добавление тиапа роли (2 - подразделение)
role_users['Тип роли'] = 2

role_users.head(5)

# Создание системных ролей
_system_roles = pd.DataFrame({
    'ID пользователя': [
        '11111111-1111-1111-1111-111111111111', # 'System'
        '00000000-0000-0000-0000-000000000002', # 'Бухгалтерские сервисы'
        '00000000-0000-0000-0000-000000000003', # 'ИТ-сервисы'
        '00000000-0000-0000-0000-000000000004', # 'Сайт компании'
        '00000000-0000-0000-0000-000000000005', # 'Робот службы безопасности'
        '00000000-0000-0000-0000-000000000006', # 'Робот финансовой службы'
        '00000000-0000-0000-0000-000000000007'  # 'Юридические сервисы'
    ],
    'Имя пользователя': [
        'System', 
        'Бухгалтерские сервисы', 
        'ИТ-сервисы', 
        'Сайт компании', 
        'Робот службы безопасности', 
        'Робот финансовой службы', 
        'Юридические сервисы'
    ],
    'Должность пользователя': [
        'Сервис', 
        'Сервис', 
        'Сервис', 
        'Сервис', 
        'Робот', 
        'Робот', 
        'Сервис'
    ], 
    'Уровень доступа пользователя': [
        1, 0, 0, 0, 1, 0, 0
    ],
    'Тип учетной записи пользователя': [
        1, 2, 2, 2, 2, 2, 2
    ], 
    'Логин пользователя': [
        'system', 
        'accounting_services', 
        'it_services', 
        'company_website', 
        'security_service_robot', 
        'financial_service_robot', 
        'legal_services'
    ], 
    'Блокировка учетной записи пользователя': [
        False, False, False, False, False, False, False
    ]
})

# Вхожденрие системных ролей самих в себя
_system_roles['ID роли'] = _system_roles['ID пользователя']
_system_roles['Название роли'] = _system_roles['Имя пользователя']
_system_roles['Тип роли'] = 1

# Добавление системных ролей
role_users = pd.concat([role_users, _system_roles], ignore_index=True)

role_users[role_users['Должность пользователя'].isin(['Сервис', 'Робот'])]

# Вхождение персональных ролей самих в себя в таблице RoleUsers
role_users_ = role_users.copy()
role_users_['ID роли'] = role_users_['ID пользователя']
role_users_['Название роли'] = role_users_['Имя пользователя']

# Добавление тиапа роли (1 - сотрудник)
role_users_['Тип роли'] = 1

role_users = pd.concat([role_users, role_users_], ignore_index=True)

print(role_users.info())
display(role_users[role_users['ID роли'] != role_users['ID пользователя']].head(5))
role_users[role_users['ID роли'] == role_users['ID пользователя']].head(5)

# Добавление данных о вхождении персональных ролей в статические роли

# Статические роли для бизнес-процессов
business_roles = [
    'Обработчик входящих документов',
    'Ответственный за договоры', 
    'Согласующий финансовых документов',
    'Контролер качества'
]

# Идентификаторы пользователей, которые могут получить доступ к статическим ролям 
personal_roles_id = role_users[role_users['ID роли'] != role_users['ID пользователя']]['ID пользователя'].tolist()
# Идентификаторы статических ролей
business_roles_id = uniqueidentifier[len(role_users)*3:len(role_users)*3+len(business_roles)]

# Создание датафрейма с данными о статических ролях
business_roles_data = pd.DataFrame({'ID роли': business_roles_id, 'Название роли': business_roles})

columns = [
    ('ID пользователя', 'str'),
    ('ID роли', 'str')
]

text_substrings = {
    'ID пользователя': personal_roles_id,
    'ID роли': business_roles_id
}

numeric_ranges = []
bool_probabilities = []

# Генерация DataFrame
role_users_ = generate_dataframe(
    columns=columns,
    text_substrings=text_substrings,
    numeric_ranges=numeric_ranges,
    bool_probabilities=bool_probabilities,
    text_probability=.75,
    numeric_probability=.5,
    bool_probability=.5,
    mean_row_count=100,
    deviation_row_count=20
)

# Удаление пустых связей между ролями
role_users_ = role_users_[(~role_users_['ID пользователя'].isnull()) & ~role_users_['ID роли'].isnull()]

# Добавление данных пользоватеолей
role_users_ = pd.merge(role_users_, role_users.drop(['ID роли', 'Название роли', 'Тип роли'], axis=1), on='ID пользователя', how='left').drop_duplicates()

# Добавление названия ролей
role_users_ = pd.merge(role_users_, business_roles_data, on='ID роли', how='inner')

# Добавление тиапа роли (0 - статическая)
role_users_['Тип роли'] = 0

# Объединение основного датафрейма role_users и вспомагательного role_users_
role_users = pd.concat([role_users, role_users_], ignore_index=True)

# Ранжирование полей датафрейма
role_users = role_users[[
    'ID пользователя', 'Имя пользователя', 'Должность пользователя',
    'Уровень доступа пользователя', 'Тип учетной записи пользователя', 
    'Логин пользователя', 'Блокировка учетной записи пользователя', 
    'ID роли', 'Название роли', 'Тип роли'
]]

print(f"\nСгенерировано строк: {len(role_users)}")
print("\nИнформация о данных:")
display(role_users[role_users['Тип роли'] == 0].info())
print("\nПервые 5 строк:")
role_users[role_users['Тип роли'] == 0].head(5)

# Проверка сгенерированных данных таблицы role_users

print('Вхождение ролей сотрудников в самих себя и в любые другие роли:')
display(role_users[role_users['ID роли'] != role_users['ID пользователя']].head(5))
display(role_users[role_users['ID роли'] == role_users['ID пользователя']].head(5))

print('\nСотрудники подразделений:')
display(role_users[role_users['Тип роли'] == 2].head(5))

print('\nНачальники отделов:')
display(role_users[
        (role_users['Должность пользователя'] == 'Начальник отдела') 
        & (role_users['Тип роли'] == 2)
].head(30))

print('\nДиректора:')
display(role_users[
        (role_users['Должность пользователя'].str.contains('иректор'))
        & (role_users['Тип роли'] == 2)
].head(5))

print('\nСотрудники, входящие в статические роли:')
display(role_users[role_users['Тип роли'] == 0].head(5))

print('\nСотрудники с неизвестным типом учетной записи:')
display(role_users[
    (role_users['Тип учетной записи пользователя'].isna())
    & (role_users['Тип роли'] == 1)
].head(5))

# Выгрузка данных датафрейма `role_users` в файл `RoleUsers.csv`
role_users.to_csv('files/RoleUsers.csv')

# Проверка выгрзки
df = pd.read_csv('files/RoleUsers.csv').drop('Unnamed: 0', axis=1)
df.head(5)

# Создание таблицы `ContextRoles`

# Коды SQL контекстных ролей
context_roles = pd.DataFrame({
    'Код SQL': [
        # Проверка роли "Автор" для текущего документа
"""
SELECT u.UserID, u.Name
FROM Users u
JOIN ContextRoleAssignments cra ON u.UserID = cra.UserID
JOIN Roles r ON cra.RoleID = r.RoleID
WHERE cra.ObjectID = @CurrentDocumentID  -- текущий документ
  AND u.UserID = @CurrentUserID           -- текущий пользователь
  AND r.RoleName = 'Автор'
  AND cra.ObjectType = 'Документ';
""",
        # Проверка роли "Согласующий"
"""
SELECT u.UserID, u.Name
FROM Users u
JOIN ContextRoleAssignments cra ON u.UserID = cra.UserID
JOIN Roles r ON cra.RoleID = r.RoleID
WHERE cra.ObjectID = @CurrentDocumentID
  AND u.UserID = @CurrentUserID
  AND r.RoleName = 'Согласующий'
  AND cra.ObjectType = 'Документ'
  AND cra.WorkflowStage = 'Согласование';  -- этап процесса
""",
        # Проверка роли "Исполнитель"
"""
SELECT u.UserID, u.Name
FROM Users u
JOIN ContextRoleAssignments cra ON u.UserID = cra.UserID
JOIN Roles r ON cra.RoleID = r.RoleID
WHERE cra.ObjectID = @TaskID  -- ID задачи
  AND u.UserID = @CurrentUserID
  AND r.RoleName = 'Исполнитель'
  AND cra.ObjectType = 'Задача'
  AND (cra.EndDate IS NULL OR cra.EndDate >= GETDATE());  -- активная роль
""",
        # Проверка роли "Утверждающий"
"""
SELECT u.UserID, u.Name
FROM Users u
JOIN ContextRoleAssignments cra ON u.UserID = cra.UserID
JOIN Roles r ON cra.RoleID = r.RoleID
WHERE cra.ObjectID = @DocumentID
  AND u.UserID = @CurrentUserID
  AND r.RoleName = 'Утверждающий'
  AND cra.ObjectType = 'Документ'
  AND cra.StartDate <= GETDATE()  -- роль активна с даты начала
  AND (cra.EndDate IS NULL OR cra.EndDate >= GETDATE());
""",
        # Проверка роли "Контролёр"
"""
SELECT u.UserID, u.Name
FROM Users u
JOIN ContextRoleAssignments cra ON u.UserID = cra.UserID
JOIN Roles r ON cra.RoleID = r.RoleID
WHERE cra.ObjectID = @DocumentID
  AND u.UserID = @CurrentUserID
  AND r.RoleName = 'Контролёр'
  AND cra.ObjectType = 'Документ'
  AND EXISTS (
      SELECT 1 
      FROM Documents d 
      WHERE d.DocumentID = cra.ObjectID 
        AND d.Status = 'На контроле'  -- дополнительный фильтр
  );
"""
    ]
})

# Создание идентификаторов
uniqueidentifier = [str(uuid.uuid4()) for _ in range(len(context_roles)*10)]

# Идентификаторы ролей
context_roles['ID роли'] = uniqueidentifier[0:len(context_roles)]

# Ранжирование полей датафрейма
context_roles = context_roles[['ID роли', 'Код SQL']]

print(context_roles.info())
context_roles.head(5)

# Выгрузка данных датафрейма `context_roles` в файл `ContextRoles.csv`
context_roles.to_csv('files/ContextRoles.csv')

# Проверка выгрзки
df = pd.read_csv('files/ContextRoles.csv').drop('Unnamed: 0', axis=1)
df.head(5)

# Создание датафрейма с идентификаторами 
# и названиями правил доступа и разрешениями

columns = [
    ('Правило отключено', 'bool'), 
    ('Всегда проверять правило', 'bool'), 
    ('РПД', 'bool'), 
    ('Типы условий', 'bool'), 
    ('Создание карточки', 'bool'), 
    ('Чтение карточки', 'bool'), 
    ('Редактирование карточки', 'bool'), 
    ('Удаление карточки', 'bool'), 
    ('Добавление файлов', 'bool'), 
    ('Редактирование собственных файлов', 'bool'), 
    ('Редактирование файлов', 'bool'), 
    ('Удаление собственных файлов', 'bool'), 
    ('Удаление всех файлов', 'bool'), 
    ('Инициация типового процесса отправки задач', 'bool'), 
    ('Редактирование маршрута', 'bool'), 
    ('Пропуск этапов', 'bool'), 
    ('Полный пересчет маршрута', 'bool'), 
    ('Ручное редактирование номера', 'bool'), 
    ('Создание резолюций', 'bool'), 
    ('Подписание файлов', 'bool'), 
    ('Создание обсуждений', 'bool'), 
    ('Права супермодератора', 'bool'), 
    ('Подписка на уведомления', 'bool'), 
    ('Создание шаблона и копирование', 'bool'), 
    ('Редактирование своих сообщений', 'bool'), 
    ('Редактирование всех сообщений', 'bool'), 
    ('Чтение обсуждений', 'bool'), 
    ('Чтение и отправка сообщений', 'bool')
]

text_substrings = {}
numeric_ranges = {}

bool_probabilities = {
    'Правило отключено': .25, 
    'Всегда проверять правило': .25, 
    'РПД': .05, 
    'Типы условий': .05, 
    'Создание карточки': .75, 
    'Чтение карточки': .85, 
    'Редактирование карточки': .7, 
    'Удаление карточки': .5, 
    'Добавление файлов': .6, 
    'Редактирование собственных файлов': .25, 
    'Редактирование файлов': .65, 
    'Удаление собственных файлов': .2, 
    'Удаление всех файлов': .3, 
    'Инициация типового процесса отправки задач': .45, 
    'Редактирование маршрута': .55, 
    'Пропуск этапов': .006, 
    'Полный пересчет маршрута': .005, 
    'Ручное редактирование номера': .4, 
    'Создание резолюций': .35, 
    'Подписание файлов': .15, 
    'Создание обсуждений': .1, 
    'Права супермодератора': .009, 
    'Подписка на уведомления': .008, 
    'Создание шаблона и копирование': .007, 
    'Редактирование своих сообщений': .004, 
    'Редактирование всех сообщений': .003, 
    'Чтение обсуждений': .002, 
    'Чтение и отправка сообщений': .001 
}

kr_permissions = generate_dataframe(
    columns=columns, 
    text_substrings=text_substrings, 
    numeric_ranges=numeric_ranges, 
    bool_probabilities=bool_probabilities, 
    text_probability=.75, 
    numeric_probability=.75, 
    bool_probability=1., 
    mean_row_count=200, 
    deviation_row_count=20
)

print(kr_permissions.info())
kr_permissions.head(5)

# Создание идентификаторов
uniqueidentifier = [str(uuid.uuid4()) for _ in range(len(kr_permissions)*10)]

# Идентификаторы правил доступа
kr_permissions['ID правила доступа'] = uniqueidentifier[0:len(kr_permissions)]

print(kr_permissions.info())
kr_permissions.head(5)

# Присваивание формальных названий правилам доступа
for i in kr_permissions.index:
    kr_permissions.loc[i, 'Название правила доступа'] = 'Правило ' + str(i)

# Ранжирование полей датафрейма
kr_permissions = kr_permissions[[
    'ID правила доступа', 
    'Название правила доступа', 
    'Правило отключено', 
    'Всегда проверять правило', 
    'РПД', 
    'Типы условий', 
    'Создание карточки', 
    'Чтение карточки', 
    'Редактирование карточки', 
    'Удаление карточки', 
    'Добавление файлов', 
    'Редактирование собственных файлов', 
    'Редактирование файлов', 
    'Удаление собственных файлов', 
    'Удаление всех файлов', 
    'Инициация типового процесса отправки задач', 
    'Редактирование маршрута', 
    'Пропуск этапов', 
    'Полный пересчет маршрута', 
    'Ручное редактирование номера', 
    'Создание резолюций', 
    'Подписание файлов', 
    'Создание обсуждений', 
    'Права супермодератора', 
    'Подписка на уведомления', 
    'Создание шаблона и копирование', 
    'Редактирование своих сообщений', 
    'Редактирование всех сообщений', 
    'Чтение обсуждений', 
    'Чтение и отправка сообщений'
]]

print(kr_permissions.info())
kr_permissions.head(5)

# Выгрузка данных датафрейма `kr_permissions` в файл `KrPermissions.csv`
kr_permissions.to_csv('files/KrPermissions.csv')

# Проверка выгрзки
df = pd.read_csv('files/KrPermissions.csv').drop('Unnamed: 0', axis=1)
df.head(5)

# Создание датафрейма `KrPermissionRoles` с идентификаторами 
# и названиями правил доступа и разрешениями

columns = [
    ('ID правила доступа', 'str'), 
    ('ID роли', 'str')
]

text_substrings = {
    'ID правила доступа': kr_permissions['ID правила доступа'].tolist(),
    'ID роли': role_users['ID роли'].tolist()
}

numeric_ranges = {}
bool_probabilities = {}

kr_permission_roles = generate_dataframe(
    columns=columns, 
    text_substrings=text_substrings, 
    numeric_ranges=numeric_ranges, 
    bool_probabilities=bool_probabilities, 
    text_probability=.75, 
    numeric_probability=.75, 
    bool_probability=1., 
    mean_row_count=300, 
    deviation_row_count=30
)

print(kr_permission_roles.info())
kr_permission_roles.head(5)

# Добавлеие названий ролей 
kr_permission_roles = pd.merge(kr_permission_roles, role_users[['ID роли', 'Название роли']], on='ID роли', how='left')

# Не может бытть правила без хотя бы одной роли 
# или идентификатора правила доступа
kr_permission_roles = kr_permission_roles.dropna()

print(kr_permission_roles.info())
kr_permission_roles.head(5)

# Выгрузка данных датафрейма `kr_permission_roles` в файл `krPermissionRoles.csv`
kr_permission_roles.to_csv('files/krPermissionRoles.csv')

# Проверка выгрзки
df = pd.read_csv('files/krPermissionRoles.csv').drop('Unnamed: 0', axis=1)
df.head(5)

# Создание справочника типов карточек
type_caption = pd.DataFrame({
    'Тип карточки': [
        'Входящий', 
        'Исходящий', 
        'Договор', 
        'Дополнительное соглашение', 
        'Счёт', 
        'Универсальный передаточный документ', 
        'Распоряжение', 
        'Служебная записка', 
        'МЧД'
]})

# Создание идентификаторов
uniqueidentifier = [str(uuid.uuid4()) for _ in range(len(type_caption)*10)]

# Идентификаторы типов карточек
type_caption['ID типа карточки'] = uniqueidentifier[0:len(type_caption)]

type_caption