Name

global.RankingAPI

Description

functions setRank - Updates the rank of the task to that rank and reorder next set appropriately generateRanks - sorts the tasks and generates the ranks

Script

var RankingAPI = Class.create();
RankingAPI.prototype = {
  initialize: function(tasks) {
      this.tasks = tasks;
      //Each task will have 3 fields - key(Sys_id), rank and isDirty(Flag to determine if that record needs update)
      // Other implementations were to pre-loaded the tasks and ranks in object(s) for easy get/set
      // However the memory print of the same will be twice/thrice
  },

  compare: function (task1, task2) {
      if(JSUtil.nil(task1.rank) && JSUtil.nil(task2.rank)) return 0;
      if(JSUtil.nil(task2) || JSUtil.nil(task2.rank)) return -1;
      if(JSUtil.nil(task1) || JSUtil.nil(task1.rank)) return 1;
      if(task1.rank > task2.rank) return 1;
      if(task1.rank < task2.rank) return -1;
      return 0;
  },

  sortTasks: function (comparatorFunction) {
      if(JSUtil.notNil(this.tasks) && this.tasks.length > 0) {
          if(JSUtil.notNil(comparatorFunction))
              this.tasks.sort(comparatorFunction);
          else
              this.tasks.sort(this.compare);
      }
  },

  taskByRank: function (rank) {
      for (var i = 0; i < this.tasks.length; i++) {
          if(JSUtil.notNil(this.tasks[i]) && JSUtil.notNil(this.tasks[i].rank) && 
              this.tasks[i].rank == rank) {
              return this.tasks[i];
          }
      }
  },

  taskByKey: function (key) {
      for (var i = 0; i < this.tasks.length; i++) {
          if(JSUtil.notNil(this.tasks[i]) && JSUtil.notNil(this.tasks[i].key) && 
              this.tasks[i].key == key) {
              return this.tasks[i];
          }
      }
  },

  successiveRankTasks: function (oldRank, newRank) {
      var successiveRankTasks = [];
      var rankCounter;
      var taskByRank;
      if(JSUtil.notNil(oldRank) && JSUtil.notNil(newRank) && oldRank != 0) {
          rankCounter = newRank;
          taskByRank = this.taskByRank(rankCounter);
          while(JSUtil.notNil(taskByRank) && rankCounter <= oldRank) {
              successiveRankTasks.push(taskByRank);
              rankCounter += 1;
              taskByRank = this.taskByRank(rankCounter);
          }
      } else if (JSUtil.nil(oldRank) || oldRank == 0) {
          //Loop till there is a blank
          rankCounter = newRank;
          taskByRank = this.taskByRank(rankCounter);
          while(JSUtil.notNil(taskByRank)) {
              successiveRankTasks.push(taskByRank);
              rankCounter += 1;
              taskByRank = this.taskByRank(rankCounter);
          }
      }
      return successiveRankTasks;
  },

  priorRankTasks: function (oldRank, newRank) {
      var priorRankTasks = [];
      if(JSUtil.notNil(oldRank) && JSUtil.notNil(newRank)) {
          var rankCounter = newRank;
          var taskByRank = this.taskByRank(rankCounter);
          while(JSUtil.notNil(taskByRank) && rankCounter >= oldRank) {
              priorRankTasks.push(taskByRank);
              rankCounter -= 1;
              taskByRank = this.taskByRank(rankCounter);
          }
      }
      return priorRankTasks;
  },

  updateRank: function (key, newRank) {
      if(JSUtil.notNil(key) && JSUtil.notNil(newRank)) {
          var task = this.taskByKey(key);
          if(JSUtil.notNil(task)) {
            var oldRank = task.rank;
            if((oldRank > newRank) || JSUtil.nil(oldRank) || oldRank == 0) {
                var successiveRankTasks = this.successiveRankTasks(oldRank,newRank);
                for (var i = 0; i < successiveRankTasks.length; i++) {
                    successiveRankTasks[i].rank += 1;
                    successiveRankTasks[i].isDirty = true;
                }
            }else if(oldRank < newRank){
                var priorRankTasks = this.priorRankTasks(oldRank,newRank);
                for (var j = 0; j < priorRankTasks.length; j++) {
                    priorRankTasks[j].rank -= 1;
                    priorRankTasks[j].isDirty = true;
                }
            }
            task.rank = newRank;
            task.isDirty = true;
          }
      }
  },
  
  getDirtyTasks: function () {
      var dirtyTasks = [];
      if(JSUtil.notNil(this.tasks) && this.tasks.length > 0) {
          for (var i = 0; i < this.tasks.length; i++) {
              if(JSUtil.notNil(this.tasks[i]) && this.tasks[i].isDirty)
                  dirtyTasks.push(this.tasks[i]);
          }
      }
      return dirtyTasks;
  },

  compact: function () {
      gs.print("Into RankingAPI.compact...");
      if(JSUtil.notNil(this.tasks) && this.tasks.length > 0) {
          gs.print("Before sort -> " + (new JSON()).encode(this.tasks));
          this.sortTasks();
          for (var i = 0; i < this.tasks.length; i++) {
              this.tasks[i].rank = (i+1);
          }
          gs.print("After sort -> " + (new JSON()).encode(this.tasks));
      }
  },

  generateRanks: function (comparatorFunction) {
    if(JSUtil.notNil(this.tasks) && this.tasks.length > 0) {
          this.sortTasks(comparatorFunction);
          for (var i = 0; i < this.tasks.length; i++) {
              this.tasks[i].rank = (i+1);
          }
      }  
  },

  generateRanksBasedOnColumn: function (comparatorFunction, comparsionColumn) {
    if(JSUtil.notNil(this.tasks) && this.tasks.length > 0) {
          for (var i = 0; i < this.tasks.length; i++) {
              this.tasks[i].comparsionColumn = this.tasks[i][comparsionColumn];
          }
          this.sortTasks(comparatorFunction);
          for (var i = 0; i < this.tasks.length; i++) {
              this.tasks[i].rank = (i+1);
          }
      }  
  },

  printTasks: function () {
      gs.print((new JSON()).encode(this.tasks));
  },

  type: 'RankingAPI'
};

Sys ID

d4f134019f932200598a5bb0657fcfea

Offical Documentation

Official Docs: