public void SetupTest()
{
string solutionDirectoryPath = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(System.IO.Directory.GetCurrentDirectory())));
_InterfaceDefinitionDirectoryPath = Path.Combine(solutionDirectoryPath, @"_TestData\InterfaceBooster\InterfaceDefinition");
_InterfaceDefinitionXmlFilePath = Path.Combine(_InterfaceDefinitionDirectoryPath, "interfaceDefinition.xml");
_InterfaceDefinitionData = InterfaceDefinitionDataController.Load(_InterfaceDefinitionXmlFilePath);
}
public void Dispose()
{
_IsInitialized = false;
_InterfaceDefinitionData = null;
_Broadcaster = null;
_SyneryClient = null;
EnvironmentVariables = null;
if (_SyneryDB != null)
{
_SyneryDB.Dispose();
}
}
private void SaveDefintion(string interfaceDefinitionFilePath, InterfaceDefinitionData data)
{
using (StreamWriter writer = new StreamWriter(interfaceDefinitionFilePath, false, USED_ENCODING))
{
using (XmlWriter xmlWriter = XmlWriter.Create(writer, new XmlWriterSettings()
{
Indent = true, NewLineHandling = NewLineHandling.Entitize
}))
{
XmlSerializer s = new XmlSerializer(data.GetType());
s.Serialize(xmlWriter, data);
}
}
}
public static void Save(string interfaceDefinitionFilePath, InterfaceDefinitionData definitionData)
{
// Validate parameters
if (interfaceDefinitionFilePath == null)
{
throw new ArgumentNullException("interfaceDefinitionFilePath", "The path of the interface definition file is required.");
}
if (definitionData == null)
{
throw new ArgumentNullException("definitionData", "The Interface Defintion data is required.");
}
InterfaceDefinitionDataController controller = new InterfaceDefinitionDataController(interfaceDefinitionFilePath);
controller.SaveDefintion(interfaceDefinitionFilePath, definitionData);
}
private InterfaceDefinitionData LoadDefinition()
{
InterfaceDefinitionData data = new InterfaceDefinitionData();
using (StreamReader reader = new StreamReader(_InterfaceDefinitionFilePath, USED_ENCODING))
{
XDocument doc = XDocument.Load(_InterfaceDefinitionFilePath);
XElement root = doc.Element("InterfaceDefinition");
data.Id = new Guid(GetRequiredAttributeValue(root, "id"));
data.Details = LoadDetails(root.Element("Details"));
data.Jobs = LoadJobs(root.Element("Jobs"));
LoadRequiredPlugins(data, root.Element("RequiredPlugins"));
}
return(data);
}
/// <summary>
/// Loads the data of an Interface definition.
/// Can throw exceptions if the loading fails.
/// </summary>
/// <param name="interfaceDefinitionFilePath">the path of the XML file</param>
/// <returns></returns>
public static InterfaceDefinitionData Load(string interfaceDefinitionFilePath)
{
// Validate parameters
if (interfaceDefinitionFilePath == null)
{
throw new ArgumentNullException("interfaceDefinitionFilePath", "The path of the interface definition file is required.");
}
if (File.Exists(interfaceDefinitionFilePath) == false)
{
throw new ArgumentException(String.Format("No interface definition found at {0}.", interfaceDefinitionFilePath), "interfaceDefinitionFilePath");
}
InterfaceDefinitionDataController controller = new InterfaceDefinitionDataController(interfaceDefinitionFilePath);
InterfaceDefinitionData data = controller.LoadDefinition();
// store the interface definition root directory path
data.RootDirectoryPath = Path.GetDirectoryName(interfaceDefinitionFilePath);
return(data);
}
/// <summary>
/// loads the data of all required plugins and appends them to the given <paramref name="data"/>.
/// </summary>
/// <param name="data"></param>
/// <param name="root"></param>
private void LoadRequiredPlugins(InterfaceDefinitionData data, XElement root)
{
data.RequiredPlugins.ProviderPluginInstances = LoadProviderPluginInstances(root.Element("ProviderPlugins"));
data.RequiredPlugins.LibraryPlugins = LoadLibraryPlugins(root.Element("LibraryPlugins"));
}
/// <summary>
/// Initialize the interface definition, the database, the plugin managers, the SyneryMemory and the SyneryInterpreter
/// This method must be called before running a job.
/// </summary>
/// <param name="environmentVariables">At least Broadcaster and InterfaceDefinitionDirectoryPath are required!</param>
/// <returns>true = success / false = error (see broadcasted messages for details)</returns>
public bool Initialize(ExecutionVariables environmentVariables)
{
IProviderPluginManager providerPluginManager;
ILibraryPluginManager libraryPluginManager;
EnvironmentVariables = environmentVariables;
// check required environment variables
if (EnvironmentVariables == null)
{
throw new ArgumentNullException("runtimeEnvironment", "The EnvironmentVariables are required.");
}
if (EnvironmentVariables.Broadcaster == null)
{
throw new ArgumentNullException("A Broadcaster is required");
}
if (EnvironmentVariables.InterfaceDefinitionDirectoryPath == null)
{
throw new ArgumentNullException("The InterfaceDefinitionDirectoryPath is required");
}
// set defaults if no values given
if (EnvironmentVariables.InterfaceDefinitionCodeDirectoryPath == null)
{
EnvironmentVariables.InterfaceDefinitionCodeDirectoryPath = Path.Combine(EnvironmentVariables.InterfaceDefinitionDirectoryPath, DEFAULT_SYNERY_CODE_DIRECTORY_RELATIVE_PATH);
}
if (EnvironmentVariables.DatabaseDirectoryPath == null)
{
EnvironmentVariables.DatabaseDirectoryPath = Path.Combine(EnvironmentVariables.InterfaceDefinitionDirectoryPath, DEFAULT_SYNERY_DATABASE_DIRECTORY_RELATIVE_PATH);
}
if (EnvironmentVariables.FilesystemDirectoryPath == null)
{
EnvironmentVariables.FilesystemDirectoryPath = Path.Combine(EnvironmentVariables.InterfaceDefinitionDirectoryPath, DEFAULT_FILESYSTEM_DIRECTORY_RELATIVE_PATH);
}
if (EnvironmentVariables.ProviderPluginDirectoryPath == null)
{
EnvironmentVariables.ProviderPluginDirectoryPath = Path.Combine(EnvironmentVariables.InterfaceDefinitionDirectoryPath, DEFAULT_PROVIDER_PLUGINS_DIRECTORY_RELATIVE_PATH);
}
if (EnvironmentVariables.LibraryPluginDirectoryPath == null)
{
EnvironmentVariables.LibraryPluginDirectoryPath = Path.Combine(EnvironmentVariables.InterfaceDefinitionDirectoryPath, DEFAULT_LIBRARY_PLUGINS_DIRECTORY_RELATIVE_PATH);
}
// create a local reference
_Broadcaster = EnvironmentVariables.Broadcaster;
// initialize the interface definition
try
{
string interfaceDefinitionFilePath = Path.Combine(EnvironmentVariables.InterfaceDefinitionDirectoryPath, INTERFACE_DEFINITION_XML_FILENAME);
_InterfaceDefinitionData = InterfaceDefinitionDataController.Load(interfaceDefinitionFilePath);
}
catch (Exception ex)
{
_Broadcaster.Error(ex);
return(false);
}
_Broadcaster.Info("Interface definition data successfully loaded.");
// initialize the Synery Database
try
{
if (Directory.Exists(EnvironmentVariables.DatabaseDirectoryPath) == false)
{
Directory.CreateDirectory(EnvironmentVariables.DatabaseDirectoryPath);
}
_SyneryDB = new SyneryDB(EnvironmentVariables.DatabaseDirectoryPath);
}
catch (SyneryDBException ex)
{
_Broadcaster.Error(ex, "SyneryDB");
return(false);
}
catch (Exception ex)
{
_Broadcaster.Error(ex);
return(false);
}
// initialize the ProviderPluginManager
try
{
providerPluginManager = new ProviderPluginManager(EnvironmentVariables.ProviderPluginDirectoryPath);
// activate the provider plugin instance references from the interface definition
providerPluginManager.Activate(_InterfaceDefinitionData.RequiredPlugins.ProviderPluginInstances);
}
catch (ProviderPluginManagerException ex)
{
_Broadcaster.Error(ex, "ProviderPluginManager");
return(false);
}
catch (Exception ex)
{
_Broadcaster.Error(ex);
return(false);
}
// initialize the LibraryPluginManager
try
{
libraryPluginManager = new LibraryPluginManager(EnvironmentVariables.LibraryPluginDirectoryPath);
// activate the provider plugin instance references from the interface definition
libraryPluginManager.Activate(_InterfaceDefinitionData.RequiredPlugins.LibraryPlugins);
}
catch (LibraryPluginManagerException ex)
{
_Broadcaster.Error(ex, "LibraryPluginManager");
return(false);
}
catch (Exception ex)
{
_Broadcaster.Error(ex);
return(false);
}
// initialize the SyneryMemory
_SyneryMemory = new SyneryMemory(_SyneryDB, _Broadcaster, providerPluginManager, libraryPluginManager);
// initialize the SyneryInterpreter
_SyneryClient = new InterpretationClient(_SyneryMemory);
// success
_IsInitialized = true;
return(true);
}
public void Setup()
{
// Prepare the paths of the temporary XML file and the expected XML file
string solutionDirectoryPath = Path.GetDirectoryName(Path.GetDirectoryName(Path.GetDirectoryName(System.IO.Directory.GetCurrentDirectory())));
_XmlFilePath = Path.Combine(solutionDirectoryPath, @"_TestData\InterfaceBooster\InterfaceDefinition\saveInterfaceDefinition_TestFile.xml");
_ExpectedXmlFilePath = Path.Combine(solutionDirectoryPath, @"_TestData\InterfaceBooster\InterfaceDefinition\saveInterfaceDefinition_ExpectedContent.xml");
// Delete the XML file if it already exists
if (File.Exists(_XmlFilePath))
{
File.Delete(_XmlFilePath);
}
_InterfaceDefinitionData = new InterfaceDefinitionData();
// Details
_InterfaceDefinitionData.Id = new Guid("f3b58f84-cbc0-4560-856d-f6c2b2feea5b");
_InterfaceDefinitionData.Details.Name = "PROFFIX CSV Article Import";
_InterfaceDefinitionData.Details.Description = "Imports some articles from a comma separated value file to PROFFIX.";
_InterfaceDefinitionData.Details.Author = "Roger Guillet";
_InterfaceDefinitionData.Details.DateOfCreation = new DateTime(2014, 2, 7);
_InterfaceDefinitionData.Details.DateOfLastChange = new DateTime(2014, 2, 26);
_InterfaceDefinitionData.Details.Version = new Version(1, 0, 0, 1);
_InterfaceDefinitionData.Details.RequiredRuntimeVersion = new Version(1, 0, 0, 0);
// Provider Plugins
_InterfaceDefinitionData.RequiredPlugins.ProviderPluginInstances.Add(new ProviderPluginInstanceReference()
{
SyneryIdentifier = "PROFFIX",
IdPlugin = new Guid("485eccb4-3920-4dc3-9ed4-27f65e8b3c91"),
PluginName = "PROFFIX Database",
IdPluginInstance = new Guid("b139306d-a688-43ae-a9dd-4e692fc2caea"),
PluginInstanceName = "4.0.0000.0001",
});
_InterfaceDefinitionData.RequiredPlugins.ProviderPluginInstances.Add(new ProviderPluginInstanceReference()
{
SyneryIdentifier = "CSV",
IdPlugin = new Guid("66CE1D53-14B3-420E-949F-EB94A3D69072"),
PluginName = "CSV Provider Plugin",
IdPluginInstance = new Guid("F897A501-60D9-4AE5-B214-920F450E9323"),
PluginInstanceName = "CSV Version 1.0",
});
// Library Plugins
_InterfaceDefinitionData.RequiredPlugins.LibraryPlugins.Add(new LibraryPluginReference()
{
SyneryIdentifier = "String",
IdPlugin = new Guid("74A8005D-C9F3-455F-94FC-04846493AB7B"),
PluginName = "String Helpers",
});
// Jobs
var job1 = new InterfaceDefinitionJobData()
{
Id = new Guid("79f8ca0f-c785-4f35-810e-835bc216f6b6"),
Name = "Run CSV Import",
Description = "Executes the import of some articles to PROFFIX.",
EstimatedDurationRemarks = "This import will only take a few seconds",
};
job1.IncludeFiles.Add(new IncludeFile()
{
Alias = "h", RelativePath = "helperFunctions.syn"
});
var job2 = new InterfaceDefinitionJobData()
{
Id = new Guid("2D74CCFB-B1B3-4625-8763-99CFEB077207"),
Name = "Check for doublets",
Description = "Executes a check for some doublets in PROFFIX.",
EstimatedDurationRemarks = "This check will only take a few seconds",
};
job2.IncludeFiles.Add(new IncludeFile()
{
Alias = "h", RelativePath = "helperFunctions.syn"
});
job2.IncludeFiles.Add(new IncludeFile()
{
Alias = "px_con", RelativePath = "proffixConnection.syn"
});
_InterfaceDefinitionData.Jobs.Add(job1);
_InterfaceDefinitionData.Jobs.Add(job2);
}
