Exemple #1
0
        internal void Configure(WSSource Source, WSJson json)
        {
            try
            {
                if (Source != null && json != null)
                {
                    if (json is WSJProperty && ((WSJProperty)json).Value is WSJValue)
                    {
                        WSJValue vJson = (WSJValue)((WSJProperty)json).Value;
                        switch (((WSJProperty)json).Key)
                        {
                        case "readaccess":
                            byte readAccessValue = byte.TryParse(vJson.Value, out readAccessValue) ? readAccessValue : READ_ACCESS_MODE.ACCESS_LEVEL;
                            READ_ACCESS_MODE = new WSAccessMode(readAccessValue, READ_ACCESS_MODE.OWNER_ACCESS_ALLOWED);
                            break;

                        case "writeaccess":
                            byte writeAccessValue = byte.TryParse(vJson.Value, out writeAccessValue) ? writeAccessValue : WRITE_ACCESS_MODE.ACCESS_LEVEL;
                            WRITE_ACCESS_MODE = new WSAccessMode(writeAccessValue, WRITE_ACCESS_MODE.OWNER_ACCESS_ALLOWED);
                            break;

                        case "skipempty":
                            bool skipempty = vJson.Value.IsTrue() ? true : vJson.Value.IsFalse() ? false : SkipEmpty;
                            SkipEmpty = skipempty;
                            break;

                        default: break;
                        }
                    }
                }
            }
            catch (Exception) { }
        }
Exemple #2
0
 public static WSJson ToJson(this string jText)
 {
     lock (ToJsonLock)
     {
         WSJson json = null;
         try
         {
             jText = jText == null ? null : jText.Trim();
             if (!string.IsNullOrEmpty(jText))
             {
                 //WSJObject
                 if ('{' == jText.FirstOrDefault() && '}' == jText.LastOrDefault())
                 {
                     json = JsonConvert.DeserializeObject <WSJson>(jText, new WSFilterConverter());
                 }
                 //WSJArray
                 else if ('[' == jText.FirstOrDefault() && ']' == jText.LastOrDefault())
                 {
                     WSJObject jObj = (WSJObject)JsonConvert.DeserializeObject <WSJson>("{json:" + jText + "}", new WSFilterConverter());
                     json = jObj.Value[0].Value;
                 }
                 //WSJValue
                 else
                 {
                     json = new WSJValue(jText);
                 }
             }
         }
         catch (Exception) { }
         return(json);
     }
 }
Exemple #3
0
        public bool ToWSJson(string invalue, out WSJson outvalue, dynamic DEFAULT = null)
        {
            outvalue = null;
            bool ok = false;

            try
            {
                if (!string.IsNullOrEmpty(invalue))
                {
                    try
                    {
                        outvalue = invalue.ToJson();
                        ok       = outvalue != null;
                    }
                    catch (Exception) { }

                    if (!ok)
                    {
                        outvalue = (DataType.IsSimple() || WSConstants.SPECIAL_CASES.Any(c => c.Match(invalue))) ? new WSJValue(invalue)
                            : DataType.IsSameOrSubclassOf(typeof(WSEntity)) && (WSEntityFFilter.OPERATIONS.STATE_OPERATIONS.Any(c => c.Match(invalue))) ? new WSJValue(invalue)
                            : DataType.IsCollectionOf <WSEntity>() && WSEntityListFFilter.OPERATIONS.STATE_OPERATIONS.Any(c => c.Match(invalue)) ? new WSJValue(invalue)
                            : null;
                    }
                    ok = outvalue != null;
                }
            }
            catch (Exception) { }
            outvalue = ok ? outvalue : DEFAULT;
            return(ok);
        }
Exemple #4
0
 public static bool TryGetJson(this string jText, out WSJson json)
 {
     lock (TryGetJsonLock)
     {
         json = jText.ToJson();
         return(json != null);
     }
 }
