api support for sharing

src/services/api.service.ts

@@ -7,6 +7,7 @@ import { TokenService } from '../abstractions/token.service';
 import { EnvironmentUrls } from '../models/domain/environmentUrls';
 
 import { CipherRequest } from '../models/request/cipherRequest';
+import { CipherShareRequest } from '../models/request/cipherShareRequest';
 import { FolderRequest } from '../models/request/folderRequest';
 import { ImportDirectoryRequest } from '../models/request/importDirectoryRequest';
 import { PasswordHintRequest } from '../models/request/passwordHintRequest';
@@ -334,6 +335,27 @@ export class ApiService implements ApiServiceAbstraction {
         }
     }
 
+    async shareCipher(id: string, request: CipherShareRequest): Promise<any> {
+        const authHeader = await this.handleTokenState();
+        const response = await fetch(new Request(this.baseUrl + '/ciphers/' + id + '/share', {
+            body: JSON.stringify(request),
+            cache: 'no-cache',
+            credentials: this.getCredentials(),
+            headers: new Headers({
+                'Accept': 'application/json',
+                'Authorization': authHeader,
+                'Content-Type': 'application/json; charset=utf-8',
+                'Device-Type': this.deviceType,
+            }),
+            method: 'PUT',
+        }));
+
+        if (response.status !== 200) {
+            const error = await this.handleError(response, false);
+            return Promise.reject(error);
+        }
+    }
+
     async deleteCipher(id: string): Promise<any> {
         const authHeader = await this.handleTokenState();
         const response = await fetch(new Request(this.baseUrl + '/ciphers/' + id, {
@@ -377,6 +399,28 @@ export class ApiService implements ApiServiceAbstraction {
         }
     }
 
+    async shareCipherAttachment(id: string, attachmentId: string, data: FormData,
+        organizationId: string): Promise<any> {
+        const authHeader = await this.handleTokenState();
+        const response = await fetch(new Request(this.baseUrl + '/ciphers/' + id + '/attachment/' +
+            attachmentId + '/share?organizationId=' + organizationId, {
+                body: data,
+                cache: 'no-cache',
+                credentials: this.getCredentials(),
+                headers: new Headers({
+                    'Accept': 'application/json',
+                    'Authorization': authHeader,
+                    'Device-Type': this.deviceType,
+                }),
+                method: 'POST',
+            }));
+
+        if (response.status !== 200) {
+            const error = await this.handleError(response, false);
+            return Promise.reject(error);
+        }
+    }
+
     async deleteCipherAttachment(id: string, attachmentId: string): Promise<any> {
         const authHeader = await this.handleTokenState();
         const response = await fetch(new Request(this.baseUrl + '/ciphers/' + id + '/attachment/' + attachmentId, {

src/services/cipher.service.ts

@@ -3,6 +3,7 @@ import { UriMatchType } from '../enums/uriMatchType';
 
 import { CipherData } from '../models/data/cipherData';
 
+import { Attachment } from '../models/domain/attachment';
 import { Card } from '../models/domain/card';
 import { Cipher } from '../models/domain/cipher';
 import { CipherString } from '../models/domain/cipherString';
@@ -19,6 +20,7 @@ import { CipherRequest } from '../models/request/cipherRequest';
 import { CipherResponse } from '../models/response/cipherResponse';
 import { ErrorResponse } from '../models/response/errorResponse';
 
+import { AttachmentView } from '../models/view/attachmentView';
 import { CardView } from '../models/view/cardView';
 import { CipherView } from '../models/view/cipherView';
 import { FieldView } from '../models/view/fieldView';
@@ -38,6 +40,7 @@ import { StorageService } from '../abstractions/storage.service';
 import { UserService } from '../abstractions/user.service';
 
 import { Utils } from '../misc/utils';
+import { CipherShareRequest } from '../models/request/cipherShareRequest';
 
 const Keys = {
     ciphersPrefix: 'ciphers_',
@@ -77,11 +80,39 @@ export class CipherService implements CipherServiceAbstraction {
             this.encryptFields(model.fields, key).then((fields) => {
                 cipher.fields = fields;
             }),
+            this.encryptAttachments(model.attachments, key).then((attachments) => {
+                cipher.attachments = attachments;
+            }),
         ]);
 
         return cipher;
     }
 
+    async encryptAttachments(attachmentsModel: AttachmentView[], key: SymmetricCryptoKey): Promise<Attachment[]> {
+        if (attachmentsModel == null || attachmentsModel.length === 0) {
+            return null;
+        }
+
+        const promises: Array<Promise<any>> = [];
+        const encAttachments: Attachment[] = [];
+        attachmentsModel.forEach(async (model) => {
+            const attachment = new Attachment();
+            attachment.id = model.id;
+            attachment.size = model.size;
+            attachment.sizeName = model.sizeName;
+            attachment.url = model.url;
+            const promise = this.encryptObjProperty(model, attachment, {
+                fileName: null,
+            }, key).then(() => {
+                encAttachments.push(attachment);
+            });
+            promises.push(promise);
+        });
+
+        await Promise.all(promises);
+        return encAttachments;
+    }
+
     async encryptFields(fieldsModel: FieldView[], key: SymmetricCryptoKey): Promise<Field[]> {
         if (!fieldsModel || !fieldsModel.length) {
             return null;
@@ -324,6 +355,49 @@ export class CipherService implements CipherServiceAbstraction {
         await this.upsert(data);
     }
 
+    async shareWithServer(cipher: Cipher): Promise<any> {
+        const request = new CipherShareRequest(cipher);
+        await this.apiService.shareCipher(cipher.id, request);
+        const userId = await this.userService.getUserId();
+        await this.upsert(cipher.toCipherData(userId));
+    }
+
+    async shareAttachmentWithServer(attachmentView: AttachmentView, cipherId: string,
+        organizationId: string): Promise<any> {
+        const attachmentResponse = await fetch(new Request(attachmentView.url, { cache: 'no-cache' }));
+        if (attachmentResponse.status !== 200) {
+            throw Error('Failed to download attachment: ' + attachmentResponse.status.toString());
+        }
+
+        const buf = await attachmentResponse.arrayBuffer();
+        const decBuf = await this.cryptoService.decryptFromBytes(buf, null);
+        const key = await this.cryptoService.getOrgKey(organizationId);
+        const encData = await this.cryptoService.encryptToBytes(decBuf, key);
+        const encFileName = await this.cryptoService.encrypt(attachmentView.fileName, key);
+
+        const fd = new FormData();
+        try {
+            const blob = new Blob([encData], { type: 'application/octet-stream' });
+            fd.append('data', blob, encFileName.encryptedString);
+        } catch (e) {
+            if (Utils.isNode && !Utils.isBrowser) {
+                fd.append('data', new Buffer(encData) as any, {
+                    filepath: encFileName.encryptedString,
+                    contentType: 'application/octet-stream',
+                } as any);
+            } else {
+                throw e;
+            }
+        }
+
+        let response: CipherResponse;
+        try {
+            response = await this.apiService.shareCipherAttachment(cipherId, attachmentView.id, fd, organizationId);
+        } catch (e) {
+            throw new Error((e as ErrorResponse).getSingleMessage());
+        }
+    }
+
     saveAttachmentWithServer(cipher: Cipher, unencryptedFile: any): Promise<Cipher> {
         return new Promise((resolve, reject) => {
             const reader = new FileReader();