예제 #1
0
        /// <summary>
        /// Creates a text ATOM value.
        /// </summary>
        /// <param name="textValue">The text value to use.</param>
        /// <param name="contentKind">The content kind of the value.</param>
        /// <returns>The Atom text value.</returns>
        private static AtomTextConstruct CreateAtomTextConstruct(string textValue, SyndicationTextContentKind contentKind)
        {
            AtomTextConstructKind kind;

            switch (contentKind)
            {
            case SyndicationTextContentKind.Plaintext:
                kind = AtomTextConstructKind.Text;
                break;

            case SyndicationTextContentKind.Html:
                kind = AtomTextConstructKind.Html;
                break;

            case SyndicationTextContentKind.Xhtml:
                kind = AtomTextConstructKind.Xhtml;
                break;

            default:
                throw new ODataException(o.Strings.General_InternalError(InternalErrorCodes.EpmSyndicationWriter_CreateAtomTextConstruct));
            }

            return(new AtomTextConstruct
            {
                Kind = kind,
                Text = textValue,
            });
        }
예제 #2
0
        private static AtomTextConstruct CreateAtomTextConstruct(string textValue, SyndicationTextContentKind contentKind, ODataVersion version)
        {
            // If V3 serialization is enabled write null values by adding the m:null="true" attribute.
            if (textValue == null && version >= ODataVersion.V3)
            {
                // Add the m:null attribute on the value
            }

            AtomTextConstructKind kind;

            switch (contentKind)
            {
            case SyndicationTextContentKind.Plaintext:
                kind = AtomTextConstructKind.Text;
                break;

            case SyndicationTextContentKind.Html:
                kind = AtomTextConstructKind.Html;
                break;

            case SyndicationTextContentKind.Xhtml:
                kind = AtomTextConstructKind.Xhtml;
                break;

            default:
                throw new ODataException(Strings.General_InternalError(InternalErrorCodes.EpmSyndicationWriter_CreateAtomTextConstruct));
            }

            return(new AtomTextConstruct()
            {
                Kind = kind,
                Text = textValue
            });
        }
        /// <summary>
        /// Given the string representation in <paramref name="strContentKind"/> gets back the corresponding enumerated value
        /// </summary>
        /// <param name="strContentKind">String representation of syndication content kind e.g. plaintext, html or xhtml</param>
        /// <param name="typeName">Type to which the property belongs</param>
        /// <param name="memberName">Name of the member whose extended properties we are searching from</param>
        /// <returns>Enumerated value of SyndicationTextContentKind</returns>
        private static SyndicationTextContentKind MapEpmContentKindToSyndicationTextContentKind(String strContentKind, String typeName, String memberName)
        {
            SyndicationTextContentKind contentKind = SyndicationTextContentKind.Plaintext;

            switch (strContentKind)
            {
            case System.Data.Services.XmlConstants.SyndContentKindPlaintext:
                contentKind = SyndicationTextContentKind.Plaintext;
                break;

            case System.Data.Services.XmlConstants.SyndContentKindHtml:
                contentKind = SyndicationTextContentKind.Html;
                break;

            case System.Data.Services.XmlConstants.SyndContentKindXHtml:
                contentKind = SyndicationTextContentKind.Xhtml;
                break;

            default:
                throw new InvalidOperationException(memberName == null ?
                                                    Strings.ObjectContext_InvalidValueForTargetTextContentKindPropertyType(strContentKind, typeName) :
                                                    Strings.ObjectContext_InvalidValueForTargetTextContentKindPropertyMember(strContentKind, memberName, typeName));
            }

            return(contentKind);
        }
        public EntityPropertyMappingAttribute(string sourcePath, string targetPath, string targetNamespacePrefix, string targetNamespaceUri, bool keepInContent)
        {
            Uri uri;

            if (string.IsNullOrEmpty(sourcePath))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("sourcePath"));
            }
            this.sourcePath = sourcePath;
            if (string.IsNullOrEmpty(targetPath))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("targetPath"));
            }
            if (targetPath[0] == '@')
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_InvalidTargetPath(targetPath));
            }
            this.targetPath            = targetPath;
            this.targetSyndicationItem = SyndicationItemProperty.CustomProperty;
            this.targetTextContentKind = SyndicationTextContentKind.Plaintext;
            this.targetNamespacePrefix = targetNamespacePrefix;
            if (string.IsNullOrEmpty(targetNamespaceUri))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("targetNamespaceUri"));
            }
            this.targetNamespaceUri = targetNamespaceUri;
            if (!Uri.TryCreate(targetNamespaceUri, UriKind.Absolute, out uri))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_TargetNamespaceUriNotValid(targetNamespaceUri));
            }
            this.keepInContent = keepInContent;
        }
 public EntityPropertyMappingAttribute(string sourcePath, string targetPath, string targetNamespacePrefix, string targetNamespaceUri, bool keepInContent)
 {
     Uri uri;
     if (string.IsNullOrEmpty(sourcePath))
     {
         throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("sourcePath"));
     }
     this.sourcePath = sourcePath;
     if (string.IsNullOrEmpty(targetPath))
     {
         throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("targetPath"));
     }
     if (targetPath[0] == '@')
     {
         throw new ArgumentException(Strings.EntityPropertyMapping_InvalidTargetPath(targetPath));
     }
     this.targetPath = targetPath;
     this.targetSyndicationItem = SyndicationItemProperty.CustomProperty;
     this.targetTextContentKind = SyndicationTextContentKind.Plaintext;
     this.targetNamespacePrefix = targetNamespacePrefix;
     if (string.IsNullOrEmpty(targetNamespaceUri))
     {
         throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("targetNamespaceUri"));
     }
     this.targetNamespaceUri = targetNamespaceUri;
     if (!Uri.TryCreate(targetNamespaceUri, UriKind.Absolute, out uri))
     {
         throw new ArgumentException(Strings.EntityPropertyMapping_TargetNamespaceUriNotValid(targetNamespaceUri));
     }
     this.keepInContent = keepInContent;
 }
