public bool SendReport(ReportType report, int datasetId)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var client = buildClient(dataset);
client.SendReport(report);
return(true);
}
catch (WebException webEx)
{
if (webEx.Status == WebExceptionStatus.Success)
{
return(false);
}
Logger.Error(webEx, "SendReport WebException:");
throw;
}
catch (Exception ex)
{
Logger.Error(ex, "SendReport failed:");
throw;
}
}
/// <summary>
/// Initialize _currentDatasetId
/// </summary>
private void InitializeCurrentDataset()
{
_currentDatasetId = Properties.Subscriber.Default.DefaultDatasetId;
// Get subscribers last index from db
txbSubscrLastindex.Text = SubscriberDatasetManager.GetLastIndex(_currentDatasetId);
}
private static void RunAsConsole(string[] args)
{
AttachConsole();
Console.WriteLine();
var datasetIds = SubscriberDatasetManager.GetListOfDatasetIDs();
if (args.Length == 1 && args[0].ToLower() == "auto")
{
SynchronizeDatasets(datasetIds);
}
else if (args.Length == 1 && args[0].ToLower() == "help")
{
Console.WriteLine("Args: auto | datasetId ...");
}
else
{
foreach (var datasetId in args)
{
if (datasetIds.Contains(int.Parse(datasetId)))
{
Synchronize(int.Parse(datasetId));
}
else
{
Console.WriteLine("ERROR: DatasetId " + datasetId + " does not exist");
}
}
}
}
/// <summary>
/// Henter siste endringsnr fra tilbyder. Brukes for at klient enkelt kan sjekke om det er noe nytt siden siste synkronisering
/// </summary>
/// <returns></returns>
public long GetLastIndexFromProvider(int datasetId)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var client = buildClient(dataset);
var lastIndexString = client.GetLastIndex(dataset.ProviderDatasetId);
var lastIndex = Convert.ToInt64(lastIndexString);
return(lastIndex);
}
catch (WebException webEx)
{
Logger.Error(webEx, "GetLastIndexFromProvider WebException:");
throw;
}
catch (Exception ex)
{
Logger.Error(ex, "GetLastIndexFromProvider failed:");
throw;
}
}
/// <summary>
/// Resets the subscribers last index for a given dataset
/// </summary>
/// <param name="datasetId"></param>
public void ResetSubscriberLastIndex(int datasetId)
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
dataset.LastIndex = 0;
ResetDataset(dataset, 0);
}
/// <summary>
/// Get OrderChangelog Response and changelogid
/// </summary>
/// <param name="datasetId"></param>
/// <param name="startIndex"></param>
/// <returns></returns>
public string OrderChangelog(int datasetId, long startIndex)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var client = buildClient(dataset);
var order = new ChangelogOrderType();
order.datasetId = dataset.ProviderDatasetId;
order.count = dataset.MaxCount.ToString();
order.startIndex = startIndex.ToString();
var resp = string.IsNullOrEmpty(dataset.Version)
? client.OrderChangelog(order)
: client.OrderChangelog2(order, dataset.Version.Trim());
if (resp.changelogId == "-1")
{
throw new Exception("Provider reports a datasetVersion that differs from that of the subscriber.\r\nThis may be due to several reasons.\r\nActions needed are emptying the local database, replacing the subscriber dataset with the new version from the provider and finally resynchronizing the dataset.");
}
dataset.AbortedChangelogId = resp.changelogId;
SubscriberDatasetManager.UpdateDataset(dataset);
return(dataset.AbortedChangelogId);
}
catch (Exception ex)
{
Logger.Error(ex, "OrderChangelog failed:");
throw;
}
}
/// <summary>
/// Tests the offline syncronization complete.
/// </summary>
/// <param name="zipFile">The zip file.</param>
/// <param name="datasetId">The dataset identifier.</param>
/// <param name="transactionStart"></param>
/// <returns>True if OK.</returns>
public bool DoSyncronizationOffline(string zipFile, int datasetId, long transactionStart)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var downloadController = new DownloadController();
downloadController.UnpackZipFile(zipFile);
// Check if zip contains folder or file - Could be more than one file
var baseFilename = zipFile.Replace(".zip", "");
string xmlFile;
var isFolder = false;
if (Directory.Exists(baseFilename))
{
xmlFile = baseFilename;
isFolder = true;
}
else
{
xmlFile = Path.ChangeExtension(zipFile, ".xml");
}
var fileList = GetChangelogFiles(isFolder, xmlFile);
return(LoopChangeLog(fileList, dataset, datasetId, 0, zipFile, transactionStart));
}
catch (Exception ex)
{
Logger.Error(ex, "TestOfflineSyncronizationComplete:");
throw;
}
}
private static void ResetDataset(Dataset dataset, long endIndex)
{
if (endIndex > 0)
{
dataset.LastIndex = endIndex;
}
dataset.AbortedEndIndex = null;
dataset.AbortedTransaction = null;
dataset.AbortedChangelogId = null;
if (!string.IsNullOrEmpty(dataset.AbortedChangelogPath))
{
if (File.Exists(dataset.AbortedChangelogPath))
{
File.Delete(dataset.AbortedChangelogPath);
}
var changelogDirectory = dataset.AbortedChangelogPath.Replace(".zip", "");
if (Directory.Exists(changelogDirectory))
{
Directory.Delete(changelogDirectory, true);
}
dataset.AbortedChangelogPath = null;
}
SubscriberDatasetManager.UpdateDataset(dataset);
}
/// <summary>
/// Fills the cboDatasetName comboBox with the dataset names
/// </summary>
private void FillComboBoxDatasetName()
{
//cboDatasetName.Items.Clear();
comboFill = true;
var datasetNameList = SubscriberDatasetManager.GetDatasetNamesAsDictionary();
cboDatasetName.DataSource = new BindingSource(datasetNameList, null);
try
{
cboDatasetName.DisplayMember = "Value";
cboDatasetName.ValueMember = "Key";
cboDatasetName.SelectedValue = _currentDatasetId;
}
catch (Exception e)
{
logger.Warn(e.Message);
}
//if (datasetNameList.Count > 0)
//{
// foreach (string name in datasetNameList)
// {
// cboDatasetName.Items.Add(name);
// }
//cboDatasetName.SelectedIndex = _currentDatasetId - 1;
//}
comboFill = false;
}
private void btnAddSelected_Click(object sender, EventArgs e)
{
IList <int> selectedDataset = new List <int>();
foreach (DataGridViewRow dgr in dgvProviderDataset.SelectedRows)
{
selectedDataset.Add(dgr.Index);
}
var blDataset = (IBindingList)dgvProviderDataset.DataSource;
if (!SubscriberDatasetManager.AddDatasets(blDataset, selectedDataset, txbProviderURL.Text, textBoxUserName.Text, textBoxPassword.Text))
{
MessageBox.Show(this, "Error saving selected datasets to internal Database.", "Get Provider Datasets",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show(this, "Saved selected datasets to the internal Database.", "Get Provider Datasets",
MessageBoxButtons.OK, MessageBoxIcon.Information);
dgDataset.DataSource = null;
InitializeDatasetGrid();
FillComboBoxDatasetName();
}
}
private void bw_SynchronizeComplete(object sender, RunWorkerCompletedEventArgs e)
{
// Update Dataset-datagridview control with changes
InitializeDatasetGrid();
// update subscribers last index from db
txbSubscrLastindex.Text = SubscriberDatasetManager.GetLastIndex(_currentDatasetId);
// Display in geoserver openlayers
UpdateToolStripStatusLabel("Display Map");
UpdateToolStripStatusLabel("Ready");
SetSynchButtonActive();
Hourglass(false);
if (_synchController.TransactionsSummary != null)
{
var logMessage = "Syncronization Transaction summary:";
listBoxLog.Items.Add(logMessage);
logMessage = "TotalInserted: " + _synchController.TransactionsSummary.TotalInserted;
listBoxLog.Items.Add(logMessage);
logMessage = "TotalUpdated: " + _synchController.TransactionsSummary.TotalUpdated;
listBoxLog.Items.Add(logMessage);
logMessage = "TotalDeleted: " + _synchController.TransactionsSummary.TotalDeleted;
listBoxLog.Items.Add(logMessage);
logMessage = "TotalReplaced: " + _synchController.TransactionsSummary.TotalReplaced;
listBoxLog.Items.Add(logMessage);
// Scroll down automatically
listBoxLog.SelectedIndex = listBoxLog.Items.Count - 1;
}
}
/// <summary>
/// Bekrefte at endringslogg er lastet ned
/// </summary>
/// <returns></returns>
public bool AcknowledgeChangelogDownloaded(int datasetId, string changelogId)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var client = buildClient(dataset);
var id = new ChangelogIdentificationType {
changelogId = changelogId
};
client.AcknowlegeChangelogDownloaded(id);
return(true);
}
catch (WebException webEx)
{
if (webEx.Status == WebExceptionStatus.Success)
{
return(false);
}
Logger.Error(webEx, "AcknowledgeChangelogDownloaded WebException:");
throw;
}
catch (Exception ex)
{
Logger.Error(ex, "AcknowledgeChangelogDownloaded failed:");
throw;
}
}
/// <summary>
/// Delete selected dataset from database
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
private void btnDeleteSelected_Click(object sender, EventArgs e)
{
IList <int> selectedDataset = new List <int>();
foreach (DataGridViewRow dgr in dgDataset.SelectedRows)
{
selectedDataset.Add(dgr.Index);
}
var subscriberDatasets = (MySortableBindingList <SubscriberDataset>)dgDataset.DataSource;
//var subscriberDatasets = (List<SubscriberDataset>)dgDataset.DataSource;
if (!SubscriberDatasetManager.RemoveDatasets(subscriberDatasets.ToList(), selectedDataset))
{
MessageBox.Show(this, "Error removing selected datasets from internal Database.", "Remove Datasets",
MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
MessageBox.Show(this, "Saved after removing selected datasets from internal Database.",
"Remove Datasets", MessageBoxButtons.OK, MessageBoxIcon.Information);
dgDataset.DataSource = null;
InitializeDatasetGrid();
cboDatasetName.SelectedIndex = 0;
FillComboBoxDatasetName();
}
}
/// <summary>
/// Get OrderChangelog Response and changelogid
/// </summary>
/// <param name="datasetId"></param>
/// <param name="startIndex"></param>
/// <returns></returns>
public string OrderChangelog(int datasetId, long startIndex)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var client = buildClient(dataset);
var order = new ChangelogOrderType();
order.datasetId = dataset.ProviderDatasetId;
order.count = dataset.MaxCount.ToString();
order.startIndex = startIndex.ToString();
var resp = client.OrderChangelog(order);
dataset.AbortedChangelogId = resp.changelogId;
SubscriberDatasetManager.UpdateDataset(dataset);
return(dataset.AbortedChangelogId);
}
catch (Exception ex)
{
Logger.ErrorException("OrderChangelog failed:", ex);
throw;
}
}
private void InitializeDatasetGrid()
{
try
{
List <string> invisibleColumns = new List <string>()
{
"DatasetId",
"AbortedEndIndex",
"AbortedTransaction",
"AbortedChangelogPath",
"AbortedChangelogId",
//"UserName",
//"Password"
};
// dgDataset.DataSource = SubscriberDatasetManager.GetAllDataset();
var list1 = SubscriberDatasetManager.GetAllDataset();
// To enable sorting in a DataGridView bound to a List
// See https://www.codeproject.com/Articles/31418/Implementing-a-Sortable-BindingList-Very-Very-Quic
MySortableBindingList <SubscriberDataset> sortableBindingList = new MySortableBindingList <SubscriberDataset>(list1); //new SortableList<SubscriberDataset>();
dgDataset.DataSource = sortableBindingList;
var col = dgDataset.Columns["DatasetId"];
dgDataset.Sort(col, ListSortDirection.Ascending);
foreach (DataGridViewColumn column in dgDataset.Columns)
{
column.SortMode = DataGridViewColumnSortMode.Automatic;
}
#if !DEBUG
foreach (var invisibleColumn in invisibleColumns)
{
dgDataset.Columns[invisibleColumn].Visible = false;
}
;
#endif
dgDataset.AutoSize = true;
//dgDataset.AllowUserToOrderColumns = true; // 20171113-Leg
// 20171113-Leg: AutoSizeColumnsMode must be set to None in order to AllowUserToResizeColumns and AllowUserToResizeRows to work.
//dgDataset.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.DisplayedCells;
}
catch (Exception ex)
{
var errMsg = "Form1_Load failed when opening database:" + SubscriberDatasetManager.GetDatasource();
logger.ErrorException(errMsg, ex);
errMsg += "\r\n" + "Remember to copy the database to the the folder:" +
AppDomain.CurrentDomain.GetData("APPBASE");
MessageBox.Show(ex.Message + "\r\n" + errMsg);
}
}
private bool LoopChangeLog(IEnumerable <string> fileList, Dataset dataset, int datasetId,
int progressCounter,
string changelogFilename, long transactionStart)
{
var i = 0;
var status = false;
XElement changeLog = null;
foreach (var fileName in fileList)
{
if (transactionStart > i)
{
i++;
continue;
}
changeLog = XElement.Load(fileName);
dataset.AbortedEndIndex = GetAbortedEndIndex(changeLog);
dataset.AbortedTransaction = i;
if (File.Exists(changelogFilename))
{
dataset.AbortedChangelogPath = changelogFilename;
}
else if (File.Exists(changelogFilename + ".zip"))
{
dataset.AbortedChangelogPath = changelogFilename + ".zip";
}
else
{
throw new FileNotFoundException("Changelogfile not found at either " + changelogFilename + " or " + changelogFilename + ".zip");
}
SubscriberDatasetManager.UpdateDataset(dataset);
status = DoWfsTransaction(changeLog, datasetId, i + 1);
if (!status)
{
throw new Exception("WfsTransaction failed");
}
OnOrderProcessingChange((progressCounter + 1) * 100);
++progressCounter;
i++;
}
if (changeLog != null)
{
ResetDataset(dataset, (long)changeLog.Attribute("endIndex"));
}
return(status);
}
public long GetLastIndexFromSubscriber(int datasetId)
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
if (dataset == null)
{
return(-1);
}
return(dataset.LastIndex);
}
/// <summary>
/// Waiting until a specific changelog is available
/// </summary>
/// <param name="datasetId"></param>
/// <param name="changeLogId"></param>
/// <returns></returns>
private void GetStatusForChangelogOnProvider(int datasetId, string changeLogId)
{
try
{
var changeLogStatus = GetChangelogStatusResponse(datasetId, changeLogId);
var starttid = DateTime.Now;
var elapsedTicks = DateTime.Now.Ticks - starttid.Ticks;
var elapsedSpan = new TimeSpan(elapsedTicks);
var timeout = 15;
//timeout = 50; // TODO: Fix for Norkart Provider,
while ((changeLogStatus == ChangelogStatusType.queued || changeLogStatus == ChangelogStatusType.working) &&
elapsedSpan.Minutes < timeout)
{
System.Threading.Thread.Sleep(3000);
elapsedTicks = DateTime.Now.Ticks - starttid.Ticks;
elapsedSpan = new TimeSpan(elapsedTicks);
changeLogStatus = GetChangelogStatusResponse(datasetId, changeLogId);
}
if (changeLogStatus == ChangelogStatusType.finished)
{
OnNewSynchMilestoneReached("ChangeLog from Provider ready for download.");
}
else
{
switch (changeLogStatus)
{
case (ChangelogStatusType.cancelled):
Logger.Info("Cancelled by Server! Call provider.");
ResetDataset(SubscriberDatasetManager.GetDataset(datasetId), -1);
throw new IOException("Recieved ChangelogStatus == cancelled from provider");
case (ChangelogStatusType.failed):
Logger.Info("ChangelogStatusType.failed waiting for ChangeLog from Provider");
ResetDataset(SubscriberDatasetManager.GetDataset(datasetId), -1);
throw new IOException("Recieved ChangelogStatus == failed from provider");
default:
Logger.Info("Timeout");
throw new IOException("Timed out waiting for ChangelogStatus == finished from provider");
}
}
}
catch (Exception ex)
{
Logger.Error(ex,
string.Format("Failed to get ChangeLog Status for changelog {0} from provider {1}", changeLogId,
"TEST"));
throw new IOException(ex.Message);
}
}
/// <summary>
/// Get and download changelog
/// </summary>
/// <param name="datasetId"></param>
/// <param name="changelogId"></param>
/// <param name="downloadController"></param>
/// <returns></returns>
public bool GetChangelog(int datasetId, string changelogId, out DownloadController downloadController)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var client = buildClient(dataset);
var id = new ChangelogIdentificationType {
changelogId = changelogId
};
var resp = client.GetChangelog(id);
var downloaduri = resp.downloadUri;
// 20151215-Leg: Norkart downloaduri may contain .zip
Logger.Info("GetChangelog downloaduri: " + downloaduri);
var changelogDir = string.IsNullOrEmpty(dataset.ChangelogDirectory)
? Environment.GetEnvironmentVariable("TEMP")
: dataset.ChangelogDirectory;
#if (NOT_FTP)
string fileName = changelogDir + @"\" + changelogid + "_Changelog.xml";
#else
CreateFolderIfMissing(changelogDir);
const string ftpPath = "abonnent";
CreateFolderIfMissing(changelogDir + @"\" + ftpPath);
// Create the abonnent folder if missing
var fileName = changelogDir + @"\" + ftpPath + @"\" + Path.GetFileName(downloaduri);
#endif
downloadController = new DownloadController {
ChangelogFilename = fileName
};
downloadController.DownloadChangelog(downloaduri, dataset);
}
catch (WebException webEx)
{
Logger.Error("GetChangelog failed:", webEx);
throw;
}
catch (Exception ex)
{
Logger.Error(ex, "GetChangelog failed:");
throw;
}
return(true);
}
private void SendErrorReport(int datasetId, string errorMessage)
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var changelogId = GetChangelogId(dataset);
ParentSynchController.SendReport(new ReportType
{
datasetId = dataset.ProviderDatasetId,
changelogId = changelogId,
description = errorMessage,
subscriberType = "Felleskomponent",
type = ReportTypeEnumType.error
}, datasetId);
}
public void SynchronizeAsThread()
{
foreach (var datasetId in SubscriberDatasetManager.GetListOfDatasetIDs())
{
var _backgroundWorker = new BackgroundWorker
{
WorkerReportsProgress = true,
WorkerSupportsCancellation = true
};
_backgroundWorker.DoWork += bw_DoSynchronization;
_backgroundWorker.RunWorkerAsync(datasetId);
_backgroundWorker.RunWorkerCompleted += bw_SynchronizeComplete;
}
}
/// <summary>
/// Save settings database
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void buttonSave_Click(object sender, EventArgs e)
{
try
{
var subscriberDatasets = (List <SubscriberDataset>)dgDataset.DataSource;
foreach (var subscriberDataset in subscriberDatasets)
{
SubscriberDatasetManager.UpdateDataset(subscriberDataset);
}
// Fill the cboDatasetName comboBox with the dataset names
cboDatasetName.SelectedIndex = 0;
FillComboBoxDatasetName();
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + ex.StackTrace);
}
}
private void CheckApplicationSchema(int datasetId)
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var client = SynchController.buildClient(dataset);
var providerDatasets = CapabilitiesDataBuilder.ReadGetCapabilities(client);
if (providerDatasets.Any(d =>
d.TargetNamespace == dataset.TargetNamespace &&
d.ProviderDatasetId == dataset.ProviderDatasetId))
{
return;
}
var errorMessage = $"No datasets on provider for datasetId {dataset.ProviderDatasetId} with applicationSchema {dataset.TargetNamespace}";
SendErrorReport(datasetId, errorMessage);
throw new Exception($"WebException error: {errorMessage}");
}
/// <summary>
/// Get ChangelogStatus Response
/// </summary>
/// <param name="datasetId"></param>
/// <param name="changelogId"></param>
/// <returns></returns>
public ChangelogStatusType GetChangelogStatusResponse(int datasetId, string changelogId)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var client = buildClient(dataset);
var id = new ChangelogIdentificationType {
changelogId = changelogId
};
var resp = client.GetChangelogStatus(id);
return(resp);
}
catch (Exception ex)
{
Logger.Error(ex, "GetChangelogStatusResponse failed:");
throw;
}
}
/// <summary>
/// Handles the SelectedIndexChanged event of the cboDatasetName control.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
private void cboDatasetName_SelectedIndexChanged(object sender, EventArgs e)
{
if (!comboFill)
{
_currentDatasetId = ((KeyValuePair <int, string>)cboDatasetName.SelectedItem).Key;
}
//cboDatasetName.SelectedIndex + 1;
Properties.Subscriber.Default.DefaultDatasetId = _currentDatasetId;
Properties.Subscriber.Default.Save();
try
{
txbSubscrLastindex.Text = SubscriberDatasetManager.GetDataset(_currentDatasetId).LastIndex.ToString();
}
catch (Exception ex)
{
cboDatasetName.SelectedIndex = 0;
_currentDatasetId = ((KeyValuePair <int, string>)cboDatasetName.SelectedItem).Key;
Properties.Subscriber.Default.DefaultDatasetId = _currentDatasetId;
Properties.Subscriber.Default.Save();
}
}
/// <summary>
/// Synchronizing of a given dataset
/// </summary>
/// <param name="datasetId"></param>
public void DoSynchronization(int datasetId)
{
try
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
var stopwatch = Stopwatch.StartNew();
var lastIndexProvider = performSynchronization(dataset, datasetId);
while (dataset.LastIndex <= lastIndexProvider)
{
lastIndexProvider = performSynchronization(dataset, datasetId);
}
stopwatch.Stop();
var ts = stopwatch.Elapsed;
var elapsedTime = string.Format("{0:00}:{1:00}:{2:00}", ts.Hours, ts.Minutes, ts.Seconds);
OnUpdateLogList("Syncronization Completed. Elapsed time: " + elapsedTime);
Logger.Info("Syncronization Completed. Elapsed time: {0}", elapsedTime);
// To set the progressbar to complete / finished
OnOrderProcessingChange(int.MaxValue);
OnNewSynchMilestoneReached("Synch completed");
}
catch (WebException webEx)
{
Logger.Error(webEx, "DoSynchronization WebException:");
throw new Exception(webEx.Message);
}
catch (Exception ex)
{
Logger.Error(ex, "DoSynchronization Exception:");
OnUpdateLogList(ex.Message);
throw new Exception(ex.Message);
}
}
private void InitializeDatasetGrid()
{
try
{
List <string> invisibleColumns = new List <string>()
{
"DatasetId",
"AbortedEndIndex",
"AbortedTransaction",
"AbortedChangelogPath",
"AbortedChangelogId",
//"UserName",
//"Password"
};
#if DEBUG
dgDataset.DataSource = SubscriberDatasetManager.GetAllDataset();
#else
dgDataset.DataSource = SubscriberDatasetManager.GetAllDataset();
foreach (var invisibleColumn in invisibleColumns)
{
dgDataset.Columns[invisibleColumn].Visible = false;
}
;
#endif
dgDataset.AutoSize = true;
dgDataset.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.DisplayedCells;
}
catch (Exception ex)
{
var errMsg = "Form1_Load failed when opening database:" + SubscriberDatasetManager.GetDatasource();
logger.ErrorException(errMsg, ex);
errMsg += "\r\n" + "Remember to copy the database to the the folder:" +
AppDomain.CurrentDomain.GetData("APPBASE");
MessageBox.Show(ex.Message + "\r\n" + errMsg);
}
}
private static void ResetDataset(SubscriberDataset dataset, long endIndex)
{
if (endIndex > 0)
{
dataset.LastIndex = endIndex;
}
dataset.AbortedEndIndex = null;
dataset.AbortedTransaction = null;
dataset.AbortedChangelogId = null;
if (!string.IsNullOrEmpty(dataset.AbortedChangelogPath))
{
if (File.Exists(dataset.AbortedChangelogPath + ".zip"))
{
File.Delete(dataset.AbortedChangelogPath + ".zip");
}
else
{
File.Delete(dataset.AbortedChangelogPath);
}
Directory.Delete(dataset.AbortedChangelogPath, true);
dataset.AbortedChangelogPath = null;
}
SubscriberDatasetManager.UpdateDataset(dataset);
}
private void buttonNew_Click(object sender, EventArgs e)
{
SubscriberDatasetManager.AddEmptyDataset();
InitializeDatasetGrid();
FillComboBoxDatasetName();
}
/// <summary>
/// Handles the Click event of the btnOfflineSync control.
/// Starts Offline sync.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
private void btnOfflineSync_Click(object sender, EventArgs e)
{
try
{
var path = Environment.CurrentDirectory;
//string fileName = "";
var zipFile = "";
var openFileDialog1 = new OpenFileDialog();
//openFileDialog1.InitialDirectory = path.Substring(0, path.LastIndexOf("bin")) +
// @"..\Kartverket.Geosynkronisering.Subscriber.BL\SchemaMapping"; //System.Environment.CurrentDirectory;
openFileDialog1.Filter = "zip files (*.zip)|*.zip|All files (*.*)|*.*";
openFileDialog1.FilterIndex = 1;
openFileDialog1.RestoreDirectory = true;
openFileDialog1.CheckFileExists = true;
openFileDialog1.Title = "Select file for Offline Syncronization";
if (openFileDialog1.ShowDialog() == DialogResult.OK)
{
try
{
zipFile = openFileDialog1.FileName;
}
catch (Exception ex)
{
MessageBox.Show("Error: Could not open file. Original error: " + ex.Message);
}
}
else
{
return;
}
//string zipFile = "";
//// zipFile = @"C:\Users\leg\AppData\Local\Temp\abonnent\6fa6e29d-e978-4ba5-a660-b7f355b233ef.zip";
//zipFile = @"C:\Users\b543836\AppData\Local\Temp\abonnent\6fa6e29d-e978-4ba5-a660-b7f355b233ef.zip";
var dataset = SubscriberDatasetManager.GetDataset(_currentDatasetId);
var lastChangeIndexSubscriber = (int)dataset.LastIndex;
if (lastChangeIndexSubscriber > 0)
{
var buttons = MessageBoxButtons.YesNo;
var result =
MessageBox.Show(
"TestOfflineSyncronizationComplete could fail if lastChangeIndexSubscriber > 0. Do you want to continue?",
"", buttons);
if (result != DialogResult.Yes)
{
return;
}
}
tabControl1.SelectTab(0);
var status = _synchController.DoSyncronizationOffline(zipFile, _currentDatasetId, 0);
if (status)
{
// Oppdaterer dgDataset
dgDataset.DataSource = SubscriberDatasetManager.GetAllDataset();
// update subscribers last index from db
txbSubscrLastindex.Text = SubscriberDatasetManager.GetLastIndex(_currentDatasetId);
if (_synchController.TransactionsSummary != null)
{
var logMessage = "Offline Syncronization Transaction summary:";
listBoxLog.Items.Add(logMessage);
logMessage = "TotalInserted: " + _synchController.TransactionsSummary.TotalInserted;
listBoxLog.Items.Add(logMessage);
logMessage = "TotalUpdated: " + _synchController.TransactionsSummary.TotalUpdated;
listBoxLog.Items.Add(logMessage);
logMessage = "TotalDeleted: " + _synchController.TransactionsSummary.TotalDeleted;
listBoxLog.Items.Add(logMessage);
logMessage = "TotalReplaced: " + _synchController.TransactionsSummary.TotalReplaced;
listBoxLog.Items.Add(logMessage);
// Scroll down automatically
listBoxLog.SelectedIndex = listBoxLog.Items.Count - 1;
}
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + ex.StackTrace, "btnOfflneSync_Click");
// throw;
}
}
