private static void SetObjectStateRecursive(object entity, ObjectState objectState, List <object> serializeStack, IEnumerable <Type> ignoreTypes)
{
if (entity != null)
{
var type = entity.GetType();
var entityType = typeof(Entity);
var objectStateProperty = type.GetProperty("ObjectState", BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance);
serializeStack.Add(entity);
objectStateProperty.SetValue(entity, objectState);
foreach (var property in type.GetProperties())
{
var isPropertySubclassOfEntity = property.PropertyType.IsSubclassOf(entityType);
var isEnumerableEntity = ExpressionsHelper.IsPropertyNonStringEnumerable(property.PropertyType) &&
ExpressionsHelper.GetElementType(property.PropertyType) != null &&
ExpressionsHelper.GetElementType(property.PropertyType).IsSubclassOf(entityType);
object propertyValue = null;
if (isPropertySubclassOfEntity || isEnumerableEntity)
{
propertyValue = property.GetValue(entity);
}
if (propertyValue != null)
{
if (isPropertySubclassOfEntity)
{
if (!IsCircularReference(property, propertyValue, serializeStack) && !ignoreTypes.Contains(property.PropertyType))
{
SetObjectStateRecursive(propertyValue, objectState, serializeStack, ignoreTypes);
}
}
else if (isEnumerableEntity)
{
var entityList = propertyValue as IEnumerable <object>;
if (entityList != null)
{
foreach (var entityFromList in entityList)
{
if (!IsCircularReference(property, entityFromList, serializeStack) && !ignoreTypes.Contains(entityFromList.GetType()))
{
SetObjectStateRecursive(entityFromList, objectState, serializeStack, ignoreTypes);
}
}
}
}
}
}
}
}
public override bool IsValid(object value)
{
if (value == null)
{
return(true);
}
var valueType = value.GetType();
if (valueType == typeof(FileModel))
{
var fileModel = (FileModel)value;
return(CheckFileModelSize(fileModel));
}
else if (ExpressionsHelper.IsPropertyNonStringEnumerable(valueType) && ExpressionsHelper.GetElementType(valueType) == typeof(FileModel))
{
var fileModels = value as IEnumerable <FileModel>;
if (fileModels != null)
{
foreach (var fileModel in fileModels)
{
if (!CheckFileModelSize(fileModel))
{
return(false);
}
}
return(true);
}
throw new ArgumentException("FileModels don't have any values.");
}
else
{
throw new ArgumentException("Property hast to hava a FileModel or IEnumerable<FileModel> type.");
}
}
public override async Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
MultipartMemoryStreamProvider parts = null;
try
{
parts = await content.ReadAsMultipartAsync();
}
catch (Exception e)
{
_logger.Error(e, "Client was disconnected while uploading file!");
}
var obj = Activator.CreateInstance(type);
if (parts != null)
{
var propertiesFromObj = obj.GetType().GetRuntimeProperties().ToList();
foreach (var property in propertiesFromObj)
{
if (property.PropertyType == typeof(FileModel))
{
var file = parts.Contents.FirstOrDefault(x => x.Headers.ContentDisposition.Name.Replace("\"", "").Equals(property.Name, StringComparison.InvariantCultureIgnoreCase));
if (file == null || file.Headers.ContentLength <= 0)
{
continue;
}
try
{
var fileModel = new FileModel(file.Headers.ContentDisposition.FileName.Trim('\"'), file.Headers.ContentType.MediaType, Convert.ToInt32(file.Headers.ContentLength), await file.ReadAsStreamAsync());
property.SetValue(obj, fileModel);
}
catch (Exception e)
{
_logger.Error(e, "Error while parsing property {0} for one FileModel.", property.Name);
}
}
else if (ExpressionsHelper.IsPropertyNonStringEnumerable(property.PropertyType) && ExpressionsHelper.GetElementType(property.PropertyType) == typeof(FileModel))
{
var files = parts.Contents.Where(x => x.Headers.ContentDisposition.Name.Replace("\"", "").StartsWith(property.Name, StringComparison.InvariantCultureIgnoreCase));
if (files != null && files.Count() > 0)
{
var fileModels = new List <FileModel>();
foreach (var file in files)
{
if (file.Headers.ContentDisposition != null && !string.IsNullOrWhiteSpace(file.Headers.ContentDisposition.FileName) &&
!string.IsNullOrWhiteSpace(file.Headers.ContentType.MediaType))
{
try
{
var fileModel = new FileModel(file.Headers.ContentDisposition.FileName.Trim('\"'), file.Headers.ContentType.MediaType, Convert.ToInt32(file.Headers.ContentLength), await file.ReadAsStreamAsync());
fileModels.Add(fileModel);
}
catch (Exception e)
{
_logger.Error(e, "Error while parsing property {0} for multiple FileModels.", property.Name);
}
}
}
if (property.PropertyType.IsArray)
{
property.SetValue(obj, fileModels.ToArray());
}
else
{
property.SetValue(obj, fileModels);
}
}
}
}
foreach (var property in propertiesFromObj.Where(x => ExpressionsHelper.GetElementType(x.PropertyType) != typeof(FileModel)))
{
var formData = parts.Contents.FirstOrDefault(x => x.Headers.ContentDisposition.Name.Replace("\"", "").Equals(property.Name, StringComparison.InvariantCultureIgnoreCase));
if (formData == null)
{
continue;
}
try
{
var strValue = await formData.ReadAsStringAsync();
object value = null;
if (!string.IsNullOrWhiteSpace(strValue) && strValue != "null" && strValue != "undefined")
{
strValue = strValue.Trim('\"');
if (property.PropertyType.IsEnum)
{
value = Enum.Parse(property.PropertyType, strValue, true);
}
else if (ExpressionsHelper.IsPropertyNonStringEnumerable(property.PropertyType))
{
value = JsonConvert.DeserializeObject(strValue, property.PropertyType);
}
else
{
var valueType = Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType;
value = ExpressionsHelper.GetValueFromJsonString(valueType, strValue);
}
}
property.SetValue(obj, value);
}
catch (Exception e)
{
_logger.Error(e, "Error while parsing property {0} for ViewModel.", property.Name);
}
}
}
return(obj);
}
