OTRS API Reference JavaScript

Source: Core.Agent.Admin.PackageManager.js

  1. // --
  2. // Copyright (C) 2001-2020 OTRS AG, https://otrs.com/
  3. // --
  4. // This software comes with ABSOLUTELY NO WARRANTY. For details, see
  5. // the enclosed file COPYING for license information (GPL). If you
  6. // did not receive this file, see https://www.gnu.org/licenses/gpl-3.0.txt.
  7. // --
  9. "use strict";
  11. var Core = Core || {};
  12. Core.Agent = Core.Agent || {};
  13. Core.Agent.Admin = Core.Agent.Admin || {};
  15. /**
  16.  * @namespace Core.Agent.Admin.PackageManager
  17.  * @memberof Core.Agent.Admin
  18.  * @author OTRS AG
  19.  * @description
  20.  *      This namespace contains the special function for AdminPackageManager module.
  21.  */
  22.  Core.Agent.Admin.PackageManager = (function (TargetNS) {
  24.     var StatusNotificationText = Core.Language.Translate('There is a package upgrade process running, click here to see status information about the upgrade progress.'),
  25.         FinisedNotificationText = Core.Language.Translate('A package upgrade was recently finished. Click here to see the results.');
  27.     /**
  28.       * @name GetPackageUpgradeResult
  29.       * @memberof Core.Agent.Admin.PackageManager
  30.       * @function
  31.       * @description
  32.       *      This function queries the status of the package upgrade process (via AJAX request) from the system data table.
  33.       */
  34.     TargetNS.GetPackageUpgradeResult = function() {
  35.          var Data = {
  36.              Action    : 'AdminPackageManager',
  37.              Subaction : 'AJAXGetPackageUpgradeResult',
  38.         },
  39.         DialogTemplate;
  41.         Core.AJAX.FunctionCall(
  42.             Core.Config.Get('CGIHandle'),
  43.             Data,
  44.             function (Response) {
  45.                 if (!Response || !Response.Success) {
  46.                     Core.UI.Dialog.ShowAlert(
  47.                         Core.Language.Translate('An error occurred during communication.'),
  48.                         Core.Language.Translate('No response from get package upgrade result.')
  49.                     );
  50.                     return false;
  51.                 }
  53.                 DialogTemplate = Core.Template.Render('PackageManager/InformationDialog', {
  54.                     PackageList: Response.PackageList,
  55.                     UpgradeStatus: Response.UpgradeStatus,
  56.                     UpgradeSuccess: Response.UpgradeSuccess,
  57.                 });
  59.                 // When finish, do not allow to click outside to close, instead show a button to actively remove data.
  60.                 if (Response.UpgradeStatus === 'Finished') {
  61.                     Core.UI.Dialog.ShowDialog({
  62.                         HTML: DialogTemplate,
  63.                         Title: Core.Language.Translate('Update all packages'),
  64.                         Modal: true,
  65.                         CloseOnClickOutside: false,
  66.                         CloseOnEscape: false,
  67.                         PositionTop: '10px',
  68.                         PositionLeft: 'Center',
  69.                         AllowAutoGrow: true,
  70.                         Buttons: [
  71.                             {
  72.                                 Label: Core.Language.Translate('Dismiss'),
  73.                                 Function: function () {
  74.                                     Core.AJAX.FunctionCall(
  75.                                         Core.Config.Get('CGIHandle'),
  76.                                         'Action=' + 'AdminPackageManager' + ';Subaction=AJAXDeletePackageUpgradeData;',
  77.                                         function (Response) {
  79.                                         if (!Response || !Response.Success) {
  80.                                             alert(Core.Language.Translate("An error occurred during communication."));
  81.                                         }
  82.                                         Core.UI.Dialog.CloseDialog($('.Dialog:visible'));
  83.                                         window.location.reload();
  84.                                     });
  85.                                 },
  86.                                 Class: 'CallForAction',
  87.                                 Type: 'Close',
  88.                             },
  89.                         ]
  90.                     });
  91.                 }
  93.                 // Otherwise show normal dialog without buttons.
  94.                 else {
  95.                     Core.UI.Dialog.ShowContentDialog(DialogTemplate, Core.Language.Translate('Update All Packages'), '100px', 'Center', true);
  96.                 }
  97.             }, 'json'
  98.         );
  99.      };
  101.      /**
  102.       * @name PackageUpgradeAll
  103.       * @memberof Core.Agent.Admin.PackageManager
  104.       * @function
  105.       * @description
  106.       *      This function creates a daemon task (via AJAX call) to upgrade all installed packages.
  107.       */
  108.     TargetNS.PackageUpgradeAll = function() {
  109.          var Data = {
  110.              Action    : 'AdminPackageManager',
  111.              Subaction : 'AJAXPackageUpgradeAll',
  112.         };
  114.         Core.AJAX.FunctionCall(
  115.             Core.Config.Get('CGIHandle'),
  116.             Data,
  117.             function (Response) {
  118.                 if (!Response || !Response.Success) {
  119.                     Core.UI.Dialog.ShowAlert(
  120.                         Core.Language.Translate('An error occurred during communication.'),
  121.                         Core.Language.Translate('No response from package upgrade all.')
  122.                     );
  123.                     return false;
  124.                 }
  126.                 TargetNS.DisablePackageActions();
  127.                 TargetNS.GetPackageUpgradeRunStatus();
  128.             }, 'json'
  129.         );
  130.      };
  132.      /**
  133.       * @name DisablePackageActions
  134.       * @memberof Core.Agent.Admin.PackageManager
  135.       * @function
  136.       * @description
  137.       *      This function prevent package actions for running.
  138.       */
  139.     TargetNS.DisablePackageActions = function() {
  140.         $('.UpgradeAll').off('click');
  141.         $('.PackageAction').addClass('Disabled').on('click', function(Event){
  142.             Core.UI.Dialog.ShowAlert(
  143.                 Core.Language.Translate('Currently not possible'),
  144.                 Core.Language.Translate('This is currently disabled because of an ongoing package upgrade.')
  145.             );
  146.             Event.stopPropagation();
  147.             Event.preventDefault();
  148.             return false;
  149.         });
  150.      };
  152.      /**
  153.       * @name EnablePackageActions
  154.       * @memberof Core.Agent.Admin.PackageManager
  155.       * @function
  156.       * @description
  157.       *      Tis function activate all package actions.
  158.       */
  159.     TargetNS.EnablePackageActions = function() {
  160.         $('.PackageAction').removeClass('Disabled').off('click');
  162.         $('.UpgradeAll').off('click.UpgradeAll').on('click.UpgradeAll', function() {
  164.             if (Core.Config.Get('DaemonCheckNotRunning')) {
  165.                 Core.UI.Dialog.ShowAlert(
  166.                     Core.Language.Translate('Currently not possible'),
  167.                     Core.Language.Translate('This option is currently disabled because the OTRS Daemon is not running.')
  168.                 );
  169.                 return false;
  170.             }
  172.             if (window.confirm(Core.Language.Translate("Are you sure you want to update all installed packages?"))) {
  173.                 TargetNS.PackageUpgradeAll();
  174.             }
  176.             return false;
  177.         });
  178.     };
  180.      /**
  181.       * @name GetPackageUpgradeRunStatus
  182.       * @memberof Core.Agent.Admin.PackageManager
  183.       * @function
  184.       * @description
  185.       *      This function checks if there is currently a PackageUpgradeAll process running (via AJAX request),
  186.       *         depending on the results it also enable/disable package actions and show/hide notifications.
  187.       */
  188.     TargetNS.GetPackageUpgradeRunStatus = function() {
  189.          var Data = {
  190.              Action    : 'AdminPackageManager',
  191.              Subaction : 'AJAXGetPackageUpgradeRunStatus',
  192.         },
  193.         NotificationType;
  195.         Core.AJAX.FunctionCall(
  196.             Core.Config.Get('CGIHandle'),
  197.             Data,
  198.             function (Response) {
  199.                 if (!Response || !Response.Success) {
  200.                     Core.UI.Dialog.ShowAlert(
  201.                         Core.Language.Translate('An error occurred during communication.'),
  202.                         Core.Language.Translate('No response from get package upgrade run status.')
  203.                     );
  204.                     return false;
  205.                 }
  207.                 /* When the process is running finished notifications needs to be removed and in
  208.                     progress notification has to be shown, all package actions needs to be disabled
  209.                 */
  210.                 if (Response.IsRunning){
  211.                     TargetNS.DisablePackageActions();
  213.                     Core.UI.HideNotification(FinisedNotificationText, 'Error', undefined);
  214.                     Core.UI.HideNotification(FinisedNotificationText, 'Confirmation', undefined);
  216.                     Core.UI.ShowNotification(
  217.                         StatusNotificationText,
  218.                         'Notice',
  219.                         undefined,
  220.                         function() {
  221.                             $('#PackageUpgradeNotification a').on('click', function(){
  222.                                 TargetNS.GetPackageUpgradeResult();
  223.                                 return false;
  224.                             });
  225.                         },
  226.                         'PackageUpgradeNotification',
  227.                         'fa-spin fa-circle-o-notch'
  228.                     );
  229.                 }
  230.                 else {
  231.                     Core.UI.HideNotification(StatusNotificationText, 'Notice', undefined);
  232.                     TargetNS.EnablePackageActions();
  233.                 }
  235.                 /* When we get the confirmation that the process has finished, progress notification
  236.                     has to be removed and finished notification has to be shown.
  237.                 */
  238.                 if (Response.UpgradeStatus && Response.UpgradeStatus === 'Finished') {
  240.                     Core.UI.HideNotification(StatusNotificationText, 'Notice', undefined);
  242.                     NotificationType = 'Error';
  243.                     if (Response.UpgradeSuccess && Response.UpgradeSuccess) {
  244.                         NotificationType = 'Confirmation';
  245.                     }
  247.                     Core.UI.ShowNotification(
  248.                         FinisedNotificationText,
  249.                         NotificationType,
  250.                         undefined,
  251.                         function() {
  252.                             $('#PackageUpgradeFinishedNotification a').on('click', function(){
  253.                                 TargetNS.GetPackageUpgradeResult();
  254.                                 return false;
  255.                             });
  256.                         },
  257.                         'PackageUpgradeFinishedNotification',
  258.                         undefined
  259.                     );
  260.                 }
  261.             }, 'json'
  262.         );
  263.      };
  265.     /**
  266.     * @name Init
  267.     * @memberof Core.Agent.Admin.PackageManager
  268.     * @function
  269.     * @description
  270.     *      This function initializes module functionality.
  271.     */
  272.     TargetNS.Init = function () {
  274.         TargetNS.EnablePackageActions();
  275.         TargetNS.GetPackageUpgradeRunStatus();
  277.         setInterval(function(){
  278.                 TargetNS.GetPackageUpgradeRunStatus();
  279.         }, 30000);
  280.     };
  282.     Core.Init.RegisterNamespace(TargetNS, 'APP_MODULE');
  284.     return TargetNS;
  285. }(Core.Agent.Admin.PackageManager || {}));

^ Use Elevator