nautobot 2.1.0b1__py3-none-any.whl → 2.1.1__py3-none-any.whl

nautobot/ui/src/utils/api.js

@@ -1,160 +0,0 @@
-import { createApi, fetchBaseQuery, retry } from "@reduxjs/toolkit/query/react";
-import {
-    API_BASE,
-    API_OBJECT_COUNTS,
-    API_USER_SESSION_INFO,
-    API_UI_MENU_INFO,
-    API_UI_READY_ROUTES,
-    API_USER_AUTHENTICATE,
-    AUTH_LOGOUT,
-} from "@constants/apiPath";
-
-/*
-  The one true API!
-
-  Using Redux's RTK Query making fetching and caching a breeze! This will provide hooks and wires automagically.
-
-  A standardized convention for retrieving data which should make developer's lives easier and is already extensively documented
-  in React and Redux's sites.
-*/
-
-/**
- * A custom baseQuery that will retry requests that fail with a 5xx error code.
- *
- * @param {Object} args - The arguments passed to the query.
- * @param {Object} api - The API object.
- * @param {Object} extraOptions - Extra options passed to the query.
- * @returns {Object} - The result of the query.
- */
-const smartRetryBaseQuery = retry(
-    async (args, api, extraOptions) => {
-        const result = await fetchBaseQuery({ baseUrl: "" })(
-            args,
-            api,
-            extraOptions
-        );
-        const dontRetryHeaders = [400, 401, 403, 404, 405, 406, 407];
-        if (dontRetryHeaders.includes(result.error?.status)) {
-            retry.fail(result.error);
-        }
-        return result;
-    },
-    {
-        maxRetries: 5,
-    }
-);
-
-/** The base RTK Query API object that will be used to create the endpoints. */
-export const baseApi = createApi({
-    baseQuery: smartRetryBaseQuery,
-    endpoints: (builder) => ({
-        /** The query to retrieve the session data. */
-        getSession: builder.query({
-            query: () => API_USER_SESSION_INFO,
-            providesTags: ["Session"],
-            invalidatesTags: ["APIData", "AppData"],
-        }),
-        /** The query to retrieve the menu data. */
-        getUIMenu: builder.query({
-            query: () => API_UI_MENU_INFO,
-            providesTags: ["AppData"],
-        }),
-        /** The query to retrieve object counts (used on the homepage). */
-        getObjectCounts: builder.query({
-            query: () => API_OBJECT_COUNTS,
-            providesTags: ["ObjectCounts"],
-        }),
-        /** The query to retrieve object data from RESTful API. */
-        getRESTAPI: builder.query({
-            query: ({
-                app_label,
-                model_name,
-                uuid = null,
-                schema = false,
-                plugin = false,
-                limit = null,
-                offset = null,
-                depth = 1,
-                filters = null,
-            }) => {
-                let url = `${API_BASE}/${
-                    plugin ? "plugins/" : ""
-                }${app_label}/${model_name}/`;
-                let method = "GET";
-                let queryParams = null;
-                if (schema) {
-                    method = "OPTIONS";
-                } else {
-                    if (uuid) {
-                        url += `${uuid}/`;
-                    }
-                    queryParams = new URLSearchParams([["depth", depth]]);
-                    if (limit) {
-                        queryParams.append("limit", limit);
-                    }
-                    if (offset) {
-                        queryParams.append("offset", offset);
-                    }
-                    if (filters) {
-                        [
-                            ...(filters instanceof URLSearchParams
-                                ? filters
-                                : new URLSearchParams(filters)),
-                        ].forEach(([param, value]) =>
-                            queryParams.append(param, value)
-                        );
-                    }
-                }
-
-                if (queryParams) {
-                    url += `?${queryParams.toString()}`;
-                }
-
-                return { url: url, method: method };
-            },
-            providesTags: ["APIData"],
-        }),
-        /** The mutation to log in */
-        login: builder.mutation({
-            query: ({ username, password }) => ({
-                url: API_USER_AUTHENTICATE,
-                method: "POST",
-                body: { username, password },
-            }),
-        }),
-        /** The mutation to log out. While is a GET, it changes data on the back-end */
-        logout: builder.mutation({
-            query: () => ({
-                url: AUTH_LOGOUT,
-                method: "GET",
-            }),
-        }),
-        getNewUIReadyRoutes: builder.query({
-            query: () => ({
-                url: API_UI_READY_ROUTES,
-                method: "GET",
-            }),
-        }),
-    }),
-});
-
-export const fetcher = (url) =>
-    fetch(url, { credentials: "include" }).then((res) => {
-        // We have to do this here because 4xx and 5xx errors
-        // are considered as a successful request.
-        if (!res.ok) {
-            throw new Error("Something Went Wrong");
-        } else {
-            return res.json();
-        }
-    });
-
-export const {
-    useGetSessionQuery,
-    useGetUIMenuQuery,
-    useGetRESTAPIQuery,
-    useGetObjectCountsQuery,
-    useGetNewUIReadyRoutesQuery,
-    useLoginMutation,
-    useLogoutMutation,
-} = baseApi;

