@cccsaurora/howler-ui 2.14.0-dev.259 → 2.14.0-dev.264

package/api/action/execute.ts

@@ -0,0 +1,19 @@
+import { hpost, joinAllUri, joinUri } from 'api';
+import { uri as parentUri } from 'api/action';
+import type { ActionReport, ActionRequest } from 'models/ActionTypes';
+
+export const uri = (id?: string) => {
+  return id ? joinAllUri(parentUri(), id, 'execute') : joinUri(parentUri(), 'execute');
+};
+
+export const post = (data: ActionRequest): Promise<ActionReport> => {
+  if (data.action_id) {
+    return hpost(uri(data.action_id), { request_id: data.request_id, query: data.query });
+  } else {
+    return hpost(uri(), {
+      request_id: data.request_id,
+      query: data.query,
+      operations: data.operations
+    });
+  }
+};

package/api/action/index.ts

@@ -0,0 +1,36 @@
+import { hdelete, hpatch, hpost, hput, joinAllUri, joinUri, uri as parentUri } from 'api';
+import * as execute from 'api/action/execute';
+import * as operations from 'api/action/operations';
+import { action } from 'api/search';
+import type { Action } from 'models/entities/generated/Action';
+
+export const uri = (id?: string) => {
+  return id ? joinAllUri(parentUri(), 'action', id) : joinUri(parentUri(), 'action');
+};
+
+export const get = (id: string): Promise<Action> => {
+  return action
+    .post({
+      query: `action_id:${id}`,
+      rows: 1
+    })
+    .then(res => res.items[0]);
+};
+
+export const post = (data: Action): Promise<Action> => {
+  return hpost(uri(), data);
+};
+
+export const put = (id: string, data: Action): Promise<Action> => {
+  return hput(uri(id), data);
+};
+
+export const patch = (id: string, data: Action): Promise<Action> => {
+  return hpatch(uri(id), data);
+};
+
+export const del = (id: string): Promise<void> => {
+  return hdelete(uri(id));
+};
+
+export { execute, operations };

package/api/action/operations.ts

@@ -0,0 +1,11 @@
+import { hget, joinUri } from 'api';
+import { uri as parentUri } from 'api/action';
+import type { ActionOperation } from 'models/ActionTypes';
+
+export const uri = () => {
+  return joinUri(parentUri(), 'operations');
+};
+
+export const get = (): Promise<ActionOperation[]> => {
+  return hget(uri());
+};

package/api/analytic/comments/index.ts

@@ -0,0 +1,27 @@
+import { hdelete, hget, hpost, hput, joinAllUri, joinUri } from 'api';
+import { uri as parentUri } from 'api/analytic';
+import type { Analytic } from 'models/entities/generated/Analytic';
+import type { Comment } from 'models/entities/generated/Comment';
+import * as react from './react';
+
+export const uri = (analytic: string, comment?: string) => {
+  return comment ? joinAllUri(parentUri(analytic), 'comments', comment) : joinUri(parentUri(analytic), 'comments');
+};
+
+export const get = (analytic: string, comment: string): Promise<Comment> => {
+  return hget(uri(analytic, comment));
+};
+
+export const put = (analytic: string, comment: string, value: string): Promise<{ success: boolean }> => {
+  return hput(uri(analytic, comment), { value });
+};
+
+export const post = (analytic: string, value: string, detection?: string): Promise<Analytic> => {
+  return hpost(uri(analytic), { value, detection });
+};
+
+export const del = (analytic: string, comments: string[]): Promise<{ success: boolean }> => {
+  return hdelete(uri(analytic), comments);
+};
+
+export { react };

package/api/analytic/comments/react.ts

@@ -0,0 +1,14 @@
+import { hdelete, hput, joinUri } from 'api';
+import { uri as parentUri } from 'api/analytic/comments';
+
+export const uri = (analytic: string, comment: string) => {
+  return joinUri(parentUri(analytic, comment), 'react');
+};
+
+export const put = (analytic: string, comment: string, type: string): Promise<boolean> => {
+  return hput(uri(analytic, comment), { type });
+};
+
+export const del = (analytic: string, comment: string): Promise<boolean> => {
+  return hdelete(uri(analytic, comment));
+};

package/api/analytic/favourite.ts

@@ -0,0 +1,14 @@
+import { hdelete, hpost, joinAllUri } from 'api';
+import { uri as parentUri } from 'api/analytic';
+
+export const uri = (id: string) => {
+  return joinAllUri(parentUri(), id, 'favourite');
+};
+
+export const del = (id: string): Promise<{ success: boolean }> => {
+  return hdelete(uri(id));
+};
+
+export const post = (id: string): Promise<{ success: boolean }> => {
+  return hpost(uri(id), {});
+};

