示例#1
0
		public void TestMultipleMultipartsContent()
		{
            AtomEntry entry = new AtomEntry(new Uri("http://purl.org/atom/ns#"));

            AtomContent content = new AtomContent(new Uri("http://purl.org/atom/ns#"));
			content.Content = "sample text";
			content.Mode = Mode.Xml;
			content.Type = MediaType.MultipartAlternative;
			content.XmlLang = Language.en_US;

			entry.Contents.Add(content);

            content = new AtomContent(new Uri("http://purl.org/atom/ns#"));
			content.Content = "sample text";
			content.Mode = Mode.Xml;
			content.Type = MediaType.MultipartAlternative;
			content.XmlLang = Language.en_US;
			entry.Contents.Add(content);
		}
示例#2
0
        internal new static AtomContent parse(XPathNavigator navigator) {
            AtomContent result_content = new AtomContent();
            string content = string.Empty;

            XPathNavigator temp_navigator = navigator.Clone();
            XPathNodeIterator it = temp_navigator.SelectDescendants( XPathNodeType.Element, true );

            while ( it.MoveNext() ) {
                string name = it.Current.Name.ToLower();
                int colon_index = name.IndexOf( ":" );

                if ( colon_index != -1 )
                    name = name.Split( new char[] { ':' }, 2 )[1];

                switch ( name ) {
                    case "content":
                        try {
                            XPathNavigatorReader temp_reader = new XPathNavigatorReader( temp_navigator );
                            string base_uri = temp_reader.GetAttribute( "base", XmlNamespaces.Xml );

                            if ( base_uri != null && base_uri.Length > 0 )
                                result_content.XmlBase = new Uri( base_uri );
                        } catch { }
                        try {
                            result_content.XmlLang = AtomUtility.parseLanguage( it.Current.XmlLang );
                        } catch { }
                        result_content.LocalName = name;

                        XPathNavigatorReader reader = new XPathNavigatorReader( it.Current );
                        reader.Read();
                        content = reader.ReadInnerXml();
                        break;
                }
            }

            it = temp_navigator.Select( "@*" );
            do {
                switch ( it.Current.Name.ToLower() ) {
                    case "type":
                        result_content.Type = AtomUtility.parseMediaType( it.Current.Value );
                        break;
                    /*
                     * mode はなさそうだ…。
                     */
                    case "mode":
                        switch ( it.Current.Value.ToLower() ) {
                            case "escaped":
                                result_content.Mode = EncodedMode.Escaped;
                                break;

                            case "base64":
                                result_content.Mode = EncodedMode.Base64;
                                break;
                        }
                        break;
                }
            } while ( it.MoveNext() );

            switch ( result_content.Mode ) {
                case EncodedMode.Escaped:
                    content = AtomUtility.Unescape( content );
                    break;

                case EncodedMode.Base64:
                    content = Encoding.Unicode.GetString( Base64.Decode( content ) );
                    break;
            }
            result_content.Content = content;

            return result_content;
        }
		public void TestContents()
		{
			AtomContent content = new AtomContent();
			content.Content = "sample text";
			content.Mode = Mode.Xml;
			content.Type = MediaType.TextPlain;
			
			entry.Contents.Add(content);

			Assert.AreEqual(content.LocalName, "content");
			Assert.AreEqual(content.FullName, "atom:content");
			Assert.AreSame(entry.Contents[0], content);
			Assert.AreEqual(entry.Contents[0], content);
		}
示例#4
0
		internal new static AtomContent Parse(XPathNavigator navigator)
		{
			AtomContent contentElement = new AtomContent();
			string content = String.Empty;

			XPathNavigator nav = navigator.Clone();
			
			// select the element itself
			XPathNodeIterator iter = nav.SelectDescendants(XPathNodeType.Element, true);
			while(iter.MoveNext())
			{
				string name = iter.Current.Name.ToLower();
				int idx = name.IndexOf(":");
				if(idx != -1)
					name = name.Split(new char[] {':'}, 2)[1];

				switch(name)
				{
					case "content":
						try
						{
							XPathNavigatorReader navReader = new XPathNavigatorReader(nav);
							string baseUri = navReader.GetAttribute("base", XmlNamespaces.Xml);
							if(baseUri != null && baseUri.Length > 0)
								contentElement.XmlBase =  new Uri(baseUri);
						}
						catch {}

						try
						{
							contentElement.XmlLang = Utils.Utils.ParseLanguage(iter.Current.XmlLang);
						}
						catch {}
						contentElement.LocalName = name;
						XPathNavigatorReader reader = new XPathNavigatorReader(iter.Current);
						reader.Read();
						content = reader.ReadInnerXml();
						break;
				}
			}
			
			// select the attributes
			iter = nav.Select("@*");
			do
			{
				switch(iter.Current.Name.ToLower())
				{
					case "type":
						contentElement.Type = Utils.Utils.ParseMediaType(
							iter.Current.Value);
						break;

					case "mode":
					{
						switch(iter.Current.Value.ToLower())
						{
							case "escaped":
								contentElement.Mode = Mode.Escaped;
								break;

							case "base64":
								contentElement.Mode = Mode.Base64;
								break;
						}
						break;
					}
				}
			} while(iter.MoveNext());

			switch(contentElement.Mode)
			{
				case Mode.Escaped:
					content = Utils.Utils.Unescape(content);
					break;

				case Mode.Base64:
					content = Encoding.Unicode.GetString(
						Utils.Utils.Base64Decode(content));
					break;
			}

			contentElement.Content = content;
			return contentElement;
		}
