예제 #1
0
파일: Login.ashx.cs 프로젝트: wkxuan/code
        public void ProcessRequest(HttpContext context)
        {
            LoginResponseDTO res;
            LoginRequestDTO  dto = new LoginRequestDTO()
            {
                PlatformId   = HttpExtension.GetRequestParam("PlatformId"),
                UserCode     = HttpExtension.GetRequestParam("UserCode"),
                UserPassword = HttpExtension.GetRequestParam("UserPassword")
            };

            if (dto.PlatformId.IsEmpty() || dto.UserCode.IsEmpty() || dto.UserPassword.IsEmpty())
            {
                res = new LoginResponseDTO()
                {
                    Success  = false,
                    ErrorMsg = "登陆信息不完整"
                };
            }
            else
            {
                res = new CommonController().Login(dto);
            }

            context.Response.ContentType = "text/plain";
            context.Response.Write(res.ToJson());
        }
예제 #2
0
    void Start()
    {
        HttpExtension httpExtension = new HttpExtension();
        string        source        = httpExtension.GetHttpWebRequest(url);

        Debug.Log(source);
    }
예제 #3
0
파일: SearchItem.cs 프로젝트: zgyzgy/ERP
        public static SearchItem GetAllPram()
        {
            SearchItem item = new Results.SearchItem();

            item.Values   = HttpExtension.GetRequestParam <Dictionary <string, string> >("Data");
            item.PageInfo = PageInfo.GetPageinfoFormUI();
            return(item);
        }
예제 #4
0
        public override void OnActionExecuted(ActionExecutedContext filterContext)
        {
            if (filterContext.HttpContext.Request.IsAjaxRequest())
            {
                UIResult res;
                //异常处理
                if (filterContext.Exception != null)
                {
                    filterContext.ExceptionHandled = true;
                    if (filterContext.Exception.GetInnerException() is zExceptionBase)
                    {
                        zExceptionBase ex = filterContext.Exception.GetInnerException() as zExceptionBase;
                        res = new UIResult()
                        {
                            Flag = ex.Flag,
                            Msg  = ex.Message
                        };
                    }
                    else
                    {
                        res = new UIResult()
                        {
                            Flag = -1,
                            Msg  = filterContext.Exception.InnerMessage()
                        };
                    }
                    filterContext.Result = res;
                }


                if (filterContext.Result is EmptyResult)
                {
                    filterContext.Result = new UIResult();
                }
                if (filterContext.Result is UIResult)
                {
                    filterContext.Result = new UIResult()
                    {
                        Data = (filterContext.Result as UIResult).GetData()
                    };
                }
            }
            else
            {
                filterContext.Controller.ViewBag.ControllerUrl =
                    IOExtension.MakeUri(
                        HttpExtension.GetWebBasePath(),
                        filterContext.RouteData.Values["area"].ToString(),
                        filterContext.RouteData.Values["controller"].ToString()) + "/";
                filterContext.Controller.ViewBag.CommonControllerUrl =
                    IOExtension.MakeUri(
                        HttpExtension.GetWebBasePath(),
                        "Base",
                        "Common") + "/";
            }
        }
예제 #5
0
파일: Do.ashx.cs 프로젝트: wkxuan/code
 public void ProcessRequest(HttpContext context)
 {
     var res = new CommonController().Do(new RequestDTO()
     {
         SecretKey = HttpExtension.GetRequestParam("SecretKey"),
         ServiceName = HttpExtension.GetRequestParam("ServiceName"),
         Context = HttpExtension.GetRequestParam("Context")
     });
     context.Response.ContentType = "text/plain";
     context.Response.Write(res.ToJson());
 }
예제 #6
0
        public IActionResult VerifyCode()
        {
            string codeValue = "";
            var    codeImg   = ValidateCode.CreateImage(out codeValue, 6);

            codeValue = codeValue.ToUpper();//验证码不分大小写

            HttpExtension.SetSession(Consts.Session_ValidateCode, codeValue);

            Response.Body.Dispose();
            return(File(codeImg, @"image/png"));
        }
        /// <summary>
        /// Gets the cookie values.
        /// </summary>
        /// <param name="cookieKey">The cookie key.</param>
        /// <returns></returns>
        public override IEnumerable <string> GetCookieValues(string cookieKey)
        {
            List <string> result = new List <string>();

            if (!string.IsNullOrWhiteSpace(cookieKey))
            {
                var cookieString = Request.Headers.GetValue(HttpConstants.HttpHeader.Cookie);
                var cookieMatrix = HttpExtension.ConvertCookieStringToMatrix(cookieString);
                cookieMatrix.TryGetValue(cookieKey, out result);
            }

            return(result?.Select(x => x.ToUrlDecodedText()));
        }
