move org vault stuff into subfolder

src/app/organizations/vault/add-edit.component.ts

@@ -0,0 +1,77 @@
+import {
+    Component,
+    OnInit,
+} from '@angular/core';
+
+import { ToasterService } from 'angular2-toaster';
+import { Angulartics2 } from 'angulartics2';
+
+import { ApiService } from 'jslib/abstractions/api.service';
+import { AuditService } from 'jslib/abstractions/audit.service';
+import { CipherService } from 'jslib/abstractions/cipher.service';
+import { FolderService } from 'jslib/abstractions/folder.service';
+import { I18nService } from 'jslib/abstractions/i18n.service';
+import { PasswordGenerationService } from 'jslib/abstractions/passwordGeneration.service';
+import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
+import { StateService } from 'jslib/abstractions/state.service';
+import { TokenService } from 'jslib/abstractions/token.service';
+import { TotpService } from 'jslib/abstractions/totp.service';
+
+import { CipherData } from 'jslib/models/data/cipherData';
+import { Cipher } from 'jslib/models/domain/cipher';
+import { Organization } from 'jslib/models/domain/organization';
+import { CipherRequest } from 'jslib/models/request/cipherRequest';
+
+import { AddEditComponent as BaseAddEditComponent } from '../../vault/add-edit.component';
+
+@Component({
+    selector: 'app-org-vault-add-edit',
+    templateUrl: '../../vault/add-edit.component.html',
+})
+export class AddEditComponent extends BaseAddEditComponent implements OnInit {
+    organization: Organization;
+
+    constructor(cipherService: CipherService, folderService: FolderService,
+        i18nService: I18nService, platformUtilsService: PlatformUtilsService,
+        analytics: Angulartics2, toasterService: ToasterService,
+        auditService: AuditService, stateService: StateService,
+        tokenService: TokenService, totpService: TotpService,
+        passwordGenerationService: PasswordGenerationService, private apiService: ApiService) {
+        super(cipherService, folderService, i18nService, platformUtilsService, analytics,
+            toasterService, auditService, stateService, tokenService, totpService, passwordGenerationService);
+    }
+
+    protected async loadCipher() {
+        if (!this.organization.isAdmin) {
+            return await super.loadCipher();
+        }
+        const response = await this.apiService.getCipherAdmin(this.cipherId);
+        return new Cipher(new CipherData(response));
+    }
+
+    protected encryptCipher() {
+        if (!this.editMode) {
+            this.cipher.organizationId = this.organization.id;
+        }
+        return super.encryptCipher();
+    }
+
+    protected async saveCipher(cipher: Cipher) {
+        if (!this.organization.isAdmin) {
+            return super.saveCipher(cipher);
+        }
+        const request = new CipherRequest(cipher);
+        if (this.editMode) {
+            return this.apiService.putCipherAdmin(this.cipherId, request);
+        } else {
+            return this.apiService.postCipherAdmin(request);
+        }
+    }
+
+    protected async deleteCipher() {
+        if (!this.organization.isAdmin) {
+            return super.deleteCipher();
+        }
+        return this.apiService.deleteCipherAdmin(this.cipherId);
+    }
+}

src/app/organizations/vault/attachments.component.ts

@@ -0,0 +1,52 @@
+import { Component } from '@angular/core';
+
+import { ToasterService } from 'angular2-toaster';
+import { Angulartics2 } from 'angulartics2';
+
+import { ApiService } from 'jslib/abstractions/api.service';
+import { CipherService } from 'jslib/abstractions/cipher.service';
+import { CryptoService } from 'jslib/abstractions/crypto.service';
+import { I18nService } from 'jslib/abstractions/i18n.service';
+import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
+import { TokenService } from 'jslib/abstractions/token.service';
+
+import { CipherData } from 'jslib/models/data/cipherData';
+import { Cipher } from 'jslib/models/domain/cipher';
+import { Organization } from 'jslib/models/domain/organization';
+
+import { AttachmentsComponent as BaseAttachmentsComponent } from '../../vault/attachments.component';
+
+@Component({
+    selector: 'app-org-vault-attachments',
+    templateUrl: '../../vault/attachments.component.html',
+})
+export class AttachmentsComponent extends BaseAttachmentsComponent {
+    organization: Organization;
+
+    constructor(cipherService: CipherService, analytics: Angulartics2,
+        toasterService: ToasterService, i18nService: I18nService,
+        cryptoService: CryptoService, tokenService: TokenService,
+        platformUtilsService: PlatformUtilsService, private apiService: ApiService) {
+        super(cipherService, analytics, toasterService, i18nService, cryptoService, tokenService,
+            platformUtilsService);
+    }
+
+    protected async loadCipher() {
+        if (!this.organization.isAdmin) {
+            return await super.loadCipher();
+        }
+        const response = await this.apiService.getCipherAdmin(this.cipherId);
+        return new Cipher(new CipherData(response));
+    }
+
+    protected saveCipherAttachment(file: File) {
+        return this.cipherService.saveAttachmentWithServer(this.cipherDomain, file, this.organization.isAdmin);
+    }
+
+    protected deleteCipherAttachment(attachmentId: string) {
+        if (!this.organization.isAdmin) {
+            return super.deleteCipherAttachment(attachmentId);
+        }
+        return this.apiService.deleteCipherAttachmentAdmin(this.cipherId, attachmentId);
+    }
+}

