private bool templateBrowserControl1_ExecuteOverride(TemplateOperations operation, ZeusTemplate template, ZeusSavedInput input, ShowGUIEventHandler guiEventHandler)
        {
            switch (operation)
            {
            case TemplateOperations.Execute:
                ZeusProcessManager.ExecuteTemplate(template.FullFileName, processCallback);
                break;

            case TemplateOperations.ExecuteLoadedInput:
                ZeusProcessManager.ExecuteSavedInput(input.FilePath, processCallback);
                break;

            case TemplateOperations.SaveInput:
                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.Filter           = "Zues Input Files (*.zinp)|*.zinp";
                saveFileDialog.FilterIndex      = 0;
                saveFileDialog.RestoreDirectory = true;
                if (saveFileDialog.ShowDialog() == DialogResult.OK)
                {
                    ZeusProcessManager.RecordTemplateInput(template.FullFileName, saveFileDialog.FileName, processCallback);
                }
                break;
            }
            return(true);
        }
Example #2
0
        private bool ExecuteTemplateOverride(TemplateOperations operation, ZeusTemplate template, ZeusSavedInput input, ShowGUIEventHandler guiEventHandler)
        {
            switch (operation)
            {
            case TemplateOperations.Execute:
                this._mdi.PerformMdiFuntion(this, "ExecutionQueueStart");
                ZeusProcessManager.ExecuteTemplate(template.FullFileName, _executionCallback);
                break;

            case TemplateOperations.ExecuteLoadedInput:
                this._mdi.PerformMdiFuntion(this, "ExecutionQueueStart");
                ZeusProcessManager.ExecuteSavedInput(input.FilePath, _executionCallback);
                break;

            case TemplateOperations.SaveInput:
                SaveFileDialog saveFileDialog = new SaveFileDialog();
                saveFileDialog.Filter           = "Zues Input Files (*.zinp)|*.zinp";
                saveFileDialog.FilterIndex      = 0;
                saveFileDialog.RestoreDirectory = true;
                if (saveFileDialog.ShowDialog() == DialogResult.OK)
                {
                    this._mdi.PerformMdiFuntion(this, "ExecutionQueueStart");
                    ZeusProcessManager.RecordTemplateInput(template.FullFileName, saveFileDialog.FileName, _executionCallback);
                }
                break;
            }
            return(true);
        }
        public void EventWidget_SelectListTemplate()
        {
            string textEdited    = "<p> Test paragraph </p>";
            string paragraphText = "Test paragraph";

            string listTemplate        = "ListPageNew";
            var    templateOperation   = new TemplateOperations();
            var    listTemplatePath    = Path.Combine(templateOperation.SfPath, "ResourcePackages", "Bootstrap", "MVC", "Views", "Event", "List.EventsList.cshtml");
            var    newListTemplatePath = Path.Combine(templateOperation.SfPath, "MVC", "Views", "Shared", "List.ListPageNew.cshtml");

            try
            {
                File.Copy(listTemplatePath, newListTemplatePath);
                this.EditFile(newListTemplatePath, textEdited);

                var mvcProxy = new MvcControllerProxy();
                mvcProxy.ControllerName = typeof(EventController).FullName;
                var eventController = new EventController();
                eventController.ListTemplateName = listTemplate;
                mvcProxy.Settings = new ControllerSettings(eventController);

                string responseContent = this.pageOperations.AddWidgetToPageAndRequest(mvcProxy);

                Assert.IsTrue(responseContent.Contains(BaseEventTitle + 1), "The event with this title was not found!");
                Assert.IsTrue(responseContent.Contains(paragraphText), "The event with this template was not found!");
            }
            finally
            {
                File.Delete(newListTemplatePath);
            }
        }
 private bool ExecuteTemplateOverride(TemplateOperations operation, ZeusTemplate template, ZeusSavedInput input, ShowGUIEventHandler guiEventHandler)
 {
     switch (operation)
     {
         case TemplateOperations.Execute:
             this._mdi.PerformMdiFuntion(this, "ExecutionQueueStart");
             ZeusProcessManager.ExecuteTemplate(template.FullFileName, _executionCallback);
             break;
         case TemplateOperations.ExecuteLoadedInput:
             this._mdi.PerformMdiFuntion(this, "ExecutionQueueStart");
             ZeusProcessManager.ExecuteSavedInput(input.FilePath, _executionCallback);
             break;
         case TemplateOperations.SaveInput:
             SaveFileDialog saveFileDialog = new SaveFileDialog();
             saveFileDialog.Filter = "Zues Input Files (*.zinp)|*.zinp";
             saveFileDialog.FilterIndex = 0;
             saveFileDialog.RestoreDirectory = true;
             if (saveFileDialog.ShowDialog() == DialogResult.OK)
             {
                 this._mdi.PerformMdiFuntion(this, "ExecutionQueueStart");
                 ZeusProcessManager.RecordTemplateInput(template.FullFileName, saveFileDialog.FileName, _executionCallback);
             }
             break;
     }
     return true;
 }
        public async Task DeleteTemplateAsync_ValidParameters_ExpectedClientCall()
        {
            IANSSafeDNSClient client = Substitute.For <IANSSafeDNSClient>();

            var ops = new TemplateOperations <Template>(client);
            await ops.DeleteTemplateAsync(123);

            await client.Received().DeleteAsync("/safedns/v1/templates/123");
        }
