public MongoQueryContextFactory(
QueryContextDependencies dependencies,
IMongoConnection cosmosClient)
{
_dependencies = dependencies;
_mongoClient = cosmosClient;
}
public MongoQueryContext(
QueryContextDependencies dependencies,
IMongoConnection cosmosClient)
: base(dependencies)
{
MongoClient = cosmosClient;
}
public PhoneBookService(IMongoConnection settings)
{
var client = new MongoClient(settings.ConnectionString);
var database = client.GetDatabase(settings.DatabaseName);
_person = database.GetCollection <Person>(settings.Name);
}
public GameContext(IMongoConnection connection)
: base(connection)
{
Characters = InitializeRepository <Character>();
Rosters = InitializeRepository <Roster>();
GameInfo = InitializeRepository <GameInfo>();
}
public MigrationExecutor(IPictureFetchingService pictureFetchingService, IPhotoWriteRepository photoWriteRepository, IPhotoRepository photoRepository, IMongoConnection mongoConnection)
{
_pictureFetchingService = pictureFetchingService;
_photoWriteRepository = photoWriteRepository;
_photoRepository = photoRepository;
_mongoConnection = mongoConnection;
}
private void Create(IMongoConnection mongoConn)
{
var url = new MongoUrl(mongoConn.DDDMongoStore());
this._client = new MongoClient(url.Url);
this._database = this._client.GetDatabase(url.DatabaseName);
}
public ConvertMongoToLcmComments(IMongoConnection conn, ILfProject proj, ILogger logger, IProgress progress)
{
_conn = conn;
_project = proj;
_logger = logger;
_progress = progress;
}
public LobbyService(IMongoConnection settings)
{
var client = new MongoClient(settings.ConnectionString);
var database = client.GetDatabase(settings.Database);
_lobby = database.GetCollection <Lobby>("lobby");
}
public CardService(IMongoConnection settings)
{
var client = new MongoClient(settings.ConnectionString);
var database = client.GetDatabase(settings.Database);
_cards = database.GetCollection <Card>("cards.collectible.uldum");
}
public MongoMentionConfigStore(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions,
ILogger <MongoMentionConfigStore> logger, IMentionConfigCache cache)
: base(databaseConnection, databaseOptions)
{
this._log = logger;
this._cache = cache;
this.OnMongoClientChanged(base.MongoConnection.Client);
}
public MongoBatchingRepositoryBase(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions, IHostApplicationLifetime hostLifetime, ILogger log)
{
this.DatabaseOptions = databaseOptions;
this.MongoConnection = databaseConnection;
this._log = log;
this._hostStoppingRegistration = hostLifetime.ApplicationStopping.Register(this.FlushBatch);
}
public MongoConfig(IMongoConnection mongoConfig)
{
Username = mongoConfig.Username;
Password = mongoConfig.Password;
AuthDatabase = mongoConfig.AuthDatabase;
Host = mongoConfig.Host;
Port = mongoConfig.Port;
}
public ConvertLcmToMongoComments(IMongoConnection conn, ILfProject proj, ILogger logger, IProgress progress, MongoProjectRecordFactory factory)
{
_conn = conn;
_project = proj;
_servLoc = proj.FieldWorksProject.ServiceLocator;
_logger = logger;
_progress = progress;
_factory = factory;
}
public MongoProjectRecordFactoryDouble(IMongoConnection connection) : base(connection)
{
_projectRecords = new Dictionary <string, MongoProjectRecord>();
var testDouble = connection as MongoConnectionDouble;
if (testDouble != null)
{
testDouble.RegisterProjectRecordFactory(this);
}
}
public MongoCommunityGoalsHistoryStore(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions, IHostApplicationLifetime hostLifetime, ILogger <MongoCommunityGoalsHistoryStore> log, IEntityCache <int, CommunityGoal> cgCache, IOptionsMonitor <CachingOptions> cachingOptions)
: base(databaseConnection, databaseOptions, hostLifetime, log)
{
this._cgCache = cgCache;
this._log = log;
this._cachingOptions = cachingOptions;
base.MongoConnection.ClientChanged += OnClientChanged;
OnClientChanged(base.MongoConnection.Client);
}
public MongoUserDataStore(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions, IHostApplicationLifetime hostLifetime, ILogger <MongoUserDataStore> log, IEntityCache <ulong, UserData> userDataCache, IOptionsMonitor <CachingOptions> cachingOptions)
: base(databaseConnection, databaseOptions, hostLifetime, log)
{
this._userDataCache = userDataCache;
this._log = log;
this._cachingOptions = cachingOptions;
base.MongoConnection.ClientChanged += OnClientChanged;
OnClientChanged(base.MongoConnection.Client);
}
public MongoPatchbotGameStore(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions, IHostApplicationLifetime hostLifetime, ILogger <MongoPatchbotGameStore> log, IEntityCache <string, PatchbotGame> patchbotGameCache, IOptionsMonitor <CachingOptions> cachingOptions)
: base(databaseConnection, databaseOptions, hostLifetime, log)
{
this._patchbotGameCache = patchbotGameCache;
this._log = log;
this._cachingOptions = cachingOptions;
base.MongoConnection.ClientChanged += OnClientChanged;
OnClientChanged(base.MongoConnection.Client);
}
private void ConfigureClient(IMongoConnection mongoConfig)
{
_mongoCredential = MongoCredential.CreateCredential(mongoConfig.AuthDatabase, mongoConfig.Username, mongoConfig.Password);
_mongoClientSettings = new MongoClientSettings {
Credential = _mongoCredential
};
_mongoServerAddress = new MongoServerAddress(mongoConfig.Host, mongoConfig.Port);
_mongoClientSettings.Server = _mongoServerAddress;
MongoClient = new MongoClient(_mongoClientSettings);
}
public MongoStellarisModsStore(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions, IOptionsMonitor <CachingOptions> cachingOptions, ILogger <MongoStellarisModsStore> log, IEntityCache <ObjectId, StellarisMod> stellarisModsCache)
{
this._databaseConnection = databaseConnection;
this._databaseOptions = databaseOptions;
this._cachingOptions = cachingOptions;
this._log = log;
this._stellarisModsCache = stellarisModsCache;
this._databaseConnection.ClientChanged += OnClientChanged;
}
public ServiceBase(IMongoConnection connection)
{
var client = new MongoClient(string.Format(connection.ConnectionString,
connection.UserName,
connection.PassWord,
connection.Database));
var database = client.GetDatabase(connection.Database);
_itens = database.GetCollection <T>(CollectionName);
}
public MongoGameServerStore(IMongoConnection databaseConnection, ILogger <MongoGameServerStore> log, IEntityCache <string, GameServer> cache,
IOptionsMonitor <DatabaseOptions> databaseOptions, IOptionsMonitor <CachingOptions> cachingOptions)
{
this._databaseConnection = databaseConnection;
this._databaseOptions = databaseOptions;
this._cache = cache;
this._cachingOptions = cachingOptions;
this._log = log;
this._databaseConnection.ClientChanged += OnClientChanged;
this.OnClientChanged(this._databaseConnection.Client);
}
public MongoNetflixAccountStore(IMongoConnection databaseConnection, ILogger <MongoNetflixAccountStore> log,
IOptionsMonitor <DatabaseOptions> databaseOptions, IOptionsMonitor <CachingOptions> cachingOptions, IOptionsMonitor <NetflixAccountOptions> netflixAccountOptions)
{
this._databaseConnection = databaseConnection;
this._databaseOptions = databaseOptions;
this._cachingOptions = cachingOptions;
this._netflixAccountOptions = netflixAccountOptions;
this._log = log;
this._databaseConnection.ClientChanged += OnClientChanged;
this.OnClientChanged(this._databaseConnection.Client);
}
public ClientEventHandler(DiscordClient client, SlashCommandsExtension slash, IMongoConnection mongo)
{
this._client = client;
this._slash = slash;
this._mongo = mongo;
this._client.Ready += (_, _) =>
{
Console.WriteLine($"{this._client.CurrentUser.Username} ready.");
return(Task.CompletedTask);
};
this._slash.SlashCommandErrored += async(s, args) =>
{
if (args.Exception is SlashExecutionChecksFailedException slex)
{
foreach (var check in slex.FailedChecks)
{
switch (check)
{
case SlashRequireUserPermissionsAttribute slashRequireUserPermissionsAttribute:
var ruContent =
$"Not enough permissions. You need: {slashRequireUserPermissionsAttribute.Permissions.ToPermissionString()}";
await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
new DiscordInteractionResponseBuilder().WithContent(ruContent).AsEphemeral(true));
break;
case SlashRequireOwnerAttribute slashRequireOwnerAttribute:
var roContent =
$"You have to be a bot owner to use that command.";
await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
new DiscordInteractionResponseBuilder().WithContent(roContent).AsEphemeral(true));
break;
case SlashRequiredChannelsAttribute slashRequiredChannelsAttribute:
var rcContent =
$"You can only use this command in allowed channels, such as {String.Join(", ", slashRequiredChannelsAttribute.RequiredChannels.Select(x => $"<#{x}>"))}";
await args.Context.CreateResponseAsync(InteractionResponseType.ChannelMessageWithSource,
new DiscordInteractionResponseBuilder().WithContent(rcContent).AsEphemeral(true));
break;
}
}
}
};
}
//private ConvertFdoToMongoOptionList _convertAnthroCodesOptionList;
public ConvertFdoToMongoLexicon(ILfProject lfProject, ILogger logger, IMongoConnection connection, IProgress progress, MongoProjectRecordFactory projectRecordFactory)
{
LfProject = lfProject;
Logger = logger;
Connection = connection;
Progress = progress;
ProjectRecordFactory = projectRecordFactory;
FwProject = LfProject.FieldWorksProject;
Cache = FwProject.Cache;
ServiceLocator = FwProject.ServiceLocator;
_wsEn = ServiceLocator.WritingSystemFactory.GetWsFromStr("en");
// Reconcile writing systems from FDO and Mongo
Dictionary <string, LfInputSystemRecord> lfWsList = FdoWsToLfWs();
#if FW8_COMPAT
List <string> VernacularWss = ServiceLocator.LanguageProject.CurrentVernacularWritingSystems.Select(ws => ws.Id).ToList();
List <string> AnalysisWss = ServiceLocator.LanguageProject.CurrentAnalysisWritingSystems.Select(ws => ws.Id).ToList();
List <string> PronunciationWss = ServiceLocator.LanguageProject.CurrentPronunciationWritingSystems.Select(ws => ws.Id).ToList();
#else
List <string> VernacularWss = ServiceLocator.LanguageProject.CurrentVernacularWritingSystems.Select(ws => ws.LanguageTag).ToList();
List <string> AnalysisWss = ServiceLocator.LanguageProject.CurrentAnalysisWritingSystems.Select(ws => ws.LanguageTag).ToList();
List <string> PronunciationWss = ServiceLocator.LanguageProject.CurrentPronunciationWritingSystems.Select(ws => ws.LanguageTag).ToList();
#endif
Connection.SetInputSystems(LfProject, lfWsList, VernacularWss, AnalysisWss, PronunciationWss);
ListConverters = new Dictionary <string, ConvertFdoToMongoOptionList>();
ListConverters[GrammarListCode] = ConvertOptionListFromFdo(LfProject, GrammarListCode, ServiceLocator.LanguageProject.PartsOfSpeechOA);
ListConverters[SemDomListCode] = ConvertOptionListFromFdo(LfProject, SemDomListCode, ServiceLocator.LanguageProject.SemanticDomainListOA, updateMongoList: false);
ListConverters[AcademicDomainListCode] = ConvertOptionListFromFdo(LfProject, AcademicDomainListCode, ServiceLocator.LanguageProject.LexDbOA.DomainTypesOA);
ListConverters[LocationListCode] = ConvertOptionListFromFdo(LfProject, LocationListCode, ServiceLocator.LanguageProject.LocationsOA);
ListConverters[UsageTypeListCode] = ConvertOptionListFromFdo(LfProject, UsageTypeListCode, ServiceLocator.LanguageProject.LexDbOA.UsageTypesOA);
ListConverters[SenseTypeListCode] = ConvertOptionListFromFdo(LfProject, SenseTypeListCode, ServiceLocator.LanguageProject.LexDbOA.SenseTypesOA);
ListConverters[AnthroCodeListCode] = ConvertOptionListFromFdo(LfProject, AnthroCodeListCode, ServiceLocator.LanguageProject.AnthroListOA);
ListConverters[StatusListCode] = ConvertOptionListFromFdo(LfProject, StatusListCode, ServiceLocator.LanguageProject.StatusOA);
_convertCustomField = new ConvertFdoToMongoCustomField(Cache, ServiceLocator, logger);
foreach (KeyValuePair <string, ICmPossibilityList> pair in _convertCustomField.GetCustomFieldParentLists())
{
string listCode = pair.Key;
ICmPossibilityList parentList = pair.Value;
if (!ListConverters.ContainsKey(listCode))
{
ListConverters[listCode] = ConvertOptionListFromFdo(LfProject, listCode, parentList);
}
}
}
public MongoGroupConfigStore(IMongoConnection databaseConnection, IOptionsMonitor <DatabaseOptions> databaseOptions, IHostApplicationLifetime hostLifetime,
ILogger <MongoGroupConfigStore> logger, IGroupConfigCache cache)
: base(databaseConnection, databaseOptions)
{
this._log = logger;
this._cache = cache;
this._replaceOptions = new ReplaceOptions()
{
IsUpsert = true, BypassDocumentValidation = false
};
this.RecreateBatchInserter();
this.OnMongoClientChanged(base.MongoConnection.Client);
this._hostStoppingRegistration = hostLifetime.ApplicationStopping.Register(_batchInserter.Flush);
this._configChangeRegistration = base.DatabaseOptions.OnChange(_ => RecreateBatchInserter());
}
private static void Config()
{
if (_mongoClient != null)
{
_connectionManager = new ConnectionManager(_mongoClient);
}
else
{
IMongoConnection mongoConnection = _configService.MongoLoggerConfig.MongoConnection;
IMongoConfig mongoConfig = new MongoConfig(mongoConnection);
_connectionManager = new ConnectionManager(mongoConfig);
}
_loggerConfigs = new Dictionary <string, Tuple <string, string> >();
foreach (var logger in _configService.MongoLoggerConfig.Loggers)
{
_loggerConfigs.Add(logger.LoggerName, new Tuple <string, string>(logger.LoggerName, logger.DatabaseName));
}
}
public TransferMongoToLcmAction(LfMergeSettings settings, ILogger logger, IMongoConnection conn, MongoProjectRecordFactory factory, EntryCounts entryCounts) : base(settings, logger)
{
EntryCounts = entryCounts;
_connection = conn;
_projectRecordFactory = factory;
}
public MongoProjectRecordFactory(IMongoConnection connection)
{
Connection = connection;
}
public PersonCategoryRepository(IMongoConnection mongoConnection, IGuidGenerator guidGenerator)
{
MongoConnection = mongoConnection;
GuidGenerator = guidGenerator;
}
public NoteRepository(IMongoConnection mongoConnection)
{
_mongoConnection = mongoConnection;
_noteCollection = _mongoConnection.GetMongoDatabase().GetCollection <Note>("Notes");
}
public TransferMongoToFdoAction(LfMergeSettingsIni settings, ILogger logger, IMongoConnection conn, MongoProjectRecordFactory factory)
: base(settings, logger)
{
_connection = conn;
_projectRecordFactory = factory;
}
public MongoContext(IMongoConnection connection)
{
_client = GetClient(connection.ConnectionString);
_database = GetDatabase(connection.DatabaseName);
}
public MongoDbConnectionBehavior(IMongoConnection connection)
: base(PartialBehavior.Ignored /* do not fire this behavior during a partial */)
{
_connection = connection;
}
public TransferFdoToMongoAction(LfMergeSettingsIni settings, ILogger logger, IMongoConnection conn)
: base(settings, logger)
{
_connection = conn;
}
