protected void OnItemSaved(object sender, EventArgs args)
        {
            CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);

            // Only continue if we have valid args, auto update is set to true, and the file exists already
            if (args != null && settings.AutoUpdate)
            {
                // Get the template destination
                Item _temp = masterDb.GetItem(GetCurrentContentGuid());
                if (_temp != null)
                {
                    string file_path = FileUtil.GetClassFilePath(CodeUtil.GetClassNameForTemplate(_temp), settings.BaseFileOutputPath);

                    // Make sure the template already exists
                    if (File.Exists(file_path))
                    {
                        // Set these up since we don't have the editor open
                        CustomItemNamespace = new Edit();
                        CustomItemFilePath  = new Edit();

                        // Call the current code beside
                        OnLoad(args);
                        OnOK(sender, args);
                    }
                }
            }

            return;
        }
        protected override void OnLoad(EventArgs args)
        {
            base.OnLoad(args);
            string currentItemId = GetCurrentContentGuid();

            template = masterDb.GetItem(currentItemId);
            if (template == null)
            {
                SheerResponse.Alert("You must select a template to continue.", new string[0]);
            }
            else
            {
                CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);

                if (settings.AutoUpdate || !Context.ClientPage.IsEvent)
                {
                    string defaultNamespace = settings.BaseNamespace;
                    string defaultFilePath  = settings.BaseFileOutputPath;

                    if (!string.IsNullOrEmpty(defaultNamespace))
                    {
                        CustomItemNamespace.Value = defaultNamespace;
                    }

                    if (!string.IsNullOrEmpty(defaultFilePath))
                    {
                        CustomItemFilePath.Value = defaultFilePath;
                    }
                    else
                    {
                        CustomItemFilePath.Value = "[ENTER CUSTOM ITEM ROOT FILE PATH]";
                    }
                }
            }
        }
        public CustomItemInformation(TemplateItem template, string baseNamespace, string baseFileRoot)
        {
            CustomItemSettings            settings          = new CustomItemSettings(HttpContext.Current);
            ICustomItemNamespaceProvider  namespaceProvider = AssemblyUtil.GetNamespaceProvider(settings.NamespaceProvider);
            ICustomItemFolderPathProvider filePathProvider  = AssemblyUtil.GetFilePathProvider(settings.FilepathProvider);

            GetItemInformation(template, baseNamespace, baseFileRoot, filePathProvider, namespaceProvider);
        }
Esempio n. 4
0
        public BaseTemplateInformation(TemplateItem template, ICustomItemNamespaceProvider namespaceProvider)
        {
            ClassName = CodeUtil.GetClassNameForTemplate(template);

            PropertyName = ClassName.Remove(ClassName.Length - 4);
            if (PropertyName.StartsWith("_"))
            {
                PropertyName = PropertyName.Substring(1);
            }

            CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);

            UsingNameSpace = namespaceProvider.GetNamespace(template, settings.BaseNamespace);
        }
        /// <summary>
        /// Using the sitecore settings, return the proper return type for the passed in
        /// field.
        /// </summary>
        /// <param name="field">The field.</param>
        /// <returns></returns>
        public static string GetFieldReturnType(TemplateFieldItem field)
        {
            string fieldType = field.Type.ToLower();

            CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);

            foreach (FieldMapping fieldMapping in settings.FieldMappings)
            {
                if (fieldMapping.SitecoreFieldType.ToLower() != fieldType)
                {
                    continue;
                }
                return(fieldMapping.FieldReturnType);
            }

            return(string.Empty);
        }
        protected override void OnOK(object sender, EventArgs args)
        {
            CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);

            ICustomItemNamespaceProvider  namespaceProvider = AssemblyUtil.GetNamespaceProvider(settings.NamespaceProvider);
            ICustomItemFolderPathProvider filePathProvider  = AssemblyUtil.GetFilePathProvider(settings.FilepathProvider);

            CustomItemInformation customItemInformation = new CustomItemInformation(template, CustomItemNamespace.Value,
                                                                                    CustomItemFilePath.Value, filePathProvider, namespaceProvider);
            CodeGenerator codeGenerator = new CodeGenerator(customItemInformation,
                                                            GenerateBaseFile.Checked, GenerateInstanceFile.Checked, GenerateInterfaceFile.Checked, GenerateStaticFile.Checked);

            codeGenerator.GenerateCode();

            SheerResponse.Alert(codeGenerator.GenerationMessage, new string[0]);

            base.OnOK(sender, args);
        }
        protected override void OnOK(object sender, EventArgs args)
        {
            foreach (ChecklistItem template in TemplateList.Items)
            {
                //Do nothing if the template has not been selected
                if (!template.Checked)
                {
                    continue;
                }

                //Try and get the template
                TemplateItem templateItem = masterDb.GetItem(template.Value);
                if (templateItem == null)
                {
                    continue;
                }

                //Using the settings item get the providers needed for creating both the namespaces for the custom items
                // as well as the file/folder strucutre.
                CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);

                ICustomItemNamespaceProvider namespaceProvider =
                    AssemblyUtil.GetNamespaceProvider(settings.NamespaceProvider);

                ICustomItemFolderPathProvider filePathProvider = AssemblyUtil.GetFilePathProvider(settings.FilepathProvider);

                //Get all the custom item information
                CustomItemInformation customItemInformation = new CustomItemInformation(templateItem, CustomItemNamespace.Value,
                                                                                        CustomItemFilePath.Value,
                                                                                        filePathProvider,
                                                                                        namespaceProvider);
                //Generate the class file(s)
                CodeGenerator codeGenerator =
                    new CodeGenerator(customItemInformation,
                                      GenerateBaseFile.Checked, GenerateInstanceFile.Checked, GenerateInterfaceFile.Checked,
                                      GenerateStaticFile.Checked);

                codeGenerator.GenerateCode();
            }

            SheerResponse.Alert("Custom items sucessfully generated.", new string[0]);

            base.OnOK(sender, args);
        }
        protected override void OnLoad(EventArgs args)
        {
            base.OnLoad(args);
            string currentItemId = GetCurrentContentGuid();

            templateFolder = masterDb.GetItem(currentItemId);
            if (templateFolder == null)
            {
                SheerResponse.Alert("You must select a template to continue.", new string[0]);
            }
            else
            {
                if (!Context.ClientPage.IsEvent)
                {
                    CustomItemSettings settings = new CustomItemSettings(HttpContext.Current);

                    //Set the default namespace text box
                    string defaultNamespace = settings.BaseNamespace;
                    if (!string.IsNullOrEmpty(defaultNamespace))
                    {
                        CustomItemNamespace.Value = defaultNamespace;
                    }

                    //Set the default file path text box
                    string defaultFilePath = settings.BaseFileOutputPath;
                    if (!string.IsNullOrEmpty(defaultFilePath))
                    {
                        CustomItemFilePath.Value = defaultFilePath;
                    }
                    else
                    {
                        CustomItemFilePath.Value = "Custom Item Root Path";
                    }

                    //Fill the list of templates with the templates
                    //that are descendent items of the selected folder
                    FillTemplateList();
                }
            }
        }