ang/crmCaseType.js

   1 (function(angular, $, _) {
   2
   3   var crmCaseType = angular.module('crmCaseType', CRM.angRequires('crmCaseType'));
   4
   5   // Note: This template will be passed to cloneDeep(), so don't put any funny stuff in here!
   6   var newCaseTypeTemplate = {
   7     title: "",
   8     name: "",
   9     is_active: "1",
  10     weight: "1",
  11     definition: {
  12       activityTypes: [
  13         {name: 'Open Case', max_instances: 1},
  14         {name: 'Email'},
  15         {name: 'Follow up'},
  16         {name: 'Meeting'},
  17         {name: 'Phone Call'}
  18       ],
  19       activitySets: [
  20         {
  21           name: 'standard_timeline',
  22           label: 'Standard Timeline',
  23           timeline: '1', // Angular won't bind checkbox correctly with numeric 1
  24           activityTypes: [
  25             {name: 'Open Case', status: 'Completed' }
  26           ]
  27         }
  28       ],
  29       caseRoles: [
  30         { name: 'Case Coordinator', creator: '1', manager: '1'}
  31       ]
  32     }
  33   };
  34
  35   crmCaseType.config(['$routeProvider',
  36     function($routeProvider) {
  37       $routeProvider.when('/caseType', {
  38         templateUrl: '~/crmCaseType/list.html',
  39         controller: 'CaseTypeListCtrl',
  40         resolve: {
  41           caseTypes: function($route, crmApi) {
  42             return crmApi('CaseType', 'get', {options: {limit: 0}});
  43           }
  44         }
  45       });
  46       $routeProvider.when('/caseType/:id', {
  47         templateUrl: '~/crmCaseType/edit.html',
  48         controller: 'CaseTypeCtrl',
  49         resolve: {
  50           apiCalls: function($route, crmApi) {
  51             var reqs = {};
  52             reqs.actStatuses = ['OptionValue', 'get', {
  53               option_group_id: 'activity_status',
  54               sequential: 1,
  55               options: {limit: 0}
  56             }];
  57             reqs.caseStatuses = ['OptionValue', 'get', {
  58               option_group_id: 'case_status',
  59               sequential: 1,
  60               options: {
  61                 sort: 'weight',
  62                 limit: 0
  63               }
  64             }];
  65             reqs.actTypes = ['OptionValue', 'get', {
  66               option_group_id: 'activity_type',
  67               sequential: 1,
  68               options: {
  69                 sort: 'name',
  70                 limit: 0
  71               }
  72             }];
  73             reqs.defaultAssigneeTypes = ['OptionValue', 'get', {
  74               option_group_id: 'activity_default_assignee',
  75               sequential: 1,
  76               options: {
  77                 limit: 0
  78               }
  79             }];
  80             reqs.relTypes = ['RelationshipType', 'get', {
  81               sequential: 1,
  82               is_active: 1,
  83               options: {
  84                 sort: 'label_a_b',
  85                 limit: 0
  86               }
  87             }];
  88             if ($route.current.params.id !== 'new') {
  89               reqs.caseType = ['CaseType', 'getsingle', {
  90                 id: $route.current.params.id
  91               }];
  92             }
  93             return crmApi(reqs);
  94           }
  95         }
  96       });
  97     }
  98   ]);
  99
 100   // Add a new record by name.
 101   // Ex: <crmAddName crm-options="['Alpha','Beta','Gamma']" crm-var="newItem" crm-on-add="callMyCreateFunction(newItem)" />
 102   crmCaseType.directive('crmAddName', function() {
 103     return {
 104       restrict: 'AE',
 105       template: '<input class="add-activity crm-action-menu fa-plus" type="hidden" />',
 106       link: function(scope, element, attrs) {
 107
 108         var input = $('input', element);
 109
 110         scope._resetSelection = function() {
 111           $(input).select2('close');
 112           $(input).select2('val', '');
 113           scope[attrs.crmVar] = '';
 114         };
 115
 116         $(input).crmSelect2({
 117           data: function () {
 118             return { results: scope[attrs.crmOptions] };
 119           },
 120           createSearchChoice: function(term) {
 121             return {id: term, text: term + ' (' + ts('new') + ')'};
 122           },
 123           createSearchChoicePosition: 'bottom',
 124           placeholder: attrs.placeholder
 125         });
 126         $(input).on('select2-selecting', function(e) {
 127           scope[attrs.crmVar] = e.val;
 128           scope.$evalAsync(attrs.crmOnAdd);
 129           scope.$evalAsync('_resetSelection()');
 130           e.preventDefault();
 131         });
 132       }
 133     };
 134   });
 135
 136   crmCaseType.directive('crmEditableTabTitle', function($timeout) {
 137     return {
 138       restrict: 'AE',
 139       link: function(scope, element, attrs) {
 140         element.addClass('crm-editable crm-editable-enabled');
 141         var titleLabel = $(element).find('span');
 142         var penIcon = $('<i class="crm-i fa-pencil crm-editable-placeholder"></i>').prependTo(element);
 143         var saveButton = $('<button type="button"><i class="crm-i fa-check"></i></button>').appendTo(element);
 144         var cancelButton = $('<button type="cancel"><i class="crm-i fa-times"></i></button>').appendTo(element);
 145         $('button', element).wrapAll('<div class="crm-editable-form" style="display:none" />');
 146         var buttons = $('.crm-editable-form', element);
 147         titleLabel.on('click', startEditMode);
 148         penIcon.on('click', startEditMode);
 149
 150         function detectEscapeKeyPress (event) {
 151           var isEscape = false;
 152
 153           if ("key" in event) {
 154               isEscape = (event.key == "Escape" || event.key == "Esc");
 155           } else {
 156               isEscape = (event.keyCode == 27);
 157           }
 158
 159           return isEscape;
 160         }
 161
 162         function detectEnterKeyPress (event) {
 163           var isEnter = false;
 164
 165           if ("key" in event) {
 166             isEnter = (event.key == "Enter");
 167           } else {
 168             isEnter = (event.keyCode == 13);
 169           }
 170
 171           return isEnter;
 172         }
 173
 174         function startEditMode () {
 175           if (titleLabel.is(":focus")) {
 176             return;
 177           }
 178
 179           penIcon.hide();
 180           buttons.show();
 181
 182           saveButton.click(function () {
 183             updateTextValue();
 184             stopEditMode();
 185           });
 186
 187           cancelButton.click(function () {
 188             revertTextValue();
 189             stopEditMode();
 190           });
 191
 192           $(element).addClass('crm-editable-editing');
 193
 194           titleLabel
 195             .attr("contenteditable", "true")
 196             .focus()
 197             .focusout(function (event) {
 198               $timeout(function () {
 199                 revertTextValue();
 200                 stopEditMode();
 201               }, 500);
 202             })
 203             .keydown(function(event) {
 204               event.stopImmediatePropagation();
 205
 206               if(detectEscapeKeyPress(event)) {
 207                 revertTextValue();
 208                 stopEditMode();
 209               } else if(detectEnterKeyPress(event)) {
 210                 event.preventDefault();
 211                 updateTextValue();
 212                 stopEditMode();
 213               }
 214             });
 215         }
 216
 217         function stopEditMode () {
 218           titleLabel.removeAttr("contenteditable").off("focusout");
 219           titleLabel.off("keydown");
 220           saveButton.off("click");
 221           cancelButton.off("click");
 222           $(element).removeClass('crm-editable-editing');
 223
 224           penIcon.show();
 225           buttons.hide();
 226         }
 227
 228         function revertTextValue () {
 229           titleLabel.text(scope.activitySet.label);
 230         }
 231
 232         function updateTextValue () {
 233           var updatedTitle = titleLabel.text();
 234
 235           scope.$evalAsync(function () {
 236             scope.activitySet.label = updatedTitle;
 237           });
 238         }
 239       }
 240     };
 241   });
 242
 243   crmCaseType.controller('CaseTypeCtrl', function($scope, crmApi, apiCalls, crmUiHelp) {
 244     var defaultAssigneeDefaultValue, ts;
 245
 246     (function init () {
 247
 248       ts = $scope.ts = CRM.ts(null);
 249       $scope.hs = crmUiHelp({file: 'CRM/Case/CaseType'});
 250       $scope.locks = { caseTypeName: true, activitySetName: true };
 251       $scope.workflows = { timeline: 'Timeline', sequence: 'Sequence' };
 252       defaultAssigneeDefaultValue = _.find(apiCalls.defaultAssigneeTypes.values, { is_default: '1' }) || {};
 253
 254       storeApiCallsResults();
 255       initCaseType();
 256       initCaseTypeDefinition();
 257       initSelectedStatuses();
 258     })();
 259
 260     /// Stores the api calls results in the $scope object
 261     function storeApiCallsResults() {
 262       $scope.activityStatuses = apiCalls.actStatuses.values;
 263       $scope.caseStatuses = _.indexBy(apiCalls.caseStatuses.values, 'name');
 264       $scope.activityTypes = _.indexBy(apiCalls.actTypes.values, 'name');
 265       $scope.activityTypeOptions = _.map(apiCalls.actTypes.values, formatActivityTypeOption);
 266       $scope.defaultAssigneeTypes = apiCalls.defaultAssigneeTypes.values;
 267       $scope.relationshipTypeOptions = getRelationshipTypeOptions(false);
 268       $scope.defaultRelationshipTypeOptions = getRelationshipTypeOptions(true);
 269       // stores the default assignee values indexed by their option name:
 270       $scope.defaultAssigneeTypeValues = _.chain($scope.defaultAssigneeTypes)
 271         .indexBy('name').mapValues('value').value();
 272     }
 273
 274     // Returns the relationship type options. If the relationship is
 275     // bidirectional (Ex: Spouse of) it adds a single option otherwise it adds
 276     // two options representing the relationship type directions (Ex: Employee
 277     // of, Employer of).
 278     //
 279     // The default relationship field needs values that are IDs with direction,
 280     // while the role field needs values that are names (with implicit
 281     // direction).
 282     //
 283     // At any rate, the labels should follow the convention in the UI of
 284     // describing case roles from the perspective of the client, while the
 285     // values must follow the convention in the XML of describing case roles
 286     // from the perspective of the non-client.
 287     function getRelationshipTypeOptions($isDefault) {
 288       return _.transform(apiCalls.relTypes.values, function(result, relType) {
 289         var isBidirectionalRelationship = relType.label_a_b === relType.label_b_a;
 290         if ($isDefault) {
 291           result.push({
 292             label: relType.label_b_a,
 293             value: relType.id + '_a_b'
 294           });
 295
 296           if (!isBidirectionalRelationship) {
 297             result.push({
 298               label: relType.label_a_b,
 299               value: relType.id + '_b_a'
 300             });
 301           }
 302         }
 303         // TODO The ids below really should use names not labels see
 304         //  https://lab.civicrm.org/dev/core/issues/774
 305         else {
 306           result.push({
 307             text: relType.label_b_a,
 308             id: relType.label_a_b
 309           });
 310
 311           if (!isBidirectionalRelationship) {
 312             result.push({
 313               text: relType.label_a_b,
 314               id: relType.label_b_a
 315             });
 316           }
 317         }
 318       }, []);
 319     }
 320
 321     /// initializes the case type object
 322     function initCaseType() {
 323       var isNewCaseType = !apiCalls.caseType;
 324
 325       if (isNewCaseType) {
 326         $scope.caseType = _.cloneDeep(newCaseTypeTemplate);
 327       } else {
 328         $scope.caseType = apiCalls.caseType;
 329       }
 330     }
 331
 332     /// initializes the case type definition object
 333     function initCaseTypeDefinition() {
 334       $scope.caseType.definition = $scope.caseType.definition || [];
 335       $scope.caseType.definition.activityTypes = $scope.caseType.definition.activityTypes || [];
 336       $scope.caseType.definition.activitySets = $scope.caseType.definition.activitySets || [];
 337       $scope.caseType.definition.caseRoles = $scope.caseType.definition.caseRoles || [];
 338       $scope.caseType.definition.statuses = $scope.caseType.definition.statuses || [];
 339       $scope.caseType.definition.timelineActivityTypes = $scope.caseType.definition.timelineActivityTypes || [];
 340       $scope.caseType.definition.restrictActivityAsgmtToCmsUser = $scope.caseType.definition.restrictActivityAsgmtToCmsUser || 0;
 341       $scope.caseType.definition.activityAsgmtGrps = $scope.caseType.definition.activityAsgmtGrps || [];
 342
 343       _.each($scope.caseType.definition.activitySets, function (set) {
 344         _.each(set.activityTypes, function (type, name) {
 345           var isDefaultAssigneeTypeUndefined = _.isUndefined(type.default_assignee_type);
 346           var typeDefinition = $scope.activityTypes[type.name];
 347           type.label = (typeDefinition && typeDefinition.label) || type.name;
 348
 349           if (isDefaultAssigneeTypeUndefined) {
 350             type.default_assignee_type = defaultAssigneeDefaultValue.value;
 351           }
 352         });
 353       });
 354
 355       // go lookup and add client-perspective labels for $scope.caseType.definition.caseRoles
 356       _.each($scope.caseType.definition.caseRoles, function (set) {
 357         _.each($scope.relationshipTypeOptions, function (relTypes) {
 358           if (relTypes.text == set.name) {
 359             set.displaylabel = relTypes.id;
 360           }
 361         });
 362       });
 363     }
 364
 365     /// initializes the selected statuses
 366     function initSelectedStatuses() {
 367       $scope.selectedStatuses = {};
 368
 369       _.each(apiCalls.caseStatuses.values, function (status) {
 370         $scope.selectedStatuses[status.name] = !$scope.caseType.definition.statuses.length || $scope.caseType.definition.statuses.indexOf(status.name) > -1;
 371       });
 372     }
 373
 374     $scope.addActivitySet = function(workflow) {
 375       var activitySet = {};
 376       activitySet[workflow] = '1';
 377       activitySet.activityTypes = [];
 378
 379       var offset = 1;
 380       var names = _.pluck($scope.caseType.definition.activitySets, 'name');
 381       while (_.contains(names, workflow + '_' + offset)) offset++;
 382       activitySet.name = workflow + '_' + offset;
 383       activitySet.label = (offset == 1  ) ? $scope.workflows[workflow] : ($scope.workflows[workflow] + ' #' + offset);
 384
 385       $scope.caseType.definition.activitySets.push(activitySet);
 386       _.defer(function() {
 387         $('.crmCaseType-acttab').tabs('refresh').tabs({active: -1});
 388       });
 389     };
 390
 391     function formatActivityTypeOption(type) {
 392       return {id: type.name, text: type.label, icon: type.icon};
 393     }
 394
 395     function addActivityToSet(activitySet, activityTypeName) {
 396       activitySet.activityTypes = activitySet.activityTypes || [];
 397             var activity = {
 398           name: activityTypeName,
 399           label: $scope.activityTypes[activityTypeName].label,
 400           status: 'Scheduled',
 401           reference_activity: 'Open Case',
 402           reference_offset: '1',
 403           reference_select: 'newest',
 404           default_assignee_type: $scope.defaultAssigneeTypeValues.NONE
 405       };
 406       activitySet.activityTypes.push(activity);
 407       if(typeof activitySet.timeline !== "undefined" && activitySet.timeline == "1") {
 408         $scope.caseType.definition.timelineActivityTypes.push(activity);
 409       }
 410     }
 411
 412     function resetTimelineActivityTypes() {
 413         $scope.caseType.definition.timelineActivityTypes = [];
 414         angular.forEach($scope.caseType.definition.activitySets, function(activitySet) {
 415             angular.forEach(activitySet.activityTypes, function(activityType) {
 416                 $scope.caseType.definition.timelineActivityTypes.push(activityType);
 417             });
 418         });
 419     }
 420
 421     function createActivity(name, callback) {
 422       CRM.loadForm(CRM.url('civicrm/admin/options/activity_type', {action: 'add', reset: 1, label: name, component_id: 7}))
 423         .on('crmFormSuccess', function(e, data) {
 424           $scope.activityTypes[data.optionValue.name] = data.optionValue;
 425           $scope.activityTypeOptions.push(formatActivityTypeOption(data.optionValue));
 426           callback(data.optionValue);
 427           $scope.$digest();
 428         });
 429     }
 430
 431     // Add a new activity entry to an activity-set
 432     $scope.addActivity = function(activitySet, activityType) {
 433       if ($scope.activityTypes[activityType]) {
 434         addActivityToSet(activitySet, activityType);
 435       } else {
 436         createActivity(activityType, function(newActivity) {
 437           addActivityToSet(activitySet, newActivity.name);
 438         });
 439       }
 440     };
 441
 442     /// Add a new top-level activity-type entry
 443     $scope.addActivityType = function(activityType) {
 444       var names = _.pluck($scope.caseType.definition.activityTypes, 'name');
 445       if (!_.contains(names, activityType)) {
 446         // Add an activity type that exists
 447         if ($scope.activityTypes[activityType]) {
 448           $scope.caseType.definition.activityTypes.push({name: activityType});
 449         } else {
 450           createActivity(activityType, function(newActivity) {
 451             $scope.caseType.definition.activityTypes.push({name: newActivity.name});
 452           });
 453         }
 454       }
 455     };
 456
 457     /// Clears the activity's default assignee values for relationship and contact
 458     $scope.clearActivityDefaultAssigneeValues = function(activity) {
 459       activity.default_assignee_relationship = null;
 460       activity.default_assignee_contact = null;
 461     };
 462
 463     // TODO roleName passed to addRole is a misnomer, its passed as the
 464     // label HOWEVER it should be saved to xml as the name see
 465     // https://lab.civicrm.org/dev/core/issues/774
 466
 467     /// Add a new role
 468     $scope.addRole = function(roles, roleName) {
 469       var names = _.pluck($scope.caseType.definition.caseRoles, 'name');
 470       if (!_.contains(names, roleName)) {
 471         var matchingRoles = _.filter($scope.relationshipTypeOptions, {id: roleName});
 472         if (matchingRoles.length) {
 473           var matchingRole = matchingRoles.shift();
 474           roles.push({name: roleName, displaylabel: matchingRole.text});
 475         } else {
 476            CRM.loadForm(CRM.url('civicrm/admin/reltype', {action: 'add', reset: 1, label_a_b: roleName}))
 477             .on('crmFormSuccess', function(e, data) {
 478               var newType = _.values(data.relationshipType)[0];
 479               roles.push({name: newType.label_b_a, displaylabel: newType.label_a_b});
 480               // Assume that the case role should be A-B but add both directions as options.
 481               $scope.relationshipTypeOptions.push({id: newType.label_a_b, text: newType.label_a_b});
 482               if (newType.label_a_b != newType.label_b_a) {
 483                 $scope.relationshipTypeOptions.push({id: newType.label_b_a, text: newType.label_b_a});
 484               }
 485               $scope.$digest();
 486             });
 487         }
 488       }
 489     };
 490
 491     $scope.onManagerChange = function(managerRole) {
 492       angular.forEach($scope.caseType.definition.caseRoles, function(caseRole) {
 493         if (caseRole != managerRole) {
 494           caseRole.manager = '0';
 495         }
 496       });
 497     };
 498
 499     $scope.removeItem = function(array, item) {
 500       var idx = _.indexOf(array, item);
 501       if (idx != -1) {
 502         array.splice(idx, 1);
 503         resetTimelineActivityTypes();
 504       }
 505     };
 506
 507     $scope.isForkable = function() {
 508       return !$scope.caseType.id || $scope.caseType.is_forkable;
 509     };
 510
 511     $scope.newStatus = function() {
 512       CRM.loadForm(CRM.url('civicrm/admin/options/case_status', {action: 'add', reset: 1}))
 513         .on('crmFormSuccess', function(e, data) {
 514           $scope.caseStatuses[data.optionValue.name] = data.optionValue;
 515           $scope.selectedStatuses[data.optionValue.name] = true;
 516           $scope.$digest();
 517         });
 518     };
 519
 520     $scope.isNewActivitySetAllowed = function(workflow) {
 521       switch (workflow) {
 522         case 'timeline':
 523           return true;
 524         case 'sequence':
 525           return 0 === _.where($scope.caseType.definition.activitySets, {sequence: '1'}).length;
 526         default:
 527           CRM.console('warn', 'Denied access to unrecognized workflow: (' + workflow + ')');
 528           return false;
 529       }
 530     };
 531
 532     $scope.isActivityRemovable = function(activitySet, activity) {
 533       return true;
 534     };
 535
 536     $scope.isValidName = function(name) {
 537       return !name || name.match(/^[a-zA-Z0-9_]+$/);
 538     };
 539
 540     $scope.getWorkflowName = function(activitySet) {
 541       var result = 'Unknown';
 542       _.each($scope.workflows, function(value, key) {
 543         if (activitySet[key]) result = value;
 544       });
 545       return result;
 546     };
 547
 548     /**
 549      * Determine which HTML partial to use for a particular
 550      *
 551      * @return string URL of the HTML partial
 552      */
 553     $scope.activityTableTemplate = function(activitySet) {
 554       if (activitySet.timeline) {
 555         return '~/crmCaseType/timelineTable.html';
 556       } else if (activitySet.sequence) {
 557         return '~/crmCaseType/sequenceTable.html';
 558       } else {
 559         return '';
 560       }
 561     };
 562
 563     $scope.dump = function() {
 564       console.log($scope.caseType);
 565     };
 566
 567     $scope.save = function() {
 568       // Add selected statuses
 569       var selectedStatuses = [];
 570       _.each($scope.selectedStatuses, function(v, k) {
 571         if (v) selectedStatuses.push(k);
 572       });
 573       // Ignore if ALL or NONE selected
 574       $scope.caseType.definition.statuses = selectedStatuses.length == _.size($scope.selectedStatuses) ? [] : selectedStatuses;
 575
 576       if ($scope.caseType.definition.activityAsgmtGrps) {
 577         $scope.caseType.definition.activityAsgmtGrps = $scope.caseType.definition.activityAsgmtGrps.toString().split(",");
 578       }
 579
 580       function dropDisplaylabel (v) {
 581         delete v.displaylabel;
 582       }
 583
 584       // strip out labels from $scope.caseType.definition.caseRoles
 585       _.map($scope.caseType.definition.caseRoles, dropDisplaylabel);
 586
 587       var result = crmApi('CaseType', 'create', $scope.caseType, true);
 588       result.then(function(data) {
 589         if (data.is_error === 0 || data.is_error == '0') {
 590           $scope.caseType.id = data.id;
 591           window.location.href = '#/caseType';
 592         }
 593       });
 594     };
 595
 596     $scope.$watchCollection('caseType.definition.activitySets', function() {
 597       _.defer(function() {
 598         $('.crmCaseType-acttab').tabs('refresh');
 599       });
 600     });
 601
 602     var updateCaseTypeName = function () {
 603       if (!$scope.caseType.id && $scope.locks.caseTypeName) {
 604         // Should we do some filtering? Lowercase? Strip whitespace?
 605         var t = $scope.caseType.title ? $scope.caseType.title : '';
 606         $scope.caseType.name = t.replace(/ /g, '_').replace(/[^a-zA-Z0-9_]/g, '').toLowerCase();
 607       }
 608     };
 609     $scope.$watch('locks.caseTypeName', updateCaseTypeName);
 610     $scope.$watch('caseType.title', updateCaseTypeName);
 611
 612     if (!$scope.isForkable()) {
 613       CRM.alert(ts('The CiviCase XML file for this case-type prohibits editing the definition.'));
 614     }
 615
 616   });
 617
 618   crmCaseType.controller('CaseTypeListCtrl', function($scope, crmApi, caseTypes) {
 619     var ts = $scope.ts = CRM.ts(null);
 620
 621     $scope.caseTypes = caseTypes.values;
 622     $scope.toggleCaseType = function (caseType) {
 623       caseType.is_active = (caseType.is_active == '1') ? '0' : '1';
 624       crmApi('CaseType', 'create', caseType, true)
 625         .catch(function (data) {
 626           caseType.is_active = (caseType.is_active == '1') ? '0' : '1'; // revert
 627           $scope.$digest();
 628         });
 629     };
 630     $scope.deleteCaseType = function (caseType) {
 631       crmApi('CaseType', 'delete', {id: caseType.id}, {
 632         error: function (data) {
 633           CRM.alert(data.error_message, ts('Error'), 'error');
 634         }
 635       })
 636         .then(function (data) {
 637           delete caseTypes.values[caseType.id];
 638         });
 639     };
 640     $scope.revertCaseType = function (caseType) {
 641       caseType.definition = 'null';
 642       caseType.is_forked = '0';
 643       crmApi('CaseType', 'create', caseType, true)
 644         .catch(function (data) {
 645           caseType.is_forked = '1'; // restore
 646           $scope.$digest();
 647         });
 648     };
 649   });
 650
 651 })(angular, CRM.$, CRM._);