package/api/analytic/index.ts

@@ -0,0 +1,27 @@
+import { hdelete, hget, hput, joinAllUri, joinUri, uri as parentUri } from 'api';
+import * as comments from 'api/analytic/comments';
+import * as favourite from 'api/analytic/favourite';
+import * as notebooks from 'api/analytic/notebooks';
+import * as owner from 'api/analytic/owner';
+import * as rules from 'api/analytic/rules';
+import type { Analytic } from 'models/entities/generated/Analytic';
+
+export type EditOptions = Pick<Analytic, 'description' | 'rule' | 'rule_crontab' | 'triage_settings'>;
+
+export const uri = (id?: string) => {
+  return id ? joinAllUri(parentUri(), 'analytic', id) : joinUri(parentUri(), 'analytic');
+};
+
+export const get = (id?: string) => {
+  return id ? hget<Analytic>(uri(id)) : hget<Analytic[]>(uri());
+};
+
+export const put = (id: string, editData: EditOptions): Promise<Analytic> => {
+  return hput(uri(id), editData);
+};
+
+export const del = (id: string) => {
+  return hdelete(uri(id));
+};
+
+export { comments, favourite, notebooks, owner, rules };

package/api/analytic/notebooks/index.ts

@@ -0,0 +1,15 @@
+import { hdelete, hpost, joinUri } from 'api';
+import { uri as parentUri } from 'api/analytic';
+import type { Analytic } from 'models/entities/generated/Analytic';
+
+export const uri = (analytic: string) => {
+  return joinUri(parentUri(analytic), 'notebooks');
+};
+
+export const post = (analytic: string, body: { detection: string; value: string; name: string }): Promise<Analytic> => {
+  return hpost(uri(analytic), body);
+};
+
+export const del = (analytic: string, notebooks: string[]): Promise<{ success: boolean }> => {
+  return hdelete(uri(analytic), notebooks);
+};

package/api/analytic/owner.ts

@@ -0,0 +1,11 @@
+import { hpost, joinAllUri } from 'api';
+import { uri as parentUri } from 'api/analytic';
+import type { Analytic } from 'models/entities/generated/Analytic';
+
+export const uri = (id: string) => {
+  return joinAllUri(parentUri(), id, 'owner');
+};
+
+export const post = (id: string, body: { username: string }): Promise<Analytic> => {
+  return hpost(uri(id), body);
+};

package/api/analytic/rules.ts

@@ -0,0 +1,13 @@
+import { hpost, joinUri } from 'api';
+import { uri as parentUri } from 'api/analytic';
+import type { Analytic } from 'models/entities/generated/Analytic';
+
+export const uri = () => {
+  return joinUri(parentUri(), 'rules');
+};
+
+export const post = (
+  body: Pick<Analytic, 'description' | 'name' | 'rule' | 'rule_type' | 'rule_crontab'>
+): Promise<Analytic> => {
+  return hpost(uri(), body);
+};

package/api/auth/apikey.ts

@@ -0,0 +1,20 @@
+import { hdelete, hpost, joinUri } from 'api';
+import { uri as parentUri } from 'api/auth';
+
+export type Privileges = 'R' | 'W' | 'E' | 'I';
+
+type CreateApiKeyResponse = {
+  apikey: string;
+};
+
+export const uri = (apiKeyName?: string) => {
+  return apiKeyName ? joinUri(joinUri(parentUri(), 'apikey'), apiKeyName) : joinUri(parentUri(), 'apikey');
+};
+
+export const post = (apiKeyName: string, priv: Privileges[], expiryDate: string): Promise<CreateApiKeyResponse> => {
+  return hpost(uri(), { name: apiKeyName, priv, expiry_date: expiryDate });
+};
+
+export const del = (apiKeyName: string) => {
+  return hdelete(uri(apiKeyName));
+};

package/api/auth/index.ts

@@ -0,0 +1,9 @@
+import { joinUri, uri as parentUri } from 'api';
+import * as apikey from 'api/auth/apikey';
+import * as login from 'api/auth/login';
+
+export const uri = () => {
+  return joinUri(parentUri(), 'auth');
+};
+
+export { apikey, login };

package/api/auth/login.ts

