gr-archiver.js

import angular from 'angular';
import {Set} from 'immutable';

import './gr-archiver.css';
import template from './gr-archiver.html';

import '../../services/archive';
import '../../services/image-accessor';
import '../../util/string';
import {getDeletedState} from "../../util/get-deleted-state";


export const module = angular.module('gr.archiver', [
    'kahuna.services.archive',
    'kahuna.services.image-accessor',
    'kahuna.services.image-logic',
    'util.string',
    getDeletedState.name
]);

module.controller('grArchiverCtrl', [
    '$scope',
    '$window',
    'archiveService',
    'imageAccessor',
    'imageLogic',
    'humanJoin',
    'mediaApi',
    'getDeletedState',
    'apiPoll',
    function ($scope,
              $window,
              archiveService,
              imageAccessor,
              imageLogic,
              humanJoin,
              mediaApi,
              getDeletedState,
              apiPoll) {

        const ctrl = this;

        ctrl.archivedState = 'unarchived';
        ctrl.archiving = false;
        ctrl.canArchive = false;

        ctrl.canUndelete = false;
        ctrl.isDeleted = false;
        ctrl.undeleting = false;

        ctrl.undelete = undelete;

        ctrl.$onInit = () => {
          getDeletedState(ctrl);
        };

        mediaApi.canUserArchive().then(canArchive => {
            ctrl.canArchive = canArchive;
        });

        $scope.$watchCollection(getImageArray, (images) => {
            const noneCanBeArchived = ! images.some(imageLogic.canBeArchived);
            const allPersisted = images.every(imageAccessor.isPersisted);
            ctrl.archivedState = noneCanBeArchived ? 'kept' :
                allPersisted ? 'archived' : 'unarchived';

            const explTokens = listAllPersistenceExplanations(images);
            let explanation, reason;
            if (images.length === 1) {
                reason = humanJoin(explTokens, 'and');
                explanation = `Kept in Library because the image has been ${reason}.`;
            } else {
                reason = humanJoin(explTokens, 'or');
                explanation = `Kept in Library because the images have been ${reason}.`;
            }
            ctrl.archivedExplanation = explanation;
        });

        ctrl.archive = () => {
            ctrl.archiving = true;
            archiveService.batchArchive(getImageArray())
                .catch(() => {
                    $window.alert('Failed to add to Library, please try again.');
                })
                .finally(() => {
                    ctrl.archiving = false;
                });
        };

        ctrl.unarchive = () => {
            ctrl.archiving = true;
            archiveService.batchUnarchive(getImageArray())
                .catch(() => {
                    $window.alert('Failed to remove from Library, please try again.');
                })
                .finally(() => {
                    ctrl.archiving = false;
                });
        };

        function getImageArray() {
            if (ctrl.images && ! ctrl.image) {
                // Convert from Immutable Set to JS Array
                return Array.from(ctrl.images);
            } else if (! ctrl.images && ctrl.image) {
                return [ctrl.image];
            } else {
                throw new Error('Either gr:images or gr:image should be provided ' +
                                'to gr-archiver directive');
            }
        }

        function listAllPersistenceExplanations(images) {
            return images.
                map(imageLogic.getPersistenceExplanation).
                map(items => new Set(items)).
                reduce((all, items) => all.union(items)).
                toArray();
        }

        function pollUndeleted(imageId) {
          const findImage = () => mediaApi.find(imageId).then(
            (i) => i.data?.softDeletedMetadata === undefined && i.data.userMetadata?.data?.archived
              ? Promise.resolve()
              : Promise.reject()
          );
          return apiPoll(findImage);
        }
        function undelete() {
            ctrl.undeleting = true;
            const imageId = ctrl.image.data.id;
            mediaApi.undelete(imageId)
                .then(() => pollUndeleted(imageId))
                .then(() => {
                    ctrl.canUndelete = false;
                    ctrl.isDeleted = false;
                    ctrl.image.softDeletedMetadata = undefined;
                    if (ctrl.image.userMetadata?.data !== undefined) {
                        ctrl.image.userMetadata.data.archived = true;
                    }
                    $scope.$emit('images-updated', [ctrl.image]);
                }).catch((e) => {
                     $window.alert('Failed to undelete image!, please try again.');
                     console.error('Image undeletion failed', e);
                }).finally(() => {
                     ctrl.undeleting = false;
                });
        }
    }
]);

module.directive('grArchiver', [function () {
    return {
        restrict: 'E',
        template: template,
        scope: {
            // Either is allowed, not both
            image: '=grImage',
            images: '=grImages'
        },
        controller: 'grArchiverCtrl',
        controllerAs: 'ctrl',
        bindToController: true
    };
}]);