Exemple #5
0
 public override bool Match(WSJson json, out WSStatus status)
 {
     status = json != null && json is WSJValue && Value.Equals(((WSJValue)json).Value) ? WSStatus.SUCCESS_Copy() : WSStatus.ERROR_Copy();
     if (status.CODE != WSStatus.SUCCESS.CODE)
     {
         status.AddNote($"Values not match:[{{current:{Value}}}<->{{original:{((WSJValue)json).Value}}}]");
         return(false);
     }
     return(true);
 }
        private WSJProperty getFieldJson(WSTableParam param, WSJson json)
        {
            WSJProperty fJson = null;

            if (json is WSJObject)
            {
                fJson = ((WSJObject)json).Value.FirstOrDefault(x => param.Match(x.Key));
            }
            else if (json is WSJArray)
            {
                fJson = ((WSJArray)json).Value.OfType <WSJObject>().FirstOrDefault(x => param.Match(x.Value[0].Key)).Value[0];
            }
            return(fJson);
        }
Exemple #7
0
        public override bool Match(WSJson json, out WSStatus status)
        {
            status = WSStatus.NONE_Copy();
            try
            {
                if (json == null)
                {
                    status = WSStatus.ERROR_Copy(); return(false);
                }
                else if (!(json is WSJObject))
                {
                    status = WSStatus.ERROR_Copy(); return(false);
                }
                else
                {
                    WSJObject            jObj  = (WSJObject)json;
                    IEnumerable <string> keys  = Value.Select(v1 => v1.Key);
                    IEnumerable <string> keys1 = jObj.Value.Select(v1 => v1.Key);
                    if (keys1.Any(p1 => !keys.Any(p => p1.Equals(p))))
                    {
                        status = WSStatus.ERROR_Copy();
                        status.AddNote($"An original service generates response with additional properties:[{keys1.Where(p1 => !keys.Any(p => p1.Equals(p))).Aggregate((a,b)=>a+","+b)}] which is not exists in current object.");
                    }
                    else if (keys.Count() != keys1.Count())
                    {
                        status = WSStatus.ERROR_Copy();
                        status.AddNote($"The current service generates response with additional properties:[{keys.Where(p1 => !keys1.Any(p => p1.Equals(p))).Aggregate((a, b) => a + "," + b)}] which is not exists in original object.");
                    }
                    else
                    {
                        foreach (WSJProperty jProp1 in jObj.Value)
                        {
                            WSJProperty jProp = Value.FirstOrDefault(x => x.Key.Equals(jProp1.Key));

                            WSStatus pStatus = jProp.Match(jProp1, out pStatus) ? WSStatus.SUCCESS_Copy() : pStatus;

                            status = pStatus;

                            if (pStatus.CODE != WSStatus.SUCCESS.CODE)
                            {
                                return(false);
                            }
                        }
                        return(!status.childs.Any(x => x.CODE != WSStatus.SUCCESS.CODE));
                    }
                }
            }
            catch (Exception) { }
            return(status.CODE == WSStatus.SUCCESS.CODE);
        }
        public List <dynamic> read(MetaFunctions CFunc, WSJson json, WSDynamicEntity _entity = null, bool multydimentional = false)
        {
            List <dynamic> result = new List <dynamic>();

            try
            {
                _entity = _entity == null ? this : _entity;
                if (json is WSJValue)
                {
                    dynamic val = readPrimitive(CFunc, (WSJValue)json, _entity); if (val != null)
                    {
                        result.Add(val);
                    }
                }
                else if (json is WSJArray)
                {
                    foreach (WSJson item in ((WSJArray)json).Value)
                    {
                        List <dynamic> val = read(CFunc, item, _entity, multydimentional);
                        if (multydimentional)
                        {
                            result.Add(val);
                        }
                        else
                        {
                            result.AddRange(val);
                        }
                    }
                }
                else if (json is WSJObject)
                {
                    List <dynamic> val = readEntity(CFunc, ((WSJObject)json).Value[0], _entity, multydimentional);
                    if (val != null && val.Any())
                    {
                        if (multydimentional)
                        {
                            result.Add(val);
                        }
                        else
                        {
                            result.AddRange(val);
                        }
                    }
                }
            }
            catch (Exception e) { WSStatus status = WSStatus.NONE.clone(); CFunc.RegError(GetType(), e, ref status, $"read():357"); }
            return(result);
        }
 private void proceedRootParam(WSJson param)
 {
     if (param is WSJValue)
     {
         proceedRootParam((WSJValue)param);
     }
     else if (param is WSJProperty)
     {
         proceedRootParam((WSJProperty)param);
     }
     else if (param is WSJObject)
     {
         proceedRootParam((WSJObject)param);
     }
     else if (param is WSJArray)
     {
         proceedRootParam((WSJArray)param);
     }
 }
 private void proceedFieldFilter(WSJson json, ref WSFieldFilters filters)
 {
     if (json is WSJValue)
     {
         proceedFieldFilter((WSJValue)json, ref filters);
     }
     else if (json is WSJProperty)
     {
         proceedFieldFilter((WSJProperty)json, ref filters);
     }
     else if (json is WSJObject)
     {
         proceedFieldFilter((WSJObject)json, ref filters);
     }
     else if (json is WSJArray)
     {
         proceedFieldFilter((WSJArray)json, ref filters);
     }
 }
