@intra-mart/smartlime 0.0.1-beta

package/lib/packages/Search/hooks/usePublicGroupRoleSerch.d.ts

@@ -0,0 +1,2 @@
+import { PublicGroupRoleSearchResult, PublicGroupRoleSet } from '../types';
+export declare const usePublicGroupRoleSearch: (paramString: string) => (publicGroupSet: PublicGroupRoleSet, init?: RequestInit) => Promise<PublicGroupRoleSearchResult>;

package/lib/packages/Search/hooks/usePublicGroupRoleSerch.js

@@ -0,0 +1,50 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeCriteria, makeParamStringIncludeProp, makeParamStringIncludeTargetDate, } from './utils';
+const getEncodeParams = (parameters, userCriteria) => {
+    return `parameters=${encodeURIComponent(parameters)}&userCriteria=${encodeURIComponent(userCriteria)}`;
+};
+export const usePublicGroupRoleSearch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (publicGroupSet, init) => {
+        try {
+            const parameters = makeParamStringIncludeCriteria(makeParamStringIncludeProp(makeParamStringIncludeTargetDate(paramString)));
+            const userCriteria = JSON.stringify({
+                public_group_set: publicGroupSet,
+            });
+            const body = getEncodeParams(parameters, userCriteria);
+            const response = await imFetch('api/smacolow/master/search/public_group_role/tree_with_attached_role/role', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/usePublicGroupSerch.d.ts

@@ -0,0 +1,2 @@
+import { PublicGroupSearcResult } from '../types';
+export declare const usePublicGroupSerch: (paramString: string) => (keyword: string, init?: RequestInit) => Promise<PublicGroupSearcResult>;

package/lib/packages/Search/hooks/usePublicGroupSerch.js

@@ -0,0 +1,56 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeCriteria, makeParamStringIncludeProp, makeParamStringIncludeTargetDate, } from './utils';
+const getEncodeParams = (parameters, userCriteria) => {
+    return `parameters=${encodeURIComponent(parameters)}&userCriteria=${encodeURIComponent(userCriteria)}`;
+};
+export const usePublicGroupSerch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (keyword, init) => {
+        try {
+            const parameters = makeParamStringIncludeCriteria(makeParamStringIncludeProp(makeParamStringIncludeTargetDate(paramString)));
+            const userCriteria = JSON.stringify({
+                keyword: keyword,
+                keyword_target: [
+                    'public_group_cd',
+                    'public_group_name',
+                    'public_group_search_name',
+                ],
+                keyword_type: 'part',
+            });
+            const body = getEncodeParams(parameters, userCriteria);
+            const response = await imFetch('api/smacolow/master/search/public_group/list', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/usePublicGroupTopSerch.d.ts

@@ -0,0 +1,2 @@
+import { PublicGroupTopSearchResult } from '../types';
+export declare const usePublicGroupTopSerch: (paramString: string) => (init?: RequestInit) => Promise<PublicGroupTopSearchResult>;

package/lib/packages/Search/hooks/usePublicGroupTopSerch.js

@@ -0,0 +1,47 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeCriteria, makeParamStringIncludeTargetDate, } from './utils';
+const getEncodeParams = (parameters) => {
+    return `parameters=${encodeURIComponent(parameters)}`;
+};
+export const usePublicGroupTopSerch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (init) => {
+        try {
+            const parameters = makeParamStringIncludeCriteria(makeParamStringIncludeTargetDate(paramString));
+            const body = getEncodeParams(parameters);
+            const response = await imFetch('api/smacolow/master/search/public_group_role/tree/public_group_top', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/useRoleSerch.d.ts

@@ -0,0 +1,2 @@
+import { PublicGroupSet, RoleSearchResult } from '../types';
+export declare const useRoleSerch: (paramString: string) => (publicGroupSet: PublicGroupSet, init?: RequestInit) => Promise<RoleSearchResult>;

package/lib/packages/Search/hooks/useRoleSerch.js

@@ -0,0 +1,50 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeCriteria, makeParamStringIncludeProp, makeParamStringIncludeTargetDate, } from './utils';
+const getEncodeParams = (parameters, userCriteria) => {
+    return `parameters=${encodeURIComponent(parameters)}&userCriteria=${encodeURIComponent(userCriteria)}`;
+};
+export const useRoleSerch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (publicGroupSet, init) => {
+        try {
+            const parameters = makeParamStringIncludeCriteria(makeParamStringIncludeProp(makeParamStringIncludeTargetDate(paramString)));
+            const userCriteria = JSON.stringify({
+                public_group_set: publicGroupSet,
+            });
+            const body = getEncodeParams(parameters, userCriteria);
+            const response = await imFetch('api/smacolow/master/search/public_group_role/tree/role', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/useUserAdditionalInformationSearch.d.ts

@@ -0,0 +1,2 @@
+import { UserAdditionalInformationSearchResult } from '../types';
+export declare const useUserAdditionalInformationSearch: (paramString: string) => (userCd: string, init?: RequestInit) => Promise<UserAdditionalInformationSearchResult>;

package/lib/packages/Search/hooks/useUserAdditionalInformationSearch.js

@@ -0,0 +1,50 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeTargetDate } from './utils';
+const getEncodeParams = (parameters, userCriteria) => {
+    return `parameters=${encodeURIComponent(parameters)}&userCriteria=${encodeURIComponent(userCriteria)}`;
+};
+export const useUserAdditionalInformationSearch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (userCd, init) => {
+        try {
+            const parameters = makeParamStringIncludeTargetDate(paramString);
+            const userCriteria = JSON.stringify({
+                user_cd: userCd,
+            });
+            const body = getEncodeParams(parameters, userCriteria);
+            const response = await imFetch('api/smacolow/master/search/user/search/additional', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/useUserSerch.d.ts

@@ -0,0 +1,2 @@
+import { UserSearchResult } from '../types';
+export declare const useUserSearch: (paramString: string) => (keyword: string, init?: RequestInit) => Promise<UserSearchResult>;

package/lib/packages/Search/hooks/useUserSerch.js

@@ -0,0 +1,68 @@
+import { useCallback } from 'react';
+import { useIMFetch } from '../../Fetch';
+import { IMSearchError } from '../IMSearchError';
+import { makeParamStringIncludeTargetDate } from './utils';
+const getEncodeParams = (parameters, userCriteria) => {
+    return `parameters=${encodeURIComponent(parameters)}&userCriteria=${encodeURIComponent(userCriteria)}`;
+};
+const key = 'jp.co.intra_mart.master.app.search.tabs.user.list_user';
+const value = ['email_address1', 'user_search_name'];
+const margeProp = (prop) => {
+    return {
+        [key]: prop && prop[key] ? [...new Set([...value, ...prop[key]])] : value,
+        ...prop,
+    };
+};
+const mergeDefaultPropinString = (paramString) => {
+    const json = JSON.parse(paramString);
+    const prop = margeProp(json.prop);
+    return JSON.stringify({
+        ...json,
+        prop,
+    });
+};
+export const useUserSearch = (paramString) => {
+    const imFetch = useIMFetch();
+    const search = useCallback(async (keyword, init) => {
+        try {
+            const parameters = mergeDefaultPropinString(makeParamStringIncludeTargetDate(paramString));
+            const userCriteria = JSON.stringify({
+                keyword: keyword,
+                keyword_target: ['user_cd', 'user_name', 'user_search_name'],
+                keyword_type: 'part',
+            });
+            const body = getEncodeParams(parameters, userCriteria);
+            const response = await imFetch('api/smacolow/master/search/user/search', {
+                ...init,
+                headers: {
+                    ...init?.headers,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                    Accept: 'application/json',
+                },
+                method: 'POST',
+                body: body,
+            });
+            if (response.status === 200) {
+                const json = await response.json();
+                return {
+                    type: 'success',
+                    response: json,
+                };
+            }
+            else {
+                return {
+                    type: 'error',
+                    detail: new IMSearchError('response status other than 200 was returned.'),
+                    response: response,
+                };
+            }
+        }
+        catch (e) {
+            return {
+                type: 'exception',
+                detail: e,
+            };
+        }
+    }, [paramString]);
+    return search;
+};

package/lib/packages/Search/hooks/utils.d.ts

@@ -0,0 +1,4 @@
+export declare const zeroPadding: (number: number) => string;
+export declare const makeParamStringIncludeTargetDate: (paramString: string) => string;
+export declare const makeParamStringIncludeProp: (paramString: string) => string;
+export declare const makeParamStringIncludeCriteria: (paramString: string) => string;

package/lib/packages/Search/hooks/utils.js

@@ -0,0 +1,25 @@
+export const zeroPadding = (number) => {
+    return `${number < 10 ? '0' : ''}${number}`;
+};
+export const makeParamStringIncludeTargetDate = (paramString) => {
+    const json = JSON.parse(paramString);
+    const date = new Date();
+    return JSON.stringify({
+        target_date: `${date.getFullYear()}-${zeroPadding(date.getMonth() + 1)}-${zeroPadding(date.getDate())}`,
+        ...json,
+    });
+};
+export const makeParamStringIncludeProp = (paramString) => {
+    const json = JSON.parse(paramString);
+    return JSON.stringify({
+        prop: {},
+        ...json,
+    });
+};
+export const makeParamStringIncludeCriteria = (paramString) => {
+    const json = JSON.parse(paramString);
+    return JSON.stringify({
+        criteria: {},
+        ...json,
+    });
+};

package/lib/packages/Search/index.d.ts

@@ -0,0 +1,49 @@
+/// <reference types="react" />
+import { Context as DefaultContext } from './Context';
+import { DepartmentPostSearchRecord, DepartmentSearchRecord, PostSearchRecord, PublicGroupSearchRecord, RoleSearchRecord, UserSearchRecord } from './types';
+export type SearchTarget = 'jp.co.intra_mart.master.search.user' | 'jp.co.intra_mart.master.search.company' | 'jp.co.intra_mart.master.search.company_post' | 'jp.co.intra_mart.master.search.department' | 'jp.co.intra_mart.master.search.public_group' | 'jp.co.intra_mart.master.search.private_group' | 'jp.co.intra_mart.master.search.public_group_role' | 'jp.co.intra_mart.master.search.role' | 'jp.co.intra_mart.master.search.attached_department_post' | 'jp.co.intra_mart.master.search.attached_public_group_role' | undefined;
+export type SearchType = 'single' | 'multiple';
+declare const useLock: () => import("react").MutableRefObject<boolean>;
+declare const useVisible: () => [boolean, import("react").Dispatch<import("react").SetStateAction<boolean>>];
+declare const useSearchTarget: () => [SearchTarget, import("react").Dispatch<import("react").SetStateAction<SearchTarget>>];
+declare const useSearchType: () => [SearchType, import("react").Dispatch<import("react").SetStateAction<SearchType>>];
+declare const useParamString: () => [string, import("react").Dispatch<import("react").SetStateAction<string>>];
+export type SuccessSingleResult = UserSearchRecord | DepartmentSearchRecord | PostSearchRecord | PublicGroupSearchRecord | RoleSearchRecord | DepartmentPostSearchRecord;
+export type SuccessMultipleResult = UserSearchRecord[] | DepartmentSearchRecord[] | PostSearchRecord[] | PublicGroupSearchRecord[] | RoleSearchRecord[] | DepartmentPostSearchRecord[];
+export type SuccessResult<T extends SearchType> = T extends 'single' ? SuccessSingleResult : SuccessMultipleResult;
+export interface Cancel {
+    readonly type: 'cancel' | 'locked';
+}
+export interface Error {
+    readonly type: 'error';
+    readonly detail: unknown;
+}
+export interface Success<T extends SearchType> {
+    readonly type: 'success';
+    readonly result: SuccessResult<T>;
+}
+export type StartSearchResult<T extends SearchType> = Cancel | Error | Success<T>;
+export type SearchSuccess = ReturnType<typeof useSearch>[1];
+export type SearchCancel = ReturnType<typeof useSearch>[2];
+export type SearchError = ReturnType<typeof useSearch>[3];
+export interface SelectSearchProps {
+    searchTarget: SearchTarget;
+    searchType: SearchType;
+    paramString: string;
+    success: SearchSuccess;
+    cancel: SearchCancel;
+    error: SearchError;
+}
+export interface StartSearchArg {
+    target: SearchTarget;
+    type: SearchType;
+    paramString: string;
+}
+declare const useSearch: (setIsVisible: ReturnType<typeof useVisible>[1], setSearchTarget: ReturnType<typeof useSearchTarget>[1], setSearchType: ReturnType<typeof useSearchType>[1], setParamString: ReturnType<typeof useParamString>[1], lockRef: ReturnType<typeof useLock>) => readonly [({ target, type, paramString }: StartSearchArg) => Promise<StartSearchResult<SearchType>>, (result: SuccessSingleResult | SuccessMultipleResult) => void, () => void, (e: unknown) => void];
+interface IMSearchProps {
+    children: JSX.Element;
+    searchContext?: typeof DefaultContext;
+    SearchComponent: (props: SelectSearchProps) => JSX.Element;
+}
+export declare const IMSearch: ({ children, searchContext, SearchComponent, }: IMSearchProps) => JSX.Element;
+export {};

package/lib/packages/Search/index.js

@@ -0,0 +1,72 @@
+import { useCallback, useRef, useState } from 'react';
+import { Modal } from 'react-native';
+import { Context as DefaultContext } from './Context';
+import { IMSearchError } from './IMSearchError';
+const useLock = () => {
+    return useRef(false);
+};
+const useVisible = () => {
+    return useState(false);
+};
+const useSearchTarget = () => {
+    return useState(undefined);
+};
+const useSearchType = () => {
+    return useState('single');
+};
+const useParamString = () => {
+    return useState('');
+};
+const useSearch = (setIsVisible, setSearchTarget, setSearchType, setParamString, lockRef) => {
+    const serchResolveRef = useRef(null);
+    const start = useCallback(({ target, type, paramString }) => {
+        return new Promise((resolve) => {
+            if (lockRef.current)
+                resolve({ type: 'locked' });
+            lockRef.current = true;
+            serchResolveRef.current = resolve;
+            setSearchTarget(target);
+            setSearchType(type);
+            setParamString(paramString);
+            setIsVisible(true);
+        });
+    }, [setIsVisible, setSearchTarget, setSearchType, setParamString]);
+    const complate = useCallback((result) => {
+        if (serchResolveRef.current != null)
+            serchResolveRef.current(result);
+        else
+            throw new IMSearchError('not found resolve');
+        serchResolveRef.current = null;
+        lockRef.current = false;
+        setIsVisible(false);
+    }, [setIsVisible]);
+    const success = useCallback((result) => {
+        complate({ type: 'success', result });
+    }, [complate]);
+    const cancel = useCallback(() => {
+        complate({ type: 'cancel' });
+    }, [complate]);
+    const error = useCallback((e) => {
+        complate({ type: 'error', detail: e });
+    }, [complate]);
+    return [start, success, cancel, error];
+};
+export const IMSearch = ({ children, searchContext, SearchComponent, }) => {
+    const Context = searchContext || DefaultContext;
+    const contextRef = useRef();
+    const lockRef = useLock();
+    const [isVisible, setIsVisible] = useVisible();
+    const [searchTarget, setSearchTarget] = useSearchTarget();
+    const [searchType, setSearchType] = useSearchType();
+    const [paramString, setParamString] = useParamString();
+    const [start, success, cancel, error] = useSearch(setIsVisible, setSearchTarget, setSearchType, setParamString, lockRef);
+    contextRef.current = {
+        start,
+    };
+    return (<Context.Provider value={contextRef.current}>
+      <Modal visible={isVisible} animationType={'slide'} transparent={true}>
+        <SearchComponent searchTarget={searchTarget} searchType={searchType} paramString={paramString} success={success} cancel={cancel} error={error}/>
+      </Modal>
+      {children}
+    </Context.Provider>);
+};