Example #1
0
        /// <summary>
        /// Returns a list of Components representing all encountered configurations that were found according to the locations in the .config file
        /// </summary>
        private List <Component> GetConfigurationComponents(RepositoryLocalObject repositoryLocalObject)
        {
            List <Component> results = new List <Component>();
            Component        configurationComponent = null;

            foreach (string location in SystemComponentLocation.Split(','))
            {
                try
                {
                    if (location == PUBLICATION) // read from Publication metadata
                    {
                        Repository publication = repositoryLocalObject.ContextRepository;
                        results.AddRange(GetConfigurationsFromMetadata(publication.Metadata, publication.MetadataSchema));
                    }
                    else if (location == CURRENT) // read from parent metadata
                    {
                        OrganizationalItem organizationalItem = repositoryLocalObject.OrganizationalItem;
                        results.AddRange(GetConfigurationsFromStructureGroup(organizationalItem, SystemComponentRecursive));
                    }
                    else if (location.StartsWith("/webdav") || TcmUri.IsValid(location))
                    {
                        configurationComponent = (Component)repositoryLocalObject.Session.GetObject(location);
                        results.Add(configurationComponent);
                    }
                }
                catch
                {
                    // Log error
                }
            }

            return(results);
        }
Example #2
0
 private void GetStructureGroupToBeCreated(OrganizationalItem folder, TcmUri rootFolderId, Stack <string> sgNames)
 {
     if (folder != null && folder.Id != rootFolderId)
     {
         sgNames.Push(folder.Title);
         GetStructureGroupToBeCreated(folder.OrganizationalItem, rootFolderId, sgNames);
     }
 }
        public static IEnumerable <Page> GetPages(this OrganizationalItem sg, bool recursive)
        {
            var filter = new OrganizationalItemItemsFilter(sg.Session)
            {
                ItemTypes = new[] { ItemType.Page },
                Recursive = recursive
            };

            return(sg.GetItems(filter).Cast <Page>());
        }
        public static IEnumerable <StructureGroup> GetStructureGroups(this OrganizationalItem sg, bool recursive)
        {
            var filter = new OrganizationalItemItemsFilter(sg.Session)
            {
                ItemTypes = new[] { ItemType.StructureGroup },
                Recursive = recursive
            };

            return(sg.GetItems(filter).Cast <StructureGroup>());
        }
Example #5
0
 protected OrganizationalItem GetChildOrganizationalItem(OrganizationalItem root, string title)
 {
     foreach (KeyValuePair <TcmUri, string> child in GetOrganizationalItemContents(root, root is Folder ? ItemType.Folder : ItemType.StructureGroup, false))
     {
         if (child.Value.ToLower() == title.ToLower())
         {
             return((OrganizationalItem)Engine.GetObject(child.Key));
         }
     }
     return(null);
 }
        public static IEnumerable <Component> GetComponents(this OrganizationalItem folder, IEnumerable <Schema> basedOnSchemas, bool recursive)
        {
            var filter = new OrganizationalItemItemsFilter(folder.Session)
            {
                ItemTypes      = new[] { ItemType.Component },
                Recursive      = recursive,
                BasedOnSchemas = basedOnSchemas
            };

            return(folder.GetItems(filter).Cast <Component>());
        }
Example #7
0
 /// <summary>
 /// Retrieves a list of <see cref="T:Tridion.ContentManager.ContentManagement.Component" /> from a
 /// <see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" />
 /// </summary>
 /// <param name="organizationalItem"><see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" /></param>
 /// <param name="schema">Schema TCM uri for filtering.</param>
 /// <returns>List of <see cref="T:Tridion.ContentManager.ContentManagement.Component" /></returns>
 public static List <Component> Components(this OrganizationalItem organizationalItem, String schema)
 {
     if (!String.IsNullOrEmpty(schema) && TcmUri.IsValid(schema))
     {
         return(organizationalItem.Components(new TcmUri(schema)));
     }
     else
     {
         return(organizationalItem.Components(null as Schema));
     }
 }
