private async Task SaveModuleDefinition()
        {
            try
            {
                var moduledefinition = await ModuleDefinitionService.GetModuleDefinitionAsync(_moduleDefinitionId, ModuleState.SiteId);

                if (moduledefinition.Name != _name)
                {
                    moduledefinition.Name = _name;
                }
                if (moduledefinition.Description != _description)
                {
                    moduledefinition.Description = _description;
                }
                if (moduledefinition.Categories != _categories)
                {
                    moduledefinition.Categories = _categories;
                }
                moduledefinition.Permissions = _permissionGrid.GetPermissions();
                await ModuleDefinitionService.UpdateModuleDefinitionAsync(moduledefinition);

                await logger.LogInformation("ModuleDefinition Saved {ModuleDefinition}", moduledefinition);

                NavigationManager.NavigateTo(NavigateUrl());
            }
            catch (Exception ex)
            {
                await logger.LogError(ex, "Error Saving ModuleDefinition {ModuleDefinitionId} {Error}", _moduleDefinitionId, ex.Message);

                AddModuleMessage("Error Saving Module", MessageType.Error);
            }
        }
        protected override async Task OnInitializedAsync()
        {
            try
            {
                _moduleDefinitionId = Int32.Parse(PageState.QueryString["id"]);
                var moduleDefinition = await ModuleDefinitionService.GetModuleDefinitionAsync(_moduleDefinitionId, ModuleState.SiteId);

                if (moduleDefinition != null)
                {
                    _name                 = moduleDefinition.Name;
                    _version              = moduleDefinition.Version;
                    _categories           = moduleDefinition.Categories;
                    _moduledefinitionname = moduleDefinition.ModuleDefinitionName;
                    _description          = moduleDefinition.Description;
                    _owner                = moduleDefinition.Owner;
                    _url         = moduleDefinition.Url;
                    _contact     = moduleDefinition.Contact;
                    _license     = moduleDefinition.License;
                    _runtimes    = moduleDefinition.Runtimes;
                    _permissions = moduleDefinition.Permissions;
                    _createdby   = moduleDefinition.CreatedBy;
                    _createdon   = moduleDefinition.CreatedOn;
                    _modifiedby  = moduleDefinition.ModifiedBy;
                    _modifiedon  = moduleDefinition.ModifiedOn;
                }
            }
            catch (Exception ex)
            {
                await logger.LogError(ex, "Error Loading ModuleDefinition {ModuleDefinitionId} {Error}", _moduleDefinitionId, ex.Message);

                AddModuleMessage("Error Loading Module", MessageType.Error);
            }
        }
Example #3
0
        private async Task InstallModules()
        {
            try
            {
                ShowProgressIndicator();
                var interop = new Interop(JSRuntime);
                await interop.RedirectBrowser(NavigateUrl(), 10);

                await ModuleDefinitionService.InstallModuleDefinitionsAsync();
            }
            catch (Exception ex)
            {
                await logger.LogError(ex, "Error Installating Module");
            }
        }
Example #4
0
        private async Task DeleteModule(ModuleDefinition moduleDefinition)
        {
            try
            {
                ShowProgressIndicator();
                var interop = new Interop(JSRuntime);
                await interop.RedirectBrowser(NavigateUrl(), 10);

                await ModuleDefinitionService.DeleteModuleDefinitionAsync(moduleDefinition.ModuleDefinitionId, moduleDefinition.SiteId);
            }
            catch (Exception ex)
            {
                await logger.LogError(ex, "Error Deleting Module {ModuleDefinition} {Error}", moduleDefinition, ex.Message);

                AddModuleMessage("Error Deleting Module", MessageType.Error);
            }
        }
Example #5
0
        protected override async Task OnInitializedAsync()
        {
            try
            {
                _moduleDefinitions = await ModuleDefinitionService.GetModuleDefinitionsAsync(PageState.Site.SiteId);

                _packages = await PackageService.GetPackagesAsync("module");
            }
            catch (Exception ex)
            {
                if (_moduleDefinitions == null)
                {
                    await logger.LogError(ex, "Error Loading Modules {Error}", ex.Message);

                    AddModuleMessage("Error Loading Modules", MessageType.Error);
                }
            }
        }
Example #6
0
        private async Task DownloadModule(string moduledefinitionname, string version)
        {
            try
            {
                await PackageService.DownloadPackageAsync(moduledefinitionname, version, "Modules");

                await logger.LogInformation("Module Downloaded {ModuleDefinitionName} {Version}", moduledefinitionname, version);

                ShowProgressIndicator();
                var interop = new Interop(JSRuntime);
                await interop.RedirectBrowser(NavigateUrl(), 10);

                await ModuleDefinitionService.InstallModuleDefinitionsAsync();
            }
            catch (Exception ex)
            {
                await logger.LogError(ex, "Error Downloading Module {ModuleDefinitionName} {Version} {Error}", moduledefinitionname, version, ex.Message);

                AddModuleMessage("Error Downloading Module", MessageType.Error);
            }
        }
Example #7
0
 private async Task CreateModule()
 {
     try
     {
         if (!string.IsNullOrEmpty(_owner) && !string.IsNullOrEmpty(_module) && _template != "-")
         {
             var moduleDefinition = new ModuleDefinition {
                 Owner = _owner.Replace(" ", ""), Name = _module.Replace(" ", ""), Description = _description, Template = _template
             };
             await ModuleDefinitionService.CreateModuleDefinitionAsync(moduleDefinition, ModuleState.ModuleId);
         }
         else
         {
             AddModuleMessage("You Must Provide An Owner, Module Name, And Template", MessageType.Warning);
         }
     }
     catch (Exception ex)
     {
         await logger.LogError(ex, "Error Creating Module");
     }
 }
Example #8
0
        protected override async Task OnInitializedAsync()
        {
            try
            {
                var moduledefinitions = await ModuleDefinitionService.GetModuleDefinitionsAsync(PageState.Site.SiteId);

                _packages = await PackageService.GetPackagesAsync("module");

                foreach (Package package in _packages.ToArray())
                {
                    if (moduledefinitions.Exists(item => Utilities.GetTypeName(item.ModuleDefinitionName) == package.PackageId))
                    {
                        _packages.Remove(package);
                    }
                }
            }
            catch (Exception ex)
            {
                await logger.LogError(ex, "Error Loading Packages {Error}", ex.Message);

                AddModuleMessage("Error Loading Packages", MessageType.Error);
            }
        }