예제 #6
0
        private static string ToAttributeValue(this SyndicationTextContentKind contentKind)
        {
            switch (contentKind)
            {
            case SyndicationTextContentKind.Html:
                return("html");

            case SyndicationTextContentKind.Xhtml:
                return("xhtml");
            }
            return("text");
        }
예제 #7
0
        internal static string MapSyndicationTextContentKindToEpmContentKind(SyndicationTextContentKind contentKind)
        {
            switch (contentKind)
            {
                case SyndicationTextContentKind.Plaintext:
                    return "text";

                case SyndicationTextContentKind.Html:
                    return "html";
            }
            return "xhtml";
        }
예제 #8
0
        internal static string MapSyndicationTextContentKindToEpmContentKind(SyndicationTextContentKind contentKind)
        {
            switch (contentKind)
            {
            case SyndicationTextContentKind.Plaintext:
                return("text");

            case SyndicationTextContentKind.Html:
                return("html");
            }
            return("xhtml");
        }
 public EntityPropertyMappingAttribute(string sourcePath, SyndicationItemProperty targetSyndicationItem, SyndicationTextContentKind targetTextContentKind, bool keepInContent)
 {
     if (string.IsNullOrEmpty(sourcePath))
     {
         throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("sourcePath"));
     }
     this.sourcePath = sourcePath;
     this.targetPath = targetSyndicationItem.ToTargetPath();
     this.targetSyndicationItem = targetSyndicationItem;
     this.targetTextContentKind = targetTextContentKind;
     this.targetNamespacePrefix = "atom";
     this.targetNamespaceUri = "http://www.w3.org/2005/Atom";
     this.keepInContent = keepInContent;
 }
 public EntityPropertyMappingAttribute(string sourcePath, SyndicationItemProperty targetSyndicationItem, SyndicationTextContentKind targetTextContentKind, bool keepInContent)
 {
     if (string.IsNullOrEmpty(sourcePath))
     {
         throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("sourcePath"));
     }
     this.sourcePath            = sourcePath;
     this.targetPath            = targetSyndicationItem.ToTargetPath();
     this.targetSyndicationItem = targetSyndicationItem;
     this.targetTextContentKind = targetTextContentKind;
     this.targetNamespacePrefix = "atom";
     this.targetNamespaceUri    = "http://www.w3.org/2005/Atom";
     this.keepInContent         = keepInContent;
 }