nautobot/ui/src/utils/app-import.js

@@ -1,15 +0,0 @@
-import NautobotApps from "@generated/app_imports";
-
-function EmptyElement() {
-    return <></>;
-}
-
-function findOrEmpty(module, key) {
-    return key in module ? module[key] : EmptyElement;
-}
-
-export function getComponentFromModule(module_name, component_name) {
-    return NautobotApps[module_name]
-        .then((module) => ({ default: findOrEmpty(module, component_name) }))
-        .catch({ default: EmptyElement });
-}

nautobot/ui/src/utils/color.js

@@ -1,15 +0,0 @@
-export function hexToRgb(hex) {
-    var result = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i.exec(hex);
-    return result
-        ? [
-              parseInt(result[1], 16),
-              parseInt(result[2], 16),
-              parseInt(result[3], 16),
-          ]
-        : null;
-}
-
-export function calculateLuminance(hex_color) {
-    var [R, G, B] = hexToRgb(hex_color);
-    return (R + R + R + B + G + G + G + G + G + G) / 10;
-}

nautobot/ui/src/utils/date.js

@@ -1,14 +0,0 @@
-export function humanFriendlyDate(dateStr) {
-    const date = new Date(dateStr);
-    return (
-        date.getFullYear().toString() +
-        "-" +
-        (date.getMonth() + 1).toString().padStart(2, "0") +
-        "-" +
-        date.getDate().toString().padStart(2, "0") +
-        " " +
-        date.getHours().toString().padStart(2, "0") +
-        ":" +
-        date.getMinutes().toString().padStart(2, "0")
-    );
-}

nautobot/ui/src/utils/index.js

@@ -1,15 +0,0 @@
-export { getComponentFromModule } from "./app-import";
-
-export { getPluginRoutes } from "./navigation";
-
-export {
-    useGetSessionQuery,
-    useGetUIMenuQuery,
-    useGetRESTAPIQuery,
-    useGetObjectCountsQuery,
-    baseApi,
-} from "./api";
-
-export { toTitleCase } from "./string";
-
-export { uiUrl } from "./url";

nautobot/ui/src/utils/navigation.js

@@ -1,48 +0,0 @@
-import { Suspense } from "react";
-import { lazy } from "react";
-import { getComponentFromModule } from "./app-import";
-import { LoadingWidget } from "@components/LoadingWidget";
-
-let app_routes = {};
-try {
-    app_routes = require("@generated/app_routes.json");
-} catch {}
-
-export function getPluginRoutes() {
-    let react_routes = [];
-
-    for (const [app_name, routes] of Object.entries(app_routes)) {
-        for (const { path, component } of routes) {
-            const Component = lazy(() =>
-                getComponentFromModule(app_name, component)
-            );
-            const route_data = {
-                path,
-                element: (
-                    <Suspense fallback={<LoadingWidget />}>
-                        <Component />
-                    </Suspense>
-                ),
-            };
-            react_routes.push(route_data);
-        }
-    }
-
-    return react_routes;
-}
-
-export function isRouteNewUIReady(route, newUIReadyRoutesRegexPatterns) {
-    if (process.env.NODE_ENV === "development") {
-        return true;
-    }
-
-    for (const pattern of newUIReadyRoutesRegexPatterns) {
-        const regex = new RegExp(pattern);
-        const match = regex.exec(route);
-        if (match) {
-            return true;
-        }
-    }
-
-    return false;
-}

nautobot/ui/src/utils/session.js