Example #8
0
 /// <summary>
 /// Retrieves a list of <see cref="T:Tridion.ContentManager.ContentManagement.Component" /> from a
 /// <see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" />
 /// </summary>
 /// <param name="organizationalItem"><see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" /></param>
 /// <param name="Schema">Schema <see cref="T:Tridion.ContentManager.TcmUri" /> for filtering.</param>
 /// <returns>List of <see cref="T:Tridion.ContentManager.ContentManagement.Component" /></returns>
 public static List <Component> Components(this OrganizationalItem organizationalItem, TcmUri schema)
 {
     if (schema != null && TcmUri.IsValid(schema))
     {
         return(organizationalItem.Components(new Schema(schema, organizationalItem.Session)));
     }
     else
     {
         return(organizationalItem.Components(null as Schema));
     }
 }
        public IEnumerable <XElement> GetListItems(OrganizationalItem parent, ItemType type, ListBaseColumns cols)
        {
            Filter filter = new Filter();

            filter.Conditions["ItemType"] = type;
            filter.BaseColumns            = cols;
            XElement   items = ConvertToXElement(parent.GetListItems(filter));
            XNamespace ns    = items.Name.Namespace;
            var        query = from item in items.Elements(ns + "Item") select item;

            return(query);
        }
Example #10
0
        /// <summary>
        /// Returns Configuration Components from the OrganizationalItem's metadata, possibly recursive.
        /// </summary>
        private List <Component> GetConfigurationsFromStructureGroup(OrganizationalItem organizationalItem, bool isRecursive)
        {
            List <Component> results = new List <Component>();

            results.AddRange(GetConfigurationsFromMetadata(organizationalItem.Metadata, organizationalItem.MetadataSchema));

            if (isRecursive && !organizationalItem.IsRootOrganizationalItem)
            {
                results.AddRange(GetConfigurationsFromStructureGroup(organizationalItem.OrganizationalItem, isRecursive));
            }

            return(results);
        }
Example #11
0
        /// <summary>
        /// Retrieves a list of <see cref="T:Tridion.ContentManager.ContentManagement.Component" /> from a
        /// <see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" />
        /// </summary>
        /// <param name="organizationalItem"><see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" /></param>
        /// <param name="recursive">if set to <c>true</c> [recursive].</param>
        /// <returns>
        /// List of <see cref="T:Tridion.ContentManager.ContentManagement.Component" />
        /// </returns>
        public static List <Component> Components(this OrganizationalItem organizationalItem, bool recursive)
        {
            if (organizationalItem != null)
            {
                OrganizationalItemItemsFilter filter = new OrganizationalItemItemsFilter(organizationalItem.Session)
                {
                    ItemTypes = new ItemType[] { ItemType.Component },
                    Recursive = recursive
                };

                // Return a list of all matching component types
                return(organizationalItem.GetItems(filter).OfType <Component>().ToList());
            }

            return(new List <Component>());
        }
Example #12
0
        /// <summary>
        /// Retrieves a list of <see cref="T:Tridion.ContentManager.ContentManagement.Component" /> from a
        /// <see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" />
        /// </summary>
        /// <param name="organizationalItem"><see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" /></param>
        /// <param name="schema">Schema <see cref="T:Tridion.ContentManager.ContentManagement.Schema" /> for filtering.</param>
        /// <returns>List of <see cref="T:Tridion.ContentManager.ContentManagement.Component" /></returns>
        public static List <Component> Components(this OrganizationalItem organizationalItem, Schema schema)
        {
            if (organizationalItem != null)
            {
                OrganizationalItemItemsFilter filter = new OrganizationalItemItemsFilter(organizationalItem.Session)
                {
                    ItemTypes      = new ItemType[] { ItemType.Component },
                    BasedOnSchemas = schema != null ? new Schema[] { schema } : null
                };

                // Return a list of all matching component types
                return(organizationalItem.GetItems(filter).OfType <Component>().ToList());
            }

            return(new List <Component>());
        }
Example #13
0
        /// <summary>
        /// Retrieves a list of tridion items specified by <see cref="T:Tridion.ContentManager.ItemType" /> from a <see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" />
        /// </summary>
        /// <param name="itemTypes">Array of <see cref="T:Tridion.ContentManager.ItemType" /></param>
        /// <param name="Recursive">if set to <c>true</c> [recursive].</param>
        /// <returns>List of Tridion KeyValuePair&lt;TcmUri, String&gt;</returns>
        public static List <KeyValuePair <TcmUri, String> > GetItems(this OrganizationalItem organizationalItem, ItemType[] itemTypes, bool recursive)
        {
            if (organizationalItem != null)
            {
                OrganizationalItemItemsFilter filter = new OrganizationalItemItemsFilter(organizationalItem.Session)
                {
                    ItemTypes = itemTypes,
                    Recursive = recursive
                };

                return((from XmlNode item in organizationalItem.GetListItems(filter).SelectNodes("/*/*")
                        select new KeyValuePair <TcmUri, String>(new TcmUri(item.Attributes["ID"].Value), item.Attributes["Title"].Value)).ToList());
            }

            return(new List <KeyValuePair <TcmUri, String> >());
        }