예제 #11
0
        /// <summary>
        /// Creates a Syndication EPM annotation on the <paramref name="annotatable"/>.
        /// </summary>
        /// <typeparam name="T">The type of the annotatable being passed in.</typeparam>
        /// <param name="annotatable">The annotatable to add the EPM annotation to.</param>
        /// <param name="sourcePath">The source path to be used in the mapping.</param>
        /// <param name="targetSyndicationItem">The syndication item to be used in the mapping (defaults to AuthorName).</param>
        /// <param name="targetTextContentKind">The target content kind (defaults to plain text).</param>
        /// <param name="keepInContent">true to keep the mapped value in content; otherwise false (defaults to true).</param>
        /// <returns>The <paramref name="annotatable"/> being passed in for composability.</returns>
        public static T EntityPropertyMapping <T>(
            this T annotatable,
            string sourcePath,
            SyndicationItemProperty targetSyndicationItem    = SyndicationItemProperty.AuthorName,
            SyndicationTextContentKind targetTextContentKind = SyndicationTextContentKind.Plaintext,
            bool keepInContent = true) where T : AnnotatedItem
        {
            ExceptionUtilities.CheckArgumentNotNull(annotatable, "annotatable");
            ExceptionUtilities.CheckArgumentNotNull(sourcePath, "sourcePath");

            ExceptionUtilities.Assert(annotatable is EntityType, "Entity Property Mappings should only be applied to entity types");

            annotatable.Add(new PropertyMappingAnnotation(sourcePath, targetSyndicationItem, targetTextContentKind, keepInContent));
            return(annotatable);
        }
        public EntityPropertyMappingAttribute(String sourcePath, SyndicationItemProperty targetSyndicationItem, SyndicationTextContentKind targetTextContentKind, bool keepInContent)
        {
            if (String.IsNullOrEmpty(sourcePath))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("sourcePath"));
            }

            this.sourcePath            = sourcePath;
            this.targetPath            = SyndicationItemPropertyToPath(targetSyndicationItem);
            this.targetSyndicationItem = targetSyndicationItem;
            this.targetTextContentKind = targetTextContentKind;
            this.targetNamespacePrefix = EntityPropertyMappingAttribute.AtomNamespacePrefix;
            this.targetNamespaceUri    = XmlConstants.AtomNamespace;
            this.keepInContent         = keepInContent;
        }
        /// <summary>
        /// Used for mapping a resource property to syndication content
        /// </summary>
        /// <param name="sourcePath">Source property path</param>
        /// <param name="targetSyndicationItem">Syndication item to which the <see cref="sourcePath"/> is mapped</param>
        /// <param name="targetTextContentKind">Syndication content kind for <see cref="targetSyndicationItem"/></param>
        /// <param name="keepInContent">If true the property value is kept in the content section as before,
        /// when false the property value is only placed at the mapped location</param>
        public EntityPropertyMappingAttribute(String sourcePath, SyndicationItemProperty targetSyndicationItem, SyndicationTextContentKind targetTextContentKind, bool keepInContent)
        {
            if (String.IsNullOrEmpty(sourcePath))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("sourcePath"));
            }

            this.sourcePath            = sourcePath;
            this.targetPath            = SyndicationItemPropertyToPath(targetSyndicationItem);
            this.targetSyndicationItem = targetSyndicationItem;
            this.targetTextContentKind = targetTextContentKind;
            this.targetNamespacePrefix = EntityPropertyMappingAttribute.AtomNamespacePrefix;
            this.targetNamespaceUri    = XmlConstants.AtomNamespace;
            this.keepInContent         = keepInContent;
        }
예제 #14
0
 /// <summary>
 /// Returns the value of the attribute for the given text content kind
 /// </summary>
 /// <param name="textKind">the text content kind</param>
 /// <returns>The value of the attribute</returns>
 public static string ToAttributeString(this SyndicationTextContentKind textKind)
 {
     if (textKind == SyndicationTextContentKind.Plaintext)
     {
         return("text");
     }
     else if (textKind == SyndicationTextContentKind.Html)
     {
         return("html");
     }
     else
     {
         ExceptionUtilities.Assert(textKind == SyndicationTextContentKind.Xhtml, "Unrecognized syndication text content kind: '{0}'", textKind);
         return("xhtml");
     }
 }