@@ -1,64 +0,0 @@
-// TODO: This file may go away entirely with the RTK Query pattern
-import axios from "axios";
-import { API_USER_SESSION_INFO } from "@constants/apiPath";
-import { createAsyncThunk, createSlice } from "@reduxjs/toolkit";
-
-export function getSession() {}
-
-export function setSession(session_object) {}
-
-export const fetchSessionAsync = createAsyncThunk(
-    "session/fetchSession",
-    async () => {
-        const response = await axios.get(API_USER_SESSION_INFO);
-        // The value we return becomes the `fulfilled` action payload
-        return response.data;
-    }
-);
-
-const initialState = {
-    logged_in: false,
-    userinfo: {
-        display: "Anonymous",
-    },
-    status: "starting",
-    backends: [],
-    sso_enabled: false,
-    sso_user: false,
-};
-
-function decomposeSessionToState(state, payload) {
-    state.userinfo = payload.user;
-    state.logged_in = payload.logged_in;
-    state.sso_enabled = payload.sso_enabled;
-    state.sso_user = payload.sso_user;
-}
-
-export const sessionSlice = createSlice({
-    name: "session",
-    initialState,
-    reducers: {
-        login: (state, action) => {
-            decomposeSessionToState(state, action.payload);
-        },
-    },
-    extraReducers: (builder) => {
-        builder
-            .addCase(fetchSessionAsync.pending, (state) => {
-                state.status = "loading";
-            })
-            .addCase(fetchSessionAsync.fulfilled, (state, action) => {
-                state.status = "idle";
-                decomposeSessionToState(state, action);
-            });
-    },
-});
-
-const { actions, reducer } = sessionSlice;
-
-export const selectLoggedIn = (state) => state.session.logged_in;
-export const selectUsername = (state) =>
-    (state.session.userinfo && state.session.userinfo.display) || "";
-
-export const { login } = actions;
-export default reducer;

nautobot/ui/src/utils/store.js

