Анализ предоставленных разрешений в Tessa

# Данные из таблицы KrPermissions, предварительно выгруженные из БД Tessa
kr_permissions = pd.read_csv('files/KrPermissions.csv').drop('Unnamed: 0', axis=1)#, sep=';', encoding='utf-8-sig')

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

# Данные из таблицы KrPermissionRoles, предварительно выгруженные из БД Tessa
kr_permission_roles = pd.read_csv('files/KrPermissionRoles.csv').drop('Unnamed: 0', axis=1)#, sep=';', encoding='utf-8-sig')

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

# Данные из таблицы KrPermissionTypes, предварительно выгруженные из БД Tessa
kr_permission_types = pd.read_csv('files/KrPermissionTypes.csv').drop('Unnamed: 0', axis=1)#, sep=';', encoding='utf-8-sig')

print(kr_permission_types.info())
kr_permission_types.head(5)

# Данные из таблицы KrPermissionStates, предварительно выгруженные из БД Tessa
kr_permission_states = pd.read_csv('files/KrPermissionStates.csv').drop('Unnamed: 0', axis=1)#, sep=';', encoding='utf-8-sig')

print(kr_permission_states.info())
kr_permission_states.head(5)

# Данные из таблицы KrPermissionExtendedcard, предварительно выгруженные из БД Tessa
kr_permission_extended_card_rules = pd.read_csv('files/KrPermissionExtendedCardRules.csv').drop('Unnamed: 0', axis=1)#, sep=';', encoding='utf-8-sig')

print(kr_permission_extended_card_rules.info())
kr_permission_extended_card_rules.head(5)

# Данные из таблицы RoleUsers, предварительно выгруженные из БД Tessa
role_users = pd.read_csv('files/RoleUsers.csv').drop('Unnamed: 0', axis=1)#, sep=';', encoding='utf-8-sig')

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

# Данные из таблицы ContextRoles, предварительно выгруженные из БД Tessa
context_roles = pd.read_csv('files/ContextRoles.csv').drop('Unnamed: 0', axis=1)#, sep=';', encoding='utf-8-sig')

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

# Уникальные пользователи
user_data = role_users[[
    'ID пользователя', 
    'Имя пользователя'
]].dropna().drop_duplicates().sort_values('Имя пользователя').reset_index(drop=True)

print(user_data.info())
user_data.head(5)

# NEW
# Кластеризация правил по пользователям, типам и состояниям карточек
# с подсчетом количества совпадающих разрешений в правилах