예제 #15
0
        private static EntityPropertyMappingAttribute ValidateAnnotationValues(EpmAnnotationValues annotationValues, string typeName, IEdmProperty property)
        {
            if (annotationValues.TargetPath == null)
            {
                string str     = "FC_TargetPath" + annotationValues.AttributeSuffix;
                string message = (property == null) ? Microsoft.Data.OData.Strings.EpmExtensionMethods_MissingAttributeOnType(str, typeName) : Microsoft.Data.OData.Strings.EpmExtensionMethods_MissingAttributeOnProperty(str, property.Name, typeName);
                throw new ODataException(message);
            }
            bool result = true;

            if ((annotationValues.KeepInContent != null) && !bool.TryParse(annotationValues.KeepInContent, out result))
            {
                string str3 = "FC_KeepInContent" + annotationValues.AttributeSuffix;
                throw new InvalidOperationException((property == null) ? Microsoft.Data.OData.Strings.EpmExtensionMethods_InvalidKeepInContentOnType(str3, typeName) : Microsoft.Data.OData.Strings.EpmExtensionMethods_InvalidKeepInContentOnProperty(str3, property.Name, typeName));
            }
            SyndicationItemProperty targetSyndicationItem = MapTargetPathToSyndicationProperty(annotationValues.TargetPath);

            if (targetSyndicationItem == SyndicationItemProperty.CustomProperty)
            {
                if (annotationValues.ContentKind != null)
                {
                    string str4 = "FC_ContentKind" + annotationValues.AttributeSuffix;
                    string str5 = (property == null) ? Microsoft.Data.OData.Strings.EpmExtensionMethods_AttributeNotAllowedForCustomMappingOnType(str4, typeName) : Microsoft.Data.OData.Strings.EpmExtensionMethods_AttributeNotAllowedForCustomMappingOnProperty(str4, property.Name, typeName);
                    throw new ODataException(str5);
                }
                return(new EntityPropertyMappingAttribute(annotationValues.SourcePath, annotationValues.TargetPath, annotationValues.NamespacePrefix, annotationValues.NamespaceUri, result));
            }
            if (annotationValues.NamespaceUri != null)
            {
                string str6 = "FC_NsUri" + annotationValues.AttributeSuffix;
                string str7 = (property == null) ? Microsoft.Data.OData.Strings.EpmExtensionMethods_AttributeNotAllowedForAtomPubMappingOnType(str6, typeName) : Microsoft.Data.OData.Strings.EpmExtensionMethods_AttributeNotAllowedForAtomPubMappingOnProperty(str6, property.Name, typeName);
                throw new ODataException(str7);
            }
            if (annotationValues.NamespacePrefix != null)
            {
                string str8 = "FC_NsPrefix" + annotationValues.AttributeSuffix;
                string str9 = (property == null) ? Microsoft.Data.OData.Strings.EpmExtensionMethods_AttributeNotAllowedForAtomPubMappingOnType(str8, typeName) : Microsoft.Data.OData.Strings.EpmExtensionMethods_AttributeNotAllowedForAtomPubMappingOnProperty(str8, property.Name, typeName);
                throw new ODataException(str9);
            }
            SyndicationTextContentKind plaintext = SyndicationTextContentKind.Plaintext;

            if (annotationValues.ContentKind != null)
            {
                plaintext = MapContentKindToSyndicationTextContentKind(annotationValues.ContentKind, annotationValues.AttributeSuffix, typeName, (property == null) ? null : property.Name);
            }
            return(new EntityPropertyMappingAttribute(annotationValues.SourcePath, targetSyndicationItem, plaintext, result));
        }
