myems-admin/app/controllers/settings/microgrid/microgridgrid.controller.js - Code Metrics - Inspection of "Merge branch 'develop'" - MyEMS/myems - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 0609f7...f69d02 )

unknown

created 2025-09-03 05:29 UTC

myems-admin/app/controllers/settings/microgrid/microgridgrid.controller.js F

↳ Parent: Project

Complexity

Total Complexity	62
Complexity/F	1.35

Size

Lines of Code	427
Function Count	46

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
wmc	62
eloc	308
dl	0
loc	427
rs	3.44
c	0
b	0
f	0
mnd	16
bc	16
fnc	46
bpm	0.3478
cpm	1.3478
noi	0

How to fix Complexity

'use strict';

app.controller('MicrogridGridController', function(
	$scope,
	$rootScope,
	$window,
	$translate,
	$uibModal,
	MicrogridService,
	MicrogridGridService,
	MicrogridDataSourceService,
	PointService,
	MeterService,
	toaster,
	SweetAlert) {
      $scope.microgrids = [];
      $scope.microgridgrids = [];
	  $scope.points = [];
	  $scope.meters = [];
      $scope.currentMicrogrid = null;
	  $scope.cur_user = JSON.parse($window.localStorage.getItem("myems_admin_ui_current_user"));
      $scope.getAllMicrogrids = function() {
		let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
  		MicrogridService.getAllMicrogrids(headers, function (response) {
  			if (angular.isDefined(response.status) && response.status === 200) {
  				$scope.microgrids = response.data;
  			} else {
  				$scope.microgrids = [];
  			}
  		});
  	};

    $scope.getDataSourcesByMicrogridID = function(id) {
      let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
      MicrogridDataSourceService.getDataSourcesByMicrogridID(id, headers, function(response) {
        if (angular.isDefined(response.status) && response.status === 200) {
          $scope.datasources = response.data;
        } else {
          $scope.datasources = [];
        }
      });
    };

    $scope.getDataSourcePointsByMicrogridID = function(id) {
      let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
      MicrogridDataSourceService.getDataSourcePointsByMicrogridID(id, headers, function(response) {
        if (angular.isDefined(response.status) && response.status === 200) {
          $scope.points = response.data;
        } else {
          $scope.points = [];
        }
      });
    };

	$scope.getAllMeters = function() {
		let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
		MeterService.getAllMeters(headers, function (response) {
			if (angular.isDefined(response.status) && response.status === 200) {
				$scope.meters = response.data;
			} else {
				$scope.meters = [];
			}
		});
	};
  	$scope.getMicrogridGridsByMicrogridID = function(id) {
		let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
  		MicrogridGridService.getMicrogridGridsByMicrogridID(id, headers, function (response) {
			if (angular.isDefined(response.status) && response.status === 200) {
				$scope.microgridgrids = response.data;
			} else {
          	$scope.microgridgrids=[];
        }
			});
  	};

  	$scope.changeMicrogrid=function(item,model){
    	$scope.currentMicrogrid=item;
    	$scope.currentMicrogrid.selected=model;
        $scope.is_show_add_microgrid_grid = true;
    	$scope.getMicrogridGridsByMicrogridID($scope.currentMicrogrid.id);
    	$scope.getDataSourcesByMicrogridID($scope.currentMicrogrid.id);
        $scope.getDataSourcePointsByMicrogridID($scope.currentMicrogrid.id);
  	};

  	$scope.addMicrogridGrid = function() {

  		var modalInstance = $uibModal.open({
  			templateUrl: 'views/settings/microgrid/microgridgrid.model.html',
  			controller: 'ModalAddMicrogridGridCtrl',
  			windowClass: "animated fadeIn",
  			resolve: {
  				params: function() {
  					return {
						meters: angular.copy($scope.meters),
						points: angular.copy($scope.points),
  					};
  				}
  			}
  		});
  		modalInstance.result.then(function(microgridgrid) {
			microgridgrid.power_point_id = microgridgrid.power_point.id;
			microgridgrid.buy_meter_id = microgridgrid.buy_meter.id;
			microgridgrid.sell_meter_id = microgridgrid.sell_meter.id;
			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
  			MicrogridGridService.addMicrogridGrid($scope.currentMicrogrid.id, microgridgrid, headers, function (response) {
  				if (angular.isDefined(response.status) && response.status === 201) {
  					toaster.pop({
  						type: "success",
  						title: $translate.instant("TOASTER.SUCCESS_TITLE"),
  						body: $translate.instant("TOASTER.SUCCESS_ADD_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
  						showCloseButton: true,
  					});
  					$scope.getMicrogridGridsByMicrogridID($scope.currentMicrogrid.id);
  					$scope.getDataSourcesByMicrogridID($scope.currentMicrogrid.id);
                    $scope.getDataSourcePointsByMicrogridID($scope.currentMicrogrid.id);
            		$scope.$emit('handleEmitMicrogridGridChanged');
  				} else {
  					toaster.pop({
  						type: "error",
  						title: $translate.instant("TOASTER.ERROR_ADD_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
  						body: $translate.instant(response.data.description),
  						showCloseButton: true,
  					});
  				}
  			});
  		}, function() {

  		});
		$rootScope.modalInstance = modalInstance;
  	};

  	$scope.editMicrogridGrid = function(microgridgrid) {
  		var modalInstance = $uibModal.open({
  			templateUrl: 'views/settings/microgrid/microgridgrid.model.html',
  			controller: 'ModalEditMicrogridGridCtrl',
    		windowClass: "animated fadeIn",
  			resolve: {
  				params: function() {
  					return {
  						microgridgrid: angular.copy(microgridgrid),
						meters: angular.copy($scope.meters),
						points: angular.copy($scope.points),
  					};
  				}
  			}
  		});

  		modalInstance.result.then(function(modifiedMicrogridGrid) {
			modifiedMicrogridGrid.power_point_id = modifiedMicrogridGrid.power_point.id;
			modifiedMicrogridGrid.buy_meter_id = modifiedMicrogridGrid.buy_meter.id;
			modifiedMicrogridGrid.sell_meter_id = modifiedMicrogridGrid.sell_meter.id;
			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
  			MicrogridGridService.editMicrogridGrid($scope.currentMicrogrid.id, modifiedMicrogridGrid, headers, function (response) {
  				if (angular.isDefined(response.status) && response.status === 200) {
  					toaster.pop({
  						type: "success",
  						title: $translate.instant("TOASTER.SUCCESS_TITLE"),
  						body: $translate.instant("TOASTER.SUCCESS_UPDATE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
  						showCloseButton: true,
  					});
  					$scope.getMicrogridGridsByMicrogridID($scope.currentMicrogrid.id);
  					$scope.getDataSourcesByMicrogridID($scope.currentMicrogrid.id);
                    $scope.getDataSourcePointsByMicrogridID($scope.currentMicrogrid.id);
            		$scope.$emit('handleEmitMicrogridGridChanged');
  				} else {
  					toaster.pop({
  						type: "error",
  						title: $translate.instant("TOASTER.ERROR_UPDATE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
  						body: $translate.instant(response.data.description),
  						showCloseButton: true,
  					});
  				}
  			});
  		}, function() {
  			//do nothing;
  		});
		$rootScope.modalInstance = modalInstance;
  	};

  	$scope.deleteMicrogridGrid = function(microgridgrid) {
  		SweetAlert.swal({
  				title: $translate.instant("SWEET.TITLE"),
  				text: $translate.instant("SWEET.TEXT"),
  				type: "warning",
  				showCancelButton: true,
  				confirmButtonColor: "#DD6B55",
  				confirmButtonText: $translate.instant("SWEET.CONFIRM_BUTTON_TEXT"),
  				cancelButtonText: $translate.instant("SWEET.CANCEL_BUTTON_TEXT"),
  				closeOnConfirm: true,
  				closeOnCancel: true
  			},
  			function(isConfirm) {
  				if (isConfirm) {
					let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
  					MicrogridGridService.deleteMicrogridGrid($scope.currentMicrogrid.id, microgridgrid.id, headers, function (response) {
  						if (angular.isDefined(response.status) && response.status === 204) {
							toaster.pop({
								type: "success",
								title: $translate.instant("TOASTER.SUCCESS_TITLE"),
								body: $translate.instant("TOASTER.SUCCESS_DELETE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
								showCloseButton: true,
							});
							$scope.getMicrogridGridsByMicrogridID($scope.currentMicrogrid.id);
							$scope.$emit('handleEmitMicrogridGridChanged');
  						} else {
							toaster.pop({
								type: "error",
								title: $translate.instant("TOASTER.ERROR_DELETE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
								body: $translate.instant(response.data.description),
								showCloseButton: true,
							});
  				   		}
  					});
  				}
  			});
  	};

    $scope.bindMicrogridGridPoint = function (grid) {
      var modalInstance = $uibModal.open({
        templateUrl:
          "views/settings/microgrid/microgridgridpoint.model.html",
        controller: "ModalBindMicrogridGridCtrl",
        windowClass: "animated fadeIn",
        resolve: {
          params: function () {
            return {
              user_uuid: $scope.cur_user.uuid,
              token: $scope.cur_user.token,
              microgridid: $scope.currentMicrogrid.id,
              microgridgrid: angular.copy(grid),
              meters: angular.copy($scope.meters),
              datasources: angular.copy($scope.datasources),
              points: angular.copy($scope.points),
            };
          },
        },
      });
      $rootScope.modalInstance = modalInstance;
    };

  	$scope.getAllMicrogrids();
	$scope.getAllMeters();
    $scope.$on('handleBroadcastMicrogridChanged', function(event) {
      $scope.getAllMicrogrids();
  	});

  });


  app.controller('ModalAddMicrogridGridCtrl', function($scope, $uibModalInstance, params) {

  	$scope.operation = "MICROGRID.ADD_MICROGRID_GRID";
	$scope.points=params.points;
	$scope.meters=params.meters;
  	$scope.ok = function() {
  		$uibModalInstance.close($scope.microgridgrid);
  	};

  	$scope.cancel = function() {
  		$uibModalInstance.dismiss('cancel');
  	};
  });

  app.controller('ModalEditMicrogridGridCtrl', function($scope, $uibModalInstance, params) {
  	$scope.operation = "MICROGRID.EDIT_MICROGRID_GRID";
  	$scope.microgridgrid = params.microgridgrid;
	$scope.points=params.points;
	$scope.meters=params.meters;
  	$scope.ok = function() {
  		$uibModalInstance.close($scope.microgridgrid);
  	};

  	$scope.cancel = function() {
  		$uibModalInstance.dismiss('cancel');
  	};
  });

  app.controller(
  "ModalBindMicrogridGridCtrl",
  function (
    $scope,
    $uibModalInstance,
    toaster,
    $translate,
    MicrogridGridService,
    PointService,
    params
  ) {
    $scope.operation = "MICROGRID.MICROGRID_GRID";
    $scope.microgridid = params.microgridid;
    $scope.microgridgrid = params.microgridgrid;
    $scope.datasources = params.datasources;
    $scope.boundpoints = [];

    let headers = { "User-UUID": params.user_uuid, Token: params.token };
    MicrogridGridService.getPointsByGridID(
      $scope.microgridid,
      $scope.microgridgrid.id,
      headers,
      function (response) {
        if (angular.isDefined(response.status) && response.status === 200) {
          $scope.boundpoints = response.data;
        } else {
          $scope.boundpoints = [];
        }
      }
    );

    $scope.cancel = function () {
      $uibModalInstance.dismiss("cancel");
    };

    $scope.changeDataSource = function (item, model) {
      $scope.currentDataSource = model;
      $scope.getPointsByDataSourceID($scope.currentDataSource);
    };

    $scope.getPointsByDataSourceID = function (id) {
      let headers = { "User-UUID": params.user_uuid, Token: params.token };
      PointService.getPointsByDataSourceID(id, headers, function (response) {
        if (angular.isDefined(response.status) && response.status === 200) {
          $scope.points = response.data;
        } else {
          $scope.points = [];
        }
      });
    };

    $scope.pairPoint = function (dragEl, dropEl) {
      var pointid = angular.element("#" + dragEl).scope().point.id;
      let headers = { "User-UUID": params.user_uuid, Token: params.token };
      MicrogridGridService.addGridPair(
        params.microgridid,
        params.microgridgrid.id,
        pointid,
        headers,
        function (response) {
          if (angular.isDefined(response.status) && response.status === 201) {
            toaster.pop({
              type: "success",
              title: $translate.instant("TOASTER.SUCCESS_TITLE"),
              body: $translate.instant("TOASTER.BIND_POINT_SUCCESS"),
              showCloseButton: true,
            });
            let headers = {
              "User-UUID": params.user_uuid,
              Token: params.token,
            };
            MicrogridGridService.getPointsByGridID(
              params.microgridid,
              params.microgridgrid.id,
              headers,
              function (response) {
                if (
                  angular.isDefined(response.status) &&
                  response.status === 200
                ) {
                  $scope.boundpoints = response.data;
                } else {
                  $scope.boundpoints = [];
                }
              }
            );
          } else {
            toaster.pop({
              type: "error",
              title: $translate.instant(response.data.title),
              body: $translate.instant(response.data.description),
              showCloseButton: true,
            });
          }
        }
      );
    };

    $scope.deletePointPair = function (dragEl, dropEl) {
      if (angular.isDefined(dragEl) && angular.element("#" + dragEl).hasClass("source")) {
        return;
      }

      var pointid = angular.element("#" + dragEl).scope().boundpoint.id;
      let headers = { "User-UUID": params.user_uuid, Token: params.token };
      MicrogridGridService.deleteGridPair(
        params.microgridid,
        params.microgridgrid.id,
        pointid,
        headers,
        function (response) {
          if (angular.isDefined(response.status) && response.status === 204) {
            toaster.pop({
              type: "success",
              title: $translate.instant("TOASTER.SUCCESS_TITLE"),
              body: $translate.instant("TOASTER.UNBIND_POINT_SUCCESS"),
              showCloseButton: true,
            });
            let headers = {
              "User-UUID": params.user_uuid,
              Token: params.token,
            };
            MicrogridGridService.getPointsByGridID(
              params.microgridid,
              params.microgridgrid.id,
              headers,
              function (response) {
                if (
                  angular.isDefined(response.status) &&
                  response.status === 200
                ) {
                  $scope.boundpoints = response.data;
                } else {
                  $scope.boundpoints = [];
                }
              }
            );
          } else {
            toaster.pop({
              type: "error",
              title: $translate.instant(response.data.title),
              body: $translate.instant(response.data.description),
              showCloseButton: true,
            });
          }
        }
      );
    };
  }
);


1			'use strict';
2
3			app.controller('MicrogridGridController', function(
4			$scope,
5			$rootScope,
6			$window,
7			$translate,
8			$uibModal,
9			MicrogridService,
10			MicrogridGridService,
11			MicrogridDataSourceService,
12			PointService,
13			MeterService,
14			toaster,
15			SweetAlert) {
16			$scope.microgrids = [];
17			$scope.microgridgrids = [];
18			$scope.points = [];
19			$scope.meters = [];
20			$scope.currentMicrogrid = null;
21			$scope.cur_user = JSON.parse($window.localStorage.getItem("myems_admin_ui_current_user"));
22			$scope.getAllMicrogrids = function() {
23			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
24			MicrogridService.getAllMicrogrids(headers, function (response) {
25			if (angular.isDefined(response.status) && response.status === 200) {
26			$scope.microgrids = response.data;
27			} else {
28			$scope.microgrids = [];
29			}
30			});
31			};
32
33			$scope.getDataSourcesByMicrogridID = function(id) {
34			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
35			MicrogridDataSourceService.getDataSourcesByMicrogridID(id, headers, function(response) {
36			if (angular.isDefined(response.status) && response.status === 200) {
37			$scope.datasources = response.data;
38			} else {
39			$scope.datasources = [];
40			}
41			});
42			};
43
44			$scope.getDataSourcePointsByMicrogridID = function(id) {
45			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
46			MicrogridDataSourceService.getDataSourcePointsByMicrogridID(id, headers, function(response) {
47			if (angular.isDefined(response.status) && response.status === 200) {
48			$scope.points = response.data;
49			} else {
50			$scope.points = [];
51			}
52			});
53			};
54
55			$scope.getAllMeters = function() {
56			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
57			MeterService.getAllMeters(headers, function (response) {
58			if (angular.isDefined(response.status) && response.status === 200) {
59			$scope.meters = response.data;
60			} else {
61			$scope.meters = [];
62			}
63			});
64			};
65			$scope.getMicrogridGridsByMicrogridID = function(id) {
66			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
67			MicrogridGridService.getMicrogridGridsByMicrogridID(id, headers, function (response) {
68			if (angular.isDefined(response.status) && response.status === 200) {
69			$scope.microgridgrids = response.data;
70			} else {
71			$scope.microgridgrids=[];
72			}
73			});
74			};
75
76			$scope.changeMicrogrid=function(item,model){
77			$scope.currentMicrogrid=item;
78			$scope.currentMicrogrid.selected=model;
79			$scope.is_show_add_microgrid_grid = true;
80			$scope.getMicrogridGridsByMicrogridID($scope.currentMicrogrid.id);
81			$scope.getDataSourcesByMicrogridID($scope.currentMicrogrid.id);
82			$scope.getDataSourcePointsByMicrogridID($scope.currentMicrogrid.id);
83			};
84
85			$scope.addMicrogridGrid = function() {
86
87			var modalInstance = $uibModal.open({
88			templateUrl: 'views/settings/microgrid/microgridgrid.model.html',
89			controller: 'ModalAddMicrogridGridCtrl',
90			windowClass: "animated fadeIn",
91			resolve: {
92			params: function() {
93			return {
94			meters: angular.copy($scope.meters),
95			points: angular.copy($scope.points),
96			};
97			}
98			}
99			});
100			modalInstance.result.then(function(microgridgrid) {
101			microgridgrid.power_point_id = microgridgrid.power_point.id;
102			microgridgrid.buy_meter_id = microgridgrid.buy_meter.id;
103			microgridgrid.sell_meter_id = microgridgrid.sell_meter.id;
104			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
105			MicrogridGridService.addMicrogridGrid($scope.currentMicrogrid.id, microgridgrid, headers, function (response) {
106			if (angular.isDefined(response.status) && response.status === 201) {
107			toaster.pop({
108			type: "success",
109			title: $translate.instant("TOASTER.SUCCESS_TITLE"),
110			body: $translate.instant("TOASTER.SUCCESS_ADD_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
111			showCloseButton: true,
112			});
113			$scope.getMicrogridGridsByMicrogridID($scope.currentMicrogrid.id);
114			$scope.getDataSourcesByMicrogridID($scope.currentMicrogrid.id);
115			$scope.getDataSourcePointsByMicrogridID($scope.currentMicrogrid.id);
116			$scope.$emit('handleEmitMicrogridGridChanged');
117			} else {
118			toaster.pop({
119			type: "error",
120			title: $translate.instant("TOASTER.ERROR_ADD_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
121			body: $translate.instant(response.data.description),
122			showCloseButton: true,
123			});
124			}
125			});
126			}, function() {
127
128			});
129			$rootScope.modalInstance = modalInstance;
130			};
131
132			$scope.editMicrogridGrid = function(microgridgrid) {
133			var modalInstance = $uibModal.open({
134			templateUrl: 'views/settings/microgrid/microgridgrid.model.html',
135			controller: 'ModalEditMicrogridGridCtrl',
136			windowClass: "animated fadeIn",
137			resolve: {
138			params: function() {
139			return {
140			microgridgrid: angular.copy(microgridgrid),
141			meters: angular.copy($scope.meters),
142			points: angular.copy($scope.points),
143			};
144			}
145			}
146			});
147
148			modalInstance.result.then(function(modifiedMicrogridGrid) {
149			modifiedMicrogridGrid.power_point_id = modifiedMicrogridGrid.power_point.id;
150			modifiedMicrogridGrid.buy_meter_id = modifiedMicrogridGrid.buy_meter.id;
151			modifiedMicrogridGrid.sell_meter_id = modifiedMicrogridGrid.sell_meter.id;
152			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
153			MicrogridGridService.editMicrogridGrid($scope.currentMicrogrid.id, modifiedMicrogridGrid, headers, function (response) {
154			if (angular.isDefined(response.status) && response.status === 200) {
155			toaster.pop({
156			type: "success",
157			title: $translate.instant("TOASTER.SUCCESS_TITLE"),
158			body: $translate.instant("TOASTER.SUCCESS_UPDATE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
159			showCloseButton: true,
160			});
161			$scope.getMicrogridGridsByMicrogridID($scope.currentMicrogrid.id);
162			$scope.getDataSourcesByMicrogridID($scope.currentMicrogrid.id);
163			$scope.getDataSourcePointsByMicrogridID($scope.currentMicrogrid.id);
164			$scope.$emit('handleEmitMicrogridGridChanged');
165			} else {
166			toaster.pop({
167			type: "error",
168			title: $translate.instant("TOASTER.ERROR_UPDATE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
169			body: $translate.instant(response.data.description),
170			showCloseButton: true,
171			});
172			}
173			});
174			}, function() {
175			//do nothing;
176			});
177			$rootScope.modalInstance = modalInstance;
178			};
179
180			$scope.deleteMicrogridGrid = function(microgridgrid) {
181			SweetAlert.swal({
182			title: $translate.instant("SWEET.TITLE"),
183			text: $translate.instant("SWEET.TEXT"),
184			type: "warning",
185			showCancelButton: true,
186			confirmButtonColor: "#DD6B55",
187			confirmButtonText: $translate.instant("SWEET.CONFIRM_BUTTON_TEXT"),
188			cancelButtonText: $translate.instant("SWEET.CANCEL_BUTTON_TEXT"),
189			closeOnConfirm: true,
190			closeOnCancel: true
191			},
192			function(isConfirm) {
193			if (isConfirm) {
194			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
195			MicrogridGridService.deleteMicrogridGrid($scope.currentMicrogrid.id, microgridgrid.id, headers, function (response) {
196			if (angular.isDefined(response.status) && response.status === 204) {
197			toaster.pop({
198			type: "success",
199			title: $translate.instant("TOASTER.SUCCESS_TITLE"),
200			body: $translate.instant("TOASTER.SUCCESS_DELETE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
201			showCloseButton: true,
202			});
203			$scope.getMicrogridGridsByMicrogridID($scope.currentMicrogrid.id);
204			$scope.$emit('handleEmitMicrogridGridChanged');
205			} else {
206			toaster.pop({
207			type: "error",
208			title: $translate.instant("TOASTER.ERROR_DELETE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_GRID")}),
209			body: $translate.instant(response.data.description),
210			showCloseButton: true,
211			});
212			}
213			});
214			}
215			});
216			};
217
218			$scope.bindMicrogridGridPoint = function (grid) {
219			var modalInstance = $uibModal.open({
220			templateUrl:
221			"views/settings/microgrid/microgridgridpoint.model.html",
222			controller: "ModalBindMicrogridGridCtrl",
223			windowClass: "animated fadeIn",
224			resolve: {
225			params: function () {
226			return {
227			user_uuid: $scope.cur_user.uuid,
228			token: $scope.cur_user.token,
229			microgridid: $scope.currentMicrogrid.id,
230			microgridgrid: angular.copy(grid),
231			meters: angular.copy($scope.meters),
232			datasources: angular.copy($scope.datasources),
233			points: angular.copy($scope.points),
234			};
235			},
236			},
237			});
238			$rootScope.modalInstance = modalInstance;
239			};
240
241			$scope.getAllMicrogrids();
242			$scope.getAllMeters();
243			$scope.$on('handleBroadcastMicrogridChanged', function(event) {
244			$scope.getAllMicrogrids();
245			});
246
247			});
248
249
250			app.controller('ModalAddMicrogridGridCtrl', function($scope, $uibModalInstance, params) {
251
252			$scope.operation = "MICROGRID.ADD_MICROGRID_GRID";
253			$scope.points=params.points;
254			$scope.meters=params.meters;
255			$scope.ok = function() {
256			$uibModalInstance.close($scope.microgridgrid);
257			};
258
259			$scope.cancel = function() {
260			$uibModalInstance.dismiss('cancel');
261			};
262			});
263
264			app.controller('ModalEditMicrogridGridCtrl', function($scope, $uibModalInstance, params) {
265			$scope.operation = "MICROGRID.EDIT_MICROGRID_GRID";
266			$scope.microgridgrid = params.microgridgrid;
267			$scope.points=params.points;
268			$scope.meters=params.meters;
269			$scope.ok = function() {
270			$uibModalInstance.close($scope.microgridgrid);
271			};
272
273			$scope.cancel = function() {
274			$uibModalInstance.dismiss('cancel');
275			};
276			});
277
278			app.controller(
279			"ModalBindMicrogridGridCtrl",
280			function (
281			$scope,
282			$uibModalInstance,
283			toaster,
284			$translate,
285			MicrogridGridService,
286			PointService,
287			params
288			) {
289			$scope.operation = "MICROGRID.MICROGRID_GRID";
290			$scope.microgridid = params.microgridid;
291			$scope.microgridgrid = params.microgridgrid;
292			$scope.datasources = params.datasources;
293			$scope.boundpoints = [];
294
295			let headers = { "User-UUID": params.user_uuid, Token: params.token };
296			MicrogridGridService.getPointsByGridID(
297			$scope.microgridid,
298			$scope.microgridgrid.id,
299			headers,
300			function (response) {
301			if (angular.isDefined(response.status) && response.status === 200) {
302			$scope.boundpoints = response.data;
303			} else {
304			$scope.boundpoints = [];
305			}
306			}
307			);
308
309			$scope.cancel = function () {
310			$uibModalInstance.dismiss("cancel");
311			};
312
313			$scope.changeDataSource = function (item, model) {
314			$scope.currentDataSource = model;
315			$scope.getPointsByDataSourceID($scope.currentDataSource);
316			};
317
318			$scope.getPointsByDataSourceID = function (id) {
319			let headers = { "User-UUID": params.user_uuid, Token: params.token };
320			PointService.getPointsByDataSourceID(id, headers, function (response) {
321			if (angular.isDefined(response.status) && response.status === 200) {
322			$scope.points = response.data;
323			} else {
324			$scope.points = [];
325			}
326			});
327			};
328
329			$scope.pairPoint = function (dragEl, dropEl) {
330			var pointid = angular.element("#" + dragEl).scope().point.id;
331			let headers = { "User-UUID": params.user_uuid, Token: params.token };
332			MicrogridGridService.addGridPair(
333			params.microgridid,
334			params.microgridgrid.id,
335			pointid,
336			headers,
337			function (response) {
338			if (angular.isDefined(response.status) && response.status === 201) {
339			toaster.pop({
340			type: "success",
341			title: $translate.instant("TOASTER.SUCCESS_TITLE"),
342			body: $translate.instant("TOASTER.BIND_POINT_SUCCESS"),
343			showCloseButton: true,
344			});
345			let headers = {
346			"User-UUID": params.user_uuid,
347			Token: params.token,
348			};
349			MicrogridGridService.getPointsByGridID(
350			params.microgridid,
351			params.microgridgrid.id,
352			headers,
353			function (response) {
354			if (
355			angular.isDefined(response.status) &&
356			response.status === 200
357			) {
358			$scope.boundpoints = response.data;
359			} else {
360			$scope.boundpoints = [];
361			}
362			}
363			);
364			} else {
365			toaster.pop({
366			type: "error",
367			title: $translate.instant(response.data.title),
368			body: $translate.instant(response.data.description),
369			showCloseButton: true,
370			});
371			}
372			}
373			);
374			};
375
376			$scope.deletePointPair = function (dragEl, dropEl) {
377			if (angular.isDefined(dragEl) && angular.element("#" + dragEl).hasClass("source")) {
378			return;
379			}
380
381			var pointid = angular.element("#" + dragEl).scope().boundpoint.id;
382			let headers = { "User-UUID": params.user_uuid, Token: params.token };
383			MicrogridGridService.deleteGridPair(
384			params.microgridid,
385			params.microgridgrid.id,
386			pointid,
387			headers,
388			function (response) {
389			if (angular.isDefined(response.status) && response.status === 204) {
390			toaster.pop({
391			type: "success",
392			title: $translate.instant("TOASTER.SUCCESS_TITLE"),
393			body: $translate.instant("TOASTER.UNBIND_POINT_SUCCESS"),
394			showCloseButton: true,
395			});
396			let headers = {
397			"User-UUID": params.user_uuid,
398			Token: params.token,
399			};
400			MicrogridGridService.getPointsByGridID(
401			params.microgridid,
402			params.microgridgrid.id,
403			headers,
404			function (response) {
405			if (
406			angular.isDefined(response.status) &&
407			response.status === 200
408			) {
409			$scope.boundpoints = response.data;
410			} else {
411			$scope.boundpoints = [];
412			}
413			}
414			);
415			} else {
416			toaster.pop({
417			type: "error",
418			title: $translate.instant(response.data.title),
419			body: $translate.instant(response.data.description),
420			showCloseButton: true,
421			});
422			}
423			}
424			);
425			};
426			}
427			);
428

MyEMS / myems

Push — master ( 0609f7...f69d02 )

myems-admin/app/controllers/settings/microgrid/microgridgrid.controller.js F

Complexity

Size

Duplication

Importance

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like