# Итерационная переменная для подсчета 
# количества чанок сотрудников
n = 0
# Чанки пользователей
for u_index, u in user_data.iterrows():
    
    # Создание датафрейма сотрудника. 
    # Объединение данных о пользователях и ролях 
    # с ID правил доступа, где используются роли 
    df = pd.merge(
        role_users[role_users['ID пользователя'] == u['ID пользователя']].sort_values([
            'Имя пользователя', 
            'Название роли'
        ])[[
            'ID пользователя', 
            'Имя пользователя', 
            'ID роли', 
            'Название роли', 
            'Тип роли'
        ]], 
        kr_permission_roles[['ID роли', 'ID правила доступа']].sort_values('ID роли'), 
        on='ID роли', 
        how='inner'
    )
    # Выход из цикла, если датафрейм пустой
    if len(df) == 0: continue
    
    # Объединение данных о ролях из текущей чанки сотрудника
    # с данными о правилах, в которых есть эти роли
    df = pd.merge(
        df, 
        kr_permission_types, 
        on='ID правила доступа', 
        how='inner'
    )
    df = pd.merge(
        df, 
        kr_permission_states, 
        on='ID правила доступа', 
        how='inner'
    )
    df = pd.merge(
        df, 
        kr_permissions, 
        on='ID правила доступа', 
        how='inner'
    )
    # Выход из цикла, если датафрейм пустой
    if len(df) == 0: continue
    
    # Изменение порядка столбцов
    df = df.iloc[:,[
        0, 1, 2, 3, 4, 5, 10, 6, 7, 8, 9, 
        11, 12, 13, 14, 15, 16, 17, 18, 19, 
        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
        30, 31, 32, 33, 34, 35, 36, 37, 38 
    ]]

    # Приведение типа параметров разрешений с bool к int
    temp_df = df.iloc[:, 11:].astype('int8')
    df = pd.concat([
        df.iloc[:, :11], 
        temp_df
    ], axis=1)
    
    # Выделение параметров разрешений
    permissions_locs = df.iloc[:, 15:].columns.tolist()
    # Выделение всех параметров, кроме содержащих данные о пользователе
    locs = df.iloc[:, 2:].columns.tolist()
    # Выделение параметров по которым будет производиться объединение
    cross_locs = df.iloc[:, 7:10].columns.tolist()
    
    # Кросс-джойн через временный ключ
    df_locs = df[locs]
    df = df_locs.merge(df_locs, on=cross_locs, suffixes=('_x', '_y'))
    del df_locs
    
    # Удаление кросс-джойна с самим собой
    df = df[
        (df['ID правила доступа_x'] != df['ID правила доступа_y']) &
        (df['ID роли_x'] != df['ID роли_y'])
    ].copy()
    
    # Удаление обратных пар правило-роль
    df['x_pairs'] = df[['ID правила доступа_x', 'ID роли_x']].agg(frozenset, axis=1)
    df['y_pairs'] = df[['ID правила доступа_y', 'ID роли_y']].agg(frozenset, axis=1)
    df['xy_pairs'] = df[['x_pairs', 'y_pairs']].agg(frozenset, axis=1)
    df['yx_pairs'] = df[['y_pairs', 'x_pairs']].agg(frozenset, axis=1)
    df = df[
        ~df['xy_pairs'].duplicated() &
        ~df['yx_pairs'].duplicated()
    ].drop(columns=['x_pairs', 'y_pairs', 'xy_pairs', 'yx_pairs'])
    
    # Перемножение параметров разрешений
    for col in permissions_locs:
        df[f'{col}_prod'] = df[f'{col}_x'] * df[f'{col}_y']
        df = df.drop(columns=[f'{col}_x', f'{col}_y'])
    
    # Суммирование всех одинаковых разрешений
    df['Количество одинаковых разрешений'] = df[[f'{c}_prod' for c in permissions_locs]].sum(axis=1)
    # Сортировка объектов по количеству одинаковых разрешений
    df = df.sort_values('Количество одинаковых разрешений', ascending=False)
    # Удаление объектов без одинаковых разрешений
    df = df[df['Количество одинаковых разрешений'] > 0].reset_index(drop=True)
    # Выход из цикла, если датафрейм пустой
    if len(df) == 0: continue
    
    # Изменение порядка столбцов
    df = df.iloc[:,[
        5, 6, 7, 0, 1, 2, 3, 4, 8, 9, 
        10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 
        20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 
        30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 
        40, 41, 42, 43, 44, 45, 46, 47
    ]]
    
    # Корректировка названий полей датафрейма
    for col in df.columns:
        if '_x' in col:
            df.rename(columns={col: col.replace('_x', '')}, inplace=True)
        if '_y' in col:
            df.rename(columns={col: col.replace('_y', ' (сопоставлено)')}, inplace=True)
        if '_prod' in col:
            df.rename(columns={col: col.replace('_prod', '')}, inplace=True)
    
    # Вывод с демонстрацией всех полей датафрейма
    '''with pd.option_context('display.max_columns', None):
        print(df.info())
        display(df.head(5))'''
    
    # Вывод результатов кластеризации правил
    if 'df' in locals():
        if len(df) > 0:
            
            # Подсчет количества чанок сотрудников
            n += 1
            # Определение текущей даты и времени по Мск
            timestamp_now = datetime.now(pytz.timezone('Europe/Moscow')).strftime('%Y-%m-%d %H:%M:%S')
            # Очистка имен пользователей для безошибочного сохранения файлов 
            # с использованием их в названии
            safe_name = re.sub(r'[<>:"/\\|&*?]', '', u['Имя пользователя'])
            
            # Пошаговое сохранение данных об одинаковых разрешениях 
            # в отдельный файл для каждой чанки сотрудника
            df.to_excel(f'permissions_clusters/{safe_name}.xlsx', sheet_name='Sheet1')
            
            # Вывод результата обработки чанки соттрудника на экран
            print(f"{n}. {timestamp_now} у сотрудника {u['Имя пользователя']} \
обнаружено {len(df)} дублей с максимальным количеством \
одинаковых разрешений {df['Количество одинаковых разрешений'].max()}")
            # Вывод каждой чанки сотрудика в виде отдельной таблицы на экране
            # с демонстрацией всех полей датафрейма
            '''with pd.option_context('display.max_columns', None):
                #display(permissions_clusters.head(5))'''
            
            # Создание и наполнение итогового датафрейма
            # с основной информацией о результатах анализа разрешений
            if 'total' not in locals():
                total = pd.DataFrame(columns=['Дата и время', 'Сотрудники', 'Всего дублей', 'Максимум одинаковых разрешений'])
            total = pd.concat([
                total,
                pd.DataFrame({
                    'Дата и время':[timestamp_now], 
                    'Сотрудники':[u['Имя пользователя']], 
                    'Всего дублей':[len(df)], 
                    'Максимум одинаковых разрешений':[df['Количество одинаковых разрешений'].max()]
                })
            ], axis=0).reset_index(drop=True)
    
    # Принудительная остановка цикла для теста
    #if n > 5: break
    

# Приведение строки к типу даты и времени и подсчет времени проведения анализа
total['Дата и время'] = pd.to_datetime(total['Дата и время'])
print('Продолжительность анализа', total['Дата и время'].max() - total['Дата и время'].min())

# Итоговые данные результатов анализа существующих разрешений в Tessa
print('Датафрейм с итоговыми данными результатов анализа существующих разрешений в Tessa:')
display(total)

# Статистические данные результатов анализа разрешений
print('Статистические данные результатов:')
for col in total.columns:
    print()
    display(pd.DataFrame(total[col].describe()))

# Данные о количестве разрешений у сотрудника с максимальным количеством дублей
total_max = total[total['Всего дублей'] == total['Всего дублей'].max()]
display(total_max)
print(f"У сотрудников, перечисленных выше, максимальное количество правил доступа, \
дублирующих разрешения в других правилах доступа. Максимальное количество дублей \
увеличивает вероятность их пересечения с дублями разрешений у других сотрудников, \
поэтому оптимизацию существующих разрешений в Tessa предлагается начать c этого сотрудника.")