예제 #16
0
        /// <summary>
        /// Applies EPM mapping to the specified entity type on the model and returns it for composablity.
        /// </summary>
        /// <param name="model">Model to use</param>
        /// <param name="entityTypeName">Entity type name</param>
        /// <param name="sourcePath">Source path</param>
        /// <param name="targetSyndicationItem">TargetSyndicationItem to use</param>
        /// <param name="targetTextContentKind">TargetTextContentKind to use</param>
        /// <param name="keepInContent">true to keep the mapped value in content; otherwise false (defaults to true).</param>
        /// <returns>Enity Model Schema with the mapping applied</returns>
        public static EntityModelSchema EntityPropertyMapping(
            this EntityModelSchema model,
            string entityTypeName,
            string sourcePath,
            SyndicationItemProperty targetSyndicationItem    = SyndicationItemProperty.AuthorName,
            SyndicationTextContentKind targetTextContentKind = SyndicationTextContentKind.Plaintext,
            bool keepInContent = true)
        {
            ExceptionUtilities.CheckArgumentNotNull(model, "model");
            ExceptionUtilities.CheckArgumentNotNull(entityTypeName, "entityTypeName");
            ExceptionUtilities.CheckArgumentNotNull(sourcePath, "sourcePath");
            var entityType = model.GetEntityType(entityTypeName);

            ExceptionUtilities.CheckObjectNotNull(entityType, "There are no entity types matching the name:{0} in the model", entityTypeName);
            entityType.EntityPropertyMapping(sourcePath, targetSyndicationItem, targetTextContentKind, keepInContent);

            return(model);
        }
        /// <summary>
        /// Used for conditional mapping to atom:link[@href] and atom:category[@term].
        /// </summary>
        /// <param name="sourcePath">Source property path.</param>
        /// <param name="targetSyndicationItem">Syndication item to which the <see cref="sourcePath"/> is mapped.</param>
        /// <param name="keepInContent">If true the property value is kept in the content section as before,
        /// when false the property value is only placed at the mapped location.</param>
        /// <param name="criteriaValue">Criteria value that is used as a condition.</param>
        public EntityPropertyMappingAttribute(String sourcePath, SyndicationItemProperty targetSyndicationItem, bool keepInContent, String criteriaValue)
        {
            if (String.IsNullOrEmpty(sourcePath))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("sourcePath"));
            }

            this.sourcePath = sourcePath;

            if (String.IsNullOrEmpty(criteriaValue))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("criteriaValue"));
            }

            this.criteriaValue         = criteriaValue;
            this.targetPath            = SyndicationItemPropertyToPath(targetSyndicationItem);
            this.targetSyndicationItem = targetSyndicationItem;
            this.targetTextContentKind = SyndicationTextContentKind.Plaintext;
            this.targetNamespacePrefix = AtomConstants.NonEmptyAtomNamespacePrefix;
            this.targetNamespaceUri    = AtomConstants.AtomNamespace;
            this.keepInContent         = keepInContent;
        }
예제 #18
0
        private static AtomTextConstruct CreateAtomTextConstruct(string textValue, SyndicationTextContentKind contentKind)
        {
            AtomTextConstructKind text;
            switch (contentKind)
            {
                case SyndicationTextContentKind.Plaintext:
                    text = AtomTextConstructKind.Text;
                    break;

                case SyndicationTextContentKind.Html:
                    text = AtomTextConstructKind.Html;
                    break;

                case SyndicationTextContentKind.Xhtml:
                    text = AtomTextConstructKind.Xhtml;
                    break;

                default:
                    throw new ODataException(Microsoft.Data.OData.Strings.General_InternalError(InternalErrorCodes.EpmSyndicationWriter_CreateAtomTextConstruct));
            }
            return new AtomTextConstruct { Kind = text, Text = textValue };
        }
        public PropertyMappingAnnotation(
            string sourcePath,
            SyndicationItemProperty targetSyndicationItem,
            SyndicationTextContentKind targetTextContentKind,
            bool keepInContent)
            : this(sourcePath, keepInContent)
        {
            this.SyndicationItemProperty = targetSyndicationItem;
            this.SyndicationTextContentKind = targetTextContentKind;

            this.TargetPath = targetSyndicationItem.ToString().ToLowerInvariant();
            if (this.TargetPath.StartsWith(ODataConstants.AuthorElementName, StringComparison.Ordinal))
            {
                this.TargetPath = this.TargetPath.Insert(ODataConstants.AuthorElementName.Length, "/");
            }
            else if (this.TargetPath.StartsWith(ODataConstants.ContributorElementName, StringComparison.Ordinal))
            {
                this.TargetPath = this.TargetPath.Insert(ODataConstants.ContributorElementName.Length, "/");
            }

            this.TargetNamespacePrefix = null;
            this.TargetNamespaceUri = ODataConstants.AtomNamespaceName;
        }
