void ExportToTextFile(object sender, RoutedEventArgs e)
{
Microsoft.Win32.SaveFileDialog d = new Microsoft.Win32.SaveFileDialog();
d.DefaultExt = ".txt";
d.Filter = "Text documents (.txt)|*.txt";
if (d.ShowDialog() == true)
{
string OutputFileName = d.FileName;
try
{
using (System.IO.StreamWriter writer = System.IO.File.CreateText(OutputFileName))
{
DataStreamer.StreamFile(
chkWriteOutSectionHeaders.IsChecked.Value, chkScriptDrops.IsChecked.Value, chkScriptCreates.IsChecked.Value, writer,
txtPrimaryInstance.Text, cmbPrimaryDatabase.SelectedValue.ToString(),
txtSecondaryInstance.Text, cmbSecondaryDatabase.SelectedValue.ToString(),
PrimaryGroup, SecondaryGroup);
}
System.Windows.MessageBox.Show(String.Format("Your file is now available at {0}.", OutputFileName), "File Export Successful.", MessageBoxButton.OK, MessageBoxImage.Information);
}
catch (Exception ex)
{
ShowErrorMessage(ex.Message);
}
}
}
public IAsyncEnumerable <TDataType> ReadAll <TDataType>() where TDataType : DataEntity
{
using (Logger.BeginScope("{Operation} is {Action} {DataType} with Id ({Id})", nameof(DataManager),
"reading all", typeof(TDataType).Name))
{
return(DataStreamer.ReadAll <TDataType>());
}
}
public int GetNextId <TDataType>() where TDataType : DataEntity
{
using (Logger.BeginScope("{Operation} is {Action} for {DataType}", nameof(DataManager), "getting next id",
typeof(TDataType).Name))
{
Logger.LogTrace("Getting next id from store");
var id = DataStreamer.NextId <TDataType>();
Logger.LogInformation("Next id is {id}", id);
return(id);
}
}
public async Task <TDataType> Read <TDataType>(int id) where TDataType : DataEntity
{
using (Logger.BeginScope("{Operation} is {Action}ing {DataType} with Id ({Id})", nameof(DataManager),
"read", typeof(TDataType).Name, id))
{
Logger.LogTrace("Started to read");
if (await DataStreamer.Exists <TDataType>(id))
{
return(await DataStreamer.Read <TDataType>(id));
}
Logger.LogInformation("Didn't find the data");
return(null);
}
}
static void Main(string[] args)
{
Console.CancelKeyPress += delegate { Console.WriteLine(String.Format("{0}Goodbye.{0}", Environment.NewLine)); };
string PrimaryServerName, SecondaryServerName, PrimaryDatabaseName, SecondaryDatabaseName, OutputFileName;
if (args.Count() == 5)
{
PrimaryServerName = args[0];
SecondaryServerName = args[1];
PrimaryDatabaseName = args[2];
SecondaryDatabaseName = args[3];
OutputFileName = args[4];
}
else
{
if (args.Count() > 0)
{
Console.WriteLine("Invalid argument listing passed. A valid call looks like:");
Console.WriteLine("IndexComparer.exe PrimaryServerName SecondaryServerName PrimaryDatabaseName SecondaryDatabaseName OutputFileName");
Console.WriteLine("");
Console.WriteLine("");
}
#region Console Activity
do
{
Console.Write("Give the primary server name. ");
PrimaryServerName = Console.ReadLine();
} while (String.IsNullOrWhiteSpace(PrimaryServerName));
do
{
Console.Write("Give the primary database name. ");
PrimaryDatabaseName = Console.ReadLine();
} while (String.IsNullOrWhiteSpace(PrimaryDatabaseName));
Console.Write("Give the secondary server name. If this is the same as the primary server, just hit Enter. ");
SecondaryServerName = Console.ReadLine();
if (String.IsNullOrWhiteSpace(SecondaryServerName))
{
SecondaryServerName = PrimaryServerName;
}
Console.Write("Give the secondary database name. If this is the same as the primary database, just hit Enter. ");
SecondaryDatabaseName = Console.ReadLine();
if (String.IsNullOrWhiteSpace(SecondaryDatabaseName))
{
SecondaryDatabaseName = PrimaryDatabaseName;
}
Console.Write("Tell where you would like the output file to go. Default: C:\\Temp\\IndexComparisonLog.txt -- ");
OutputFileName = Console.ReadLine();
if (String.IsNullOrWhiteSpace(OutputFileName))
{
OutputFileName = @"C:\Temp\IndexComparisonLog.txt";
}
#endregion
}
List <IndexSet> PrimaryResults = IndexSet.RetrieveIndexData(PrimaryServerName, PrimaryDatabaseName);
List <IndexSet> SecondaryResults = IndexSet.RetrieveIndexData(SecondaryServerName, SecondaryDatabaseName);
using (System.IO.StreamWriter writer = System.IO.File.CreateText(OutputFileName))
{
DataStreamer.StreamFile(true, true, true, writer, PrimaryServerName, PrimaryDatabaseName, SecondaryServerName, SecondaryDatabaseName, PrimaryResults, SecondaryResults);
}
}
public async Task <bool> Restore <TDataType>(int id) where TDataType : DataEntity
{
using (Logger.BeginScope("{Operation} is {Action} {DataType} with Id ({Id})", nameof(DataManager),
"restoring", typeof(TDataType).Name, id))
{
var data = await Read <TDataType>(id);
if (data is null)
{
Logger.LogTrace("Data could be deleted");
if (await DataStreamer.Undelete <TDataType>(id))
{
Logger.LogTrace("Data restored to store");
data = await Read <TDataType>(id);
if (typeof(TDataType).IsDefined(typeof(AuditAttribute), true))
{
Logger.LogTrace("Data is audited");
if (await AuditWorker.UndeleteEvent(data))
{
if (await AuditWorker.CommitEvents(data))
{
Logger.LogTrace("Audit committed to store");
if (await IndexWorker.Index(data))
{
Logger.LogInformation("Restored data with audit");
return(true);
}
Logger.LogWarning("Failed to index data");
await AuditWorker.RollbackEvent(data);
}
else
{
Logger.LogWarning("Failed to commit audit for data to store");
await AuditWorker.DiscardEvents(data);
Logger.LogTrace("Discarded audit record");
}
}
else
{
Logger.LogWarning("Failed to create undelete audit record for data");
}
}
else
{
if (await IndexWorker.Index(data))
{
Logger.LogInformation("Restored data");
return(true);
}
Logger.LogWarning("Failed to index data");
}
await DataStreamer.Delete <TDataType>(id);
Logger.LogInformation("Rolled back restore");
}
Logger.LogWarning("Failed to restore data");
return(false);
}
Logger.LogWarning("Data didn't need restoring");
return(true);
}
}
public async Task <bool> Delete <TDataType>(int id) where TDataType : DataEntity
{
using (Logger.BeginScope("{Operation} is {Action} {DataType} with Id ({Id})", nameof(DataManager),
"deleting", typeof(TDataType).Name, id))
{
var data = await Read <TDataType>(id);
if (data is null)
{
Logger.LogWarning("Unable to find the data it may already be deleted");
return(false);
}
if (typeof(TDataType).IsDefined(typeof(AuditAttribute), true))
{
Logger.LogTrace("Data is audited");
if (await AuditWorker.DeleteEvent(data))
{
Logger.LogTrace("Delete audit record created");
if (await DataStreamer.Delete <TDataType>(id))
{
Logger.LogTrace("Data deleted from store");
if (await AuditWorker.CommitEvents(data))
{
Logger.LogTrace("Audit committed to store");
if (await IndexWorker.Unindex(data))
{
Logger.LogInformation("Data deleted from store");
return(true);
}
Logger.LogWarning("Failed to remove indexes for data");
await AuditWorker.RollbackEvent(data);
Logger.LogInformation("Added rollback audit record");
}
else
{
Logger.LogWarning("Failed to commit audit to store");
}
await DataStreamer.Rollback(id, data);
Logger.LogInformation("Rolled data back");
}
else
{
Logger.LogWarning("Failed to delete data");
await AuditWorker.DiscardEvents(data);
Logger.LogTrace("Discarded audit record");
}
return(false);
}
Logger.LogWarning("Failed to create audit record for delete");
return(false);
}
Logger.LogTrace("Data is not audited");
if (await DataStreamer.Delete <TDataType>(id))
{
Logger.LogInformation("Deleted data");
if (await IndexWorker.Unindex(data))
{
Logger.LogInformation("Removed any indexes for data");
return(true);
}
Logger.LogWarning("Failed to remove indexes for data");
await DataStreamer.Rollback(id, data);
Logger.LogInformation("Rolled data back");
}
Logger.LogWarning("Failed to delete data");
return(false);
}
}
public async Task <bool> Write <TDataType>(TDataType data) where TDataType : DataEntity
{
using (Logger.BeginScope("{Operation} is {Action} {DataType} with Id ({Id})", nameof(DataManager),
"writing", typeof(TDataType).Name, data.Id))
{
Logger.LogTrace("Checking if data exists");
var currentData = await Read <TDataType>(data.Id);
Logger.LogInformation(currentData is null ? "Creating data" : "Updating data");
if (typeof(TDataType).IsDefined(typeof(AuditAttribute), true))
{
Logger.LogTrace("{DataType} is audited", typeof(TDataType).Name);
var writtenData = await DataStreamer.Write(data.Id, data);
if (writtenData)
{
Logger.LogTrace("Data ready to commit to store");
var auditResult = currentData is null
? await AuditWorker.CreationEvent(data)
: await AuditWorker.UpdateEvent(data, currentData);
if (auditResult)
{
Logger.LogTrace("Audit record created");
writtenData = await DataStreamer.Commit <TDataType>(data.Id);
if (writtenData)
{
Logger.LogTrace("Data saved to store");
var committedAudit = await AuditWorker.CommitEvents(data);
if (committedAudit)
{
Logger.LogTrace("Audit saved to store");
var indexed = await IndexWorker.Index(data);
if (indexed)
{
Logger.LogInformation("Data, Audit saved successfully");
return(true);
}
Logger.LogWarning("Failed to index data");
await AuditWorker.RollbackEvent(data);
Logger.LogInformation("Added rollback to audit");
Logger.LogTrace("Rolled back data");
}
await DataStreamer.Rollback(data.Id, currentData);
Logger.LogInformation("Rolled data back");
return(false);
}
await AuditWorker.DiscardEvents(data);
return(false);
}
Logger.LogWarning("Failed to create audit record for data");
await DataStreamer.DiscardChanges <TDataType>(data.Id);
Logger.LogTrace("Discard changes");
}
Logger.LogWarning("Failed to save data to the store");
return(false);
}
Logger.LogTrace("Data is not audited");
var writeAndCommit = await DataStreamer.WriteAndCommit(data.Id, data);
if (writeAndCommit)
{
var indexed = await IndexWorker.Index(data);
if (!indexed)
{
Logger.LogWarning("Failed to index data");
await DataStreamer.Rollback(data.Id, currentData);
Logger.LogInformation("Rolled data back");
return(false);
}
Logger.LogTrace("Data was indexed");
Logger.LogInformation("Data saved successfully");
}
else
{
Logger.LogWarning("Failed to save data");
}
return(writeAndCommit);
}
}
