/// <summary>
/// Gets the path of the data file directory used by <see cref="FileDataProvider"/>s
/// managed by <c>this</c>, relative to the base uri of the <see cref="Presentation"/>
/// owning the file data provider manager.
/// </summary>
/// <returns>The path</returns>
/// <remarks>
/// The DataFileDirectory is initialized lazily:
/// If the DataFileDirectory has not been explicitly initialized using the <see cref="DataFileDirectory"/> setter,
/// retrieving <see cref="DataFileDirectory"/> will assing it the default value "Data"</remarks>
////{
//// get
//// {
//// if (mDataFileDirectory == null) mDataFileDirectory = "Data";
//// return mDataFileDirectory;
//// }
////set
////{
//// if (value == null)
//// {
//// throw new exception.MethodParameterIsNullException(
//// "The DataFileDirectory can not be null");
//// }
//// if (mDataFileDirectory != null)
//// {
//// throw new exception.IsAlreadyInitializedException(
//// "The DataProviderManager has already been initialized with a DataFileDirectory");
//// }
//// Uri tmp;
//// if (!Uri.TryCreate(value, UriKind.Relative, out tmp))
//// {
//// throw new exception.InvalidUriException(String.Format(
//// "DataFileDirectory must be a relative Uri, '{0}' is not",
//// value));
//// }
//// if (!Directory.Exists(value))
//// {
//// Directory.CreateDirectory(value);
//// }
//// mDataFileDirectory = value;
////}
////}
///// <summary>
///// Moves the data file directory of the manager
///// </summary>
///// <param name="newDataFileDir">The new data file direcotry</param>
///// <param name="deleteSource">A <see cref="bool"/> indicating if the source/old data files shlould be deleted</param>
///// <param name="overwriteDestDir">A <see cref="bool"/> indicating if the new data directory should be overwritten</param>
//public void MoveDataFiles(string newDataFileDir, bool deleteSource, bool overwriteDestDir)
//{
// if (Path.IsPathRooted(newDataFileDir))
// {
// throw new exception.MethodParameterIsOutOfBoundsException(
// "The data file directory path must be relative");
// }
// string oldPath = DataFileDirectoryFullPath;
// mDataFileDirectory = newDataFileDir;
// string newPath = DataFileDirectoryFullPath;
// try
// {
// if (Directory.Exists(newPath))
// {
// if (overwriteDestDir)
// {
// Directory.Delete(newPath);
// }
// else
// {
// throw new exception.OperationNotValidException(
// String.Format("Directory {0} already exists", newPath));
// }
// }
// CopyDataFiles(oldPath, newPath);
// if (deleteSource && Directory.Exists(oldPath))
// {
// Directory.Delete(oldPath);
// }
// }
// catch (Exception e)
// {
// throw new exception.OperationNotValidException(
// String.Format("Could not move data files to {0}: {1}", newPath, e.Message),
// e);
// }
//}
private string getDataFileDirectoryFullPath(Uri baseUri)
{
if (!baseUri.IsFile)
{
throw new exception.InvalidUriException(
"The base Uri of the presentation to which the DataProviderManager belongs must be a file Uri");
}
string localPathPresentation = baseUri.LocalPath;
if (File.Exists(localPathPresentation))
{
localPathPresentation = Path.GetDirectoryName(localPathPresentation);
}
string localPath = Path.Combine(localPathPresentation, DataFileDirectory);
//Uri dataFileDirUri = new Uri(baseUri, DataFileDirectory);
//string localPath = dataFileDirUri.LocalPath;
if (!Directory.Exists(localPath))
{
FileDataProvider.CreateDirectory(localPath);
}
return(localPath);
}
public static void MoveDirectory(string sourcePath, string destPath)
{
if (!Directory.Exists(destPath))
{
FileDataProvider.CreateDirectory(destPath);
}
foreach (string file in Directory.GetFiles(sourcePath))
{
string dest = Path.Combine(destPath, Path.GetFileName(file));
File.Move(file, dest);
try
{
File.SetAttributes(dest, FileAttributes.Normal);
}
catch
{
}
}
foreach (string folder in Directory.GetDirectories(sourcePath))
{
string dest = Path.Combine(destPath, Path.GetFileName(folder));
FileDataProvider.MoveDirectory(folder, dest);
}
FileDataProvider.DeleteDirectory(sourcePath);
}
public override bool ValueEquals(WithPresentation other)
{
if (!base.ValueEquals(other))
{
return(false);
}
FileDataProvider otherz = other as FileDataProvider;
if (otherz == null)
{
return(false);
}
if (otherz.MimeType != MimeType)
{
//System.Diagnostics.Debug.Fail("! ValueEquals !");
return(false);
}
if (Presentation.DataProviderManager.CompareByteStreamsDuringValueEqual &&
other.Presentation.DataProviderManager.CompareByteStreamsDuringValueEqual)
{
if (!DataProviderManager.CompareDataProviderContent(this, otherz))
{
//System.Diagnostics.Debug.Fail("! ValueEquals !");
return(false);
}
}
return(true);
}
/// <summary>
/// Reads the attributes of a DataProviderManager xuk element.
/// </summary>
/// <param name="source">The source <see cref="XmlReader"/></param>
protected override void XukInAttributes(XmlReader source)
{
base.XukInAttributes(source);
string dataFileDirectoryPath = source.GetAttribute(XukStrings.DataFileDirectoryPath);
if (string.IsNullOrEmpty(dataFileDirectoryPath))
{
throw new exception.XukException(
"dataFileDirectoryPath attribute is missing from DataProviderManager element");
}
DataFileDirectory = FileDataProvider.UriDecode(dataFileDirectoryPath);
}
public void CopyFileDataProvidersToDataFolder(string fullDataFolderPath)
{
if (!Directory.Exists(fullDataFolderPath))
{
FileDataProvider.CreateDirectory(fullDataFolderPath);
}
reportProgress(-1, Path.GetFileName(fullDataFolderPath));
int index = 0;
const int progressStep = 10;
int progress = progressStep;
List <FileDataProvider> list = new List <FileDataProvider>(m_Presentation.DataProviderManager.ManagedFileDataProviders);
foreach (FileDataProvider fdp in list)
{
index++;
progress = 100 * index / list.Count;
reportProgress_Throttle(progress, string.Format("{1}/{2} ({0})", fdp.DataFileRelativePath, index, list.Count));
if (RequestCancellation)
{
return;
}
string pathSource = Path.Combine(m_Presentation.DataProviderManager.DataFileDirectoryFullPath, fdp.DataFileRelativePath);
if (!File.Exists(pathSource))
{
throw new exception.DataMissingException(String.Format("File does not exist: {0}", pathSource));
}
string pathDest = Path.Combine(fullDataFolderPath, fdp.DataFileRelativePath);
if (!File.Exists(pathDest))
{
File.Copy(pathSource, pathDest);
try
{
File.SetAttributes(pathDest, FileAttributes.Normal);
}
catch
{
}
}
}
}
public void InitByMovingExistingFile(string path)
{
if (!File.Exists(path))
{
throw new exception.DataMissingException(
String.Format("The data file {0} does not exist", path));
}
if (File.Exists(DataFileFullPath))
{
throw new exception.OperationNotValidException(
String.Format("The data file {0} already exists", DataFileFullPath));
}
foreach (DataProvider dp in Presentation.DataProviderManager.ManagedObjects.ContentsAs_Enumerable)
{
if (dp is FileDataProvider)
{
FileDataProvider fdp = (FileDataProvider)dp;
if (fdp.DataFileFullPath == path)
{
throw new exception.OperationNotValidException(
String.Format("The data file {0} is already managed", path));
}
}
}
//Directory.GetParent(filePath).FullName
//if (Path.GetDirectoryName(path) != Presentation.DataProviderManager.DataFileDirectoryFullPath)
//{
// throw new exception.OperationNotValidException(
// String.Format("The data file {0} is not in the data directory {1}", path, Presentation.DataProviderManager.DataFileDirectoryFullPath));
//}
File.Move(path, DataFileFullPath);
try
{
File.SetAttributes(DataFileFullPath, FileAttributes.Normal);
}
catch
{
}
HasBeenInitialized = true;
}
/// <summary>
/// Exports <c>this</c> to a given destination <see cref="Presentation"/>
/// </summary>
/// <param name="destPres">The destination <see cref="Presentation"/></param>
/// <returns>The exported <see cref="FileDataProvider"/></returns>
public override DataProvider Export(Presentation destPres)
{
lock (m_lock)
{
FileDataProvider expFDP = destPres.DataProviderFactory.Create <FileDataProvider>(MimeType);
Stream thisStm = OpenInputStream_NoLock();
try
{
if (thisStm.Length > 0)
{
expFDP.AppendData(thisStm, thisStm.Length);
}
}
finally
{
thisStm.Close();
}
return(expFDP);
}
}
private void XukInDataProviderItem(XmlReader source, IProgressHandler handler)
{
if (!source.IsEmptyElement)
{
string uid = XukAble.ReadXukAttribute(source, XukAble.Uid_NAME);
bool addedProvider = false;
while (source.Read())
{
if (source.NodeType == XmlNodeType.Element)
{
DataProvider prov = Presentation.DataProviderFactory.Create_SkipManagerInitialization("", source.LocalName, source.NamespaceURI);
if (prov != null)
{
if (addedProvider)
{
throw new exception.XukException(
"Multiple DataProviders within the same mDataProviderItem is not supported");
}
prov.XukIn(source, handler);
//string uid_ = source.GetAttribute(XukStrings.Uid);
if (string.IsNullOrEmpty(prov.Uid) && !string.IsNullOrEmpty(uid))
{
prov.Uid = uid;
}
Presentation.DataProviderManager.AddManagedObject_NoSafetyChecks(prov, prov.Uid);
//if (IsManagerOf(prov.Uid))
//{
// if (GetManagedObject(prov.Uid) != prov)
// {
// throw new exception.XukException(
// String.Format("Another DataProvider exists in the manager with uid {0}", prov.Uid));
// }
//}
//else
//{
// SetUidOfManagedObject(prov, prov.Uid);
//}
if (prov is FileDataProvider)
{
FileDataProvider fdProv = (FileDataProvider)prov;
foreach (string path in mXukedInFilDataProviderPaths)
{
if (path.Equals(fdProv.DataFileRelativePath, StringComparison.OrdinalIgnoreCase))
{
throw new exception.XukException(String.Format(
"Another FileDataProvider using data file {0} has already been Xukked in",
fdProv.DataFileRelativePath));
}
}
if (!File.Exists(fdProv.DataFileFullPath))
{
Presentation.DataProviderManager.RemoveManagedObject(fdProv);
return;
}
mXukedInFilDataProviderPaths.Add(fdProv.DataFileRelativePath);
}
addedProvider = true;
}
else if (!source.IsEmptyElement)
{
source.ReadSubtree().Close();
}
}
else if (source.NodeType == XmlNodeType.EndElement)
{
break;
}
if (source.EOF)
{
throw new exception.XukException("Unexpectedly reached EOF");
}
}
}
}
private void XukInDataProvider(XmlReader source, IProgressHandler handler)
{
if (source.NodeType == XmlNodeType.Element)
{
DataProvider prov = Presentation.DataProviderFactory.Create_SkipManagerInitialization("", source.LocalName, source.NamespaceURI);
if (prov != null)
{
prov.XukIn(source, handler);
//if (prov is FileDataProvider
// && !File.Exists(((FileDataProvider)prov).DataFileFullPath))
//{
// SEE BELOW
//}
//string uid = source.GetAttribute(XukStrings.Uid);
if (string.IsNullOrEmpty(prov.Uid))
{
throw new exception.XukException("uid attribute of mDataProviderItem element is missing");
}
Presentation.DataProviderManager.AddManagedObject_NoSafetyChecks(prov, prov.Uid);
//if (IsManagerOf(prov.Uid))
//{
// if (GetManagedObject(prov.Uid) != prov)
// {
// throw new exception.XukException(
// String.Format("Another DataProvider exists in the manager with uid {0}", prov.Uid));
// }
//}
//else
//{
// SetUidOfManagedObject(prov, prov.Uid);
//}
if (prov is FileDataProvider)
{
FileDataProvider fdProv = (FileDataProvider)prov;
foreach (string path in mXukedInFilDataProviderPaths)
{
if (path.Equals(fdProv.DataFileRelativePath, StringComparison.OrdinalIgnoreCase))
{
throw new exception.XukException(String.Format(
"Another FileDataProvider using data file {0} has already been Xukked in",
fdProv.DataFileRelativePath));
}
}
if (!File.Exists(fdProv.DataFileFullPath))
{
Presentation.DataProviderManager.RemoveManagedObject(prov);
return;
}
mXukedInFilDataProviderPaths.Add(fdProv.DataFileRelativePath);
}
}
else if (!source.IsEmptyElement)
{
source.ReadSubtree().Close();
}
}
}
/// <summary>
/// Writes data from data provider stream to a file external to project
/// </summary>
/// <param name="exportFilePath"></param>
/// <param name="canOverwrite"></param>
public virtual void ExportDataStreamToFile(string exportFilePath, bool canOverwrite)
{
if (exportFilePath == null)
{
throw new exception.MethodParameterIsNullException("external file path cannot be null");
}
if (File.Exists(exportFilePath) && !canOverwrite)
{
throw new System.Exception("Export file with same name already exists");
}
Stream source = OpenInputStream();
if (source.Length == 0)
{
source.Close();
throw new exception.InputStreamIsTooShortException("The data provider has no data to export to external file");
}
const uint BUFFER_SIZE = 1024 * 1024; // 1 MB MAX BUFFER
string parentdir = Path.GetDirectoryName(exportFilePath);
if (!Directory.Exists(parentdir))
{
FileDataProvider.CreateDirectory(parentdir);
}
FileStream exportFileStream = null;
try
{
//exportFileStream = File.Create(exportFilePath);
exportFileStream = new FileStream(exportFilePath, FileMode.Create, FileAccess.Write, FileShare.Read);
}
catch (Exception ex)
{
source.Close();
#if DEBUG
Debugger.Break();
#endif
throw;
}
try
{
StreamUtils.Copy(source, 0, exportFileStream, BUFFER_SIZE);
//if (source.Length <= BUFFER_SIZE)
//{
// byte[] buffer = new byte[source.Length];
// int read = source.Read(buffer, 0, (int)source.Length);
// exportFileStream.Write(buffer, 0, read);
//}
//else
//{
// byte[] buffer = new byte[BUFFER_SIZE];
// int bytesRead = 0;
// while ((bytesRead = source.Read(buffer, 0, BUFFER_SIZE)) > 0)
// {
// exportFileStream.Write(buffer, 0, bytesRead);
// }
//}
}
finally
{
exportFileStream.Close();
source.Close();
}
}
public void Rename(string prefix)
{
if (mOpenOutputStream != null)
{
#if DEBUG
Debugger.Break();
#endif
return;
}
if (mOpenInputStreams.Count > 0)
{
#if DEBUG
Debugger.Break();
#endif
return;
}
string oldPrefix = m_NamePrefix;
string oldName = DataFileRelativePath;
string oldPath = DataFileFullPath;
m_NamePrefix = prefix;
mDataFileRelativePath = null;
string newName = DataFileRelativePath;
string newPath = DataFileFullPath;
#if DEBUG
DebugFix.Assert(!File.Exists(newPath));
#endif
#if DEBUG
foreach (DataProvider dp in Presentation.DataProviderManager.ManagedObjects.ContentsAs_Enumerable)
{
if (dp is FileDataProvider)
{
FileDataProvider fdp = (FileDataProvider)dp;
if (fdp == this)
{
continue;
}
if (fdp.DataFileFullPath == newPath)
{
Debugger.Break();
}
}
}
#endif
if (!File.Exists(oldPath))
{
#if DEBUG
Debugger.Break();
#endif
HasBeenInitialized = false;
return;
}
try
{
File.Move(oldPath, DataFileFullPath);
try
{
File.SetAttributes(DataFileFullPath, FileAttributes.Normal);
}
catch
{
}
HasBeenInitialized = true;
}
catch (Exception ex)
{
#if DEBUG
Debugger.Break();
#endif
m_NamePrefix = oldPrefix;
mDataFileRelativePath = oldName;
newName = DataFileRelativePath;
newPath = DataFileFullPath;
}
}
