openproject/frontend/app/work_packages/controllers/work-package-details-controller.js

//-- copyright
// OpenProject is a project management system.
// Copyright (C) 2012-2015 the OpenProject Foundation (OPF)
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License version 3.
//
// OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows:
// Copyright (C) 2006-2013 Jean-Philippe Lang
// Copyright (C) 2010-2013 the ChiliProject Team
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
//
// See doc/COPYRIGHT.rdoc for more details.
//++

module.exports = function($scope,
    $state,
    latestTab,
    workPackage,
    I18n,
    RELATION_TYPES,
    RELATION_IDENTIFIERS,
    $q,
    $rootScope,
    $filter,
    WorkPackagesHelper,
    PathHelper,
    UsersHelper,
    ConfigurationService,
    WorkPackageService,
    ActivityService,
    CommonRelationsHandler,
    ChildrenRelationsHandler,
    ParentRelationsHandler,
    NotificationsService
  ) {
  $scope.$on('$stateChangeSuccess', function(event, toState){
    latestTab.registerState(toState.name);
  });

  $rootScope.$on('workPackageRefreshRequired', function(e, callback) {
    refreshWorkPackage(callback);
  });

  // initialization
  setWorkPackageScopeProperties(workPackage);

  $scope.I18n = I18n;
  WorkPackageService.cache().put('preselectedWorkPackageId', $scope.workPackage.props.id);
  $scope.maxDescriptionLength = 800;

  function refreshWorkPackage(callback) {
    WorkPackageService.getWorkPackage($scope.workPackage.props.id)
      .then(function(workPackage) {
        setWorkPackageScopeProperties(workPackage);
        $scope.$broadcast('workPackageRefreshed');
        if (callback) {
          callback(workPackage);
        }
      });
  }
  // Inform parent that work package is loaded so back url can be maintained
  $scope.$emit('workPackgeLoaded');

  function outputMessage(message, isError) {
    if (!!isError) {
      NotificationsService.addError(message);
    }
    else {
      NotificationsService.addSuccess(message);
    }
  }

  function outputError(error) {
    outputMessage(error.message || I18n.t('js.work_packages.error'), true);
  }

  $scope.outputMessage = outputMessage; // expose to child controllers
  $scope.outputError = outputError; // expose to child controllers

  function setWorkPackageScopeProperties(workPackage){
    $scope.workPackage = workPackage;
    $scope.isWatched = !!workPackage.links.unwatch;

    // autocomplete path
    var projectId = workPackage.embedded.project.props.id;
    $scope.autocompletePath = PathHelper.staticWorkPackagesAutocompletePath(projectId);

    // activities and latest activities
    $scope.activitiesSortedInDescendingOrder = ConfigurationService.commentsSortedInDescendingOrder();
    $scope.activities = [];
    aggregateActivities($scope.workPackage);

    // watchers
    if(workPackage.links.watchers) {
      $scope.watchers = workPackage.embedded.watchers.embedded.elements;
    }

    $scope.showStaticPagePath = PathHelper.staticWorkPackagePath($scope.workPackage.props.id);

    // Type
    $scope.type = workPackage.embedded.type;

    // Author
    $scope.author = workPackage.embedded.author;
    $scope.authorPath = PathHelper.staticUserPath($scope.author.props.id);
    $scope.authorActive = UsersHelper.isActive($scope.author);

    // Attachments
    $scope.attachments = workPackage.embedded.attachments.embedded.elements;

    // relations
    $q.all(WorkPackagesHelper.getParent(workPackage)).then(function(parents) {
      var relationsHandler = new ParentRelationsHandler(workPackage, parents, 'parent');
      $scope.wpParent = relationsHandler;
    });

    $q.all(WorkPackagesHelper.getChildren(workPackage)).then(function(children) {
      var relationsHandler = new ChildrenRelationsHandler(workPackage, children);
      $scope.wpChildren = relationsHandler;
    });

    function relationTypeIterator(key) {
      $q.all(WorkPackagesHelper.getRelationsOfType(
        workPackage,
        RELATION_TYPES[key])
      ).then(function(relations) {
        var relationsHandler = new CommonRelationsHandler(workPackage,
                                                          relations,
                                                          RELATION_IDENTIFIERS[key]);
        $scope[key] = relationsHandler;
      });
    }

    for (var key in RELATION_TYPES) {
      if (RELATION_TYPES.hasOwnProperty(key)) {
        relationTypeIterator(key);
      }
    }
  }

  $scope.toggleWatch = function() {
    // Toggle early to avoid delay.
    $scope.isWatched = !$scope.isWatched;
    WorkPackageService.toggleWatch($scope.workPackage)
                      .then(function() { refreshWorkPackage() }, outputError);
  };

  $scope.canViewWorkPackageWatchers = function() {
    return !!($scope.workPackage && $scope.workPackage.embedded.watchers !== undefined);
  };

  $scope.isInitialActivity = ActivityService.isInitialActivity;

  function aggregateActivities(workPackage) {
    // Do not yet add any intermittent result to the scope,
    // as we will get an inconsistent activity view
    // As we may not what activities will be added at a given time,
    // let them be aggregated asynchronously.
    var aggregated = [],
      totalActivities = 0;

    var aggregate = function(success, activity) {

      if (success === true) {
        aggregated = aggregated.concat(activity);
      }

      if (++totalActivities === 2) {
        $scope.activities = $filter('orderBy')(aggregated,
          'props.createdAt',
          $scope.activitiesSortedInDescendingOrder
        );
      }
    };

    addDisplayedActivities(workPackage, aggregate);
    addDisplayedRevisions(workPackage, aggregate);
  }

  function addDisplayedActivities(workPackage, aggregate) {
    var activities = workPackage.embedded.activities.embedded.elements;
    aggregate(true, activities);
  }

  function addDisplayedRevisions(workPackage, aggregate) {
    var linkedRevisions = workPackage.links.revisions;

    if (linkedRevisions === undefined) {
      return aggregate();
    }

    linkedRevisions
      .fetch()
      .then(function(data) {
        aggregate(true, data.embedded.elements);
      }, aggregate);
  }

  // toggles

  $scope.toggleStates = {
    hideFullDescription: true,
    hideAllAttributes: true
  };

  function getFocusAnchorLabel(tab, workPackage) {
    var tabLabel = I18n.t('js.work_packages.tabs.' + tab),
        params = {
          tab: tabLabel,
          type: workPackage.props.type,
          subject: workPackage.props.subject
        };

    return I18n.t('js.label_work_package_details_you_are_here', params);
  }

  $scope.focusAnchorLabel = getFocusAnchorLabel(
    $state.current.url.replace(/\//, ''),
    $scope.workPackage
  );
};