public static IQueryable <IArioFactField> GetFields(IArioFact fact, List <string> fieldNames)
 {
     if (fact == null)
     {
         return(null);
     }
     return(fact.Fields.Where(f => fieldNames.Contains(f.Name)).AsQueryable());
 }
 public static IArioFactField GetField(IArioFact fact, string fieldName)
 {
     return(GetFields(fact, new List <string>()
     {
         fieldName
     })
            .FirstOrDefault());
 }
        public static double?GetFieldNumericalValue(IArioFact fact, string fieldName)
        {
            var field = GetFieldValue(fact, fieldName);

            if (string.IsNullOrWhiteSpace(field))
            {
                return(null);
            }

            double result;

            double.TryParse(field, System.Globalization.NumberStyles.AllowDecimalPoint, System.Globalization.CultureInfo.InvariantCulture, out result);
            return(result);
        }
        public static double?GetFieldProbability(IArioFact fact, string fieldName)
        {
            if (fact == null)
            {
                return(null);
            }

            var field = fact.Fields.FirstOrDefault(f => f.Name == fieldName);

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

            return(field.Probability);
        }
        public static string GetFieldValue(IArioFact fact, string fieldName)
        {
            if (fact == null)
            {
                return(string.Empty);
            }

            var field = fact.Fields.FirstOrDefault(f => f.Name == fieldName);

            if (field != null)
            {
                return(field.Value);
            }

            return(string.Empty);
        }
        public static DateTime?GetFieldDateTimeValue(IArioFact fact, string fieldName)
        {
            var recognizedDate = GetFieldValue(fact, fieldName);

            if (string.IsNullOrWhiteSpace(recognizedDate))
            {
                return(null);
            }

            DateTime date;

            if (Calendar.TryParseDate(recognizedDate, out date))
            {
                return(date);
            }
            else
            {
                return(null);
            }
        }
        public static string GetFactLabel(IArioFact fact, string propertyName)
        {
            string factInfo = fact.Name + propertyName;

            foreach (var field in fact.Fields)
            {
                factInfo += field.Name + field.Value;
            }

            var factHash = string.Empty;

            using (MD5 md5Hash = MD5.Create())
            {
                byte[] data = md5Hash.ComputeHash(Encoding.UTF8.GetBytes(factInfo));
                for (int i = 0; i < data.Length; i++)
                {
                    factHash += data[i].ToString("x2");
                }
            }
            return(factHash);
        }
        public virtual IEntityRecognitionInfoFacts GetPreviousPropertyRecognitionResults(IArioFact fact,
                                                                                         string propertyName,
                                                                                         string filterPropertyValue,
                                                                                         string filterPropertyName)
        {
            var factLabel       = GetFactLabel(fact, propertyName);
            var recognitionInfo = EntityRecognitionInfos.GetAll()
                                  .Where(d => d.Facts.Any(f => f.FactLabel == factLabel && f.VerifiedValue != null && f.VerifiedValue != string.Empty) &&
                                         d.Facts.Any(f => f.PropertyName == filterPropertyName && f.PropertyValue == filterPropertyValue))
                                  .OrderByDescending(d => d.Id)
                                  .FirstOrDefault();

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

            return(recognitionInfo.Facts
                   .Where(f => f.FactLabel == factLabel && !string.IsNullOrWhiteSpace(f.VerifiedValue)).First());
        }