Exemple #11
0
        public void Merge(WSTableSource ext)
        {
            base.Merge(ext);

            AllowOwnerAccess = ext.AllowOwnerAccess;
            BaseFilter       = ext.BaseFilter;
            DeletableFilter  = ext.DeletableFilter;
            EditableFilter   = ext.EditableFilter;
            CreatableFilter  = ext.CreatableFilter;
            ReadableFilter   = ext.ReadableFilter;

            foreach (WSTableParam orgParam in Params.OfType <WSTableParam>())
            {
                WSTableParam extParam = ext.DBParams.FirstOrDefault(p => p.WSColumnRef.NAME.Equals(orgParam.WSColumnRef.NAME));
                if (extParam != null)
                {
                    orgParam.Merge(extParam);
                }
            }
        }
        private List <WSMemberSchema> readFieldSchema(WSJson json, out bool replace)// json => WSJValue || WSJProperty || WSJObject
        {
            replace = true;

            if (json is WSJValue)
            {
                return(readFieldSchema(new WSJProperty(((WSJValue)json).Value, new WSJArray()), out replace));
            }
            else if (json is WSJProperty)
            {
                return(readFieldSchema((WSJProperty)json, out replace));
            }
            else if (json is WSJObject)
            {
                return(readFieldSchema(((WSJObject)json).Value[0], out replace));
            }
            else if (json is WSJArray)
            {
                return(readFieldSchema(((WSJArray)json).Value[0], out replace));
            }

            return(null);
        }
        private WSJProperty mergeFilters(WSJson baseFilter, WSJProperty dynamicFilter)
        {
            WSJProperty json = null;

            if (baseFilter == null || !baseFilter.IsValid)
            {
                json = dynamicFilter;
            }
            else
            {
                List <WSJProperty> fProps = new List <WSJProperty>();
                json = new WSJProperty(Source.NAME, new WSJObject(fProps));
                foreach (WSTableParam param in Source.DBParams)
                {
                    List <WSJProperty> mProps = new List <WSJProperty>();

                    WSJProperty bpjValue = getFieldJson(param, baseFilter);
                    if (bpjValue != null && bpjValue.IsValid)
                    {
                        mProps.Add(bpjValue);
                    }

                    if (dynamicFilter != null && dynamicFilter.IsValid)
                    {
                        WSJProperty dpjValue = getFieldJson(param, dynamicFilter);
                        if (dpjValue != null && dpjValue.IsValid)
                        {
                            mProps.Add(dpjValue);
                        }
                    }

                    fProps.AddRange(mProps);
                }
            }
            return(json);
        }
Exemple #14
0
 public abstract WSFilter GetBaseFilter(WSRequest Request, Expression _member, int _level, WSJson BaseFilter = null);
Exemple #15
0
 public bool Match(WSJson json)
 {
     WSStatus status = WSStatus.NONE_Copy(); return(Match(json, out status));
 }
Exemple #16
0
 public abstract bool Match(WSJson json, out WSStatus status);
Exemple #17
0
 public override WSFilter GetBaseFilter(WSRequest Request, Expression _member, int _level, WSJson BaseFilter = null)
 {
     return(null);
 }
Exemple #18
0
        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);
        }
