UMA compatibiliy about scim-for-keycloak HOT 11 CLOSED

import {useUserLogin} from "../provider/login-provider";
import {Optional} from "./utils";

export function useScimClient()
{
  
  const auth = useUserLogin();
  
  function createResource(resourcePath, resource, onSuccess, onError)
  {
    auth.accessToken.then(accessToken =>
    {
      fetch(resourcePath, {
        method: "POST",
        headers: {
          'Content-Type': 'application/scim+json',
          'Authorization': 'Bearer ' + accessToken
        },
        body: JSON.stringify(resource)
      }).then(response =>
      {
        let tmpResponse = {
          success: response.status === 201,
          status: response.status,
          resource: response.json()
        };
        if (tmpResponse.success)
        {
          new Optional(onSuccess).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        else
        {
          new Optional(onError).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        return tmpResponse;
      });
    });
  }
  
  function getResource(resourcePath, id, params, onSuccess, onError)
  {
    auth.accessToken.then(accessToken =>
    {
      let searchParams = new Optional(params).map(parameters => "?" + new URLSearchParams(parameters).toString())
                                             .orElse("");
      let url = resourcePath + new Optional(id).map(val => "/" + encodeURIComponent(val)).orElse("") + searchParams;
      
      fetch(url, {
        method: "GET",
        headers: {
          'Authorization': 'Bearer ' + accessToken
        }
      }).then(response =>
      {
        let tmpResponse = {
          success: response.status === 200,
          status: response.status,
          resource: response.json()
        };
        if (tmpResponse.success)
        {
          new Optional(onSuccess).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        else
        {
          new Optional(onError).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        return tmpResponse;
      });
    });
  }
  
  async function listResources({
                                 resourcePath,
                                 startIndex,
                                 count,
                                 filter,
                                 sortBy,
                                 sortOrder,
                                 attributes,
                                 excludedAttributes,
                                 onSuccess,
                                 onError
                               } = {})
  {
    auth.accessToken.then(accessToken =>
    {
      let startIndexParam = new Optional(startIndex).map(val => "startIndex=" + val).orElse(null);
      let countParam = new Optional(count).map(val => "count=" + val).orElse(null);
      let filterParam = new Optional(filter).map(val => "filter=" + encodeURI(val)).orElse(null);
      let sortByParam = new Optional(sortBy).map(val => "sortBy=" + encodeURI(val)).orElse(null);
      let sortOrderParam = new Optional(sortOrder).map(val => "sortOrder=" + val).orElse(null);
      let attributesParam = new Optional(attributes).map(val => "attributes=" + encodeURI(val)).orElse(null);
      let excludedAttributesParam = new Optional(excludedAttributes).map(
        val => "excludedAttributes=" + encodeURI(val)).orElse(null);
      
      let query = Array.of(startIndexParam, countParam, filterParam, sortByParam, sortOrderParam, attributesParam,
        excludedAttributesParam)
                       .filter(val => val != null)
                       .join("&");
      
      query = new Optional(query).filter(val => val.length > 0).map(val => "?" + val).orElse("");
      
      let requestUrl = resourcePath + query;
      
      fetch(requestUrl, {
        method: "GET",
        headers: {
          'Authorization': 'Bearer ' + accessToken
        }
      }).then(response =>
      {
        let tmpResponse = {
          success: response.status === 200,
          status: response.status,
          resource: response.json()
        };
        if (tmpResponse.success)
        {
          new Optional(onSuccess).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        else
        {
          new Optional(onError).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        return tmpResponse;
      });
    });
  }
  
  function updateResource(resourcePath, id, resource, onSuccess, onError)
  {
    auth.accessToken.then(accessToken =>
    {
      fetch(resourcePath + "/" + encodeURIComponent(id), {
        method: "PUT",
        headers: {
          'Content-Type': 'application/scim+json',
          'Authorization': 'Bearer ' + accessToken
        },
        body: JSON.stringify(resource)
      }).then(response =>
      {
        let tmpResponse = {
          success: response.status === 200,
          status: response.status,
          resource: response.json()
        };
        if (tmpResponse.success)
        {
          new Optional(onSuccess).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        else
        {
          new Optional(onError).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        return tmpResponse;
      });
    });
  }
  
  function patchResource(resourcePath, id, patchBody, onSuccess, onError)
  {
    auth.accessToken.then(accessToken =>
    {
      fetch(resourcePath + "/" + encodeURIComponent(id), {
        method: "PATCH",
        headers: {
          'Content-Type': 'application/scim+json',
          'Authorization': 'Bearer ' + accessToken
        },
        body: JSON.stringify(patchBody)
      }).then(response =>
      {
        let tmpResponse = {
          success: response.status === 200,
          status: response.status,
          resource: response.json()
        };
        if (tmpResponse.success)
        {
          new Optional(onSuccess).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        else
        {
          new Optional(onError).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        return tmpResponse;
      });
    });
  }
  
  function deleteResource(resourcePath, id, requestBody, onSuccess, onError)
  {
    auth.accessToken.then(accessToken =>
    {
      fetch(resourcePath + "/" + encodeURIComponent(id), {
        method: "DELETE",
        headers: {
          'Authorization': 'Bearer ' + accessToken
        },
        body: requestBody ? JSON.stringify(requestBody) : null
      }).then(response =>
      {
        let tmpResponse = {
          success: response.status === 204,
          status: response.status,
          resource: response.status === 204 ? undefined : response.json()
        };
        if (tmpResponse.success)
        {
          new Optional(onSuccess).ifPresent(func => func());
        }
        else
        {
          new Optional(onError).ifPresent(func => tmpResponse.resource.then(json => func(json)));
        }
        return tmpResponse;
      });
    });
  }
  
  return {
    createResource: createResource,
    getResource: getResource,
    listResources: listResources,
    updateResource: updateResource,
    patchResource: patchResource,
    deleteResource: deleteResource
  };
}