static MongoDbDataStoreFactory()
{
var typeSerializer = new TypeSerialiser();
BsonSerializer.RegisterSerializer(typeof(Type), typeSerializer);
BsonSerializer.RegisterSerializer(Type.GetType("System.RuntimeType"), typeSerializer);
IndexTypesByEntityType = new Dictionary <Type, IList <object> >();
foreach (Assembly assembly in AppDomain.CurrentDomain.GetAssemblies())
{
var mongoIndexTypes = assembly
.GetTypes()
.Where
(
type =>
(
// base is NOT an abstract index
(
type.BaseType != null &&
type.BaseType.IsGenericType &&
typeof(MongoDbIndex <>).IsAssignableFrom(type.BaseType.GetGenericTypeDefinition())
)
||
// base is an abstract index
(
type.BaseType != null &&
type.BaseType.BaseType != null &&
type.BaseType.BaseType.IsGenericType &&
typeof(MongoDbIndex <>).IsAssignableFrom(type.BaseType.BaseType.GetGenericTypeDefinition())
)
||
// a deeper inheritance model
(
type.BaseType != null &&
type.BaseType.BaseType != null &&
type.BaseType.BaseType.BaseType != null &&
type.BaseType.BaseType.BaseType.IsGenericType &&
typeof(MongoDbIndex <>).IsAssignableFrom(type.BaseType.BaseType.BaseType.GetGenericTypeDefinition())
)
||
// an even deeper inheritance model
(
type.BaseType != null &&
type.BaseType.BaseType != null &&
type.BaseType.BaseType.BaseType != null &&
type.BaseType.BaseType.BaseType.BaseType != null &&
type.BaseType.BaseType.BaseType.BaseType.IsGenericType &&
typeof(MongoDbIndex <>).IsAssignableFrom(type.BaseType.BaseType.BaseType.BaseType.GetGenericTypeDefinition())
)
) &&
!type.IsAbstract
);
foreach (Type mongoIndexType in mongoIndexTypes)
{
Type genericType = mongoIndexType;
while (genericType != null && !genericType.IsGenericType)
{
genericType = genericType.BaseType;
}
genericType = genericType.GetGenericArguments().Single();
IList <object> indexTypes;
if (!IndexTypesByEntityType.TryGetValue(genericType, out indexTypes))
{
IndexTypesByEntityType.Add(genericType, indexTypes = new List <object>());
}
object mongoIndex = Activator.CreateInstance(mongoIndexType, true);
indexTypes.Add(mongoIndex);
}
}
}
static EventStore()
{
BsonSerializer.RegisterSerializer(typeof(EventSourceVersion), new EventSourceVersionSerializer());
}
static SerializationHelper()
{
var decimalSerializer = new DecimalSerializer(BsonType.Decimal128, new RepresentationConverter(allowOverflow: false, allowTruncation: false));
BsonSerializer.RegisterSerializer(decimalSerializer);
}
/// <summary>
/// Loads serializers
/// </summary>
public void Load()
{
BsonSerializer.RegisterSerializer(new DecimalSerializer(BsonType.String));
}
static LocalDateTimeSerializerTests()
{
BsonSerializer.RegisterSerializer(new LocalDateTimeSerializer());
}
/// <summary>
/// Set database initializer
/// </summary>
public virtual void SetDatabaseInitializer()
{
BsonSerializer.RegisterSerializer(typeof(DateTime),
new DateTimeSerializer(DateTimeKind.Utc));
}
protected override void Load(ContainerBuilder builder)
{
base.Load(builder);
string cs = _configuration.GetSection("Settings:CADENA_CONEXION").Value;
var mongoUrl = new MongoUrl(cs);
/*
* var ms = MongoClientSettings.FromConnectionString(cs);
* ms.SslSettings = new SslSettings() { EnabledSslProtocols = SslProtocols.Tls12 };
* ms.RetryWrites = false;
* ms.ServerSelectionTimeout = new TimeSpan(0, 5, 0);
* ms.WaitQueueTimeout = new TimeSpan(0, 5, 0);
* ms.WaitQueueSize = 60000;
*/
//builder.RegisterType<DataContext>().Named<IDataContext>("contextNoSql").WithParameter("settings", settings).InstancePerLifetimeScope();
builder.RegisterType <DataContext>().Named <IDataContext>("contextNoSql").WithParameter("mongoUrl", mongoUrl).InstancePerLifetimeScope();
/*
* //-> Aplicacion
* builder.RegisterAssemblyTypes(Assembly.Load(new AssemblyName("Minedu.AprendoEnCasaOffLine.Contenido.Core")))
* .Where(t => t.Name.EndsWith("Aplicacion", StringComparison.Ordinal) && t.GetTypeInfo().IsClass)
* .AsImplementedInterfaces();
*
* //-> Validacion
* builder.RegisterAssemblyTypes(Assembly.Load(new AssemblyName("Minedu.AprendoEnCasaOffLine.Contenido.Core")))
* .Where(t => t.Name.EndsWith("Validacion", StringComparison.Ordinal) && t.GetTypeInfo().IsClass)
* .AsSelf();
*/
//Base
builder.RegisterType <CollectionContext>().As <ICollectionContext>().WithParameter((c, p) => true, (c, p) => p.ResolveNamed <IDataContext>("contextNoSql"));
BsonSerializer.RegisterSerializer(typeof(DateTime), new BsonUtcDateTimeSerializer());
//Repository
/*
* builder.RegisterAssemblyTypes(Assembly.Load(new AssemblyName("Minedu.AprendoEnCasaOffLine.Contenido.Core")))
* .Where(t => t.Name.EndsWith("Repositorio", StringComparison.Ordinal) && t.IsGenericType == false && t.IsClass == true && t.BaseType.Name.Contains("CustomBaseRepository"))
* .AsImplementedInterfaces()
* .WithParameter((c, p) => true, (c, p) => p.ResolveNamed<IDataContext>("contextNoSql"))
* .InstancePerLifetimeScope();
*/
builder.RegisterGeneric(typeof(CollectionContext <>))
.As(typeof(ICollectionContext <>))
.WithParameter((c, p) => true, (c, p) => p.ResolveNamed <IDataContext>("contextNoSql"))
.InstancePerDependency();
builder.RegisterGeneric(typeof(BaseRepository <>))
.As(typeof(IBaseRepository <>))
.WithParameter((c, p) => true, (c, p) => p.ResolveNamed <IDataContext>("contextNoSql"))
.InstancePerDependency();
builder.RegisterGeneric(typeof(CustomBaseRepository <>))
.As(typeof(ICustomBaseRepository <>))
.WithParameter((c, p) => true, (c, p) => p.ResolveNamed <IDataContext>("contextNoSql"))
.InstancePerDependency();
}
static B()
{
BsonSerializer.RegisterSerializer(typeof(IX), BsonClassMapSerializer.Instance);
}
static void AddSerializer <TType>() where TType : IMessage, new()
{
BsonSerializer.RegisterSerializer(typeof(TType),
new ProtoBsonSerializer <TType>());
}
static DatabaseProvider()
{
BsonSerializer.RegisterSerializer(typeof(Document), new JsonSerializerAdapter <Document>());
}
static InstantSerializerTests()
{
BsonSerializer.RegisterSerializer(new InstantSerializer());
}
private void MongoDBSettingHandler()
{
DateTimeSerializer dateTimeSerializer = new DateTimeSerializer(DateTimeKind.Local, BsonType.DateTime);
BsonSerializer.RegisterSerializer(typeof(DateTime), dateTimeSerializer);
}
/// <summary>The method called by the runtime to add services to the container.</summary>
/// <param name="services">The service injection container.</param>
public void ConfigureServices(IServiceCollection services)
{
// init basic services
services
.Configure <ApiClientsConfig>(this.Configuration.GetSection("ApiClients"))
.Configure <BackgroundServicesConfig>(this.Configuration.GetSection("BackgroundServices"))
.Configure <ModCompatibilityListConfig>(this.Configuration.GetSection("ModCompatibilityList"))
.Configure <ModUpdateCheckConfig>(this.Configuration.GetSection("ModUpdateCheck"))
.Configure <MongoDbConfig>(this.Configuration.GetSection("MongoDB"))
.Configure <SiteConfig>(this.Configuration.GetSection("Site"))
.Configure <RouteOptions>(options => options.ConstraintMap.Add("semanticVersion", typeof(VersionConstraint)))
.AddLogging()
.AddMemoryCache()
.AddMvc()
.ConfigureApplicationPartManager(manager => manager.FeatureProviders.Add(new InternalControllerFeatureProvider()))
.AddJsonOptions(options =>
{
foreach (JsonConverter converter in new JsonHelper().JsonSettings.Converters)
{
options.SerializerSettings.Converters.Add(converter);
}
options.SerializerSettings.Formatting = Formatting.Indented;
options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore;
});
MongoDbConfig mongoConfig = this.Configuration.GetSection("MongoDB").Get <MongoDbConfig>();
// init background service
{
BackgroundServicesConfig config = this.Configuration.GetSection("BackgroundServices").Get <BackgroundServicesConfig>();
if (config.Enabled)
{
services.AddHostedService <BackgroundService>();
}
}
// init MongoDB
services.AddSingleton <MongoDbRunner>(serv => !mongoConfig.IsConfigured()
? MongoDbRunner.Start()
: throw new InvalidOperationException("The MongoDB connection is configured, so the local development version should not be used.")
);
services.AddSingleton <IMongoDatabase>(serv =>
{
// get connection string
string connectionString = mongoConfig.IsConfigured()
? mongoConfig.ConnectionString
: serv.GetRequiredService <MongoDbRunner>().ConnectionString;
// get client
BsonSerializer.RegisterSerializer(new UtcDateTimeOffsetSerializer());
return(new MongoClient(connectionString).GetDatabase(mongoConfig.Database));
});
services.AddSingleton <IModCacheRepository>(serv => new ModCacheRepository(serv.GetRequiredService <IMongoDatabase>()));
services.AddSingleton <IWikiCacheRepository>(serv => new WikiCacheRepository(serv.GetRequiredService <IMongoDatabase>()));
// init Hangfire
services
.AddHangfire(config =>
{
config
.SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
.UseSimpleAssemblyNameTypeSerializer()
.UseRecommendedSerializerSettings();
if (mongoConfig.IsConfigured())
{
config.UseMongoStorage(mongoConfig.ConnectionString, $"{mongoConfig.Database}-hangfire", new MongoStorageOptions
{
MigrationOptions = new MongoMigrationOptions(MongoMigrationStrategy.Drop),
CheckConnection = false // error on startup takes down entire process
});
}
else
{
config.UseMemoryStorage();
}
});
// init API clients
{
ApiClientsConfig api = this.Configuration.GetSection("ApiClients").Get <ApiClientsConfig>();
string version = this.GetType().Assembly.GetName().Version.ToString(3);
string userAgent = string.Format(api.UserAgent, version);
services.AddSingleton <IChucklefishClient>(new ChucklefishClient(
userAgent: userAgent,
baseUrl: api.ChucklefishBaseUrl,
modPageUrlFormat: api.ChucklefishModPageUrlFormat
));
services.AddSingleton <ICurseForgeClient>(new CurseForgeClient(
userAgent: userAgent,
apiUrl: api.CurseForgeBaseUrl
));
services.AddSingleton <IGitHubClient>(new GitHubClient(
baseUrl: api.GitHubBaseUrl,
userAgent: userAgent,
acceptHeader: api.GitHubAcceptHeader,
username: api.GitHubUsername,
password: api.GitHubPassword
));
services.AddSingleton <IModDropClient>(new ModDropClient(
userAgent: userAgent,
apiUrl: api.ModDropApiUrl,
modUrlFormat: api.ModDropModPageUrl
));
services.AddSingleton <INexusClient>(new NexusClient(
webUserAgent: userAgent,
webBaseUrl: api.NexusBaseUrl,
webModUrlFormat: api.NexusModUrlFormat,
webModScrapeUrlFormat: api.NexusModScrapeUrlFormat,
apiAppVersion: version,
apiKey: api.NexusApiKey
));
services.AddSingleton <IPastebinClient>(new PastebinClient(
baseUrl: api.PastebinBaseUrl,
userAgent: userAgent
));
}
// init helpers
services
.AddSingleton <IGzipHelper>(new GzipHelper())
.AddSingleton <IStorageProvider>(serv => new StorageProvider(
serv.GetRequiredService <IOptions <ApiClientsConfig> >(),
serv.GetRequiredService <IPastebinClient>(),
serv.GetRequiredService <IGzipHelper>()
));
}
/// <summary>The method called by the runtime to add services to the container.</summary>
/// <param name="services">The service injection container.</param>
public void ConfigureServices(IServiceCollection services)
{
// init basic services
services
.Configure <ApiClientsConfig>(this.Configuration.GetSection("ApiClients"))
.Configure <BackgroundServicesConfig>(this.Configuration.GetSection("BackgroundServices"))
.Configure <ModCompatibilityListConfig>(this.Configuration.GetSection("ModCompatibilityList"))
.Configure <ModUpdateCheckConfig>(this.Configuration.GetSection("ModUpdateCheck"))
.Configure <StorageConfig>(this.Configuration.GetSection("Storage"))
.Configure <SiteConfig>(this.Configuration.GetSection("Site"))
.Configure <RouteOptions>(options => options.ConstraintMap.Add("semanticVersion", typeof(VersionConstraint)))
.AddLogging()
.AddMemoryCache();
StorageConfig storageConfig = this.Configuration.GetSection("Storage").Get <StorageConfig>();
StorageMode storageMode = storageConfig.Mode;
// init MVC
services
.AddControllers()
.AddNewtonsoftJson(options => this.ConfigureJsonNet(options.SerializerSettings))
.ConfigureApplicationPartManager(manager => manager.FeatureProviders.Add(new InternalControllerFeatureProvider()));
services
.AddRazorPages();
// init storage
switch (storageMode)
{
case StorageMode.InMemory:
services.AddSingleton <IModCacheRepository>(new ModCacheMemoryRepository());
services.AddSingleton <IWikiCacheRepository>(new WikiCacheMemoryRepository());
break;
case StorageMode.Mongo:
case StorageMode.MongoInMemory:
{
// local MongoDB instance
services.AddSingleton <MongoDbRunner>(_ => storageMode == StorageMode.MongoInMemory
? MongoDbRunner.Start()
: throw new NotSupportedException($"The in-memory MongoDB runner isn't available in storage mode {storageMode}.")
);
// MongoDB
services.AddSingleton <IMongoDatabase>(serv =>
{
BsonSerializer.RegisterSerializer(new UtcDateTimeOffsetSerializer());
return(new MongoClient(this.GetMongoDbConnectionString(serv, storageConfig))
.GetDatabase(storageConfig.Database));
});
// repositories
services.AddSingleton <IModCacheRepository>(serv => new ModCacheMongoRepository(serv.GetRequiredService <IMongoDatabase>()));
services.AddSingleton <IWikiCacheRepository>(serv => new WikiCacheMongoRepository(serv.GetRequiredService <IMongoDatabase>()));
}
break;
default:
throw new NotSupportedException($"Unhandled storage mode '{storageMode}'.");
}
// init Hangfire
services
.AddHangfire((serv, config) =>
{
config
.SetDataCompatibilityLevel(CompatibilityLevel.Version_170)
.UseSimpleAssemblyNameTypeSerializer()
.UseRecommendedSerializerSettings();
switch (storageMode)
{
case StorageMode.InMemory:
config.UseMemoryStorage();
break;
case StorageMode.MongoInMemory:
case StorageMode.Mongo:
string connectionString = this.GetMongoDbConnectionString(serv, storageConfig);
config.UseMongoStorage(MongoClientSettings.FromConnectionString(connectionString), $"{storageConfig.Database}-hangfire", new MongoStorageOptions
{
MigrationOptions = new MongoMigrationOptions(MongoMigrationStrategy.Drop),
CheckConnection = false // error on startup takes down entire process
});
break;
}
});
// init background service
{
BackgroundServicesConfig config = this.Configuration.GetSection("BackgroundServices").Get <BackgroundServicesConfig>();
if (config.Enabled)
{
services.AddHostedService <BackgroundService>();
}
}
// init API clients
{
ApiClientsConfig api = this.Configuration.GetSection("ApiClients").Get <ApiClientsConfig>();
string version = this.GetType().Assembly.GetName().Version.ToString(3);
string userAgent = string.Format(api.UserAgent, version);
services.AddSingleton <IChucklefishClient>(new ChucklefishClient(
userAgent: userAgent,
baseUrl: api.ChucklefishBaseUrl,
modPageUrlFormat: api.ChucklefishModPageUrlFormat
));
services.AddSingleton <ICurseForgeClient>(new CurseForgeClient(
userAgent: userAgent,
apiUrl: api.CurseForgeBaseUrl
));
services.AddSingleton <IGitHubClient>(new GitHubClient(
baseUrl: api.GitHubBaseUrl,
userAgent: userAgent,
acceptHeader: api.GitHubAcceptHeader,
username: api.GitHubUsername,
password: api.GitHubPassword
));
services.AddSingleton <IModDropClient>(new ModDropClient(
userAgent: userAgent,
apiUrl: api.ModDropApiUrl,
modUrlFormat: api.ModDropModPageUrl
));
services.AddSingleton <INexusClient>(new NexusClient(
webUserAgent: userAgent,
webBaseUrl: api.NexusBaseUrl,
webModUrlFormat: api.NexusModUrlFormat,
webModScrapeUrlFormat: api.NexusModScrapeUrlFormat,
apiAppVersion: version,
apiKey: api.NexusApiKey
));
services.AddSingleton <IPastebinClient>(new PastebinClient(
baseUrl: api.PastebinBaseUrl,
userAgent: userAgent
));
}
// init helpers
services
.AddSingleton <IGzipHelper>(new GzipHelper())
.AddSingleton <IStorageProvider>(serv => new StorageProvider(
serv.GetRequiredService <IOptions <ApiClientsConfig> >(),
serv.GetRequiredService <IPastebinClient>(),
serv.GetRequiredService <IGzipHelper>()
));
}
static MigrationRunner()
{
BsonSerializer.RegisterSerializer(typeof(MigrationVersion), new MigrationVersionSerializer());
}
static Startup()
{
BsonSerializer.RegisterSerializer(new JTokenBsonSerializer());
BsonSerializer.RegisterSerializer(new EnumSerializer <PermissionType>(BsonType.String));
}
public void Provide(IBindingProviderBuilder builder)
{
builder.Bind <IKeyMaterialService>().To <PortalKeyMaterialService>();
BsonSerializer.RegisterSerializer(new RsaSecurityKeySerializer());
}
private static void InitClassMap()
{
BsonSerializer.RegisterSerializer(DateTimeSerializer.LocalInstance);
if (!BsonClassMap.IsClassMapRegistered(typeof(BootstrapDict)))
{
BsonClassMap.RegisterClassMap <BootstrapDict>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.User)))
{
BsonClassMap.RegisterClassMap <DataAccess.User>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
md.UnmapMember(user => user.Checked);
md.UnmapMember(user => user.Period);
md.UnmapMember(user => user.NewPassword);
md.UnmapMember(user => user.UserStatus);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(BootstrapMenu)))
{
BsonClassMap.RegisterClassMap <BootstrapMenu>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
md.UnmapMember(m => m.CategoryName);
md.UnmapMember(m => m.Active);
md.UnmapMember(m => m.ParentName);
md.UnmapMember(m => m.Menus);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.Group)))
{
BsonClassMap.RegisterClassMap <DataAccess.Group>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
md.UnmapMember(group => group.Checked);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.Role)))
{
BsonClassMap.RegisterClassMap <DataAccess.Role>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
md.UnmapMember(role => role.Checked);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.Exceptions)))
{
BsonClassMap.RegisterClassMap <DataAccess.Exceptions>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
md.UnmapMember(ex => ex.Period);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.Log)))
{
BsonClassMap.RegisterClassMap <DataAccess.Log>(md =>
{
md.AutoMap();
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.Trace)))
{
BsonClassMap.RegisterClassMap <DataAccess.Trace>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
md.AddKnownType(typeof(DataAccess.Log));
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.LoginUser)))
{
BsonClassMap.RegisterClassMap <DataAccess.LoginUser>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.ResetUser)))
{
BsonClassMap.RegisterClassMap <DataAccess.ResetUser>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(RejectUser)))
{
BsonClassMap.RegisterClassMap <RejectUser>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.Message)))
{
BsonClassMap.RegisterClassMap <DataAccess.Message>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
md.UnmapMember(t => t.LabelName);
md.UnmapMember(t => t.Period);
md.UnmapMember(t => t.FromIcon);
md.UnmapMember(t => t.FromDisplayName);
});
}
if (!BsonClassMap.IsClassMapRegistered(typeof(DataAccess.Task)))
{
BsonClassMap.RegisterClassMap <DataAccess.Task>(md =>
{
md.AutoMap();
md.IdMemberMap.SetSerializer(new StringSerializer(BsonType.ObjectId));
md.IdMemberMap.SetIgnoreIfDefault(true);
md.UnmapMember(t => t.AssignDisplayName);
});
}
}
public void ConfigureServices(IServiceCollection services)
{
services.AddControllers();
#region MongoDB
var conventionPack = new ConventionPack
{
new CamelCaseElementNameConvention()
};
ConventionRegistry.Register(
"camelCase",
conventionPack,
t => true
);
//BsonClassMap.RegisterClassMap<SRecipe>(
// x => new RecipeMapper().SetupBsonMapping(x)
//);
BsonClassMap.RegisterClassMap <JsonLdObject>(
x => new JsonLdObjectMapper().SetupBsonMapping(x)
);
BsonClassMap.RegisterClassMap <Thing>(
x => new ThingMapper().SetupBsonMapping(x)
);
BsonSerializer.RegisterSerializationProvider(
new ValuesSerializerProvider()
);
BsonSerializer.RegisterGenericSerializerDefinition(
typeof(OneOrMany <>),
typeof(OneOrManySerializer <>)
);
MongoDbHelper.Default
.MapInterfaceToDefaultImplementation <IAggregateRating>()
.MapInterfaceToDefaultImplementation <IClaimReview>()
.MapInterfaceToDefaultImplementation <IClip>()
.MapInterfaceToDefaultImplementation <ICreativeWork>()
.MapInterfaceToDefaultImplementation <IDemand>()
.MapInterfaceToDefaultImplementation <IHowTo>()
.MapInterfaceToDefaultImplementation <IHowToSection>()
.MapInterfaceToDefaultImplementation <IHowToDirection>()
.MapInterfaceToDefaultImplementation <IHowToItem>()
.MapInterfaceToDefaultImplementation <IHowToStep>()
.MapInterfaceToDefaultImplementation <IHowToSupply>()
.MapInterfaceToDefaultImplementation <IHowToTip>()
.MapInterfaceToDefaultImplementation <IHowToTool>()
.MapInterfaceToDefaultImplementation <IIntangible>()
.MapInterfaceToDefaultImplementation <IImageGallery>()
.MapInterfaceToDefaultImplementation <IImageObject>()
.MapInterfaceToDefaultImplementation <IItemList>()
.MapInterfaceToDefaultImplementation <IMonetaryAmount>()
.MapInterfaceToDefaultImplementation <INutritionInformation>()
.MapInterfaceToDefaultImplementation <IOrganization>()
.MapInterfaceToDefaultImplementation <IPerson>()
.MapInterfaceToDefaultImplementation <IPublicationEvent>()
.MapInterfaceToDefaultImplementation <IQuantitativeValue>()
.MapInterfaceToDefaultImplementation <IRating>()
.MapInterfaceToDefaultImplementation <IRecipe>()
.MapInterfaceToDefaultImplementation <IReview>()
.MapInterfaceToDefaultImplementation <IReviewAction>()
.MapInterfaceToDefaultImplementation <IStructuredValue>()
.MapInterfaceToDefaultImplementation <IThing, Thing>(x => x.Name)
.MapInterfaceToDefaultImplementation <IVideoObject>();
//BsonSerializer.RegisterSerializer(
// typeof(IThing),
// new ThingSerializer()
//);
BsonSerializer.RegisterSerializer(
typeof(TimeSpan),
new TimeSpanSerializer()
);
BsonSerializer.RegisterSerializer(
typeof(JsonLdContext),
new JsonLdContextSerializer()
);
BsonSerializer.RegisterGenericSerializerDefinition(
typeof(Values <,>),
typeof(ValuesSerializer <,>)
);
BsonSerializer.RegisterGenericSerializerDefinition(
typeof(Values <, ,>),
typeof(ValuesSerializer <, ,>)
);
BsonSerializer.RegisterGenericSerializerDefinition(
typeof(Values <, , ,>),
typeof(ValuesSerializer <, , ,>)
);
BsonSerializer.RegisterGenericSerializerDefinition(
typeof(Values <, , , , , ,>),
typeof(ValuesSerializer <, , , , , ,>)
);
//BsonSerializer.RegisterDiscriminatorConvention(
// typeof(Values<,>),
// new SchemaValuesConvention()
//);
//BsonSerializer.RegisterDiscriminatorConvention(
// typeof(Values<,,>),
// new SchemaValuesConvention()
//);
//BsonSerializer.RegisterDiscriminatorConvention(
// typeof(Values<,,,>),
// new SchemaValuesConvention()
//);
//BsonSerializer.RegisterDiscriminatorConvention(
// typeof(Values<,,,,,,>),
// new SchemaValuesConvention()
//);
services
.AddMongoDb(
Configuration.GetConnectionString("RecipeDb"),
Configuration.GetValue <string>("DatabaseName")
);
#endregion
//services.AddGraphQL(
// sp =>
// {
// var schema = SchemaBuilder.New()
// //.EnableRelaySupport()
// .AddType<ThingTypeDescriptor>()
// .AddServices(sp)
// //.AddObjectType<OneOrManyTypeDescriptor>()
// //.Use(next => context =>
// //{
// // return Task.CompletedTask;
// //})
// //.AddObjectType<ThingTypeDescriptor>()
// .AddObjectType<SchemaOrgTypeDescriptor<SRecipe>>()
// //.AddObjectType<RecipeTypeDescriptor>()
// .AddQueryType(d => d.Name(QueryConstants.QueryTypeName))
// //.AddType<RecipeQueryType>()
// .AddType<HelloWorldQueryType>()
// .Create();
// return schema;
// }
//);
}
static MongoDbAdapter()
{
BsonSerializer.RegisterSerializer(new VoucherSerializer());
BsonSerializer.RegisterSerializer(new VoucherDetailSerializer());
BsonSerializer.RegisterSerializer(new AssetSerializer());
BsonSerializer.RegisterSerializer(new AssetItemSerializer());
BsonSerializer.RegisterSerializer(new AmortizationSerializer());
BsonSerializer.RegisterSerializer(new AmortItemSerializer());
BsonSerializer.RegisterSerializer(new BalanceSerializer());
BsonSerializer.RegisterSerializer(new ExchangeSerializer());
BsonDocument MakeProject(BsonValue days, bool detail)
{
var proj = new BsonDocument
{
["_id"] = false,
["date"] = new BsonDocument
{
["$switch"] = new BsonDocument
{
["branches"] = new BsonArray
{
new BsonDocument
{
["case"] = new BsonDocument
{
["$eq"] = new BsonArray
{
new BsonDocument
{
["$type"] = "$date",
},
"missing",
},
},
["then"] = BsonNull.Value,
},
},
["default"] = new BsonDocument
{
["$subtract"] =
new BsonArray
{
"$date",
new BsonDocument
{
["$multiply"] =
new BsonArray {
days, 24 * 60 * 60 * 1000
},
},
},
},
},
},
};
if (detail)
{
proj["detail"] = true;
}
return(proj);
}
var year = new BsonDocument
{
["$subtract"] = new BsonArray {
new BsonDocument {
["$dayOfYear"] = "$date"
}, 1
},
};
var month = new BsonDocument
{
["$subtract"] = new BsonArray {
new BsonDocument {
["$dayOfMonth"] = "$date"
}, 1
},
};
var week = new BsonDocument
{
["$mod"] = new BsonArray
{
new BsonDocument
{
["$add"] = new BsonArray
{
new BsonDocument {
["$dayOfWeek"] = "$date"
}, 5,
},
},
7,
},
};
ProjectYear = MakeProject(year, true);
ProjectMonth = MakeProject(month, true);
ProjectWeek = MakeProject(week, true);
ProjectNothingButYear = MakeProject(year, false);
ProjectNothingButMonth = MakeProject(month, false);
ProjectNothingButWeek = MakeProject(week, false);
}
public static IKernel WithMongoEventsProvider(this IKernel kernel, string url, string database, string collection)
{
BsonSerializer.RegisterSerializer(typeof(decimal), new DecimalSerializer(BsonType.Decimal128));
BsonSerializer.RegisterSerializer(typeof(decimal?), new NullableSerializer <decimal>(new DecimalSerializer(BsonType.Decimal128)));
return(kernel.WithModule(new MongoEventsProviderModule(url, database, collection)));
}
/// <summary>
/// Set database initializer
/// </summary>
public virtual void SetDatabaseInitializer()
{
//BsonSerializer.RegisterSerializer<decimal>(new DecimalSerializer().WithRepresentation(BsonType.Double));
BsonSerializer.RegisterSerializer(typeof(DateTime),
new DateTimeSerializer(DateTimeKind.Utc));
}
public void Configuration(IAppBuilder Builder)
{
ConfigureOAuth(Builder);
var Configuration = new HttpConfiguration();
var HTTPServer = new HttpServer(Configuration);
#region Custom Routing and WebAPI versionong
Builder.UseWebApi(Configuration);
// reporting api versions will return the headers "api-supported-versions" and "api-deprecated-versions"
Configuration.AddApiVersioning(O => O.ReportApiVersions = true);
Configuration.Routes.MapHttpRoute(
"VersionedUrl",
"api/{namespace}/{application}/v{apiVersion}/{module}/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional },
constraints: new { apiVersion = new ApiVersionRouteConstraint() });
Configuration.Routes.MapHttpRoute(
"DefaultApi",
"api/{namespace}/{application}/v{apiVersion}/{module}/{controller}/{id}",
defaults: new { id = RouteParameter.Optional },
constraints: new { apiVersion = new ApiVersionRouteConstraint() });
Configuration.Routes.MapHttpRoute(
"VersionedNoAppUrl",
"api/{namespace}/v{apiVersion}/{module}/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional },
constraints: new { apiVersion = new ApiVersionRouteConstraint() });
Configuration.Routes.MapHttpRoute(
"DefaultApiNoApp",
"api/{namespace}/v{apiVersion}/{module}/{controller}/{id}",
defaults: new { id = RouteParameter.Optional },
constraints: new { apiVersion = new ApiVersionRouteConstraint() });
Configuration.Routes.MapHttpRoute(
"VersionedQueryString",
"api/{namespace}/{application}/{module}/{controller}/{id}",
defaults: new { id = RouteParameter.Optional });
Configuration.Routes.MapHttpRoute(
"VersionedQueryStringWithAction",
"api/{namespace}/{application}/{module}/{controller}/{action}/{id}",
defaults: new { id = RouteParameter.Optional });
Configuration.Services.Replace(typeof(IHttpControllerSelector), new NamespaceHttpControllerSelector(Configuration));
#endregion
#region Register DBContext, Service, Repository To Unity
var Container = new UnityContainer();
Container.RegisterType <RecDBMSSQLIDBFactory, RecDBMSSQLDBFactory>(new HierarchicalLifetimeManager());
//Container.RegisterType<BookDBMongoDBIDBFactory, BookDBMongoDBDBFactory>(new HierarchicalLifetimeManager());
//Container.RegisterType<BookDBOracleIDBFactory, BookDBOracleDBFactory>(new HierarchicalLifetimeManager());
Container.RegisterTypes(
AllClasses.FromAssemblies(typeof(RecDBRepository).Assembly)
.Where(t => t.Name.EndsWith("Repository")),
WithMappings.FromAllInterfaces);
// Container.RegisterType<IRolesRepository, RolesRepository>(new InjectionConstructor("DeveloperCompetencyDBEntities"));
Container.RegisterTypes(
AllClasses.FromAssemblies(typeof(RecDBService).Assembly)
.Where(t => t.Name.EndsWith("Service")),
WithMappings.FromAllInterfaces);
Configuration.DependencyResolver = new UnityResolver(Container);
#endregion
//MongoDB Datetime Converter
BsonSerializer.RegisterSerializer(typeof(DateTime), DateTimeSerializer.UtcInstance);
//Allow Cross Domain Access
Builder.UseCors(Microsoft.Owin.Cors.CorsOptions.AllowAll);
Builder.UseWebApi(HTTPServer);
}
static EventSubscriptions()
{
BsonSerializer.RegisterSerializer(typeof(MethodInfo), new MethodInfoSerializer());
BsonSerializer.RegisterSerializer(typeof(Type), new TypeSerializer());
BsonSerializer.RegisterSerializationProvider(new BsonSerializationProvider());
}
static OffsetDateTimeSerializerTests()
{
BsonSerializer.RegisterSerializer(new OffsetDateTimeSerializer());
}
public static void Init()
{
BsonSerializer.RegisterSerializer(new EnumSerializer <NumericType>(BsonType.String));
}
public BaseMongoRepository()
{
this.MongoDbHandler = new MongoDbHandler <TEntity>();
BsonSerializer.RegisterSerializer(typeof(DateTime), new DateTimeSerializer(DateTimeKind.Local));
}
private void RegisterConventions()
{
BsonSerializer.RegisterSerializer(typeof(decimal), new DecimalSerializer(BsonType.Decimal128));
BsonSerializer.RegisterSerializer(typeof(decimal?), new NullableSerializer <decimal>(new DecimalSerializer(BsonType.Decimal128)));
ConventionRegistry.Register("Conventions", new MongoDbConventions(), x => true);
}
public static void Init()
{
BsonSerializer.RegisterSerializer(typeof(MigrationVersion), new MigrationVersionSerializer());
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddCors();
services.AddScoped <IMessage, Message>();
var builder = services.BuildServiceProvider();
AppSetting appSettings = new AppSetting((IMessage)builder.GetRequiredService(typeof(IMessage)));
var appSettingsSection = Configuration.GetSection("Settings");
appSettingsSection.Bind(appSettings);
services.AddSingleton <MongoDBClient>(new MongoDBClient(appSettings.DBEndpoint, appSettings.DBName));
services.AddSingleton <ISetting>(appSettings);
BsonSerializer.RegisterSerializer(typeof(DateTime), DateTimeSerializer.LocalInstance);
// jwt token authorize
services.AddAuthentication(x =>
{
x.DefaultAuthenticateScheme = JwtBearerDefaults.AuthenticationScheme;
x.DefaultChallengeScheme = JwtBearerDefaults.AuthenticationScheme;
})
.AddJwtBearer(x =>
{
x.RequireHttpsMetadata = false;
x.SaveToken = true;
x.TokenValidationParameters = new TokenValidationParameters
{
ValidateIssuerSigningKey = true,
IssuerSigningKey = new SymmetricSecurityKey(Encoding.ASCII.GetBytes(appSettings.ApplicationToken)),
ValidateIssuer = false,
ValidateAudience = false,
ClockSkew = TimeSpan.Zero
};
});
services.AddControllers()
.AddNewtonsoftJson(options => options.SerializerSettings.ContractResolver = new DefaultContractResolver());
/// Add collections
services.AddSingleton <IUserCollection, MongoUserCollection>();
services.AddSingleton <IDeptReminderCollection, MongoDeptReminderCollection>();
services.AddSingleton <ITransferCollection, MongoTransferCollection>();
services.AddSingleton <ITransactionCollection, MongoTransactionCollection>();
services.AddSingleton <ILinkingBankCollection, MongoLinkingBankCollection>();
///
/// Add services
services.AddSingleton <IContext, Context>();
services.AddSingleton <IEmployeeService, EmployeeService>();
services.AddSingleton <IUserService, UserService>();
services.AddSingleton <IAccountService, AccountService>();
services.AddSingleton <IDeptReminderService, DeptReminderService>();
services.AddSingleton <ILinkingBankService, LinkingBankService>();
services.AddTransient <IExternalBanking, ExternalBanking_BKTBank>();
///
services.AddTransient <IEncrypt, Encrypt>();
}
