src/services/collection-service/collection-service.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { CommonResourceService } from "../../common/api/common-resource-service";
   6 import { CollectionResource } from "../../models/collection";
   7 import axios, { AxiosInstance } from "axios";
   8 import { KeepService } from "../keep-service/keep-service";
   9 import { FilterBuilder } from "../../common/api/filter-builder";
  10 import { CollectionFile, createCollectionFile, createCollectionDirectory, createCollectionFilesTree } from "../../models/collection-file";
  11 import { parseKeepManifestText, stringifyKeepManifest } from "../collection-files-service/collection-manifest-parser";
  12 import * as _ from "lodash";
  13 import { KeepManifestStream } from "../../models/keep-manifest";
  14 import { WebDAV } from "../../common/webdav";
  15 import { AuthService } from "../auth-service/auth-service";
  16
  17 export type UploadProgress = (fileId: number, loaded: number, total: number, currentTime: number) => void;
  18
  19 export class CollectionService extends CommonResourceService<CollectionResource> {
  20     constructor(serverApi: AxiosInstance, private keepService: KeepService, private webdavClient: WebDAV, private authService: AuthService) {
  21         super(serverApi, "collections");
  22     }
  23
  24     async files(uuid: string) {
  25         const request = await this.webdavClient.propfind(`/c=${uuid}`);
  26         if (request.responseXML != null) {
  27             return createCollectionFilesTree(this.extractFilesData(request.responseXML));
  28         }
  29         return Promise.reject();
  30     }
  31
  32     async deleteFile(collectionUuid: string, filePath: string){
  33         return this.webdavClient.delete(`/c=${collectionUuid}${filePath}`);
  34     }
  35
  36
  37     extractFilesData(document: Document) {
  38         return Array
  39             .from(document.getElementsByTagName('D:response'))
  40             .slice(1)
  41             .map(element => {
  42                 const [displayNameElement] = Array.from(element.getElementsByTagName('D:displayname'));
  43                 const name = displayNameElement ? displayNameElement.innerHTML : undefined;
  44
  45                 const [sizeElement] = Array.from(element.getElementsByTagName('D:getcontentlength'));
  46                 const size = sizeElement ? parseInt(sizeElement.innerHTML, 10) : 0;
  47
  48                 const [hrefElement] = Array.from(element.getElementsByTagName('D:href'));
  49                 const pathname = hrefElement ? hrefElement.innerHTML : undefined;
  50                 const directory = pathname && pathname.replace(/\/c=[0-9a-zA-Z\-]*/, '').replace(`/${name || ''}`, '');
  51
  52                 const href = this.webdavClient.defaults.baseURL + pathname + '?api_token=' + this.authService.getApiToken();
  53
  54                 const data = {
  55                     url: href,
  56                     id: `${directory}/${name}`,
  57                     name,
  58                     path: directory,
  59                 };
  60
  61                 const [resourceTypeElement] = Array.from(element.getElementsByTagName('D:resourcetype'));
  62                 return resourceTypeElement && resourceTypeElement.innerHTML === ''
  63                     ? createCollectionFile({ ...data, size })
  64                     : createCollectionDirectory(data);
  65
  66             });
  67     }
  68
  69
  70     private readFile(file: File): Promise<ArrayBuffer> {
  71         return new Promise<ArrayBuffer>(resolve => {
  72             const reader = new FileReader();
  73             reader.onload = () => {
  74                 resolve(reader.result as ArrayBuffer);
  75             };
  76
  77             reader.readAsArrayBuffer(file);
  78         });
  79     }
  80
  81     private uploadFile(keepServiceHost: string, file: File, fileId: number, onProgress?: UploadProgress): Promise<CollectionFile> {
  82         return this.readFile(file).then(content => {
  83             return axios.post<string>(keepServiceHost, content, {
  84                 headers: {
  85                     'Content-Type': 'text/octet-stream'
  86                 },
  87                 onUploadProgress: (e: ProgressEvent) => {
  88                     if (onProgress) {
  89                         onProgress(fileId, e.loaded, e.total, Date.now());
  90                     }
  91                     console.log(`${e.loaded} / ${e.total}`);
  92                 }
  93             }).then(data => createCollectionFile({
  94                 id: data.data,
  95                 name: file.name,
  96                 size: file.size
  97             }));
  98         });
  99     }
 100
 101     private async updateManifest(collectionUuid: string, files: CollectionFile[]): Promise<CollectionResource> {
 102         const collection = await this.get(collectionUuid);
 103         const manifest: KeepManifestStream[] = parseKeepManifestText(collection.manifestText);
 104
 105         files.forEach(f => {
 106             let kms = manifest.find(stream => stream.name === f.path);
 107             if (!kms) {
 108                 kms = {
 109                     files: [],
 110                     locators: [],
 111                     name: f.path
 112                 };
 113                 manifest.push(kms);
 114             }
 115             kms.locators.push(f.id);
 116             const len = kms.files.length;
 117             const nextPos = len > 0
 118                 ? parseInt(kms.files[len - 1].position, 10) + kms.files[len - 1].size
 119                 : 0;
 120             kms.files.push({
 121                 name: f.name,
 122                 position: nextPos.toString(),
 123                 size: f.size
 124             });
 125         });
 126
 127         console.log(manifest);
 128
 129         const manifestText = stringifyKeepManifest(manifest);
 130         const data = { ...collection, manifestText };
 131         return this.update(collectionUuid, CommonResourceService.mapKeys(_.snakeCase)(data));
 132     }
 133
 134     uploadFiles(collectionUuid: string, files: File[], onProgress?: UploadProgress): Promise<CollectionResource | never> {
 135         const filters = FilterBuilder.create()
 136             .addEqual("service_type", "proxy");
 137
 138         return this.keepService.list({ filters }).then(data => {
 139             if (data.items && data.items.length > 0) {
 140                 const serviceHost =
 141                     (data.items[0].serviceSslFlag ? "https://" : "http://") +
 142                     data.items[0].serviceHost +
 143                     ":" + data.items[0].servicePort;
 144
 145                 console.log("serviceHost", serviceHost);
 146
 147                 const files$ = files.map((f, idx) => this.uploadFile(serviceHost, f, idx, onProgress));
 148                 return Promise.all(files$).then(values => {
 149                     return this.updateManifest(collectionUuid, values);
 150                 });
 151             } else {
 152                 return Promise.reject("Missing keep service host");
 153             }
 154         });
 155     }
 156 }