meerschaum 2.9.5__py3-none-any.whl → 3.0.0__py3-none-any.whl

meerschaum/api/dash/callbacks/pipes.py

@@ -5,22 +5,35 @@
 Define callbacks for the `/dash/pipes/` page.
 """
 
-from urllib.parse import parse_qs
+from urllib.parse import parse_qs, quote_plus
+from typing import List, Optional, Dict, Any
 
+import dash
 from dash.dependencies import Input, Output, State
 from dash import no_update
+from dash.exceptions import PreventUpdate
+import dash_bootstrap_components as dbc
 
 import meerschaum as mrsm
 from meerschaum.api.dash import dash_app
-from meerschaum.api.dash.pipes import build_pipe_card
-from meerschaum.api import CHECK_UPDATE
+from meerschaum.api.dash.components import (
+    alert_from_success_tuple,
+    build_cards_grid,
+)
+from meerschaum.api.dash.pipes import (
+    build_pipe_card,
+    build_pipes_dropdown_keys_row,
+    build_pipes_tags_dropdown,
+    build_pipes_navbar,
+)
+from meerschaum.api import CHECK_UPDATE, get_api_connector
 from meerschaum.utils.packages import import_html, import_dcc
 from meerschaum.api.dash.sessions import is_session_authenticated
-from meerschaum.utils.typing import Optional, Dict, Any
 html, dcc = import_html(check_update=CHECK_UPDATE), import_dcc(check_update=CHECK_UPDATE)
 
 
 @dash_app.callback(
+    Output('pipes-navbar-div', 'children'),
     Output('pipe-output-div', 'children'),
     Input('pipes-location', 'pathname'),
     State('pipes-location', 'search'),
@@ -32,24 +45,191 @@ def render_pipe_page_from_url(
     session_data: Optional[Dict[str, Any]],
 ):
     if not str(pathname).startswith('/dash/pipes'):
-        return no_update
+        raise PreventUpdate
 
     session_id = (session_data or {}).get('session-id', None)
     authenticated = is_session_authenticated(str(session_id))
+    query_params = parse_qs(pipe_search.lstrip('?')) if pipe_search else {}
+    instance = query_params.get('instance', [None])[0] or str(get_api_connector())
+    tags = query_params.get('tags', [None])[0] or []
+    if isinstance(tags, str):
+        tags = tags.split(',')
+
+    connector_keys = query_params.get('connector_keys', [None])[0] or []
+    if isinstance(connector_keys, str):
+        connector_keys = connector_keys.split(',')
+
+    metric_keys = query_params.get('metric_keys', [None])[0] or []
+    if isinstance(metric_keys, str):
+        metric_keys = metric_keys.split(',')
+
+    location_keys = query_params.get('location_keys', [None])[0] or []
+    if isinstance(location_keys, str):
+        location_keys = location_keys.split(',')
 
     keys = pathname.replace('/dash/pipes', '').lstrip('/').rstrip('/').split('/')
-    if len(keys) not in (2, 3):
-        return no_update
+    instance_connector = mrsm.get_connector(instance)
+    viewing_single_pipe = len(keys) in (2, 3)
+    if instance_connector is None:
+        return (
+            build_pipes_navbar(instance, with_instance_select=(not viewing_single_pipe)),
+            [
+                html.Br(),
+                alert_from_success_tuple((False, f"Invalid instance keys '{instance}'.")),
+                html.Br(),
+            ]
+        )
+
+    if not viewing_single_pipe:
+        try:
+            pipes = mrsm.get_pipes(
+                as_list=True,
+                connector_keys=connector_keys,
+                metric_keys=metric_keys,
+                location_keys=location_keys,
+                tags=tags,
+                instance=instance_connector,
+            )
+        except Exception as e:
+            return (
+                build_pipes_navbar(instance, with_instance_select=False),
+                [
+                    html.Br(),
+                    alert_from_success_tuple(
+                        (False, f"Failed to get pipes for instance '{instance}':\n{e}")
+                    ),
+                    html.Br(),
+                    dbc.Row(
+                        [
+                            dbc.Button(
+                                "Reload",
+                                id='pipes-reload-button',
+                                size='lg',
+                                href=(
+                                    "/dash/pipes"
+                                    if pathname.startswith('/dash/pipes/')
+                                    else "/dash/pipes/" 
+                                )
+                            ),
+                        ],
+                        justify='center',
+                        align='center',
+                        className='h-50',
+                    ),
+                ]
+            )
+
+        cards = [
+            build_pipe_card(pipe, authenticated=authenticated, include_manage=False)
+            for pipe in pipes
+        ]
+        return (
+            build_pipes_navbar(instance, with_instance_select=True),
+            [
+                html.Div([
+                    html.Br(),
+                    build_pipes_dropdown_keys_row(
+                        connector_keys,
+                        metric_keys,
+                        location_keys,
+                        tags,
+                        pipes,
+                        instance_connector,
+                    ),
+                    html.Br(),
+                    build_pipes_tags_dropdown(
+                        connector_keys,
+                        metric_keys,
+                        location_keys,
+                        tags,
+                        instance,
+                    ),
+                ]),
+                html.Br(),
+                build_cards_grid(cards, 1),
+                html.Br(),
+            ]
+        )
 
     ck = keys[0]
     mk = keys[1]
     lk = keys[2] if len(keys) == 3 else None
-    query_params = parse_qs(pipe_search.lstrip('?')) if pipe_search else {}
-    instance = query_params.get('instance', [None])[0]
 
     pipe = mrsm.Pipe(ck, mk, lk, instance=instance)
-    return [
-        html.Br(),
-        build_pipe_card(pipe, authenticated=authenticated, include_manage=False),
-        html.Br(),
-    ]
+    return (
+        build_pipes_navbar(instance, with_instance_select=False),
+        [
+            html.Br(),
+            build_pipe_card(pipe, authenticated=authenticated, include_manage=False),
+            html.Br(),
+        ]
+    )
+
+
+@dash_app.callback(
+    Output('pipes-location', 'search'),
+    Input('pipes-connector-keys-dropdown', 'value'),
+    Input('pipes-metric-keys-dropdown', 'value'),
+    Input('pipes-location-keys-dropdown', 'value'),
+    Input('pipes-tags-dropdown', 'value'),
+    Input('instance-select', 'value'),
+    Input('pipes-clear-all-button', 'n_clicks'),
+)
+def update_location_on_pipes_filter_change(
+    connector_keys: Optional[List[str]],
+    metric_keys: Optional[List[str]],
+    location_keys: Optional[List[str]],
+    tags: Optional[List[str]],
+    instance_keys: str,
+    clear_all_button_n_clicks: Optional[int],
+):
+    """
+    Update the URL parameters when clicking the dropdowns.
+    """
+    ctx = dash.callback_context.triggered
+    if len(ctx) != 1:
+        raise PreventUpdate
+
+    if not any(
+        (connector_keys or [])
+        + (metric_keys or [])
+        + (location_keys or [])
+        + (tags or [])
+        + ([instance_keys] if instance_keys else [])
+    ):
+        return ''
+
+    if ctx[0].get('prop_id', None) == 'pipes-clear-all-button.n_clicks':
+        connector_keys = []
+        metric_keys = []
+        location_keys = []
+        tags = []
+
+    include_instance_keys = instance_keys and instance_keys != str(get_api_connector())
+    search_str = ""
+    
+    if connector_keys:
+        search_str += "connector_keys=" + ','.join((quote_plus(ck) for ck in connector_keys))
+        if metric_keys or location_keys or tags or include_instance_keys:
+            search_str += '&'
+
+    if metric_keys:
+        search_str += "metric_keys=" + ','.join((quote_plus(mk) for mk in metric_keys))
+        if location_keys or tags or include_instance_keys:
+            search_str += '&'
+
+    if location_keys:
+        search_str += "location_keys=" + ','.join((quote_plus(str(lk)) for lk in location_keys))
+        if tags or include_instance_keys:
+            search_str += '&'
+
+    if tags:
+        search_str += "tags=" + ','.join((quote_plus(tag) for tag in tags))
+        if include_instance_keys:
+            search_str += '&'
+
+    if instance_keys:
+        if include_instance_keys:
+            search_str += "instance=" + quote_plus(instance_keys)
+
+    return ('?' + search_str) if search_str else ''

meerschaum/api/dash/callbacks/plugins.py

@@ -66,4 +66,3 @@ def edit_plugin_description(
         success, _msg = get_api_connector().register_plugin(plugin, debug=debug, force=True)
         msg = _msg if not success else "Successfully updated description."
     return [alert_from_success_tuple((success, msg))]
-

meerschaum/api/dash/callbacks/register.py

@@ -13,8 +13,9 @@ from meerschaum.api.dash.sessions import set_session
 from dash.dependencies import Input, Output, State, ALL, MATCH
 from dash.exceptions import PreventUpdate
 from meerschaum.core import User
-from meerschaum.config.static import STATIC_CONFIG
+from meerschaum._internal.static import STATIC_CONFIG
 from meerschaum.utils.packages import attempt_import
+from meerschaum.api._oauth2 import CustomOAuth2PasswordRequestForm
 dash = attempt_import('dash', check_update=CHECK_UPDATE)
 from fastapi.exceptions import HTTPException
 
@@ -97,10 +98,16 @@ def register_button_click(
         form_class += ' is-invalid'
         return {}, form_class, dash.no_update
     try:
-        _ = login({'username': username, 'password': password})
+        form = CustomOAuth2PasswordRequestForm(
+            grant_type='password',
+            username=username,
+            password=password,
+            scope=' '.join(STATIC_CONFIG['tokens']['scopes'])
+        )
+        _ = login(form)
         session_data = {'session-id': str(uuid.uuid4())}
         set_session(session_data['session-id'], {'username': username})
-    except HTTPException as e:
+    except HTTPException:
         form_class += ' is-invalid'
         session_data = None
     return session_data, form_class, (dash.no_update if not session_data else endpoints['dash'])

meerschaum/api/dash/callbacks/settings/password_reset.py

@@ -11,7 +11,7 @@ from dash.dependencies import Input, Output, State
 import dash_bootstrap_components as dbc
 
 from meerschaum.core.User import User
-from meerschaum.config.static import STATIC_CONFIG
+from meerschaum._internal.static import STATIC_CONFIG
 from meerschaum.api import get_api_connector, debug
 from meerschaum.api.dash import dash_app
 from meerschaum.api.dash.components import alert_from_success_tuple
@@ -39,7 +39,7 @@ def password_reset_button_click(n_clicks, new_password_value, session_store_data
         )
 
     instance_connector = get_api_connector()
-    user = User(username, new_password_value)
+    user = User(username, new_password_value, instance=instance_connector)
     success, msg = instance_connector.edit_user(user, debug=debug)
     return alert_from_success_tuple((success, msg))
 

meerschaum/api/dash/callbacks/tokens.py

@@ -0,0 +1,389 @@
+#! /usr/bin/env python3
+# vim:fenc=utf-8
+
+"""
+Define the callbacks for the tokens page.
+"""
+
+import json
+from typing import Optional, List, Dict, Any, Tuple
+from datetime import datetime, timezone
+
+import dash
+from dash.dependencies import Input, Output, State, MATCH, ALL
+from dash.exceptions import PreventUpdate
+import dash_bootstrap_components as dbc
+import dash.html as html
+import dash.dcc as dcc
+
+import meerschaum as mrsm
+from meerschaum.api import get_api_connector, debug
+from meerschaum.api.dash import dash_app
+from meerschaum.api.dash.sessions import get_user_from_session
+from meerschaum.api.dash.components import alert_from_success_tuple, build_cards_grid
+from meerschaum.api.dash.tokens import (
+    get_tokens_cards,
+    get_tokens_table,
+    build_tokens_register_input_modal,
+    build_tokens_register_output_modal,
+)
+from meerschaum._internal.static import STATIC_CONFIG
+from meerschaum.utils.daemon import get_new_daemon_name
+from meerschaum.core import Token
+
+
+@dash_app.callback(
+    Output('tokens-output-div', 'children'),
+    Output('tokens-register-input-modal', 'children'),
+    Output('tokens-alert-div', 'children'),
+    Input('tokens-refresh-button', 'n_clicks'),
+    State('session-store', 'data'),
+)
+def refresh_tokens_button_click(
+    n_clicks: Optional[int],
+    session_data: Optional[Dict[str, Any]] = None,
+):
+    """
+    Build the tokens cards on load or refresh.
+    """
+    session_id = (session_data or {}).get('session-id', None)
+    tokens_table, alerts = get_tokens_table(session_id)
+    if not tokens_table:
+        return (
+            [
+                html.H4('No tokens registered.'),
+                html.P('Click the `+` button to register a new token.'),
+            ],
+            build_tokens_register_input_modal(),
+            alerts,
+        )
+
+    return tokens_table, build_tokens_register_input_modal(), alerts
+
+
+@dash_app.callback(
+    Output('tokens-register-input-modal', 'is_open'),
+    Input('tokens-create-button', 'n_clicks'),
+    prevent_initial_call=True,
+)
+def create_tokens_button_click(n_clicks: Optional[int]):
+    """
+    Open the tokens registration modal when the plus button is clicked.
+    """
+    if not n_clicks:
+        raise PreventUpdate
+
+    return True
+
+
+@dash_app.callback(
+    Output("tokens-scopes-checklist-div", 'style'),
+    Input("tokens-toggle-scopes-switch", 'value'),
+    prevent_initial_call=True,
+)
+def toggle_token_scopes_checklist(value: bool):
+    """
+    Toggle the scopes checklist.
+    """
+    return {'display': 'none'} if value else {}
+
+
+@dash_app.callback(
+    Output('tokens-scopes-checklist', 'value'),
+    Output('tokens-deselect-scopes-button', 'children'),
+    Input('tokens-deselect-scopes-button', 'n_clicks'),
+    State('tokens-deselect-scopes-button', 'children'),
+    prevent_initial_call=True,
+)
+def deselect_scopes_click(n_clicks: Optional[int], name: str):
+    """
+    Set the value of the scopes checklist to an empty list.
+    """
+    if not n_clicks:
+        raise PreventUpdate
+
+    new_name = 'Select all' if name == 'Deselect all' else 'Deselect all'
+    value = (
+        []
+        if name == 'Deselect all'
+        else list(STATIC_CONFIG['tokens']['scopes'])
+    )
+
+    return value, new_name
+
+
+@dash_app.callback(
+    Output({'type': 'tokens-scopes-checklist', 'index': MATCH}, 'value'),
+    Output({'type': 'tokens-deselect-scopes-button', 'index': MATCH}, 'children'),
+    Input({'type': 'tokens-deselect-scopes-button', 'index': MATCH}, 'n_clicks'),
+    State({'type': 'tokens-deselect-scopes-button', 'index': MATCH}, 'children'),
+    prevent_initial_call=True,
+)
+def edit_token_deselect_scopes_click(n_clicks: Optional[int], name: str):
+    """
+    Set the value of the scopes checklist to an empty list.
+    """
+    if not n_clicks:
+        raise PreventUpdate
+
+    new_name = 'Select all' if name == 'Deselect all' else 'Deselect all'
+    value = (
+        []
+        if name == 'Deselect all'
+        else list(STATIC_CONFIG['tokens']['scopes'])
+    )
+
+    return value, new_name
+
+
+@dash_app.callback(
+    Output('tokens-register-input-modal', 'is_open'),
+    Output('tokens-register-output-modal', 'is_open'),
+    Output('tokens-register-output-modal', 'children'),
+    Input('tokens-register-button', 'n_clicks'),
+    State('tokens-name-input', 'value'),
+    State('tokens-scopes-checklist', 'value'),
+    State('tokens-expiration-datepickersingle', 'date'),
+    State('session-store', 'data'),
+    prevent_initial_call=True,
+)
+def register_token_click(
+    n_clicks: Optional[int],
+    name: str,
+    scopes: List[str],
+    expiration: Optional[datetime] = None,
+    session_data: Optional[Dict[str, Any]] = None,
+):
+    """
+    Register the token.
+    """
+    if not n_clicks:
+        raise PreventUpdate
+
+    session_id = (session_data or {}).get('session-id', None)
+    token = Token(
+        label=(name or None),
+        user=get_user_from_session(session_id),
+        expiration=(datetime.fromisoformat(f"{expiration}") if expiration is not None else None),
+    )
+    return False, True, build_tokens_register_output_modal(token)
+
+
+@dash_app.callback(
+    Output("tokens-refresh-button", "n_clicks"),
+    Input("tokens-register-output-modal", "is_open"),
+    Input({'type': 'tokens-edit-modal', 'index': ALL}, 'is_open'),
+    Input({'type': 'tokens-invalidate-modal', 'index': ALL}, 'is_open'),
+    Input({'type': 'tokens-delete-modal', 'index': ALL}, 'is_open'),
+    State("tokens-refresh-button", "n_clicks"),
+    prevent_initial_call=True,
+)
+def register_token_modal_close_refresh(
+    register_is_open: bool,
+    edit_is_open_list,
+    invalidate_is_open_list,
+    delete_is_open_list,
+    n_clicks: int,
+):
+    """
+    Refresh the cards when the registration, edit, invalidate, or delete modals changes visibility.
+    """
+    if any(
+        edit_is_open_list
+        + invalidate_is_open_list
+        + delete_is_open_list
+    ):
+        raise PreventUpdate
+
+    return (n_clicks or 0) + 1
+
+
+@dash_app.callback(
+    Output('tokens-register-clipboard', 'content'),
+    Output('tokens-register-clipboard', 'n_clicks'),
+    Output('tokens-register-copy-button', 'children'),
+    Input('tokens-register-copy-button', 'n_clicks'),
+    State('tokens-register-clipboard', 'n_clicks'),
+    State('token-id-pre', 'children'),
+    State('token-secret-pre', 'children'),
+    prevent_initial_call=True,
+)
+def copy_token_button_click(
+    n_clicks: int,
+    clipboard_n_clicks: Optional[int],
+    token_id: str,
+    token_secret: str,
+) -> Tuple[str, int, str]:
+    """
+    Copy the token's ID and secret to the clipboard.
+    """
+    if not n_clicks:
+        raise PreventUpdate
+    return (
+        f"Client ID: {token_id}\nClient Secret: {token_secret}",
+        (clipboard_n_clicks or 0) + 1,
+        "Copied!",
+    )
+
+
+@dash_app.callback(
+    Output('tokens-close-register-output-modal-button', 'disabled'),
+    Output('tokens-register-output-modal', 'backdrop'),
+    Input('tokens-register-clipboard', 'n_clicks'),
+    prevent_initial_call=True,
+)
+def enable_close_button(n_clicks):
+    """
+    Enable the close button once the token has been copied.
+    """
+    if not n_clicks:
+        raise PreventUpdate
+    return False, True
+
+
+@dash_app.callback(
+    Output('tokens-register-output-modal', 'is_open'),
+    Input('tokens-close-register-output-modal-button', 'n_clicks'),
+    prevent_initial_call=True,
+)
+def close_register_output_modal(n_clicks: int) -> bool:
+    """
+    Close the register output modal when the Close button is clicked.
+    """
+    if not n_clicks:
+        raise PreventUpdate
+    return False
+
+
+@dash_app.callback(
+    Output({'type': 'tokens-edit-modal', 'index': MATCH}, 'is_open'),
+    Input({'type': 'tokens-edit-button', 'index': MATCH}, 'n_clicks'),
+    prevent_initial_call=True,
+)
+def edit_token_button_click(n_clicks: int):
+    if not n_clicks:
+        raise PreventUpdate
+    return True
+
+
+@dash_app.callback(
+    Output({'type': 'tokens-edit-modal', 'index': MATCH}, 'is_open'),
+    Output({'type': 'tokens-edit-alerts-div', 'index': MATCH}, 'children'),
+    Input({'type': 'tokens-edit-submit-button', 'index': MATCH}, 'n_clicks'),
+    State({'type': 'tokens-expiration-datepickersingle', 'index': MATCH}, 'date'),
+    State({'type': 'tokens-scopes-checklist', 'index': MATCH}, 'value'),
+    State({'type': 'tokens-name-input', 'index': MATCH}, 'value'),
+    prevent_initial_call=True,
+)
+def edit_token_submit_button_click(
+    n_clicks: int,
+    expiration: Optional[datetime],
+    scopes: List[str],
+    label: str,
+):
+    if not n_clicks:
+        raise PreventUpdate
+
+    ctx = dash.callback_context.triggered
+    if ctx[0]['value'] is None:
+        raise PreventUpdate
+
+    component_dict = json.loads(ctx[0]['prop_id'].split('.' + 'n_clicks')[0])
+    token_id = component_dict['index']
+
+    token = Token(
+        id=token_id,
+        label=label,
+        expiration=(datetime.fromisoformat(f"{expiration}T00:00:00Z") if expiration is not None else None),
+        scopes=scopes,
+        instance=get_api_connector(),
+    )
+
+    success, msg = token.edit(debug=debug)
+    if not success:
+        return dash.no_update, alert_from_success_tuple((success, msg))
+
+    return False, dash.no_update
+
+
+@dash_app.callback(
+    Output({'type': 'tokens-invalidate-modal', 'index': MATCH}, 'is_open'),
+    Input({'type': 'tokens-invalidate-button', 'index': MATCH}, 'n_clicks'),
+    prevent_initial_call=True,
+)
+def invalidate_token_click(n_clicks: int):
+    if not n_clicks:
+        raise PreventUpdate
+    return True
+
+
+@dash_app.callback(
+    Output({'type': 'tokens-delete-modal', 'index': MATCH}, 'is_open'),
+    Input({'type': 'tokens-delete-button', 'index': MATCH}, 'n_clicks'),
+    prevent_initial_call=True,
+)
+def invalidate_token_click(n_clicks: int):
+    if not n_clicks:
+        raise PreventUpdate
+    return True
+
+
+
+@dash_app.callback(
+    Output({'type': 'tokens-edit-modal', 'index': MATCH}, 'is_open'),
+    Output({'type': 'tokens-invalidate-modal', 'index': MATCH}, 'is_open'),
+    Output({'type': 'tokens-invalidate-alerts-div', 'index': MATCH}, 'children'),
+    Input({'type': 'tokens-invalidate-confirm-button', 'index': MATCH}, 'n_clicks'),
+    prevent_initial_call=True,
+)
+def invalidate_token_confirm_click(n_clicks: int):
+    if not n_clicks:
+        raise PreventUpdate
+
+    ctx = dash.callback_context.triggered
+    if ctx[0]['value'] is None:
+        raise PreventUpdate
+
+    component_dict = json.loads(ctx[0]['prop_id'].split('.' + 'n_clicks')[0])
+    token_id = component_dict['index']
+
+    token = Token(
+        id=token_id,
+        instance=get_api_connector(),
+    )
+
+    success, msg = token.invalidate(debug=debug)
+    if not success:
+        return dash.no_update, dash.no_update, alert_from_success_tuple((success, msg))
+
+    return False, False, dash.no_update
+
+
+@dash_app.callback(
+    Output({'type': 'tokens-edit-modal', 'index': MATCH}, 'is_open'),
+    Output({'type': 'tokens-delete-modal', 'index': MATCH}, 'is_open'),
+    Output({'type': 'tokens-delete-alerts-div', 'index': MATCH}, 'children'),
+    Input({'type': 'tokens-delete-confirm-button', 'index': MATCH}, 'n_clicks'),
+    prevent_initial_call=True,
+)
+def delete_token_confirm_click(n_clicks: int):
+    if not n_clicks:
+        raise PreventUpdate
+
+    ctx = dash.callback_context.triggered
+    if ctx[0]['value'] is None:
+        raise PreventUpdate
+
+    component_dict = json.loads(ctx[0]['prop_id'].split('.' + 'n_clicks')[0])
+    token_id = component_dict['index']
+
+    token = Token(
+        id=token_id,
+        instance=get_api_connector(),
+    )
+
+    success, msg = token.delete(debug=debug)
+    if not success:
+        return dash.no_update, dash.no_update, alert_from_success_tuple((success, msg))
+
+    return False, False, []