src/app/organizations/vault/ciphers.component.ts

@@ -0,0 +1,67 @@
+import { Component } from '@angular/core';
+
+import { ToasterService } from 'angular2-toaster';
+import { Angulartics2 } from 'angulartics2';
+
+import { ApiService } from 'jslib/abstractions/api.service';
+import { CipherService } from 'jslib/abstractions/cipher.service';
+import { I18nService } from 'jslib/abstractions/i18n.service';
+import { PlatformUtilsService } from 'jslib/abstractions/platformUtils.service';
+
+import { CipherData } from 'jslib/models/data/cipherData';
+import { Cipher } from 'jslib/models/domain/cipher';
+import { Organization } from 'jslib/models/domain/organization';
+import { CipherView } from 'jslib/models/view/cipherView';
+
+import { CiphersComponent as BaseCiphersComponent } from '../../vault/ciphers.component';
+
+@Component({
+    selector: 'app-org-vault-ciphers',
+    templateUrl: '../../vault/ciphers.component.html',
+})
+export class CiphersComponent extends BaseCiphersComponent {
+    organization: Organization;
+
+    constructor(cipherService: CipherService, analytics: Angulartics2,
+        toasterService: ToasterService, i18nService: I18nService,
+        platformUtilsService: PlatformUtilsService, private apiService: ApiService) {
+        super(cipherService, analytics, toasterService, i18nService, platformUtilsService);
+    }
+
+    async load(filter: (cipher: CipherView) => boolean = null) {
+        if (!this.organization.isAdmin) {
+            await super.load();
+            return;
+        }
+        const ciphers = await this.apiService.getCiphersOrganization(this.organization.id);
+        if (ciphers != null && ciphers.data != null && ciphers.data.length) {
+            const decCiphers: CipherView[] = [];
+            const promises: any[] = [];
+            ciphers.data.forEach((r) => {
+                const data = new CipherData(r);
+                const cipher = new Cipher(data);
+                promises.push(cipher.decrypt().then((c) => decCiphers.push(c)));
+            });
+            await Promise.all(promises);
+            decCiphers.sort(this.cipherService.getLocaleSortingFunction());
+            this.allCiphers = decCiphers;
+        } else {
+            this.allCiphers = [];
+        }
+        this.applyFilter(filter);
+        this.loaded = true;
+    }
+
+    applyFilter(filter: (cipher: CipherView) => boolean = null) {
+        if (this.organization.isAdmin) {
+            super.applyFilter(filter);
+        } else {
+            const f = (c: CipherView) => c.organizationId === this.organization.id && (filter == null || filter(c));
+            super.applyFilter(f);
+        }
+    }
+
+    checkCipher(c: CipherView) {
+        // do nothing
+    }
+}

src/app/organizations/vault/collections.component.ts