@@ -0,0 +1,35 @@
+import { hget, hpost, joinUri } from 'api';
+import { uri as parentUri } from 'api/auth';
+import { MY_LOCAL_STORAGE_PREFIX, StorageKey } from 'utils/constants';
+
+export type PostLoginBody = {
+  user?: string;
+  password?: string;
+  refresh_token?: string;
+  provider?: string;
+};
+
+export type LoginResponse = {
+  app_token?: string;
+  refresh_token?: string;
+  provider?: string;
+};
+
+export const uri = (searchParams?: URLSearchParams) => {
+  return joinUri(parentUri(), 'login', searchParams);
+};
+
+export const post = (body: PostLoginBody): Promise<LoginResponse> => {
+  return hpost(uri(), body);
+};
+
+export const get = (search: URLSearchParams): Promise<LoginResponse> => {
+  const nonce = localStorage.getItem(`${MY_LOCAL_STORAGE_PREFIX}.${StorageKey.LOGIN_NONCE}`);
+
+  if (nonce) {
+    search.set('nonce', JSON.parse(nonce));
+    localStorage.removeItem(`${MY_LOCAL_STORAGE_PREFIX}.${StorageKey.LOGIN_NONCE}`);
+  }
+
+  return hget(uri(), search);
+};

package/api/configs/index.ts

@@ -0,0 +1,10 @@
+import { hget, joinUri, uri as parentUri } from 'api';
+import type { ApiType } from 'models/entities/generated/ApiType';
+
+export const uri = () => {
+  return joinUri(parentUri(), 'configs');
+};
+
+export const get = (): Promise<ApiType> => {
+  return hget(uri());
+};

package/api/dossier/hit.ts

@@ -0,0 +1,10 @@
+/* eslint-disable import/no-cycle */
+import { hget, joinAllUri } from 'api';
+import type { Dossier } from 'models/entities/generated/Dossier';
+import { uri as parentUri } from '.';
+
+const uri = (id: string) => joinAllUri(parentUri(), 'hit', id);
+
+export const get = (id?: string): Promise<Dossier[]> => {
+  return hget(uri(id));
+};

package/api/dossier/index.ts

@@ -0,0 +1,26 @@
+// eslint-disable-next-line import/no-cycle
+import { hdelete, hget, hpost, hput, joinAllUri, joinUri, uri as parentUri } from 'api';
+import type { Dossier } from 'models/entities/generated/Dossier';
+import * as hit from './hit';
+
+export const uri = (id?: string) => {
+  return id ? joinAllUri(parentUri(), 'dossier', id) : joinUri(parentUri(), 'dossier');
+};
+
+export const get = (id?: string): Promise<Dossier | Dossier[]> => {
+  return hget(uri(id));
+};
+
+export const post = (newData: Partial<Dossier>): Promise<Dossier> => {
+  return hpost(uri(), newData);
+};
+
+export const put = (id: string, dossier: Partial<Dossier>): Promise<Dossier> => {
+  return hput(uri(id), dossier);
+};
+
+export const del = (id: string): Promise<void> => {
+  return hdelete(uri(id));
+};
+
+export { hit };

package/api/help.ts

@@ -0,0 +1,71 @@
+import { hget, joinUri, uri as parentUri } from 'api';
+
+export const uri = () => {
+  return joinUri(parentUri(), '');
+};
+
+interface ApiDescription {
+  /**
+   * Name of the api
+   */
+  name: string;
+
+  /**
+   * API path
+   */
+  path: string;
+
+  /**
+   * Is UI only API
+   */
+  ui_only: boolean;
+
+  /**
+   * Allowed HTTP methods
+   */
+  methods: string[];
+
+  /**
+   * API documentation
+   */
+  description: string;
+
+  /**
+   * Unique ID for the API
+   */
+  id: string;
+
+  /**
+   * Function called in the code
+   */
+  function: string;
+
+  /**
+   * Does the API require login
+   **/
+  protected: boolean;
+
+  /**
+   * Type of users allowed to use API
+   */
+  required_type: string[];
+
+  /**
+   * Type of privileges needed by API keys to use API
+   */
+  required_priv: string[];
+
+  /**
+   * Is the API stable?
+   **/
+  complete: boolean;
+}
+
+export interface HelpResponse {
+  apis: ApiDescription[];
+  blueprints: { [index: string]: string };
+}
+
+export const get = (): Promise<HelpResponse> => {
+  return hget(uri());
+};

package/api/hit/assign.ts

@@ -0,0 +1,11 @@
+import { hput, joinAllUri } from 'api';
+import type { HitActionBody, HitActionResponse } from 'api/hit';
+import { uri as parentUri } from 'api/hit';
+
+export const uri = (id: string) => {
+  return joinAllUri(parentUri(), id, 'assign');
+};
+
+export const put = (id: string, body: HitActionBody): Promise<HitActionResponse> => {
+  return hput(uri(id), body);
+};

package/api/hit/comments/index.ts

