diff --git a/docusaurus.config.ts b/docusaurus.config.ts index 90298169e6dbe..7bbd7d58ed350 100644 --- a/docusaurus.config.ts +++ b/docusaurus.config.ts @@ -86,7 +86,9 @@ const config: Config = { { name: 'twitter:image', content: 'https://developer.sailpoint.com/img/SailPoint-Logo-OG.png' }, // Content Security Policy - { 'http-equiv': 'Content-Security-Policy', content: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;" }, + { 'http-equiv': 'Content-Security-Policy', + content: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://o2352gowwy55a4vviyswr76lxu0ednjs.lambda-url.us-east-2.on.aws https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;" }, + ], algolia: { appId: 'TB01H1DFAM', diff --git a/navbar.ts b/navbar.ts index ae0c094a36995..795922cb1bdef 100644 --- a/navbar.ts +++ b/navbar.ts @@ -34,6 +34,7 @@ const navbarConfig = { { label: 'CLI', to: '/docs/tools/cli' }, { label: 'Escaping Tool Formatter', to: '/tools/escaping-tool-formatter' }, { label: 'JSON Path Evaluator', to: '/tools/json-path-evaluator' }, + { label: 'XPath Evaluator', to: '/tools/xpath-evaluator' }, { label: 'Rule Development Kit', to: '/docs/tools/rule-development-kit' }, { label: 'UI Development Kit', to: '/docs/tools/ui-development-kit' }, { label: 'Velocity PlayGround', to: '/tools/velocity-playground' }, diff --git a/src/components/xpath/ImplementationDropdown/index.tsx b/src/components/xpath/ImplementationDropdown/index.tsx new file mode 100644 index 0000000000000..234420693703b --- /dev/null +++ b/src/components/xpath/ImplementationDropdown/index.tsx @@ -0,0 +1,112 @@ +import React, { useState, FocusEvent, ChangeEvent } from 'react'; +import FormControl from '@mui/material/FormControl'; +import InputLabel from '@mui/material/InputLabel'; +import Select from '@mui/material/Select'; +import MenuItem from '@mui/material/MenuItem'; +import { useColorMode } from '@docusaurus/theme-common'; +import { createTheme, ThemeProvider } from '@mui/material/styles'; + +// Define prop types +interface ImplementationDropdownProps { + implementation: string; + onImplementationChange: (value: string) => void; + onFocus?: (event: FocusEvent) => void; + onBlur?: (event: FocusEvent) => void; +} + +const ImplementationDropdown: React.FC = ({ + implementation, + onImplementationChange, + onFocus, + onBlur, +}) => { + const { colorMode } = useColorMode(); + const [isFocused, setIsFocused] = useState(false); + const [expanded, setExpanded] = useState(false); + + const theme = createTheme({ + components: { + MuiOutlinedInput: { + styleOverrides: { + root: { + '& .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? '#ffffff' : 'initial', + borderWidth: 1, + }, + '&.Mui-focused .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + '&:hover .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }, + }, + MuiSelect: { + styleOverrides: { + icon: { + color: colorMode === 'dark' ? '#ffffff' : 'black', + }, + }, + }, + }, + }); + + const handleChange = (event: ChangeEvent<{ value: unknown }>) => { + onImplementationChange(event.target.value as string); + }; + + // Handle focus and blur state changes + const handleFocus = (event: FocusEvent) => { + setIsFocused(true); + if (onFocus) onFocus(event); + }; + + const handleBlur = (event: FocusEvent) => { + setIsFocused(false); + if (onBlur) onBlur(event); + }; + + // Handle dropdown expanded state + const handleDropdownOpen = () => setExpanded(true); + const handleDropdownClose = () => setExpanded(false); + + return ( + + + + Implementation + + + + + + ); +}; + +export default ImplementationDropdown; diff --git a/src/components/xpath/InputTerminal/index.tsx b/src/components/xpath/InputTerminal/index.tsx new file mode 100644 index 0000000000000..5c464b1845cf3 --- /dev/null +++ b/src/components/xpath/InputTerminal/index.tsx @@ -0,0 +1,64 @@ +import React from 'react'; +import AceEditor from 'react-ace'; +import 'ace-builds/src-noconflict/mode-xml'; +import 'ace-builds/src-noconflict/mode-text'; +import 'ace-builds/src-noconflict/theme-github_dark'; +import 'ace-builds/src-noconflict/theme-github_light_default'; +import 'ace-builds/src-noconflict/ext-language_tools'; +import { useColorMode } from '@docusaurus/theme-common'; +import styles from '../../../pages/tools/xpath.module.css'; + +// Ensure ace is properly configured +declare const ace: any; +if (typeof ace !== 'undefined' && ace.config) { + ace.config.setModuleUrl( + 'ace/mode/xml_worker', + new URL( + 'https://ajaxorg.github.io/ace-builds/src-noconflict/worker-xml.js' + ).toString(), + ); +} + +interface InputTerminalProps { + fontSize: string; + value: string; + onChange: (value: string) => void; + hasXmlParseError?: boolean; + mode?: 'xml' | 'text'; // 🔄 new optional mode prop +} + +const InputTerminal: React.FC = ({ + fontSize, + value, + onChange, + hasXmlParseError = false, + mode = 'xml', +}) => { + const { colorMode } = useColorMode(); + + const terminalClass = hasXmlParseError + ? styles.inputTerminalContainer + : styles.terminalContainerDefault; + + return ( +
+

Inputs

+ +
+ ); +}; + +export default InputTerminal; diff --git a/src/components/xpath/ResultTerminal/index.tsx b/src/components/xpath/ResultTerminal/index.tsx new file mode 100644 index 0000000000000..6ca944f2fe4f9 --- /dev/null +++ b/src/components/xpath/ResultTerminal/index.tsx @@ -0,0 +1,54 @@ +import React from 'react'; +import AceEditor from 'react-ace'; +import 'ace-builds/src-noconflict/mode-json'; +import 'ace-builds/src-noconflict/mode-text'; +import 'ace-builds/src-noconflict/theme-github_dark'; +import 'ace-builds/src-noconflict/theme-github_light_default'; +import 'ace-builds/src-noconflict/ext-language_tools'; +import { useColorMode } from '@docusaurus/theme-common'; +import styles from '../../../pages/tools/xpath.module.css'; + +// Ensure ace is properly configured +declare const ace: any; +if (typeof ace !== 'undefined' && ace.config) { + ace.config.setModuleUrl( + 'ace/mode/json_worker', + new URL( + 'https://ajaxorg.github.io/ace-builds/src-noconflict/worker-json.js' + ).toString(), + ); +} + +// Props interface with optional `mode` +interface ResultTerminalProps { + result: string; + fontSize: string; + mode?: 'json' | 'text'; +} + +const ResultTerminal: React.FC = ({ result, fontSize, mode = 'json' }) => { + const { colorMode } = useColorMode(); + + return ( +
+

Evaluation results

