/// <inheritdoc/> public ICommand Convert(CommandRequest request) { // todo: Cache it per transaction / command context var type = _applicationResourceResolver.Resolve(request.Type); // todo: Verify that it is a an ICommand var instance = Activator.CreateInstance(type) as ICommand; var properties = type.GetTypeInfo().DeclaredProperties.ToDictionary(p => p.Name, p => p); // todo: Verify that the command shape matches 100% - do not allow anything else // todo: Convert to target type if mismatch request.Content.Keys.ForEach(propertyName => { if (properties.ContainsKey(propertyName)) { var property = properties[propertyName]; object value = request.Content[propertyName]; if (property.PropertyType.IsConcept()) { value = ConceptFactory.CreateConceptInstance(property.PropertyType, value); } else if (property.PropertyType == typeof(DateTimeOffset) && value.GetType() == typeof(DateTime)) { value = new DateTimeOffset((DateTime)value); } property.SetValue(instance, value); } }); return(instance); }
object HandleValue(ParameterInfo parameter, string input) { _logger.Trace($"Parameter : {parameter.Name} - {input}"); if (parameter.ParameterType == typeof(string)) { return(input); } input = Unescape(input); if (parameter.ParameterType.GetTypeInfo().IsValueType) { return(TypeDescriptor.GetConverter(parameter.ParameterType).ConvertFromInvariantString(input)); } if (parameter.ParameterType.IsConcept()) { var genericArgumentType = parameter.ParameterType.GetTypeInfo().BaseType.GetTypeInfo().GetGenericArguments()[0]; var value = input.ParseTo(genericArgumentType); return(ConceptFactory.CreateConceptInstance(parameter.ParameterType, value)); } input = _jsonInterceptor.Intercept(input); _logger.Trace($"Deserialize '{input}' into {parameter.ParameterType}"); var deserialized = _serializer.FromJson(parameter.ParameterType, input, SerializationOptions.CamelCase); return(deserialized); }
object HandleValue(Type targetType, object value) { if (value is JArray || value is JObject) { value = _serializer.FromJson(targetType, value.ToString()); } else if (targetType.IsConcept()) { value = ConceptFactory.CreateConceptInstance(targetType, value); } else if (targetType == typeof(DateTimeOffset)) { if (value is DateTime time) { value = new DateTimeOffset(time); } } else if (targetType.IsEnum) { value = Enum.Parse(targetType, value.ToString()); } else if (targetType == typeof(Guid)) { value = Guid.Parse(value.ToString()); } else { if (!targetType.IsAssignableFrom(value.GetType())) { value = System.Convert.ChangeType(value, targetType, CultureInfo.InvariantCulture); } } return(value); }
/// <inheritdoc/> public T Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { var bsonReader = context.Reader; var actualType = args.NominalType; object value = null; BsonType bsonType = bsonReader.GetCurrentBsonType(); var valueType = actualType.GetConceptValueType(); if (bsonType == BsonType.Document) // It should be a Concept object { bsonReader.ReadStartDocument(); var keyName = bsonReader.ReadName(Utf8NameDecoder.Instance); if (keyName == "Value" || keyName == "value") { value = GetDeserializedValue(valueType, ref bsonReader); bsonReader.ReadEndDocument(); } else { //Throw exception } } else { value = GetDeserializedValue(valueType, ref bsonReader); } dynamic concept = ConceptFactory.CreateConceptInstance(ValueType, value); return(concept); }
/// <inheritdoc/> public object FromJson(Type type, string json, ISerializationOptions options = null) { var serializer = CreateSerializerForDeserialization(options); using (var textReader = new StringReader(json)) { using (var reader = new JsonTextReader(textReader)) { object instance; if (type.IsConcept()) { var genericArgumentType = type.GetConceptValueType(); var value = serializer.Deserialize(reader, genericArgumentType); return(ConceptFactory.CreateConceptInstance(type, value)); } if (type.GetTypeInfo().IsValueType || type.HasInterface <IEnumerable>()) { instance = serializer.Deserialize(reader, type); } else { IEnumerable <string> propertiesMatched; instance = CreateInstanceOf(type, json, out propertiesMatched); DeserializeRemaindingProperties(type, serializer, reader, instance, propertiesMatched); } return(instance); } } }
/// <inheritdoc/> public T Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { var bsonReader = context.Reader; var actualType = args.NominalType; BsonType bsonType = bsonReader.GetCurrentBsonType(); var valueType = actualType.GetConceptValueType(); object value; // It should be a Concept object if (bsonType == BsonType.Document) { bsonReader.ReadStartDocument(); var keyName = bsonReader.ReadName(Utf8NameDecoder.Instance); if (keyName == "Value" || keyName == "value") { value = GetDeserializedValue(valueType, ref bsonReader); bsonReader.ReadEndDocument(); } else { throw new FailedConceptSerialization("Expected a concept object, but no key named 'Value' or 'value' was found on the object"); } } else { value = GetDeserializedValue(valueType, ref bsonReader); } return((dynamic)ConceptFactory.CreateConceptInstance(ValueType, value)); }
public object FromJson(Type type, string json, ISerializationOptions options = null) { var serializer = CreateSerializerForDeserialization(options); using (var textReader = new StringReader(json)) { using (var reader = new JsonTextReader(textReader)) { object instance; if (type.IsConcept()) { var genericArgumentType = type.GetTypeInfo().BaseType.GetTypeInfo().GetGenericArguments()[0]; var value = serializer.Deserialize(reader, genericArgumentType); return(ConceptFactory.CreateConceptInstance(type, value)); } if (type.GetTypeInfo().IsValueType || type.HasInterface <IEnumerable>()) { instance = serializer.Deserialize(reader, type); } else { instance = CreateInstanceOf(type, json); serializer.Populate(reader, instance); } return(instance); } } }
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { //var instance = Activator.CreateInstance(objectType); //var genericArgumentType = objectType.BaseType.GetGenericArguments()[0]; //var value = reader.Value; //if (genericArgumentType == typeof(Guid)) // value = Guid.Parse(reader.Value.ToString()); //objectType.GetProperty("Value").SetValue(instance, value, null); //return instance; return(ConceptFactory.CreateConceptInstance(objectType, reader.Value)); }
void PopulateProperties(QueryRequest descriptor, Type queryType, object instance) { foreach (var key in descriptor.Parameters.Keys) { var property = queryType .GetProperties() .SingleOrDefault(_ => _ .Name.Equals(key, StringComparison.InvariantCultureIgnoreCase)); if (property != null) { var propertyValue = descriptor.Parameters[key].ToString(); object value = null; if (property.PropertyType.IsConcept()) { var valueType = property.PropertyType.GetConceptValueType(); object underlyingValue = null; try { if (valueType == typeof(Guid)) { underlyingValue = Guid.Parse(propertyValue); } else { underlyingValue = Convert.ChangeType(propertyValue, valueType, CultureInfo.InvariantCulture); } value = ConceptFactory.CreateConceptInstance(property.PropertyType, underlyingValue); } catch { } } else { if (property.PropertyType == typeof(Guid)) { value = Guid.Parse(propertyValue); } else { value = Convert.ChangeType(propertyValue, property.PropertyType, CultureInfo.InvariantCulture); } } property.SetValue(instance, value, null); } } }
/// <inheritdoc/> public object Deserialize(BsonDeserializationContext context, BsonDeserializationArgs args) { var bsonReader = context.Reader; var actualType = args.NominalType; object value = null; var valueType = actualType.GetConceptValueType(); if (valueType == typeof(Guid)) { var binaryData = bsonReader.ReadBinaryData(); value = binaryData.ToGuid(); } else if (valueType == typeof(double)) { value = bsonReader.ReadDouble(); } else if (valueType == typeof(float)) { value = (float)bsonReader.ReadDouble(); } else if (valueType == typeof(Int32)) { value = bsonReader.ReadInt32(); } else if (valueType == typeof(Int64)) { value = bsonReader.ReadInt64(); } else if (valueType == typeof(bool)) { value = bsonReader.ReadBoolean(); } else if (valueType == typeof(string)) { value = bsonReader.ReadString(); } else if (valueType == typeof(decimal)) { value = decimal.Parse(bsonReader.ReadString()); } var concept = ConceptFactory.CreateConceptInstance(actualType, value); return(concept); }
KeyValuePair <object, object> BuildKeyValuePair(JProperty prop, Type keyType, Type valueType) { var key = ConceptFactory.CreateConceptInstance(keyType, prop.Name); var valueProp = prop.Value; object value = null; if (valueType.IsAPrimitiveType()) { value = valueProp.ToObject(valueType); } else if (valueType.IsConcept()) { value = ConceptFactory.CreateConceptInstance(valueType, valueProp.ToObject(valueType.GetConceptValueType())); } else { value = valueType == typeof(object) ? prop.First() : _serializer.FromJson(valueType, prop.Value.ToString()); } return(new KeyValuePair <object, object>(key, value)); }
/// <summary> /// Convert a string into the desired type /// </summary> /// <param name="input">the string to parse</param> /// <param name="type">the desired type</param> /// <returns>value as the desired type</returns> public static object ParseTo(this string input, Type type) { if (type == typeof(Guid)) { Guid result; if (Guid.TryParse(input, out result)) { return(result); } return(Guid.Empty); } if (type.IsConcept()) { var primitiveType = type.GetConceptValueType(); var primitive = ParseTo(input, primitiveType); return(ConceptFactory.CreateConceptInstance(type, primitive)); } return(Convert.ChangeType(input, type, null)); }
static dynamic ConstructInstanceOfType(PropertyBag pb, Type targetType, string pbKey, IObjectFactory factory) { if (!pb.ContainsKey(pbKey)) { return(null); } var value = pb[pbKey]; if (value == null) { return(null); } if (targetType.IsDate()) { return(BuildDate(value)); } if (targetType.IsDateTimeOffset()) { return(BuildDateTimeOffset(value)); } if (targetType.IsAPrimitiveType() || targetType == typeof(PropertyBag)) { return(targetType == typeof(PropertyBag)? (PropertyBag)value : value); } if (targetType.IsConcept()) { return(ConceptFactory.CreateConceptInstance(targetType, value)); } if (targetType.IsEnumerable()) { return(targetType.ConstructEnumerable(factory, value)); } return(factory.Build(targetType, value as PropertyBag)); }
object HandleValue(ParameterInfo parameter, string input) { if (parameter.ParameterType == typeof(string)) { return(input); } input = Unescape(input); if (parameter.ParameterType.IsValueType) { return(TypeDescriptor.GetConverter(parameter.ParameterType).ConvertFromInvariantString(input)); } if (parameter.ParameterType.IsConcept()) { var genericArgumentType = parameter.ParameterType.BaseType.GetGenericArguments()[0]; var value = input.ParseTo(genericArgumentType); return(ConceptFactory.CreateConceptInstance(parameter.ParameterType, value)); } input = _jsonInterceptor.Intercept(input); return(_serializer.FromJson(parameter.ParameterType, input)); }
/// <inheritdoc/> public object ConvertFrom(Type objectType, object value) { return(ConceptFactory.CreateConceptInstance(objectType, value)); }
static async Task Main(string[] args) { Console.WriteLine("This program gets the definitions of the relationship types from the Snomed site and, where the description is active, tries to find the attribute description. " + "These are then bundled up into a SQL command that you can use to create a table variable in queries"); var query = new StringBuilder("declare @RelationshipDescriptions table (id bigint, Description varchar(1000)); insert into @RelationshipDescriptions (id, Description) "); var first = true; //from: select distinct(typeid) from dbo.relationships var ids = new List <long> { 246075003, 408729009, 116676008, 116683001, 736474004, 718497002, 260669005, 309824003, 370134009, 118169006, 363703001, 418775008, 736518005, 736475003, 367346004, 4075201000001103, 272741003, 12223101000001108, 736472000, 704319004, 116678009, 738774007, 4074601000001102, 13088901000001108, 736473005, 424244007, 736476002, 370131001, 260507000, 260858005, 10363001000001101, 127489000, 363708005, 732947008, 363705008, 370130000, 424876005, 123005000, 410675002, 246456000, 763032000, 255234002, 704327008, 246454002, 424361007, 4074901000001109, 8940601000001102, 4075401000001104, 261583007, 4074801000001103, 246090004, 8941901000001101, 762949000, 84971000000100, 131195008, 246112005, 733723002, 8653101000001104, 47429007, 370133003, 726542003, 246093002, 246075003, 732946004, 363698007, 363702006, 405813007, 405816004, 116680003, 363701004, 732943007, 10546003, 10362601000001103, 246100006, 704326004, 263535000, 4074701000001107, 260686004, 10362901000001105, 246267002, 363704007, 363713009, 704321009, 733725009, 8652801000001103, 766952006, 363709002, 118168003, 363589002, 9191701000001107, 10362701000001108, 408732007, 10362801000001104, 424226004, 425391005, 704318007, 8941101000001104, 733724008, 263502005, 363710007, 42752001, 726633004, 371881003, 246501002, 260870009, 719715003, 308489006, 370129005, 370135005, 732945000, 13088501000001100, 116686009, 405814001, 8941301000001102, 419066007, 260908002, 370132008, 13089101000001102, 704324001, 408730004, 13088401000001104, 370127007, 411116001, 8940001000001105, 12223201000001101, 258214002, 733722007, 118170007, 246513007, 363699004, 408731000, 363714003, 13085501000001109, 732944001, 13088701000001106, 363715002, 363700003, 405815000, 118171006, 12223501000001103 };//{ 116680003, 408729009, 116676008, 116683001, 736474004}; foreach (var id in ids) { var description = "(Could not be found)"; try { var concept = await ConceptFactory.GetById(id); if (concept.Active) { var term = concept.Descriptions.First(descr => descr.Active && descr.Released).Term; var attributeTerm = concept.Descriptions.FirstOrDefault(descr => descr.Active && descr.Released && descr.Term.Contains("(attribute)"))?.Term; term = attributeTerm ?? term; foreach (var description1 in concept.Descriptions.Where(descr => descr.Active && descr.Released)) { Console.WriteLine($"{id}: {description1.Term}"); } Console.WriteLine($"{id} ** {term}"); description = term; } else { var term = concept.Descriptions.First().Term; Console.WriteLine($"{id} is Inactive"); description = $"(Inactive) {term}"; } } catch (System.Net.Http.HttpRequestException ex) { Console.WriteLine($"{id} EX: {ex.Message}"); } query.Append(first ?"": " union "); var sql = $"select {id},'{description}' "; first = false; query.Append(sql); } Console.WriteLine(query); }
/// <inheritdoc/> public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) { return(ConceptFactory.CreateConceptInstance(objectType, reader.Value)); }
public OrbitLoginPage(SeleniumContext seleniumContext) { this.seleniumContext = seleniumContext; ConceptFactory.InitElements(seleniumContext.Driver, this); }
/// <summary> /// Convert a <see cref="System.Protobuf.guid"/> to <see cref="ConceptAs{T}">Guid concept</see> /// </summary> /// <param name="guid"><see cref="System.Protobuf.guid"/> to convert from</param> /// <typeparam name="T">Type of <see cref="ConceptAs{T}"/> to convert to</typeparam> /// <returns>Converted instance - matching the type given</returns> public static T ToConcept <T>(this System.Protobuf.guid guid) where T : ConceptAs <Guid> { return(ConceptFactory.CreateConceptInstance(typeof(T), new Guid(guid.Value.ToByteArray())) as T); }
/// <summary> /// Get a value from a <see cref="DynamicTableEntity"/> by giving a property info representing the property to get value for /// </summary> /// <param name="entity"><see cref="DynamicTableEntity">Entity</see> to get from</param> /// <param name="propertyInfo"><see cref="PropertyInfo"/> for the property</param> /// <returns>Value of the property from the <see cref="DynamicTableEntity">entity</see></returns> public static object GetValue(DynamicTableEntity entity, PropertyInfo propertyInfo) { var valueType = propertyInfo.PropertyType; var entityProperty = entity.Properties[propertyInfo.Name]; var concept = valueType.IsConcept(); object value = null; if (concept) { valueType = valueType.GetConceptValueType(); } if (valueType == typeof(EventSourceVersion)) { value = EventSourceVersion.FromCombined(entityProperty.DoubleValue.Value); } if (valueType == typeof(Guid)) { value = entityProperty.GuidValue.Value; } if (valueType == typeof(int)) { value = entityProperty.Int32Value.Value; } if (valueType == typeof(long)) { value = entityProperty.Int64Value.Value; } if (valueType == typeof(string)) { value = entityProperty.StringValue; } if (valueType == typeof(DateTime)) { value = entityProperty.DateTime.Value; } if (valueType == typeof(DateTimeOffset)) { value = entityProperty.DateTimeOffsetValue.Value; } if (valueType == typeof(bool)) { value = entityProperty.BooleanValue.Value; } if (valueType == typeof(double)) { value = entityProperty.DoubleValue.Value; } if (valueType == typeof(float)) { value = (float)entityProperty.DoubleValue.Value; } if (concept) { return(ConceptFactory.CreateConceptInstance(propertyInfo.PropertyType, value)); } return(value); }