repo: integrate packages from former merchant-backoffice.git

1 files changed, 150 insertions, 0 deletions

diff --git a/packages/merchant-backend-ui/src/hooks/transfer.ts b/packages/merchant-backend-ui/src/hooks/transfer.ts
new file mode 100644
index 000000000..482f00dc5
--- /dev/null
+++ b/packages/merchant-backend-ui/src/hooks/transfer.ts
@@ -0,0 +1,150 @@
+/*
+ This file is part of GNU Taler
+ (C) 2021 Taler Systems S.A.
+
+ GNU Taler is free software; you can redistribute it and/or modify it under the
+ terms of the GNU General Public License as published by the Free Software
+ Foundation; either version 3, or (at your option) any later version.
+
+ GNU Taler is distributed in the hope that it will be useful, but WITHOUT ANY
+ WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License along with
+ GNU Taler; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
+ */
+import { MerchantBackend } from '../declaration';
+import { useBackendContext } from '../context/backend';
+import { request, mutateAll, HttpResponse, HttpError, HttpResponseOk, HttpResponsePaginated } from './backend';
+import useSWR from 'swr';
+import { useInstanceContext } from '../context/instance';
+import { MAX_RESULT_SIZE, PAGE_SIZE } from '../utils/constants';
+import { useEffect, useState } from 'preact/hooks';
+
+async function transferFetcher<T>(url: string, token: string, backend: string, payto_uri?: string, verified?: string, position?: string, delta?: number): Promise<HttpResponseOk<T>> {
+  const params: any = {}
+  if (payto_uri !== undefined) params.payto_uri = payto_uri
+  if (verified !== undefined) params.verified = verified
+  if (delta !== undefined) {
+    // if (delta > 0) {
+    //   params.after = searchDate?.getTime()
+    // } else {
+    //   params.before = searchDate?.getTime()
+    // }
+    params.limit = delta
+  }
+  if (position !== undefined) params.offset = position
+
+  return request<T>(`${backend}${url}`, { token, params })
+}
+
+export function useTransferAPI(): TransferAPI {
+  const { url: baseUrl, token: adminToken } = useBackendContext();
+  const { token: instanceToken, id, admin } = useInstanceContext();
+
+  const { url, token } = !admin ? {
+    url: baseUrl, token: adminToken
+  } : {
+    url: `${baseUrl}/instances/${id}`, token: instanceToken
+  };
+
+  const informTransfer = async (data: MerchantBackend.Transfers.TransferInformation): Promise<HttpResponseOk<MerchantBackend.Transfers.MerchantTrackTransferResponse>> => {
+    mutateAll(/@"\/private\/transfers"@/);
+
+    return request<MerchantBackend.Transfers.MerchantTrackTransferResponse>(`${url}/private/transfers`, {
+      method: 'post',
+      token,
+      data
+    });
+  };
+
+  return { informTransfer };
+}
+
+export interface TransferAPI {
+  informTransfer: (data: MerchantBackend.Transfers.TransferInformation) => Promise<HttpResponseOk<MerchantBackend.Transfers.MerchantTrackTransferResponse>>;
+}
+
+export interface InstanceTransferFilter {
+  payto_uri?: string;
+  verified?: 'yes' | 'no';
+  position?: string;
+}
+
+
+export function useInstanceTransfers(args?: InstanceTransferFilter, updatePosition?: (id: string) => void): HttpResponsePaginated<MerchantBackend.Transfers.TransferList> {
+  const { url: baseUrl, token: baseToken } = useBackendContext();
+  const { token: instanceToken, id, admin } = useInstanceContext();
+
+  const { url, token } = !admin ? {
+    url: baseUrl, token: baseToken
+  } : {
+    url: `${baseUrl}/instances/${id}`, token: instanceToken
+  }
+
+  const [pageBefore, setPageBefore] = useState(1)
+  const [pageAfter, setPageAfter] = useState(1)
+
+  const totalAfter = pageAfter * PAGE_SIZE;
+  const totalBefore = args?.position !== undefined ? pageBefore * PAGE_SIZE : 0;
+
+  /**
+   * FIXME: this can be cleaned up a little
+   * 
+   * the logic of double query should be inside the orderFetch so from the hook perspective and cache
+   * is just one query and one error status
+   */
+  const { data: beforeData, error: beforeError, isValidating: loadingBefore } = useSWR<HttpResponseOk<MerchantBackend.Transfers.TransferList>, HttpError>(
+    [`/private/transfers`, token, url, args?.payto_uri, args?.verified, args?.position, totalBefore],
+    transferFetcher,
+  )
+  const { data: afterData, error: afterError, isValidating: loadingAfter } = useSWR<HttpResponseOk<MerchantBackend.Transfers.TransferList>, HttpError>(
+    [`/private/transfers`, token, url, args?.payto_uri, args?.verified, args?.position, -totalAfter],
+    transferFetcher,
+  )
+
+  //this will save last result
+  const [lastBefore, setLastBefore] = useState<HttpResponse<MerchantBackend.Transfers.TransferList>>({ loading: true })
+  const [lastAfter, setLastAfter] = useState<HttpResponse<MerchantBackend.Transfers.TransferList>>({ loading: true })
+  useEffect(() => {
+    if (afterData) setLastAfter(afterData)
+    if (beforeData) setLastBefore(beforeData)
+  }, [afterData, beforeData])
+
+  // this has problems when there are some ids missing
+
+  if (beforeError) return beforeError
+  if (afterError) return afterError
+
+  const pagination = {
+    isReachingEnd: afterData && afterData.data.transfers.length < totalAfter,
+    isReachingStart: (!args?.position) || (beforeData && beforeData.data.transfers.length < totalBefore),
+    loadMore: () => {
+      if (!afterData) return
+      if (afterData.data.transfers.length < MAX_RESULT_SIZE) {
+        setPageAfter(pageAfter + 1)
+      } else {
+        const from = `${afterData.data.transfers[afterData.data.transfers.length - 1].transfer_serial_id}`
+        if (from && updatePosition) updatePosition(from)
+      }
+    },
+    loadMorePrev: () => {
+      if (!beforeData) return
+      if (beforeData.data.transfers.length < MAX_RESULT_SIZE) {
+        setPageBefore(pageBefore + 1)
+      } else if (beforeData) {
+        const from = `${beforeData.data.transfers[beforeData.data.transfers.length - 1].transfer_serial_id}`
+        if (from && updatePosition) updatePosition(from)
+      }
+    },
+  }
+
+  const transfers = !beforeData || !afterData ? [] : (beforeData || lastBefore).data.transfers.slice().reverse().concat((afterData || lastAfter).data.transfers)
+  if (loadingAfter || loadingBefore) return { loading: true, data: { transfers } }
+  if (beforeData && afterData) {
+    return { ok: true, data: { transfers }, ...pagination }
+  }
+  return { loading: true }
+}
+
+