Example #6
0
        public void LoadFromFile(string fileName)
        {
            IsLocked = true;
            FileName = fileName;
            var full = File.ReadAllBytes(fileName);
            var type = DecideTemplateOperations(fileName);

            if (type > 0)
            {
                Logger.Debug("LoadFromFile Type : " + type);

                var zipContent = TemplateOperations.ExtractDataContentFromNLock(full);
                try
                {
                    Template = TemplateOperations.ExtractTemplateFromNLock(full);
                    Template = _encryptionStrategy.Decrypt(zipContent, Template);
                }
                catch (Exception)
                {
                    throw;
                }

                UnlockForm loginFrom;

                if (type == 2)
                {
                    var hash = TemplateOperations.GetHashFromNLock(full);
                    Logger.Debug("LoadFromFile Hash : " + Encoding.UTF8.GetString(hash));
                    loginFrom = new UnlockForm(Template, hash, fileName);
                }
                else
                {
                    loginFrom = new UnlockForm(Template, fileName)
                    {
                        PwHash = null
                    };
                }
                loginFrom.ShowDialog();
                var result = loginFrom.DialogResult;
                if (result != DialogResult.Cancel)
                {
                    _verified = loginFrom.Verified;
                    if (Unlock() == VerificationStatus.Failed)
                    {
                        throw new Exception("Loading from file failed");
                    }
                }
                loginFrom.Dispose();
            }
            else
            {
                throw new Exception("Loading from file failed");
            }
        }
        public async Task GetTemplateAsync_ValidParameters_ExpectedResult()
        {
            IANSSafeDNSClient client = Substitute.For <IANSSafeDNSClient>();

            client.GetAsync <Template>("/safedns/v1/templates/123").Returns(new Template()
            {
                ID = 123
            });

            var ops      = new TemplateOperations <Template>(client);
            var template = await ops.GetTemplateAsync(123);

            Assert.AreEqual(123, template.ID);
        }
        public async Task UpdateTemplateAsync_ValidParameters_ExpectedClientCall()
        {
            UpdateTemplateRequest req = new UpdateTemplateRequest()
            {
                Name = "template1"
            };

            IANSSafeDNSClient client = Substitute.For <IANSSafeDNSClient>();

            var ops = new TemplateOperations <Template>(client);
            await ops.UpdateTemplateAsync(123, req);

            await client.Received().PatchAsync("/safedns/v1/templates/123", req);
        }
        public async Task GetTemplatesAsync_ExpectedResult()
        {
            IANSSafeDNSClient client = Substitute.For <IANSSafeDNSClient>();
            var ops = new TemplateOperations <Template>(client);

            client.GetAllAsync(Arg.Any <ANSClient.GetPaginatedAsyncFunc <Template> >(), null).Returns(Task.Run <IList <Template> >(() =>
            {
                return(new List <Template>()
                {
                    new Template(),
                    new Template()
                });
            }));

            var templates = await ops.GetTemplatesAsync();

            Assert.AreEqual(2, templates.Count);
        }
        public void EventWidget_SelectDetailTemplate()
        {
            string testName        = System.Reflection.MethodInfo.GetCurrentMethod().Name;
            string pageNamePrefix  = testName + "EventsPage";
            string pageTitlePrefix = testName + "Events Page";
            string urlNamePrefix   = testName + "events-page";
            int    pageIndex       = 1;
            string textEdited      = "<p> Test paragraph </p>";
            string paragraphText   = "Test paragraph";
            var    eventsManager   = EventsManager.GetManager();
            string url             = UrlPath.ResolveAbsoluteUrl("~/" + urlNamePrefix + pageIndex);

            string detailTemplate        = "DetailPageNew";
            var    templateOperation     = new TemplateOperations();
            var    detailTemplatePath    = Path.Combine(templateOperation.SfPath, "ResourcePackages", "Bootstrap", "MVC", "Views", "Event", "Detail.EventDetails.cshtml");
            var    newDetailTemplatePath = Path.Combine(templateOperation.SfPath, "MVC", "Views", "Shared", "Detail.DetailPageNew.cshtml");

            try
            {
                File.Copy(detailTemplatePath, newDetailTemplatePath);
                this.EditFile(newDetailTemplatePath, textEdited);

                var mvcProxy = new MvcControllerProxy();
                mvcProxy.ControllerName = typeof(EventController).FullName;
                var eventController = new EventController();
                eventController.DetailTemplateName = detailTemplate;
                mvcProxy.Settings = new ControllerSettings(eventController);

                this.pageOperations.CreatePageWithControl(mvcProxy, pageNamePrefix, pageTitlePrefix, urlNamePrefix, pageIndex);

                var    eventItem      = eventsManager.GetEvents().Where <Event>(e => e.Status == Telerik.Sitefinity.GenericContent.Model.ContentLifecycleStatus.Master && e.Title == BaseEventTitle + 1).FirstOrDefault();
                string detailEventUrl = url + eventItem.ItemDefaultUrl;

                string responseContent = PageInvoker.ExecuteWebRequest(detailEventUrl);

                Assert.IsTrue(responseContent.Contains(BaseEventTitle + 1), "The event with this title was not found!");
                Assert.IsTrue(responseContent.Contains(paragraphText), "The event with this template was not found!");
            }
            finally
            {
                File.Delete(newDetailTemplatePath);
            }
        }
        public async Task CreateTemplateAsync_ExpectedResult()
        {
            CreateTemplateRequest req = new CreateTemplateRequest()
            {
                Name = "testtemplate1"
            };

            IANSSafeDNSClient client = Substitute.For <IANSSafeDNSClient>();

            client.PostAsync <Template>("/safedns/v1/templates", req).Returns(new Template()
            {
                ID = 123
            });

            var ops = new TemplateOperations <Template>(client);
            int id  = await ops.CreateTemplateAsync(req);

            Assert.AreEqual(123, id);
        }