Example #14
0
 /// <summary>
 /// Retrieves a list of <see cref="T:Tridion.ContentManager.CommunicationManagement.Page" /> from a
 /// <see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" />
 /// </summary>
 /// <param name="organizationalItem"><see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" /></param>
 /// <returns>
 /// List of <see cref="T:Tridion.ContentManager.CommunicationManagement.Page" />
 /// </returns>
 public static List <Page> Pages(this OrganizationalItem organizationalItem)
 {
     return(organizationalItem.Pages(false));
 }
 public static IEnumerable <StructureGroup> GetStructureGroups(this OrganizationalItem sg)
 {
     return(GetStructureGroups(sg, false));
 }
Example #16
0
 /// <summary>
 /// Retrieves a list of <see cref="T:Tridion.ContentManager.CommunicationManagement.StructureGroup" /> from a
 /// <see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" />
 /// </summary>
 /// <param name="organizationalItem"><see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" /></param>
 /// <returns>
 /// List of <see cref="T:Tridion.ContentManager.CommunicationManagement.StructureGroup" />
 /// </returns>
 public static List <StructureGroup> StructureGroups(this OrganizationalItem organizationalItem)
 {
     return(organizationalItem.StructureGroups(false));
 }
 public static IEnumerable <Page> GetPages(this OrganizationalItem sg)
 {
     return(GetPages(sg, false));
 }
Example #18
0
 /// <summary>
 /// Creates a new Tridion collection by calling GetListItems using the provided filter on the provided organizational item
 /// the collection is then filtered by applying the xpath query provided
 /// </summary>
 /// <param name="engine">An instantiated Engine object <typeparamref name="Tridion.ContentManager.Templating.Engine"/></param>
 /// <param name="root">The organizational element to get the list of items for</param>
 /// <param name="filter">An instantiated Filter object with preset conditions</param>
 /// <param name="xpath">An Xpath expression to further filter the retrieved results </param>
 public TridionCollectionBase(Engine engine, OrganizationalItem root, Filter filter, XPathExpression xpath) : this(engine, root.GetListItems(new OrganizationalItemItemsFilter(filter, engine.GetSession())), xpath)
 {
 }
Example #19
0
 public TridionCollection(Engine engine, OrganizationalItem root, Filter filter) : base(engine, root, filter)
 {
 }
Example #20
0
 public TridionCollection(Engine engine, OrganizationalItem root, Filter filter, XPathExpression xpath) : base(engine, root, filter, xpath)
 {
 }
		public IEnumerable<XElement> GetListItems(OrganizationalItem parent, ItemType type, ListBaseColumns cols) {
			Filter filter = new Filter();
			filter.Conditions["ItemType"] = type;
			filter.BaseColumns = cols;
			XElement items = ConvertToXElement(parent.GetListItems(filter));
			XNamespace ns = items.Name.Namespace;
			var query = from item in items.Elements(ns + "Item") select item;
			return query;
		}