@@ -0,0 +1,27 @@
+import { hdelete, hget, hpost, hput, joinAllUri, joinUri } from 'api';
+import { uri as parentUri } from 'api/hit';
+import type { Comment } from 'models/entities/generated/Comment';
+import type { Hit } from 'models/entities/generated/Hit';
+import * as react from './react';
+
+export const uri = (hit: string, comment?: string) => {
+  return comment ? joinAllUri(parentUri(hit), 'comments', comment) : joinUri(parentUri(hit), 'comments');
+};
+
+export const get = (hit: string, comment: string): Promise<Comment> => {
+  return hget(uri(hit, comment));
+};
+
+export const put = (hit: string, comment: string, value: string): Promise<{ success: boolean }> => {
+  return hput(uri(hit, comment), { value });
+};
+
+export const post = (hit: string, value: string): Promise<Hit> => {
+  return hpost(uri(hit), { value });
+};
+
+export const del = (hit: string, comments: string[]): Promise<{ success: boolean }> => {
+  return hdelete(uri(hit), comments);
+};
+
+export { react };

package/api/hit/comments/react.ts

@@ -0,0 +1,15 @@
+// eslint-disable-next-line import/no-cycle
+import { hdelete, hput, joinUri } from 'api';
+import { uri as parentUri } from 'api/hit/comments';
+
+export const uri = (hit: string, comment: string) => {
+  return joinUri(parentUri(hit, comment), 'react');
+};
+
+export const put = (hit: string, comment: string, type: string): Promise<boolean> => {
+  return hput(uri(hit, comment), { type });
+};
+
+export const del = (hit: string, comment: string): Promise<boolean> => {
+  return hdelete(uri(hit, comment));
+};

package/api/hit/index.ts

@@ -0,0 +1,56 @@
+import { hdelete, hget, hpost, joinAllUri, joinUri, uri as parentUri } from 'api';
+import * as assign from 'api/hit/assign';
+import * as comments from 'api/hit/comments';
+import * as labels from 'api/hit/labels';
+import * as overwrite from 'api/hit/overwrite';
+import * as transition from 'api/hit/transition';
+import type { Hit } from 'models/entities/generated/Hit';
+
+export type HitActionBody = {
+  value: string;
+};
+
+export type LabelActionBody = {
+  value: string[];
+};
+
+export type HitTransitionBody = {
+  transition: string;
+  data: { [key: string]: any };
+};
+
+export type HitActionResponse = {
+  success: boolean;
+};
+
+export const uri = (id?: string): string => {
+  return id ? joinAllUri(parentUri(), 'hit', id) : joinUri(parentUri(), 'hit');
+};
+
+export const get = <T extends Hit>(id: string, metadata?: string[]): Promise<T> => {
+  const params = new URLSearchParams();
+
+  if (metadata) {
+    params.append('metadata', metadata.join(','));
+  }
+
+  return hget(uri(id), params);
+};
+
+interface PostResponse {
+  valid: Hit[];
+  invalid: {
+    input: Hit;
+    error: string;
+  }[];
+}
+
+export const post = (hits: Hit[]): Promise<PostResponse> => {
+  return hpost(uri(), hits);
+};
+
+export const del = (ids: string[]): Promise<{ success: boolean }> => {
+  return hdelete(uri(), ids);
+};
+
+export { assign, comments, labels, overwrite, transition };

package/api/hit/labels.ts

@@ -0,0 +1,16 @@
+import { hdelete, hput, joinAllUri } from 'api';
+import type { LabelActionBody } from 'api/hit';
+import { uri as parentUri } from 'api/hit';
+import type { Hit } from 'models/entities/generated/Hit';
+
+export const uri = (id: string, category: string) => {
+  return joinAllUri(parentUri(), id, 'labels', category);
+};
+
+export const put = (id: string, category: string, body: LabelActionBody): Promise<Hit> => {
+  return hput(uri(id, category), body);
+};
+
+export const del = (id: string, category: string, body: LabelActionBody): Promise<Hit> => {
+  return hdelete(uri(id, category), body);
+};

package/api/hit/overwrite.ts

@@ -0,0 +1,11 @@
+import { hput, joinAllUri } from 'api';
+import { uri as parentUri } from 'api/hit';
+import type { Hit } from 'models/entities/generated/Hit';
+
+export const uri = (id: string) => {
+  return joinAllUri(parentUri(), id, 'overwrite');
+};
+
+export const put = <T extends Hit = Hit>(id: string, body: Partial<T>): Promise<T> => {
+  return hput(uri(id), body);
+};

package/api/hit/transition.ts

@@ -0,0 +1,12 @@
+import { hpost, joinAllUri } from 'api';
+import type { HitTransitionBody } from 'api/hit';
+import { uri as parentUri } from 'api/hit';
+import type { Hit } from 'models/entities/generated/Hit';
+
+export const uri = (id: string) => {
+  return joinAllUri(parentUri(), id, 'transition');
+};
+
+export const post = (id: string, body: HitTransitionBody): Promise<Hit> => {
+  return hpost(uri(id), body);
+};