Example #12
0
 private VerificationStatus Unlock()
 {
     Logger.Debug("Unlocking");
     if (_verified)
     {
         if (FileName != null)
         {
             var zipContent = TemplateOperations.ExtractDataContentFromNLock(FileName);
             Logger.Debug("ExtractDataContentFromNLock");
             _lockedContent = _encryptionStrategy.Decrypt(Template, zipContent);
             _container.LoadFromMemory(_lockedContent);
             IsLocked = false;
         }
         return(VerificationStatus.Verfified);
     }
     else
     {
         Logger.Debug("Not verified");
         IsLocked = true;
         return(VerificationStatus.Failed);
     }
 }
 private bool templateBrowserControl1_ExecuteOverride(TemplateOperations operation, ZeusTemplate template, ZeusSavedInput input, ShowGUIEventHandler guiEventHandler)
 {
     switch (operation)
     {
         case TemplateOperations.Execute:
             ZeusProcessManager.ExecuteTemplate(template.FullFileName, processCallback);
             break;
         case TemplateOperations.ExecuteLoadedInput:
             ZeusProcessManager.ExecuteSavedInput(input.FilePath, processCallback);
             break;
         case TemplateOperations.SaveInput:
             SaveFileDialog saveFileDialog = new SaveFileDialog();
             saveFileDialog.Filter = "Zues Input Files (*.zinp)|*.zinp";
             saveFileDialog.FilterIndex = 0;
             saveFileDialog.RestoreDirectory = true;
             if (saveFileDialog.ShowDialog() == DialogResult.OK)
             {
                 ZeusProcessManager.RecordTemplateInput(template.FullFileName, saveFileDialog.FileName, processCallback);
             }
             break;
     }
     return true;
 }
