feat(settings): add settings management (#906)

app/services/docker/containerService.js

@@ -0,0 +1,91 @@
+angular.module('portainer.services')
+.factory('ContainerService', ['$q', 'Container', 'ResourceControlService', function ContainerServiceFactory($q, Container, ResourceControlService) {
+  'use strict';
+  var service = {};
+
+  service.getContainers = function (all) {
+    var deferred = $q.defer();
+    Container.query({ all: all }).$promise
+    .then(function success(data) {
+      var containers = data;
+      deferred.resolve(containers);
+    })
+    .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;
+  };
+
+  service.remove = function(container, removeVolumes) {
+    var deferred = $q.defer();
+
+    Container.remove({id: container.Id, v: (removeVolumes) ? 1 : 0, force: true}).$promise
+    .then(function success(data) {
+      if (data.message) {
+        deferred.reject({ msg: data.message, err: data.message });
+      }
+      if (container.ResourceControl && container.ResourceControl.Type === 1) {
+        return ResourceControlService.deleteResourceControl(container.ResourceControl.Id);
+      }
+    })
+    .then(function success() {
+      deferred.resolve();
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to remove container', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  return service;
+}]);

app/services/docker/imageService.js

@@ -0,0 +1,100 @@
+angular.module('portainer.services')
+.factory('ImageService', ['$q', 'Image', 'ImageHelper', function ImageServiceFactory($q, Image, ImageHelper) {
+  'use strict';
+  var service = {};
+
+  service.image = function(imageId) {
+    var deferred = $q.defer();
+    Image.get({id: imageId}).$promise
+    .then(function success(data) {
+      if (data.message) {
+        deferred.reject({ msg: data.message });
+      } else {
+        var image = new ImageDetailsViewModel(data);
+        deferred.resolve(image);
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve image details', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.images = function() {
+    var deferred = $q.defer();
+    Image.query({}).$promise
+    .then(function success(data) {
+      var images = data.map(function (item) {
+        return new ImageViewModel(item);
+      });
+      deferred.resolve(images);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve images', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.pullImage = function(image, registry) {
+    var deferred = $q.defer();
+    var imageConfiguration = ImageHelper.createImageConfigForContainer(image, registry);
+    Image.create(imageConfiguration).$promise
+    .then(function success(data) {
+      var err = data.length > 0 && data[data.length - 1].hasOwnProperty('message');
+      if (err) {
+        var detail = data[data.length - 1];
+        deferred.reject({ msg: detail.message });
+      } else {
+        deferred.resolve(data);
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to pull image', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.pullTag = function(tag) {
+    var imageAndRegistry = ImageHelper.extractImageAndRegistryFromTag(tag);
+    return service.pullImage(imageAndRegistry.image, imageAndRegistry.registry);
+  };
+
+  service.tagImage = function(id, image, registry) {
+    var imageConfig = ImageHelper.createImageConfigForCommit(image, registry);
+    return Image.tag({id: id, tag: imageConfig.tag, repo: imageConfig.repo}).$promise;
+  };
+
+  service.deleteImage = function(id, forceRemoval) {
+    var deferred = $q.defer();
+    Image.remove({id: id, force: forceRemoval}).$promise
+    .then(function success(data) {
+      if (data[0].message) {
+        deferred.reject({ msg: data[0].message });
+      } else {
+        deferred.resolve();
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to remove image', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.pushImage = function(tag) {
+    var deferred = $q.defer();
+    Image.push({tag: tag}).$promise
+    .then(function success(data) {
+      if (data[data.length - 1].error) {
+        deferred.reject({ msg: data[data.length - 1].error });
+      } else {
+        deferred.resolve();
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to push image tag', err: err });
+    });
+    return deferred.promise;
+  };
+
+  return service;
+}]);

app/services/docker/infoService.js

@@ -0,0 +1,20 @@
+angular.module('portainer.services')
+.factory('InfoService', ['$q', 'Info', function InfoServiceFactory($q, Info) {
+  'use strict';
+  var service = {};
+
+  service.getVolumePlugins = function() {
+    var deferred = $q.defer();
+    Info.get({}).$promise
+    .then(function success(data) {
+      var plugins = data.Plugins.Volume;
+      deferred.resolve(plugins);
+    })
+    .catch(function error(err) {
+      deferred.reject({msg: 'Unable to retrieve volume plugin information', err: err});
+    });
+    return deferred.promise;
+  };
+
+  return service;
+}]);

app/services/docker/networkService.js

@@ -0,0 +1,52 @@
+angular.module('portainer.services')
+.factory('NetworkService', ['$q', 'Network', function NetworkServiceFactory($q, Network) {
+  'use strict';
+  var service = {};
+
+  service.networks = function() {
+    return Network.query({}).$promise;
+  };
+
+  service.retrieveSwarmNetworks = function() {
+    var deferred = $q.defer();
+
+    service.networks()
+    .then(function success(data) {
+      var networks = data.filter(function (network) {
+        if (network.Scope === 'swarm') {
+          return network;
+        }
+      });
+      deferred.resolve(networks);
+    })
+    .catch(function error(err) {
+      deferred.reject({msg: 'Unable to retrieve networks', err: err});
+    });
+
+    return deferred.promise;
+  };
+
+  service.filterGlobalNetworks = function(networks) {
+    return networks.filter(function (network) {
+      if (network.Scope === 'global') {
+        return network;
+      }
+    });
+  };
+
+  service.filterSwarmModeAttachableNetworks = function(networks) {
+    return networks.filter(function (network) {
+      if (network.Scope === 'swarm' && network.Attachable === true) {
+        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/docker/nodeService.js

@@ -0,0 +1,24 @@
+angular.module('portainer.services')
+.factory('NodeService', ['$q', 'Node', function NodeServiceFactory($q, Node) {
+  'use strict';
+  var service = {};
+
+  service.nodes = function(id) {
+    var deferred = $q.defer();
+
+    Node.query({}).$promise
+    .then(function success(data) {
+      var nodes = data.map(function (item) {
+        return new NodeViewModel(item);
+      });
+      deferred.resolve(nodes);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve nodes', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  return service;
+}]);

app/services/docker/secretService.js

@@ -0,0 +1,47 @@
+angular.module('portainer.services')
+.factory('SecretService', ['$q', 'Secret', function SecretServiceFactory($q, Secret) {
+  'use strict';
+  var service = {};
+
+  service.secret = function(secretId) {
+    var deferred = $q.defer();
+
+    Secret.get({id: secretId}).$promise
+    .then(function success(data) {
+      var secret = new SecretViewModel(data);
+      deferred.resolve(secret);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve secret details', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  service.secrets = function() {
+    var deferred = $q.defer();
+
+    Secret.query({}).$promise
+    .then(function success(data) {
+      var secrets = data.map(function (item) {
+        return new SecretViewModel(item);
+      });
+      deferred.resolve(secrets);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve secrets', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  service.remove = function(secretId) {
+    return Secret.remove({ id: secretId }).$promise;
+  };
+
+  service.create = function(secretConfig) {
+    return Secret.create(secretConfig).$promise;
+  };
+
+  return service;
+}]);

app/services/docker/serviceService.js

@@ -0,0 +1,41 @@
+angular.module('portainer.services')
+.factory('ServiceService', ['$q', 'Service', 'ResourceControlService', function ServiceServiceFactory($q, Service, ResourceControlService) {
+  'use strict';
+  var service = {};
+
+  service.service = function(id) {
+    var deferred = $q.defer();
+
+    Service.get({ id: id }).$promise
+    .then(function success(data) {
+      var service = new ServiceViewModel(data);
+      deferred.resolve(service);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve service details', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  service.remove = function(service) {
+    var deferred = $q.defer();
+
+    Service.remove({id: service.Id}).$promise
+    .then(function success() {
+      if (service.ResourceControl && service.ResourceControl.Type === 2) {
+        return ResourceControlService.deleteResourceControl(service.ResourceControl.Id);
+      }
+    })
+    .then(function success() {
+      deferred.resolve();
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to remove service', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  return service;
+}]);

app/services/docker/taskService.js

@@ -0,0 +1,39 @@
+angular.module('portainer.services')
+.factory('TaskService', ['$q', 'Task', function TaskServiceFactory($q, Task) {
+  'use strict';
+  var service = {};
+
+  service.task = function(id) {
+    var deferred = $q.defer();
+
+    Task.get({ id: id }).$promise
+    .then(function success(data) {
+      var task = new TaskViewModel(data);
+      deferred.resolve(task);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve task details', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  service.serviceTasks = function(serviceName) {
+    var deferred = $q.defer();
+
+    Task.query({ filters: { service: [serviceName] } }).$promise
+    .then(function success(data) {
+      var tasks = data.map(function (item) {
+        return new TaskViewModel(item);
+      });
+      deferred.resolve(tasks);
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to retrieve tasks associated to the service', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  return service;
+}]);

app/services/docker/volumeService.js

@@ -0,0 +1,103 @@
+angular.module('portainer.services')
+.factory('VolumeService', ['$q', 'Volume', 'VolumeHelper', 'ResourceControlService', 'UserService', 'TeamService', function VolumeServiceFactory($q, Volume, VolumeHelper, ResourceControlService, UserService, TeamService) {
+  'use strict';
+  var service = {};
+
+  service.volumes = function() {
+    var deferred = $q.defer();
+    Volume.query().$promise
+    .then(function success(data) {
+      var volumes = data.Volumes || [];
+      volumes = volumes.map(function (item) {
+        return new VolumeViewModel(item);
+      });
+      deferred.resolve(volumes);
+    })
+    .catch(function error(err) {
+      deferred.reject({msg: 'Unable to retrieve volumes', err: err});
+    });
+    return deferred.promise;
+  };
+
+  service.volume = function(id) {
+    var deferred = $q.defer();
+    Volume.get({id: id}).$promise
+    .then(function success(data) {
+      var volume = new VolumeViewModel(data);
+      deferred.resolve(volume);
+    })
+    .catch(function error(err) {
+      deferred.reject({msg: 'Unable to retrieve volume details', err: err});
+    });
+    return deferred.promise;
+  };
+
+  service.getVolumes = function() {
+    return Volume.query({}).$promise;
+  };
+
+  service.remove = function(volume) {
+    var deferred = $q.defer();
+
+    Volume.remove({id: volume.Id}).$promise
+    .then(function success(data) {
+      if (data.message) {
+        deferred.reject({ msg: data.message, err: data.message });
+      }
+      if (volume.ResourceControl && volume.ResourceControl.Type === 3) {
+        return ResourceControlService.deleteResourceControl(volume.ResourceControl.Id);
+      }
+    })
+    .then(function success() {
+      deferred.resolve();
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to remove volume', err: err });
+    });
+
+    return deferred.promise;
+  };
+
+  service.createVolumeConfiguration = function(name, driver, driverOptions) {
+    var volumeConfiguration = {
+      Name: name,
+      Driver: driver,
+      DriverOpts: VolumeHelper.createDriverOptions(driverOptions)
+    };
+    return volumeConfiguration;
+  };
+
+  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 {
+        var volume = new VolumeViewModel(data);
+        deferred.resolve(volume);
+      }
+    })
+    .catch(function error(err) {
+      deferred.reject({ msg: 'Unable to create volume', err: err });
+    });
+    return deferred.promise;
+  };
+
+  service.createVolumes = function(volumeConfigurations) {
+    var createVolumeQueries = volumeConfigurations.map(function(volumeConfiguration) {
+      return service.createVolume(volumeConfiguration);
+    });
+    return $q.all(createVolumeQueries);
+  };
+
+  service.createXAutoGeneratedLocalVolumes = function (x) {
+    var createVolumeQueries = [];
+    for (var i = 0; i < x; i++) {
+      createVolumeQueries.push(service.createVolume({}));
+    }
+    return $q.all(createVolumeQueries);
+  };
+
+  return service;
+}]);