/// <summary>
/// Constructor
/// </summary>
/// <param name="backendProviderType">Type of backend provider to create.</param>
/// <param name="ui">The UI service.</param>
/// <param name="dirs">The directories service.</param>
/// <param name="settings">The FDO settings.</param>
internal FdoServiceLocatorFactory(FDOBackendProviderType backendProviderType, IFdoUI ui, IFdoDirectories dirs, FdoSettings settings)
{
m_backendProviderType = backendProviderType;
m_ui = ui;
m_dirs = dirs;
m_settings = settings;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="ProjectId"/> class.
/// </summary>
/// <param name="type">The type of BEP.</param>
/// <param name="name">The project name (for local projects, this can be a filename).
/// </param>
/// <param name="server">The remote host name or <c>null</c> for a local project.
/// </param>
/// ------------------------------------------------------------------------------------
public ProjectId(FDOBackendProviderType type, string name, string server)
{
Debug.Assert(type != FDOBackendProviderType.kMemoryOnly);
m_type = type;
m_path = CleanUpNameForType(type, name, server);
if (Type == FDOBackendProviderType.kDb4oClientServer)
{
m_serverName = ResolveServer(server);
}
}
public void PortAllBEPsTestsUsingAnUnopenedSource(
[Values(FDOBackendProviderType.kXML, FDOBackendProviderType.kDb4oClientServer)]
FDOBackendProviderType sourceType,
[Values(FDOBackendProviderType.kXML, FDOBackendProviderType.kDb4oClientServer, FDOBackendProviderType.kMemoryOnly)]
FDOBackendProviderType targetType)
{
var path = Path.Combine(Path.GetTempPath(), "FieldWorksTest");
if (!Directory.Exists(path))
{
Directory.CreateDirectory(path);
}
var sourceBackendStartupParameters = GenerateBackendStartupParameters(false, sourceType);
var targetBackendStartupParameters = GenerateBackendStartupParameters(true, targetType);
var sourceGuids = new List <Guid>();
// Make sure we start from a clean slate
DeleteDatabase(sourceBackendStartupParameters);
DeleteDatabase(targetBackendStartupParameters);
// Set up data source
var projId = new TestProjectId(sourceBackendStartupParameters.ProjectId.Type,
sourceBackendStartupParameters.ProjectId.Path);
using (FdoCache sourceCache = FdoCache.CreateCacheWithNewBlankLangProj(
projId, "en", "fr", "en", new DummyFdoUI(), FwDirectoryFinder.FdoDirectories, new FdoSettings()))
{
// BEP is a singleton, so we shouldn't call Dispose on it. This will be done
// by service locator.
var sourceDataSetup = GetMainBEPInterface(sourceCache);
sourceCache.ServiceLocator.GetInstance <IUndoStackManager>().Save(); // persist the new db so we can reopen it.
sourceDataSetup.LoadDomain(BackendBulkLoadDomain.All);
sourceGuids.AddRange(GetAllCmObjects(sourceCache).Select(obj => obj.Guid)); // Collect all source Guids
}
// Migrate source data to new BEP.
IThreadedProgress progressDlg = new DummyProgressDlg();
using (var targetCache = FdoCache.CreateCacheWithNoLangProj(
new TestProjectId(targetBackendStartupParameters.ProjectId.Type, null), "en", new DummyFdoUI(), FwDirectoryFinder.FdoDirectories, new FdoSettings()))
{
// BEP is a singleton, so we shouldn't call Dispose on it. This will be done
// by service locator.
var targetDataSetup = GetMainBEPInterface(targetCache);
targetDataSetup.InitializeFromSource(new TestProjectId(targetBackendStartupParameters.ProjectId.Type,
targetBackendStartupParameters.ProjectId.Path), sourceBackendStartupParameters, "en", progressDlg);
targetDataSetup.LoadDomain(BackendBulkLoadDomain.All);
CompareResults(sourceGuids, targetCache);
}
sourceGuids.Clear();
// Try to clean up after ourselves
DeleteDatabase(sourceBackendStartupParameters, false);
DeleteDatabase(targetBackendStartupParameters, false);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Protected constructor for initialization in tests
/// </summary>
/// <param name="projectsRootFolder">The root folder for projects (typically the
/// default, but if these setings represent a project elsewhere, then this will be the
/// root folder for this project).</param>
/// <param name="projectName">Name of the project.</param>
/// <param name="linkedFilesPath">The linked files path.</param>
/// <param name="sharedProjectFolder">A possibly alternate project path that
/// should be used for things that should be shared.</param>
/// <param name="originalProjType">Type of the project before converting for backup.</param>
/// <param name="destFolder">The destination folder.</param>
/// ------------------------------------------------------------------------------------
protected BackupProjectSettings(string projectsRootFolder, string projectName,
string linkedFilesPath, string sharedProjectFolder, FDOBackendProviderType originalProjType, string destFolder) :
base(projectsRootFolder, linkedFilesPath, sharedProjectFolder)
{
ProjectName = projectName;
DbVersion = FDOBackendProvider.ModelVersion;
FwVersion = new VersionInfoProvider(Assembly.GetExecutingAssembly(), false).MajorVersion;
// For DB4o projects, we need to convert them over to XML. We can't put the
// converted project in the same directory so we convert them to a temporary
// directory (see FWR-2813).
DatabaseFolder = (originalProjType == FDOBackendProviderType.kXML || originalProjType == FDOBackendProviderType.kSharedXML) ? ProjectPath : Path.GetTempPath();
DestinationFolder = destFolder;
BackupTime = DateTime.Now;
}
public void CleanUpNameForType_Default_onlyName()
{
m_defaultBepType = FDOBackendProviderType.kDb4oClientServer;
string expectedPath = Path.Combine(Path.Combine(DirectoryFinder.ProjectsDirectory, "ape"),
DirectoryFinder.GetDb4oDataFileName("ape"));
m_localCsSvcs.Stub(cs => cs.IdForLocalProject("ape")).Return(expectedPath);
m_mockFileOs.AddExistingFile(expectedPath);
ProjectId proj = new ProjectId("ape", null);
Assert.AreEqual(expectedPath, proj.Path);
Assert.AreEqual(FDOBackendProviderType.kDb4oClientServer, proj.Type);
Assert.IsTrue(proj.IsValid);
}
public ProjectIdentifier(string projectPath)
{
Path = System.IO.Path.GetFullPath(projectPath);
string ext = System.IO.Path.GetExtension(Path);
switch (ext.ToLowerInvariant())
{
case FdoFileHelper.ksFwDataXmlFileExtension:
m_backendProviderType = FDOBackendProviderType.kXML;
break;
case FdoFileHelper.ksFwDataDb4oFileExtension:
m_backendProviderType = FDOBackendProviderType.kDb4oClientServer;
break;
}
}
private void ConvertToTargetBEP(FdoCache originalCache, FDOBackendProviderType bepType, string targetPathname, string msg)
{
// Convert to test target BEP.
TimeSpan elapsedTime;
DeleteBEP(bepType, targetPathname);
var start = DateTime.Now;
using (var targetCache = FdoCache.CreateCacheCopy(bepType, new object[] { targetPathname }, "en", originalCache))
{
//var dataSetup = targetCache.ServiceLocator.GetInstance<IDataSetup>();
//dataSetup.CreateNewLanguageProject(new object[] { targetPathname }, originalCache);
elapsedTime = DateTime.Now - start;
}
MessageBox.Show(this, msg + elapsedTime.TotalMilliseconds);
}
private BackendStartupParameter GenerateBackendStartupParameters(bool isTarget, FDOBackendProviderType type)
{
var nameSuffix = (isTarget ? "_New" : "") + m_random.Next(1000);
string name = null;
switch (type)
{
case FDOBackendProviderType.kXML:
name = FdoFileHelper.GetXmlDataFileName("TLP" + nameSuffix);
break;
case FDOBackendProviderType.kDb4oClientServer:
name = "TLPCS" + nameSuffix;
break;
//case FDOBackendProviderType.kMemoryOnly: name = null;
}
return new BackendStartupParameter(true, BackendBulkLoadDomain.All, new TestProjectId(type, name));
}
public void PortAllBEPsTestsUsingAnAlreadyOpenedSource(
[Values(FDOBackendProviderType.kXML, FDOBackendProviderType.kDb4oClientServer, FDOBackendProviderType.kMemoryOnly)]
FDOBackendProviderType sourceType,
[Values(FDOBackendProviderType.kXML, FDOBackendProviderType.kDb4oClientServer, FDOBackendProviderType.kMemoryOnly)]
FDOBackendProviderType targetType)
{
var sourceBackendStartupParameters = GenerateBackendStartupParameters(false, sourceType);
var targetBackendStartupParameters = GenerateBackendStartupParameters(true, targetType);
// Make sure we start from a clean slate
DeleteDatabase(sourceBackendStartupParameters);
// Set up data source, but only do it once.
var sourceGuids = new List <Guid>();
using (var sourceCache = FdoCache.CreateCacheWithNewBlankLangProj(
new TestProjectId(sourceBackendStartupParameters.ProjectId.Type,
sourceBackendStartupParameters.ProjectId.Path), "en", "fr", "en", new DummyFdoUI(), FwDirectoryFinder.FdoDirectories, new FdoSettings()))
{
// BEP is a singleton, so we shouldn't call Dispose on it. This will be done
// by service locator.
var sourceDataSetup = GetMainBEPInterface(sourceCache);
// The source is created ex nihilo.
sourceDataSetup.LoadDomain(sourceBackendStartupParameters.BulkLoadDomain);
sourceGuids.AddRange(GetAllCmObjects(sourceCache).Select(obj => obj.Guid)); // Collect all source Guids
DeleteDatabase(targetBackendStartupParameters);
// Migrate source data to new BEP.
using (var targetCache = FdoCache.CreateCacheCopy(
new TestProjectId(targetBackendStartupParameters.ProjectId.Type,
targetBackendStartupParameters.ProjectId.Path), "en", new DummyFdoUI(), FwDirectoryFinder.FdoDirectories, new FdoSettings(), sourceCache))
{
// BEP is a singleton, so we shouldn't call Dispose on it. This will be done
// by service locator.
var targetDataSetup = GetMainBEPInterface(targetCache);
targetDataSetup.LoadDomain(BackendBulkLoadDomain.All);
CompareResults(sourceGuids, targetCache);
}
}
// Try to clean up after ourselves
DeleteDatabase(sourceBackendStartupParameters, false);
DeleteDatabase(targetBackendStartupParameters, false);
}
/// <summary>
/// Delete a backend provider.
/// </summary>
/// <param name="bepType"></Type of parameter>
/// <param name="fileName"></File name to delete>
// TODO (SteveMiller/RandyR): Replace this method with the RemoveBackend() method.
// TODO This will properly remove files as each back end provider prefers.
// TODO Currently this works only because of a MySQL capability that doesn't need
// TODO the file to be deleted ahead of time.
private static void DeleteBEP(
FDOBackendProviderType bepType, string fileName)
{
#if USING_MYSQL
if (bepType != FDOBackendProviderType.kMySqlClientServer &&
bepType != FDOBackendProviderType.kMySqlClientServerInnoDB)
{
if (File.Exists(fileName))
{
File.Delete(fileName);
}
}
#else
if (File.Exists(fileName))
{
File.Delete(fileName);
}
#endif
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Cleans the name of the project given the project type. (e.g. For an XML type, this
/// will ensure that the name is rooted and ends with the correct extension)
/// </summary>
/// <param name="type">The type of the project.</param>
/// <param name="name">The name of the project.</param>
/// <param name="server">The name or IP address of the server (or <c>null</c> for a
/// local project).</param>
/// <returns>The cleaned up name with the appropriate extension</returns>
/// ------------------------------------------------------------------------------------
private static string CleanUpNameForType(FDOBackendProviderType type, string name, string server)
{
if (string.IsNullOrEmpty(name))
{
return(null);
}
string ext;
switch (type)
{
case FDOBackendProviderType.kXML:
ext = FdoFileHelper.ksFwDataXmlFileExtension;
break;
case FDOBackendProviderType.kDb4oClientServer:
if (!IsServerLocal(server))
{
return(name);
}
ext = FdoFileHelper.ksFwDataDb4oFileExtension;
break;
default:
return(name);
}
if (!SysPath.IsPathRooted(name))
{
string sProjName = (SysPath.GetExtension(name) == ext) ? SysPath.GetFileNameWithoutExtension(name) : name;
name = SysPath.Combine(SysPath.Combine(FwDirectoryFinder.ProjectsDirectory, sProjName), name);
}
// If the file doesn't have the expected extension and exists with the extension or
// does not exist without it, we add the expected extension.
if (SysPath.GetExtension(name) != ext && (FileUtils.SimilarFileExists(name + ext) || !FileUtils.SimilarFileExists(name)))
{
name += ext;
}
return(name);
}
private void LoadSource(FDOBackendProviderType bepType, string sourcePathname, string msg)
{
// Do a dry run, to get it precompiled.
using (var cache = FdoCache.CreateCacheFromExistingData(bepType, new object[] { sourcePathname }, "en"))
{
}
// Do a load for each count.
var elapsedTime = new TimeSpan(0);
for (var i = 0; i < numericUpDown1.Value; ++i)
{
var start = DateTime.Now;
using (var cache = FdoCache.CreateCacheFromExistingData(bepType, new object[] { sourcePathname }, "en"))
{
//var dataSetup = cache.ServiceLocator.GetInstance<IDataSetup>();
//dataSetup.StartupExtantLanguageProject(new object[] { sourcePathname });
elapsedTime += DateTime.Now - start;
}
}
MessageBox.Show(this, string.Format("Average time to load {0}: {1}",
msg, elapsedTime.TotalMilliseconds / (int)numericUpDown1.Value));
}
private void Import(FdoCache originalCache, FDOBackendProviderType bepType, string msg, string exportedPathname)
{
DeleteBEP(bepType, exportedPathname);
if (m_timingRun)
{
// Do a dry run, to get it precomplied.
using (var cache = FdoCache.CreateCacheCopy(bepType, new object[] { exportedPathname }, "en", originalCache))
{
//var dataSetup = cache.ServiceLocator.GetInstance<IDataSetup>();
//dataSetup.CreateNewLanguageProject(new object[] {exportedPathname}, originalCache);
}
}
// Do an export for each count.
var elapsedTime = new TimeSpan(0);
int runCount = m_timingRun ? (int)numericUpDown1.Value : 1;
for (var i = 0; i < runCount; ++i)
{
DeleteBEP(bepType, exportedPathname);
var start = DateTime.Now;
using (var cache = FdoCache.CreateCacheCopy(bepType, new object[] { exportedPathname }, "en", originalCache))
{
//var dataSetup = cache.ServiceLocator.GetInstance<IDataSetup>();
//dataSetup.CreateNewLanguageProject(new object[] { exportedPathname }, originalCache);
elapsedTime += DateTime.Now - start;
}
}
if (m_timingRun)
{
DeleteBEP(bepType, exportedPathname);
}
MessageBox.Show(this, string.Format("Average time to import from XML to {0}: {1}", msg, elapsedTime.TotalMilliseconds / runCount));
}
private void Import(FdoCache originalCache, FDOBackendProviderType bepType, string msg, string exportedPathname)
{
DeleteBEP(bepType, exportedPathname);
if (m_timingRun)
{
// Do a dry run, to get it precomplied.
using (var cache = FdoCache.CreateCacheCopy(bepType, new object[] {exportedPathname}, "en", originalCache))
{
//var dataSetup = cache.ServiceLocator.GetInstance<IDataSetup>();
//dataSetup.CreateNewLanguageProject(new object[] {exportedPathname}, originalCache);
}
}
// Do an export for each count.
var elapsedTime = new TimeSpan(0);
int runCount = m_timingRun ? (int)numericUpDown1.Value : 1;
for (var i = 0; i < runCount; ++i)
{
DeleteBEP(bepType, exportedPathname);
var start = DateTime.Now;
using (var cache = FdoCache.CreateCacheCopy(bepType, new object[] {exportedPathname}, "en", originalCache))
{
//var dataSetup = cache.ServiceLocator.GetInstance<IDataSetup>();
//dataSetup.CreateNewLanguageProject(new object[] { exportedPathname }, originalCache);
elapsedTime += DateTime.Now - start;
}
}
if (m_timingRun)
DeleteBEP(bepType, exportedPathname);
MessageBox.Show(this, string.Format("Average time to import from XML to {0}: {1}", msg, elapsedTime.TotalMilliseconds / runCount));
}
public void Setup()
{
m_defaultBepType = FDOBackendProviderType.kXML;
m_mockFileOs = new MockFileOS();
FileUtils.Manager.SetFileAdapter(m_mockFileOs);
}
public void CleanUpNameForType_Default_onlyName()
{
m_defaultBepType = FDOBackendProviderType.kDb4oClientServer;
string expectedPath = Path.Combine(Path.Combine(FwDirectoryFinder.ProjectsDirectory, "ape"),
FdoFileHelper.GetDb4oDataFileName("ape"));
m_localCsSvcs.Stub(cs => cs.IdForLocalProject("ape")).Return(expectedPath);
m_mockFileOs.AddExistingFile(expectedPath);
ProjectId proj = new ProjectId("ape", null);
Assert.AreEqual(expectedPath, proj.Path);
Assert.AreEqual(FDOBackendProviderType.kDb4oClientServer, proj.Type);
Assert.IsTrue(proj.IsValid);
}
private BackendStartupParameter GenerateBackendStartupParameters(bool isTarget, FDOBackendProviderType type)
{
var nameSuffix = (isTarget ? "_New" : "") + m_random.Next(1000);
string name = null;
switch (type)
{
case FDOBackendProviderType.kXML:
name = FdoFileHelper.GetXmlDataFileName("TLP" + nameSuffix);
break;
case FDOBackendProviderType.kDb4oClientServer:
name = "TLPCS" + nameSuffix;
break;
//case FDOBackendProviderType.kMemoryOnly: name = null;
}
return(new BackendStartupParameter(true, BackendBulkLoadDomain.All, new TestProjectId(type, name)));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="BrowserProjectId"/> class.
/// </summary>
/// ------------------------------------------------------------------------------------
public BrowserProjectId(FDOBackendProviderType type, string name)
{
m_type = type;
Path = name;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Constructor used for testing
/// </summary>
/// <param name="projectsRootFolder">The root folder for projects (typically the
/// default, but if these setings represent a project elsewhere, then this will be the
/// root folder for this project).</param>
/// <param name="projectName">Name of the project.</param>
/// <param name="linkedFilesRootDir">Path for the location of the LinkedFiles. (null for most tests)</param>
/// <param name="originalProjType">Type of the project before converting for backup.</param>
/// ------------------------------------------------------------------------------------
internal DummyBackupProjectSettings(string projectsRootFolder, string projectName, string linkedFilesRootDir,
FDOBackendProviderType originalProjType) :
base(projectsRootFolder, projectName, linkedFilesRootDir, null, originalProjType)
{
}
public ParatextLexiconPluginProjectID(FDOBackendProviderType backendProviderType, string projectPath)
{
m_backendProviderType = backendProviderType;
Path = projectPath;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="ProjectId"/> class.
/// </summary>
/// <param name="type">The type of BEP.</param>
/// <param name="name">The project name (for local projects, this can be a filename).
/// </param>
/// <param name="server">The remote host name or <c>null</c> for a local project.
/// </param>
/// ------------------------------------------------------------------------------------
public ProjectId(FDOBackendProviderType type, string name, string server)
{
Debug.Assert(type != FDOBackendProviderType.kMemoryOnly);
m_type = type;
m_path = CleanUpNameForType(type, name, server);
if (Type == FDOBackendProviderType.kDb4oClientServer)
m_serverName = ResolveServer(server);
}
public ParatextLexiconPluginProjectID(FDOBackendProviderType backendProviderType, string projectPath)
{
m_backendProviderType = backendProviderType;
Path = projectPath;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Constructor
/// </summary>
/// <param name="backendProviderType">Type of backend provider to create.</param>
/// ------------------------------------------------------------------------------------
internal FdoServiceLocatorFactory(FDOBackendProviderType backendProviderType)
{
m_backendProviderType = backendProviderType;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Constructor used for testing
/// </summary>
/// <param name="projectsRootFolder">The root folder for projects (typically the
/// default, but if these setings represent a project elsewhere, then this will be the
/// root folder for this project).</param>
/// <param name="projectName">Name of the project.</param>
/// <param name="linkedFilesRootDir">Path for the location of the LinkedFiles. (null for most tests)</param>
/// <param name="originalProjType">Type of the project before converting for backup.</param>
/// ------------------------------------------------------------------------------------
internal DummyBackupProjectSettings(string projectsRootFolder, string projectName, string linkedFilesRootDir,
FDOBackendProviderType originalProjType) :
base(projectsRootFolder, projectName, linkedFilesRootDir, null, originalProjType, FwDirectoryFinder.DefaultBackupDirectory)
{
}
private void LoadSource(FDOBackendProviderType bepType, string sourcePathname, string msg)
{
// Do a dry run, to get it precompiled.
using (var cache = FdoCache.CreateCacheFromExistingData(bepType, new object[] {sourcePathname}, "en"))
{
}
// Do a load for each count.
var elapsedTime = new TimeSpan(0);
for (var i = 0; i < numericUpDown1.Value; ++i)
{
var start = DateTime.Now;
using (var cache = FdoCache.CreateCacheFromExistingData(bepType, new object[] {sourcePathname}, "en"))
{
//var dataSetup = cache.ServiceLocator.GetInstance<IDataSetup>();
//dataSetup.StartupExtantLanguageProject(new object[] { sourcePathname });
elapsedTime += DateTime.Now - start;
}
}
MessageBox.Show(this, string.Format("Average time to load {0}: {1}",
msg, elapsedTime.TotalMilliseconds / (int)numericUpDown1.Value));
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Cleans the name of the project given the project type. (e.g. For an XML type, this
/// will ensure that the name is rooted and ends with the correct extension)
/// </summary>
/// <param name="type">The type of the project.</param>
/// <param name="name">The name of the project.</param>
/// <param name="server">The name or IP address of the server (or <c>null</c> for a
/// local project).</param>
/// <returns>The cleaned up name with the appropriate extension</returns>
/// ------------------------------------------------------------------------------------
private static string CleanUpNameForType(FDOBackendProviderType type, string name, string server)
{
if (string.IsNullOrEmpty(name))
return null;
string ext;
switch (type)
{
case FDOBackendProviderType.kXML:
ext = FdoFileHelper.ksFwDataXmlFileExtension;
break;
case FDOBackendProviderType.kDb4oClientServer:
if (!IsServerLocal(server))
return name;
ext = FdoFileHelper.ksFwDataDb4oFileExtension;
break;
default:
return name;
}
if (!SysPath.IsPathRooted(name))
{
string sProjName = (SysPath.GetExtension(name) == ext) ? SysPath.GetFileNameWithoutExtension(name) : name;
name = SysPath.Combine(SysPath.Combine(FwDirectoryFinder.ProjectsDirectory, sProjName), name);
}
// If the file doesn't have the expected extension and exists with the extension or
// does not exist without it, we add the expected extension.
if (SysPath.GetExtension(name) != ext && (FileUtils.SimilarFileExists(name + ext) || !FileUtils.SimilarFileExists(name)))
name += ext;
return name;
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Protected constructor for initialization in tests
/// </summary>
/// <param name="projectsRootFolder">The root folder for projects (typically the
/// default, but if these setings represent a project elsewhere, then this will be the
/// root folder for this project).</param>
/// <param name="projectName">Name of the project.</param>
/// <param name="linkedFilesPath">The linked files path.</param>
/// <param name="sharedProjectFolder">A possibly alternate project path that
/// should be used for things that should be shared.</param>
/// <param name="originalProjType">Type of the project before converting for backup.</param>
/// <param name="destFolder">The destination folder.</param>
/// ------------------------------------------------------------------------------------
protected BackupProjectSettings(string projectsRootFolder, string projectName,
string linkedFilesPath, string sharedProjectFolder, FDOBackendProviderType originalProjType, string destFolder) :
base(projectsRootFolder, linkedFilesPath, sharedProjectFolder)
{
ProjectName = projectName;
DbVersion = FDOBackendProvider.ModelVersion;
FwVersion = new VersionInfoProvider(Assembly.GetExecutingAssembly(), false).MajorVersion;
// For DB4o projects, we need to convert them over to XML. We can't put the
// converted project in the same directory so we convert them to a temporary
// directory (see FWR-2813).
DatabaseFolder = (originalProjType == FDOBackendProviderType.kXML || originalProjType == FDOBackendProviderType.kSharedXML) ? ProjectPath : Path.GetTempPath();
DestinationFolder = destFolder;
BackupTime = DateTime.Now;
}
public void Setup()
{
m_defaultBepType = FDOBackendProviderType.kXML;
m_mockFileOs = new MockFileOS();
FileUtils.Manager.SetFileAdapter(m_mockFileOs);
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="SimpleProjectId"/> class.
/// </summary>
/// ------------------------------------------------------------------------------------
public SimpleProjectId(FDOBackendProviderType type, string name)
{
m_type = type;
Path = name;
}
/// <summary>
/// Delete a backend provider.
/// </summary>
/// <param name="bepType"></Type of parameter>
/// <param name="fileName"></File name to delete>
// TODO (SteveMiller/RandyR): Replace this method with the RemoveBackend() method.
// TODO This will properly remove files as each back end provider prefers.
// TODO Currently this works only because of a MySQL capability that doesn't need
// TODO the file to be deleted ahead of time.
private static void DeleteBEP(
FDOBackendProviderType bepType, string fileName)
{
#if USING_MYSQL
if (bepType != FDOBackendProviderType.kMySqlClientServer &&
bepType != FDOBackendProviderType.kMySqlClientServerInnoDB)
{
if (File.Exists(fileName))
File.Delete(fileName);
}
#else
if (File.Exists(fileName))
File.Delete(fileName);
#endif
}
/// ------------------------------------------------------------------------------------
/// <summary>
/// Initializes a new instance of the <see cref="TestProjectId"/> class.
/// </summary>
/// ------------------------------------------------------------------------------------
public TestProjectId(FDOBackendProviderType type, string name)
{
m_type = type;
Path = name;
}
private void ConvertToTargetBEP(FdoCache originalCache, FDOBackendProviderType bepType, string targetPathname, string msg)
{
// Convert to test target BEP.
TimeSpan elapsedTime;
DeleteBEP(bepType, targetPathname);
var start = DateTime.Now;
using (var targetCache = FdoCache.CreateCacheCopy(bepType, new object[] { targetPathname }, "en", originalCache))
{
//var dataSetup = targetCache.ServiceLocator.GetInstance<IDataSetup>();
//dataSetup.CreateNewLanguageProject(new object[] { targetPathname }, originalCache);
elapsedTime = DateTime.Now - start;
}
MessageBox.Show(this, msg + elapsedTime.TotalMilliseconds);
}
