myems-admin/app/controllers/settings/microgrid/microgridpowerconversionsystem.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/microgridpowerconversionsystem.controller.js F

↳ Parent: Project

Complexity

Total Complexity	65
Complexity/F	1.35

Size

Lines of Code	450
Function Count	48

Duplication

Duplicated Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
wmc	65
eloc	326
dl	0
loc	450
rs	3.2
c	0
b	0
f	0
mnd	17
bc	17
fnc	48
bpm	0.3541
cpm	1.3541
noi	0

How to fix Complexity

'use strict';

app.controller('MicrogridPowerconversionsystemController', function(
	$scope,
	$rootScope,
	$window,
	$translate,
	$uibModal,
	MicrogridService,
	MicrogridPowerconversionsystemService,
	MicrogridDataSourceService,
	PointService,
	MeterService,
	CommandService,
	toaster,
	SweetAlert) {
      $scope.microgrids = [];
      $scope.microgridpowerconversionsystems = [];
	  $scope.meters = [];
	  $scope.points = [];
	  $scope.commands = [];
      $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.getAllCommands = function() {
		let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
		CommandService.getAllCommands(headers, function (response) {
			if (angular.isDefined(response.status) && response.status === 200) {
				$scope.commands = response.data;
			} else {
				$scope.commands = [];
			}
		});
	};
  	$scope.getMicrogridPowerconversionsystemsByMicrogridID = function(id) {
		let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
  		MicrogridPowerconversionsystemService.getMicrogridPowerconversionsystemsByMicrogridID(id, headers, function (response) {
			if (angular.isDefined(response.status) && response.status === 200) {
				$scope.microgridpowerconversionsystems = response.data;
			} else {
          		$scope.microgridpowerconversionsystems=[];
        	}
		});
  	};

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

  	$scope.addMicrogridPowerconversionsystem = function() {

  		var modalInstance = $uibModal.open({
  			templateUrl: 'views/settings/microgrid/microgridpowerconversionsystem.model.html',
  			controller: 'ModalAddMicrogridPowerconversionsystemCtrl',
  			windowClass: "animated fadeIn",
  			resolve: {
  				params: function() {
  					return {
						meters: angular.copy($scope.meters),
						points: angular.copy($scope.points),
						commands: angular.copy($scope.commands),
  					};
  				}
  			}
  		});
  		modalInstance.result.then(function(microgridpowerconversionsystem) {
			microgridpowerconversionsystem.run_state_point_id = microgridpowerconversionsystem.run_state_point.id;
			microgridpowerconversionsystem.today_charge_energy_point_id = microgridpowerconversionsystem.today_charge_energy_point.id;
			microgridpowerconversionsystem.today_discharge_energy_point_id = microgridpowerconversionsystem.today_discharge_energy_point.id;
			microgridpowerconversionsystem.total_charge_energy_point_id = microgridpowerconversionsystem.total_charge_energy_point.id;
			microgridpowerconversionsystem.total_discharge_energy_point_id = microgridpowerconversionsystem.total_discharge_energy_point.id;

			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
  			MicrogridPowerconversionsystemService.addMicrogridPowerconversionsystem($scope.currentMicrogrid.id, microgridpowerconversionsystem, 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_POWER_CONVERSION_SYSTEM")}),
  						showCloseButton: true,
  					});
  					$scope.getMicrogridPowerconversionsystemsByMicrogridID($scope.currentMicrogrid.id);
  					$scope.getDataSourcesByMicrogridID($scope.currentMicrogrid.id);
                    $scope.getDataSourcePointsByMicrogridID($scope.currentMicrogrid.id);
            		$scope.$emit('handleEmitMicrogridPowerconversionsystemChanged');
  				} else {
  					toaster.pop({
  						type: "error",
  						title: $translate.instant("TOASTER.ERROR_ADD_BODY", {template: $translate.instant("MICROGRID.MICROGRID_POWER_CONVERSION_SYSTEM")}),
  						body: $translate.instant(response.data.description),
  						showCloseButton: true,
  					});
  				}
  			});
  		}, function() {

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

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

  		modalInstance.result.then(function(modifiedMicrogridPowerconversionsystem) {
			modifiedMicrogridPowerconversionsystem.run_state_point_id = modifiedMicrogridPowerconversionsystem.run_state_point.id;
			modifiedMicrogridPowerconversionsystem.today_charge_energy_point_id = modifiedMicrogridPowerconversionsystem.today_charge_energy_point.id;
			modifiedMicrogridPowerconversionsystem.today_discharge_energy_point_id = modifiedMicrogridPowerconversionsystem.today_discharge_energy_point.id;
			modifiedMicrogridPowerconversionsystem.total_charge_energy_point_id = modifiedMicrogridPowerconversionsystem.total_charge_energy_point.id;
			modifiedMicrogridPowerconversionsystem.total_discharge_energy_point_id = modifiedMicrogridPowerconversionsystem.total_discharge_energy_point.id;

			let headers = { "User-UUID": $scope.cur_user.uuid, "Token": $scope.cur_user.token };
  			MicrogridPowerconversionsystemService.editMicrogridPowerconversionsystem($scope.currentMicrogrid.id, modifiedMicrogridPowerconversionsystem, 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_POWER_CONVERSION_SYSTEM")}),
  						showCloseButton: true,
  					});
  					$scope.getMicrogridPowerconversionsystemsByMicrogridID($scope.currentMicrogrid.id);
  					$scope.getDataSourcesByMicrogridID($scope.currentMicrogrid.id);
                    $scope.getDataSourcePointsByMicrogridID($scope.currentMicrogrid.id);
            		$scope.$emit('handleEmitMicrogridPowerconversionsystemChanged');
  				} else {
  					toaster.pop({
  						type: "error",
  						title: $translate.instant("TOASTER.ERROR_UPDATE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_POWER_CONVERSION_SYSTEM")}),
  						body: $translate.instant(response.data.description),
  						showCloseButton: true,
  					});
  				}
  			});
  		}, function() {
  			//do nothing;
  		});
		$rootScope.modalInstance = modalInstance;
  	};

  	$scope.deleteMicrogridPowerconversionsystem = function(microgridpowerconversionsystem) {
  		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 };
  					MicrogridPowerconversionsystemService.deleteMicrogridPowerconversionsystem($scope.currentMicrogrid.id, microgridpowerconversionsystem.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_POWER_CONVERSION_SYSTEM")}),
								showCloseButton: true,
							});
							$scope.getMicrogridPowerconversionsystemsByMicrogridID($scope.currentMicrogrid.id);
							$scope.$emit('handleEmitMicrogridPowerconversionsystemChanged');
  						} else {
							toaster.pop({
								type: "error",
								title: $translate.instant("TOASTER.ERROR_DELETE_BODY", {template: $translate.instant("MICROGRID.MICROGRID_POWER_CONVERSION_SYSTEM")}),
								body: $translate.instant(response.data.description),
								showCloseButton: true,
							});
  				   		}
  					});
  				}
  			});
  	};

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

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


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

  	$scope.operation = "MICROGRID.ADD_MICROGRID_POWER_CONVERSION_SYSTEM";
	$scope.points=params.points;
	$scope.meters=params.meters;
	$scope.commands=params.commands;
  	$scope.ok = function() {
  		$uibModalInstance.close($scope.microgridpowerconversionsystem);
  	};

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

  app.controller('ModalEditMicrogridPowerconversionsystemCtrl', function($scope, $uibModalInstance, params) {
  	$scope.operation = "MICROGRID.EDIT_MICROGRID_POWER_CONVERSION_SYSTEM";
  	$scope.microgridpowerconversionsystem = params.microgridpowerconversionsystem;
	$scope.points=params.points;
	$scope.meters=params.meters;
	$scope.commands=params.commands;
  	$scope.ok = function() {
  		$uibModalInstance.close($scope.microgridpowerconversionsystem);
  	};

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

  app.controller(
  "ModalBindMicrogridPowerConversionSystemCtrl",
  function (
    $scope,
    $uibModalInstance,
    toaster,
    $translate,
    MicrogridPowerconversionsystemService,
    PointService,
    params
  ) {
    $scope.operation = "MICROGRID.MICROGRID_POWER_CONVERSION_SYSTEM";
    $scope.microgridid = params.microgridid;
    $scope.microgridpowerconversionsystem = params.microgridpowerconversionsystem;
    $scope.datasources = params.datasources;
    $scope.boundpoints = [];

    let headers = { "User-UUID": params.user_uuid, Token: params.token };
    MicrogridPowerconversionsystemService.getPointsByPowerConversionSystemID(
      $scope.microgridid,
      $scope.microgridpowerconversionsystem.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 };
      MicrogridPowerconversionsystemService.addPowerConversionSystemPair(
        params.microgridid,
        params.microgridpowerconversionsystem.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,
            };
            MicrogridPowerconversionsystemService.getPointsByPowerConversionSystemID(
              params.microgridid,
              params.microgridpowerconversionsystem.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.element("#" + dragEl).hasClass("source")) {
        return;
      }

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

MyEMS / myems

Push — master ( 0609f7...f69d02 )

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

Complexity

Size

Duplication

Importance

How to fix Complexity

Complexity

Duplication Side-by-Side

Filter issues like