예제 #20
0
        public PropertyMappingAnnotation(
            string sourcePath,
            SyndicationItemProperty targetSyndicationItem,
            SyndicationTextContentKind targetTextContentKind,
            bool keepInContent)
            : this(sourcePath, keepInContent)
        {
            this.SyndicationItemProperty    = targetSyndicationItem;
            this.SyndicationTextContentKind = targetTextContentKind;

            this.TargetPath = targetSyndicationItem.ToString().ToLowerInvariant();
            if (this.TargetPath.StartsWith(ODataConstants.AuthorElementName, StringComparison.Ordinal))
            {
                this.TargetPath = this.TargetPath.Insert(ODataConstants.AuthorElementName.Length, "/");
            }
            else if (this.TargetPath.StartsWith(ODataConstants.ContributorElementName, StringComparison.Ordinal))
            {
                this.TargetPath = this.TargetPath.Insert(ODataConstants.ContributorElementName.Length, "/");
            }

            this.TargetNamespacePrefix = null;
            this.TargetNamespaceUri    = ODataConstants.AtomNamespaceName;
        }
예제 #21
0
        private static AtomTextConstruct CreateAtomTextConstruct(string textValue, SyndicationTextContentKind contentKind, ODataVersion version)
        {
            // If V3 serialization is enabled write null values by adding the m:null="true" attribute.
            if (textValue == null && version >= ODataVersion.V3)
            {
                // Add the m:null attribute on the value
            }

            AtomTextConstructKind kind;
            switch (contentKind)
            {
                case SyndicationTextContentKind.Plaintext:
                    kind = AtomTextConstructKind.Text;
                    break;
                case SyndicationTextContentKind.Html:
                    kind = AtomTextConstructKind.Html;
                    break;
                case SyndicationTextContentKind.Xhtml:
                    kind = AtomTextConstructKind.Xhtml;
                    break;
                default:
                    throw new ODataException(Strings.General_InternalError(InternalErrorCodes.EpmSyndicationWriter_CreateAtomTextConstruct));
            }

            return new AtomTextConstruct() 
            { 
                Kind = kind, 
                Text = textValue 
            };
        }
예제 #22
0
 /// <summary>
 /// Converts test enum SyndicationTextContentKind to product enum.
 /// </summary>
 /// <param name="contentKind">test enum value</param>
 /// <returns>product enum</returns>
 public static AtomSyndicationTextContentKind ToProductEnum(this SyndicationTextContentKind contentKind)
 {
     return(ConvertEnum <SyndicationTextContentKind, AtomSyndicationTextContentKind>(contentKind));
 }
        /// <summary>
        /// Used for conditional mapping to atom:link[@href] and atom:category[@term].
        /// </summary>
        /// <param name="sourcePath">Source property path.</param>
        /// <param name="targetSyndicationItem">Syndication item to which the <see cref="sourcePath"/> is mapped.</param>
        /// <param name="keepInContent">If true the property value is kept in the content section as before, 
        /// when false the property value is only placed at the mapped location.</param>
        /// <param name="criteriaValue">Criteria value that is used as a condition.</param>
        public EntityPropertyMappingAttribute(String sourcePath, SyndicationItemProperty targetSyndicationItem, bool keepInContent, String criteriaValue)
        {
            if (String.IsNullOrEmpty(sourcePath))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("sourcePath"));
            }

            this.sourcePath = sourcePath;

            if (String.IsNullOrEmpty(criteriaValue))
            {
                throw new ArgumentException(Strings.EntityPropertyMapping_EpmAttribute("criteriaValue"));
            }

            this.criteriaValue = criteriaValue;
            this.targetPath = SyndicationItemPropertyToPath(targetSyndicationItem);
            this.targetSyndicationItem = targetSyndicationItem;
            this.targetTextContentKind = SyndicationTextContentKind.Plaintext;
            this.targetNamespacePrefix = AtomConstants.NonEmptyAtomNamespacePrefix;
            this.targetNamespaceUri = AtomConstants.AtomNamespace;
            this.keepInContent = keepInContent;
        }