/// <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>
/// 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;
}
}
/// <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;
}
}
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>
/// 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 = client.OrderChangelog(order);
dataset.AbortedChangelogId = resp.changelogId;
SubscriberDatasetManager.UpdateDataset(dataset);
return(dataset.AbortedChangelogId);
}
catch (Exception ex)
{
Logger.ErrorException("OrderChangelog failed:", ex);
throw;
}
}
/// <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;
}
}
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);
}
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>
/// 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>
/// 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>
/// 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);
}
}
/// <summary>
/// Build wfs-t transaction from changelog, and do the transaction
/// </summary>
/// <param name="changeLog"></param>
/// <param name="datasetId"></param>
/// <returns></returns>
public bool DoWfsTransactions(XElement changeLog, int datasetId)
{
try
{
bool success;
var xDoc = ConstructWfsTransaction(changeLog);
SaveWfsTransactionToDisk(xDoc.Root, datasetId);
if (xDoc == null)
{
return(false);
}
// Post to WFS-T server (e.g. deegree or GeoServer)
try
{
//20121122-Leg:: Get subscriber deegree / GeoServer url from db
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
String url = dataset.ClientWfsUrl;
var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.Method = "POST";
httpWebRequest.ContentType = "text/xml"; //"application/x-www-form-urlencoded";
httpWebRequest.Timeout = System.Threading.Timeout.Infinite;
//httpWebRequest.ReadWriteTimeout = System.Threading.Timeout.Infinite;
//httpWebRequest.AllowWriteStreamBuffering = false;
//httpWebRequest.SendChunked = true;
var writer = new StreamWriter(httpWebRequest.GetRequestStream());
xDoc.Save(writer, SaveOptions.DisableFormatting);
writer.Close();
//GC.Collect();
// get response from request
HttpWebResponse httpWebResponse = CheckResponseForErrors(httpWebRequest);
success = CreateTransactionSummary(httpWebResponse);
}
catch (WebException webEx)
{
Logger.ErrorException("DoWfsTransactions WebException:", webEx);
throw new Exception("WebException error : " + webEx.Message);
}
catch (Exception ex)
{
Logger.ErrorException("DoWfsTransactions Exception (inner):", ex);
return(false);
}
return(success);
}
catch (Exception ex)
{
Logger.ErrorException("DoWfsTransactions failed:", ex);
throw;
}
}
/// <summary>
/// Build wfs-t transaction from changelog, and do the transaction
/// </summary>
/// <param name="changeLog"></param>
/// <param name="datasetId"></param>
/// <returns></returns>
public bool DoWfsTransactions(XElement changeLog, int datasetId)
{
var success = false;
var xDoc = ConstructWfsTransaction(changeLog);
SaveWfsTransactionToDisk(xDoc.Root, datasetId);
// Post to WFS-T server (e.g. deegree or GeoServer)
try
{
//20121122-Leg:: Get subscriber deegree / GeoServer url from db
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
String url = dataset.ClientWfsUrl;
var httpWebRequest = (HttpWebRequest)WebRequest.Create(url);
httpWebRequest.Method = "POST";
httpWebRequest.ContentType = "text/xml"; //"application/x-www-form-urlencoded";
httpWebRequest.Timeout = System.Threading.Timeout.Infinite;
//httpWebRequest.ReadWriteTimeout = System.Threading.Timeout.Infinite;
//httpWebRequest.AllowWriteStreamBuffering = false;
//httpWebRequest.SendChunked = true;
var writer = new StreamWriter(httpWebRequest.GetRequestStream());
xDoc.Save(writer, SaveOptions.DisableFormatting);
writer.Close();
//GC.Collect();
// get response from request
HttpWebResponse httpWebResponse = CheckResponseForErrors(httpWebRequest);
success = CreateTransactionSummary(httpWebResponse);
}
catch (WebException webEx)
{
if (webEx.Message.Contains("null"))
{
throw new Exception("WebException error: This error most often occurs when there's something wrong with namespaces. Check deegree configuration. Exception: " + webEx.Message);
}
CheckApplicationSchema(datasetId);
if (webEx.Message.ToLowerInvariant().Contains("geometry") && webEx.Message.ToLowerInvariant().Contains("invalid"))
{
SendErrorReport(datasetId, webEx.Message);
}
throw new Exception("WebException error: " + webEx.Message);
}
catch (Exception ex)
{
Logger.Error(ex, "DoWfsTransactions Exception (inner): ");
if (ex.Source != "System")
{
SendErrorReport(datasetId, ex.Message);
}
return(false);
}
return(success);
}
/// <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;
}
}
/// <summary>
/// Synchronizing of a given dataset
/// </summary>
/// <param name="datasetId"></param>
public void DoSynchronization(int datasetId)
{
var dataset = SubscriberDatasetManager.GetDataset(datasetId);
try
{
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.ErrorException("DoSynchronization WebException:", webEx);
throw new Exception(webEx.Message);
}
catch (Exception ex)
{
Logger.ErrorException("DoSynchronization Exception:", ex);
OnUpdateLogList(ex.Message);
Logger.Log(LogLevel.Error, "Details:");
OnUpdateLogList("Details:");
PropertyInfo[] properties = dataset.GetType().GetProperties();
foreach (PropertyInfo property in properties)
{
dynamic propValue;
if (property.Name == "Password")
{
propValue = "****";
}
else
{
propValue = property.GetValue(dataset, null);
}
string propLogEntry = $"\t{property.Name} : {propValue}";
Logger.Log(LogLevel.Error, propLogEntry);
OnUpdateLogList(propLogEntry);
}
Logger.Log(LogLevel.Error, "End details.");
OnUpdateLogList("End details.");
throw new Exception(ex.Message);
}
}