bug 1307169: Emergency shut off frontend (#460). r=bhearsum

auslib/db.py

@@ -2385,7 +2385,7 @@ def insert(self, changed_by, transaction=None, dryrun=False, **columns):
 
         ret = super(EmergencyShutoffs, self).insert(changed_by=changed_by, transaction=transaction, dryrun=dryrun, **columns)
         if not dryrun:
-            return ret.inserted_primary_key
+            return ret.last_updated_params()
 
     def getPotentialRequiredSignoffs(self, affected_rows, transaction=None):
         potential_required_signoffs = []
@@ -2402,8 +2402,8 @@ def delete(self, where, changed_by=None, old_data_version=None, transaction=None
             raise PermissionDeniedError("%s is not allowed to delete shutoffs for product %s" % (changed_by, product))
 
         if not dryrun:
-            for current_rule in self.select(where=where, transaction=transaction):
-                potential_required_signoffs = self.getPotentialRequiredSignoffs([current_rule], transaction=transaction)
+            for current_emergency_shutoff in self.select(where=where, transaction=transaction):
+                potential_required_signoffs = self.getPotentialRequiredSignoffs([current_emergency_shutoff], transaction=transaction)
                 verify_signoffs(potential_required_signoffs, signoffs)
 
         super(EmergencyShutoffs, self).delete(changed_by=changed_by, where=where, old_data_version=old_data_version, transaction=transaction, dryrun=dryrun)

auslib/test/admin/views/test_emergency_shutoff.py

@@ -123,6 +123,13 @@ def test_update_scheduled_deletion(self):
                                 .execute().fetchall()
         self.assertTrue(sc)
 
+    def test_delete_scheduled_deletion(self):
+        resp = self._delete('/scheduled_changes/emergency_shutoff/1', qs={'data_version': 1})
+        self.assertStatusCode(resp, 200)
+        sc_table = dbo.emergencyShutoffs.scheduled_changes
+        sc = sc_table.t.select().where(sc_table.sc_id == 1).execute().fetchall()
+        self.assertFalse(sc)
+
     def test_enact_updates_scheduled_for_reactivation(self):
         resp = self._post('/scheduled_changes/emergency_shutoff/1/enact')
         self.assertStatusCode(resp, 200)

auslib/web/admin/emergency_shutoff.py

@@ -26,11 +26,11 @@ def post(emergency_shutoff, changed_by, transaction):
         return problem(
             400, 'Bad Request', 'Invalid Emergency shutoff data',
             ext={'data': 'Emergency shutoff for product/channel already exists.'})
-    dbo.emergencyShutoffs.insert(
+    inserted_shutoff = dbo.emergencyShutoffs.insert(
         changed_by=changed_by, transaction=transaction, product=emergency_shutoff['product'], channel=emergency_shutoff['channel'])
     return Response(status=201,
                     content_type="application/json",
-                    response=json.dumps(emergency_shutoff))
+                    response=json.dumps(inserted_shutoff))
 
 
 @requirelogin
@@ -76,6 +76,13 @@ def update_scheduled_deletion(sc_id, sc_emergency_shutoff, changed_by, transacti
     return view._post(sc_id, sc_emergency_shutoff, transaction, changed_by, sc_emergency_shutoff['sc_data_version'])
 
 
+@requirelogin
+@transactionHandler
+def delete_scheduled_deletion(sc_id, changed_by, transaction, **kwargs):
+    view = ScheduledChangeView('emergency_shutoff', dbo.emergencyShutoffs)
+    return view._delete(sc_id, transaction, changed_by)
+
+
 def scheduled_changes_signoffs(sc_id):
     view = SignoffsView('emergency_shutoff', dbo.emergencyShutoffs)
     return view.post(sc_id)

auslib/web/admin/swagger/api.yaml

@@ -3912,6 +3912,29 @@ paths:
         '404':
           $ref: '#/responses/resourceNotFound'
 
+    delete:
+      summary: Deletes the given Scheduled Change for Emergency Shutoff.
+      description: >
+        Deletes the given Scheduled Change for Emergency Shutoff. 'data_version' must be provided. [Docs](http://mozilla-balrog.readthedocs.io/en/latest/admin_api.html#scheduled-changes-object-sc-id)
+      tags:
+        - Scheduled Changes
+        - Emergency Shutoff
+      operationId: auslib.web.admin.emergency_shutoff.delete_scheduled_deletion
+      consumes: []
+      produces:
+        - application/json
+      parameters:
+        - $ref: '#/parameters/sc_id_param'
+        - $ref: '#/parameters/dataVersionParam'
+        - $ref: '#/parameters/csrfTokenParam'
+      responses:
+        '200':
+          description: Successfully deleted the given scheduled change.
+        '400':
+          $ref: '#/responses/invalidFormData'
+        '404':
+          $ref: '#/responses/resourceNotFound'
+
   /scheduled_changes/emergency_shutoff/{sc_id}/enact:
     post:
       summary: Execute the scheduled change for the emergency shut off.

ui/app/js/controllers/disable_updates_modal.js

@@ -0,0 +1,27 @@
+angular.module('app').controller('DisableUpdatesModalCtrl',
+  function($scope, $modalInstance, EmergencyShutoffs, product, channel){
+    $scope.product = product;
+    $scope.channel = channel;
+    $scope.saving = false;
+
+    $scope.disableUpdates = function() {
+      $scope.saving = true;
+      EmergencyShutoffs.create($scope.product, $scope.channel)
+        .success(function(response) {
+          $modalInstance.close(response);
+          sweetAlert("Disabling Updates", "Updates were disabled successfully!", "success");
+        })
+        .error(function(response, status) {
+          if (typeof response === 'object') {
+            sweetAlert("Form submission error", response.data, "error");
+          }
+        })
+        .finally(function() {
+          $scope.saving = false;
+        });
+    };
+
+    $scope.cancel = function() {
+      $modalInstance.dismiss('cancel');
+    };
+  });

ui/app/js/controllers/enable_updates_modal.js

@@ -0,0 +1,62 @@
+angular.module('app').controller('EnableUpdatesCtrl',
+  function($scope, $modalInstance, CSRF, EmergencyShutoffs, emergency_shutoff, signoffs_requirements){
+    $scope.saving = false;
+    $scope.emergency_shutoff = emergency_shutoff;
+    $scope.signoffs_requirements = signoffs_requirements.filter(function(required_signoff) {
+      return required_signoff.product === emergency_shutoff.product && required_signoff.channel === emergency_shutoff.channel;
+    }).reduce(function(signoffs_reqs, signoff) {
+      signoffs_reqs.length++;
+      signoffs_reqs.roles[signoff.role] = signoff.signoffs_required;
+      return signoffs_reqs;
+    }, {'length': 0, 'roles': {}});
+
+    $scope.enableUpdates = function() {
+      $scope.saving = true;
+      CSRF.getToken()
+        .then(function(csrf_token) {
+          if($scope.signoffs_requirements.length > 0) {
+            EmergencyShutoffs.scheduleEnableUpdates($scope.emergency_shutoff, csrf_token)
+              .success(function(response) {
+                $modalInstance.close();
+                sweetAlert(
+                  "Enabling Updates",
+                  "Updates have been scheduled to be enabled successfully.",
+                  "success");
+              })
+              .error(function(response, status) {
+                if (typeof response === 'object') {
+                  sweetAlert("Form submission error", response.data, "error");
+                }
+              })
+              .finally(function(){
+                $scope.saving = false;
+              });
+          } else {
+            EmergencyShutoffs.delete(
+              $scope.emergency_shutoff.product,
+              $scope.emergency_shutoff.channel,
+              $scope.emergency_shutoff.data_version,
+              csrf_token)
+                .success(function(response) {
+                  $modalInstance.close();
+                  sweetAlert(
+                    "Enabling Updates",
+                    "Updates were enabled successfully.",
+                    "success");
+                })
+                .error(function(response, status) {
+                  if (typeof response === 'object') {
+                    sweetAlert("Form submission error", response.data, "error");
+                  }
+                })
+                .finally(function(){
+                  $scope.saving = false;
+                });
+          }
+        });
+    };
+
+    $scope.cancel = function () {
+      $modalInstance.dismiss('cancel');
+    };
+  });

ui/app/js/controllers/rules_controller.js

@@ -1,5 +1,5 @@
 angular.module("app").controller('RulesController',
-function($scope, $routeParams, $location, $timeout, Rules, Search, $modal, $route, Releases, Page, Permissions, ProductRequiredSignoffs, Helpers) {
+function($scope, $routeParams, $location, $timeout, Rules, Search, $modal, $route, Releases, Page, Permissions, ProductRequiredSignoffs, Helpers, EmergencyShutoffs, CSRF) {
 
   Page.setTitle('Rules');
 
@@ -16,6 +16,8 @@ function($scope, $routeParams, $location, $timeout, Rules, Search, $modal, $rout
   $scope.rules = [];
   $scope.pr_ch_filter = "";
   $scope.show_sc = true;
+  $scope.emergency_shutoffs = [];
+  $scope.current_emergency_shutoff = null;
 
   function changeLocationWithFilterParams(filterParamsString) {
     localStorage.setItem("pr_ch_filter", filterParamsString);
@@ -141,6 +143,23 @@ function($scope, $routeParams, $location, $timeout, Rules, Search, $modal, $rout
           return Rules.ruleSignoffsRequired(rule, undefined, $scope.signoffRequirements);
         }
       };
+
+      EmergencyShutoffs.get().success(function(response_emergency_shutoffs) {
+        $scope.emergency_shutoffs = response_emergency_shutoffs.shutoffs;
+      }).finally(function() {
+        EmergencyShutoffs.scheduledChanges()
+          .success(function(response_emergency_shutoffs_sc) {
+            if($scope.emergency_shutoffs.length > 0) {
+              shutoffs_sc = response_emergency_shutoffs_sc.scheduled_changes;
+              if(shutoffs_sc.length > 0) {
+                $scope.emergency_shutoffs.forEach(function(shutoff) {
+                  shutoff.sc = EmergencyShutoffs.shutoffScheduledEnableChange(shutoff, shutoffs_sc);
+                });
+              }
+            }
+          });
+      });
+
     })
     .error(function() {
       console.error(arguments);
@@ -156,6 +175,7 @@ function($scope, $routeParams, $location, $timeout, Rules, Search, $modal, $rout
       localStorage.setItem("pr_ch_filter", value);
     }
     $scope.pr_ch_selected = value.split(',');
+    $scope.setEmergencyShutoff($scope.pr_ch_selected);
   });
 
   $scope.selectPageSize = function() {
@@ -248,6 +268,14 @@ function($scope, $routeParams, $location, $timeout, Rules, Search, $modal, $rout
     changeLocationWithFilterParams($scope.pr_ch_filter);
   };
 
+  $scope.setEmergencyShutoff = function(pr_ch_selected) {
+    if(pr_ch_selected.length > 0) {
+      $scope.current_emergency_shutoff =
+        $scope.emergency_shutoffs.find(function(shutoff) {
+          return shutoff.product === pr_ch_selected[0] && shutoff.channel === pr_ch_selected[1];
+        });
+    }
+  };
 
   $scope.openUpdateModal = function(rule) {
 
@@ -672,5 +700,133 @@ function($scope, $routeParams, $location, $timeout, Rules, Search, $modal, $rout
     });
   };
 
+  $scope.openDisableUpdatesModal = function() {
+    var modal = $modal.open({
+      templateUrl: 'disable_updates_modal.html',
+      controller: 'DisableUpdatesModalCtrl',
+      size: 'lg',
+      backdrop: 'static',
+      resolve: {
+        product: function() {
+          return $scope.pr_ch_selected[0];
+        },
+        channel: function() {
+          return $scope.pr_ch_selected[1];
+        }
+      }
+    });
+    modal.result.then(function(emergency_shutoff) {
+      $scope.emergency_shutoffs.push(emergency_shutoff);
+      $scope.current_emergency_shutoff = emergency_shutoff;
+    });
+  };
+
+  $scope.openEnableUpdatesModal = function() {
+    var modal = $modal.open({
+      templateUrl: 'enable_updates_modal.html',
+      controller: 'EnableUpdatesCtrl',
+      size: 'lg',
+      backdrop: 'static',
+      resolve: {
+        emergency_shutoff: function() {
+          return $scope.current_emergency_shutoff;
+        },
+        signoffs_requirements: function() {
+          return $scope.signoffRequirements;
+        }
+      }
+    });
+    modal.result.then(function() {
+      EmergencyShutoffs.scheduledChanges()
+        .success(function(response_emergency_shutoffs_sc) {
+          shutoffs_sc = response_emergency_shutoffs_sc.scheduled_changes;
+          $scope.current_emergency_shutoff.sc =
+            EmergencyShutoffs.shutoffScheduledEnableChange($scope.current_emergency_shutoff, shutoffs_sc);
+          if(!$scope.current_emergency_shutoff.sc) {
+            $scope.emergency_shutoffs = $scope.emergency_shutoffs.filter(function(eso) {
+              return eso.product !== $scope.current_emergency_shutoff.product || eso.channel !== $scope.current_emergency_shutoff.channel;
+            });
+            $scope.current_emergency_shutoff = null;
+          }
+        });
+    });
+  };
+
+  $scope.openEnableUpdateRevokeSignoffModal = function() {
+    $modal.open({
+      templateUrl: "revoke_signoff_modal.html",
+      controller: "RevokeSignoffCtrl",
+      backdrop: "static",
+      resolve: {
+        object_name: function() {
+          return "Emergency Shutoff";
+        },
+        service: function() {
+          return EmergencyShutoffs;
+        },
+        current_user: function() {
+          return $scope.current_user;
+        },
+        sc: function() {
+          return $scope.current_emergency_shutoff.sc;
+        },
+        pk: function() {
+          return {
+            'Emergency Shutoff': $scope.current_emergency_shutoff.product + '/' + $scope.current_emergency_shutoff.channel
+          };
+        },
+        data: null
+      }
+    });
+  };
+
+  $scope.openEnableUpdateSignoffModal = function() {
+    var modalInstance = $modal.open({
+      templateUrl: "signoff_modal.html",
+      controller: "SignoffCtrl",
+      backdrop: "static",
+      resolve: {
+        object_name: function() {
+          return "Emergency Shutoff";
+        },
+        service: function() {
+          return EmergencyShutoffs;
+        },
+        current_user: function() {
+          return $scope.current_user;
+        },
+        user_roles: function() {
+          return $scope.user_roles;
+        },
+        required_signoffs: function () {
+          return $scope.current_emergency_shutoff.sc["required_signoffs"];
+        },
+        sc: function() {
+          return $scope.current_emergency_shutoff.sc;
+        },
+        pk: function() {
+          return {
+            'Emergency Shutoff': $scope.current_emergency_shutoff.product + '/' + $scope.current_emergency_shutoff.channel
+          };
+        },
+        data: null
+      }
+    });
+  };
 
+  $scope.deleteScheduledEnableUpdates = function() {
+    CSRF.getToken()
+      .then(function(csrf_token) {
+        EmergencyShutoffs.deleteScheduledEnableUpdates(
+          $scope.current_emergency_shutoff.sc.sc_id,
+          $scope.current_emergency_shutoff.sc.data_version,
+          csrf_token).success(function() {
+            $scope.current_emergency_shutoff.sc = null;
+            sweetAlert(
+              "Enabling Updates",
+              "Scheduled Enable Updates deleted successfully.",
+              "success");
+          });
+      });
+  };
 });