+ + +
+ ); +}; + +export default ResultTerminal; diff --git a/src/components/xpath/TerminalFontSizeDropdown/index.tsx b/src/components/xpath/TerminalFontSizeDropdown/index.tsx new file mode 100644 index 0000000000000..3188f2c2d3593 --- /dev/null +++ b/src/components/xpath/TerminalFontSizeDropdown/index.tsx @@ -0,0 +1,114 @@ +import React, { useState, ChangeEvent, FocusEvent } from 'react'; +import FormControl from '@mui/material/FormControl'; +import InputLabel from '@mui/material/InputLabel'; +import Select from '@mui/material/Select'; +import MenuItem from '@mui/material/MenuItem'; +import { createTheme, ThemeProvider } from '@mui/material/styles'; +import { useColorMode } from '@docusaurus/theme-common'; + +// Define props interface +interface TerminalFontSizeDropdownProps { + fontSize: string; + onFontSizeChange: (value: string) => void; + onFocus?: (event: FocusEvent) => void; + onBlur?: (event: FocusEvent) => void; +} + +const TerminalFontSizeDropdown: React.FC = ({ + fontSize, + onFontSizeChange, + onFocus, + onBlur, +}) => { + const { colorMode } = useColorMode(); + const [isFocused, setIsFocused] = useState(false); + const [expanded, setExpanded] = useState(false); + + const theme = createTheme({ + components: { + MuiOutlinedInput: { + styleOverrides: { + root: { + '& .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? '#ffffff' : 'initial', + borderWidth: 1, + }, + '&.Mui-focused .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + '&:hover .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }, + }, + MuiSelect: { + styleOverrides: { + icon: { + color: colorMode === 'dark' ? '#ffffff' : 'black', + }, + }, + }, + }, + }); + + const handleChange = (event: ChangeEvent<{ value: unknown }>) => { + onFontSizeChange(event.target.value as string); + }; + + // Handle focus and blur state changes + const handleFocus = (event: FocusEvent) => { + setIsFocused(true); + if (onFocus) onFocus(event); + }; + + const handleBlur = (event: FocusEvent) => { + setIsFocused(false); + if (onBlur) onBlur(event); + }; + + // Handle dropdown expanded state + const handleDropdownOpen = () => setExpanded(true); + const handleDropdownClose = () => setExpanded(false); + + return ( + + + + Terminal Font Size + + + + + ); +}; + +export default TerminalFontSizeDropdown; diff --git a/src/components/xpath/XPathQueryInput/index.tsx b/src/components/xpath/XPathQueryInput/index.tsx new file mode 100644 index 0000000000000..a66ec3b7f962f --- /dev/null +++ b/src/components/xpath/XPathQueryInput/index.tsx @@ -0,0 +1,69 @@ +import React, { useState, FocusEvent, ChangeEvent } from 'react'; +import TextField from '@mui/material/TextField'; +import { useColorMode } from '@docusaurus/theme-common'; +import { createTheme, ThemeProvider } from '@mui/material/styles'; + +// Define props interface +interface XPathQueryInputProps { + value: string; + onChange: (event: ChangeEvent) => void; + onFocus?: (event: FocusEvent) => void; + onBlur?: (event: FocusEvent) => void; +} + +const XPathQueryInput: React.FC = ({ value, onChange, onFocus, onBlur }) => { + const { colorMode } = useColorMode(); + const [isFocused, setIsFocused] = useState(false); + + const theme = createTheme({ + components: { + MuiOutlinedInput: { + styleOverrides: { + root: { + '& .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? '#ffffff' : 'initial', + borderWidth: 1, + }, + '&:hover .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }, + }, + }, + }); + + return ( + + { + setIsFocused(true); + if (onFocus) onFocus(event); + }} + onBlur={(event) => { + setIsFocused(false); + if (onBlur) onBlur(event); + }} + sx={{ + m: 1, + minWidth: 800, + '& .MuiInputLabel-root': { + color: isFocused ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial', + }, + '& .MuiOutlinedInput-root.Mui-focused': { + '& fieldset': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }} + id="outlined-basic-xpath-input" + label="Enter XPath query" + variant="outlined" + value={value} + onChange={onChange} + /> + + ); +}; + +export default XPathQueryInput; diff --git a/src/components/xpath/XPathRootInput/index.tsx b/src/components/xpath/XPathRootInput/index.tsx new file mode 100644 index 0000000000000..3b8c6bdd46cee --- /dev/null +++ b/src/components/xpath/XPathRootInput/index.tsx @@ -0,0 +1,69 @@ +import React, { useState, FocusEvent, ChangeEvent } from 'react'; +import TextField from '@mui/material/TextField'; +import { useColorMode } from '@docusaurus/theme-common'; +import { createTheme, ThemeProvider } from '@mui/material/styles'; + +// Define props interface +interface XPathRootInputProps { + value: string; + onChange: (event: ChangeEvent) => void; + onFocus?: (event: FocusEvent) => void; + onBlur?: (event: FocusEvent) => void; +} + +const XPathRootInput: React.FC = ({ value, onChange, onFocus, onBlur }) => { + const { colorMode } = useColorMode(); + const [isFocused, setIsFocused] = useState(false); + + const theme = createTheme({ + components: { + MuiOutlinedInput: { + styleOverrides: { + root: { + '& .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? '#ffffff' : 'initial', + borderWidth: 1, + }, + '&:hover .MuiOutlinedInput-notchedOutline': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }, + }, + }, + }); + + return ( + + { + setIsFocused(true); + if (onFocus) onFocus(event); + }} + onBlur={(event) => { + setIsFocused(false); + if (onBlur) onBlur(event); + }} + sx={{ + m: 1, + minWidth: 800, + '& .MuiInputLabel-root': { + color: isFocused ? (colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)') : 'initial', + }, + '& .MuiOutlinedInput-root.Mui-focused': { + '& fieldset': { + borderColor: colorMode === 'dark' ? 'rgb(115,200,235)' : 'rgb(4,125,246)', + }, + }, + }} + id="outlined-basic-xpath-input" + label="Enter XPath root" + variant="outlined" + value={value} + onChange={onChange} + /> + + ); +}; + +export default XPathRootInput; diff --git a/src/components/xpath/useDebounce.ts b/src/components/xpath/useDebounce.ts new file mode 100644 index 0000000000000..481ad379e122d --- /dev/null +++ b/src/components/xpath/useDebounce.ts @@ -0,0 +1,16 @@ +import { useState, useEffect } from 'react'; + +// Define the hook's return type +export function useDebounce(value: T, delay: number): T { + const [debouncedValue, setDebouncedValue] = useState(value); + + useEffect(() => { + const handler = setTimeout(() => { + setDebouncedValue(value); + }, delay); + + return () => clearTimeout(handler); + }, [value, delay]); + + return debouncedValue; +} diff --git a/src/pages/tools/EscapeTool.module.css b/src/pages/tools/EscapeTool.module.css index 7187a01c6cbf5..daa975baa60dd 100644 --- a/src/pages/tools/EscapeTool.module.css +++ b/src/pages/tools/EscapeTool.module.css @@ -31,12 +31,12 @@ background: var(--terminal-background) !important; } -a[id^='jsonpathDocumentationLink'] { +a[id^='xpathDocumentationLink'] { color: var(--link-color) !important; text-decoration: underline !important; } -a[id^='jsonpathDocumentationLink']:hover { +a[id^='xpathDocumentationLink']:hover { text-decoration: none !important; } @@ -51,15 +51,15 @@ div[id^='implementation-dropdown-select'] { color: var(--ifm-primary-text-color); } -input[id^='outlined-basic-jsonpath-input'], -label[id^='outlined-basic-jsonpath-input-label'], +input[id^='outlined-basic-xpath-input'], +label[id^='outlined-basic-xpath-input-label'], select[id^='terminal-font-size-select'], label[id^='terminal-font-size-label'], select[id^='implementation-dropdown-select'], label[id^='implementation-dropdown-label'] { color: var(--ifm-primary-text-color); } -input[id^='outlined-basic-jsonpath-input'], +input[id^='outlined-basic-xpath-input'], div[id^='terminal-font-size-select'], div[id^='implementation-dropdown-select'] { background: var(--terminal-background); @@ -84,7 +84,7 @@ span[class^='ace_string'] { color: var(--terminal-value) !important; } -div [id^='jsonpathalert'] { +div [id^='xpathalert'] { color: rgb(244, 67, 54); border: 1px solid rgb(244, 67, 54); } diff --git a/src/pages/tools/sample.xml.json b/src/pages/tools/sample.xml.json new file mode 100644 index 0000000000000..c4935a5ff0468 --- /dev/null +++ b/src/pages/tools/sample.xml.json @@ -0,0 +1 @@ +{"xml":"<?xml version="1.0" encoding="UTF-8"?>
<soap:Envelope
    xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
    xmlns:xhr="urn:com.xylophonichr/api">
  <soap:Body>
    <xhr:GetEmployees_Response xhr:version="v12.0">

      <!-- ============================================================ -->
      <!-- PAGINATION METADATA                                          -->
      <!-- ============================================================ -->
      <xhr:Response_Filter>
        <xhr:Effective_As_Of_Date>2026-03-30</xhr:Effective_As_Of_Date>
        <xhr:Effective_As_Of_DateTime>2026-03-30T12:00:00.000-07:00</xhr:Effective_As_Of_DateTime>
        <xhr:Page>1</xhr:Page>
        <xhr:Page_Size>100</xhr:Page_Size>
      </xhr:Response_Filter>

      <xhr:Response_Summary>
        <xhr:Total_Records>4</xhr:Total_Records>
        <xhr:Total_Pages>1</xhr:Total_Pages>
        <xhr:Records_On_Page>4</xhr:Records_On_Page>
        <xhr:Current_Page>1</xhr:Current_Page>
      </xhr:Response_Summary>

      <xhr:Response_Data>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 1 — Active, Full-Time, US-based                     -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">a4c9e17f2b6d48a3901e7c5f83d2b0a6</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-204817</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-204817</xhr:Employee_Number>
            <xhr:Login_ID>kpatel</xhr:Login_ID>

            <!-- ======================================================== -->
            <!-- PERSONAL DATA                                             -->
            <!-- ======================================================== -->
            <xhr:Personal_Data>

              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">USA</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Title>Ms.</xhr:Title>
                    <xhr:First_Name>Kavita</xhr:First_Name>
                    <xhr:Middle_Name>Rani</xhr:Middle_Name>
                    <xhr:Last_Name>Patel</xhr:Last_Name>
                    <xhr:Suffix/>
                    <xhr:Display_Name>Kavita Rani Patel</xhr:Display_Name>
                    <xhr:Sort_Name>Patel, Kavita Rani</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Kavita</xhr:First_Name>
                    <xhr:Last_Name>Patel</xhr:Last_Name>
                    <xhr:Display_Name>Kavita Patel</xhr:Display_Name>
                    <xhr:Sort_Name>Patel, Kavita</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>

                <!-- Work Email -->
                <xhr:Email>
                  <xhr:Email_Address>kavita.patel@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <!-- Personal Email -->
                <xhr:Email>
                  <xhr:Email_Address>kavita.r.patel@outlook.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <!-- Work Phone -->
                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>415</xhr:Area_Code>
                  <xhr:Number>555-0132</xhr:Number>
                  <xhr:Extension>4420</xhr:Extension>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Landline</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (415) 555-0132 x4420</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Mobile Phone -->
                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>650</xhr:Area_Code>
                  <xhr:Number>555-0278</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (650) 555-0278</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Home Address -->
                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2025-01-10T08:15:00.000-08:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">1847 Lombard Street</xhr:Line>
                  <xhr:Line xhr:Type="LINE_2">Unit 6</xhr:Line>
                  <xhr:City>San Francisco</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>California</xhr:Region_Name>
                  <xhr:Postal_Code>94123</xhr:Postal_Code>
                  <xhr:Formatted_Address>1847 Lombard Street, Unit 6, San Francisco, CA 94123, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>

              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1990-04-18</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Female</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Married</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2020-08-15</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-7890</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Issued_Date>2008-06-20</xhr:Issued_Date>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>BADGE-10482</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Badge_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>PKT-0091</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Parking_Permit</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <!-- ======================================================== -->
            <!-- EMPLOYMENT DATA                                           -->
            <!-- ======================================================== -->
            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-009213</xhr:Position_ID>
                  <xhr:Position_Title>Principal Data Engineer</xhr:Position_Title>
                  <xhr:Business_Title>Principal Data Engineer</xhr:Business_Title>
                  <xhr:Start_Date>2024-02-12</xhr:Start_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">7bc6640c8af459c6bf99d4b02c59d001</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-009213</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-DATA-ENG-P</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>Principal Data Engineer</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Individual_Contributor</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Engineering</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Data-Engineering</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>San Francisco HQ</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SF-HQ</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">350 Mission Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 22</xhr:Line>
                      <xhr:City>San Francisco</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>California</xhr:Region_Name>
                      <xhr:Postal_Code>94105</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">ENG-DATA-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-7100</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-7100</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Engineering - Data Platform</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">4a5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">REG-WEST</xhr:ID>
                        <xhr:ID xhr:type="Region_Org_Code">REG-WEST</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Western Region</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">5b6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Region</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">aabbccdd11223344556677889900aabb</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-198044</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2022-08-01</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2022-08-01</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2022-08-01</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date/>
                  <xhr:Continuous_Service_Date>2022-08-01</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2022-08-01</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2022-08-01</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2022-08-01</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2022-08-01</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <xhr:Probation_Start_Date>2022-08-01</xhr:Probation_Start_Date>
                  <xhr:Probation_End_Date>2023-02-01</xhr:Probation_End_Date>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 2 — Terminated (Voluntary Resignation)              -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">8dd7761e9bf54ac7b011e5c23d70fa92</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-187293</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-187293</xhr:Employee_Number>
            <xhr:Login_ID>tchen</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">USA</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Tao</xhr:First_Name>
                    <xhr:Last_Name>Chen</xhr:Last_Name>
                    <xhr:Display_Name>Tao Chen</xhr:Display_Name>
                    <xhr:Sort_Name>Chen, Tao</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Tao</xhr:First_Name>
                    <xhr:Last_Name>Chen</xhr:Last_Name>
                    <xhr:Display_Name>Tao Chen</xhr:Display_Name>
                    <xhr:Sort_Name>Chen, Tao</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>tao.chen@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>312</xhr:Area_Code>
                  <xhr:Number>555-0491</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">e4f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Landline</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (312) 555-0491</xhr:Formatted_Number>
                </xhr:Phone>

                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2024-03-22T10:45:00.000-06:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">440 North Wabash Avenue</xhr:Line>
                  <xhr:Line xhr:Type="LINE_2">Apt 2701</xhr:Line>
                  <xhr:City>Chicago</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-IL</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>Illinois</xhr:Region_Name>
                  <xhr:Postal_Code>60611</xhr:Postal_Code>
                  <xhr:Formatted_Address>440 North Wabash Avenue, Apt 2701, Chicago, IL 60611, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>
              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1985-12-09</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Male</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">dd44ee55ff66007788990011223344bb</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">CN</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Married</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2015-05-20</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-3456</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-006744</xhr:Position_ID>
                  <xhr:Position_Title>Marketing Manager</xhr:Position_Title>
                  <xhr:Business_Title>Senior Marketing Manager</xhr:Business_Title>
                  <xhr:Start_Date>2023-03-01</xhr:Start_Date>
                  <xhr:End_Date>2026-01-15</xhr:End_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">ccd8e9f0a1b2c3d4e5f6a7b8c9d0e1f2</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-006744</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">aa11bb22cc33dd44ee55ff6600778899</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-MKT-MGR</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>Marketing Manager</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Manager</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">bb22cc33dd44ee55ff66007788990011</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Marketing</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">cc33dd44ee55ff660077889900112233</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Marketing</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>Chicago Office</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">dd44ee55ff66007788990011223344aa</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-CHI-01</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">233 South Wacker Drive</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Suite 4800</xhr:Line>
                      <xhr:City>Chicago</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-IL</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>Illinois</xhr:Region_Name>
                      <xhr:Postal_Code>60606</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">ee55ff660077889900112233445566bb</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">MKT-BRAND-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">ff660077889900112233445566778899</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-5200</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-5200</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Marketing - Brand</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">1122334455667788990011aabbccddee</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-176002</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>false</xhr:Is_Active>
                  <xhr:Active_Status_Date>2021-09-15</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2021-09-15</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2021-09-15</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date>2026-01-15</xhr:End_Employment_Date>
                  <xhr:Continuous_Service_Date>2021-09-15</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2021-09-15</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2021-09-15</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2021-09-15</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2021-09-15</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>true</xhr:Is_Terminated>
                  <xhr:Termination_Date>2026-01-15</xhr:Termination_Date>
                  <xhr:Pay_Through_Date>2026-01-31</xhr:Pay_Through_Date>
                  <xhr:Termination_Category_Reference>
                    <xhr:ID xhr:type="GID">aabb1122ccdd3344eeff5566aabb7788</xhr:ID>
                    <xhr:ID xhr:type="Termination_Category_Code">Voluntary</xhr:ID>
                  </xhr:Termination_Category_Reference>
                  <xhr:Primary_Termination_Reason_Reference>
                    <xhr:ID xhr:type="GID">ccdd3344eeff5566aabb778899001122</xhr:ID>
                    <xhr:ID xhr:type="Termination_Reason_Code">Resignation_New_Opportunity</xhr:ID>
                  </xhr:Primary_Termination_Reason_Reference>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <xhr:Not_Returning>true</xhr:Not_Returning>
                  <xhr:Resignation_Date>2025-12-15</xhr:Resignation_Date>
                  <xhr:Last_Day_of_Work>2026-01-14</xhr:Last_Day_of_Work>
                  <xhr:Eligible_for_Rehire_Reference>
                    <xhr:ID xhr:type="GID">eeff5566aabb778899001122ccdd3344</xhr:ID>
                    <xhr:ID xhr:type="Rehire_Eligibility_Code">Yes</xhr:ID>
                  </xhr:Eligible_for_Rehire_Reference>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 3 — Active, On Leave (Parental)                     -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">f7e6d5c4b3a2918070605040302010ff</xhr:ID>
            <xhr:ID xhr:type="Employee_Number">EMP-211305</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>EMP-211305</xhr:Employee_Number>
            <xhr:Login_ID>sjohansson</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">SWE</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Sofia</xhr:First_Name>
                    <xhr:Middle_Name>Linnéa</xhr:Middle_Name>
                    <xhr:Last_Name>Johansson</xhr:Last_Name>
                    <xhr:Display_Name>Sofia Linnéa Johansson</xhr:Display_Name>
                    <xhr:Sort_Name>Johansson, Sofia Linnéa</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Sofia</xhr:First_Name>
                    <xhr:Last_Name>Johansson</xhr:Last_Name>
                    <xhr:Display_Name>Sofia Johansson</xhr:Display_Name>
                    <xhr:Sort_Name>Johansson, Sofia</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>sofia.johansson@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Email>
                  <xhr:Email_Address>sofia.johansson@proton.me</xhr:Email_Address>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="false">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>206</xhr:Area_Code>
                  <xhr:Number>555-0834</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (206) 555-0834</xhr:Formatted_Number>
                </xhr:Phone>

                <xhr:Address>
                  <xhr:Country_Reference>
                    <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                    <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                  </xhr:Country_Reference>
                  <xhr:Last_Modified>2025-06-01T11:00:00.000-08:00</xhr:Last_Modified>
                  <xhr:Line xhr:Type="LINE_1">3014 NE 55th Street</xhr:Line>
                  <xhr:City>Seattle</xhr:City>
                  <xhr:Region_Reference>
                    <xhr:ID xhr:type="GID">d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6</xhr:ID>
                    <xhr:ID xhr:type="Region_Code">USA-WA</xhr:ID>
                  </xhr:Region_Reference>
                  <xhr:Region_Name>Washington</xhr:Region_Name>
                  <xhr:Postal_Code>98105</xhr:Postal_Code>
                  <xhr:Formatted_Address>3014 NE 55th Street, Seattle, WA 98105, United States of America</xhr:Formatted_Address>
                  <xhr:Is_Business_Site_Default>false</xhr:Is_Business_Site_Default>
                  <xhr:Usage xhr:Public="false">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d6</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">HOME</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Address>
              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1993-02-14</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">9a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Female</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <xhr:Marital_Status_Reference>
                  <xhr:ID xhr:type="GID">e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1</xhr:ID>
                  <xhr:ID xhr:type="Marital_Status_Code">Domestic_Partnership</xhr:ID>
                </xhr:Marital_Status_Reference>
                <xhr:Marital_Status_Date>2023-01-10</xhr:Marital_Status_Date>
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>***-**-5512</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">e8f9a0b1c2d3e4f5a6b7c8d9e0f1a2b3</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">USA-SSN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
                <!-- Note: also holds a Swedish personal identity number -->
                <xhr:National_ID>
                  <xhr:National_ID_Detail>
                    <xhr:Value>930214-XXXX</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">a0b1c2d3e4f5a6b7c8d9e0f1a2b3c4d5</xhr:ID>
                      <xhr:ID xhr:type="National_ID_Type">SWE-PIN</xhr:ID>
                    </xhr:ID_Type_Reference>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788991122334455aabb</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">SE</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:Issued_Date>1993-02-14</xhr:Issued_Date>
                  </xhr:National_ID_Detail>
                </xhr:National_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-010881</xhr:Position_ID>
                  <xhr:Position_Title>UX Research Lead</xhr:Position_Title>
                  <xhr:Business_Title>UX Research Lead</xhr:Business_Title>
                  <xhr:Start_Date>2024-06-01</xhr:Start_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>0</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">1122aabb3344ccdd5566eeff7788a1b2</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-010881</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">d4e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Regular</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">bb11cc22dd33ee44ff550066778899aa</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-UXR-LEAD</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>UX Research Lead</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">6c7d8e9f0a1b2c3d4e5f6a7b8c9d0e1f</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Manager</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">cc22dd33ee44ff5500667788990011bb</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Design</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">dd33ee44ff550066778899001122ccbb</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Design-Research</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>Seattle Office</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">ee44ff55006677889911223344556677</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SEA-01</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">701 Pike Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 8</xhr:Line>
                      <xhr:City>Seattle</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-WA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>Washington</xhr:Region_Name>
                      <xhr:Postal_Code>98101</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Salary</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">ff5500667788990011223344556677aa</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">DES-RESEARCH-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">00667788990011223344556677889900</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-8300</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-8300</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Design - Research</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">2233445566778899aabb0011ccddeeff</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-201440</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2023-04-10</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2023-04-10</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2023-04-10</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date/>
                  <xhr:Continuous_Service_Date>2023-04-10</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2023-04-10</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2023-04-10</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date>2023-04-10</xhr:Benefits_Service_Date>
                  <xhr:Company_Service_Date>2023-04-10</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <!-- Leave of Absence fields — only present when on leave -->
                  <xhr:On_Leave>true</xhr:On_Leave>
                  <xhr:Leave_Start_Date>2026-02-03</xhr:Leave_Start_Date>
                  <xhr:Expected_Return_Date>2026-08-03</xhr:Expected_Return_Date>
                  <xhr:Leave_Type_Reference>
                    <xhr:ID xhr:type="GID">7788990011223344556677aabbccdd00</xhr:ID>
                    <xhr:ID xhr:type="Leave_Type_Code">Parental_Leave</xhr:ID>
                  </xhr:Leave_Type_Reference>
                  <xhr:Leave_Request_Reference>
                    <xhr:ID xhr:type="GID">8899001122334455667788aabbccdd11</xhr:ID>
                    <xhr:ID xhr:type="Leave_Request_ID">LR-2026-000412</xhr:ID>
                  </xhr:Leave_Request_Reference>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

        <!-- ============================================================ -->
        <!-- EMPLOYEE 4 — Contingent Worker (Contractor)                  -->
        <!-- ============================================================ -->
        <xhr:Employee>
          <xhr:Employee_Reference>
            <xhr:ID xhr:type="GID">0102030405060708090a0b0c0d0e0f10</xhr:ID>
            <xhr:ID xhr:type="Contingent_Worker_Number">CW-400091</xhr:ID>
          </xhr:Employee_Reference>

          <xhr:Employee_Data>
            <xhr:Employee_Number>CW-400091</xhr:Employee_Number>
            <xhr:Login_ID>mnakamura.ext</xhr:Login_ID>

            <xhr:Personal_Data>
              <xhr:Name_Data>
                <xhr:Legal_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">ff00112233445566778899aabbccddee</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">JP</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha3">JPN</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Masato</xhr:First_Name>
                    <xhr:Last_Name>Nakamura</xhr:Last_Name>
                    <xhr:Display_Name>Masato Nakamura</xhr:Display_Name>
                    <xhr:Sort_Name>Nakamura, Masato</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Legal_Name>
                <xhr:Preferred_Name>
                  <xhr:Name_Detail>
                    <xhr:Country_Reference>
                      <xhr:ID xhr:type="GID">bc33aa3152ec42d4995f4791a106ed09</xhr:ID>
                      <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                    </xhr:Country_Reference>
                    <xhr:First_Name>Masa</xhr:First_Name>
                    <xhr:Last_Name>Nakamura</xhr:Last_Name>
                    <xhr:Display_Name>Masa Nakamura</xhr:Display_Name>
                    <xhr:Sort_Name>Nakamura, Masa</xhr:Sort_Name>
                  </xhr:Name_Detail>
                </xhr:Preferred_Name>
              </xhr:Name_Data>

              <xhr:Contact_Data>
                <xhr:Email>
                  <xhr:Email_Address>masato.nakamura.ext@globaldynamics.com</xhr:Email_Address>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                </xhr:Email>

                <xhr:Phone>
                  <xhr:Country_Code>1</xhr:Country_Code>
                  <xhr:Area_Code>408</xhr:Area_Code>
                  <xhr:Number>555-0612</xhr:Number>
                  <xhr:Device_Type_Reference>
                    <xhr:ID xhr:type="GID">f5a6b7c8d9e0f1a2b3c4d5e6f7a8b9c0</xhr:ID>
                    <xhr:ID xhr:type="Device_Type_Code">Mobile</xhr:ID>
                  </xhr:Device_Type_Reference>
                  <xhr:Usage xhr:Public="true">
                    <xhr:Type_Info xhr:Primary="true">
                      <xhr:Type_Reference>
                        <xhr:ID xhr:type="GID">d0e1f2a3b4c5d6e7f8a9b0c1d2e3f4a5</xhr:ID>
                        <xhr:ID xhr:type="Usage_Type_Code">WORK</xhr:ID>
                      </xhr:Type_Reference>
                    </xhr:Type_Info>
                  </xhr:Usage>
                  <xhr:Formatted_Number>+1 (408) 555-0612</xhr:Formatted_Number>
                </xhr:Phone>

                <!-- Note: No home address on file for contingent workers — common pattern -->

              </xhr:Contact_Data>

              <xhr:Biographical_Data>
                <xhr:Date_of_Birth>1987-09-30</xhr:Date_of_Birth>
                <xhr:Gender_Reference>
                  <xhr:ID xhr:type="GID">0a1b2c3d4e5f6a7b8c9d0e1f2a3b4c5d</xhr:ID>
                  <xhr:ID xhr:type="Gender_Code">Male</xhr:ID>
                </xhr:Gender_Reference>
                <xhr:Country_of_Birth_Reference>
                  <xhr:ID xhr:type="GID">ff00112233445566778899aabbccddee</xhr:ID>
                  <xhr:ID xhr:type="ISO_3166_Alpha2">JP</xhr:ID>
                </xhr:Country_of_Birth_Reference>
                <!-- No marital status — not collected for contingent workers -->
              </xhr:Biographical_Data>

              <xhr:Identification_Data>
                <!-- Contingent workers may have no national IDs on file -->
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>VENDOR-TECHSTAR-0091</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Vendor_Worker_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
                <xhr:Custom_ID>
                  <xhr:Custom_ID_Detail>
                    <xhr:Value>BADGE-EXT-7721</xhr:Value>
                    <xhr:ID_Type_Reference>
                      <xhr:ID xhr:type="GID">f1a2b3c4d5e6f7a8b9c0d1e2f3a4b5c6</xhr:ID>
                      <xhr:ID xhr:type="Custom_ID_Type">Badge_ID</xhr:ID>
                    </xhr:ID_Type_Reference>
                  </xhr:Custom_ID_Detail>
                </xhr:Custom_ID>
              </xhr:Identification_Data>

            </xhr:Personal_Data>

            <xhr:Employment_Data>
              <xhr:Job_Data>
                <xhr:Position>
                  <xhr:Position_ID>POS-CW-0412</xhr:Position_ID>
                  <xhr:Position_Title>Staff Augmentation - DevOps</xhr:Position_Title>
                  <xhr:Business_Title>DevOps Engineer (Contract)</xhr:Business_Title>
                  <xhr:Start_Date>2025-10-01</xhr:Start_Date>
                  <xhr:End_Date>2026-09-30</xhr:End_Date>
                  <xhr:Default_Weekly_Hours>40</xhr:Default_Weekly_Hours>
                  <xhr:Scheduled_Weekly_Hours>40</xhr:Scheduled_Weekly_Hours>
                  <xhr:FTE_Percentage>100</xhr:FTE_Percentage>

                  <xhr:Position_Reference>
                    <xhr:ID xhr:type="GID">aabb0011ccdd2233eeff4455667788cc</xhr:ID>
                    <xhr:ID xhr:type="Position_ID">POS-CW-0412</xhr:ID>
                  </xhr:Position_Reference>

                  <xhr:Employee_Type_Reference>
                    <xhr:ID xhr:type="GID">e5f6a7b8c9d0e1f2a3b4c5d6e7f8a9b0</xhr:ID>
                    <xhr:ID xhr:type="Employee_Type_Code">Contingent_Worker</xhr:ID>
                  </xhr:Employee_Type_Reference>

                  <xhr:Job_Profile>
                    <xhr:Job_Profile_Reference>
                      <xhr:ID xhr:type="GID">cc11dd22ee33ff440055667788990011</xhr:ID>
                      <xhr:ID xhr:type="Job_Profile_Code">JP-DEVOPS-CW</xhr:ID>
                    </xhr:Job_Profile_Reference>
                    <xhr:Job_Profile_Name>DevOps Engineer (Contract)</xhr:Job_Profile_Name>
                    <xhr:Management_Level_Reference>
                      <xhr:ID xhr:type="GID">2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e</xhr:ID>
                      <xhr:ID xhr:type="Management_Level_Code">Individual_Contributor</xhr:ID>
                    </xhr:Management_Level_Reference>
                    <xhr:Job_Category_Reference>
                      <xhr:ID xhr:type="GID">3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f</xhr:ID>
                      <xhr:ID xhr:type="Job_Category_Code">Engineering</xhr:ID>
                    </xhr:Job_Category_Reference>
                    <xhr:Job_Family_Reference>
                      <xhr:ID xhr:type="GID">ee44ff5500667788990011223344aabb</xhr:ID>
                      <xhr:ID xhr:type="Job_Family_Code">JF-Infrastructure</xhr:ID>
                    </xhr:Job_Family_Reference>
                  </xhr:Job_Profile>

                  <xhr:Work_Location>
                    <xhr:Location_Name>San Francisco HQ</xhr:Location_Name>
                    <xhr:Location_Reference>
                      <xhr:ID xhr:type="GID">5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b</xhr:ID>
                      <xhr:ID xhr:type="Location_Code">LOC-SF-HQ</xhr:ID>
                    </xhr:Location_Reference>
                    <xhr:Location_Type_Reference>
                      <xhr:ID xhr:type="GID">6f7a8b9c0d1e2f3a4b5c6d7e8f9a0b1c</xhr:ID>
                      <xhr:ID xhr:type="Location_Type_Code">Office</xhr:ID>
                    </xhr:Location_Type_Reference>
                    <xhr:Address>
                      <xhr:Country_Reference>
                        <xhr:ID xhr:type="ISO_3166_Alpha2">US</xhr:ID>
                      </xhr:Country_Reference>
                      <xhr:Line xhr:Type="LINE_1">350 Mission Street</xhr:Line>
                      <xhr:Line xhr:Type="LINE_2">Floor 22</xhr:Line>
                      <xhr:City>San Francisco</xhr:City>
                      <xhr:Region_Reference>
                        <xhr:ID xhr:type="Region_Code">USA-CA</xhr:ID>
                      </xhr:Region_Reference>
                      <xhr:Region_Name>California</xhr:Region_Name>
                      <xhr:Postal_Code>94105</xhr:Postal_Code>
                    </xhr:Address>
                  </xhr:Work_Location>

                  <xhr:Pay_Rate_Type_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Pay_Rate_Type_Code">Hourly</xhr:ID>
                  </xhr:Pay_Rate_Type_Reference>

                  <xhr:Time_Type_Reference>
                    <xhr:ID xhr:type="GID">8b9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e</xhr:ID>
                    <xhr:ID xhr:type="Time_Type_Code">Full_Time</xhr:ID>
                  </xhr:Time_Type_Reference>

                  <xhr:Supervisory_Org_Reference>
                    <xhr:ID xhr:type="GID">9c0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f</xhr:ID>
                    <xhr:ID xhr:type="Org_Code">ENG-DATA-001</xhr:ID>
                  </xhr:Supervisory_Org_Reference>

                  <!-- Vendor / Staffing Agency reference — unique to contingent workers -->
                  <xhr:Staffing_Agency_Reference>
                    <xhr:ID xhr:type="GID">1100aabb2233ccdd4455eeff66778800</xhr:ID>
                    <xhr:ID xhr:type="Vendor_Code">VENDOR-TECHSTAR</xhr:ID>
                  </xhr:Staffing_Agency_Reference>

                  <xhr:Organization_Assignments>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">0d1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">CC-7100</xhr:ID>
                        <xhr:ID xhr:type="Cost_Center_Code">CC-7100</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Engineering - Data Platform</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">1e2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Cost_Center</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                    <xhr:Organization>
                      <xhr:Organization_Reference>
                        <xhr:ID xhr:type="GID">2f3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c</xhr:ID>
                        <xhr:ID xhr:type="Org_Code">COMP-GD</xhr:ID>
                        <xhr:ID xhr:type="Company_Code">COMP-GD</xhr:ID>
                      </xhr:Organization_Reference>
                      <xhr:Organization_Name>Global Dynamics Inc.</xhr:Organization_Name>
                      <xhr:Organization_Type_Reference>
                        <xhr:ID xhr:type="GID">3a4b5c6d7e8f9a0b1c2d3e4f5a6b7c8d</xhr:ID>
                        <xhr:ID xhr:type="Org_Type_Code">Company</xhr:ID>
                      </xhr:Organization_Type_Reference>
                    </xhr:Organization>
                  </xhr:Organization_Assignments>

                </xhr:Position>

                <xhr:Manager_Reference>
                  <xhr:ID xhr:type="GID">aabbccdd11223344556677889900aabb</xhr:ID>
                  <xhr:ID xhr:type="Employee_Number">EMP-198044</xhr:ID>
                </xhr:Manager_Reference>

                <xhr:Employment_Status>
                  <xhr:Is_Active>true</xhr:Is_Active>
                  <xhr:Active_Status_Date>2025-10-01</xhr:Active_Status_Date>
                  <xhr:Hire_Date>2025-10-01</xhr:Hire_Date>
                  <xhr:Original_Hire_Date>2025-10-01</xhr:Original_Hire_Date>
                  <xhr:End_Employment_Date>2026-09-30</xhr:End_Employment_Date>
                  <xhr:Continuous_Service_Date>2025-10-01</xhr:Continuous_Service_Date>
                  <xhr:First_Day_of_Work>2025-10-01</xhr:First_Day_of_Work>
                  <xhr:Seniority_Date>2025-10-01</xhr:Seniority_Date>
                  <xhr:Benefits_Service_Date/>
                  <xhr:Company_Service_Date>2025-10-01</xhr:Company_Service_Date>
                  <xhr:Is_Retired>false</xhr:Is_Retired>
                  <xhr:Is_Terminated>false</xhr:Is_Terminated>
                  <xhr:Is_Rehire>false</xhr:Is_Rehire>
                  <xhr:Days_Unemployed>0</xhr:Days_Unemployed>
                  <!-- Contract End — only present for contingent workers -->
                  <xhr:Contract_End_Date>2026-09-30</xhr:Contract_End_Date>
                  <xhr:Contract_Renewable>true</xhr:Contract_Renewable>
                </xhr:Employment_Status>

              </xhr:Job_Data>
            </xhr:Employment_Data>

          </xhr:Employee_Data>
        </xhr:Employee>

      </xhr:Response_Data>
    </xhr:GetEmployees_Response>
  </soap:Body>
