src/store/advanced-tab/advanced-tab.tsx

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { Dispatch } from 'redux';
   6 import { dialogActions } from 'store/dialog/dialog-actions';
   7 import { RootState } from 'store/store';
   8 import { ResourceKind, extractUuidKind } from 'models/resource';
   9 import { getResource } from 'store/resources/resources';
  10 import { GroupContentsResourcePrefix } from 'services/groups-service/groups-service';
  11 import { snackbarActions, SnackbarKind } from 'store/snackbar/snackbar-actions';
  12 import { ContainerRequestResource } from 'models/container-request';
  13 import { CollectionResource } from 'models/collection';
  14 import { ProjectResource } from 'models/project';
  15 import { ServiceRepository } from 'services/services';
  16 import { FilterBuilder } from 'services/api/filter-builder';
  17 import { ListResults } from 'services/common-service/common-service';
  18 import { RepositoryResource } from 'models/repositories';
  19 import { SshKeyResource } from 'models/ssh-key';
  20 import { VirtualMachinesResource } from 'models/virtual-machines';
  21 import { UserResource } from 'models/user';
  22 import { LinkResource } from 'models/link';
  23 import { KeepServiceResource } from 'models/keep-services';
  24 import { ApiClientAuthorization } from 'models/api-client-authorization';
  25 import React from 'react';
  26
  27 export const ADVANCED_TAB_DIALOG = 'advancedTabDialog';
  28
  29 export interface AdvancedTabDialogData {
  30     uuid: string;
  31     apiResponse: JSX.Element;
  32     metadata: ListResults<LinkResource> | string;
  33     user: UserResource | string;
  34     pythonHeader: string;
  35     pythonExample: string;
  36     cliGetHeader: string;
  37     cliGetExample: string;
  38     cliUpdateHeader: string;
  39     cliUpdateExample: string;
  40     curlHeader: string;
  41     curlExample: string;
  42 }
  43
  44 enum CollectionData {
  45     COLLECTION = 'collection',
  46     STORAGE_CLASSES_CONFIRMED = 'storage_classes_confirmed'
  47 }
  48
  49 enum ProcessData {
  50     CONTAINER_REQUEST = 'container_request',
  51     OUTPUT_NAME = 'output_name'
  52 }
  53
  54 enum ProjectData {
  55     GROUP = 'group',
  56     DELETE_AT = 'delete_at'
  57 }
  58
  59 enum RepositoryData {
  60     REPOSITORY = 'repository',
  61     CREATED_AT = 'created_at'
  62 }
  63
  64 enum SshKeyData {
  65     SSH_KEY = 'authorized_key',
  66     CREATED_AT = 'created_at'
  67 }
  68
  69 enum VirtualMachineData {
  70     VIRTUAL_MACHINE = 'virtual_machine',
  71     CREATED_AT = 'created_at'
  72 }
  73
  74 enum ResourcePrefix {
  75     REPOSITORIES = 'repositories',
  76     AUTORIZED_KEYS = 'authorized_keys',
  77     VIRTUAL_MACHINES = 'virtual_machines',
  78     KEEP_SERVICES = 'keep_services',
  79     USERS = 'users',
  80     API_CLIENT_AUTHORIZATIONS = 'api_client_authorizations',
  81     LINKS = 'links'
  82 }
  83
  84 enum KeepServiceData {
  85     KEEP_SERVICE = 'keep_services',
  86     CREATED_AT = 'created_at'
  87 }
  88
  89 enum UserData {
  90     USER = 'user',
  91     USERNAME = 'username'
  92 }
  93
  94 enum ApiClientAuthorizationsData {
  95     API_CLIENT_AUTHORIZATION = 'api_client_authorization',
  96     DEFAULT_OWNER_UUID = 'default_owner_uuid'
  97 }
  98
  99 enum LinkData {
 100     LINK = 'link',
 101     PROPERTIES = 'properties'
 102 }
 103
 104 type AdvanceResourceKind = CollectionData | ProcessData | ProjectData | RepositoryData | SshKeyData | VirtualMachineData | KeepServiceData | ApiClientAuthorizationsData | UserData | LinkData;
 105 type AdvanceResourcePrefix = GroupContentsResourcePrefix | ResourcePrefix;
 106 type AdvanceResponseData = ContainerRequestResource | ProjectResource | CollectionResource | RepositoryResource | SshKeyResource | VirtualMachinesResource | KeepServiceResource | ApiClientAuthorization | UserResource | LinkResource | undefined;
 107
 108 export const openAdvancedTabDialog = (uuid: string) =>
 109     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 110         const kind = extractUuidKind(uuid);
 111         switch (kind) {
 112             case ResourceKind.COLLECTION:
 113                 const { data: dataCollection, metadata: metaCollection, user: userCollection } = await dispatch<any>(getDataForAdvancedTab(uuid));
 114                 const advanceDataCollection = advancedTabData({
 115                     uuid,
 116                     metadata: metaCollection,
 117                     user: userCollection,
 118                     apiResponseKind: collectionApiResponse,
 119                     data: dataCollection,
 120                     resourceKind: CollectionData.COLLECTION,
 121                     resourcePrefix: GroupContentsResourcePrefix.COLLECTION,
 122                     resourceKindProperty: CollectionData.STORAGE_CLASSES_CONFIRMED,
 123                     property: dataCollection.storageClassesConfirmed
 124                 });
 125                 dispatch<any>(initAdvancedTabDialog(advanceDataCollection));
 126                 break;
 127             case ResourceKind.PROCESS:
 128                 const { data: dataProcess, metadata: metaProcess, user: userProcess } = await dispatch<any>(getDataForAdvancedTab(uuid));
 129                 const advancedDataProcess = advancedTabData({
 130                     uuid,
 131                     metadata: metaProcess,
 132                     user: userProcess,
 133                     apiResponseKind: containerRequestApiResponse,
 134                     data: dataProcess,
 135                     resourceKind: ProcessData.CONTAINER_REQUEST,
 136                     resourcePrefix: GroupContentsResourcePrefix.PROCESS,
 137                     resourceKindProperty: ProcessData.OUTPUT_NAME,
 138                     property: dataProcess.outputName
 139                 });
 140                 dispatch<any>(initAdvancedTabDialog(advancedDataProcess));
 141                 break;
 142             case ResourceKind.PROJECT:
 143                 const { data: dataProject, metadata: metaProject, user: userProject } = await dispatch<any>(getDataForAdvancedTab(uuid));
 144                 const advanceDataProject = advancedTabData({
 145                     uuid,
 146                     metadata: metaProject,
 147                     user: userProject,
 148                     apiResponseKind: groupRequestApiResponse,
 149                     data: dataProject,
 150                     resourceKind: ProjectData.GROUP,
 151                     resourcePrefix: GroupContentsResourcePrefix.PROJECT,
 152                     resourceKindProperty: ProjectData.DELETE_AT,
 153                     property: dataProject.deleteAt
 154                 });
 155                 dispatch<any>(initAdvancedTabDialog(advanceDataProject));
 156                 break;
 157             case ResourceKind.REPOSITORY:
 158                 const dataRepository = getState().repositories.items.find(it => it.uuid === uuid);
 159                 const advanceDataRepository = advancedTabData({
 160                     uuid,
 161                     metadata: '',
 162                     user: '',
 163                     apiResponseKind: repositoryApiResponse,
 164                     data: dataRepository,
 165                     resourceKind: RepositoryData.REPOSITORY,
 166                     resourcePrefix: ResourcePrefix.REPOSITORIES,
 167                     resourceKindProperty: RepositoryData.CREATED_AT,
 168                     property: dataRepository!.createdAt
 169                 });
 170                 dispatch<any>(initAdvancedTabDialog(advanceDataRepository));
 171                 break;
 172             case ResourceKind.SSH_KEY:
 173                 const dataSshKey = getState().auth.sshKeys.find(it => it.uuid === uuid);
 174                 const advanceDataSshKey = advancedTabData({
 175                     uuid,
 176                     metadata: '',
 177                     user: '',
 178                     apiResponseKind: sshKeyApiResponse,
 179                     data: dataSshKey,
 180                     resourceKind: SshKeyData.SSH_KEY,
 181                     resourcePrefix: ResourcePrefix.AUTORIZED_KEYS,
 182                     resourceKindProperty: SshKeyData.CREATED_AT,
 183                     property: dataSshKey!.createdAt
 184                 });
 185                 dispatch<any>(initAdvancedTabDialog(advanceDataSshKey));
 186                 break;
 187             case ResourceKind.VIRTUAL_MACHINE:
 188                 const dataVirtualMachine = getState().virtualMachines.virtualMachines.items.find(it => it.uuid === uuid);
 189                 const advanceDataVirtualMachine = advancedTabData({
 190                     uuid,
 191                     metadata: '',
 192                     user: '',
 193                     apiResponseKind: virtualMachineApiResponse,
 194                     data: dataVirtualMachine,
 195                     resourceKind: VirtualMachineData.VIRTUAL_MACHINE,
 196                     resourcePrefix: ResourcePrefix.VIRTUAL_MACHINES,
 197                     resourceKindProperty: VirtualMachineData.CREATED_AT,
 198                     property: dataVirtualMachine.createdAt
 199                 });
 200                 dispatch<any>(initAdvancedTabDialog(advanceDataVirtualMachine));
 201                 break;
 202             case ResourceKind.KEEP_SERVICE:
 203                 const dataKeepService = getState().keepServices.find(it => it.uuid === uuid);
 204                 const advanceDataKeepService = advancedTabData({
 205                     uuid,
 206                     metadata: '',
 207                     user: '',
 208                     apiResponseKind: keepServiceApiResponse,
 209                     data: dataKeepService,
 210                     resourceKind: KeepServiceData.KEEP_SERVICE,
 211                     resourcePrefix: ResourcePrefix.KEEP_SERVICES,
 212                     resourceKindProperty: KeepServiceData.CREATED_AT,
 213                     property: dataKeepService!.createdAt
 214                 });
 215                 dispatch<any>(initAdvancedTabDialog(advanceDataKeepService));
 216                 break;
 217             case ResourceKind.USER:
 218                 const { resources } = getState();
 219                 const data = getResource<UserResource>(uuid)(resources);
 220                 const metadata = await services.linkService.list({
 221                     filters: new FilterBuilder()
 222                         .addEqual('head_uuid', uuid)
 223                         .getFilters()
 224                 });
 225                 const advanceDataUser = advancedTabData({
 226                     uuid,
 227                     metadata,
 228                     user: '',
 229                     apiResponseKind: userApiResponse,
 230                     data,
 231                     resourceKind: UserData.USER,
 232                     resourcePrefix: ResourcePrefix.USERS,
 233                     resourceKindProperty: UserData.USERNAME,
 234                     property: data!.username
 235                 });
 236                 dispatch<any>(initAdvancedTabDialog(advanceDataUser));
 237                 break;
 238             case ResourceKind.API_CLIENT_AUTHORIZATION:
 239                 const apiClientAuthorizationResources = getState().resources;
 240                 const dataApiClientAuthorization = getResource<ApiClientAuthorization>(uuid)(apiClientAuthorizationResources);
 241                 const advanceDataApiClientAuthorization = advancedTabData({
 242                     uuid,
 243                     metadata: '',
 244                     user: '',
 245                     apiResponseKind: apiClientAuthorizationApiResponse,
 246                     data: dataApiClientAuthorization,
 247                     resourceKind: ApiClientAuthorizationsData.API_CLIENT_AUTHORIZATION,
 248                     resourcePrefix: ResourcePrefix.API_CLIENT_AUTHORIZATIONS,
 249                     resourceKindProperty: ApiClientAuthorizationsData.DEFAULT_OWNER_UUID,
 250                     property: dataApiClientAuthorization!.defaultOwnerUuid
 251                 });
 252                 dispatch<any>(initAdvancedTabDialog(advanceDataApiClientAuthorization));
 253                 break;
 254             case ResourceKind.LINK:
 255                 const linkResources = getState().resources;
 256                 const dataLink = getResource<LinkResource>(uuid)(linkResources);
 257                 const advanceDataLink = advancedTabData({
 258                     uuid,
 259                     metadata: '',
 260                     user: '',
 261                     apiResponseKind: linkApiResponse,
 262                     data: dataLink,
 263                     resourceKind: LinkData.LINK,
 264                     resourcePrefix: ResourcePrefix.LINKS,
 265                     resourceKindProperty: LinkData.PROPERTIES,
 266                     property: dataLink!.properties
 267                 });
 268                 dispatch<any>(initAdvancedTabDialog(advanceDataLink));
 269                 break;
 270             default:
 271                 dispatch(snackbarActions.OPEN_SNACKBAR({ message: "Could not open advanced tab for this resource.", hideDuration: 2000, kind: SnackbarKind.ERROR }));
 272         }
 273     };
 274
 275 const getDataForAdvancedTab = (uuid: string) =>
 276     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 277         const { resources } = getState();
 278         const data = getResource<any>(uuid)(resources);
 279         const metadata = await services.linkService.list({
 280             filters: new FilterBuilder()
 281                 .addEqual('head_uuid', uuid)
 282                 .getFilters()
 283         });
 284
 285         return { data, metadata };
 286     };
 287
 288 const initAdvancedTabDialog = (data: AdvancedTabDialogData) => dialogActions.OPEN_DIALOG({ id: ADVANCED_TAB_DIALOG, data });
 289
 290 interface AdvancedTabData {
 291     uuid: string;
 292     metadata: ListResults<LinkResource> | string;
 293     user: UserResource | string;
 294     apiResponseKind: (apiResponse) => JSX.Element;
 295     data: AdvanceResponseData;
 296     resourceKind: AdvanceResourceKind;
 297     resourcePrefix: AdvanceResourcePrefix;
 298     resourceKindProperty: AdvanceResourceKind;
 299     property: any;
 300 }
 301
 302 const advancedTabData = ({ uuid, user, metadata, apiResponseKind, data, resourceKind, resourcePrefix, resourceKindProperty, property }: AdvancedTabData) => {
 303     return {
 304         uuid,
 305         user,
 306         metadata,
 307         apiResponse: apiResponseKind(data),
 308         pythonHeader: pythonHeader(resourceKind),
 309         pythonExample: pythonExample(uuid, resourcePrefix),
 310         cliGetHeader: cliGetHeader(resourceKind),
 311         cliGetExample: cliGetExample(uuid, resourceKind),
 312         cliUpdateHeader: cliUpdateHeader(resourceKind, resourceKindProperty),
 313         cliUpdateExample: cliUpdateExample(uuid, resourceKind, property, resourceKindProperty),
 314         curlHeader: curlHeader(resourceKind, resourceKindProperty),
 315         curlExample: curlExample(uuid, resourcePrefix, property, resourceKind, resourceKindProperty),
 316     };
 317 };
 318
 319 const pythonHeader = (resourceKind: string) =>
 320     `An example python command to get a ${resourceKind} using its uuid:`;
 321
 322 const pythonExample = (uuid: string, resourcePrefix: string) => {
 323     const pythonExample = `import arvados
 324
 325 x = arvados.api().${resourcePrefix}().get(uuid='${uuid}').execute()`;
 326
 327     return pythonExample;
 328 };
 329
 330 const cliGetHeader = (resourceKind: string) =>
 331     `An example arv command to get a ${resourceKind} using its uuid:`;
 332
 333 const cliGetExample = (uuid: string, resourceKind: string) => {
 334     const cliGetExample = `arv ${resourceKind} get \\
 335   --uuid ${uuid}`;
 336
 337     return cliGetExample;
 338 };
 339
 340 const cliUpdateHeader = (resourceKind: string, resourceName: string) =>
 341     `An example arv command to update the "${resourceName}" attribute for the current ${resourceKind}:`;
 342
 343 const cliUpdateExample = (uuid: string, resourceKind: string, resource: string | string[], resourceName: string) => {
 344     const CLIUpdateCollectionExample = `arv ${resourceKind} update \\
 345   --uuid ${uuid} \\
 346   --${resourceKind} '{"${resourceName}":${JSON.stringify(resource)}}'`;
 347
 348     return CLIUpdateCollectionExample;
 349 };
 350
 351 const curlHeader = (resourceKind: string, resource: string) =>
 352     `An example curl command to update the "${resource}" attribute for the current ${resourceKind}:`;
 353
 354 const curlExample = (uuid: string, resourcePrefix: string, resource: string | string[], resourceKind: string, resourceName: string) => {
 355     const curlExample = `curl -X PUT \\
 356   -H "Authorization: OAuth2 $ARVADOS_API_TOKEN" \\
 357   --data-urlencode ${resourceKind}@/dev/stdin \\
 358   https://$ARVADOS_API_HOST/arvados/v1/${resourcePrefix}/${uuid} \\
 359   <<EOF
 360 {
 361   "${resourceName}": ${JSON.stringify(resource, null, 4)}
 362 }
 363 EOF`;
 364
 365     return curlExample;
 366 };
 367
 368 const stringify = (item: string | null | number | boolean) =>
 369     JSON.stringify(item) || 'null';
 370
 371 const stringifyObject = (item: any) =>
 372     JSON.stringify(item, null, 2) || 'null';
 373
 374 const containerRequestApiResponse = (apiResponse: ContainerRequestResource): JSX.Element => {
 375     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, properties, state, requestingContainerUuid, containerUuid,
 376         containerCountMax, mounts, runtimeConstraints, containerImage, environment, cwd, command, outputPath, priority, expiresAt, filters, containerCount,
 377         useExisting, schedulingParameters, outputUuid, logUuid, outputName, outputTtl } = apiResponse;
 378     const response = `
 379 "uuid": "${uuid}",
 380 "owner_uuid": "${ownerUuid}",
 381 "created_at": "${createdAt}",
 382 "modified_at": ${stringify(modifiedAt)},
 383 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 384 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 385 "name": ${stringify(name)},
 386 "description": ${stringify(description)},
 387 "properties": ${stringifyObject(properties)},
 388 "state": ${stringify(state)},
 389 "requesting_container_uuid": ${stringify(requestingContainerUuid)},
 390 "container_uuid": ${stringify(containerUuid)},
 391 "container_count_max": ${stringify(containerCountMax)},
 392 "mounts": ${stringifyObject(mounts)},
 393 "runtime_constraints": ${stringifyObject(runtimeConstraints)},
 394 "container_image": ${stringify(containerImage)},
 395 "environment": ${stringifyObject(environment)},
 396 "cwd": ${stringify(cwd)},
 397 "command": ${stringifyObject(command)},
 398 "output_path": ${stringify(outputPath)},
 399 "priority": ${stringify(priority)},
 400 "expires_at": ${stringify(expiresAt)},
 401 "filters": ${stringify(filters)},
 402 "container_count": ${stringify(containerCount)},
 403 "use_existing": ${stringify(useExisting)},
 404 "scheduling_parameters": ${stringifyObject(schedulingParameters)},
 405 "output_uuid": ${stringify(outputUuid)},
 406 "log_uuid": ${stringify(logUuid)},
 407 "output_name": ${stringify(outputName)},
 408 "output_ttl": ${stringify(outputTtl)}`;
 409
 410     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 411 };
 412
 413 const collectionApiResponse = (apiResponse: CollectionResource): JSX.Element => {
 414     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, properties, portableDataHash, replicationDesired,
 415         replicationConfirmedAt, replicationConfirmed, deleteAt, trashAt, isTrashed, storageClassesDesired,
 416         storageClassesConfirmed, storageClassesConfirmedAt, currentVersionUuid, version, preserveVersion, fileCount, fileSizeTotal } = apiResponse;
 417     const response = `
 418 "uuid": "${uuid}",
 419 "owner_uuid": "${ownerUuid}",
 420 "created_at": "${createdAt}",
 421 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 422 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 423 "modified_at": ${stringify(modifiedAt)},
 424 "portable_data_hash": ${stringify(portableDataHash)},
 425 "replication_desired": ${stringify(replicationDesired)},
 426 "replication_confirmed_at": ${stringify(replicationConfirmedAt)},
 427 "replication_confirmed": ${stringify(replicationConfirmed)},
 428 "name": ${stringify(name)},
 429 "description": ${stringify(description)},
 430 "properties": ${stringifyObject(properties)},
 431 "delete_at": ${stringify(deleteAt)},
 432 "trash_at": ${stringify(trashAt)},
 433 "is_trashed": ${stringify(isTrashed)},
 434 "storage_classes_desired": ${JSON.stringify(storageClassesDesired, null, 2)},
 435 "storage_classes_confirmed": ${JSON.stringify(storageClassesConfirmed, null, 2)},
 436 "storage_classes_confirmed_at": ${stringify(storageClassesConfirmedAt)},
 437 "current_version_uuid": ${stringify(currentVersionUuid)},
 438 "version": ${version},
 439 "preserve_version": ${preserveVersion},
 440 "file_count": ${fileCount},
 441 "file_size_total": ${fileSizeTotal}`;
 442
 443     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 444 };
 445
 446 const groupRequestApiResponse = (apiResponse: ProjectResource): JSX.Element => {
 447     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, groupClass, trashAt, isTrashed, deleteAt, properties, writableBy } = apiResponse;
 448     const response = `
 449 "uuid": "${uuid}",
 450 "owner_uuid": "${ownerUuid}",
 451 "created_at": "${createdAt}",
 452 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 453 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 454 "modified_at": ${stringify(modifiedAt)},
 455 "name": ${stringify(name)},
 456 "description": ${stringify(description)},
 457 "group_class": ${stringify(groupClass)},
 458 "trash_at": ${stringify(trashAt)},
 459 "is_trashed": ${stringify(isTrashed)},
 460 "delete_at": ${stringify(deleteAt)},
 461 "properties": ${stringifyObject(properties)},
 462 "writable_by": ${stringifyObject(writableBy)}`;
 463
 464     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 465 };
 466
 467 const repositoryApiResponse = (apiResponse: RepositoryResource): JSX.Element => {
 468     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, cloneUrls } = apiResponse;
 469     const response = `
 470 "uuid": "${uuid}",
 471 "owner_uuid": "${ownerUuid}",
 472 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 473 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 474 "modified_at": ${stringify(modifiedAt)},
 475 "name": ${stringify(name)},
 476 "created_at": "${createdAt}",
 477 "clone_urls": ${stringifyObject(cloneUrls)}`;
 478
 479     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 480 };
 481
 482 const sshKeyApiResponse = (apiResponse: SshKeyResource): JSX.Element => {
 483     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, authorizedUserUuid, expiresAt } = apiResponse;
 484     const response = `
 485 "uuid": "${uuid}",
 486 "owner_uuid": "${ownerUuid}",
 487 "authorized_user_uuid": "${authorizedUserUuid}",
 488 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 489 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 490 "modified_at": ${stringify(modifiedAt)},
 491 "name": ${stringify(name)},
 492 "created_at": "${createdAt}",
 493 "expires_at": "${expiresAt}"`;
 494     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 495 };
 496
 497 const virtualMachineApiResponse = (apiResponse: VirtualMachinesResource): JSX.Element => {
 498     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, hostname } = apiResponse;
 499     const response = `
 500 "hostname": ${stringify(hostname)},
 501 "uuid": "${uuid}",
 502 "owner_uuid": "${ownerUuid}",
 503 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 504 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 505 "modified_at": ${stringify(modifiedAt)},
 506 "modified_at": ${stringify(modifiedAt)},
 507 "created_at": "${createdAt}"`;
 508
 509     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 510 };
 511
 512 const keepServiceApiResponse = (apiResponse: KeepServiceResource): JSX.Element => {
 513     const {
 514         uuid, readOnly, serviceHost, servicePort, serviceSslFlag, serviceType,
 515         ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid
 516     } = apiResponse;
 517     const response = `
 518 "uuid": "${uuid}",
 519 "owner_uuid": "${ownerUuid}",
 520 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 521 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 522 "modified_at": ${stringify(modifiedAt)},
 523 "service_host": "${serviceHost}",
 524 "service_port": "${servicePort}",
 525 "service_ssl_flag": "${stringify(serviceSslFlag)}",
 526 "service_type": "${serviceType}",
 527 "created_at": "${createdAt}",
 528 "read_only": "${stringify(readOnly)}"`;
 529
 530     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 531 };
 532
 533 const userApiResponse = (apiResponse: UserResource): JSX.Element => {
 534     const {
 535         uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid,
 536         email, firstName, lastName, username, isActive, isAdmin, prefs, defaultOwnerUuid,
 537     } = apiResponse;
 538     const response = `
 539 "uuid": "${uuid}",
 540 "owner_uuid": "${ownerUuid}",
 541 "created_at": "${createdAt}",
 542 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 543 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 544 "modified_at": ${stringify(modifiedAt)},
 545 "email": "${email}",
 546 "first_name": "${firstName}",
 547 "last_name": "${stringify(lastName)}",
 548 "username": "${username}",
 549 "is_active": "${isActive},
 550 "is_admin": "${isAdmin},
 551 "prefs": "${stringifyObject(prefs)},
 552 "default_owner_uuid": "${defaultOwnerUuid},
 553 "username": "${username}"`;
 554
 555     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 556 };
 557
 558 const apiClientAuthorizationApiResponse = (apiResponse: ApiClientAuthorization): JSX.Element => {
 559     const {
 560         uuid, ownerUuid, apiToken, apiClientId, userId, createdByIpAddress, lastUsedByIpAddress,
 561         lastUsedAt, expiresAt, defaultOwnerUuid, scopes, updatedAt, createdAt
 562     } = apiResponse;
 563     const response = `
 564 "uuid": "${uuid}",
 565 "owner_uuid": "${ownerUuid}",
 566 "api_token": "${stringify(apiToken)}",
 567 "api_client_id": "${stringify(apiClientId)}",
 568 "user_id": "${stringify(userId)}",
 569 "created_by_ip_address": "${stringify(createdByIpAddress)}",
 570 "last_used_by_ip_address": "${stringify(lastUsedByIpAddress)}",
 571 "last_used_at": "${stringify(lastUsedAt)}",
 572 "expires_at": "${stringify(expiresAt)}",
 573 "created_at": "${stringify(createdAt)}",
 574 "updated_at": "${stringify(updatedAt)}",
 575 "default_owner_uuid": "${stringify(defaultOwnerUuid)}",
 576 "scopes": "${JSON.stringify(scopes, null, 2)}"`;
 577
 578     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 579 };
 580
 581 const linkApiResponse = (apiResponse: LinkResource): JSX.Element => {
 582     const {
 583         uuid, name, headUuid, properties, headKind, tailUuid, tailKind, linkClass,
 584         ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid
 585     } = apiResponse;
 586     const response = `
 587 "uuid": "${uuid}",
 588 "name": "${name}",
 589 "head_uuid": "${headUuid}",
 590 "head_kind": "${headKind}",
 591 "tail_uuid": "${tailUuid}",
 592 "tail_kind": "${tailKind}",
 593 "link_class": "${linkClass}",
 594 "owner_uuid": "${ownerUuid}",
 595 "created_at": "${stringify(createdAt)}",
 596 "modified_at": ${stringify(modifiedAt)},
 597 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 598 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 599 "properties": "${JSON.stringify(properties, null, 2)}"`;
 600
 601     return <span style={{ marginLeft: '-15px' }}>{'{'} {response} {'\n'} <span style={{ marginLeft: '-15px' }}>{'}'}</span></span>;
 602 };