src/store/advanced-tab/advanced-tab.ts

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