@@ -1,242 +0,0 @@
-import { configureStore } from "@reduxjs/toolkit";
-import { baseApi } from "@utils/api";
-import { combineReducers } from "redux";
-import { createSlice } from "@reduxjs/toolkit";
-import {
-    persistReducer,
-    FLUSH,
-    REHYDRATE,
-    PAUSE,
-    PERSIST,
-    PURGE,
-    REGISTER,
-} from "redux-persist";
-import storage from "redux-persist/lib/storage";
-
-//
-// Auth
-//
-
-const initialAuthState = {
-    logged_in: false,
-    user: {},
-    sso_enabled: false,
-    backends: [],
-};
-
-/**
- * Redux slice for logged_in state
- * @param {Object} state - The current state
- * @returns {boolean} - Whether the user is logged in
- */
-export function isLoggedInSelector(state) {
-    return state?.appState?.auth?.logged_in || false;
-}
-
-/**
- * Redux slice for current user state
- * @param {Object} state - The current state
- * @returns {Object} - Whether the user is logged in
- */
-export function currentUserSelector(state) {
-    return state?.appState?.auth?.user || {};
-}
-
-//
-// Navigation
-//
-
-const initialCurrentContext = "Inventory";
-
-const initialNavigationState = {
-    currentContext: initialCurrentContext, // TODO: Add sidebar support for null
-    contextToRoute: {},
-    routeToContext: {},
-};
-
-/**
- * Given an App Label and Model Name, return the current context
- * @param {string} app_label
- * @param {string} model_name
- * @returns {string} The current context
- */
-export function getCurrentAppContextSelector(app_label, model_name) {
-    return (store) => {
-        return (
-            store?.appState?.navigation?.routeToContext[app_label]?.[
-                model_name
-            ] || initialCurrentContext
-        );
-        // TODO: We should probably throw an error or not fall back to Inventory if the context is not found
-    };
-}
-/**
- *
- * @param {Object} state - The current state
- * @returns
- */
-export function getCurrentContextSelector(state) {
-    return state?.appState?.navigation?.currentContext || initialCurrentContext;
-}
-
-/**
- * Retrieve the contextToRoute object from the application state
- * @param {Object} state
- * @returns {Object} The navigation slice of the application state
- */
-export function getMenuInfoSelector(state) {
-    return state?.appState?.navigation?.contextToRoute || {};
-}
-
-//
-// App State
-//
-
-const initialAppState = {
-    auth: structuredClone(initialAuthState),
-    navigation: structuredClone(initialNavigationState),
-};
-
-const appStateSlice = createSlice({
-    name: "appState",
-    initialState: initialAppState,
-    reducers: {
-        /**
-         * Updates the current context of the app
-         * @param {Object} state - The current state
-         * @param {Object} action - The called-with payload, which should be one of the keys in the contextToRoute object
-         * @returns
-         */
-        updateCurrentContext(state, action) {
-            // TODO: Add validation that the payload is a valid context
-            state.navigation.currentContext = action.payload;
-            return state;
-        },
-        /**
-         * Given an API payload with the menu information store both directions of menu
-         * - Context (Inventory, Circuits, etc) to Route (app/model) (contextToRoute)
-         * - Route (app/model) to Context (Inventory, Circuits, etc) (routeToContext)
-         * @param {Object} state - The current state
-         * @param {Object} action - The called-with payload (from the API)
-         * @returns The updated state
-         */
-        updateNavigation(state, action) {
-            let menuInfo = action.payload;
-            state.navigation =
-                state.navigation || structuredClone(initialNavigationState);
-            state.navigation.contextToRoute = menuInfo;
-            let urlPatternToContext = {};
-            for (const context in menuInfo) {
-                for (const group in menuInfo[context]) {
-                    for (const urlPatternOrSubGroupName in menuInfo[context][
-                        group
-                    ]) {
-                        const urlPatternOrSubGroup =
-                            menuInfo[context][group][urlPatternOrSubGroupName];
-                        if (typeof urlPatternOrSubGroup === "string") {
-                            // It's a URL pattern
-                            let tokens = urlPatternOrSubGroup.split("/");
-                            if (tokens.length === 4) {
-                                let appLabel = tokens[1];
-                                let modelNamePlural = tokens[2];
-                                if (appLabel in urlPatternToContext === false) {
-                                    urlPatternToContext[appLabel] = {};
-                                }
-                                urlPatternToContext[appLabel][modelNamePlural] =
-                                    context;
-                            }
-                        } else {
-                            // It's a submenu
-                            for (const urlPattern in urlPatternOrSubGroup) {
-                                let tokens = urlPattern.split("/");
-                                if (tokens.length === 4) {
-                                    let appLabel = tokens[1];
-                                    let modelNamePlural = tokens[2];
-                                    if (
-                                        appLabel in urlPatternToContext ===
-                                        false
-                                    ) {
-                                        urlPatternToContext[appLabel] = {};
-                                    }
-                                    urlPatternToContext[appLabel][
-                                        modelNamePlural
-                                    ] = context;
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-
-            state.navigation.routeToContext = urlPatternToContext;
-            return state;
-        },
-        /**
-         * Given an API payload with session information, updates the state with the session information
-         * @param {Object} state - The current state
-         * @param {Object} action - The called-with payload and action type
-         * @returns The updated state
-         */
-        updateAuthStateWithSession(state, action) {
-            state.auth = state.auth || structuredClone(initialAuthState);
-            state.auth.user = action.payload.user;
-            state.auth.logged_in = action.payload.logged_in;
-            state.auth.sso_enabled = action.payload.sso_enabled;
-            state.auth.backends = action.payload.backends;
-            return state;
-        },
-        /**
-         * Set the user back to logged-out and clear the user object
-         * @param {Object} state - The current state
-         * @param {*} _ - The called-with payload, ignored here
-         * @returns The updated state
-         */
-        flushSessionState(state, _) {
-            state.auth.user = {};
-            state.auth.logged_in = false;
-            return state;
-        },
-    },
-});
-
-// The actions available to update the App State slice
-export const {
-    updateCurrentContext,
-    updateNavigation,
-    updateAuthStateWithSession,
-    flushSessionState,
-} = appStateSlice.actions;
-
-// Combine our internal app state reducers with the RTK Query reducers
-const rootReducer = combineReducers({
-    [baseApi.reducerPath]: baseApi.reducer,
-    appState: appStateSlice.reducer,
-});
-
-// Configure redux-persist to save state in Local Storage for performance
-const persistConfig = {
-    key: "root",
-    version: 3, // Increment this number if you change the shape of the state
-    storage,
-};
-
-// Instantiate the persistent reducer to pull state from cache
-const persistedReducer = persistReducer(persistConfig, rootReducer);
-
-// Global Redux store for global state management
-export const store = configureStore({
-    reducer: persistedReducer,
-    middleware: (getDefaultMiddleware) =>
-        getDefaultMiddleware({
-            serializableCheck: {
-                ignoredActions: [
-                    FLUSH,
-                    REHYDRATE,
-                    PAUSE,
-                    PERSIST,
-                    PURGE,
-                    REGISTER,
-                ],
-            },
-        }).concat(baseApi.middleware),
-});

nautobot/ui/src/utils/string.js

@@ -1,6 +0,0 @@
-export function toTitleCase(str, separator = " ") {
-    return str
-        .split(separator)
-        .map((x) => (x ? x[0].toUpperCase() + x.slice(1) : ""))
-        .join(" ");
-}

nautobot/ui/src/utils/url.js

@@ -1,4 +0,0 @@
-/* Convert an API URL into its presumed UI equivalent */
-export function uiUrl(apiUrl) {
-    return apiUrl.replace("/api/", "/");
-}