예제 #8
0
파일: PageInfo.cs 프로젝트: zgyzgy/ERP
        public static PageInfo GetPageinfoFormUI()
        {
            PageInfo p = new DbDomain.PageInfo();

            if (string.IsNullOrEmpty(HttpExtension.GetRequestParam("page")))
            {
                p.PageIndex = p.PageSize = 0;
            }
            else
            {
                p.PageIndex = HttpExtension.GetRequestParam("page").ToInt() - 1;
                p.PageSize  = HttpExtension.GetRequestParam("rows").ToInt();
            }
            return(p);
        }
예제 #9
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="purchase"></param>
 /// <returns></returns>
 /// <exception cref="DataConflictException">When product definition has changed on server</exception>
 public async Task <PurchasedItem> AddPuchase(PurchaseOrder purchase)
 {
     return(await HttpExtension.AskRetryOnHttpStatusFail(
                async() => {
         try
         {
             return await _connectionService.PostJsonAuthorizedAsync <PurchaseOrder, PurchasedItem>(purchase, u => u.Shop.User);
         }
         catch (HttpStatusCodeException ex) when(ex.Status == HttpStatusCode.Conflict)
         {
             var proposal = JsonConvert.DeserializeObject <PurchaseOrder>(ex.Content);
             throw new DataConflictException(proposal);
         }
     }));
 }
        public async Task <Urls> GetUrls()
        {
            if (_result != null)
            {
                return(_result);
            }

            var client = CreateHttpClient(x => x);

            _result = await HttpExtension.AskRetryOnHttpStatusFail(
                async() =>
            {
                var response = await client.GetAsync(Config.ApiConfigUrl);
                return(await response.ParseJsonResponseBody <Urls>());
            });

            return(_result);
        }
예제 #11
0
 // searches for extension header in response
 /// <devdoc>
 ///    <para>[To be supplied.]</para>
 /// </devdoc>
 public string GetExtension(HttpExtension extension, string header)
 {
     CheckDisposed();
     return(GetResponseHeader(header));
 }
예제 #12
0
 public async Task <List <Product> > GetProducts()
 {
     return(await HttpExtension.AskRetryOnHttpStatusFail(
                () => _connectionService.GetJsonAsync <List <Product> >(urls => urls.Shop.Products)
                ));
 }
예제 #13
0
 // searches for extension header in response
 /// <devdoc>
 ///    <para>[To be supplied.]</para> 
 /// </devdoc> 
 public string GetExtension(HttpExtension extension, string header)
 {
     CheckDisposed();
     return GetResponseHeader(header);
 }
