private static async Task UpdateMasterGames()
{
_awsRegion = ConfigurationManager.AppSettings["awsRegion"] !;
_betaBucket = ConfigurationManager.AppSettings["betaBucket"] !;
_productionReadOnlyConnectionString = ConfigurationManager.AppSettings["productionConnectionString"] !;
_betaConnectionString = ConfigurationManager.AppSettings["betaConnectionString"] !;
DapperNodaTimeSetup.Register();
MySQLFantasyCriticUserStore productionUserStore = new MySQLFantasyCriticUserStore(_productionReadOnlyConnectionString, _clock);
MySQLFantasyCriticUserStore betaUserStore = new MySQLFantasyCriticUserStore(_betaConnectionString, _clock);
MySQLMasterGameRepo productionMasterGameRepo = new MySQLMasterGameRepo(_productionReadOnlyConnectionString, productionUserStore);
MySQLMasterGameRepo betaMasterGameRepo = new MySQLMasterGameRepo(_betaConnectionString, betaUserStore);
MySQLBetaCleaner cleaner = new MySQLBetaCleaner(_betaConnectionString);
AdminService betaAdminService = GetAdminService();
_logger.Info("Getting master games from production");
var productionMasterGameTags = await productionMasterGameRepo.GetMasterGameTags();
var productionMasterGames = await productionMasterGameRepo.GetMasterGames();
var betaMasterGameTags = await betaMasterGameRepo.GetMasterGameTags();
var betaMasterGames = await betaMasterGameRepo.GetMasterGames();
IReadOnlyList <MasterGameHasTagEntity> productionGamesHaveTagEntities = await GetProductionGamesHaveTagEntities();
await cleaner.UpdateMasterGames(productionMasterGameTags, productionMasterGames, betaMasterGameTags,
betaMasterGames, productionGamesHaveTagEntities);
await betaAdminService.RefreshCaches();
}
public RequestChangeOfSupplierTests()
{
var services = new ServiceCollection();
_connectionString =
Environment.GetEnvironmentVariable("MarketData_IntegrationTests_ConnectionString");
services.AddScoped <IDbConnectionFactory>(sp => new SqlDbConnectionFactory(_connectionString));
services.AddScoped <IUnitOfWorkCallback, UnitOfWorkCallback>();
services.AddScoped <ISystemDateTimeProvider, SystemDateTimeProviderStub>();
services.AddScoped <IEventPublisher, EventPublisherStub>();
services.AddScoped <IActorMessagePublisher, ActorMessagePublisher>();
services.AddScoped <IMeteringPointRepository, MeteringPointRepository>();
services.AddScoped <IEnergySupplierRepository, EnergySupplierRepository>();
services.AddMediatR(new[]
{
typeof(RequestChangeSupplierCommandHandler).Assembly,
});
services.AddScoped(typeof(IPipelineBehavior <,>), typeof(UnitOfWorkHandlerBehavior <,>));
services.AddScoped(typeof(IPipelineBehavior <,>), typeof(PublishIntegrationEventsHandlerBehavior <,>));
services.AddScoped <IPipelineBehavior <RequestChangeOfSupplier, RequestChangeOfSupplierResult>, PublishActorMessageHandlerBehavior>();
services.AddGreenEnergyHub(typeof(RequestChangeOfSupplier).Assembly);
DapperNodaTimeSetup.Register();
_serviceProvider = services.BuildServiceProvider();
_mediator = _serviceProvider.GetRequiredService <IMediator>();
_meteringPointRepository = _serviceProvider.GetRequiredService <IMeteringPointRepository>();
_energySupplierRepository = _serviceProvider.GetRequiredService <IEnergySupplierRepository>();
_unitOfWorkCallback = _serviceProvider.GetRequiredService <IUnitOfWorkCallback>();
_actorMessagePublisher = _serviceProvider.GetRequiredService <IActorMessagePublisher>();
}
public static IServiceCollection RegisterCommonStuff(this IServiceCollection services, IConfiguration configuration)
{
DapperNodaTimeSetup.Register();
services.AddSingleton(configuration.UrlProvider());
var serilogLogger = ContainerExtensions.Logger.get(configuration);
services.AddSingleton <Serilog.ILogger>(serilogLogger);
var loggerFactory = new LoggerFactory(); // lowTODO figure out if we need to dispose
services.AddDbContextPool <CardOverflowDb>(optionsBuilder => {
//loggerFactory.AddSerilog(serilogLogger);
optionsBuilder
//.UseLoggerFactory(loggerFactory)
//.EnableSensitiveDataLogging()
.UseSnakeCaseNamingConvention()
.UseNpgsql(configuration.GetConnectionString("DefaultConnection"), x => x.UseNodaTime());
});
services.AddSingleton <DbExecutor>();
services.AddSingleton <Func <Task <NpgsqlConnection> > >(_ => async() => {
var conn = new NpgsqlConnection(configuration.GetConnectionString("DefaultConnection"));
await conn.OpenAsync();
return(conn);
});
Log.Logger = serilogLogger;
services.AddLogging(x => x
.AddFilter("Microsoft.AspNetCore", LogLevel.Warning)
.AddFilter("Microsoft.EntityFrameworkCore", LogLevel.Warning));
return(services);
}
public VendaRepository(IDatabaseConfig config)
{
DapperNodaTimeSetup.Register();
_action = config.DbAction;
_itemVendaDataAccess = new ItemVendaDataAccess();
_tableVenda = DatabaseUtils.Table <Venda>();
_tableItemVenda = DatabaseUtils.Table <ItemVenda>();
_tableDisco = DatabaseUtils.Table <Disco>();
}
public override void Configure(IFunctionsHostBuilder builder)
{
if (builder == null)
{
throw new ArgumentNullException(nameof(builder));
}
builder.Services.AddGreenEnergyHub(typeof(RequestChangeOfSupplier).Assembly, typeof(RequestChangeSupplierCommandHandler).Assembly);
builder.Services.AddUnitOfWork("MARKET_DATA_DB_CONNECTION_STRING");
builder.Services.AddSingleton <IJsonSerializer, JsonSerializer>();
builder.Services.AddScoped <IHubRehydrator, JsonMessageDeserializer>();
builder.Services.AddScoped <IDbConnectionFactory>(serviceProvider =>
{
var configuration = serviceProvider.GetService <IConfiguration>();
var connectionString = configuration.GetValue <string>("MARKET_DATA_DB_CONNECTION_STRING");
return(new SqlDbConnectionFactory(connectionString));
});
builder.Services.AddScoped(serviceProvider =>
{
var configuration = serviceProvider.GetService <IConfiguration>();
var connectionString = configuration.GetValue <string>("POST_OFFICE_QUEUE_CONNECTION_STRING");
var topicName = configuration.GetValue <string>("POST_OFFICE_QUEUE_TOPIC_NAME");
var client = new ServiceBusClient(connectionString);
return(client.CreateSender(topicName));
});
DapperNodaTimeSetup.Register();
builder.Services.AddScoped <IUnitOfWorkCallback, UnitOfWorkCallback>();
builder.Services.AddScoped <ISystemDateTimeProvider, SystemDateTimeProvider>();
builder.Services.AddScoped <IEventPublisher, EventPublisher>();
builder.Services.AddScoped <IActorMessagePublisher, ActorMessagePublisher>();
builder.Services.AddScoped <IMeteringPointRepository, MeteringPointRepository>();
builder.Services.AddScoped <IEnergySupplierRepository, EnergySupplierRepository>();
builder.Services.AddScoped <IInternalCommandRepository, InternalCommandRepository>();
builder.Services.AddScoped <IInternalCommandService, InternalCommandService>();
builder.Services.AddScoped <IForwardMessageRepository, ForwardMessageRepository>();
builder.Services.AddScoped <IForwardMessageService, ForwardMessageService>();
builder.Services.AddScoped <IPostOfficeService, PostOfficeService>();
builder.Services.AddScoped <DomainEventsContext>();
builder.Services.AddScoped(typeof(IPipelineBehavior <,>), typeof(DomainEventPublisherBehavior <,>));
builder.Services.AddScoped(typeof(IPipelineBehavior <,>), typeof(UnitOfWorkHandlerBehavior <,>));
builder.Services.AddScoped(typeof(IPipelineBehavior <,>), typeof(PublishIntegrationEventsHandlerBehavior <,>));
builder.Services.AddScoped <IPipelineBehavior <RequestChangeOfSupplier, RequestChangeOfSupplierResult>, PublishActorMessageHandlerBehavior>();
}
/// <summary>
/// Use the SqlStateProvider as StateProvider
/// </summary>
/// <param name="host">The workerHost</param>
/// <param name="config">The config</param>
public static void UseSqlStateProvider <TFile, TMetadata, TQueryFilter>
(this WorkerHost <TFile, TMetadata, TQueryFilter> host, ISqlStateProviderConfig config)
where TFile : class, IResource <TMetadata>
where TMetadata : class, IResourceMetadata
where TQueryFilter : class, new()
{
DapperNodaTimeSetup.Register();
Dapper.SqlMapper.AddTypeMap(typeof(DateTime), DbType.DateTime2);
Dapper.SqlMapper.AddTypeMap(typeof(DateTime?), DbType.DateTime2);
host.UseStateProvider <SqlStateProvider>(r =>
{
r.Container.RegisterSingleton <IDbConnectionManager, ReliableSqlConnectionManager>();
r.Container.RegisterInstance(config);
r.OnBeforeStart += () => r.Container.GetInstance <SqlStateProvider>().EnsureTableAreCreated();
});
}
private static async Task RefreshAndCleanDatabase()
{
var productionRDSName = ConfigurationManager.AppSettings["productionRDSName"] !;
var betaRDSName = ConfigurationManager.AppSettings["betaRDSName"] !;
DapperNodaTimeSetup.Register();
RDSRefresher rdsRefresher = new RDSRefresher(productionRDSName, betaRDSName);
await rdsRefresher.CopySourceToDestination();
MySQLFantasyCriticUserStore betaUserStore = new MySQLFantasyCriticUserStore(_betaConnectionString, _clock);
MySQLBetaCleaner cleaner = new MySQLBetaCleaner(_betaConnectionString);
_logger.Info("Cleaning emails/passwords for non-beta users");
var allUsers = await betaUserStore.GetAllUsers();
var betaUsers = await betaUserStore.GetUsersInRoleAsync("BetaTester", CancellationToken.None);
await cleaner.CleanEmailsAndPasswords(allUsers, betaUsers);
}
private static void Main(string[] args)
{
DapperNodaTimeSetup.Register();
var connectionString = args[0];
var connection = new SqlConnection(connectionString);
Stuff.GetDbRetryPolicy().Execute(() => connection.Open());
var areas = connection.Query <dynamic>("select [gitlocalpath], lastchangeset from MigStatus");
foreach (var area in areas)
{
var gitlocal = (string)area.gitlocalpath;
if (!Directory.Exists(gitlocal))
{
continue;
}
var startchangeset = (int)area.lastchangeset;
var paths = connection.Query <syncpath>(
$"select gitrepolocalpath, tfslocalpath, tfspath from MigrationPaths where gitrepolocalpath like '{gitlocal}\\%'")
.ToArray();
var sqlpaths = "(\'" + string.Join("', '", paths.Select(p => p.tfspath)) + "\')";
do
{
var noCommitsToBeMerged = connection.QueryFirst <int>(
$"select count(*) from changesets where changesetid > {startchangeset} and TfsPath in {sqlpaths}");
if (noCommitsToBeMerged == 0)
{
break;
}
var commitid = connection.QueryFirst <int>(
$"select min(changesetid) from changesets where changesetid > {startchangeset} and TfsPath in {sqlpaths}");
var changeset = connection.QueryFirst <CheckIn>(
$"select ChangesetId as Id, comment, trim(committer) as committerName, trim(committerEmail), [CommitterDate] as date from changesets where changesetid = {commitid}");
var tfsPaths = paths.Select(p => p.tfslocalpath).ToArray();
var tfsRootPath =
new string(
tfsPaths
.First()
.Substring(0, tfsPaths.Min(s => s.Length))
.TakeWhile((c, i) => tfsPaths.All(s => s[i] == c))
.ToArray());
foreach (var path in paths)
{
UpdateTfsPath(path.tfslocalpath, commitid);
}
var proc = new Process
{
StartInfo = new ProcessStartInfo("cmd",
$"/c Robocopy {tfsRootPath} . /MIR /XD .git /XF .gitattributes /XF .gitignore")
{
UseShellExecute = false,
WorkingDirectory = gitlocal
}
};
proc.Start();
proc.WaitForExit();
proc = new Process
{
StartInfo = new ProcessStartInfo("cmd", "/c git add .")
{
UseShellExecute = false,
WorkingDirectory = gitlocal
}
};
proc.Start();
proc.WaitForExit();
if (changeset.committerEmail == null)
{
changeset.committerEmail = changeset.committerName.ToLower().Replace(' ', '.') + "@unit4.com";
}
var d = changeset.date.ToStringWithOffset();
var commitcli =
$"git commit -m '{changeset.comment}' -m 'https://team47system1.corp.u4agr.com/tfs/DefaultCollection/Platform/_versionControl/changeset/{changeset.Id}' --author '{changeset.committerName} <{changeset.committerEmail}>' --date '{d}'";
proc = new Process
{
StartInfo = new ProcessStartInfo(@"pwsh", $"-c {commitcli}")
{
UseShellExecute = false,
WorkingDirectory = gitlocal
}
};
proc.Start();
proc.WaitForExit();
startchangeset = commitid;
connection.Execute(
$"update MigStatus set lastchangeset = {startchangeset} where [gitlocalpath] = '{gitlocal}'");
} while (true);
}
}
public static void AddDapperNodaTime()
{
DapperNodaTimeSetup.Register();
Dapper.SqlMapper.AddTypeHandler(new Helpers.InstantHandler());
}
private static void Main(string[] args)
{
DapperNodaTimeSetup.Register();
var connectionString = args[0];
var connection = new SqlConnection(connectionString);
Stuff.GetDbRetryPolicy().Execute(() => connection.Open());
var syncpaths = connection.Query <SyncPath>(
"SELECT [TfsUrl], [TfsPath], [LastChangeSetId] FROM [TfsPathsToSync]");
foreach (var syncpath in syncpaths)
{
Console.WriteLine($"Processing {syncpath.TfsPath}");
var tfs = new TfsUtil(syncpath.TfsUrl);
var history = tfs.GetHistory(syncpath.TfsPath);
int newLastChangesetId = 0;
foreach (var changeset in history)
{
newLastChangesetId = Math.Max(newLastChangesetId, changeset.Id);
if (changeset.Id > syncpath.LastChangeSetId)
{
var count = connection.QuerySingle <int>(
"select count(*) from Changesets where TfsPath = @TfsPath and ChangeSetId = @ChangesetId",
new
{
// ReSharper disable once RedundantAnonymousTypePropertyName
TfsPath = syncpath.TfsPath,
ChangesetId = changeset.Id
});
if (count == 0)
{
connection.Execute(
@"insert into Changesets (TfsPath, ChangesetId, Comment, Committer, CommitterEmail, CommitterDate) values
(@TfsPath, @ChangesetId, @Comment, @Committer, @CommitterEmail, @CommitterDate) ",
new[]
{
new
{
syncpath.TfsPath,
ChangesetId = changeset.Id,
Comment = changeset.comment,
Committer = changeset.committerName,
CommitterEmail = changeset.committerEmail,
CommitterDate = changeset.date
}
});
}
}
else
{
break;
}
}
if (syncpath.LastChangeSetId != newLastChangesetId)
{
int rows = connection.Execute(
@"update TfsPathsToSync set LastChangeSetId = @newMaxId where TfsUrl = @tfsUrl and TfsPath = @tfsPath",
new
{
newMaxId = newLastChangesetId,
tfsUrl = syncpath.TfsUrl,
tfsPath = syncpath.TfsPath
});
if (rows != 1)
{
Console.WriteLine($"Error updateing LastChangeSetId for {syncpath.TfsPath}");
}
Console.WriteLine($"Updated {syncpath.TfsPath} up to commit {newLastChangesetId}");
}
}
}