Example #22
0
 /// <summary>
 /// Retrieves a list of <see cref="T:Tridion.ContentManager.ContentManagement.Component" /> from a
 /// <see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" />
 /// </summary>
 /// <param name="organizationalItem"><see cref="T:Tridion.ContentManager.ContentManagement.OrganizationalItem" /></param>
 /// <returns>
 /// List of <see cref="T:Tridion.ContentManager.ContentManagement.Component" />
 /// </returns>
 public static List <Component> Components(this OrganizationalItem organizationalItem)
 {
     return(organizationalItem.Components(null as Schema));
 }
		protected List<KeyValuePair<TcmUri, string>> GetOrganizationalItemContents(OrganizationalItem orgItem, ItemType itemType, bool recursive) {
			Filter filter = new Filter();
			filter.Conditions.Add("ItemType", itemType);
			filter.Conditions.Add("Recursive", recursive);
			List<KeyValuePair<TcmUri, string>> res = new List<KeyValuePair<TcmUri, string>>();
			foreach (XmlNode item in orgItem.GetListItems(filter).SelectNodes("/*/*")) {
				string title = item.Attributes["Title"].Value;
				TcmUri id = new TcmUri(item.Attributes["ID"].Value);
				res.Add(new KeyValuePair<TcmUri, string>(id, title));
			}
			return res;
		}
        /// <summary>
        /// Process images
        /// </summary>
        /// <param name="htmlDoc"></param>
        /// <param name="taggedImageList"></param>
        /// <param name="parentFolder"></param>
        /// <param name="componentTitle"></param>
        /// <param name="archive"></param>
        private static void ProcessImages(HtmlDocument htmlDoc, EmbeddedSchemaField taggedImageList, OrganizationalItem parentFolder, String componentTitle, ZipArchive archive)
        {
            EmbeddedSchemaFieldDefinition taggedImageField = (EmbeddedSchemaFieldDefinition)taggedImageList.Definition;
            Schema       taggedImageSchema               = taggedImageField.EmbeddedSchema;
            SchemaFields taggedImageSchemaFields         = new SchemaFields(taggedImageSchema);
            MultimediaLinkFieldDefinition mmLinkFieldDef = (MultimediaLinkFieldDefinition)taggedImageSchemaFields.Fields[1];
            Schema imageSchema = mmLinkFieldDef.AllowedTargetSchemas[0];
            Folder imageFolder = null;

            var taggedImageNames = new List <string>();
            var foundImages      = new Dictionary <string, Component>();

            foreach (var node in htmlDoc.DocumentNode.QuerySelectorAll("[data-image-name]"))
            {
                if (imageFolder == null)
                {
                    imageFolder       = new Folder(parentFolder.Session, parentFolder.Id);
                    imageFolder.Title = componentTitle + " " + "Images";
                    imageFolder.Save();
                }

                //Logger.Write("Processing image tag...", "CampaignZipImporter", LogCategory.Custom, System.Diagnostics.TraceEventType.Information);

                var imageUrl        = node.Attributes["src"];
                var taggedImageName = node.Attributes["data-image-name"];
                if (imageUrl != null && taggedImageName != null && !taggedImageNames.Contains(taggedImageName.Value))
                {
                    ZipArchiveEntry imageEntry = archive.GetEntry(imageUrl.Value);
                    if (imageEntry != null)
                    {
                        Component imageComponent;
                        if (foundImages.TryGetValue(imageUrl.Value, out imageComponent) == false)
                        {
                            imageComponent = new Component(parentFolder.Session, imageFolder.Id);
                            var imageName   = Path.GetFileName(imageUrl.Value);
                            var metadataXml = new XmlDocument();
                            metadataXml.LoadXml("<Metadata xmlns=\"" + imageSchema.NamespaceUri + "\"/>");
                            imageComponent.Schema   = imageSchema;
                            imageComponent.Metadata = metadataXml.DocumentElement;
                            imageComponent.Title    = imageName;

                            var  extension   = Path.GetExtension(imageUrl.Value).ToLower();
                            bool foundMMType = false;
                            foreach (var mmType in imageSchema.AllowedMultimediaTypes)
                            {
                                if (mmType.FileExtensions.Contains(extension))
                                {
                                    imageComponent.BinaryContent.MultimediaType = mmType;
                                    foundMMType = true;
                                    break;
                                }
                            }
                            if (!foundMMType)
                            {
                                Logger.Write("Could not find multimedia type for image extension: " + extension, "CampaignZipImporter", LogCategory.Custom, System.Diagnostics.TraceEventType.Error);
                            }

                            imageComponent.BinaryContent.UploadFromStream = imageEntry.Open();
                            imageComponent.BinaryContent.Filename         = imageName;
                            imageComponent.Save(true);
                            foundImages.Add(imageUrl.Value, imageComponent);
                        }
                        var taggedImageXml = new StringBuilder();
                        taggedImageXml.Append("<TaggedImage xmlns:xlink=\"http://www.w3.org/1999/xlink\"><name>");
                        taggedImageXml.Append(taggedImageName.Value);
                        taggedImageXml.Append("</name><image xlink:type=\"simple\" xlink:href=\"");
                        taggedImageXml.Append(imageComponent.Id);
                        taggedImageXml.Append("\" xlink:title=\"");
                        taggedImageXml.Append(imageComponent.Title);
                        taggedImageXml.Append("\" /></TaggedImage>");

                        XmlDocument xmlDoc = new XmlDocument();
                        xmlDoc.LoadXml(taggedImageXml.ToString());
                        ItemFields taggedImage = new ItemFields(xmlDoc.DocumentElement, taggedImageSchema);
                        taggedImageList.Values.Add(taggedImage);
                        taggedImageNames.Add(taggedImageName.Value);
                    }
                }
            }
        }
 protected List<KeyValuePair<TcmUri, string>> GetOrganizationalItemContents(OrganizationalItem orgItem, ItemType itemType, bool recursive)
 {
     OrganizationalItemItemsFilter filter = new OrganizationalItemItemsFilter(orgItem.Session)
         {
             ItemTypes = new List<ItemType> { itemType },
             Recursive = recursive
         };
     return XmlElementToTcmUriList(orgItem.GetListItems(filter));
 }
 protected OrganizationalItem GetChildOrganizationalItem(OrganizationalItem root, string title)
 {
     foreach (KeyValuePair<TcmUri, string> child in GetOrganizationalItemContents(root, root is Folder ? ItemType.Folder : ItemType.StructureGroup, false))
     {
         if (child.Value.ToLower() == title.ToLower())
         {
             return (OrganizationalItem)Engine.GetObject(child.Key);
         }
     }
     return null;
 }