Example #14
0
        /// <summary>
        /// Constructor.  Note that you should dispose the instance when you're finished with it.
        /// </summary>
        /// <param name="addressOrFQDN">The target XenServer IP address or FQDN.</param>
        /// <param name="username">The user name.</param>
        /// <param name="password">The password.</param>
        /// <param name="name">Optionally specifies the XenServer name.</param>
        /// <param name="logFolder">
        /// The folder where log files are to be written, otherwise or <c>null</c> or
        /// empty if logging is disabled.
        /// </param>
        public XenClient(string addressOrFQDN, string username, string password, string name = null, string logFolder = null)
        {
            Covenant.Requires <ArgumentNullException>(!string.IsNullOrEmpty(username));

            if (!IPAddress.TryParse(addressOrFQDN, out var address))
            {
                var hostEntry = Dns.GetHostEntry(addressOrFQDN);

                if (hostEntry.AddressList.Length == 0)
                {
                    throw new XenException($"[{addressOrFQDN}] is not a valid IP address or fully qualified domain name of a XenServer host.");
                }

                address = hostEntry.AddressList.First();
            }

            var logWriter = (TextWriter)null;

            if (!string.IsNullOrEmpty(logFolder))
            {
                Directory.CreateDirectory(logFolder);

                logWriter = new StreamWriter(Path.Combine(logFolder, $"XENSERVER-{addressOrFQDN}.log"));
            }

            Address           = addressOrFQDN;
            Name              = name;
            SshProxy          = new SshProxy <XenClient>(addressOrFQDN, null, address, SshCredentials.FromUserPassword(username, password), logWriter);
            SshProxy.Metadata = this;
            runOptions        = RunOptions.IgnoreRemotePath;

            // Initialize the operation classes.

            Repository = new RepositoryOperations(this);
            Template   = new TemplateOperations(this);
            Machine    = new MachineOperations(this);
        }
        public async Task GetTemplatesPaginatedAsync_ExpectedClientCall()
        {
            IANSSafeDNSClient client = Substitute.For <IANSSafeDNSClient>();

            client.GetPaginatedAsync <Template>("/safedns/v1/templates").Returns(Task.Run(() =>
            {
                return(new Paginated <Template>(client, "/safedns/v1/templates", null, new Response.ClientResponse <System.Collections.Generic.IList <Template> >()
                {
                    Body = new Response.ClientResponseBody <System.Collections.Generic.IList <Template> >()
                    {
                        Data = new List <Template>()
                        {
                            new Template(),
                            new Template()
                        }
                    }
                }));
            }));

            var ops       = new TemplateOperations <Template>(client);
            var paginated = await ops.GetTemplatesPaginatedAsync();

            Assert.AreEqual(2, paginated.Items.Count);
        }
 public async Task DeleteTemplateAsync_InvalidTemplateID_ThrowsANSClientValidationException()
 {
     var ops = new TemplateOperations <Template>(null);
     await Assert.ThrowsExceptionAsync <ANSClientValidationException>(() => ops.DeleteTemplateAsync(0));
 }