Example #1
0
        public override void Invoke(CommandInvocationContext context)
        {
            if (PackageLogic.Instance.PackagesCollection.Packages.Count > 0)
            {
                List <Packages.Package> packagesToList = new List <Packages.Package>();

                foreach (var pkg in PackageLogic.Instance.PackagesCollection.Packages)
                {
                    bool isLoaded = PackageLogic.Instance.LoadedPackages.Contains(pkg);
                    bool add      = true;
                    if (LoadedOnly.IsPresent && !isLoaded)
                    {
                        add = false;
                    }

                    if (add)
                    {
                        packagesToList.Add(pkg);
                    }
                }

                if (!string.IsNullOrWhiteSpace(Filter))
                {
                    packagesToList = packagesToList.Where(e => e.Name.IndexOf(Filter, StringComparison.OrdinalIgnoreCase) > -1).ToList();
                }

                base.Out.Object.Write(TableRecords.CreatePackageRecordList(packagesToList.ToArray()));
            }
            else
            {
                base.Out.Object.Write(TableRecords.CreatePackageRecordList());
            }
        }
Example #2
0
        public override void Invoke(CommandInvocationContext context)
        {
            var asm = Util.LoadAssembly(Assembly);

            if (asm == null)
            {
                base.Out.Error.WriteLine(string.Format("Could not load assembly from assembly string '{0}'", Assembly));
                return;
            }

            Package pkg = PackageLogic.Instance.PackagesCollection.Packages.FirstOrDefault(e => e.Name.Equals(Package, StringComparison.OrdinalIgnoreCase));

            List <string> modulesToInstall = null;

            if (!string.IsNullOrWhiteSpace(Modules))
            {
                modulesToInstall = new List <string>(Modules.Split(new char[] { ',' }, StringSplitOptions.RemoveEmptyEntries));
            }

            int count = 0;

            foreach (var type in asm.GetTypes())
            {
                if (type.GetInterface(typeof(IModule).FullName) != null)
                {
                    var  module = (IModule)Activator.CreateInstance(type);
                    bool add    = true;
                    if (modulesToInstall != null && !modulesToInstall.Contains(module.Name, StringComparer.OrdinalIgnoreCase))
                    {
                        add = false;
                    }

                    if (add)
                    {
                        base.Out.Verbose.WriteLine(string.Format("Adding module '{0}' from type '{1}'", module.Name, type));
                        if (AddModule(pkg, module))
                        {
                            count++;
                        }
                    }
                }
            }

            PackageLogic.Instance.Save();

            if (count > 0)
            {
                base.Out.Object.Table(TableRecords.CreatePackageRecordList(pkg));
            }
            else
            {
                base.Out.Standard.WriteLine("No modules could be found to load");
            }
        }
        public override void Invoke(CommandInvocationContext context)
        {
            if (base.Confirm("The module will be removed."))
            {
                var pkg = PackageLogic.Instance.PackagesCollection.Packages
                          .FirstOrDefault(e => e.Name.Equals(Package, StringComparison.OrdinalIgnoreCase));

                pkg.Modules.Remove(pkg.Modules.FirstOrDefault(m => m.Name.Equals(Module, StringComparison.OrdinalIgnoreCase)));

                PackageLogic.Instance.Save();

                base.Out.Object.Table(TableRecords.CreatePackageRecordList(pkg));

                if (PackageLogic.Instance.LoadedPackages.Contains(pkg))
                {
                    base.Out.Warning.WriteLine("This package is currently loaded and must be reloaded before the changes will take effect");
                }
            }
        }
        public override void Invoke(CommandInvocationContext context)
        {
            if (PackageLogic.Instance.PackagesCollection.Packages
                .Exists(e => e.Name.Equals(Name, StringComparison.OrdinalIgnoreCase)))
            {
                base.Out.Warning.WriteLine(string.Format("The package name '{0}' is already being used by another package", Name));
            }
            else
            {
                var newPkg = new Packages.Package()
                {
                    Name = Name
                };

                PackageLogic.Instance.PackagesCollection.Packages.Add(newPkg);
                PackageLogic.Instance.Save();

                base.Out.Object.Write(TableRecords.CreatePackageRecordList(newPkg));
            }
        }