Exemple #19
0
 public WSJOutput(WSJson _json, List <Type> _allowedValueTypes)
 {
     allowedValueTypes = _allowedValueTypes;
     json = _json;
 }
        public override WSFilter GetBaseFilter(WSRequest Request, Expression _member, int _level, WSJson _BaseFilter = null)
        {
            WSJson          BaseFilter = _BaseFilter == null ? Source.BaseFilter : _BaseFilter;
            WSCombineFilter filter     = new WSCombineFilter(WSCombineFilter.SQLMode.AndAlso);

            if (filter != null && BaseFilter != null && BaseFilter.IsValid)
            {
                Expression member = null;
                filter = BaseFilter is WSJArray ? new WSCombineFilter(WSCombineFilter.SQLMode.OrElse) : filter;

                BaseFilter.apply(Request, Func);

                if (BaseFilter != null && BaseFilter.IsValid)
                {
                    if (_member.Type == Source.ReturnType)
                    {
                        member = _member;
                    }
                    else if (Parent != null)
                    {
                        WSTableParam paramExt = (WSTableParam)Parent.Source.GetXParam(Name);
                        if (paramExt != null)
                        {
                            member = Expression.Property(_member, paramExt.WSColumnRef.NAME);
                        }
                    }

                    if (member != null)
                    {
                        if (BaseFilter is WSJValue)
                        {
                            if (((WSJValue)BaseFilter).Value.IsTrue() || ((WSJValue)BaseFilter).Value.IsFalse())
                            {
                                WSFilter subFilter = ((WSJValue)BaseFilter).GetOptionFilter(Func, member, _level);
                                if (subFilter != null)
                                {
                                    filter.Add(subFilter);
                                }
                            }
                        }
                        else if (BaseFilter is WSJObject)
                        {
                            foreach (WSJProperty item in ((WSJObject)BaseFilter).Value)
                            {
                                bool replace = true;
                                List <WSMemberSchema> _schemas = readFieldSchema(item, out replace);
                                if (_schemas.Any())
                                {
                                    foreach (WSMemberSchema _schema in _schemas)
                                    {
                                        WSFilter subFilter = _schema.GetCustomFilter(member, _level);
                                        if (subFilter != null)
                                        {
                                            filter.Add(subFilter);
                                        }
                                    }
                                }
                            }
                        }
                        else if (BaseFilter is WSJArray)
                        {
                            foreach (WSJson item in ((WSJArray)BaseFilter).Value)
                            {
                                bool replace = true;
                                List <WSMemberSchema> _schemas = readFieldSchema(item, out replace);
                                if (_schemas.Any())
                                {
                                    foreach (WSMemberSchema _schema in _schemas)
                                    {
                                        WSFilter subFilter = _schema.GetCustomFilter(member, _level);
                                        if (subFilter != null)
                                        {
                                            filter.Add(subFilter);
                                        }
                                    }
                                }
                                else if (item is WSJValue && (((WSJValue)item).Value.IsTrue() || ((WSJValue)item).Value.IsFalse()))
                                {
                                    WSFilter subFilter = ((WSJValue)item).GetOptionFilter(Func, member, _level);
                                    if (subFilter != null)
                                    {
                                        filter.Add(subFilter);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            WSFilter result = filter != null && filter.IsValid ? filter.Reduce() : null;

            return(result);
        }
Exemple #21
0
        public new void ReadXmlAttributes(XmlReader reader)
        {
            base.ReadXmlAttributes(reader);

            #region DeleteFlag
            string _DeleteFlag = reader["deleteFlag"];
            if (!string.IsNullOrEmpty(_DeleteFlag) && GetXParam(_DeleteFlag) != null)
            {
                DeleteFlag = (WSTableParam)GetXParam(_DeleteFlag);
            }
            #endregion

            #region IsReadableBySchema
            string _AttrIsReadableBySchema = reader["readable"];
            if (!string.IsNullOrEmpty(_AttrIsReadableBySchema))
            {
                if (_AttrIsReadableBySchema.IsTrue() || _AttrIsReadableBySchema.IsFalse())
                {
                    _IsReadableBySchema = _AttrIsReadableBySchema.IsTrue();
                }
                else
                {
                    _IsReadableBySchema = true;
                    ReadableFilter      = _AttrIsReadableBySchema.ToJson();
                }
            }
            #endregion

            #region IsCreatableBySchema
            string _AttrIsCreatableBySchema = reader["creatable"];
            if (!string.IsNullOrEmpty(_AttrIsCreatableBySchema))
            {
                if (_AttrIsCreatableBySchema.IsTrue() || _AttrIsCreatableBySchema.IsFalse())
                {
                    _IsCreatableBySchema = _AttrIsCreatableBySchema.IsTrue();
                }
                else
                {
                    _IsCreatableBySchema = true;
                    CreatableFilter      = _AttrIsCreatableBySchema.ToJson();
                }
            }
            #endregion

            #region IsEditableBySchema
            string _AttrIsEditableBySchema = reader["editable"];
            if (!string.IsNullOrEmpty(_AttrIsEditableBySchema))
            {
                if (_AttrIsEditableBySchema.IsTrue() || _AttrIsEditableBySchema.IsFalse())
                {
                    _IsEditableBySchema = _AttrIsEditableBySchema.IsTrue();
                }
                else
                {
                    _IsEditableBySchema = true;
                    EditableFilter      = _AttrIsEditableBySchema.ToJson();
                }
            }
            #endregion

            #region IsDeletableBySchema
            string _AttrIsDeletableBySchema = reader["deletable"];
            if (!string.IsNullOrEmpty(_AttrIsDeletableBySchema))
            {
                if (_AttrIsDeletableBySchema.IsTrue() || _AttrIsDeletableBySchema.IsFalse())
                {
                    _IsDeletableBySchema = _AttrIsDeletableBySchema.IsTrue();
                }
                else
                {
                    _IsDeletableBySchema = true;
                    DeletableFilter      = _AttrIsDeletableBySchema.ToJson();
                }
            }
            #endregion

            #region AllowOwnerAccess
            string  _AllowOwnerAccess  = reader["allowOwnerAccess"];
            dynamic _dAllowOwnerAccess = AllowOwnerAccess;
            if (!string.IsNullOrEmpty(_AllowOwnerAccess) && typeof(bool).Read(_AllowOwnerAccess, out _dAllowOwnerAccess))
            {
                AllowOwnerAccess = _dAllowOwnerAccess;
            }
            #endregion

            #region BaseFilter
            try
            {
                string _BaseFilterValue = reader["baseFilter"];
                if (!string.IsNullOrEmpty(_BaseFilterValue))
                {
                    BaseFilter = _BaseFilterValue.ToJson();
                }
            }
            catch (Exception e) { WSStatus status = WSStatusBase.NONE.clone(); CFunc.RegError(GetType(), e, ref status); }

            #endregion
        }
Exemple #22
0
        public WSCall(HttpContext _InContext)
        {
            try
            {
                if (_InContext != null)
                {
                    INPUT = new Dictionary <string, string>();

                    #region READ POST PARAMETERS
                    if (_InContext.Request.HttpMethod.Equals("POST"))
                    {
                        #region READ FORM PARAMETERS
                        foreach (string fKey in _InContext.Request.Form.AllKeys)
                        {
                            if (!string.IsNullOrEmpty(fKey))
                            {
                                string fValue = _InContext.Request.Form[fKey];
                                INPUT.Save(fKey, fValue);
                            }
                        }
                        #endregion


                        string[]             allKeys    = _InContext.Request.Params.AllKeys;
                        IEnumerable <string> actualKeys = allKeys.Where(x => x != null && !WSConstants.STANDARD_ASP_URL_PARAMS.Select(p => p.ToLower()).Contains(x.ToLower()));
                        string[]             PKeys      = actualKeys.ToArray();

                        foreach (string PKey in _InContext.Request.Params)
                        {
                            if (!string.IsNullOrEmpty(PKey))
                            {
                                if (!WSConstants.STANDARD_ASP_URL_PARAMS.Any(x => x.Equals(PKey)))
                                {
                                    bool   isValid = true;
                                    string PVal    = _InContext.Request.Params[PKey];
                                    if (PKey.ToLower().Equals("url"))
                                    {
                                        string RawUrl = _InContext.Request.RawUrl;
                                        if (PVal.Equals(RawUrl))
                                        {
                                            isValid = false;
                                        }
                                        else
                                        {
                                            PVal = PVal.Split(new char[] { ',' }).FirstOrDefault(x => !x.ToLower().Equals(RawUrl.ToLower())); isValid = !string.IsNullOrEmpty(PVal);
                                        }
                                    }
                                    if (isValid)
                                    {
                                        INPUT.Save(PKey, PVal, false);
                                    }
                                }
                            }
                            else
                            {
                                string jValue = _InContext.Request.Params[PKey];
                                status.AddNote("POST: try saving empty key {" + PKey + ":" + jValue + "}", WSConstants.ACCESS_LEVEL.READ);
                                if (!string.IsNullOrEmpty(jValue))
                                {
                                    WSJson json = jValue.ToJson();
                                    if (json == null)
                                    {
                                        status.AddNote("POST:failed convert json {" + jValue + "}. Try autoresolve.", WSConstants.ACCESS_LEVEL.READ);
                                        json = ("{data:" + jValue + "}").ToJson();
                                        json = json != null && (json is WSJObject) ? ((WSJObject)json).Value[0].Value : null;
                                    }

                                    if (json == null)
                                    {
                                        status.AddNote("POST:failed convert json {" + jValue + "}", WSConstants.ACCESS_LEVEL.READ);
                                    }
                                    else
                                    {
                                        if (json is WSJArray)
                                        {
                                            WSJArray jArray = (WSJArray)json;
                                            foreach (WSJson innerJson in jArray.Value)
                                            {
                                                if (innerJson is WSJProperty)
                                                {
                                                    WSJProperty jProp = (WSJProperty)innerJson;
                                                    INPUT.Save(jProp.Key, jProp.Value.ToString(), false);
                                                }
                                            }
                                        }
                                        else if (json is WSJObject)
                                        {
                                            foreach (WSJProperty jProp in ((WSJObject)json).Value)
                                            {
                                                string jVal = Newtonsoft.Json.JsonConvert.SerializeObject(jProp.Value, new WSFilterConverter());
                                                INPUT.Save(jProp.Key, jVal, false);
                                            }
                                        }
                                        else if (json is WSJProperty)
                                        {
                                            WSJProperty jProp = (WSJProperty)json;
                                            string      jVal  = Newtonsoft.Json.JsonConvert.SerializeObject(jProp.Value, new WSFilterConverter());
                                            INPUT.Save(jProp.Key, jVal, false);
                                        }
                                    }
                                }
                            }
                        }
                    }

                    #endregion

                    #region READ QUERY-STRING PARAMETERS
                    foreach (var queryParam in _InContext.Request.QueryString.Keys)
                    {
                        if (queryParam != null)
                        {
                            string qKey   = queryParam.ToString();
                            string qValue = _InContext.Request.QueryString[qKey];
                            INPUT.Save(qKey, qValue);
                        }
                    }
                    #endregion

                    #region READ ROUTE-DATA PARAM
                    foreach (var urlParam in _InContext.Request.RequestContext.RouteData.Values)
                    {
                        if (!WSConstants.STANDARD_ASP_URL_PARAMS.Select(p => p.ToLower()).Contains(urlParam.Key.ToLower()))
                        {
                            string uKey   = urlParam.Key;
                            string uValue = urlParam.Value.ToString();
                            INPUT.Save(uKey, uValue);
                        }
                    }
                    #endregion

                    SessionID = INPUT.Any(x => WSConstants.PARAMS.SESSIONID.Match(x.Key)) ? INPUT.FirstOrDefault(x => WSConstants.PARAMS.SESSIONID.Match(x.Key)).Value : string.Empty;
                    if (string.IsNullOrEmpty(SessionID))
                    {
                        if (_InContext.Session != null)
                        {
                            SessionID = _InContext.Session.SessionID;
                        }
                        else
                        {
                            SessionID = _InContext.Request.Params["ASP.NET_SessionId"];
                        }
                    }

                    IsLocal = _InContext.Request == null || _InContext.Request.IsLocal;

                    UserHostAddress = _InContext.Request.UserHostAddress;

                    HttpMethod = _InContext.Request.HttpMethod;

                    Url = _InContext.Request.Url;

                    Files = _InContext.Request.Files;
                }
            }
            catch (Exception) { }
        }