protected void InitTest(IUserAuthRepository userAuthRepository) { ((IClearable)userAuthRepository).Clear(); var appsettingsMock = new Mock <IAppSettings>(); var appSettings = appsettingsMock.Object; new AuthFeature(null, new IAuthProvider[] { new CredentialsAuthProvider(), new BasicAuthProvider(), new FacebookAuthProvider(appSettings), new TwitterAuthProvider(appSettings) }) .Register(null); mockService = new Mock <IServiceBase>(); mockService.Expect(x => x.TryResolve <IAuthRepository>()).Returns(userAuthRepository); requestContext = new BasicRequest(); mockService.Expect(x => x.Request).Returns(requestContext); service = mockService.Object; RegisterDto = new Register { UserName = "******", Password = "******", Email = "*****@*****.**", DisplayName = "DisplayName", FirstName = "FirstName", LastName = "LastName", }; }
public object Any(BasicRequest request) { DTOResponseLayUI dtoResponseLayUi = new DTOResponseLayUI(); BasicService service = new BasicService(); DTOResponse response = new DTOResponse(); if (request.ACTION == OPAction.QUERY) { response = service.GetList(request); } else if (request.ACTION == OPAction.AFFIRM) { response = service.SaveBasicObject(request); } else if (request.ACTION == OPAction.OP_01) { response = service.GetSysparamsList(request); } else if (request.ACTION == OPAction.OP_02) { response = service.SaveSysparams(request); } else { dtoResponseLayUi.code = -1; dtoResponseLayUi.msg = "未定义的操作类型:" + request.ACTION.ToString(); return(dtoResponseLayUi); } return(this.ConvertTo(response)); }
public MvcHtmlString RenderAction(string route, string viewName = null) { var req = new BasicRequest { Verb = HttpMethods.Get, PathInfo = route, ContentType = MimeTypes.Html, ResponseContentType = MimeTypes.Html, }; req.SetTemplate(EmptyTemplate); if (viewName != null) { req.SetView(viewName); } var response = HostContext.ServiceController.Execute(req); req.Response.WriteToResponse(req, response) .Wait(); //unnecessary as results are sync anyway var resBytes = ((MemoryStream)req.Response.OutputStream).ToArray(); var html = resBytes.FromUtf8Bytes(); return(MvcHtmlString.Create(html)); }
public BasicResponse <List <R_PersoninfInfo> > GetAllPersonInfo(BasicRequest personinfRequest) { // var encodelist = _enumcodeRepository.Datas.ToList(); var deptlist = _deptRepository.Datas.ToList(); var result = _Repository.Datas.ToList(); var personinfInfoList = ObjectConverter.CopyList <R_PersoninfModel, R_PersoninfInfo>(result); var personinfresponse = new BasicResponse <List <R_PersoninfInfo> >(); personinfresponse.Data = personinfInfoList.Select(o => { //性别 o.Gender = ConvertGender(o.A22); //部门 var dept = deptlist.FirstOrDefault(d => d.ID == o.Bm); o.deptName = dept == null ? string.Empty : dept.Dept; //职务 var title = encodelist.FirstOrDefault(t => t.EnumTypeID == "20" && t.LngEnumValue.ToString() == o.Zw); o.zwDesc = title == null ? string.Empty : title.StrEnumDisplay; //工种 var worktype = encodelist.FirstOrDefault(t => t.EnumTypeID == "25" && t.LngEnumValue.ToString() == o.Gz); o.gzDesc = worktype == null ? string.Empty : worktype.StrEnumDisplay; return(o); }).ToList(); return(personinfresponse); }
public static RegisterService GetRegistrationService( AbstractValidator <Register> validator = null, IUserAuthRepository authRepo = null, string contentType = null) { var requestContext = new BasicRequest(); if (contentType != null) { requestContext.ResponseContentType = contentType; } var userAuthRepository = authRepo ?? GetStubRepo(); HostContext.Container.Register <IAuthRepository>(userAuthRepository); var service = new RegisterService { RegistrationValidator = validator ?? new RegistrationValidator(), Request = requestContext, }; HostContext.Container.Register(userAuthRepository); (HostContext.TryResolve <IAuthRepository>() as InMemoryAuthRepository)?.Clear(); return(service); }
public static UserRegistrationService GetRegistrationService( AbstractValidator <UserRegistrationRequest> validator = null, IUserAuthRepository authRepo = null, string contentType = null) { var requestContext = new BasicRequest(); if (contentType != null) { requestContext.ResponseContentType = contentType; } var userAuthRepository = authRepo ?? GetStubRepo(); var service = new UserRegistrationService { UserRegistrationRequestValidator = validator ?? new UserRegistrationRequestValidator { UserAuthRepo = userAuthRepository }, AuthRepo = userAuthRepository, Request = requestContext, }; HostContext.Container.Register(userAuthRepository); return(service); }
public DTOResponse SaveSysparams(BasicRequest request) { DTOResponse dtoResponse = new DTOResponse(); try { SysParams entity = HelperSerializer.GetObjectFromJsonString <SysParams>(request.PostData); if (entity == null) { throw new Exception("传入的参数无法解析!"); } using (IDbConnection dbConn = HelperConnection.GetConnectionFactory().OpenDbConnection()) { SqlExpression <SysParams> expression1 = dbConn.From <SysParams>(); expression1.Where(x => x.ID == entity.ID); expression1.UpdateFields.Add("PARAVALUE"); int count1 = dbConn.UpdateOnly <SysParams>(entity, expression1); dtoResponse.TotalCount = count1; dtoResponse.IsSuccess = count1 == 1 ? true : false; //dtoResponse.IsSuccess = dbConn.Update<SysParams>(entity); dtoResponse.MessageText = "操作完成:" + dtoResponse.IsSuccess; return(dtoResponse); } } catch (Exception ex) { dtoResponse.IsSuccess = false; dtoResponse.MessageText = ex.Message; logger.Error((object)ex); return(dtoResponse); } }
public override void Configure(Container container) { Plugins.Add(new AuthFeature(() => new AuthUserSession(), new IAuthProvider[] { new CredentialsAuthProvider(AppSettings), })); container.Register <IUserAuthRepository>(c => new InMemoryAuthRepository()); var authRepo = container.Resolve <IUserAuthRepository>(); authRepo.CreateUserAuth(new UserAuth { Id = 1, UserName = "******", FirstName = "First", LastName = "Last", DisplayName = "Display", }, "p@55word"); container.Register(c => createMqServerFn()); var mqServer = container.Resolve <IMessageService>(); mqServer.RegisterHandler <HelloIntro>(ExecuteMessage); mqServer.RegisterHandler <MqAuthOnly>(m => { var req = new BasicRequest { Verb = HttpMethods.Post }; req.Headers["X-ss-id"] = m.GetBody().SessionId; var response = ExecuteMessage(m, req); return(response); }); mqServer.Start(); }
public void TestBasicRequest(string urlFormatter, IEnumerable <string> serverNodes, string apiKey) { var srcS = new BasicRequest(urlFormatter, serverNodes, apiKey); var srcD = SandD(srcS); Assert.IsNotNull(srcD); }
private T Send <T>(BasicRequest request) { try { var jsonText = JsonConvert.SerializeObject(request); var payload = Convert.ToBase64String(Encoding.UTF8.GetBytes(jsonText)); var hmac = new HMACSHA384(Encoding.UTF8.GetBytes(_secret)); var hash = hmac.ComputeHash(Encoding.UTF8.GetBytes(payload)); var hexHash = BitConverter.ToString(hash).Replace("-", ""); using (var client = new WebClient()) { client.Headers.Add("X-GEMINI-APIKEY", _key); client.Headers.Add("X-GEMINI-PAYLOAD", payload); client.Headers.Add("X-GEMINI-SIGNATURE", hexHash); var response = client.UploadString($"{_baseUrl}{request.Request}", ""); return(JsonConvert.DeserializeObject <T>(response)); } } catch (Exception ex) { throw ex; } }
public void With_TypedArguments() { serviceController.Register(typeof(BasicRequest), typeof(BasicService)); var request = new BasicRequest(); Console.WriteLine("With_TypedArguments(): {0}", Measure(() => serviceController.Execute(request), Times)); }
public async Task Dispatch(ResolvedEvent @event) { var headers = JsonObject.Parse(@event.Event.Metadata.FromAsciiBytes()).ToNameValueCollection(); var clrEventType = headers.Get(EventClrTypeHeader); Type type; if (EventTypes.TryResolveMapping(clrEventType, out type)) { var typedEvent = JsonSerializer.DeserializeFromString(@event.Event.Data.FromAsciiBytes(), type); try { var request = new BasicRequest(); request.Headers.AddAll(headers); await HostContext.ServiceController.ExecuteAsync(typedEvent, request, true); } catch (Exception e) { log.Error(e); } return; } }
public void By_default_assigned_roles_are_saved_in_UserAuth_table() { using (var appHost = new BasicAppHost { ConfigureAppHost = host => { host.Plugins.Add(new AuthFeature(() => new AuthUserSession(), new [] { new BasicAuthProvider() }) { IncludeRegistrationService = true, }); }, ConfigureContainer = container => { container.Register <IDbConnectionFactory>(c => new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider)); container.Register <IAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>())); container.Resolve <IAuthRepository>().InitSchema(); } }.Init()) { using (var db = appHost.Container.Resolve <IDbConnectionFactory>().Open()) { var register = CreateNewUserRegistration(); var req = new BasicRequest(register) { QueryString = { ["authSecret"] = appHost.Config.AdminAuthSecret = "allow" } }; var response = (RegisterResponse)appHost.ExecuteService(register, req); var userAuth = db.SingleById <UserAuth>(response.UserId); var assignResponse = (AssignRolesResponse)appHost.ExecuteService(new AssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); Assert.That(assignResponse.AllRoles[0], Is.EqualTo("TestRole")); Assert.That(assignResponse.AllPermissions[0], Is.EqualTo("TestPermission")); userAuth = db.SingleById <UserAuth>(response.UserId); Assert.That(userAuth.Roles[0], Is.EqualTo("TestRole")); Assert.That(userAuth.Permissions[0], Is.EqualTo("TestPermission")); appHost.ExecuteService(new UnAssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); userAuth = db.SingleById <UserAuth>(response.UserId); Assert.That(userAuth.Roles.Count, Is.EqualTo(0)); Assert.That(userAuth.Permissions.Count, Is.EqualTo(0)); } } }
/// <summary> /// 获取所有已定义人员 /// </summary> /// <param name="personinfRequest"></param> /// <returns></returns> public BasicResponse <List <R_PersoninfInfo> > GetAllDefinedPersonInfoCache(BasicRequest personinfRequest) { RPersoninfCacheGetByConditionRequest RPersoninfCacheRequest = new RPersoninfCacheGetByConditionRequest(); RPersoninfCacheRequest.Predicate = a => !string.IsNullOrEmpty(a.Name); return(_RPersoninfCacheService.GetRPersoninfCache(RPersoninfCacheRequest)); }
public async Task <GetCoursesResponse> GetAll(BasicRequest request) { var courses = await _courseRepository.GetAll(); var coursesDto = courses.MapToDto(_mapper); return(new GetCoursesResponse(coursesDto)); }
public BasicResult Detokenize(BasicRequest request) { if (_basicService.GetSettings().Behaviour == Behaviour.RandomSeedInconsistent && request.Seed == null && _basicService.GetSettings().Encrypt == false) { throw new ArgumentException("A valid seed is required to detonkenize a token created using Random Seed tokenization."); } return(_basicService.Detokenize(request, _tokenTableSet)); }
private BasicResponse GetInfo(string typeCd) { var request = new BasicRequest(); request.Add("TypeCd", typeCd); var logic = new GetOperateLogic(); var response = PageCom.Invoke(logic, request); return response; }
public void Can_assign_roles_that_persist_to_UserAuthRole_table_in_DynamoDb() { using (var appHost = new BasicAppHost { ConfigureAppHost = host => { host.Plugins.Add(new AuthFeature(() => new AuthUserSession(), new[] { new BasicAuthProvider() }) { IncludeRegistrationService = true, }); }, ConfigureContainer = container => { container.Register <IPocoDynamo>(c => new PocoDynamo(DynamoConfig.CreateDynamoDBClient())); //DynamoMetadata.Reset(); container.Resolve <IPocoDynamo>().DeleteAllTables(TimeSpan.FromMinutes(1)); container.Register <IAuthRepository>(c => new DynamoDbAuthRepository(c.Resolve <IPocoDynamo>())); container.Resolve <IAuthRepository>().InitSchema(); } }.Init()) { var db = appHost.Container.Resolve <IPocoDynamo>(); var register = CreateNewUserRegistration(); var req = new BasicRequest(register); req.QueryString["authSecret"] = appHost.Config.AdminAuthSecret = "allow"; var response = (RegisterResponse)appHost.ExecuteService(register, req); var userAuth = db.GetItem <UserAuth>(response.UserId); var assignResponse = (AssignRolesResponse)appHost.ExecuteService(new AssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); Assert.That(assignResponse.AllRoles[0], Is.EqualTo("TestRole")); Assert.That(assignResponse.AllPermissions[0], Is.EqualTo("TestPermission")); Assert.That(userAuth.Roles.Count, Is.EqualTo(0)); Assert.That(userAuth.Permissions.Count, Is.EqualTo(0)); var manageRoles = (IManageRoles)appHost.Container.Resolve <IAuthRepository>(); Assert.That(manageRoles.HasRole(userAuth.Id.ToString(), "TestRole")); Assert.That(manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission")); appHost.ExecuteService(new UnAssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); Assert.That(!manageRoles.HasRole(userAuth.Id.ToString(), "TestRole")); Assert.That(!manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission")); } }
public BasicResponse <List <MsgUserRuleInfo> > GetAllMsgUserInfo(BasicRequest msgUserRuleRequest) { var result = _Repository.Datas.ToList(); var msgUserRuleInfo = ObjectConverter.CopyList <MsgUserRuleModel, MsgUserRuleInfo>(result); var msgUserRuleresponse = new BasicResponse <List <MsgUserRuleInfo> >(); msgUserRuleresponse.Data = msgUserRuleInfo.ToList(); return(msgUserRuleresponse); }
public BasicResponse <List <B_CallInfo> > GetAll(BasicRequest callRequest) { var callresponse = new BasicResponse <List <B_CallInfo> >(); var callModelLists = _Repository.GetAllCall(); var callinfolists = ObjectConverter.CopyList <B_CallModel, B_CallInfo>(callModelLists).ToList(); callresponse.Data = callinfolists; return(callresponse); }
public void With_Expressions() { var requestType = typeof(BasicRequest); serviceController.Register(requestType, typeof(BasicService)); var request = new BasicRequest(); Console.WriteLine("With_Expressions(): {0}", Measure(() => serviceController.Execute(request), Times)); }
public ITileSource CreateTileSource() { var tileSchema = new GlobalSphericalMercator(); var tileLayerRequest = new BasicRequest(_url, Domains); var tileProvider = new WebTileProvider(tileLayerRequest); var tileSource = new TileSource(tileProvider, tileSchema); return(tileSource); }
public void With_Reflection() { var serviceController = new ServiceControllerReflection(); serviceController.Register(() => new BasicService()); var request = new BasicRequest(); Console.WriteLine("With_Reflection(): {0}", Measure(() => serviceController.ExecuteReflection(request), Times)); }
public void With_ServiceStackFunq() { var serviceController = new ServiceController(); serviceController.Register(() => new BasicService()); var request = new BasicRequest(); Console.WriteLine("With_TypedArguments(): {0}", Measure(() => serviceController.Execute(request), Times)); }
public void Can_assign_roles_that_persist_to_UserAuthRole_table() { using (var appHost = new BasicAppHost { ConfigureContainer = container => { container.Register <IDbConnectionFactory>(c => new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider)); container.Register <IAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>()) { UseDistinctRoleTables = true, }); container.Resolve <IAuthRepository>().InitSchema(); } }.Init()) { using (var db = appHost.Container.Resolve <IDbConnectionFactory>().Open()) { var register = CreateNewUserRegistration(); var req = new BasicRequest(register); req.QueryString["authSecret"] = appHost.Config.AdminAuthSecret = "allow"; var response = (RegisterResponse)appHost.ExecuteService(register, req); var userAuth = db.SingleById <UserAuth>(response.UserId); var assignResponse = (AssignRolesResponse)appHost.ExecuteService(new AssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); Assert.That(assignResponse.AllRoles[0], Is.EqualTo("TestRole")); Assert.That(assignResponse.AllPermissions[0], Is.EqualTo("TestPermission")); Assert.That(userAuth.Roles.Count, Is.EqualTo(0)); Assert.That(userAuth.Permissions.Count, Is.EqualTo(0)); var manageRoles = (IManageRoles)appHost.Container.Resolve <IAuthRepository>(); Assert.That(manageRoles.HasRole(userAuth.Id.ToString(), "TestRole")); Assert.That(manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission")); appHost.ExecuteService(new UnAssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); Assert.That(!manageRoles.HasRole(userAuth.Id.ToString(), "TestRole")); Assert.That(!manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission")); } } }
public BasicResponse <List <MsgRuleInfo> > GetAllMsgRule(BasicRequest msgRuleRequest) { var msgRuleModelLists = _Repository.GetAllMsgRule(); var MsgRuleInfos = ObjectConverter.CopyList <MsgRuleModel, MsgRuleInfo>(msgRuleModelLists); var msgRuleresponse = new BasicResponse <List <MsgRuleInfo> >(); msgRuleresponse.Data = MsgRuleInfos.ToList(); return(msgRuleresponse); }
public void With_TypeFactory() { var requestType = typeof(BasicRequest); serviceController.RegisterGServiceExecutor(requestType, typeof(BasicService), new BasicServiceTypeFactory()); var request = new BasicRequest(); Console.WriteLine("With_TypeFactory(): {0}", Measure(() => serviceController.Execute(request), Times)); }
public BasicResponse <List <Jc_DefInfo> > GetAll(BasicRequest defRequest) { var defresponse = new BasicResponse <List <Jc_DefInfo> >(); var defModelLists = _Repository.Datas.ToList(); var definfolists = ObjectConverter.CopyList <B_DefModel, Jc_DefInfo>(defModelLists).ToList(); //var definfolists = _bdefCacheService.GetAll(new Sys.Safety.Request.Cache.B_DefCacheGetAllRequest()).Data; defresponse.Data = definfolists; return(defresponse); }
public void With_CustomFunc() { var requestType = typeof(BasicRequest); var serviceController = new ServiceController(); serviceController.Register(requestType, typeof(BasicService), type => new BasicService()); var request = new BasicRequest(); Console.WriteLine("With_CustomFunc(): {0}", Measure(() => serviceController.Execute(request), Times)); }
public void GetEndpointAttributes_AcceptsUserHostAddressFormats(string format, RequestAttributes expected) { var handler = new TestHandler(); var request = new BasicRequest { UserHostAddress = format, IsSecureConnection = false, Verb = "GET" }; Assert.AreEqual(expected | RequestAttributes.HttpGet | RequestAttributes.InSecure, request.GetAttributes()); }
public void CanGenerateAFullEnglishBasicClient() { var client = BasicClientFactory.GetClient(BasicClientType.FullEnglish); var testString = "abc,def,ghi,123???{{}}"; var result = client.Tokenize(testString).Value; Assert.AreNotEqual(testString, result); result = client.Detokenize(BasicRequest.FromString(result)).Value; Assert.AreEqual(testString, result); }
/// <summary> /// Xử lý filter /// </summary> private BasicResponse Save(HttpContext context, BasicRequest request) { // Khai báo biến cục bộ var logic = new SaveOperateLogic(); var config = new BasicConfig(); // Gán giá trị config config.RoleCd = W150901Logics.CD_ROLE_CD_ADM_MA_RMT_EN_UPDATE; // Tiến hành gọi logic var response = HandlerCom.Invoke(logic, request, config); // Kết quả xử lý return response; }
/// <summary> /// Xử lý filter /// </summary> private BasicResponse Filter(HttpContext context, BasicRequest request) { // Khai báo biến cục bộ var logic = new FilterOperateLogic(); var config = new BasicConfig(); // Gán giá trị config config.RoleCd = W150901Logics.CD_ROLE_CD_ADM_SE_PAG_FILTER; // Tiến hành gọi logic var response = HandlerCom.Invoke(logic, request, config); // Kết quả xử lý return response; }
/// <summary> /// Xử lý init /// </summary> private BasicResponse InitLayout(HttpContext context, BasicRequest request) { // Khai báo biến cục bộ var logic = new InitOperateLogic(); var config = new BasicConfig(); // Gán giá trị config config.RoleCd = W150901Logics.CD_ROLE_CD_ADM_MA_TOU_LI_VIEW; // Tiến hành gọi logic var response = HandlerCom.Invoke(logic, request, config); // Kết quả xử lý return response; }
public void By_default_assigned_roles_are_saved_in_UserAuth_table() { using (var appHost = new BasicAppHost { ConfigureContainer = container => { container.Register<IDbConnectionFactory>(c => new OrmLiteConnectionFactory(":memory:", SqliteDialect.Provider)); container.Register<IAuthRepository>(c => new OrmLiteAuthRepository(c.Resolve<IDbConnectionFactory>())); container.Resolve<IAuthRepository>().InitSchema(); } }.Init()) { using (var db = appHost.Container.Resolve<IDbConnectionFactory>().Open()) { var register = CreateNewUserRegistration(); var req = new BasicRequest(register); req.QueryString["authSecret"] = appHost.Config.AdminAuthSecret = "allow"; var response = (RegisterResponse)appHost.ExecuteService(register, req); var userAuth = db.SingleById<UserAuth>(response.UserId); var assignResponse = (AssignRolesResponse)appHost.ExecuteService(new AssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); Assert.That(assignResponse.AllRoles[0], Is.EqualTo("TestRole")); Assert.That(assignResponse.AllPermissions[0], Is.EqualTo("TestPermission")); userAuth = db.SingleById<UserAuth>(response.UserId); Assert.That(userAuth.Roles[0], Is.EqualTo("TestRole")); Assert.That(userAuth.Permissions[0], Is.EqualTo("TestPermission")); appHost.ExecuteService(new UnAssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); userAuth = db.SingleById<UserAuth>(response.UserId); Assert.That(userAuth.Roles.Count, Is.EqualTo(0)); Assert.That(userAuth.Permissions.Count, Is.EqualTo(0)); } } }
/// <summary> /// Xử lý gen mã /// </summary> public BasicResponse GenCd(HttpContext context, BasicRequest request) { // Khai báo biến cục bộ var response = new BasicResponse(); // Trường hợp là đăng ký if (request.IsAdd) { Thread.Sleep(1000); response.Add("TypeCd", DataHelper.GetUniqueKey()); response.Add(BasicResponse.PROP_RESULT_FLAG, true); } // Kết quả xử lý return response; }
public BasicResponse Invoke(BasicRequest request) { // Khởi tạo biến cục bộ var logic = new FilterLogic(); // Convert đối tượng request var inputObject = MapHelper.Convert<FilterDataModel>(request); // Thực thi xử lý logic var resultObject = logic.Execute(inputObject); // Convert đối tượng response var response = MapHelper.Convert<BasicResponse>(resultObject); // Kết quả trả về return response; }
private BasicResponse CalcInfo(BookingObject bookingObj) { var request = new BasicRequest(); request.Add("TypeCd", bookingObj.TypeCd); request.Add("DateFrom", bookingObj.DateFrom); request.Add("DateTo", bookingObj.DateTo); request.Add("RoomQty", bookingObj.RoomQty); request.Add("HasPickUp", bookingObj.PickUp); request.Add("HasSeeOff", bookingObj.SeeOff); var logic = new CalcOperateLogic(); var response = PageCom.Invoke(logic, request); return response; }
protected void Page_Load(object sender, EventArgs e) { var request = new BasicRequest(); request.Add("Slug", "destinations"); var logic = new InitOperateLogic(); var response = PageCom.Invoke(logic, request); var Pages = PageCom.GetValue<HashMap>(response, "Page"); ltPageName.Text = PageCom.GetValue<string>(Pages, "PageName"); ltPageContent.Text = PageCom.GetValue<string>(Pages, "Content"); Page.Title = PageCom.GetValue<string>(response, "MetaTitle"); Page.MetaKeywords = PageCom.GetValue<string>(response, "MetaKey"); Page.MetaDescription = PageCom.GetValue<string>(response, "MetaDescription"); }
protected void Page_Load(object sender, EventArgs e) { var request = new BasicRequest(); request.Add("Slug", Request["name"]); var logic = new InitOperateLogic(); var response = PageCom.Invoke(logic, request); var Tours = PageCom.GetValue<HashMap>(response, "Tour"); ltTourTitle.Text = PageCom.GetValue<string>(Tours, "TourName"); ltTourDes.Text = PageCom.GetValue<string>(Tours, "Notes"); Page.Title = PageCom.GetValue<string>(response, "MetaTitle"); Page.MetaKeywords = PageCom.GetValue<string>(response, "MetaKey"); Page.MetaDescription = PageCom.GetValue<string>(response, "MetaDescription"); }
protected void Page_Load(object sender, EventArgs e) { var request = new BasicRequest(); request.Add("Slug", "contact-us"); var logic = new InitOperateLogic(); var response = PageCom.Invoke(logic, request); var Pages = PageCom.GetValue<HashMap>(response, "Page"); ltPageName.Text = PageCom.GetValue<string>(Pages, "PageName"); ltPageContent.Text = PageCom.GetValue<string>(Pages, "Content"); Page.Title = PageCom.GetValue<string>(response, "MetaTitle"); Page.MetaKeywords = PageCom.GetValue<string>(response, "MetaKey"); Page.MetaDescription = PageCom.GetValue<string>(response, "MetaDescription"); getInfoCompany(); btnSubmit.Text = Strings.CLN_CONTACT_US_SEND; }
protected void btnSubmit_Command(object sender, CommandEventArgs e) { var request = new BasicRequest(); request.Add("Name", txtName.Text); request.Add("Phone", txtPhone.Text); request.Add("Email", txtEmail.Text); request.Add("Description", txtDescription.Text); var logic = new SendMailOperateLogic(); var response = PageCom.Invoke(logic, request); if (response.ResultFlag) { Page.ClientScript.RegisterStartupScript(this.GetType(), "clientscript", "<script> alert('" + Strings.CLN_ALERT_SUCCESS + "'); </script>"); clearControls(); } else { Page.ClientScript.RegisterStartupScript(this.GetType(), "clientscript", "<script> alert('" + Strings.CLN_ALERT_ERROR + "'); </script>"); } }
public static UserRegistrationService GetRegistrationService( AbstractValidator<UserRegistrationRequest> validator = null, IUserAuthRepository authRepo = null, string contentType = null) { var requestContext = new BasicRequest(); if (contentType != null) { requestContext.ResponseContentType = contentType; } var userAuthRepository = authRepo ?? GetStubRepo(); var service = new UserRegistrationService { UserRegistrationRequestValidator = validator ?? new UserRegistrationRequestValidator { UserAuthRepo = userAuthRepository }, AuthRepo = userAuthRepository, Request = requestContext, }; HostContext.Container.Register(userAuthRepository); return service; }
public void PublishNext() { if (!Enabled) return; var message = new BasicRequest {CorrelationId = Guid.NewGuid()}; if (Published != null) Published(this, null); _serviceBus.PublishRequest(message, rc => { rc.SetTimeout(30.Seconds()); rc.Handle<BasicResponse>(x => { if (ResponseHandled != null) ResponseHandled(this, null); System.Threading.Thread.Sleep(1000); }); }); PublishNext(); }
public void Can_assign_roles_that_persist_to_UserAuthRole_table_in_DynamoDb() { using (var appHost = new BasicAppHost { ConfigureContainer = container => { container.Register<IPocoDynamo>(c => new PocoDynamo(DynamoConfig.CreateDynamoDBClient())); //DynamoMetadata.Reset(); container.Resolve<IPocoDynamo>().DeleteAllTables(TimeSpan.FromMinutes(1)); container.Register<IAuthRepository>(c => new DynamoDbAuthRepository(c.Resolve<IPocoDynamo>())); container.Resolve<IAuthRepository>().InitSchema(); } }.Init()) { var db = appHost.Container.Resolve<IPocoDynamo>(); var register = CreateNewUserRegistration(); var req = new BasicRequest(register); req.QueryString["authSecret"] = appHost.Config.AdminAuthSecret = "allow"; var response = (RegisterResponse)appHost.ExecuteService(register, req); var userAuth = db.GetItem<UserAuth>(response.UserId); var assignResponse = (AssignRolesResponse)appHost.ExecuteService(new AssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); Assert.That(assignResponse.AllRoles[0], Is.EqualTo("TestRole")); Assert.That(assignResponse.AllPermissions[0], Is.EqualTo("TestPermission")); Assert.That(userAuth.Roles.Count, Is.EqualTo(0)); Assert.That(userAuth.Permissions.Count, Is.EqualTo(0)); var manageRoles = (IManageRoles)appHost.Container.Resolve<IAuthRepository>(); Assert.That(manageRoles.HasRole(userAuth.Id.ToString(), "TestRole")); Assert.That(manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission")); appHost.ExecuteService(new UnAssignRoles { UserName = userAuth.UserName, Roles = { "TestRole" }, Permissions = { "TestPermission" }, }, req); Assert.That(!manageRoles.HasRole(userAuth.Id.ToString(), "TestRole")); Assert.That(!manageRoles.HasPermission(userAuth.Id.ToString(), "TestPermission")); } }
public string RenderToHtml(RazorPage razorPage, out IRazorView razorView, object model = null, string layout = null) { if (razorPage == null) throw new ArgumentNullException("razorPage"); var httpReq = new BasicRequest(); if (layout != null) { httpReq.Items[RazorPageResolver.LayoutKey] = layout; } razorView = PageResolver.ExecuteRazorPage(httpReq, httpReq.Response, model, razorPage); var ms = (MemoryStream)httpReq.Response.OutputStream; return ms.ToArray().FromUtf8Bytes(); }
public void CheckRoleAssignmentInUserRoleTableUsingIAuthRepository() { using (var appHost = new BasicAppHost { ConfigureContainer = container => { container.Register<IUnitOfWork>(c => UnitOfWork); container.Register<IAuthRepository>(c => new LightSpeedUserAuthRepository(c.Resolve<IUnitOfWork>()) { UseDistinctRoleTables = true }); } }.Init()) { // Arrange LightSpeed.UserAuth userAuth; AssignRolesResponse assignRolesResponse; var newRegistration = CreateNewUserRegistration(); var request = new BasicRequest(newRegistration); var response = (RegisterResponse)appHost.ExecuteService(newRegistration, request); var authRepo = appHost.Resolve<IAuthRepository>(); // Test #1: Check role and permission assignment // --------------------------------------------- // Act userAuth = UnitOfWork.FindById<LightSpeed.UserAuth>(response.UserId); // Hydrate userAuth var assignRoleRequest = new AssignRoles { UserName = userAuth.UserName, Roles = { TestRoleName }, Permissions = { TestPermissionName }, }; userAuth = (LightSpeed.UserAuth)authRepo.GetUserAuthByUserName(assignRoleRequest.UserName); authRepo.AssignRoles(userAuth, assignRoleRequest.Roles, assignRoleRequest.Permissions); // Assert #1.1: // Check UserAuth to contain roles and permissions Assert.That(authRepo.GetRoles(userAuth).FirstOrDefault(), Is.EqualTo(TestRoleName)); Assert.That(authRepo.GetPermissions(userAuth).FirstOrDefault(), Is.EqualTo(TestPermissionName)); // Assert #1.2: // Check that roles and permissions are not persisted to UserAuth table Assert.That(userAuth.Roles.Count, Is.EqualTo(0)); Assert.That(userAuth.Permissions.Count, Is.EqualTo(0)); // Assert #1.3: // Check UserRoles table to contain roles and permissions var manageRoles = (IManageRoles)appHost.Container.Resolve<IAuthRepository>(); Assert.That(manageRoles.HasRole(userAuth.Id.ToString(), TestRoleName)); Assert.That(manageRoles.HasPermission(userAuth.Id.ToString(), TestPermissionName)); // Test #2: Check role and permission un-assignment // ------------------------------------------------ // Act userAuth = UnitOfWork.FindById<LightSpeed.UserAuth>(response.UserId); // Hydrate userAuth var unassignRolesRequest = new UnAssignRoles { UserName = userAuth.UserName, Roles = { TestRoleName }, Permissions = { TestPermissionName }, }; userAuth = (LightSpeed.UserAuth)authRepo.GetUserAuthByUserName(assignRoleRequest.UserName); authRepo.UnAssignRoles(userAuth, unassignRolesRequest.Roles, unassignRolesRequest.Permissions); // Assert #2.1: // Check UserAuth to contain roles and permissions Assert.That(authRepo.GetRoles(userAuth).FirstOrDefault(), Is.Null); Assert.That(authRepo.GetPermissions(userAuth).FirstOrDefault(), Is.Null); // Assert #2.2: // Check UserRole table not to contain roles and permissions above Assert.That(!manageRoles.HasRole(userAuth.Id.ToString(), TestRoleName)); Assert.That(!manageRoles.HasPermission(userAuth.Id.ToString(), TestPermissionName)); } }
public object Any(BasicRequest request) { return new BasicRequestResponse(); }
public MvcHtmlString RenderAction(string route, string viewName = null) { var req = new BasicRequest { Verb = HttpMethods.Get, PathInfo = route, ContentType = MimeTypes.Html, ResponseContentType = MimeTypes.Html, }.PopulateWith(HttpRequest); req.SetTemplate(EmptyTemplate); if (viewName != null) req.SetView(viewName); var response = HostContext.ServiceController.Execute(req); req.Response.WriteToResponse(req, response) .Wait(); //unnecessary as results are sync anyway var resBytes = ((MemoryStream)req.Response.OutputStream).ToArray(); var html = resBytes.FromUtf8Bytes(); return MvcHtmlString.Create(html); }
public void CheckRoleAssignmentInUserAuthTableUsingSecretKey() { using (var appHost = new BasicAppHost { ConfigureAppHost = host => { host.Config.AdminAuthSecret = AdminAuthSecret; }, ConfigureContainer = container => { container.Register<IUnitOfWork>(c => UnitOfWork); container.Register<IAuthRepository>(c => new LightSpeedUserAuthRepository(c.Resolve<IUnitOfWork>())); } }.Init()) { // Arrange LightSpeed.UserAuth userAuth; AssignRolesResponse assignRolesResponse; var newRegistration = CreateNewUserRegistration(); var request = new BasicRequest(newRegistration); request.QueryString["authSecret"] = AdminAuthSecret; var response = (RegisterResponse)appHost.ExecuteService(newRegistration, request); // Test #1: Check role and permission assignment // --------------------------------------------- // Act userAuth = UnitOfWork.FindById<LightSpeed.UserAuth>(response.UserId); // Hydrate userAuth var assignRoleRequest = new AssignRoles { UserName = userAuth.UserName, Roles = { TestRoleName }, Permissions = { TestPermissionName }, }; // Assert #1.1: // Check AssignRoles response to contain roles and permissions assignRolesResponse = (AssignRolesResponse)appHost.ExecuteService(assignRoleRequest, request); Assert.That(assignRolesResponse.AllRoles[0], Is.EqualTo(TestRoleName)); Assert.That(assignRolesResponse.AllPermissions[0], Is.EqualTo(TestPermissionName)); // Assert #1.2: // Check UserAuth to contain roles and permissions userAuth = UnitOfWork.FindById<LightSpeed.UserAuth>(response.UserId); Assert.That(userAuth.Roles[0], Is.EqualTo(TestRoleName)); Assert.That(userAuth.Permissions[0], Is.EqualTo(TestPermissionName)); // Test #2: Check role and permission un-assignment // ------------------------------------------------ // Act var unassignRolesRequest = new UnAssignRoles { UserName = userAuth.UserName, Roles = { TestRoleName }, Permissions = { TestPermissionName }, }; appHost.ExecuteService(unassignRolesRequest, request); // Assert #2.1: // Check UserAuth not to contain roles and permissions above userAuth = UnitOfWork.FindById<LightSpeed.UserAuth>(response.UserId); Assert.That(userAuth.Roles.Count, Is.EqualTo(0)); Assert.That(userAuth.Permissions.Count, Is.EqualTo(0)); } }
protected void InitTest(IUserAuthRepository userAuthRepository) { ((IClearable)userAuthRepository).Clear(); var appsettingsMock = new Mock<IAppSettings>(); var appSettings = appsettingsMock.Object; new AuthFeature(null, new IAuthProvider[] { new CredentialsAuthProvider(), new BasicAuthProvider(), new FacebookAuthProvider(appSettings), new TwitterAuthProvider(appSettings) }) .Register(null); mockService = new Mock<IServiceBase>(); mockService.Expect(x => x.TryResolve<IAuthRepository>()).Returns(userAuthRepository); requestContext = new BasicRequest(); mockService.Expect(x => x.Request).Returns(requestContext); service = mockService.Object; RegisterDto = new Register { UserName = "******", Password = "******", Email = "*****@*****.**", DisplayName = "DisplayName", FirstName = "FirstName", LastName = "LastName", }; }
public static RegisterService GetRegistrationService( IUserAuthRepository userAuthRepository, AuthUserSession oAuthUserSession = null, BasicRequest request = null) { if (request == null) request = new BasicRequest(); if (oAuthUserSession == null) oAuthUserSession = request.ReloadSession(); oAuthUserSession.Id = request.Response.CreateSessionId(request); request.Items[ServiceExtensions.RequestItemsSessionKey] = oAuthUserSession; var mockAppHost = new BasicAppHost(); mockAppHost.Container.Register<IAuthRepository>(userAuthRepository); var authService = new AuthenticateService { Request = request, }; authService.SetResolver(mockAppHost); mockAppHost.Register(authService); var registrationService = new RegisterService { AuthRepo = userAuthRepository, Request = request, RegistrationValidator = new RegistrationValidator { UserAuthRepo = RegistrationServiceTests.GetStubRepo() }, }; registrationService.SetResolver(mockAppHost); return registrationService; }
public void With_Native() { var request = new BasicRequest(); Console.WriteLine("Native(): {0}", Measure(() => new BasicService().Execute(request), Times)); }
public BasicResponse(BasicRequest requestContext) { this.requestContext = requestContext; this.Headers = new Dictionary<string, string>(); this.Items = new Dictionary<string, object>(); }
public override void Configure(Container container) { LogManager.LogFactory = new Log4NetFactory(true); container.Register(_dbConnectionFactory); var basicAuthProvider = new BasicAuthProvider(); container.Register(basicAuthProvider); Plugins.Add(new AuthFeature( () => new AuthUserSession(), new IAuthProvider[] {basicAuthProvider, }, SystemConstants.LoginUrl )); var userRepo = new OrmLiteAuthRepository(_dbConnectionFactory); container.Register<IAuthRepository>(userRepo); var cacheClient = new MemoryCacheClient(); container.Register(cacheClient); var currencyTypeRepository = new CurrencyTypeRepository { DbConnectionFactory = _dbConnectionFactory }; var transactionTypeRepository = new TransactionTypeRepository { DbConnectionFactory = _dbConnectionFactory }; var transactionStatusTypeRepository = new TransactionStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory }; var transactionNotificationStatusTypeRepository = new TransactionNotificationStatusTypeRepository { DbConnectionFactory = _dbConnectionFactory }; var transactionRepository = new TransactionRepository { DbConnectionFactory = _dbConnectionFactory }; var currencyTypeLogic = new CurrencyTypeLogic { Repository = currencyTypeRepository }; var transactionTypeLogic = new TransactionTypeLogic { Repository = transactionTypeRepository }; var transactionStatusTypeLogic = new TransactionStatusTypeLogic { Repository = transactionStatusTypeRepository }; var transactionNotificationStatusTypeLogic = new TransactionNotificationStatusTypeLogic { Repository = transactionNotificationStatusTypeRepository }; var transactionLogic = new TransactionLogic {Repository = transactionRepository}; container.Register<IRest<CurrencyType, GetCurrencyTypes>>(currencyTypeLogic); container.Register<IRest<TransactionType, GetTransactionTypes>>(transactionTypeLogic); container.Register<IRest<TransactionStatusType, GetTransactionStatusTypes>>(transactionStatusTypeLogic); container.Register<IRest<TransactionNotificationStatusType, GetTransactionNotificationStatusTypes>>(transactionNotificationStatusTypeLogic); container.Register<IRest<Transaction, GetTransactions>>(transactionLogic); CatchAllHandlers.Add((httpMethod, pathInfo, filePath) => pathInfo.StartsWith("/favicon.ico") ? new FavIconHandler() : null); var redisLocation = ConfigurationManager.AppSettings["ReddisService"]; Container.Register<IRedisClientsManager>(new PooledRedisClientManager(redisLocation)); var mqService = new RedisMqServer(container.Resolve<IRedisClientsManager>()); var messagingHandlers = new MessageService { Log = new Logger(typeof(MessageService).Name) }; Func<IMessage, IMessage> filterSecureRequests = (message) => { /* var tag = message.Tag; if (string.IsNullOrWhiteSpace(tag)) return message; if (tag.StartsWith("basic ", StringComparison.InvariantCultureIgnoreCase)) { var creds = Encoding.UTF8.GetString(Convert.FromBase64String(tag.Substring(5))); var i = creds.IndexOf(':'); var userName = creds.Substring(0, i); var userPass = creds.Substring(i + 1); if (userName != SystemConstants.AllowedUser || userPass != SystemConstants.AllowedPass) { message.Tag = null; return message; } _currentSessionGuid = Guid.NewGuid(); var sessionKey = userName + "/" + _currentSessionGuid.ToString("N"); SessionContext = new SessionContext { SessionKey = sessionKey, Username = userName }; container.Register(SessionContext); message.Tag = sessionKey; return message; } message.Tag = null;*/ return message; }; mqService.RequestFilter = filterSecureRequests; Func<IMessage<Transaction>, PostResponse<Transaction>> handlePostTransactions = (message) => { var service = new TransactionWebService { Logic = transactionLogic }; var request = new BasicRequest {Message = message, Dto = message.GetBody()}; var response = new BasicResponse(request); //userRepo.TryAuthenticate() service.SessionFactory.GetOrCreateSession(request, response); var session = service.GetSession(); session.UserName = "******"; var results = new PostResponse<Transaction> {Result = (Transaction) service.Post(message.GetBody())}; return results; }; // Dto Get Operations mqService.RegisterHandler<GetCurrencyTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), currencyTypeLogic)); mqService.RegisterHandler<GetTransactions>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionLogic)); mqService.RegisterHandler<GetTransactionStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionStatusTypeLogic)); mqService.RegisterHandler<GetTransactionNotificationStatusTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionNotificationStatusTypeLogic)); mqService.RegisterHandler<GetTransactionTypes>(m => messagingHandlers.MessagingGetWrapper(m.GetBody(), transactionTypeLogic)); // Dto Post Operations mqService.RegisterHandler<CurrencyType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), currencyTypeLogic.Post)); mqService.RegisterHandler<Transaction>(handlePostTransactions); mqService.RegisterHandler<TransactionStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionStatusTypeLogic.Post)); mqService.RegisterHandler<TransactionNotificationStatusType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionNotificationStatusTypeLogic.Post)); mqService.RegisterHandler<TransactionType>(m => messagingHandlers.MessagingPostRequest(m.GetBody(), transactionTypeLogic.Post)); // Dto Put Opertations mqService.RegisterHandler<DeleteCurrencyType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), currencyTypeLogic)); mqService.RegisterHandler<DeleteTransaction>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionLogic)); mqService.RegisterHandler<DeleteTransactionStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionStatusTypeLogic)); mqService.RegisterHandler<DeleteTransactionNotificationStatusType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionNotificationStatusTypeLogic)); mqService.RegisterHandler<DeleteTransactionType>(m => messagingHandlers.MessagingDeleteWrapper(m.GetBody(), transactionTypeLogic)); mqService.Start(); }