/// <summary>
/// Load a list of facts and eventlogs in the fields.
/// </summary>
/// <param name="field"></param>
/// <author>Bernhard Bruns,Thomas Meents, Moritz Eversmann</author>
public static bool LoadFactsInField(Field field)
{
try
{
List <List <Case> > listOfFacts = DBWorker.GetFacts(MainWindow.MatrixSelection.SelectedDimensions, EventSelectionModel.GetInstance().SelectedDimensions, field);
foreach (List <Case> fact in listOfFacts)
{
if (fact != null)
{
field.EventLog.Cases.AddRange(fact);
}
}
return(true);
}
catch (TimeoutException ex)
{
ErrorHandling.ReportErrorToUser("Error: Database Timeout. " + ex.Message);
}
catch (Exception ex)
{
if (ex is NoParamsGivenException || ex is NotImplementedException || ex is ArgumentException)
{
ErrorHandling.ReportErrorToUser("Error: " + ex.Message);
}
else
{
throw;
}
}
return(false);
}
/// <summary>
/// Serialize the database settings from a file (DatabaseSettings.mpm)
/// </summary>
/// <author>Bernhard Bruns, Moritz Eversmann</author>
public static void SaveConnectionParameters()
{
try
{
Serializer.Serialize("DatabaseSettings.mpm", ConnectionParametersList);
}
catch (SEHException ex)
{
ErrorHandling.ReportErrorToUser("Error while saving: " + ex.Message + "\n" + ex.StackTrace);
}
catch (UnauthorizedAccessException ex)
{
ErrorHandling.ReportErrorToUser("Error while saving: Unauthorized Access: " + ex.Message + "\n" + ex.StackTrace);
}
catch (Exception ex)
{
if (ex is ArgumentNullException || ex is IOException || ex is NullReferenceException || ex is ArgumentOutOfRangeException)
{
ErrorHandling.ReportErrorToUser("Error: " + ex.Message);
}
else
{
throw;
}
}
}
/// <summary>
/// Deserialize a xml-file
/// </summary>
/// <author>Bernhard Bruns, Moritz Eversmann</author>
public static T DeserializeObjectFromXML <T>(String filepath)
{
TextReader reader = null;
T objectDeserialized = default(T);
try
{
reader = new StreamReader(filepath);
XmlSerializer deserializer = new XmlSerializer(typeof(T));
objectDeserialized = (T)deserializer.Deserialize(reader);
}
catch (OutOfMemoryException ex)
{
ErrorHandling.ReportErrorToUser("Error loading xml: The file you are trying to load seems to be damaged. " + ex.Message);
}
catch (FileNotFoundException ex)
{
ErrorHandling.ReportErrorToUser("Error loading xml: The file " + (ex as FileNotFoundException).FileName + " cannot be found. You need to generate and save results first!");
}
catch (InvalidOperationException ex)
{
ErrorHandling.ReportErrorToUser("Error loading xml: The xml-file is invalid. It will automatically be deleted. " + ex.Message);
reader.Close();
File.Delete(filepath);
}
catch (NotSupportedException ex)
{
ErrorHandling.ReportErrorToUser("Error: " + ex.Message + "\nFilepath: " + filepath + "\n" + ex.StackTrace);
}
catch (Exception ex)
{
if (ex is TargetInvocationException || ex is SerializationException)
{
ErrorHandling.ReportErrorToUser("Error: The file you are loading was saved with an old version of this software and can't be read.");
}
else if (ex is IOException || ex is NullReferenceException || ex is ArgumentOutOfRangeException)
{
ErrorHandling.ReportErrorToUser("Error loading xml: " + ex.Message);
}
else
{
ErrorHandling.ReportErrorToUser("Error: " + ex.Message);
}
}
finally
{
if (reader != null)
{
reader.Close();
}
}
return(objectDeserialized);
}
/// <summary>
/// Returns the Visualization of the field, creates on if it does not already exist.
/// </summary>
/// <param name="field"></param>
/// <param name="canvas"></param>
/// <param name="dragAndDrop"></param>
/// <param name="forceRedraw"></param>
/// <returns></returns>
/// <author>Jannik Arndt</author>
public static Canvas GetOrCreatePetriNetVisualization(Field field, Canvas canvas, bool dragAndDrop = true, bool forceRedraw = false)
{
PetriNetVisualizer petriNetVisualizer = new PetriNetVisualizer();
try
{
return(petriNetVisualizer.DrawPetriNet((PetriNet)field.ProcessModel, canvas, dragAndDrop, forceRedraw));
}
catch (KeyNotFoundException)
{
ErrorHandling.ReportErrorToUser("This process model cannot be viewed, probably because a loop was not properly marked.");
}
return(null);
}
/// <summary>
/// Serialize an object to xml
/// </summary>
/// <author>Bernhard Bruns, Moritz Eversmann</author>
public static void SerializeObjectToXML(String filepath, object objectToSerialize)
{
TextWriter writer = null;
try
{
XmlSerializer serializer = new XmlSerializer(objectToSerialize.GetType());
writer = new StreamWriter(filepath);
serializer.Serialize(writer, objectToSerialize);
}
catch (SEHException ex)
{
ErrorHandling.ReportErrorToUser("Error while serialize object to xml: " + ex.Message + "\n" + (ex as SEHException).StackTrace);
}
catch (UnauthorizedAccessException ex)
{
ErrorHandling.ReportErrorToUser("Error while serialize object to xml: Unauthorized Access: " + ex.Message + "\n" + (ex as UnauthorizedAccessException).StackTrace);
}
catch (NotSupportedException ex)
{
ErrorHandling.ReportErrorToUser("Error: " + ex.Message + "\nFilename: " + filepath + "\n" + ex.StackTrace);
}
catch (Exception ex)
{
if (ex is ArgumentNullException || ex is IOException || ex is NullReferenceException || ex is ArgumentOutOfRangeException)
{
ErrorHandling.ReportErrorToUser("Error: " + ex.Message);
}
else
{
throw;
}
}
finally
{
if (writer != null)
{
writer.Close();
}
}
}
/// <summary>
/// Deserialize the database settings from a file (DatabaseSettings.mpm)
/// </summary>
/// <author>Bernhard Bruns, Moritz Eversmann</author>
public static bool LoadConnectionParameters()
{
if (File.Exists(AppDomain.CurrentDomain.BaseDirectory + @"\DatabaseSettings.mpm"))
{
try
{
ConnectionParametersList = Serializer.Deserialize <List <ConnectionParameters> >("DatabaseSettings.mpm");
return(true);
}
catch (OutOfMemoryException ex)
{
ErrorHandling.ReportErrorToUser("Error loading database settings: The file you are trying to load seems to be damaged. " + ex.Message);
}
catch (FileNotFoundException ex)
{
ErrorHandling.ReportErrorToUser("Error loading database settings: The file " + ex.FileName + " cannot be found.");
}
catch (SerializationException)
{
ErrorHandling.ReportErrorToUser("Error: The file you are loading was saved with an old version of this software and can't be read. It will automatically be deleted.");
File.Delete(AppDomain.CurrentDomain.BaseDirectory + @"\DatabaseSettings.mpm");
}
catch (Exception ex)
{
if (ex is IOException || ex is NullReferenceException || ex is ArgumentOutOfRangeException)
{
ErrorHandling.ReportErrorToUser("Error loading database settings: " + ex.Message);
}
else
{
throw;
}
return(false);
}
}
else
{
ConnectionParametersList = new List <ConnectionParameters>();
}
return(false);
}
//public static bool DeleteMetaDataXML(ConnectionParameters conParams)
//{
// String DBDatabaseWithoutPathName = conParams.Database.Substring(conParams.Database.LastIndexOf(("\\")) + 1);
// Path = AppDomain.CurrentDomain.BaseDirectory + @"\Metadata_" + DBDatabaseWithoutPathName + "@" + conParams.Host + ".xml";
// if (File.Exists(Path))
// {
// try
// {
// File.Delete(Path);
// }
// catch {
// return false;
// }
// }
// return true;
//}
/// <summary>
/// <summary>
/// Writes the content from the xml-file to the FactTable if the xml exists
/// </summary>
/// <author>Bernhard Bruns, Moritz Eversmann</author>
public static bool SynchronizeFactTableWithXML(ConnectionParameters conParams)
{
try
{
//Databasename without Path and without backslashes. The SQLite-Databasename is the directory Path to the database.
String dbDatabaseWithoutPathName = conParams.Database.Substring(conParams.Database.LastIndexOf(("\\")) + 1);
Path = AppDomain.CurrentDomain.BaseDirectory + @"\Metadata_" + dbDatabaseWithoutPathName + "@" + conParams.Host + ".xml";
if (File.Exists(Path))
{
XmlMetadata = DeserializeObjectFromXML <MetaDataRepository>(Path);
if (XmlMetadata != null)
{
if (CompareXMLWithMetadata(DBWorker.MetaData, XmlMetadata))
{
DBWorker.MetaData.EventClassifier = XmlMetadata.EventClassifier;
for (int i = 0; i < DBWorker.MetaData.ListOfFactDimensions.Count; i++)
{
GetMetadataFromXMLAndWriteInFacttable(DBWorker.MetaData.ListOfFactDimensions[i], XmlMetadata.ListOfFactDimensions[i], true);
}
return(true);
}
}
}
}
catch (NullReferenceException ex)
{
ErrorHandling.ReportErrorToUser("Error synchronize facttable: " + ex.Message);
}
catch (Exception ex)
{
ErrorHandling.ReportErrorToUser("Error synchronize facttable: " + ex.Message);
}
return(false);
}
/// <summary>
/// Configures and opens a database connection
/// Builds the metadata repository and loads the xml-serialized metadata-file.
/// Navigates to page P2Metadata
/// </summary>
/// <param name="conParams"></param>
/// <returns></returns>
/// <author>Bernhard Bruns, Moritz Eversmann, Bernd Nottbeck</author>
public static bool EstablishDatabaseConnection(ConnectionParameters conParams)
{
try
{
if (DBWorker.ConfigureDBConnection(conParams))
{
DBWorker.OpenConnection();
MainWindow.ConnectionName = DBWorker.GetConnectionName();
DBWorker.BuildMetadataRepository();
XMLHelper.SynchronizeFactTableWithXML(conParams);
DefaultEventClassifierIsSelected = false;
if (DBWorker.MetaData.EventClassifier == "")
{
DefaultEventClassifierIsSelected = true;
if (DBWorker.MetaData.ListOfEventsTableColumnNames.Contains("PROC_DESCRIPTION"))
{
DBWorker.MetaData.EventClassifier = "PROC_DESCRIPTION";
}
else if (DBWorker.MetaData.ListOfEventsTableColumnNames.Contains("activity"))
{
DBWorker.MetaData.EventClassifier = "activity";
}
else if (DBWorker.MetaData.ListOfEventsTableColumnNames.Contains("ACTIVITY"))
{
DBWorker.MetaData.EventClassifier = "ACTIVITY";
}
else
{
DefaultEventClassifierIsSelected = false;
}
}
NavigationCommands.GoToPage.Execute("/Pages/P2metadata.xaml", null);
}
return(true);
}
catch (TypeInitializationException ex)
{
ErrorHandling.ReportErrorToUser("Error: Type initialization. " + ex.Message);
}
catch (NoParamsGivenException)
{
ErrorHandling.ReportErrorToUser("Error: No databasefields are filled.");
}
catch (DBException ex)
{
ErrorHandling.ReportErrorToUser("Database error: " + ex.Message);
}
catch (TimeoutException ex)
{
ErrorHandling.ReportErrorToUser("Database Timeout: " + ex.Message);
}
catch (Exception ex)
{
ErrorHandling.ReportErrorToUser("Error: " + ex.Message + " " + ex.StackTrace);
}
return(false);
}
