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