public bool Check(HttpServiceBase service, HttpRequest req)
        {
            switch (service.RightType)
            {
            case RightEnum.NoCheck:
                return(true);

            case RightEnum.OnlyUrlRight:
                return(loginService.CheckUrlRight(service.RightUrl, service.GetQueryString(req)));

            case RightEnum.UrlAndSoftRight:
                return(loginService.CheckUrlRight(service.RightUrl, service.GetQueryString(req)) && CheckSoft(req["softs"]));

            case RightEnum.UrlAndProjectSourceRight:
                return(loginService.CheckUrlRight(service.RightUrl, service.GetQueryString(req)) && CheckProject(req["projectsource"]));

            case RightEnum.DefinedByYourself:
                return(service.Check(req));

            case RightEnum.DefinedByYourselfAndUrlAndSoftRight:
                return(loginService.CheckUrlRight(service.RightUrl, service.GetQueryString(req)) && CheckSoft(req["softs"]) && service.Check(req));

            default:
                return(true);
            }
        }
Example #2
0
 public AuthorizationTransaction(IFormatter <AuthorizationRequest, AuthorizationResponse, string> formatter, HttpServiceBase <AuthorizationRequest, HttpResponseMessage> authorizationService,
                                 ILogger logger, BaseValidator <AuthorizationRequest> validators)
 {
     this.formatter            = formatter;
     this.authorizationService = authorizationService;
     this.logger     = logger;
     this.validators = validators;
 }
        public void Create()
        {
            var mockLogger = new Mock <ILogger>();

            var obj = new HttpServiceBase(mockLogger.Object);

            Assert.IsNotNull(obj);
            Assert.IsNotNull(obj.Logger);
            Assert.AreEqual(mockLogger.Object, obj.Logger);
        }
 static HttpService()
 {
     services = new Dictionary <string, HttpServiceBase>(50);
     Type[] types = typeof(HttpServiceBase).Assembly.GetTypes();
     for (int i = 0; i < types.Length; i++)
     {
         if (!types[i].IsAbstract && typeof(HttpServiceBase).IsAssignableFrom(types[i]))
         {
             HttpServiceBase obj = Activator.CreateInstance(types[i]) as HttpServiceBase;
             if (obj != null)
             {
                 services.Add(obj.ServiceCategory.ToLower(), obj);
             }
         }
     }
 }
Example #5
0
 public VoidTransaction(IFormatter <PaymentRequest, BaseResponse, string> formatter, HttpServiceBase <PaymentRequest, HttpResponseMessage> voidService, ILogger logger)
 {
     this.formatter   = formatter;
     this.voidService = voidService;
     this.logger      = logger;
 }
 public CaptureTransaction(IFormatter <PaymentRequest, BaseResponse, string> formatter, HttpServiceBase <PaymentRequest, HttpResponseMessage> captureService, ILogger logger)
 {
     this.formatter      = formatter;
     this.captureService = captureService;
     this.logger         = logger;
 }
        public override void ProcessRequest(HttpContext context)
        {
            try
            {
                string serviceCategory = context.Request["service"];

                if (!string.IsNullOrEmpty(serviceCategory))
                {
                    serviceCategory = serviceCategory.Trim().ToLower();
                    HttpServiceBase service = null;
                    if (services.TryGetValue(serviceCategory, out service))
                    {
                        service.LoginService = loginService;


                        //try
                        //{
                        SetDefaultProjectAndPlat(context);
                        SetDefaultSofts(context);
                        Result result = service.Process(context);
                        if (result != null)
                        {
                            if (result.resultCode == 0)
                            {
                                if (result.OriginalString)
                                {
                                    context.Response.Write(result.data);
                                }
                                else
                                {
                                    context.Response.Write(
                                        JsonConvert.SerializeObject(result.m_Showstate ? result : result.data));
                                }
                            }
                            else if (result.resultCode == 2)
                            {
                                context.Response.Write(JsonConvert.SerializeObject(result));
                            }
                            else
                            {
                                context.Response.Write(
                                    JsonConvert.SerializeObject(Result.GetFailedResult(service.ServiceName + "处理失败!")));
                            }
                        }
                        //}
                        //catch (NotRightException ex)
                        //{
                        //    LogHelper.WriteException("Http服务发生异常:" + service.ServiceName, ex);
                        //    context.Response.Write(JsonConvert.SerializeObject(Result.GetFailedResult("该页面权限不足!", ex)));
                        //}
                        //catch (CheckException ex)
                        //{
                        //    context.Response.Write(JsonConvert.SerializeObject(Result.GetFailedResult(ex.Mes, ex)));
                        //}
                        //catch (Exception ex)
                        //{
                        //    LogHelper.WriteException("Http服务发生异常:" + service.ServiceName, ex);
                        //    context.Response.Write(JsonConvert.SerializeObject(Result.GetFailedResult("该页面处理异常请反馈!", ex)));
                        //}
                    }
                    else
                    {
                        context.Response.Write(
                            JsonConvert.SerializeObject(
                                Result.GetDeniedResult("客户端发出错误的服务请求类型:" + serviceCategory)));
                    }
                }
            }
            finally
            {
                try
                {
                    if (context.Response.IsClientConnected)
                    {
                        context.Response.Flush();
                    }
                }
                catch { }
            }
        }
 public SearchPaymentTransaction(IFormatter <PaymentRequest, BaseResponse, string> formatter, HttpServiceBase <PaymentRequest, HttpResponseMessage> searchPaymentService, ILogger logger)
 {
     this.formatter            = formatter;
     this.searchPaymentService = searchPaymentService;
     this.logger = logger;
 }