private static bool?IsFileMatch(MapCriteria criteria, NetworkMessageInfo source, FileData file)
        {
            string sourceValue;

            switch (criteria.SourceType)
            {
            case MappingDataType.FileValue:
                sourceValue = source.Source.FindFileValue(criteria.SourceName);
                break;

            case MappingDataType.EventValue:
                sourceValue = source.Source.FindEventValue(criteria.SourceName);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }

            if (sourceValue == null)
            {
                return(null);
            }

            switch (criteria.SourceName.ToUpper())
            {
            // Condition DateTime
            case Keywords.DATETIME_UPPER:
                DateTime sourceDateTime;
                if (DateTimeExt.TryParseWithTimeZoneRemoval(sourceValue, out sourceDateTime))
                {
                    return(sourceDateTime >= file.Start && sourceDateTime <= file.End);
                }
                return(false);

            default:
                switch (criteria.Operator)
                {
                case Keywords.EQUAL:
                    return(sourceValue == file.FindFileValue(criteria.TargetName));

                case Keywords.NOT_EQUAL:
                    return(sourceValue != file.FindFileValue(criteria.TargetName));
                }
                break;
            }
            return(null);
        }
        /// <summary>
        /// Returns True or False depending on if the Source and Target match based on the Criteria.
        /// If the Source or Target are missing fields required by the Criteria then returns NULL
        /// </summary>
        public static CriteriaMatchResult IsMatch(MapCriteria criteria, NetworkMessageInfo source, NetworkMessageInfo target, string targetPath)
        {
            string sourceValue;
            string targetValue;

            switch (criteria.SourceName)
            {
            case Keywords.DATETIME:

                DateTime sourceDateTime;
                if (!DateTimeExt.TryParseWithTimeZoneRemoval(source.Source.FindEventValue(Keywords.DATETIME), out sourceDateTime))
                {
                    return new CriteriaMatchResult {
                               IsMatch = false, SourceValue = "", TargetValue = ""
                    }
                }
                ;

                var start = sourceDateTime.AddMilliseconds(criteria.TimeConditionMs.GetValueOrDefault() * -1);
                var end   = sourceDateTime.AddMilliseconds(criteria.TimeConditionMs.GetValueOrDefault());

                DateTime targetDateTime;
                if (!DateTimeExt.TryParseWithTimeZoneRemoval(GetTargetValue(target, targetPath, Keywords.DATETIME), out targetDateTime))
                {
                    return new CriteriaMatchResult {
                               IsMatch = false, SourceValue = sourceDateTime.ToString(Keywords.DATETIMEFORMAT), TargetValue = ""
                    }
                }
                ;

                return(new CriteriaMatchResult
                {
                    IsMatch = (targetDateTime >= start && targetDateTime <= end),
                    SourceValue = sourceDateTime.ToString(Keywords.DATETIMEFORMAT),
                    TargetValue = targetDateTime.ToString(Keywords.DATETIMEFORMAT)
                });

            default:
                switch (criteria.SourceType)
                {
                case MappingDataType.FileValue:
                    sourceValue =
                        XmlDal.CacheModel.GetFile(source.Source.FilePath).FindFileValue(criteria.SourceName);

                    break;

                case MappingDataType.EventValue:
                    sourceValue = source.Source.FindEventValue(criteria.SourceName);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }

                switch (criteria.TargetType)
                {
                case MappingDataType.FileValue:
                    targetValue =
                        XmlDal.CacheModel.GetFile(targetPath).FindFileValue(criteria.TargetName);
                    break;

                case MappingDataType.EventValue:
                    targetValue = GetTargetValue(target, targetPath, criteria.TargetName);
                    break;

                default:
                    throw new ArgumentOutOfRangeException();
                }
                bool?isMatch = null;
                if (criteria.UseSourceValue && criteria.UseTargetValue)
                {
                    switch (criteria.Operator)
                    {
                    case Keywords.EQUAL:
                        isMatch = (String.Equals(criteria.SourceValue, sourceValue, StringComparison.CurrentCultureIgnoreCase)) &&
                                  (String.Equals(criteria.TargetValue, targetValue, StringComparison.CurrentCultureIgnoreCase));
                        break;

                    case Keywords.NOT_EQUAL:
                        isMatch = (!String.Equals(criteria.SourceValue, sourceValue, StringComparison.CurrentCultureIgnoreCase)) &&
                                  (String.Equals(criteria.TargetValue, targetValue, StringComparison.CurrentCultureIgnoreCase));
                        break;
                    }
                }
                else if (criteria.UseSourceValue && !criteria.UseTargetValue)
                {
                    switch (criteria.Operator)
                    {
                    case Keywords.EQUAL:
                        isMatch = (String.Equals(criteria.SourceValue, sourceValue, StringComparison.CurrentCultureIgnoreCase)) &&
                                  (String.Equals(sourceValue, targetValue, StringComparison.CurrentCultureIgnoreCase));
                        break;

                    case Keywords.NOT_EQUAL:
                        isMatch = (!String.Equals(criteria.SourceValue, sourceValue, StringComparison.CurrentCultureIgnoreCase)) &&
                                  (String.Equals(sourceValue, targetValue, StringComparison.CurrentCultureIgnoreCase));
                        break;
                    }
                }
                else if (!criteria.UseSourceValue && criteria.UseTargetValue)
                {
                    switch (criteria.Operator)
                    {
                    case Keywords.EQUAL:
                        isMatch = (String.Equals(criteria.TargetValue, targetValue, StringComparison.CurrentCultureIgnoreCase)) &&
                                  (String.Equals(sourceValue, targetValue, StringComparison.CurrentCultureIgnoreCase));
                        break;

                    case Keywords.NOT_EQUAL:
                        isMatch = (!String.Equals(criteria.TargetValue, targetValue, StringComparison.CurrentCultureIgnoreCase)) &&
                                  (String.Equals(sourceValue, targetValue, StringComparison.CurrentCultureIgnoreCase));
                        break;
                    }
                }
                else if (!criteria.UseSourceValue && !criteria.UseTargetValue)
                {
                    switch (criteria.Operator)
                    {
                    case Keywords.EQUAL:
                        isMatch = (String.Equals(sourceValue, targetValue, StringComparison.CurrentCultureIgnoreCase));
                        break;

                    case Keywords.NOT_EQUAL:
                        isMatch = (!String.Equals(sourceValue, targetValue, StringComparison.CurrentCultureIgnoreCase));
                        break;
                    }
                }

                if (isMatch != null)
                {
                    return(new CriteriaMatchResult
                    {
                        IsMatch = isMatch.Value,
                        SourceValue = sourceValue,
                        TargetValue = targetValue,
                        CriteriaSourceValue = criteria.SourceValue,
                        CriteriaTargetValue = criteria.TargetValue
                    });
                }

                break;
            }
            return(new CriteriaMatchResult
            {
                IsMatch = false,
                SourceValue = sourceValue,
                TargetValue = targetValue
            });
        }