refactor(templates): refactor controller code and create required services (#580)

app/services/containerService.js

@@ -0,0 +1,71 @@
+angular.module('portainer.services')
+.factory('ContainerService', ['$q', 'Container', 'ContainerHelper', function ContainerServiceFactory($q, Container, ContainerHelper) {
+  'use strict';
+  var service = {};
+
+  service.getContainers = function (all, hiddenLabels) {
+    var deferred = $q.defer();
+    Container.query({ all: all }).$promise
+    .then(function success(data) {
+      var containers = data;
+      if (hiddenLabels) {
+        containers = ContainerHelper.hideContainers(d, hiddenLabels);
+      }
+      deferred.resolve(data);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retriever containers', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.createContainer = function(configuration) {
+    var deferred = $q.defer();
+    Container.create(configuration).$promise
+    .then(function success(data) {
+      if (data.message) {
+        deferred.reject({ msg: data.message });
+      } else {
+        deferred.resolve(data);
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to create container', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.startContainer = function(containerID) {
+    var deferred = $q.defer();
+    Container.start({ id: containerID }, {}).$promise
+    .then(function success(data) {
+      if (data.message) {
+        deferred.reject({ msg: data.message });
+      } else {
+        deferred.resolve(data);
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to start container', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.createAndStartContainer = function(configuration) {
+    var deferred = $q.defer();
+    var containerID;
+    service.createContainer(configuration)
+    .then(function success(data) {
+      containerID = data.Id;
+      return service.startContainer(containerID);
+    })
+    .then(function success() {
+      deferred.resolve({ Id: containerID });
+    })
+    .catch(function error(err) {
+      deferred.reject(err);
+    });
+    return deferred.promise;
+  };
+  return service;
+}]);

app/services/imageService.js

@@ -0,0 +1,24 @@
+angular.module('portainer.services')
+.factory('ImageService', ['$q', 'Image', function ImageServiceFactory($q, Image) {
+  'use strict';
+  var service = {};
+
+  service.pullImage = function(imageConfiguration) {
+    var deferred = $q.defer();
+    Image.create(imageConfiguration).$promise
+    .then(function success(data) {
+      var err = data.length > 0 && data[data.length - 1].hasOwnProperty('error');
+      if (err) {
+        var detail = data[data.length - 1];
+        deferred.reject({ msg: detail.error });
+      } else {
+        deferred.resolve(data);
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to pull image', err: err });
+    });
+    return deferred.promise;
+  };
+  return service;
+}]);

app/services/networkService.js

@@ -0,0 +1,25 @@
+angular.module('portainer.services')
+.factory('NetworkService', ['$q', 'Network', function NetworkServiceFactory($q, Network) {
+  'use strict';
+  var service = {};
+
+  service.getNetworks = function() {
+    return Network.query({}).$promise;
+  };
+
+  service.filterGlobalNetworks = function(networks) {
+    return networks.filter(function (network) {
+      if (network.Scope === 'global') {
+        return network;
+      }
+    });
+  };
+
+  service.addPredefinedLocalNetworks = function(networks) {
+    networks.push({Scope: "local", Name: "bridge"});
+    networks.push({Scope: "local", Name: "host"});
+    networks.push({Scope: "local", Name: "none"});
+  };
+
+  return service;
+}]);

app/services/templateService.js

@@ -0,0 +1,59 @@
+angular.module('portainer.services')
+.factory('TemplateService', ['$q', 'Template', 'TemplateHelper', 'ImageHelper', function TemplateServiceFactory($q, Template, TemplateHelper, ImageHelper) {
+  'use strict';
+  var service = {};
+
+  service.getTemplates = function() {
+    var deferred = $q.defer();
+    Template.get().$promise
+    .then(function success(data) {
+      var templates = data.map(function (tpl, idx) {
+        var template = new TemplateViewModel(tpl);
+        template.index = idx;
+        return template;
+      });
+      deferred.resolve(templates);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve templates', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.createTemplateConfiguration = function(template, containerName, network, containerMapping) {
+    var imageConfiguration = service.createImageConfiguration(template);
+    var containerConfiguration = service.createContainerConfiguration(template, containerName, network, containerMapping);
+    containerConfiguration.Image = imageConfiguration.fromImage + ':' + imageConfiguration.tag;
+    return {
+      container: containerConfiguration,
+      image: imageConfiguration
+    };
+  };
+
+  service.createImageConfiguration = function(template) {
+    return ImageHelper.createImageConfigForContainer(template.Image, template.Registry);
+  };
+
+  service.createContainerConfiguration = function(template, containerName, network, containerMapping) {
+    var configuration = TemplateHelper.getDefaultContainerConfiguration();
+    configuration.HostConfig.NetworkMode = network.Name;
+    configuration.name = containerName;
+    configuration.Image = template.Image;
+    if (template.Env) {
+      configuration.Env = TemplateHelper.EnvToStringArray(template.Env, containerMapping);
+    }
+    var portConfiguration = TemplateHelper.portArrayToPortConfiguration(template.Ports);
+    configuration.HostConfig.PortBindings = portConfiguration.bindings;
+    configuration.ExposedPorts = portConfiguration.exposedPorts;
+    return configuration;
+  };
+
+  service.updateContainerConfigurationWithVolumes = function(configuration, template, createdVolumes) {
+    createdVolumes.forEach(function (volume, idx) {
+      configuration.Volumes[template.Volumes[idx]] = {};
+      configuration.HostConfig.Binds.push(volume.Name + ':' + template.Volumes[idx]);
+    });
+  };
+
+  return service;
+}]);

app/services/volumeService.js

@@ -0,0 +1,59 @@
+angular.module('portainer.services')
+.factory('VolumeService', ['$q', 'Volume', function VolumeServiceFactory($q, Volume) {
+  'use strict';
+  var service = {};
+
+  function prepareVolumeQueries(template, containerConfig) {
+    var volumeQueries = [];
+    if (template.volumes) {
+      template.volumes.forEach(function (vol) {
+        volumeQueries.push(
+          Volume.create({}, function (d) {
+            if (d.message) {
+              Messages.error("Unable to create volume", {}, d.message);
+            } else {
+              Messages.send("Volume created", d.Name);
+              containerConfig.Volumes[vol] = {};
+              containerConfig.HostConfig.Binds.push(d.Name + ':' + vol);
+            }
+          }, function (e) {
+            Messages.error("Failure", e, "Unable to create volume");
+          }).$promise
+        );
+      });
+    }
+    return volumeQueries;
+  }
+
+  service.createVolume = function(volumeConfiguration) {
+    var deferred = $q.defer();
+    Volume.create(volumeConfiguration).$promise
+    .then(function success(data) {
+      if (data.message) {
+        deferred.reject({ msg: data.message });
+      } else {
+        deferred.resolve(data);
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to create volume', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.createVolumes = function(volumes) {
+    var createVolumeQueries = volumes.map(function(volume) {
+      return service.createVolume(volume);
+    });
+    return $q.all(createVolumeQueries);
+  };
+
+  service.createAutoGeneratedLocalVolumes = function (volumes) {
+    var createVolumeQueries = volumes.map(function(volume) {
+      return service.createVolume({});
+    });
+    return $q.all(createVolumeQueries);
+  };
+
+  return service;
+}]);