Example #27
0
 /// <summary>
 /// Creates a new Tridion collection by calling GetListItems using the provided filter on the provided organizational item
 /// </summary>
 /// <param name="engine">An instantiated Engine object <typeparamref name="Tridion.ContentManager.Templating.Engine"/></param>
 /// <param name="root">The organizational element to get the list of items for</param>
 /// <param name="filter">An instantiated Filter object with preset conditions</param>
 /// <param name="itemXmlName">In some GetListItems methods the xml element name is different from 'Item' this allows for a different name</param>
 public TridionCollectionBase(Engine engine, OrganizationalItem root, Filter filter, string itemXmlName)
     : this(engine, root.GetListItems(new OrganizationalItemItemsFilter(filter, engine.GetSession())), itemXmlName)
 {
 }
Example #28
0
        protected List <KeyValuePair <TcmUri, string> > GetOrganizationalItemContents(OrganizationalItem orgItem, ItemType itemType, bool recursive)
        {
            //Filter filter = new Filter();
            //filter.Conditions.Add("ItemType", itemType);
            //filter.Conditions.Add("Recursive", recursive);
            OrganizationalItemItemsFilter filter = new OrganizationalItemItemsFilter(orgItem.Session)
            {
                ItemTypes = new List <ItemType> {
                    itemType
                }, Recursive = recursive
            };
            List <KeyValuePair <TcmUri, string> > res = new List <KeyValuePair <TcmUri, string> >();

            foreach (XmlNode item in orgItem.GetListItems(filter).SelectNodes("/*/*"))
            {
                string title = item.Attributes["Title"].Value;
                TcmUri id    = new TcmUri(item.Attributes["ID"].Value);
                res.Add(new KeyValuePair <TcmUri, string>(id, title));
            }
            return(res);
        }
Example #29
0
        protected List <KeyValuePair <TcmUri, string> > GetOrganizationalItemContents(OrganizationalItem orgItem, ItemType itemType, bool recursive)
        {
            OrganizationalItemItemsFilter filter = new OrganizationalItemItemsFilter(orgItem.Session)
            {
                ItemTypes = new List <ItemType> {
                    itemType
                },
                Recursive = recursive
            };

            return(XmlElementToTcmUriList(orgItem.GetListItems(filter)));
        }
Example #30
0
 public TridionCollection(Engine engine, OrganizationalItem root, Filter filter, string itemXmlName) : base(engine, root, filter, itemXmlName)
 {
 }
 public static IEnumerable <Component> GetComponents(this OrganizationalItem folder, bool recursive)
 {
     return(GetComponents(folder, Enumerable.Empty <Schema>(), recursive));
 }