</soap:Envelope>"} \ No newline at end of file diff --git a/src/pages/tools/xpath-evaluator.tsx b/src/pages/tools/xpath-evaluator.tsx new file mode 100644 index 0000000000000..59ff9ecb0dcb2 --- /dev/null +++ b/src/pages/tools/xpath-evaluator.tsx @@ -0,0 +1,231 @@ +import React, {useState} from 'react'; +import Layout from '@theme/Layout'; +import styles from './xpath.module.css'; +import Alert from '@mui/material/Alert'; +import Stack from '@mui/material/Stack'; +import Link from '@mui/material/Link'; +import TerminalFontSizeDropdown from '../../components/xpath/TerminalFontSizeDropdown'; +import InputTerminal from '../../components/xpath/InputTerminal'; +import ResultTerminal from '../../components/xpath/ResultTerminal'; +import ImplementationDropdown from '../../components/xpath/ImplementationDropdown'; +import XPathQueryInput from '../../components/xpath/XPathQueryInput'; +import XPathRootInput from '../../components/xpath/XPathRootInput'; +import { + evaluateXPath, +} from '../../services/XPathService'; +import useDocusaurusContext from '@docusaurus/useDocusaurusContext'; +import Button from '@mui/material/Button'; + +// Define the type for implementation options +type ImplementationType = 'XPath'; + +// Define the documentation links type +const documentationLinks: Record< + ImplementationType, + {url: string; text: string} +> = { + XPath: { + url: 'https://en.wikipedia.org/wiki/XPath', + text: 'XPath Documentation', + }, +}; + const sampleXmlFile = require('./sample.xml.json') + let buffer = Buffer.from(sampleXmlFile.xml, 'base64') + const sampleXml = buffer.toString(); + + const XPathEvaluator: React.FC = () => { + const [result, setResult] = useState(JSON.stringify([], null, 4)); + const [query, setQuery] = useState('xhr:Employee_Data/xhr:Personal_Data/xhr:Name_Data/xhr:Legal_Name/xhr:Name_Detail/xhr:Last_Name'); + const [root, setRoot] = useState('//xhr:Response_Data/xhr:Employee'); + const [queryParseError, setQueryParseError] = useState(''); + const [fontSize, setFontSize] = useState('16'); + const [inputXml, setInputXml] = useState(sampleXml); + const [implementation, setImplementation] = + useState('XPath'); + const [localXml, setLocalXml] = useState(inputXml); + const [xmlParseError, setXmlParseError] = useState(false); + const [isQueryFocused, setIsQueryFocused] = useState(false); + const [isRootFocused, setIsRootFocused] = useState(false); + const [isDropdownFocused, setIsDropdownFocused] = useState(false); + const {siteConfig} = useDocusaurusContext(); + + // Apply XPath query + const applyXPathQuery = async (xml: string, xPath: string, root: string) => { + if (xPath.length === 0 || xPath === '//') { + setResult('[]'); + return; + } + + try { + let result: any; + let tempResult: any; + + try { + switch (implementation) { + case 'XPath': + tempResult = await evaluateXPath( + 'https://o2352gowwy55a4vviyswr76lxu0ednjs.lambda-url.us-east-2.on.aws/', + xPath, + root, + xml, + ); + result = tempResult.error ? tempResult.error : tempResult; + break; + } + } catch (error: any) { + result = error.message; + } + + setResult( + result.length > 0 || + typeof result === 'number' || + typeof result === 'object' || + typeof result === 'boolean' + ? JSON.stringify(result, null, 2) + : 'No match', + ); + setQueryParseError(''); + setXmlParseError(false); + } catch (error: any) { + setResult('No match'); + setXmlParseError(true); + setQueryParseError(error.message || 'Error executing XPath query'); + } + }; + + // Handle input change + const handleXmlChange = (newxml: string) => { + setLocalXml(newxml); + }; + + // Handle query input change + const handleQueryChange = (event: React.ChangeEvent) => { + setQuery(event.target.value); + }; + + // Handle root input change + const handleRootChange = (event: React.ChangeEvent) => { + setRoot(event.target.value); + }; + + // Handle implementation change + const handleImplementationChange = ( + newImplementation: ImplementationType, + ) => { + setImplementation(newImplementation); + }; + + // Handle focus events + const handleQueryFocus = () => setIsQueryFocused(true); + const handleQueryBlur = () => setIsQueryFocused(false); + const handleRootFocus = () => setIsRootFocused(true); + const handleRootBlur = () => setIsRootFocused(false); + const handleDropdownFocus = () => setIsDropdownFocused(true); + const handleDropdownBlur = () => setIsDropdownFocused(false); + + // Run button handler + const handleRunQuery = () => { + applyXPathQuery(localXml, query, root); + }; + + return ( + +
+
+
+ + + + + {documentationLinks[implementation] && ( + + {documentationLinks[implementation].text} + + )} + {queryParseError && ( +
+ + {queryParseError} + +
+ )} + + + + {(false && + + )} + + + + + +
+ + + + + +
+
+ + ); +}; + +export default XPathEvaluator; diff --git a/src/pages/tools/xpath.module.css b/src/pages/tools/xpath.module.css new file mode 100644 index 0000000000000..8d71f391778ca --- /dev/null +++ b/src/pages/tools/xpath.module.css @@ -0,0 +1,96 @@ +.containerFluid { + margin: 20px; +} + +.actionBar { + margin-top: 2%; + margin-bottom: 2%; +} + +.alertContainer { + min-height: 50px; +} + +.inputTerminalContainer { + border: 3px solid red !important; + background: var(--terminal-background) !important; +} + +.terminalContainerDefault { + border: 3px solid var(--dev-card-background) !important; + background: var(--terminal-background) !important; +} + +a[id^='xpathDocumentationLink'] { + color: var(--link-color) !important; + text-decoration: underline !important; +} + +a[id^='xpathDocumentationLink']:hover { + text-decoration: none!important; +} + +li[class^='MuiButtonBase-root'] { + color: var(--ifm-primary-text-color); +} +div[class^='MuiFormControl-root'] { + color: var(--ifm-primary-text-color); +} +div[id^='terminal-font-size-select'], +div[id^='implementation-dropdown-select'] { + color: var(--ifm-primary-text-color); +} + +input[id^='outlined-basic-xpath-input'], +label[id^='outlined-basic-xpath-input-label'], +select[id^='terminal-font-size-select'], +label[id^='terminal-font-size-label'], +select[id^='implementation-dropdown-select'], +label[id^='implementation-dropdown-label'] { + color: var(--ifm-primary-text-color); +} +input[id^='outlined-basic-xpath-input'], +div[id^='terminal-font-size-select'], +div[id^='implementation-dropdown-select'] { + background: var(--terminal-background); +} +fieldset[class^='MuiOutlinedInput-notchedOutline css-1ll44ll-MuiOutlinedInput-notchedOutline'] { + border: 1.5px solid var(--terminal-background); +} +ul[class^='MuiList-root MuiList-padding MuiMenu-list css-1toxriw-MuiList-root-MuiMenu-list'] { + background-color: var(--terminal-background); +} +ul[class^='MuiMenu-list'] { + background-color: var(--terminal-background); +} +div[class^='MuiPaper-root'] { + background-color: var(--terminal-background) !important; +} + +span[class^='ace_variable'] { + color: var(--terminal-key) !important; +} +span[class^='ace_string'] { + color: var(--terminal-value) !important; +} + +div [id^='xpathalert'] { + color: rgb(244, 67, 54); + border: 1px solid rgb(244, 67, 54); +} + +.actionBar button { + min-width: 100px; +} + +.runButton { + color: var(--ifm-button-colors) !important; + border: 1px solid var(--ifm-button-colors) !important; + background-color: var(--dropdown-background) !important; +} + +.runButton:hover { + background-color: var(--ifm-button-colors) !important; + color: var(--text-on-primary) !important; + border: 1px solid var(--ifm-button-colors) !important; +} diff --git a/src/services/XPathService.ts b/src/services/XPathService.ts new file mode 100644 index 0000000000000..2b471841174af --- /dev/null +++ b/src/services/XPathService.ts @@ -0,0 +1,58 @@ +// Common function to handle XPath evaluation +export async function evaluateXPath( + gatewayUrl: string, + xPathQuery: string, + rootPath: string, + xmlData: string | object +): Promise { + const buffer = Buffer.from(xmlData); + const xmlb64String = buffer.toString('base64'); + + const requestBody = { + attributeMappings: { + 'XPath Query Result': xPathQuery + }, + rootPath: rootPath, + xml: xmlb64String + }; + + try { + const response = await fetch(`${gatewayUrl}`, { + method: 'POST', + headers: { + 'Content-Type': 'application/json' + }, + body: JSON.stringify(requestBody) + }); + + if (!response.ok) { + const errorResponse = await response.json(); + console.error('JSONPath error:', errorResponse.error); + + // Handle rate limiting specifically + if (response.status === 429) { + throw new Error('Too many requests. Please wait a moment and try again.'); + } + + throw new Error(`XPath evaluation error: ${errorResponse.error}`); + } + + const json = await response.json(); + console.log('Response JSON: ' + json); + + // Parse the result if it's a string containing JSON + if (json.result && typeof json.result === 'string') { + try { + json.result = JSON.parse(json.result); + } catch (e) { + // If it's not valid JSON, keep the original string + console.log('Result was not JSON parseable, keeping as is'); + } + } + + return json; + } catch (error) { + console.error('Error evaluating XPath:', error); + throw error; + } +} \ No newline at end of file diff --git a/template.yaml b/template.yaml index 0b470e74d6c35..29048fe351ea2 100644 --- a/template.yaml +++ b/template.yaml @@ -360,7 +360,7 @@ Resources: Comment: "Security headers for developer.sailpoint.com including CSP" SecurityHeadersConfig: ContentSecurityPolicy: - ContentSecurityPolicy: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;" + ContentSecurityPolicy: "default-src 'self'; script-src 'self' 'unsafe-inline' 'unsafe-eval' https://code.jquery.com https://www.googletagmanager.com https://cdn.jsdelivr.net https://cdn.cookielaw.org https://googleads.g.doubleclick.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net https://p.typekit.net https://use.typekit.net; img-src 'self' data: https: http:; font-src 'self' data: https://cdn.jsdelivr.net https://use.typekit.net https://cdnjs.cloudflare.com; connect-src 'self' http://localhost:3000 https://*.algolia.net https://*.algolianet.com https://www.googletagmanager.com https://www.google.com https://analytics.google.com https://developer.sailpoint.com https://nug87yusrg.execute-api.us-east-1.amazonaws.com https://o2352gowwy55a4vviyswr76lxu0ednjs.lambda-url.us-east-2.on.aws https://cdn.cookielaw.org https://stats.g.doubleclick.net https://googleads.g.doubleclick.net https://*.api.identitynow.com https://*.api.identitynow-demo.com; frame-src 'self' https://www.googletagmanager.com https://www.youtube.com https://play.vidyard.com; worker-src 'self' blob:;" Override: true Parameters: AuthUsername: