/// <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);
}
