add contribution modal, cell morphology creation (#914)

Author: bilalesi

package.json

@@ -81,8 +81,10 @@
     "d3": "^7.8.4",
     "d3-sankey": "^0.12.3",
     "date-fns": "^4.1.0",
+    "dayjs": "^1.11.18",
     "deepdash-es": "^5.3.9",
     "distinct-colors": "^3.0.0",
+    "embla-carousel-fade": "^8.6.0",
     "embla-carousel-react": "^8.6.0",
     "embla-carousel-wheel-gestures": "^8.1.0",
     "fast-csv": "^5.0.2",

pnpm-lock.yaml

@@ -448,7 +448,7 @@ class ApiClient {
  * @param {CacheConfiguration} [cacheConfig] - optional cache configuration
  * @returns {Promise<ApiClient>} a promise that resolves to an instance of ApiClient
  */
-export default async function authApiClient(rootUri: string, cacheConfig?: CacheConfiguration) {
+export async function authApiClient(rootUri: string, cacheConfig?: CacheConfiguration) {
   const session = await getSession();
 
   return new ApiClient({
@@ -457,3 +457,5 @@ export default async function authApiClient(rootUri: string, cacheConfig?: Cache
     cache: cacheConfig,
   });
 }
+
+export default authApiClient;

src/api/apiClient.ts

@@ -1,5 +1,5 @@
-import authApiClient from '@/api/apiClient';
 import { getEntityCoreContext } from '@/api/entitycore/utils';
+import { authApiClient } from '@/api/apiClient';
 import { entityCoreUrl } from '@/config';
 
 import type { EntityCoreResponse } from '@/api/entitycore/types/shared/response';

src/api/entitycore/queries/annotations/etype.ts

@@ -0,0 +1,75 @@
+import z from 'zod';
+
+import { getEntityCoreContext } from '@/api/entitycore/utils';
+import { authApiClient } from '@/api/apiClient';
+import { entityCoreUrl } from '@/config';
+
+import type { IMTypeClassification } from '@/api/entitycore/types/shared/global';
+import type { EntityCoreResponse } from '@/api/entitycore/types/shared/response';
+import type { WorkspaceContext } from '@/types/common';
+
+const baseUri = '/mtype-classification';
+/**
+ * Retrieves a list of mtype classifications from the EntityCoreAPI.
+
+ * @returns {Promise<EntityCoreResponse<IMType>>} A promise that resolves to the list of mtypes
+ */
+export async function getMtypeClassifications({
+  filters,
+  ctx,
+}: {
+  filters?: any;
+  ctx?: WorkspaceContext;
+}) {
+  const api = await authApiClient(entityCoreUrl);
+  return await api.get<EntityCoreResponse<IMTypeClassification>>(baseUri, {
+    ...getEntityCoreContext(ctx),
+    queryParams: {
+      ...filters,
+    },
+  });
+}
+
+/**
+ * Retrieves one mtype classification from the EntityCoreAPI.
+
+ * @returns {Promise<IMType>} A promise that resolves to the single mtype
+ */
+export async function getMtypeClassification({ id }: { id: string }) {
+  const api = await authApiClient(entityCoreUrl);
+  return await api.get<IMTypeClassification>(`${baseUri}/${id}`, undefined, {
+    cache: { cacheName: 'mtype', enabled: true, ttlInSeconds: 86_400 },
+  });
+}
+
+export const mtypeClassificationCreateSchema = z.object({
+  authorized_public: z.boolean(),
+  entity_id: z.string().uuid(),
+  mtype_class_id: z.string().uuid(),
+});
+
+export type TMtypeClassificationCreate = z.infer<typeof mtypeClassificationCreateSchema>;
+
+/**
+ * Creates a new mtype classification
+ * @param param0
+ * @returns A promise that resolves to the created mtype classification
+ */
+export async function createMtypeClassification({
+  context,
+  payload,
+}: {
+  context: WorkspaceContext;
+  payload: TMtypeClassificationCreate;
+}) {
+  const api = await authApiClient(entityCoreUrl);
+  return await api.post<IMTypeClassification>(baseUri, {
+    ...getEntityCoreContext(context),
+    headers: {
+      accept: 'application/json',
+      'content-type': 'application/json',
+      ...getEntityCoreContext(context).headers,
+    },
+    body: payload,
+  });
+}

src/api/entitycore/queries/annotations/mtype-classification.ts

@@ -1,5 +1,5 @@
-import authApiClient from '@/api/apiClient';
 import { getEntityCoreContext } from '@/api/entitycore/utils';
+import { authApiClient } from '@/api/apiClient';
 import { entityCoreUrl } from '@/config';
 
 import type { IMType, IMTypeFilter } from '@/api/entitycore/types/shared/global';

src/api/entitycore/queries/annotations/mtype.ts

@@ -1,10 +1,9 @@
 import kebabCase from 'lodash/kebabCase';
 
-import authApiClient from '@/api/apiClient';
-
 import { TEntityTypeDict } from '@/api/entitycore/types/entity-type';
 import { getEntityCoreContext } from '@/api/entitycore/utils';
 import { compactRecord } from '@/utils/dictionary';
+import { authApiClient } from '@/api/apiClient';
 import { entityCoreUrl } from '@/config';
 
 import type {
@@ -216,3 +215,42 @@ export async function listDirectoryOfAssets({
     { retryOnError }
   );
 }
+
+export async function createAsset({
+  ctx,
+  entityType,
+  entityId,
+  fileName,
+  payload,
+  meta,
+  label,
+  mimeType,
+}: {
+  ctx?: WorkspaceContext;
+  entityType: EntityCoreDataType;
+  entityId: string;
+  fileName: string;
+  mimeType: string;
+  payload: BlobPart;
+  meta?: Record<string, any>;
+  label?: AssetLabel;
+}): Promise<IAsset> {
+  const blob = new Blob([payload], { type: mimeType });
+  const file = new File([blob], fileName, { type: mimeType });
+  const formData = new FormData();
+
+  if (file) formData.append('file', file);
+  if (label) formData.append('label', label);
+  if (meta) formData.append('meta', JSON.stringify(meta));
+
+  const api = await authApiClient(entityCoreUrl);
+  return await api.post<IAsset>(`/${kebabCase(entityType)}/${entityId}/assets`, {
+    headers: {
+      ...getEntityCoreContext(ctx).headers,
+      // This is required due apiClient is using "application/json" as default content-type
+      // the browser should handle auto the multipart-form
+      'Content-Type': undefined,
+    },
+    body: formData,
+  });
+}

src/api/entitycore/queries/assets/index.ts

@@ -1,3 +1,4 @@
+import z from 'zod';
 import { entityCoreApi, getEntityCoreContext } from '@/api/entitycore/utils';
 
 import type { EntityCoreResponse } from '@/api/entitycore/types/shared/response';
@@ -69,3 +70,56 @@ export async function getCellMorphology({
     },
   });
 }
+
+const cellMorphologySchema = z.object({
+  name: z
+    .string({ message: 'Cell morphology name is required' })
+    .nonempty({ message: 'Cell morphology name is required' }),
+  description: z
+    .string({ message: 'Cell morphology description is required' })
+    .nonempty({ message: 'Cell morphology description is required' }),
+  brain_region_id: z
+    .string({ message: 'Brain region is required' })
+    .uuid()
+    .nonempty({ message: 'Brain region is required' }),
+  subject_id: z
+    .string({ message: 'Subject is required' })
+    .uuid()
+    .nonempty({ message: 'Subject is required' }),
+  license_id: z
+    .string({ message: 'License is required' })
+    .uuid()
+    .nonempty({ message: 'License is required' }),
+  experiment_date: z.string({ message: 'Experiment date is required' }).nullish(),
+  contact_email: z
+    .string({ message: 'Contact email is required' })
+    .email({ message: 'Contact email is required' })
+    .nullish(),
+  published_in: z.string({ message: 'Published in is required' }).nullish(),
+  location: z.object({ x: z.number(), y: z.number(), z: z.number() }).nullable(),
+});
+
+export type TCellMorphologyCreate = z.infer<typeof cellMorphologySchema>;
+
+/**
+ * Creates a new cell morphology
+ * @param param0
+ * @returns A promise that resolves to the created cell morphology
+ */
+export async function createCellMorphology({
+  context,
+  payload,
+}: {
+  context?: WorkspaceContext | null;
+  payload: TCellMorphologyCreate;
+}) {
+  const api = await entityCoreApi();
+  return await api.post<ICellMorphology>(baseUri, {
+    headers: {
+      accept: 'application/json',
+      'content-type': 'application/json',
+      ...getEntityCoreContext(context).headers,
+    },
+    body: payload,
+  });
+}

src/api/entitycore/queries/experimental/cell-morphology.ts

@@ -0,0 +1,31 @@
+import { authApiClient } from '@/api/apiClient';
+import { entityCoreUrl } from '@/config';
+
+import type { EntityCoreResponse } from '@/api/entitycore/types/shared/response';
+import type { IConsortiumFilter } from '@/api/entitycore/types/entities/agent';
+import type { IConsortium } from '@/api/entitycore/types/shared/global';
+
+const baseUri = '/consortium';
+/**
+ * Retrieves a list of consortia from the EntityCoreAPI.
+
+ * @returns {Promise<EntityCoreResponse<IConsortium>>} A promise that resolves to the list of consortia
+ */
+export async function getConsortia({ filters }: { filters: Partial<IConsortiumFilter> }) {
+  const api = await authApiClient(entityCoreUrl);
+  return await api.get<EntityCoreResponse<IConsortium>>(baseUri, {
+    queryParams: {
+      ...filters,
+    },
+  });
+}
+
+/**
+ * Retrieves one consortium from the EntityCoreAPI.
+
+ * @returns {Promise<IConsortium>} A promise that resolves to the single consortium
+ */
+export async function getConsortium({ id }: { id: string }) {
+  const api = await authApiClient(entityCoreUrl);
+  return await api.get<IConsortium>(`${baseUri}/${id}`);
+}