public virtual void Init(IAppSettings appSettings = null)
{
RequireSecureConnection = true;
HashAlgorithm = "RS256";
ExpireTokensIn = TimeSpan.FromDays(14);
if (appSettings != null)
{
RequireSecureConnection = appSettings.Get("aadr.RequireSecureConnection", RequireSecureConnection);
//Issuer = appSettings.GetString("jwt.Issuer");
Audience = appSettings.GetString("aadr.Audience");
Tenant = appSettings.GetString("aadr.Tenant");
//KeyId = appSettings.GetString("jwt.KeyId");
//var hashAlg = appSettings.GetString("aadr.HashAlgorithm");
//if (!string.IsNullOrEmpty(hashAlg))
// HashAlgorithm = hashAlg;
//RequireHashAlgorithm = appSettings.Get("jwt.RequireHashAlgorithm", RequireSecureConnection);
//PrivateKeyXml = appSettings.GetString("jwt.PrivateKeyXml");
//PublicKeyXml = appSettings.GetString("jwt.PublicKeyXml");
//var base64 = appSettings.GetString("jwt.AuthKeyBase64");
//if (base64 != null)
// AuthKeyBase64 = base64;
var dateStr = appSettings.GetString("aadr.InvalidateTokensIssuedBefore");
if (!string.IsNullOrEmpty(dateStr))
{
InvalidateTokensIssuedBefore = dateStr.FromJsv <DateTime>();
}
ExpireTokensIn = appSettings.Get("aadr.ExpireTokensIn", ExpireTokensIn);
var intStr = appSettings.GetString("aadr.ExpireTokensInDays");
if (intStr != null)
{
ExpireTokensInDays = int.Parse(intStr);
}
}
_jwtAuthProviderReader = new JwtAuthProviderReader();
_jwtAuthProviderReader.RequireSecureConnection = RequireSecureConnection;
//_jwtAuthProviderReader.Issuer = "ssjwt";
_jwtAuthProviderReader.ExpireTokensIn = ExpireTokensIn;
_jwtAuthProviderReader.InvalidateTokensIssuedBefore = InvalidateTokensIssuedBefore;
_publicKeys = RetrievePublicKeys(Tenant);
}
public void Register(IAppHost appHost)
{
JwtAuthProvider = AuthenticateService.GetJwtAuthProvider();
if (JwtAuthProvider is JwtAuthProvider)
{
appHost.RegisterService(typeof(JwksService));
}
else if (JwtAuthProvider != null)
{
var keySet = RetrieveKeySet();
LoadKeySet(keySet);
}
}
public override void Configure(Container container)
{
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var jwtprovider = new JwtAuthProviderReader
{
HashAlgorithm = "RS256",
PublicKeyXml = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_JWT_PUBLIC_KEY_XML),
#if (DEBUG)
RequireSecureConnection = false,
//EncryptPayload = true,
#endif
};
this.Plugins.Add(new CorsFeature(allowedHeaders: "rToken, bToken, Content-Type, Authorization, Access-Control-Allow-Origin, Access-Control-Allow-Credentials"));
this.Plugins.Add(new ServerEventsFeature());
this.Plugins.Add(new AuthFeature(() => new CustomUserSession(),
new IAuthProvider[] {
jwtprovider,
}));
#if (DEBUG)
SetConfig(new HostConfig {
DebugMode = true
});
#endif
SetConfig(new HostConfig {
DefaultContentType = MimeTypes.Json
});
string env = Environment.GetEnvironmentVariable(EnvironmentConstants.ASPNETCORE_ENVIRONMENT);
var redisServer = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_SERVER);
var redisPassword = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PASSWORD);
var redisPort = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PORT);
//if (env == "Staging")
//{
// container.Register<IRedisClientsManager>(c => new RedisManagerPool(redisServer));
//}
//else
//{
var redisConnectionString = string.Format("redis://{0}@{1}:{2}", redisPassword, redisServer, redisPort);
container.Register <IRedisClientsManager>(c => new RedisManagerPool(redisConnectionString));
//}
container.Register <IUserAuthRepository>(c => new MyRedisAuthRepository(c.Resolve <IRedisClientsManager>()));
container.Register <IEbMqClient>(c => new EbMqClient()).ReusedWithin(ReuseScope.Request);
RabbitMqMessageFactory rabitFactory = new RabbitMqMessageFactory();
rabitFactory.ConnectionFactory.UserName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_USER);
rabitFactory.ConnectionFactory.Password = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PASSWORD);
rabitFactory.ConnectionFactory.HostName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_HOST);
rabitFactory.ConnectionFactory.Port = Convert.ToInt32(Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PORT));
rabitFactory.ConnectionFactory.VirtualHost = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_VHOST);
var mqServer = new RabbitMqServer(rabitFactory);
container.AddScoped <IMessageProducer, RabbitMqProducer>(serviceProvider =>
{
return(mqServer.CreateMessageProducer() as RabbitMqProducer);
});
container.Register <IServerEvents>(c => new RedisServerEvents(c.Resolve <IRedisClientsManager>()));
container.Resolve <IServerEvents>().Start();
//Setting Assembly version in Redis
RedisClient client = (container.Resolve <IRedisClientsManager>() as RedisManagerPool).GetClient() as RedisClient;
AssemblyName assembly = Assembly.GetExecutingAssembly().GetName();
String version = assembly.Name.ToString() + " - " + assembly.Version.ToString();
client.Set("ServerEventsAssembly", version);
this.GlobalRequestFilters.Add((req, res, requestDto) =>
{
ILog log = LogManager.GetLogger(GetType());
log.Info("In GlobalRequestFilters");
try
{
log.Info("In Try");
if (requestDto != null)
{
log.Info("In Auth Header");
var auth = req.Headers[HttpHeaders.Authorization];
if (string.IsNullOrEmpty(auth))
{
res.ReturnAuthRequired();
}
else
{
if (req.Headers[CacheConstants.RTOKEN] != null)
{
log.Info("Req Headers Not Null");
}
var jwtoken = new JwtSecurityToken(auth.Replace("Bearer", string.Empty).Trim());
foreach (var c in jwtoken.Claims)
{
if (c.Type == "cid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add(CoreConstants.SOLUTION_ID, c.Value);
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).SolnId = c.Value;
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).SolnId = c.Value;
}
continue;
}
if (c.Type == "uid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("UserId", Convert.ToInt32(c.Value));
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).UserId = Convert.ToInt32(c.Value);
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserId = Convert.ToInt32(c.Value);
}
continue;
}
if (c.Type == "wc" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("wc", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).WhichConsole = c.Value.ToString();
}
continue;
}
if (c.Type == "sub" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("sub", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserAuthId = c.Value.ToString();
}
continue;
}
}
log.Info("Req Filter Completed");
}
}
}
catch (Exception e)
{
log.Info("ErrorStackTraceNontokenServices..........." + e.StackTrace);
log.Info("ErrorMessageNontokenServices..........." + e.Message);
log.Info("InnerExceptionNontokenServices..........." + e.InnerException);
}
});
}
public override void Configure(Container container)
{
// Settings
SetConfig(new HostConfig {
UseCamelCase = true
});
RoleNames.Admin = Roles.Admin;
JsConfig.EmitCamelCaseNames = true;
JsConfig.ExcludeTypeInfo = true;
JsConfig <UserSession> .IncludeTypeInfo = true;
JsConfig.DateHandler = DateHandler.ISO8601;
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var baseSettings = new AppSettings();
container.Register(baseSettings);
container.Register(c => new MultiAppSettings(c.Resolve <AppSettings>()));
var appSettings = container.Resolve <MultiAppSettings>();
var configuration =
container.Resolve <Microsoft.Extensions.Options.IOptions <ApplicationConfiguration> >().Value;
container.Register(configuration);
// DB
container.Register <IDbConnectionFactory>(c =>
{
var connectionString =
configuration.ConnectionStrings.AzureSql;
return(new OrmLiteConnectionFactory(connectionString,
SqlServerDialect.Provider));
});
container.Register(c => c.Resolve <IDbConnectionFactory>().Open())
.ReusedWithin(ReuseScope.None);
// Redis
//container.Register<IRedisClientsManager>(c =>
// {
// var connectionString =
// configuration.ConnectionStrings.AzureRedis;
// return new RedisManagerPool(connectionString);
// });
// Cache
//container.Register(c => c.Resolve<IRedisClientsManager>().GetCacheClient());
container.Register <ICacheClient>(new MemoryCacheClient {
FlushOnDispose = false
});
// Validators
container.RegisterValidators(typeof(IAuditable).GetAssembly());
// Auth
container.Register <IUserAuthRepository>(
c => new OrmLiteAuthRepository(c.Resolve <IDbConnectionFactory>())
{
UseDistinctRoleTables = true
});
// Db filters
OrmLiteConfig.InsertFilter = (dbCmd, row) =>
{
if (row is IAuditable)
{
var auditRow = row as IAuditable;
auditRow.CreateDate = auditRow.ModifyDate = DateTime.UtcNow;
}
if (row is Product)
{
var product = row as Product;
product.OnInsert();
}
};
OrmLiteConfig.UpdateFilter = (dbCmd, row) =>
{
if (row is IAuditable)
{
var auditRow = row as IAuditable;
auditRow.ModifyDate = DateTime.UtcNow;
if (auditRow.CreateDate == DateTime.MinValue)
{
auditRow.CreateDate = auditRow.ModifyDate;
}
}
if (row is Product)
{
var product = row as Product;
product.OnUpdate();
}
};
// Schema init
using (var ctx = container.Resolve <IDbConnectionFactory>().Open())
{
ctx.CreateTableIfNotExists <ApiKey>();
ctx.CreateTableIfNotExists <Category>();
ctx.CreateTableIfNotExists <Product>();
ctx.CreateTableIfNotExists <ProductCategory>();
ctx.CreateTableIfNotExists <ProductImage>();
ctx.CreateTableIfNotExists <Tag>();
ctx.CreateTableIfNotExists <ProductTag>();
ctx.CreateTableIfNotExists <UserPriceOverride>();
ctx.CreateTableIfNotExists <Vendor>();
ctx.CreateTableIfNotExists <InventoryTransaction>();
ctx.CreateTableIfNotExists <Sale>();
ctx.CreateTableIfNotExists <Warehouse>();
ctx.CreateTableIfNotExists <Location>();
ctx.CreateTableIfNotExists <Image>();
ctx.CreateTableIfNotExists <Customer>();
ctx.CreateTableIfNotExists <Merchant>();
ctx.CreateTableIfNotExists <Order>();
ctx.CreateTableIfNotExists <Offer>();
ctx.CreateTableIfNotExists <Address>();
}
// Mail
container.Register(c =>
{
var host = configuration.Mail.Host;
var port = configuration.Mail.Port;
var useSsl = configuration.Mail.UseSsl;
var creds = new NetworkCredential(configuration.Mail.Username,
configuration.Mail.Password);
var client = new SmtpClient();
client.Connect(host, port, useSsl);
client.Authenticate(creds);
return(client);
});
// Plugins
Plugins.Add(new CorsFeature(
allowCredentials: true,
allowedMethods: "OPTIONS, GET, PUT, POST, PATCH, DELETE, SEARCH",
allowedHeaders: "Content-Type, X-Requested-With, Cache-Control, Authorization",
allowOriginWhitelist:
new List <string>
{
"http://localhost:6307",
"http://localhost:8080",
"http://0.0.0.0:8080",
"http://0.0.0.0:3000",
"http://inventory-web-dev-wb45gu.herokuapp.com",
"https://inventory-web-dev-wb45gu.herokuapp.com",
"https://inventory-web-sta-d8w373.herokuapp.com",
"https://inventory.derprecated.com",
"https://inventory-web-pro.herokuapp.com"
},
maxAge: 3600));
var jwk = JwkFromUri(new Uri(configuration.Auth0.Jwks));
var rsaPubkey = RsaPubkeyFromJwk(jwk);
var managementUri = new Uri($"https://{configuration.Auth0.Domain}/");
var tokenAuth = new JwtAuthProviderReader
{
RequireHashAlgorithm = true,
HashAlgorithm = "RS256",
PublicKey = rsaPubkey,
Audience = configuration.Auth0.Audience,
Issuer = configuration.Auth0.Issuer,
PopulateSessionFilter = (session, json, request) =>
{
/* JSON object looks like:
* {
* "app_metadata": {
* "authorization": {
* "roles": ["Admin", "User", "Delegated Admin - Administrator", "Delegated Admin - User"],
* "permissions": ["everything", "login", "manageCategories", "dispatchInventory"]
* }
* },
* "iss": "https://derprecated.auth0.com/",
* "sub": "google-oauth2|108854378958464530522",
* "aud": "HgdpKajxywOUlc52Uv6rASdiABMsnYd4",
* "exp": 1489635158,
* "iat": 1489599158
* }
*
* session props already set:
* session.UserAuthId = json.sub.split('|',2)[1]
*/
var authorization = json.Object("app_metadata")
.Object("authorization");
session.Permissions = authorization
.GetArray <string>("permissions")
.ToList();
session.Roles = authorization
.GetArray <string>("roles")
.ToList();
},
#if DEBUG
RequireSecureConnection = false
#endif
};
Plugins.Add(new AuthFeature(
() => new AuthUserSession(),
new IAuthProvider[]
{
tokenAuth
},
"/login")
{
IncludeAssignRoleServices = false,
ValidateUniqueEmails = true
});
Plugins.Add(new ValidationFeature());
Plugins.Add(new AutoQueryFeature {
MaxLimit = 100
});
Plugins.Add(new SwaggerFeature());
// Restrictions
typeof(AssignRoles).AddAttributes(new RestrictAttribute {
VisibleLocalhostOnly = true
});
typeof(UnAssignRoles).AddAttributes(new RestrictAttribute {
VisibleLocalhostOnly = true
});
// Handlers
container.RegisterAs <ImageHandler, IHandler <Image> >()
.ReusedWithin(ReuseScope.Request);
container.RegisterAs <ProductImageHandler, IHandler <ProductImage> >()
.ReusedWithin(ReuseScope.Request);
container.RegisterAs <LocationHandler, IHandler <Location> >()
.ReusedWithin(ReuseScope.Request);
container.RegisterAs <CategoryHandler, IHandler <Category> >()
.ReusedWithin(ReuseScope.Request);
container.RegisterAs <VendorHandler, IHandler <Vendor> >()
.ReusedWithin(ReuseScope.Request);
container.RegisterAs <WarehouseHandler, IHandler <Warehouse> >()
.ReusedWithin(ReuseScope.Request);
container.RegisterAs <ProductHandler, IHandler <Product> >()
.ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired <UserHandler>()
.ReusedWithin(ReuseScope.Request);
container.RegisterAutoWired <Auth0Handler>();
container.RegisterAs <AddressHandler, IHandler <Address> >()
.ReusedWithin(ReuseScope.Request);
container.RegisterAs <OrderHandler, IHandler <Order> >()
.ReusedWithin(ReuseScope.Request);
container.Register(new StripeHandler(configuration.Stripe.SecretKey));
container.RegisterAutoWired <InventoryHandler>()
.ReusedWithin(ReuseScope.Request);
// Misc
container.Register(new AuthenticationApiClient(new Uri($"https://{configuration.Auth0.Domain}/")));
container.Register(new ShopifyServiceClient($"https://{configuration.Shopify.Domain}")
{
UserName = configuration.Shopify.ApiKey,
Password = configuration.Shopify.Password
});
container.Register(c =>
{
var connectionString = configuration.ConnectionStrings.AzureStorage;
return(CloudStorageAccount.Parse(connectionString));
});
container.Register(c => c.Resolve <CloudStorageAccount>().CreateCloudBlobClient());
}
public override void Configure(Container container)
{
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var jwtprovider = new JwtAuthProviderReader
{
HashAlgorithm = "RS256",
PublicKeyXml = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_JWT_PUBLIC_KEY_XML),
RequireSecureConnection = false,
//EncryptPayload = true,
};
this.Plugins.Add(new AuthFeature(() => new CustomUserSession(),
new IAuthProvider[] {
jwtprovider,
}));
#if (DEBUG)
SetConfig(new HostConfig {
DebugMode = true
});
#endif
SetConfig(new HostConfig {
DefaultContentType = MimeTypes.Json
});
string env = Environment.GetEnvironmentVariable(EnvironmentConstants.ASPNETCORE_ENVIRONMENT);
var redisServer = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_SERVER);
var redisPassword = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PASSWORD);
var redisPort = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PORT);
RedisClient client = null;
string redisConnectionString = string.Format("redis://{0}@{1}:{2}", redisPassword, redisServer, redisPort);
container.Register <IRedisClientsManager>(c => new RedisManagerPool(redisConnectionString));
client = (container.Resolve <IRedisClientsManager>() as RedisManagerPool).GetClient() as RedisClient;
AssemblyName assembly = Assembly.GetExecutingAssembly().GetName();
String version = assembly.Name.ToString() + " - " + assembly.Version.ToString();
client.Set("MQAssembly", version);
container.Register <IEbServerEventClient>(c => new EbServerEventClient()).ReusedWithin(ReuseScope.Request);
container.Register <IServiceClient>(c => new JsonServiceClient(Environment.GetEnvironmentVariable(EnvironmentConstants.EB_SERVICESTACK_EXT_URL))).ReusedWithin(ReuseScope.Request);
container.Register <IEbConnectionFactory>(c => new EbConnectionFactory(c)).ReusedWithin(ReuseScope.Request);
container.Register <IEbStaticFileClient>(c => new EbStaticFileClient()).ReusedWithin(ReuseScope.Request);
RabbitMqMessageFactory rabitFactory = new RabbitMqMessageFactory();
rabitFactory.ConnectionFactory.UserName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_USER);
rabitFactory.ConnectionFactory.Password = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PASSWORD);
rabitFactory.ConnectionFactory.HostName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_HOST);
rabitFactory.ConnectionFactory.Port = Convert.ToInt32(Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PORT));
rabitFactory.ConnectionFactory.VirtualHost = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_VHOST);
var mqServer = new RabbitMqServer(rabitFactory);
mqServer.RetryCount = 1;
mqServer.RegisterHandler <RefreshSolutionConnectionsRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadFileRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadImageRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadImageInfraMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadDpRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <UploadLogoRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <NotificationToDBRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SaveRoleMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SaveUserMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SuspendUserMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <BrowserExceptionRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SaveUserGroupMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<GetImageFtpRequest>(base.ExecuteMessage, 3);
mqServer.RegisterHandler <EmailServicesRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <SMSSentRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <ApiMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<SMSStatusLogMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<SlackPostMqRequest>(base.ExecuteMessage);
//mqServer.RegisterHandler<SlackAuthMqRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <ReportRenderMultipleMQRequest>(base.ExecuteMessage);
mqServer.Start();
container.AddScoped <IMessageProducer, RabbitMqProducer>(serviceProvider =>
{
return(mqServer.CreateMessageProducer() as RabbitMqProducer);
});
container.AddScoped <IMessageQueueClient, RabbitMqQueueClient>(serviceProvider =>
{
return(mqServer.CreateMessageQueueClient() as RabbitMqQueueClient);
});
//var quartzFeature = new QuartzFeature();
//// create a simple job trigger to repeat every minute
//quartzFeature.RegisterJob<MyJob>(
// trigger =>
// trigger.WithSimpleSchedule(s =>
// s.WithInterval(TimeSpan.FromSeconds(30))
// .RepeatForever()
// )
// .Build()
//);
//quartzFeature.RegisterJob<MyJob>(
// trigger =>
// trigger.WithDailyTimeIntervalSchedule(s => s.WithInterval(1, IntervalUnit.Minute))
// .Build()
//);
//// register the plugin
//Plugins.Add(quartzFeature);
this.GlobalRequestFilters.Add((req, res, requestDto) =>
{
ILog log = LogManager.GetLogger(GetType());
log.Info("In GlobalRequestFilters");
try
{
log.Info("In Try");
if (requestDto != null /*&& requestDto.GetType() != typeof(RefreshSolutionExtRequest)*/)
{
log.Info("In Auth Header");
var auth = req.Headers[HttpHeaders.Authorization];
if (string.IsNullOrEmpty(auth))
{
res.ReturnAuthRequired();
}
else
{
if (req.Headers[CacheConstants.RTOKEN] != null)
{
Resolve <IEbServerEventClient>().AddAuthentication(req);
}
var jwtoken = new JwtSecurityToken(auth.Replace("Bearer", string.Empty).Trim());
foreach (var c in jwtoken.Claims)
{
if (c.Type == "cid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add(CoreConstants.SOLUTION_ID, c.Value);
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).SolnId = c.Value;
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).SolnId = c.Value;
}
continue;
}
if (c.Type == "uid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("UserId", Convert.ToInt32(c.Value));
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).UserId = Convert.ToInt32(c.Value);
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserId = Convert.ToInt32(c.Value);
}
continue;
}
if (c.Type == "wc" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("wc", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).WhichConsole = c.Value.ToString();
}
continue;
}
if (c.Type == "sub" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("sub", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserAuthId = c.Value.ToString();
}
continue;
}
}
log.Info("Req Filter Completed");
}
}
}
catch (Exception e)
{
log.Info("ErrorStackTraceNontokenServices..........." + e.StackTrace);
log.Info("ErrorMessageNontokenServices..........." + e.Message);
log.Info("InnerExceptionNontokenServices..........." + e.InnerException);
}
});
}
public override void Configure(Container container)
{
LogManager.LogFactory = new ConsoleLogFactory(debugEnabled: true);
var jwtprovider = new JwtAuthProviderReader
{
HashAlgorithm = "RS256",
PublicKeyXml = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_JWT_PUBLIC_KEY_XML),
#if (DEBUG)
RequireSecureConnection = false,
//EncryptPayload = true,
#endif
};
this.Plugins.Add(new AuthFeature(() => new CustomUserSession(),
new IAuthProvider[] {
jwtprovider,
}));
#if (DEBUG)
SetConfig(new HostConfig {
DebugMode = true
});
#endif
SetConfig(new HostConfig {
DefaultContentType = MimeTypes.Json
});
RabbitMqMessageFactory rabitFactory = new RabbitMqMessageFactory();
rabitFactory.ConnectionFactory.UserName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_USER);
rabitFactory.ConnectionFactory.Password = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PASSWORD);
rabitFactory.ConnectionFactory.HostName = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_HOST);
rabitFactory.ConnectionFactory.Port = Convert.ToInt32(Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_PORT));
rabitFactory.ConnectionFactory.VirtualHost = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_RABBIT_VHOST);
var mqServer = new RabbitMqServer(rabitFactory);
mqServer.RetryCount = 1;
mqServer.RegisterHandler <ScheduleRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <DeleteJobRequest>(base.ExecuteMessage);
mqServer.RegisterHandler <RescheduleRequest>(base.ExecuteMessage);
mqServer.Start();
container.AddScoped <IMessageProducer, RabbitMqProducer>(serviceProvider =>
{
return(mqServer.CreateMessageProducer() as RabbitMqProducer);
});
container.AddScoped <IMessageQueueClient, RabbitMqQueueClient>(serviceProvider =>
{
return(mqServer.CreateMessageQueueClient() as RabbitMqQueueClient);
});
//****************SCHEDULER********************
string conn = string.Format("Server = {0}; Database = {1}; Uid = {2}; Pwd = {3}; Trust Server Certificate=true; Port= {4}; Use SSL Stream=true; SSL Mode=Require;",
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DB_SERVER),
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DBNAME),
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DB_RW_USER),
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DB_RW_PASSWORD),
Environment.GetEnvironmentVariable(EnvironmentConstants.EB_INFRA_DB_PORT));
var properties = new NameValueCollection
{
["quartz.serializer.type"] = "json",
["quartz.scheduler.instanceName"] = "DotnetCoreScheduler",
["quartz.scheduler.instanceId"] = "instance_one",
["quartz.threadPool.type"] = "Quartz.Simpl.SimpleThreadPool, Quartz",
["quartz.threadPool.threadCount"] = "5",
["quartz.jobStore.misfireThreshold"] = "60000",
["quartz.jobStore.type"] = "Quartz.Impl.AdoJobStore.JobStoreTX, Quartz",
["quartz.jobStore.useProperties"] = "true",
["quartz.jobStore.dataSource"] = "myDS",
["quartz.jobStore.tablePrefix"] = "QRTZ_",
["quartz.jobStore.driverDelegateType"] = "Quartz.Impl.AdoJobStore.PostgreSQLDelegate, Quartz",
["quartz.dataSource.myDS.provider"] = "Npgsql ",
["quartz.dataSource.myDS.connectionString"] = conn
};
StdSchedulerFactory factory = new Quartz.Impl.StdSchedulerFactory(properties);
IScheduler scheduler = factory.GetScheduler().Result;
scheduler.Start().Wait();
container.AddScoped <IScheduler>(serviceProvider =>
{
return(scheduler);
});
string env = Environment.GetEnvironmentVariable(EnvironmentConstants.ASPNETCORE_ENVIRONMENT);
var redisServer = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_SERVER);
var redisPassword = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PASSWORD);
var redisPort = Environment.GetEnvironmentVariable(EnvironmentConstants.EB_REDIS_PORT);
RedisClient client = null;
//if (env == "Staging")
//{
// client = new RedisClient(redisServer, Convert.ToInt32(redisPort));
//}
//else
//{
client = new RedisClient(string.Format("redis://{0}@{1}:{2}", redisPassword, redisServer, redisPort));
//}
//Setting Assembly version in Redis
AssemblyName assembly = Assembly.GetExecutingAssembly().GetName();
String version = assembly.Name.ToString() + " - " + assembly.Version.ToString();
client.Set("SchedulerAssembly", version);
this.GlobalRequestFilters.Add((req, res, requestDto) =>
{
ILog log = LogManager.GetLogger(GetType());
log.Info("In GlobalRequestFilters");
try
{
log.Info("In Try");
if (requestDto != null)
{
log.Info("In Auth Header");
var auth = req.Headers[HttpHeaders.Authorization];
if (string.IsNullOrEmpty(auth))
{
res.ReturnAuthRequired();
}
else
{
if (req.Headers[CacheConstants.RTOKEN] != null)
{
Resolve <IEbServerEventClient>().AddAuthentication(req);
}
var jwtoken = new JwtSecurityToken(auth.Replace("Bearer", string.Empty).Trim());
foreach (var c in jwtoken.Claims)
{
if (c.Type == "cid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add(CoreConstants.SOLUTION_ID, c.Value);
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).SolnId = c.Value;
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).SolnId = c.Value;
}
continue;
}
if (c.Type == "uid" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("UserId", Convert.ToInt32(c.Value));
if (requestDto is IEbSSRequest)
{
(requestDto as IEbSSRequest).UserId = Convert.ToInt32(c.Value);
}
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserId = Convert.ToInt32(c.Value);
}
continue;
}
if (c.Type == "wc" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("wc", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).WhichConsole = c.Value.ToString();
}
continue;
}
if (c.Type == "sub" && !string.IsNullOrEmpty(c.Value))
{
RequestContext.Instance.Items.Add("sub", c.Value);
if (requestDto is EbServiceStackAuthRequest)
{
(requestDto as EbServiceStackAuthRequest).UserAuthId = c.Value.ToString();
}
continue;
}
}
log.Info("Req Filter Completed");
}
}
}
catch (Exception e)
{
log.Info("ErrorStackTraceNontokenServices..........." + e.StackTrace);
log.Info("ErrorMessageNontokenServices..........." + e.Message);
log.Info("InnerExceptionNontokenServices..........." + e.InnerException);
}
});
}