Example #32
0
        /// <summary>
        /// Process images
        /// </summary>
        /// <param name="htmlDoc"></param>
        /// <param name="taggedImageList"></param>
        /// <param name="parentFolder"></param>
        /// <param name="componentTitle"></param>
        /// <param name="archive"></param>
        private static void ProcessImages(HtmlDocument htmlDoc, EmbeddedSchemaField taggedImageList, OrganizationalItem parentFolder, String componentTitle, ZipArchive archive)
        {
            EmbeddedSchemaFieldDefinition taggedImageField = (EmbeddedSchemaFieldDefinition)taggedImageList.Definition;
            Schema       taggedImageSchema               = taggedImageField.EmbeddedSchema;
            SchemaFields taggedImageSchemaFields         = new SchemaFields(taggedImageSchema);
            MultimediaLinkFieldDefinition mmLinkFieldDef = (MultimediaLinkFieldDefinition)taggedImageSchemaFields.Fields.Where(field => field.Name.Equals("image")).First();
            Schema imageSchema = mmLinkFieldDef.AllowedTargetSchemas[0];
            Folder imageFolder = null;

            var taggedImageNames     = new List <string>();
            var foundImages          = new Dictionary <string, Component>();
            var imageFolderWebDavUrl = parentFolder.WebDavUrl + "/" + componentTitle + " Images";

            foreach (var node in htmlDoc.DocumentNode.QuerySelectorAll("[data-image-name]"))
            {
                var imageUrl = node.Attributes["src"];

                //Logger.Write("Processing image tag...", "CampaignZipImporter", LogCategory.Custom, System.Diagnostics.TraceEventType.Information);

                var taggedImageName = node.Attributes["data-image-name"];
                if (imageUrl != null && taggedImageName != null && !taggedImageNames.Contains(taggedImageName.Value) && !IsEntryAlreadyDefined(taggedImageName.Value, taggedImageList))
                {
                    //Logger.Write("Adding image with name: " + taggedImageName.Value, "CampaignZipImporter", LogCategory.Custom, System.Diagnostics.TraceEventType.Information);

                    if (imageUrl != null && !imageUrl.Value.StartsWith("http"))
                    {
                        if (imageFolder == null)
                        {
                            if (parentFolder.Session.IsExistingObject(imageFolderWebDavUrl))
                            {
                                imageFolder = (Folder)parentFolder.Session.GetObject(imageFolderWebDavUrl);
                            }
                            else
                            {
                                // Create folder
                                //
                                imageFolder       = new Folder(parentFolder.Session, parentFolder.Id);
                                imageFolder.Title = componentTitle + " Images";
                                imageFolder.Save();
                            }
                        }
                    }

                    // If an absolute image URL
                    //
                    else if (imageUrl != null && imageUrl.Value.StartsWith("http"))
                    {
                        var    url        = imageUrl.Value;
                        string parameters = null;
                        if (url.Contains("?"))
                        {
                            var parts = url.Split(new char[] { '?' }, StringSplitOptions.RemoveEmptyEntries);
                            url        = parts[0];
                            parameters = parts[1];
                        }
                        var taggedImageXml = new StringBuilder();
                        taggedImageXml.Append("<TaggedImage xmlns:xlink=\"http://www.w3.org/1999/xlink\"><name>");
                        taggedImageXml.Append(taggedImageName.Value);
                        taggedImageXml.Append("</name><imageUrl>");
                        taggedImageXml.Append(SecurityElement.Escape(url));
                        taggedImageXml.Append("</imageUrl>");
                        if (parameters != null)
                        {
                            taggedImageXml.Append("<parameters>");
                            taggedImageXml.Append(SecurityElement.Escape(parameters));
                            taggedImageXml.Append("</parameters>");
                        }
                        taggedImageXml.Append("</TaggedImage>");

                        XmlDocument xmlDoc = new XmlDocument();
                        xmlDoc.LoadXml(taggedImageXml.ToString());
                        ItemFields taggedImage = new ItemFields(xmlDoc.DocumentElement, taggedImageSchema);
                        taggedImageList.Values.Add(taggedImage);
                        taggedImageNames.Add(taggedImageName.Value);
                        continue;
                    }
                    ZipArchiveEntry imageEntry = archive.GetEntry(imageUrl.Value);
                    if (imageEntry != null)
                    {
                        Component imageComponent;
                        if (foundImages.TryGetValue(imageUrl.Value, out imageComponent) == false)
                        {
                            var imageName      = Path.GetFileName(imageUrl.Value);
                            var imageWebDavUri = imageFolderWebDavUrl + "/" + imageName;
                            if (parentFolder.Session.IsExistingObject(imageWebDavUri))
                            {
                                imageComponent = (Component)parentFolder.Session.GetObject(imageWebDavUri);
                            }
                            else
                            {
                                imageComponent = new Component(parentFolder.Session, imageFolder.Id);
                                var metadataXml = new XmlDocument();
                                metadataXml.LoadXml("<Metadata xmlns=\"" + imageSchema.NamespaceUri + "\"/>");
                                imageComponent.Schema   = imageSchema;
                                imageComponent.Metadata = metadataXml.DocumentElement;

                                var extension = Path.GetExtension(imageUrl.Value);
                                imageComponent.Title = imageName.Replace(extension, ""); // Set title without extension
                                extension            = extension.ToLower().Replace(".", "");

                                bool foundMMType = false;
                                foreach (var mmType in imageSchema.AllowedMultimediaTypes)
                                {
                                    if (mmType.FileExtensions.Contains(extension))
                                    {
                                        imageComponent.BinaryContent.MultimediaType = mmType;
                                        foundMMType = true;
                                        break;
                                    }
                                }
                                if (!foundMMType)
                                {
                                    Logger.Write("Could not find multimedia type for image extension: " + extension, "CampaignZipImporter", LogCategory.Custom, System.Diagnostics.TraceEventType.Error);
                                }

                                imageComponent.BinaryContent.UploadFromStream = imageEntry.Open();
                                imageComponent.BinaryContent.Filename         = imageName;
                                imageComponent.Save(true);
                            }
                            foundImages.Add(imageUrl.Value, imageComponent);
                        }
                        var taggedImageXml = new StringBuilder();
                        taggedImageXml.Append("<TaggedImage xmlns:xlink=\"http://www.w3.org/1999/xlink\"><name>");
                        taggedImageXml.Append(taggedImageName.Value);
                        taggedImageXml.Append("</name><image xlink:type=\"simple\" xlink:href=\"");
                        taggedImageXml.Append(imageComponent.Id);
                        taggedImageXml.Append("\" xlink:title=\"");
                        taggedImageXml.Append(imageComponent.Title);
                        taggedImageXml.Append("\" /></TaggedImage>");

                        XmlDocument xmlDoc = new XmlDocument();
                        xmlDoc.LoadXml(taggedImageXml.ToString());
                        ItemFields taggedImage = new ItemFields(xmlDoc.DocumentElement, taggedImageSchema);
                        taggedImageList.Values.Add(taggedImage);
                        taggedImageNames.Add(taggedImageName.Value);
                    }
                }
            }
        }