예제 #14
0
        /// <summary>
        /// Processes the route.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <param name="doAuthentication">if set to <c>true</c> [do authentication].</param>
        /// <returns></returns>
        /// <exception cref="ResourceNotFoundException">
        /// ResourceName
        /// or
        /// or
        /// </exception>
        internal virtual RuntimeContext ProcessRoute(HttpApiContextContainer <TRequest, TResponse> context, bool doAuthentication = true)
        {
            try
            {
                context.CheckNullObject(nameof(context));
                var httpMethod = context.HttpMethod;
                var uri        = context.Url;

                var rawFullUrl = string.Format("{0}: {1}", httpMethod, context.Url);
                var result     = InitializeRuntimeContext(uri);

                result.CheckNullObjectAsInvalid("URL");

                if (result.Version.Equals(ApiConstants.BuiltInFeatureVersionKeyword, StringComparison.OrdinalIgnoreCase))
                {
                    return(result);
                }

                if (string.IsNullOrWhiteSpace(result.ResourceName))
                {
                    throw new ResourceNotFoundException(rawFullUrl, nameof(result.ResourceName));
                }

                RuntimeRoute runtimeRoute;
                var          apiRouterIdentifier = new ApiRouteIdentifier(result.Realm, result.Version, result.ResourceName, httpMethod, result.Parameter1);
                if (!RestApiRoutePool.Routes.TryGetValue(apiRouterIdentifier, out runtimeRoute))
                {
                    apiRouterIdentifier = new ApiRouteIdentifier(result.Realm, result.Version, result.ResourceName, httpMethod, null);
                    RestApiRoutePool.Routes.TryGetValue(apiRouterIdentifier, out runtimeRoute);
                }
                else
                {
                    if (runtimeRoute != null && (!string.IsNullOrWhiteSpace(result.Parameter1) && !runtimeRoute.IsActionUsed))
                    {
                        throw new ResourceNotFoundException(rawFullUrl);
                    }
                }

                if (runtimeRoute == null)
                {
                    throw new ResourceNotFoundException(rawFullUrl);
                }

                result.ApiRouterIdentifier = apiRouterIdentifier;

                // Override out parameters
                result.OperationParameters = runtimeRoute.OperationParameters ?? new RuntimeApiOperationParameters();

                result.ApiMethod    = runtimeRoute.ApiMethod;
                result.ApiInstance  = runtimeRoute.ApiInstance;
                result.IsActionUsed = runtimeRoute.IsActionUsed;
                result.IsVoid       = runtimeRoute.IsVoid;
                context.Settings    = result.Settings = runtimeRoute.Setting ?? RestApiSettingPool.DefaultRestApiSettings;
                result.OmitApiEvent = runtimeRoute.OmitApiTracking?.Omit(ApiTrackingType.Event) ?? false;

                if (runtimeRoute.ApiCacheAttribute != null)
                {
                    result.ApiCacheIdentity = runtimeRoute.ApiRouteIdentifier.Clone() as ApiRouteIdentifier;
                    if (runtimeRoute.ApiCacheAttribute.CacheParameter.CachedByParameterizedIdentity)
                    {
                        result.ApiCacheIdentity.SetParameterizedIdentifier(uri.ToQueryString());
                    }

                    result.ApiCacheContainer = runtimeRoute.ApiCacheContainer;

                    if (result.ApiCacheContainer != null)
                    {
                        string cachedResponseBody;
                        if (result.ApiCacheContainer.GetCacheResult(result.ApiCacheIdentity, out cachedResponseBody))
                        {
                            result.CachedResponseBody = cachedResponseBody;
                            result.ApiCacheStatus     = ApiCacheStatus.UseCache;
                        }
                        else
                        {
                            result.ApiCacheStatus = ApiCacheStatus.UpdateCache;
                        }
                    }
                    else
                    {
                        result.ApiCacheStatus = ApiCacheStatus.NoCache;
                    }
                }

                // Fill basic context info.
                var userAgentHeaderKey = context.Settings?.OriginalUserAgentHeaderKey;
                var token = context.TryGetRequestHeader((context.Settings?.TokenHeaderKey).SafeToString(HttpConstants.HttpHeader.TOKEN));
                ContextHelper.ApiContext.IndicatedOperator = context.TryGetRequestHeader(HttpConstants.HttpHeader.OPERATOR);

                ContextHelper.ConsistContext(
                    // TOKEN
                    token,
                    // Settings
                    context.Settings,
                    // IP Address
                    context.TryGetRequestHeader(context.Settings?.OriginalIpAddressHeaderKey.SafeToString(HttpConstants.HttpHeader.ORIGINAL)).SafeToString(context.ClientIpAddress),
                    // User Agent
                    string.IsNullOrWhiteSpace(userAgentHeaderKey) ? context.UserAgent : context.TryGetRequestHeader(userAgentHeaderKey).SafeToString(context.UserAgent),
                    // Culture Code
                    context.QueryString.Get(HttpConstants.QueryString.Language).SafeToString(context.UserLanguages.SafeFirstOrDefault()).EnsureCultureCode(),
                    // Current Uri
                    context.Url,
                    HttpExtension.GetBasicAuthentication(context.TryGetRequestHeader(HttpConstants.HttpHeader.Authorization).DecodeBase64()),
                    apiRouterIdentifier.ToApiUniqueIdentifier()
                    );

                string userIdentifier = ContextHelper.ApiContext.CurrentCredential?.Name.SafeToString(token);

                var authenticationException = doAuthentication ? Authorize(runtimeRoute, ContextHelper.ApiContext) : null;

                if (authenticationException != null)
                {
                    throw authenticationException.Handle(new { result.ApiMethod.Name, token });
                }

                return(result);
            }
            catch (Exception ex)
            {
                throw ex.Handle();
            }
        }
예제 #15
0
 public async Task <AccountInfo> GetAccountInfo()
 {
     return(await HttpExtension.AskRetryOnHttpStatusFail(
                () => _connectionService.GetJsonAuthorizedAsync <AccountInfo>(u => u.Shop.User, cache: false)
                ));
 }