@@ -0,0 +1,57 @@
+import { Component } from '@angular/core';
+
+import { ToasterService } from 'angular2-toaster';
+import { Angulartics2 } from 'angulartics2';
+
+import { ApiService } from 'jslib/abstractions/api.service';
+import { CipherService } from 'jslib/abstractions/cipher.service';
+import { CollectionService } from 'jslib/abstractions/collection.service';
+import { I18nService } from 'jslib/abstractions/i18n.service';
+
+import { CipherData } from 'jslib/models/data/cipherData';
+import { Cipher } from 'jslib/models/domain/cipher';
+import { Organization } from 'jslib/models/domain/organization';
+import { CipherCollectionsRequest } from 'jslib/models/request/cipherCollectionsRequest';
+
+import { CollectionsComponent as BaseCollectionsComponent } from '../../vault/collections.component';
+
+@Component({
+    selector: 'app-org-vault-collections',
+    templateUrl: '../../vault/collections.component.html',
+})
+export class CollectionsComponent extends BaseCollectionsComponent {
+    organization: Organization;
+
+    constructor(collectionService: CollectionService, analytics: Angulartics2,
+        toasterService: ToasterService, i18nService: I18nService,
+        cipherService: CipherService, private apiService: ApiService) {
+        super(collectionService, analytics, toasterService, i18nService, cipherService);
+    }
+
+    protected async loadCipher() {
+        if (!this.organization.isAdmin) {
+            return await super.loadCipher();
+        }
+        const response = await this.apiService.getCipherAdmin(this.cipherId);
+        return new Cipher(new CipherData(response));
+    }
+
+    protected loadCipherCollections() {
+        if (!this.organization.isAdmin) {
+            return super.loadCipherCollections();
+        }
+        return this.collectionIds;
+    }
+
+    protected loadCollections() {
+        if (!this.organization.isAdmin) {
+            return super.loadCollections();
+        }
+        return Promise.resolve(this.collections);
+    }
+
+    protected saveCollections() {
+        const request = new CipherCollectionsRequest(this.cipherDomain.collectionIds);
+        return this.apiService.putCipherCollectionsAdmin(this.cipherId, request);
+    }
+}

src/app/organizations/vault/groupings.component.ts

@@ -0,0 +1,55 @@
+import { Component } from '@angular/core';
+
+import { ApiService } from 'jslib/abstractions/api.service';
+import { CollectionService } from 'jslib/abstractions/collection.service';
+import { FolderService } from 'jslib/abstractions/folder.service';
+import { I18nService } from 'jslib/abstractions/i18n.service';
+
+import { CollectionData } from 'jslib/models/data/collectionData';
+import { Collection } from 'jslib/models/domain/collection';
+import { Organization } from 'jslib/models/domain/organization';
+import { CollectionView } from 'jslib/models/view/collectionView';
+
+import { GroupingsComponent as BaseGroupingsComponent } from '../../vault/groupings.component';
+
+@Component({
+    selector: 'app-org-vault-groupings',
+    templateUrl: '../../vault/groupings.component.html',
+})
+export class GroupingsComponent extends BaseGroupingsComponent {
+    organization: Organization;
+
+    constructor(collectionService: CollectionService, folderService: FolderService,
+        private apiService: ApiService, private i18nService: I18nService) {
+        super(collectionService, folderService);
+    }
+
+    async loadCollections() {
+        if (!this.organization.isAdmin) {
+            await super.loadCollections(this.organization.id);
+            return;
+        }
+        const collections = await this.apiService.getCollections(this.organization.id);
+        if (collections != null && collections.data != null && collections.data.length) {
+            const decCollections: CollectionView[] = [];
+            const promises: any[] = [];
+            collections.data.forEach((r) => {
+                const data = new CollectionData(r);
+                const collection = new Collection(data);
+                promises.push(collection.decrypt().then((c) => decCollections.push(c)));
+            });
+            await Promise.all(promises);
+            decCollections.sort(this.collectionService.getLocaleSortingFunction());
+            this.collections = decCollections;
+        } else {
+            this.collections = [];
+        }
+
+        const unassignedCollection = new CollectionView();
+        unassignedCollection.name = this.i18nService.t('unassigned');
+        unassignedCollection.id = 'unassigned';
+        unassignedCollection.organizationId = this.organization.id;
+        unassignedCollection.readOnly = true;
+        this.collections.push(unassignedCollection);
+    }
+}

src/app/organizations/vault/vault.component.html

@@ -0,0 +1,23 @@
+<div class="container page-content">
+    <div class="row">
+        <div class="col-3">
+            <app-org-vault-groupings [showFolders]="false" [showFavorites]="false" (onAllClicked)="clearGroupingFilters()" (onCipherTypeClicked)="filterCipherType($event)"
+                (onCollectionClicked)="filterCollection($event.id)" (onSearchTextChanged)="filterSearchText($event)">
+            </app-org-vault-groupings>
+        </div>
+        <div class="col-9">
+            <div class="page-header d-flex">
+                <h1>{{'vault' | i18n}}</h1>
+                <button type="button" class="btn btn-primary btn-sm ml-auto" (click)="addCipher()" appBlurClick>
+                    <i class="fa fa-plus fa-fw"></i>{{'addItem' | i18n}}
+                </button>
+            </div>
+            <app-org-vault-ciphers (onCipherClicked)="editCipher($event)" (onAttachmentsClicked)="editCipherAttachments($event)" (onAddCipher)="addCipher()"
+                (onCollectionsClicked)="editCipherCollections($event)">
+            </app-org-vault-ciphers>
+        </div>
+    </div>
+</div>
+<ng-template #attachments></ng-template>
+<ng-template #cipherAddEdit></ng-template>
+<ng-template #collections></ng-template>