Example #33
0
 /// <summary>
 /// Creates a new Tridion collection by calling GetListItems using the provided filter on the provided organizational item
 /// </summary>
 /// <param name="engine">An instantiated Engine object <typeparamref name="Tridion.ContentManager.Templating.Engine"/></param>
 /// <param name="root">The organizational element to get the list of items for</param>
 /// <param name="filter">An instantiated Filter object with preset conditions</param>
 public TridionCollectionBase(Engine engine, OrganizationalItem root, Filter filter)
     : this(engine, root.GetListItems(new OrganizationalItemItemsFilter(filter, engine.GetSession())), String.Empty)
 {
 }
		public IEnumerable<XElement> GetListItems(OrganizationalItem parent, ItemType type) {
			return GetListItems(parent, type, ListBaseColumns.IdAndTitle);
		}
		private void GetStructureGroupToBeCreated(OrganizationalItem folder, TcmUri rootFolderId, Stack<string> sgNames) {
			if (folder != null && folder.Id != rootFolderId) {
				sgNames.Push(folder.Title);
				GetStructureGroupToBeCreated(folder.OrganizationalItem, rootFolderId, sgNames);
			}
		}
        /// <summary>
        /// Returns Configuration Components from the OrganizationalItem's metadata, possibly recursive.
        /// </summary>
        private List<Component> GetConfigurationsFromStructureGroup(OrganizationalItem organizationalItem, bool isRecursive)
        {
            List<Component> results = new List<Component>();
            results.AddRange(GetConfigurationsFromMetadata(organizationalItem.Metadata, organizationalItem.MetadataSchema));

            if (isRecursive && !organizationalItem.IsRootOrganizationalItem)
            {
                results.AddRange(GetConfigurationsFromStructureGroup(organizationalItem.OrganizationalItem, isRecursive));
            }

            return results;
        }
 public IEnumerable <XElement> GetListItems(OrganizationalItem parent, ItemType type)
 {
     return(GetListItems(parent, type, ListBaseColumns.IdAndTitle));
 }