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 With_TypedArguments()
{
serviceController.Register(typeof(BasicRequest), typeof(BasicService));
var request = new BasicRequest();
Console.WriteLine("With_TypedArguments(): {0}", Measure(() => serviceController.Execute(request), Times));
}
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 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 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 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 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 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();
}