src/app/organizations/vault/vault.component.ts

@@ -0,0 +1,230 @@
+import { Location } from '@angular/common';
+import {
+    Component,
+    ComponentFactoryResolver,
+    OnInit,
+    ViewChild,
+    ViewContainerRef,
+} from '@angular/core';
+import {
+    ActivatedRoute,
+    Router,
+} from '@angular/router';
+
+import { I18nService } from 'jslib/abstractions/i18n.service';
+import { SyncService } from 'jslib/abstractions/sync.service';
+import { UserService } from 'jslib/abstractions/user.service';
+
+import { Organization } from 'jslib/models/domain/organization';
+import { CipherView } from 'jslib/models/view/cipherView';
+
+import { CipherType } from 'jslib/enums/cipherType';
+
+import { ModalComponent } from '../../modal.component';
+
+import { AddEditComponent } from './add-edit.component';
+import { AttachmentsComponent } from './attachments.component';
+import { CiphersComponent } from './ciphers.component';
+import { CollectionsComponent } from './collections.component';
+import { GroupingsComponent } from './groupings.component';
+
+@Component({
+    selector: 'app-org-vault',
+    templateUrl: 'vault.component.html',
+})
+export class VaultComponent implements OnInit {
+    @ViewChild(GroupingsComponent) groupingsComponent: GroupingsComponent;
+    @ViewChild(CiphersComponent) ciphersComponent: CiphersComponent;
+    @ViewChild('attachments', { read: ViewContainerRef }) attachmentsModalRef: ViewContainerRef;
+    @ViewChild('cipherAddEdit', { read: ViewContainerRef }) cipherAddEditModalRef: ViewContainerRef;
+    @ViewChild('collections', { read: ViewContainerRef }) collectionsModalRef: ViewContainerRef;
+
+    organization: Organization;
+    collectionId: string;
+    type: CipherType;
+
+    private modal: ModalComponent = null;
+
+    constructor(private route: ActivatedRoute, private userService: UserService,
+        private location: Location, private router: Router,
+        private syncService: SyncService, private i18nService: I18nService,
+        private componentFactoryResolver: ComponentFactoryResolver) { }
+
+    ngOnInit() {
+        this.route.parent.params.subscribe(async (params) => {
+            this.organization = await this.userService.getOrganization(params.organizationId);
+            this.groupingsComponent.organization = this.organization;
+            this.ciphersComponent.organization = this.organization;
+
+            this.route.queryParams.subscribe(async (qParams) => {
+                if (!this.organization.isAdmin) {
+                    await this.syncService.fullSync(false);
+                }
+                await this.groupingsComponent.load();
+
+                if (qParams == null) {
+                    this.groupingsComponent.selectedAll = true;
+                    await this.ciphersComponent.load();
+                    return;
+                }
+
+                if (qParams.type) {
+                    const t = parseInt(qParams.type, null);
+                    this.groupingsComponent.selectedType = t;
+                    await this.filterCipherType(t, true);
+                } else if (qParams.collectionId) {
+                    this.groupingsComponent.selectedCollectionId = qParams.collectionId;
+                    await this.filterCollection(qParams.collectionId, true);
+                } else {
+                    this.groupingsComponent.selectedAll = true;
+                    await this.ciphersComponent.load();
+                }
+            });
+        });
+    }
+
+    async clearGroupingFilters() {
+        this.ciphersComponent.showAddNew = true;
+        this.groupingsComponent.searchPlaceholder = this.i18nService.t('searchVault');
+        await this.ciphersComponent.applyFilter();
+        this.clearFilters();
+        this.go();
+    }
+
+    async filterCipherType(type: CipherType, load = false) {
+        this.ciphersComponent.showAddNew = true;
+        this.groupingsComponent.searchPlaceholder = this.i18nService.t('searchType');
+        const filter = (c: CipherView) => c.type === type;
+        if (load) {
+            await this.ciphersComponent.load(filter);
+        } else {
+            await this.ciphersComponent.applyFilter(filter);
+        }
+        this.clearFilters();
+        this.type = type;
+        this.go();
+    }
+
+    async filterCollection(collectionId: string, load = false) {
+        this.ciphersComponent.showAddNew = false;
+        this.groupingsComponent.searchPlaceholder = this.i18nService.t('searchCollection');
+        const filter = (c: CipherView) => {
+            if (collectionId === 'unassigned') {
+                return c.collectionIds == null || c.collectionIds.length === 0;
+            } else {
+                return c.collectionIds.indexOf(collectionId) > -1;
+            }
+        };
+        if (load) {
+            await this.ciphersComponent.load(filter);
+        } else {
+            await this.ciphersComponent.applyFilter(filter);
+        }
+        this.clearFilters();
+        this.collectionId = collectionId;
+        this.go();
+    }
+
+    filterSearchText(searchText: string) {
+        this.ciphersComponent.searchText = searchText;
+    }
+
+    editCipherAttachments(cipher: CipherView) {
+        if (this.modal != null) {
+            this.modal.close();
+        }
+
+        const factory = this.componentFactoryResolver.resolveComponentFactory(ModalComponent);
+        this.modal = this.attachmentsModalRef.createComponent(factory).instance;
+        const childComponent = this.modal.show<AttachmentsComponent>(AttachmentsComponent, this.attachmentsModalRef);
+
+        childComponent.organization = this.organization;
+        childComponent.cipherId = cipher.id;
+        let madeAttachmentChanges = false;
+        childComponent.onUploadedAttachment.subscribe(() => madeAttachmentChanges = true);
+        childComponent.onDeletedAttachment.subscribe(() => madeAttachmentChanges = true);
+
+        this.modal.onClosed.subscribe(async () => {
+            this.modal = null;
+            if (madeAttachmentChanges) {
+                await this.ciphersComponent.refresh();
+            }
+            madeAttachmentChanges = false;
+        });
+    }
+
+    editCipherCollections(cipher: CipherView) {
+        if (this.modal != null) {
+            this.modal.close();
+        }
+
+        const factory = this.componentFactoryResolver.resolveComponentFactory(ModalComponent);
+        this.modal = this.collectionsModalRef.createComponent(factory).instance;
+        const childComponent = this.modal.show<CollectionsComponent>(CollectionsComponent, this.collectionsModalRef);
+
+        if (this.organization.isAdmin) {
+            childComponent.collectionIds = cipher.collectionIds;
+            childComponent.collections = this.groupingsComponent.collections.filter((c) => !c.readOnly);
+        }
+        childComponent.organization = this.organization;
+        childComponent.cipherId = cipher.id;
+        childComponent.onSavedCollections.subscribe(async () => {
+            this.modal.close();
+            await this.ciphersComponent.refresh();
+        });
+
+        this.modal.onClosed.subscribe(async () => {
+            this.modal = null;
+        });
+    }
+
+    addCipher() {
+        const component = this.editCipher(null);
+        component.type = this.type;
+    }
+
+    editCipher(cipher: CipherView) {
+        if (this.modal != null) {
+            this.modal.close();
+        }
+
+        const factory = this.componentFactoryResolver.resolveComponentFactory(ModalComponent);
+        this.modal = this.cipherAddEditModalRef.createComponent(factory).instance;
+        const childComponent = this.modal.show<AddEditComponent>(AddEditComponent, this.cipherAddEditModalRef);
+
+        childComponent.organization = this.organization;
+        childComponent.cipherId = cipher == null ? null : cipher.id;
+        childComponent.onSavedCipher.subscribe(async (c: CipherView) => {
+            this.modal.close();
+            await this.ciphersComponent.refresh();
+        });
+        childComponent.onDeletedCipher.subscribe(async (c: CipherView) => {
+            this.modal.close();
+            await this.ciphersComponent.refresh();
+        });
+
+        this.modal.onClosed.subscribe(() => {
+            this.modal = null;
+        });
+
+        return childComponent;
+    }
+
+    private clearFilters() {
+        this.collectionId = null;
+        this.type = null;
+    }
+
+    private go(queryParams: any = null) {
+        if (queryParams == null) {
+            queryParams = {
+                type: this.type,
+                collectionId: this.collectionId,
+            };
+        }
+
+        const url = this.router.createUrlTree(['organizations', this.organization.id, 'vault'],
+            { queryParams: queryParams }).toString();
+        this.location.go(url);
+    }
+}