private bool Validate(object obj, WSParam xParam, JsonWriter writer, JsonSerializer serializer, WSSchema schema, WSSource xSource, WSParamList outFields, ref WSStatus status, WSRequest Request, MetaFunctions CFunc)
{
try
{
if (this is WSDynamicEntity && schema == null)
{
status.CODE = WSStatus.ERROR.CODE; status.AddNote("No schema defined", WSConstants.ACCESS_LEVEL.READ);
}
else if (xParam == null)
{
status.CODE = WSStatus.ERROR.CODE; status.AddNote("Undefined parameters are not allowed", WSConstants.ACCESS_LEVEL.READ);
}
else
{
bool IsOwner = false;//TODO@ANDVO:2015-09-11 : ADD IsOwner validation check
int paramAccessLevel = xParam.READ_ACCESS_MODE.ACCESS_LEVEL;
paramAccessLevel = (xSource != null && xSource.AccessLevel > paramAccessLevel) ? xSource.AccessLevel : paramAccessLevel;
if (Request.Security.AuthToken.User.role < paramAccessLevel && !IsOwner)
{
#region ACCESS DENIED HANDLING
if (xSource != null && xSource.ShowMessageInaccessible)
{
string accessNote = "Access denied";
status.CODE = WSStatus.ATTANTION.CODE;
status.AddNote(accessNote, WSConstants.ACCESS_LEVEL.READ);
WritePropName(writer, xParam.NAME);
serializer.Serialize(writer, accessNote);
}
#endregion
}
else
{
if (!WSParamList.IsEmpty(outFields) && !outFields.Any(a => a.Match(schema.Name)))
{
}
else
{
if (obj == null && !xParam.SkipEmpty)
{
obj = string.Empty;
status.CODE = WSStatus.ATTANTION.CODE;
status.AddNote("Can not write NULL to [" + xParam.DISPLAY_NAME + "]. Value set to empty string.", WSConstants.ACCESS_LEVEL.READ);
}
if (obj != null)
{
status.AddNote("done", WSConstants.ACCESS_LEVEL.READ);
return(true);
}
}
}
}
}
catch (Exception e) {
status.CODE = WSStatus.ERROR.CODE; status.AddNote("Error(line" + e.LineNumber() + "- " + e.Message + ")");
CFunc.RegError(GetType(), e, ref status);
}
return(false);
}
private bool validateType(JsonWriter writer, WSParam xParam, object obj, List <Type> printedTypes, bool ignoreCurcularity, WSRequest Request, MetaFunctions CFunc)
{
bool isValid = false;
if (obj != null && Request.Security != null && Request.Security.IsValid && xParam != null)
{
byte uRole = Request.Security.IsLogged ? Request.Security.AuthToken.User.role : WSConstants.ACCESS_LEVEL.READ;
int paramAccessLevel = xParam.READ_ACCESS_MODE.ACCESS_LEVEL;
WSTableSource xSource = (WSTableSource)CFunc.GetSourceByType(obj.GetType());
paramAccessLevel = (xSource != null && xSource.AccessLevel > paramAccessLevel) ? xSource.AccessLevel : paramAccessLevel;
bool showCycledTypesMessage = uRole >= WSConstants.ACCESS_LEVEL.ADMIN && xSource != null && xSource.ShowMessageInaccessible;
Type entityType = null;
if (obj.IsCollection())
{
if (obj.IsCollectionOf <WSEntity>())
{
entityType = (obj as IList).GetEntityType();
}
else if (obj.IsCollectionOf <WSRecord>() && (obj as IList).Count > 0)
{
entityType = ((WSRecord)(obj as IList)[0]).entity.GetType();
}
}
else if (obj is WSRecord)
{
entityType = ((WSRecord)obj).entity.GetType();
}
else if (obj is WSEntity)
{
entityType = obj.GetType();
}
bool Ignore = ignoreCurcularity ? false : (printedTypes != null && printedTypes.Any(t => t == entityType));
if (Ignore)
{
if (showCycledTypesMessage)
{
WritePropName(writer, xParam.NAME);
writer.WriteValue("[unavailable : cycled references detected]");
}
}
else
{
if (entityType.IsValidDynamicEntity())
{
WSSource src = CFunc.GetSourceByType(entityType);
isValid = src != null && uRole >= src.AccessLevel;
}
else
{
isValid = true;
}
}
}
return(isValid);
}
private object getMemberValue(WSEntity entity, WSParam eParam, MetaFunctions CFunc)
{
WSTableSource xSource = (WSTableSource)CFunc.GetSourceByType(entity.GetType());
IEnumerable <MemberInfo> eMembers = xSource.ReturnType.GetMembers().Where(m => m is PropertyInfo || m is FieldInfo);
MemberInfo eField = eMembers.FirstOrDefault(m => eParam.Match(m.Name));
return(eField is PropertyInfo ? ((PropertyInfo)eField).GetValue(entity, null) : eField is FieldInfo ? ((FieldInfo)eField).GetValue(entity) : null);
}
public void ReadXmlContent(System.Xml.XmlReader reader, Func <Type, WSTableSource> getTSource)
{
base.ReadXmlContent(reader);
bool done = false;
while (reader.MoveToContent() == XmlNodeType.Element)
{
switch (reader.Name)
{
case "params":
{
if (reader.ReadToDescendant("param"))
{
while (reader.MoveToContent() == XmlNodeType.Element)
{
string pName = reader.GetAttribute("name");
WSParam param = GetXParam(pName, null, getTSource);
if (param == null)
{
reader.Skip();
continue;
}
else
{
if (param is WSTableParam)
{
((WSTableParam)param).ReadXml(reader);
}
else
{
param.ReadXml(reader);
}
}
reader.MoveToContent();
if (!reader.Read())
{
break;
}
}
}
break;
}
default:
{
done = true;
break;
}
}
reader.MoveToContent();
if (done || !reader.Read())
{
break;
}
}
}
private WSStatus WriteJMembers(IEnumerable <MemberInfo> members, JsonWriter writer, JsonSerializer serializer, WSEntitySchema eSchema, WSSource xSource, WSParamList outFields, List <Type> printedTypes, WSRequest Request, MetaFunctions CFunc, WSDataContext DBContext)
{
WSStatus status = WSStatus.NONE_Copy();
try
{
Type eType = GetType();
object obj = null;
WSParam param = null;
if (this is WSDynamicEntity)
{
foreach (WSSchema fieldSchema in eSchema.Fields /*.Items*/)
{
if (fieldSchema is WSFieldSchema)
{
param = ((WSFieldSchema)fieldSchema).param;
}
else if (fieldSchema is WSEntityBaseSchema)
{
param = GetParam(xSource, fieldSchema.Name);
}
//else if (childSchema is WSEntitySchema) { param = GetParam(childSchema.Name); }
//else if (childSchema is WSEntityListSchema) { param = GetParam(((WSEntityListSchema)childSchema).EntitySchema.Name); }
MemberInfo member = param == null ? null : members.FirstOrDefault(p => param.Match(p.Name, null, null, false));
obj = member == null ? null : member is PropertyInfo ? ((PropertyInfo)member).GetValue(this, null) : member is FieldInfo ? ((FieldInfo)member).GetValue(this) : null;
if (param != null)
{
status.childs.Add(WriteJProperty(obj, param, writer, serializer, fieldSchema, xSource, outFields, printedTypes, Request, CFunc, DBContext));
}
}
}
else if (this is WSStaticEntity)
{
foreach (MemberInfo member in members)
{
param = GetParam(xSource, member.Name, member.ReflectedType);
obj = member is PropertyInfo ? ((PropertyInfo)member).GetValue(this, null) : member is FieldInfo ? ((FieldInfo)member).GetValue(this) : null;
if (param != null)
{
status.childs.Add(WriteJProperty(obj, param, writer, serializer, null, xSource, outFields, printedTypes, Request, CFunc, DBContext));
}
}
}
status.AddNote("done", WSConstants.ACCESS_LEVEL.READ);
}
catch (Exception e)
{
status.CODE = WSStatus.ERROR.CODE;
status.AddNote("Error(line" + e.LineNumber() + "- " + e.Message + ")");
CFunc.RegError(GetType(), e, ref status);
}
return(status);
}
public static bool ContainsParam(this Dictionary <string, string> dict, WSParam param)
{
if (dict != null && dict.Any() && param != null)
{
try
{
return(dict.ContainsKey(param.NAME) || (param.ALIACES != null && dict.Keys.Any(key => param.ALLOWED_VALUES.Any(value => value.Match(key)))));
}
catch (Exception) { }
}
return(false);
}
private WSParam GetParam(WSSource xSource, string name, Type DefaultFieldType = null)
{
WSParam xParam = null;
if (this is WSDynamicEntity && xSource != null)
{
xParam = xSource.GetXParam(name, DefaultFieldType);
}
else if (this is WSStaticEntity || this is WSV1ResponseEntity)
{
xParam = new WSParam(0, name, DefaultFieldType, null);
}
return(xParam);
}
public override Expression SortTable <TEntity>(MetaFunctions CFunc, WSDataContext dc, List <PropertyInfo> parents, Expression expression, ref WSStatus iostatus)
{
try
{
if (dc != null)
{
parents = parents != null ? parents : new List <PropertyInfo>();
Type srcType = parents.Any() ? parents.LastOrDefault().PropertyType.IsCollection() ? parents.LastOrDefault().PropertyType.GetEntityType() : parents.LastOrDefault().PropertyType : typeof(TEntity);
ITable initSource = srcType == null ? null : dc.GetTable(typeof(TEntity));
ITable source = srcType == null ? null : dc.GetTable(srcType);
WSTableSource schema = srcType == null ? null : (WSTableSource)CFunc.GetSourceByType(srcType);
if (schema != null)
{
WSParam param = schema.GetXParam(Key);
if (param != null && param is WSTableParam)
{
WSTableParam tParam = (WSTableParam)param;
PropertyInfo property = srcType.GetProperties().FirstOrDefault(p => tParam.WSColumnRef.NAME.Equals(p.Name));
if (property == null)
{
iostatus.AddNote(string.Format("No PropertyInfo found for : [{0}]", tParam.WSColumnRef.NAME));
}
else
{
parents.Add(property);
if (tParam.DataType.IsSimple() && tParam.IsSortable)
{
bool IsDesc = false;
if (Value is WSJValue)
{
IsDesc = ((WSJValue)Value).Value.ToLower().Equals("desc");
}
expression = SortPrimitiveType <TEntity>(initSource, source, param, IsDesc, parents, expression, ref iostatus);
}
else if (tParam.DataType.IsSameOrSubclassOf(typeof(WSEntity)) || tParam.DataType.IsCollectionOf <WSEntity>())
{
expression = Value.SortTable <TEntity>(CFunc, dc, parents, expression, ref iostatus);
}
}
}
}
}
}
catch (Exception e) { CFunc.RegError(GetType(), e, ref iostatus); }
return(expression);
}
internal WSParam Clone()
{
WSParam param = new WSParam(CODE, NAME, DataType, func);
param.DISPLAY_NAME = DISPLAY_NAME;
param.READ_ACCESS_MODE = READ_ACCESS_MODE != null?READ_ACCESS_MODE.Clone() : new WSAccessMode(WSConstants.ACCESS_LEVEL.READ);
param.WRITE_ACCESS_MODE = WRITE_ACCESS_MODE != null?WRITE_ACCESS_MODE.Clone() : new WSAccessMode(WSConstants.ACCESS_LEVEL.UPDATE);
param.SkipEmpty = SkipEmpty;
param.ALLOWED_VALUES = (ALLOWED_VALUES != null && ALLOWED_VALUES.Any()) ? ALLOWED_VALUES.Select(x => x.Clone()).ToList() : new List <WSValue>();
param.ALIACES = (ALIACES != null && ALIACES.Any()) ? ALIACES.Select(x => x).ToList() : new List <string>();
param.DESCRIPTION = DESCRIPTION;
return(param);
}
public static bool ReadValue(this Dictionary <string, string> dict, WSParam key, out string value)
{
lock (ReadDictionaryLock)
{
value = null;
try
{
if (dict != null && key != null)
{
if (dict.Any(d => key.Match(d.Key)))
{
value = dict.FirstOrDefault(d => key.Match(d.Key)).Value;
return(true);
}
}
}
catch (Exception) { }
return(false);
}
}
public void Merge(WSSource ext)
{
base.Merge(ext);
PrintStatus = ext.PrintStatus;
ShowMessageInaccessible = ext.ShowMessageInaccessible;
DefaultSchemaDeepness = ext.DefaultSchemaDeepness;
if (WSConstants.ACCESS_LEVEL.LEVELS.Any(x => x == ext.AccessLevel))
{
AccessLevel_ = ext.AccessLevel;
}
foreach (WSParam orgParam in Params.OfType <WSParam>())
{
WSParam extParam = ext.Params.FirstOrDefault(p => p.Match(orgParam.NAME));
if (extParam != null)
{
orgParam.Merge(extParam);
}
}
}
public WSParam GetXParam(string xName, Type DefaultFieldType = null, Func <Type, WSTableSource> getTSource = null)
{
WSParam param = null;
try
{
if (!string.IsNullOrEmpty(xName))
{
xName = xName.ToLower();
param = Params.FirstOrDefault(p => p is WSTableParam ? ((WSTableParam)p).Match(xName, null, getTSource) : p.Match(xName, null, getTSource));
if (param == null)
{
if (DefaultFieldType != null)
{
param = new WSTableParam(ReturnType, 0, xName.ToLower(), new WSColumnRef(xName), DefaultFieldType, CFunc);
}
}
}
}
catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); }
return(param);
}
internal void Merge(WSParam param)
{
try
{
base.Merge(param);
if (param.isValid)
{
NAME = string.IsNullOrEmpty(param.NAME) ? NAME : param.NAME;
DISPLAY_NAME = string.IsNullOrEmpty(param.DISPLAY_NAME) ? DISPLAY_NAME : param.DISPLAY_NAME;
DESCRIPTION = string.IsNullOrEmpty(param.DESCRIPTION) ? DESCRIPTION : param.DESCRIPTION;
SkipEmpty = param.SkipEmpty;
READ_ACCESS_MODE.Merge(param.READ_ACCESS_MODE);
WRITE_ACCESS_MODE.Merge(param.WRITE_ACCESS_MODE);
if (param.ALLOWED_VALUES != null && param.ALLOWED_VALUES.Any(v => v.isValid))
{
ALLOWED_VALUES = param.ALLOWED_VALUES.Where(v => v.isValid).ToList();
}
}
}
catch (Exception) { }
}
internal void AddParam(WSParam _param)
{
List <WSParam> _Params = Params.ToList(); _Params.Add(_param); Params = _Params;
}
internal Expression SortPrimitiveType <TEntity>(ITable initSource, ITable source, WSParam param, bool IsDesc, List <PropertyInfo> parents, Expression expression, ref WSStatus iostatus)
{
//EXAMPLE: event.json?sort={EventID:asc} :=> Events = db.Events.OrderBy(p => p.EventID);
try
{
if (source != null && param != null && parents != null)
{
Expression sourceExpr = source.Expression;
string command = expression == null ? "OrderBy" : "ThenBy";
expression = expression == null ? initSource.Expression : expression;
command = IsDesc ? (command + "Descending") : command; //{OrderBy} / {OrderByDescending}
ParameterExpression parameter = Expression.Parameter(typeof(TEntity), "p"); //{p}
List <Type> pTypes = new List <Type> {
typeof(TEntity), parents.LastOrDefault().PropertyType
};
Expression innerExpr = CreateSortExpression(parameter, IsDesc, parents, 0);
LambdaExpression lExpr = Expression.Lambda(innerExpr, parameter); //{p=>p.EventID} / {x=>x.Organization.ID}
UnaryExpression uExpr = Expression.Quote(lExpr); //{p=>p.EventID} / {x=>x.Organization.ID}
//public static IOrderedQueryable<TSource> OrderBy<TSource, TKey>(this IQueryable<TSource> source, Expression<Func<TSource, TKey>> keySelector);
expression = Expression.Call(
typeof(Queryable),
command, //"OrderBy" OrderBy
pTypes.ToArray(), //{Event,Int32} <TSource, TKey>
expression, //{db.Events} this IQueryable<TSource> source
uExpr //{p=>p.EventID} / {x=>x.Organization.ID} Expression<Func<TSource, TKey>> keySelector
);
//}
}
}
catch (Exception) { }
return(expression);
}
public static bool IsValid(WSParam p)
{
try { return(p != null && p.isValid); } catch (Exception) { } return(false);
}
private WSStatus WriteCollapsedValues(JsonWriter writer, JsonSerializer serializer, WSEntity entity, WSSource xSource, WSJson collapseOption, WSRequest Request, MetaFunctions CFunc)
{
WSStatus status = WSStatus.NONE_Copy();
try
{
/*******************************************************************************
*
* // TODO @ANDVO : 2016-02-15 : IMPORTANT!!! => Implement security check like this :
*
* WSStatus status = Validate(obj, xParam, writer, serializer, security, schema);
* if (status.CODE == WSStatus.SUCCESS.CODE)
* {
*/
if (entity != null && collapseOption != null && collapseOption.IsValid)
{
WSTableSource childSource = (WSTableSource)CFunc.GetSourceByType(entity.GetType());
object fieldValue = null;
WSParam field = null;
if (collapseOption is WSJValue)
{
string fieldName = ((WSJValue)collapseOption).Value;
field = entity.GetParam(xSource, fieldName);
fieldValue = getMemberValue(entity, field, CFunc);
WSPrimitiveFieldSchema fieldSchema = new WSPrimitiveFieldSchema(CFunc, (WSTableParam)field, new WSJProperty(fieldName, new WSJArray()), /*((WSTableSource)entity.getSource())*/ childSource.BaseSchema);
if (Validate(fieldValue, field, writer, serializer, childSource.BaseSchema, childSource, null, ref status, Request, CFunc))
{
object _obj = null;
serializer.Serialize(writer, field.TryReadPrimitiveWithDefault(fieldValue, string.Empty, out _obj) ? _obj : string.Empty);
writer.Flush();
status = WSStatus.SUCCESS_Copy();
}
}
else if (collapseOption is WSJObject)
{
WSJProperty collapseSrc = ((WSJObject)collapseOption).Value.FirstOrDefault();
field = entity.GetParam(childSource, collapseSrc.Key);
fieldValue = getMemberValue(entity, field, CFunc);
if (Validate(fieldValue, field, writer, serializer, childSource.BaseSchema, childSource, null, ref status, Request, CFunc))
{
if (fieldValue == null)
{
serializer.Serialize(writer, "NULL");
writer.Flush();
}
else if (fieldValue is WSEntity)
{
WSTableSource fieldSource = (WSTableSource)CFunc.GetSourceByType(fieldValue.GetType());
status = WriteCollapsedValues(writer, serializer, (WSEntity)fieldValue, fieldSource, collapseSrc.Value, Request, CFunc);
}
else if (fieldValue.IsCollectionOf <WSEntity>())
{
WSTableSource fieldSource = (WSTableSource)CFunc.GetSourceByType(fieldValue.GetType().GetEntityType());
if (!((IEnumerable <WSEntity>)fieldValue).Any())
{
serializer.Serialize(writer, "NULL");
writer.Flush();
}
else
{
foreach (WSEntity eItem in (IEnumerable <WSEntity>)fieldValue)
{
status.childs.Add(WriteCollapsedValues(writer, serializer, eItem, fieldSource, collapseSrc.Value, Request, CFunc));
}
status = status.IsPositive ? WSStatus.SUCCESS_Copy() : WSStatus.ERROR_Copy();
}
}
}
}
}
/*}
*
*******************************************************************************/
}
catch (Exception e) { CFunc.RegError(GetType(), e, ref status); }
return(status);
}
private void WriteXmlValue(object obj, WSParam outputParam, Type type, XmlWriter writer)
{
WSStatus status = WSStatus.NONE.clone();
try
{
object _temp = null;
if (obj == null)
{
writer.WriteValue(string.Empty);
}
else if (obj.GetType().IsPrimitive || obj.GetType().Equals(typeof(string)))
{
writer.WriteValue(outputParam.TryReadPrimitiveWithDefault(obj, string.Empty, out _temp) ? _temp : string.Empty);
}
else if (type.IsCollection())
{
if (obj is IEnumerable)
{
IEnumerable enu = obj as IEnumerable;
if (enu == null || !enu.GetEnumerator().MoveNext())
{
writer.WriteValue(string.Empty);
}
else
{
if (obj is IList)
{
IList list = obj as IList;
Type lt = list[0].GetType();
if (lt.IsPrimitive)
{
writer.WriteValue(outputParam.TryReadPrimitiveWithDefault(obj, string.Empty, out _temp) ? _temp : string.Empty);
}
else
{
foreach (object item in list)
{
if (item is WSRecord)
{
((WSRecord)item).WriteXml(writer);
}
else
{
object _item = null; writer.WriteValue(outputParam.TryReadPrimitiveWithDefault(item, string.Empty, out _item)? _item : string.Empty);
}
}
}
}
else if (obj is IDictionary)
{
IDictionary list = obj as IDictionary;
foreach (object item in list)
{
DictionaryEntry entry = (DictionaryEntry)item;
writer.WriteStartElement(entry.Key != null ? entry.Key.ToString() : "undefined");
if (entry.Value is WSRecord)
{
((WSRecord)entry.Value).WriteXml(writer);
}
else
{
object _item = null; writer.WriteValue(outputParam.TryReadPrimitiveWithDefault(entry.Value, string.Empty, out _item)? _item : string.Empty);
}
writer.WriteEndElement();
}
}
}
}
}
else if (obj is WSRecord)
{
((WSRecord)obj).WriteXml(writer);
}
else
{
try { new XmlSerializer(obj.GetType()).Serialize(writer, obj); }
catch (Exception e) {
CFunc.RegError(GetType(), e, ref status);
writer.WriteValue(string.Empty);
}
}
}
catch (Exception e) { CFunc.RegError(GetType(), e, ref status); }
}
private WSStatus WriteJProperty(object obj, WSParam xParam, JsonWriter writer, JsonSerializer serializer, WSSchema schema, WSSource xSource, WSParamList outFields, List <Type> printedTypes, WSRequest Request, MetaFunctions CFunc, WSDataContext DBContext)
{
WSStatus status = WSStatus.NONE_Copy();
try
{
if (Validate(obj, xParam, writer, serializer, schema, xSource, outFields, ref status, Request, CFunc))
{
if (obj == null)
{
WritePropName(writer, ((schema != null && !string.IsNullOrEmpty(schema.Name)) ? schema.Name : xParam.NAME), true, PrintMode.ValueCell);
serializer.Serialize(writer, obj);
}
else if (obj is WSStatus || obj is WSStatus_JSON)
{
#region PRINT WSStatus
WSStatus_JSON json = obj is WSStatus_JSON ? (WSStatus_JSON)obj : ((WSStatus)obj).GetJson();
if (json != null)
{
WritePropName(writer, ((schema != null && !string.IsNullOrEmpty(schema.Name)) ? schema.Name : xParam.NAME), true, PrintMode.TableHeader);
serializer.Serialize(writer, json);
}
#endregion
}
else if (obj.GetType().IsSimple())
{
#region PRINT PRIMITIVE FIELD
if (obj is DateTime)
{
obj = ((DateTime)obj).ToString(WSConstants.DATE_FORMAT);
}
else if (obj is TimeSpan)
{
obj = ((TimeSpan)obj).ToString(WSConstants.TIMESPAN_FORMAT_SIMPLE);
}
WritePropName(writer, (schema != null && !string.IsNullOrEmpty(schema.Name)) ? schema.Name : xParam.NAME);
object _obj = null;
serializer.Serialize(writer, xParam.TryReadPrimitiveWithDefault(obj, string.Empty, out _obj) ? _obj : string.Empty);
#endregion
}
else if (obj.GetType().IsSimpleCollection())
{
#region PRINT PRIMITIVE COLLECTION
string key = (schema != null && !string.IsNullOrEmpty(schema.Name)) ? schema.Name : xParam.NAME;
status.AddNote("ready to searialize primitive fields (" + key + ")");
WritePropName(writer, key);
serializer.Serialize(writer, obj);
#endregion
}
else if (obj is WSRecord)
{
#region PRINT WSRecord
string pKey = (schema != null && !string.IsNullOrEmpty(schema.Name)) ? schema.Name : xParam.NAME;
WritePropName(writer, pKey);
((WSRecord)obj).WriteJson(writer, serializer, printedTypes, Request, CFunc, DBContext);
#endregion
}
else if (obj.IsCollectionOf <WSRecord>())
{
#region PRINT WSRecord Collection
string pKey = (schema != null && !string.IsNullOrEmpty(schema.Name)) ? schema.Name : xParam.NAME;
WritePropName(writer, pKey);
writer.WriteStartArray();
IList list = obj as IList;
foreach (WSRecord record in list)
{
if (record != null)
{
record.WriteJson(writer, serializer, printedTypes, Request, CFunc, DBContext);
}
}
writer.WriteEndArray();
#endregion
}
else
{
#region PRINT ENTITY
bool printAllowed =
(this is WSStaticEntity)
||
(
schema is WSEntityBaseSchema
&&
validateType(writer, xParam, obj, printedTypes, true, Request, CFunc)
);
if (printAllowed)
{
string pKey = (schema != null && !string.IsNullOrEmpty(schema.Name)) ? schema.Name : xParam.NAME;
WritePropName(writer, pKey, false);
#region PRINT WSEntity
if (obj is WSEntity)
{
if (obj is WSDynamicEntity && !((WSDynamicEntity)obj).Match(Request, DBContext, CFunc, schema))
{
serializer.Serialize(writer, "NULL");
}
else
{
((WSEntity)obj).WriteJson(writer, serializer, schema, outFields, printedTypes, Request, CFunc, DBContext);
}
}
#endregion
#region PRINT Collection
else if (obj.IsCollectionOf <WSEntity>())
{
IList list = obj as IList;
Type eType = list.GetEntityType();
writer.WriteStartArray();
foreach (WSEntity entity in list)
{
if (entity != null)
{
if (entity is WSDynamicEntity)
{
WSDynamicEntity dEntity = (WSDynamicEntity)entity;
if (dEntity.Match(Request, DBContext, CFunc, schema))
{
entity.WriteJson(writer, serializer, schema, outFields, printedTypes, Request, CFunc, DBContext);
}
}
else
{
entity.WriteJson(writer, serializer, schema, outFields, printedTypes, Request, CFunc, DBContext);
}
}
}
writer.WriteEndArray();
}
#endregion
}
#endregion
}
status.AddNote("done", WSConstants.ACCESS_LEVEL.READ);
}
}
catch (Exception e)
{
status.CODE = WSStatus.ERROR.CODE;
status.AddNote("Error(line" + e.LineNumber() + "- " + e.Message + ")");
CFunc.RegError(GetType(), e, ref status);
}
return(status);
}
public void WriteXml(XmlWriter writer)
{
try
{
writer.WriteStartElement(Name);
Type type = GetType();
bool writeAllFields = WSParamList.IsEmpty(outFields);
foreach (PropertyInfo x in type.GetProperties())
{
string xName = x.Name.ToLower();
WSParam xParam = GetParam(x.Name, x.PropertyType);
if (xParam != null && role >= xParam.READ_ACCESS_MODE.ACCESS_LEVEL)
{
if (writeAllFields)
{
writer.WriteStartElement(xName);
WriteXmlValue(x.GetValue(this, null), null, x.PropertyType, writer);
writer.WriteEndElement();
}
else
{
WSParam outputParam = outFields.FirstOrDefault(a => a.Match(xName));
if (outputParam != null)
{
writer.WriteStartElement(xName);
WriteXmlValue(x.GetValue(this, null), outputParam, x.PropertyType, writer);
writer.WriteEndElement();
}
}
}
}
foreach (FieldInfo x in type.GetFields())
{
string xName = x.Name.ToLower();
WSParam xParam = GetParam(x.Name, x.FieldType);
if (xParam != null && role >= xParam.READ_ACCESS_MODE.ACCESS_LEVEL)
{
if (writeAllFields)
{
writer.WriteStartElement(xName);
WriteXmlValue(x.GetValue(this), null, x.FieldType, writer);
writer.WriteEndElement();
}
else
{
WSParam outputParam = outFields.FirstOrDefault(a => a.Match(xName));
if (outputParam != null)
{
writer.WriteStartElement(xName);
WriteXmlValue(x.GetValue(this), outputParam, x.FieldType, writer);
writer.WriteEndElement();
}
}
}
}
writer.WriteEndElement();
}
catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status); }
}