示例#5
0
        internal static AtomEntry Parse(XPathNavigator navigator)
        {
            AtomEntry entry = new AtomEntry();

            XPathNavigator    nav  = navigator.Clone();
            XPathNodeIterator iter = nav.SelectDescendants(XPathNodeType.All, true);

            while (iter.MoveNext())
            {
                string name = iter.Current.Name.ToLower();
                int    idx  = name.IndexOf(":");
                if (idx != -1)
                {
                    string prefix;
                    prefix = name.Split(new char[] { ':' }, 2)[0];
                    if (prefix == "atom")
                    {
                        name = name.Split(new char[] { ':' }, 2)[1];
                    }
                }

                switch (name)
                {
                case "entry":
                    try
                    {
                        entry.Uri     = FindAlternateUri(iter.Current);
                        entry.XmlLang = Utils.Utils.ParseLanguage(iter.Current.XmlLang);
                    }
                    catch {}
                    break;

                case "title":
                    AtomContentConstruct content = AtomContentConstruct.Parse(iter.Current);
                    entry.Title = content;
                    break;

                case "link":
                    entry.Links.Add(AtomLink.Parse(iter.Current));
                    break;

                case "author":
                    entry.Author = AtomPersonConstruct.Parse(iter.Current);
                    break;

                case "contributor":
                    entry.Contributors.Add(AtomPersonConstruct.Parse(iter.Current));
                    break;

                case "id":
                    entry.Id = new Uri(iter.Current.Value);
                    break;

                case "modified":
                    entry.Modified = AtomDateConstruct.Parse(iter.Current);
                    break;

                case "issued":
                    entry.Issued = AtomDateConstruct.Parse(iter.Current);
                    break;

                case "created":
                    entry.Created = AtomDateConstruct.Parse(iter.Current);
                    break;

                case "summary":
                    entry.Summary = AtomContentConstruct.Parse(iter.Current);
                    break;

                case "content":
                    entry.Contents.Add(AtomContent.Parse(iter.Current));
                    break;

                case "dc:title":
                case "dc:creator":
                case "dc:subject":
                case "dc:description":
                case "dc:publisher":
                case "dc:contributor":
                case "dc:date":
                case "dc:type":
                case "dc:format":
                case "dc:identifier":
                case "dc:source":
                case "dc:language":
                case "dc:relation":
                case "dc:coverage":
                case "dc:rights":
                    entry.AdditionalElements.Add(DcElement.Parse(iter.Current));
                    break;
                }
            }

            return(entry);
        }
示例#6
0
        internal new static AtomContent Parse(XPathNavigator navigator, Uri ns)
        {
            AtomContent contentElement = new AtomContent(ns);
            string      content        = String.Empty;

            XPathNavigator nav = navigator.Clone();

            // select the element itself
            XPathNodeIterator iter = nav.SelectDescendants(XPathNodeType.Element, true);

            while (iter.MoveNext())
            {
                string name = iter.Current.Name.ToLower();
                int    idx  = name.IndexOf(":");
                if (idx != -1)
                {
                    name = name.Split(new char[] { ':' }, 2)[1];
                }

                switch (name)
                {
                case "content":
                    try
                    {
                        XPathNavigatorReader navReader = new XPathNavigatorReader(nav);
                        string baseUri = navReader.GetAttribute("base", XmlNamespaces.Xml);
                        if (baseUri != null && baseUri.Length > 0)
                        {
                            contentElement.XmlBase = new Uri(baseUri);
                        }
                    }
                    catch {}

                    try
                    {
                        contentElement.XmlLang = Utils.Utils.ParseLanguage(iter.Current.XmlLang);
                    }
                    catch {}
                    contentElement.LocalName = name;
                    XPathNavigatorReader reader = new XPathNavigatorReader(iter.Current);
                    reader.Read();
                    content = reader.ReadInnerXml();
                    break;
                }
            }

            // select the attributes
            iter = nav.Select("@*");
            do
            {
                switch (iter.Current.Name.ToLower())
                {
                case "type":
                    switch (iter.Current.Value)
                    {
                    case "html":
                        contentElement.Type = MediaType.TextHtml;
                        break;

                    default:
                        contentElement.Type = Utils.Utils.ParseMediaType(
                            iter.Current.Value);
                        break;
                    }
                    break;

                case "mode":
                {
                    switch (iter.Current.Value.ToLower())
                    {
                    case "escaped":
                        contentElement.Mode = Mode.Escaped;
                        break;

                    case "base64":
                        contentElement.Mode = Mode.Base64;
                        break;
                    }
                    break;
                }
                }
            } while(iter.MoveNext());

            switch (contentElement.Mode)
            {
            case Mode.Escaped:
                content = Utils.Utils.Unescape(content);
                break;

            case Mode.Base64:
                content = Encoding.Unicode.GetString(
                    Utils.Utils.Base64Decode(content));
                break;
            }

            contentElement.Content = content;
            return(contentElement);
        }