public static string GetTempRootPath(ContentURI uri)
{
string sPathToTempContent = string.Empty;
FileStorageIO.PLATFORM_TYPES ePlatform = FileStorageIO.GetPlatformType(uri);
if (ePlatform == FileStorageIO.PLATFORM_TYPES.webserver)
{
//store in temp subfolder of resources directory (set permissions once)
bool bIsAzureStorage = false;
string sRoot = GetResourceRootPath(uri, bIsAzureStorage);
if (!sRoot.EndsWith(GeneralHelpers.FILE_PATH_DELIMITER) &&
(!string.IsNullOrEmpty(sRoot)))
{
sRoot = string.Concat(sRoot, GeneralHelpers.FILE_PATH_DELIMITER);
}
sPathToTempContent = string.Format("{0}{1}{2}",
sRoot, uri.URIDataManager.TempDocsURIName,
GeneralHelpers.FILE_PATH_DELIMITER);
}
else if (ePlatform == FileStorageIO.PLATFORM_TYPES.azure)
{
//performance will be better when temp files are in same cloud storage as content
//copying back and forth will be easier
sPathToTempContent = string.Format("{0}{1}{2}",
uri.URIDataManager.DefaultRootWebStoragePath,
uri.URIDataManager.TempDocsURIName,
GeneralHelpers.WEBFILE_PATH_DELIMITER);
}
return(sPathToTempContent);
}
public static string GetTempDocsPathToNewFileSystemPath(ContentURI uri, bool isLocalCacheDirectory,
string newFileName)
{
//210 added specifically for script file handling (http to file server path conversions)
string sTempDocPath = string.Empty;
if (!string.IsNullOrEmpty(uri.URIDataManager.TempDocPath))
{
string sOldTempFileName = Path.GetFileName(uri.URIDataManager.TempDocPath);
sTempDocPath = uri.URIDataManager.TempDocPath.Replace(sOldTempFileName, newFileName);
}
else
{
//make a new temp doc path for temp storage of script file
string sDirectoryPath = GetTempWebDirectory(uri,
isLocalCacheDirectory, GeneralHelpers.Get2RandomInteger());
string sDelimiter = FileStorageIO.GetDelimiterForFileStorage(sDirectoryPath);
//make the tempdocpath
string sTempDocPath2 = string.Concat(sDirectoryPath, sDelimiter, newFileName);
//return sTempDocPath;
bool bHasDirectory = FileStorageIO.DirectoryCreate(
uri, sTempDocPath2);
}
return(sTempDocPath);
}
public static async Task <bool> NeedsNewXhtmlDoc(ContentURI uri,
GeneralHelpers.DOC_STATE_NUMBER displayDocType,
string xmlDocPath, string xhtmlDocPath)
{
bool bNeedsNewXhtmlDoc = false;
//rule 1: authorized edits always get new html
bNeedsNewXhtmlDoc = await AuthorizedEditNeedsHtmlFragment(uri,
displayDocType, xmlDocPath);
if (bNeedsNewXhtmlDoc)
{
bNeedsNewXhtmlDoc = true;
return(bNeedsNewXhtmlDoc);
}
if (!await FileStorageIO.URIAbsoluteExists(uri, xhtmlDocPath))
{
//rule 2: if the html doesn't exist, make it
bNeedsNewXhtmlDoc = true;
return(bNeedsNewXhtmlDoc);
}
bNeedsNewXhtmlDoc = await FileStorageIO.File1IsNewerAsync(
uri, xmlDocPath, xhtmlDocPath);
return(bNeedsNewXhtmlDoc);
}
public async Task <bool> GetXmlFromFile(ContentURI uri,
string filePath, XPathNavigator xPathNav)
{
bool bHasCompleted = false;
xPathNav = null;
if (await FileStorageIO.URIAbsoluteExists(uri, filePath))
{
XmlDocument oSelectedDoc = new XmlDocument();
XmlReader reader
= await Helpers.FileStorageIO.GetXmlReaderAsync(uri, filePath);
if (reader != null)
{
using (reader)
{
oSelectedDoc.Load(reader);
}
}
if (oSelectedDoc != null)
{
xPathNav = oSelectedDoc.CreateNavigator();
}
}
bHasCompleted = true;
return(bHasCompleted);
}
public static async Task <bool> File1IsNewerAsync(ContentURI uri,
string file1Path, string file2Path)
{
bool bXmlIsNewer = false;
bool bFile2Exists = await FileStorageIO.URIAbsoluteExists(uri, file2Path);
if (!bFile2Exists)
{
return(true);
}
if (await FileStorageIO.URIAbsoluteExists(uri, file1Path) &&
bFile2Exists)
{
DateTime xmlFileTime
= await GetLastWriteTimeUtcAsync(uri, file1Path);
DateTime xhtmlFileTime
= await GetLastWriteTimeUtcAsync(uri, file2Path);
if (xmlFileTime > xhtmlFileTime)
{
//rule 3: if the xmldoc is older than than the html, make a new html
bXmlIsNewer = true;
}
}
return(bXmlIsNewer);
}
public static async Task <bool> AddNewestXmlFileWithExtensionToList(
ContentURI uri, string docPath,
string fileExtension, IDictionary <string, string> lstFilePaths)
{
bool bHasCompleted = false;
DirectoryInfo dir = null;
if (!FileStorageIO.DirectoryExists(uri, docPath))
{
uri.ErrorMessage = Exceptions.DevTreksErrors.MakeStandardErrorMsg(
string.Empty, "DIRECTORY_NOEXIST");
return(bHasCompleted);
}
if (Path.HasExtension(docPath))
{
//if it has an extension it needs the parent directory
dir = new DirectoryInfo(
Path.GetDirectoryName(docPath));
}
else
{
dir = new DirectoryInfo(docPath);
}
bHasCompleted = await AddNewestFileWithFileExtension(uri, dir, fileExtension,
lstFilePaths);
bHasCompleted = true;
return(bHasCompleted);
}
public void WriteFileXml(ContentURI uri,
XmlDocument doc, string filePath)
{
bool bCanWrite = true;
XmlTextWriter oTextWriter;
try
{
//uses FileStream to open filepath; could open filestream here asynchronously and pass filestream instead of filePath
FileStorageIO.DirectoryCreate(uri, filePath);
oTextWriter = new XmlTextWriter(filePath, Encoding.UTF8);
using (oTextWriter)
{
bCanWrite = oTextWriter.BaseStream.CanWrite;
if (bCanWrite == true)
{
doc.WriteTo(oTextWriter);
oTextWriter.Flush();
}
else
{
bCanWrite = false;
}
}
}
catch (Exception x)
{
uri.ErrorMessage = Exceptions.DevTreksErrors.MakeStandardErrorMsg(
x.ToString(), "FILEIO_CANTSAVEFILE");
File.Delete(filePath);
}
}
public async Task <bool> PackageIDPFFiles(ContentURI uri, string packageFilePathName,
IDictionary <string, string> args)
{
bool bIsPackaged = false;
string errorMsg = string.Empty;
PackageIO packIO = new PackageIO();
packIO.CheckForPackageFileErrors(packageFilePathName, args,
ref errorMsg);
if (!string.IsNullOrEmpty(errorMsg))
{
return(bIsPackaged);
}
//files are found in this directory and its subfolders
CurrentDirectory = FileStorageIO.GetDirectoryName(packageFilePathName);
//Directory.SetCurrentDirectory(Path.GetDirectoryName(packageFilePathName));
//1. copy container.xml file into a meta-inf subfolder
string sContainerNewPath = await CopyContainerFile(uri, errorMsg);
//2. copy mimetype.txt into root folder
string sMimeTypeNewPath = await CopyEPubFile(uri, MIMETYPE_FILE, MIMETYPE_FILE, errorMsg);
//3. create content.opf file and place in root folder
//.opf extension is not liked when saving file so use temp.xml
string sTempFileName = string.Concat(Helpers.GeneralHelpers.GetRandomInteger(0).ToString(),
Helpers.GeneralHelpers.EXTENSION_XML);
string sContentNewPath = await CopyEPubFile(uri, CONTENT_FILE, sTempFileName, errorMsg);
//copy the files in args into content.opf
if (errorMsg == string.Empty)
{
await MakeContentFile(uri, Path.GetFileNameWithoutExtension(packageFilePathName),
args, sContentNewPath, errorMsg);
//4. create toc.ncx file and place in root
//.ncx extension is not liked when saving file so use temp.xml
sTempFileName = string.Concat(Helpers.GeneralHelpers.GetRandomInteger(12223).ToString(),
Helpers.GeneralHelpers.EXTENSION_XML);
string sNavigationNewPath = await CopyEPubFile(uri, NCX_FILE, sTempFileName, errorMsg);
//copy whatever files from args that are needed into the ncx file
await MakeNavigationFile(uri, packageFilePathName,
args, sNavigationNewPath, errorMsg);
//copy misc. files
string sTitlePath = await CopyEPubFile(uri, TITLEPAGE_FILE, TITLEPAGE_FILE, errorMsg);
//add the epub files to args for zipping
args.Add(sContainerNewPath, "epub");
args.Add(sMimeTypeNewPath, "epub");
args.Add(sContentNewPath, "epub");
args.Add(sNavigationNewPath, "epub");
args.Add(sTitlePath, "epub");
if (errorMsg == string.Empty)
{
bIsPackaged = true;
}
}
return(bIsPackaged);
}
public static void AddNewestXmlFileWithExtensionToList(
ContentURI uri, string docPath,
string fileExtension, IDictionary <string, string> lstFilePaths,
ref string errorMsg)
{
DirectoryInfo dir = null;
if (!FileStorageIO.DirectoryExists(uri, docPath))
{
errorMsg = Exceptions.DevTreksErrors.MakeStandardErrorMsg(
string.Empty, "DIRECTORY_NOEXIST");
return;
}
if (Path.HasExtension(docPath))
{
//if it has an extension it needs the parent directory
dir = new DirectoryInfo(
Path.GetDirectoryName(docPath));
}
else
{
dir = new DirectoryInfo(docPath);
}
AddNewestFileWithFileExtension(uri, dir, fileExtension,
lstFilePaths);
}
public static string GetResourceRootPath(ContentURI uri,
string networkWebFileSystemPath)
{
string sPathToContent = string.Empty;
//networkWebFileSystemName derives from uri.URINetwork.WebFileSystemPath
//and is stored in db table Network
string sContentContainerOrFolderName =
(string.IsNullOrEmpty(networkWebFileSystemPath)) ?
uri.URIDataManager.ContentURIName
: networkWebFileSystemPath;
FileStorageIO.PLATFORM_TYPES ePlatform = FileStorageIO.GetPlatformType(uri);
if (ePlatform == FileStorageIO.PLATFORM_TYPES.webserver)
{
//store in temp subfolder of resources directory (set permissions once)
bool bIsAzureStorage = false;
string sRoot = GetResourceRootPath(uri, bIsAzureStorage);
if (!sRoot.EndsWith(GeneralHelpers.FILE_PATH_DELIMITER) &&
(!string.IsNullOrEmpty(sRoot)))
{
sRoot = string.Concat(sRoot, GeneralHelpers.FILE_PATH_DELIMITER);
}
sPathToContent = string.Format("{0}{1}{2}",
sRoot, sContentContainerOrFolderName,
GeneralHelpers.FILE_PATH_DELIMITER);
}
else if (ePlatform == FileStorageIO.PLATFORM_TYPES.azure)
{
//store in 'commontreks' (or other network containername) container
sPathToContent = string.Format("{0}{1}{2}",
uri.URIDataManager.DefaultRootWebStoragePath,
sContentContainerOrFolderName, GeneralHelpers.WEBFILE_PATH_DELIMITER);
}
return(sPathToContent);
}
private static async Task <bool> AddSiblingFilesAsync(
ContentURI uri, DirectoryInfo folder,
string currentFilePath, string packageName, string fileType,
string newFilePath, IDictionary <string, string> zipArgs)
{
bool bHasCopied = false;
string sPackageFilePath = string.Empty;
if (folder != null)
{
string sNoCalcDocExt = string.Concat(Helpers.GeneralHelpers.FILENAME_DELIMITER,
Helpers.GeneralHelpers.FILENAME_EXTENSIONS.addin.ToString());
FileInfo[] files = folder.GetFiles();
if (files != null)
{
string sFileExtension = string.Empty;
foreach (FileInfo file in files)
{
if (fileType == Helpers.GeneralHelpers.EXTENSION_CSV)
{
bHasCopied = AddSiblingCSVFilesAsync(
uri, file, currentFilePath, sNoCalcDocExt,
packageName, fileType, newFilePath, zipArgs);
}
else
{
//current file is already in the package
if (!file.FullName.Equals(currentFilePath))
{
//package either all html or all xml files
if (Path.GetExtension(file.FullName).Equals(fileType))
{
//v174 exclude calcdocs because too much unneeded docs in package
if (!file.Name.Contains(sNoCalcDocExt))
{
sPackageFilePath = Path.Combine(newFilePath, Path.GetFileName(file.FullName));
bHasCopied = await FileStorageIO.CopyURIsAsync(
uri, file.FullName, sPackageFilePath);
if (Helpers.FileStorageIO.URIAbsoluteExists(
uri, sPackageFilePath))
{
if (!zipArgs.ContainsKey(sPackageFilePath))
{
zipArgs.Add(sPackageFilePath, packageName);
}
}
}
}
}
}
}
}
}
return(bHasCopied);
}
public static string GetMiscDocURI(string existingURI)
{
string sMiscDocURI = string.Empty;
string sDirectory = FileStorageIO.GetDirectoryName(existingURI);
string sFileNameNoExt = Path.GetFileNameWithoutExtension(existingURI);
string sExt = Path.GetExtension(existingURI);
string sMiscFileName = string.Concat(sFileNameNoExt,
GeneralHelpers.EXTENSION_MISC, sExt);
sMiscDocURI = Path.Combine(sDirectory, sMiscFileName);
return(sMiscDocURI);
}
//set in ViewDataHelper when uri is configured with appsettings
public static void SetAbsoluteURLPath(ContentURI uri,
string absoluteURLPath)
{
string sWebPath = absoluteURLPath;
FileStorageIO.PLATFORM_TYPES ePlatform = FileStorageIO.GetPlatformType(uri);
if (ePlatform != FileStorageIO.PLATFORM_TYPES.azure)
{
//only azure should be using https
sWebPath = absoluteURLPath.Replace("https", "http");
}
uri.URIDataManager.WebPath = sWebPath;
}
public async Task <bool> WriteFileXmlAsync(
ContentURI uri, XmlReader reader, string filePath)
{
bool bHasSaved = false;
FileStorageIO.DirectoryCreate(uri, filePath);
using (reader)
{
reader.MoveToContent();
FileIO fileIO = new FileIO();
bHasSaved = await fileIO.WriteTextFileAsync(filePath, reader.ReadOuterXml());
}
return(bHasSaved);
}
public static async Task <bool> AuthorizedEditNeedsHtmlFragment(ContentURI uri,
GeneralHelpers.DOC_STATE_NUMBER displayDocType,
string xmlDocPath)
{
bool bNeedsNewXhtmlFrag = false;
//tempdocs can be edited by anyone
if (uri.URIMember.ClubInUse.PrivateAuthorizationLevel
== AccountHelper.AUTHORIZATION_LEVELS.fulledits ||
uri.URIFileExtensionType == GeneralHelpers.FILENAME_EXTENSIONS.temp.ToString())
{
if (uri.URIDataManager.ServerSubActionType
== GeneralHelpers.SERVER_SUBACTION_TYPES.runaddin)
{
//if temp doc exists they are in the middle of running calcs
//if save = calcs they have just finished running calcs
if (await FileStorageIO.URIAbsoluteExists(
uri, uri.URIDataManager.TempDocPath) &&
(!string.IsNullOrEmpty(uri.URIDataManager.TempDocSaveMethod) &&
uri.URIDataManager.TempDocSaveMethod != Helpers.GeneralHelpers.NONE))
{
if (displayDocType
== GeneralHelpers.DOC_STATE_NUMBER.seconddoc)
{
//v1.2.0: need to pass params to seconddoc telling which save message to display
bNeedsNewXhtmlFrag = true;
}
else
{
bNeedsNewXhtmlFrag = false;
}
}
else
{
if (displayDocType
== GeneralHelpers.DOC_STATE_NUMBER.seconddoc)
{
//always init calcors/analyzers with new doc
bNeedsNewXhtmlFrag = true;
}
}
}
else
{
bNeedsNewXhtmlFrag = true;
}
}
return(bNeedsNewXhtmlFrag);
}
public static void GetXmlFromFile(string filePath,
out XmlReader reader)
{
reader = null;
//filepath can be uri with http or filesystem
if (FileStorageIO.FileExists(filePath))
{
//keep settings consistent with linq to xml default
XmlReaderSettings oSettings = new XmlReaderSettings();
oSettings.ConformanceLevel = ConformanceLevel.Document;
oSettings.IgnoreWhitespace = true;
oSettings.IgnoreComments = true;
reader = XmlReader.Create(filePath, oSettings);
}
}
public static async Task <bool> AddNewestFileWithFileExtension(
ContentURI uri, DirectoryInfo folder,
string fileExtension, IDictionary <string, string> lstFilePaths)
{
bool bHasCompleted = false;
FileInfo[] files = folder.GetFiles();
FileInfo newestFile = null;
bool bIsNewerFile = false;
foreach (FileInfo file in files)
{
if (Path.GetFileNameWithoutExtension(file.FullName).EndsWith(fileExtension) &&
file.Extension == Helpers.GeneralHelpers.EXTENSION_XML)
{
//rule 1: analyzers can only use calculator data
if (file.Name.StartsWith(GeneralHelpers.ADDIN))
{
//rule2: use only the latest file calculated with that fileextension
//if this folder had more than one file with this extension,
//it could mean that an old calculation,
//from a previous calculator, was not deleted properly
uri.URIDataManager.ParentStartRow++;
if (newestFile != null)
{
bIsNewerFile
= await FileStorageIO.File1IsNewerAsync(
uri, file.FullName, newestFile.FullName);
if (bIsNewerFile)
{
newestFile = file;
}
}
else
{
newestFile = file;
}
}
}
}
if (newestFile != null)
{
AddFileToList(newestFile, uri, lstFilePaths);
}
bHasCompleted = true;
return(bHasCompleted);
}
public void GetXmlFromFile(ContentURI uri,
string filePath, out XPathDocument xPathDoc)
{
xPathDoc = null;
if (FileStorageIO.URIAbsoluteExists(uri, filePath))
{
XmlReader reader = FileStorageIO.GetXmlReader(uri, filePath);
if (reader != null)
{
using (reader)
{
xPathDoc = new XPathDocument(reader);
}
}
}
}
public async Task WriteXhtmlFragmentAsync(StringWriter writer,
ContentURI uri, string xmlDocToReadPath, string htmlFragmentDocPath,
DataHelpers.GeneralHelpers.DOC_STATE_NUMBER displayDocType)
{
if (DataHelpers.FileStorageIO.URIAbsoluteExists(uri, htmlFragmentDocPath))
{
//write html
DataHelpers.FileStorageIO oFileStorageIO = new DataHelpers.FileStorageIO();
await oFileStorageIO.SaveHtmlURIToWriterAsync(uri, writer, htmlFragmentDocPath);
}
else
{
//transform xml
await WriteXhtmlFragmentAsync(writer, uri, xmlDocToReadPath, displayDocType);
}
}
public bool ZipFiles(ContentURI uri, string zipFilePath,
IDictionary <string, string> args)
{
bool bIsZipped = false;
string errorMsg = string.Empty;
PackageIO packIO = new PackageIO();
packIO.CheckForPackageFileErrors(zipFilePath, args,
ref errorMsg);
if (!string.IsNullOrEmpty(errorMsg))
{
return(bIsZipped);
}
//filesystem
//don't want the temp directory info in the file path, disrupts subfolders (i.e. in packages)
Directory.SetCurrentDirectory(Path.GetDirectoryName(zipFilePath));
string sCurrentDirectory = FileStorageIO.GetDirectoryName(zipFilePath);
//init the zip with the zip's file name
using (FileStream zipToOpen = new FileStream(Path.GetFileName(zipFilePath), FileMode.Create))
{
using (ZipArchive archive = new ZipArchive(zipToOpen, ZipArchiveMode.Update))
{
string[] arrValues = { };
string sRelPartPath = string.Empty;
string sKey = string.Empty;
string sValue = string.Empty;
foreach (KeyValuePair <string, string> kvp in args)
{
sKey = kvp.Key;
sValue = kvp.Value;
if (string.IsNullOrEmpty(sKey) == false &&
Helpers.FileStorageIO.URIAbsoluteExists(
uri, sKey))
{
//convert the absolute path of partFullPath into a path relative to the package root (getcurrentdirectory)
sRelPartPath = AppSettings.ConvertAbsPathToRelPath(sCurrentDirectory, sKey);
//will add files to the same directory as setcurrentdirectory
//2.0.0 change required adding a reference to System.IO.Compression.FileSystem
archive.CreateEntryFromFile(sKey, sRelPartPath);
}
}
bIsZipped = true;
}
}
return(bIsZipped);
}
public void WriteFileXml(ContentURI uri,
XmlReader reader, string filePath,
out string errorMsg)
{
errorMsg = string.Empty;
bool bCanWrite = true;
XmlTextWriter oTextWriter;
try
{
//uses FileStream to open filepath; could open filestream here asynchronously and pass filestream instead of filePath
FileStorageIO.DirectoryCreate(uri, filePath);
oTextWriter = new XmlTextWriter(filePath, Encoding.UTF8);
using (oTextWriter)
{
bCanWrite = oTextWriter.BaseStream.CanWrite;
if (bCanWrite == true)
{
using (reader)
{
reader.MoveToContent();
oTextWriter.WriteRaw(reader.ReadOuterXml());
oTextWriter.Flush();
}
}
else
{
bCanWrite = false;
}
}
}
catch (Exception x)
{
errorMsg = Exceptions.DevTreksErrors.MakeStandardErrorMsg(
x.ToString(), "FILEIO_CANTSAVEFILE");
File.Delete(filePath);
}
if (!bCanWrite)
{
errorMsg = Exceptions.DevTreksErrors.MakeStandardErrorMsg(
string.Empty, "FILEIO_STREAMCLOSED");
}
oTextWriter = null;
}
public static async Task <bool> AddNewestIOFile(
ContentURI uri, DirectoryInfo folder,
IDictionary <string, string> lstFilePaths)
{
bool bHasCompleted = false;
//inputs and outputs don't have base NPV calcs and can be used directly without running new calculations
FileInfo[] files = folder.GetFiles();
FileInfo newestFile = null;
bool bIsNewerFile = false;
foreach (FileInfo file in files)
{
if (file.Extension == Helpers.GeneralHelpers.EXTENSION_XML)
{
//rule2: use only the latest file calculated with that fileextension
//if this folder had more than one file with this extension,
//it could mean that an old calculation,
//from a previous calculator, was not deleted properly
uri.URIDataManager.ParentStartRow++;
if (newestFile != null)
{
bIsNewerFile
= await FileStorageIO.File1IsNewerAsync(
uri, file.FullName, newestFile.FullName);
if (bIsNewerFile)
{
newestFile = file;
}
}
else
{
newestFile = file;
}
}
}
if (newestFile != null)
{
AddFileToList(newestFile, uri, lstFilePaths);
}
bHasCompleted = true;
return(bHasCompleted);
}
public static string GetTempWebDirectory(ContentURI uri,
bool isPackageDirectory, int randomId)
{
//if randomid is not enough switch to guid
string sTempDirPath = string.Empty;
string sRootDirectory = string.Empty;
if (isPackageDirectory)
{
sRootDirectory = GetTempCacheRootPath(uri);
sTempDirPath = string.Concat(sRootDirectory, randomId.ToString());
}
else
{
//0.9.1: multiple servers won't work with local cache; needs blob storage
sRootDirectory = GetTempRootPath(uri);
sTempDirPath = string.Concat(sRootDirectory, randomId.ToString());
}
FileStorageIO.DirectoryCreate(uri, sTempDirPath);
return(sTempDirPath);
}
public async Task <bool> GetXmlFromFile(ContentURI uri,
string filePath, XPathDocument xPathDoc)
{
bool bHasCompleted = false;
xPathDoc = null;
if (await FileStorageIO.URIAbsoluteExists(uri, filePath))
{
XmlReader reader = await FileStorageIO.GetXmlReaderAsync(uri, filePath);
if (reader != null)
{
using (reader)
{
xPathDoc = new XPathDocument(reader);
}
}
}
bHasCompleted = true;
return(bHasCompleted);
}
public static string GetTempDocPath(ContentURI uri, bool isLocalCacheDirectory,
string uriPattern, string tempURIPattern)
{
string sTempDocPath = string.Empty;
//use uri.URIDataManager.TempDocURI to set subdirectory for holding
//all related tempdocs (easy to package)
string sRandomId = ContentURI.GetURIPatternPart(tempURIPattern, ContentURI.URIPATTERNPART.id);
string sNodeName = ContentURI.GetURIPatternPart(tempURIPattern, ContentURI.URIPATTERNPART.node);
string sDirectory = string.Empty;
//ok to put empty uris in a "0" subfolder
if (sRandomId != string.Empty &&
sNodeName != GeneralHelpers.NONE &&
sRandomId != "0")
{
//has a tempdoc to work with
//uri.uridatamanager.tempdocuri's random urid is always subdir
sDirectory = GetTempWebDirectory(uri, isLocalCacheDirectory,
GeneralHelpers.ConvertStringToInt(sRandomId));
}
else
{
//may be starting to build a tempdoc
//need a random directory
sDirectory = GetTempWebDirectory(uri, isLocalCacheDirectory,
GeneralHelpers.Get2RandomInteger());
}
string sDelimiter = FileStorageIO.GetDelimiterForFileStorage(sDirectory);
//don't use uri.uriclubdocpath filename because it may not need to be set
//for the selectedlinkedviewuri
string sFileName = string.Concat(
ContentHelper.MakeStandardFileNameFromURIPattern(uriPattern),
GeneralHelpers.EXTENSION_XML);
//make the tempdocpath
sTempDocPath = string.Concat(sDirectory, sDelimiter,
ContentHelper.MakeStandardFileNameFromURIPattern(uriPattern),
GeneralHelpers.EXTENSION_XML);
return(sTempDocPath);
}
public static void AddNewestIOFile(
ContentURI uri, DirectoryInfo folder,
ref int i, ref IDictionary <string, string> lstFilePaths)
{
//inputs and outputs don't have base NPV calcs and can be used directly without running new calculations
FileInfo[] files = folder.GetFiles();
FileInfo newestFile = null;
bool bIsNewerFile = false;
foreach (FileInfo file in files)
{
if (file.Extension == Helpers.GeneralHelpers.EXTENSION_XML)
{
//rule2: use only the latest file calculated with that fileextension
//if this folder had more than one file with this extension,
//it could mean that an old calculation,
//from a previous calculator, was not deleted properly
i++;
if (newestFile != null)
{
bIsNewerFile
= FileStorageIO.File1IsNewer(
uri, file.FullName, newestFile.FullName);
if (bIsNewerFile)
{
newestFile = file;
}
}
else
{
newestFile = file;
}
}
}
if (newestFile != null)
{
AddFileToList(newestFile, i, ref lstFilePaths);
}
}
public void GetXmlFromFile(ContentURI uri,
string filePath, out XPathNavigator xPathNav)
{
xPathNav = null;
if (FileStorageIO.URIAbsoluteExists(uri, filePath))
{
XmlDocument oSelectedDoc = new XmlDocument();
XmlReader reader
= Helpers.FileStorageIO.GetXmlReader(uri, filePath);
if (reader != null)
{
using (reader)
{
oSelectedDoc.Load(reader);
}
}
if (oSelectedDoc != null)
{
xPathNav = oSelectedDoc.CreateNavigator();
}
}
}
public static void AddNewestFileWithFileExtension(
ContentURI uri, DirectoryInfo folder,
string fileExtension, IDictionary <string, string> lstFilePaths)
{
FileInfo[] files = folder.GetFiles();
FileInfo newestFile = null;
bool bIsNewerFile = false;
foreach (FileInfo file in files)
{
if (file.FullName.EndsWith(fileExtension) &&
file.Extension == Helpers.GeneralHelpers.EXTENSION_XML)
{
//use only the latest file calculated with that fileextension
//if this folder had more than one file with this extension,
//it could mean that an old calculation,
//from a previous calculator, was not deleted properly
if (newestFile != null)
{
bIsNewerFile
= FileStorageIO.File1IsNewer(
uri, file.FullName, newestFile.FullName);
if (bIsNewerFile)
{
newestFile = file;
}
}
else
{
newestFile = file;
}
}
}
if (newestFile != null)
{
int i = 0;
AddFileToList(newestFile, i, ref lstFilePaths);
}
}
//gets paths to css, js, images in web root
public static string GetWebContentFullPath(ContentURI uri,
string webSubfolder, string filename)
{
string sPathToContent = string.Empty;
FileStorageIO.PLATFORM_TYPES ePlatform = FileStorageIO.GetPlatformType(uri);
if (ePlatform == FileStorageIO.PLATFORM_TYPES.webserver)
{
sPathToContent = string.Format("{0}{1}{2}{3}",
uri.URIDataManager.DefaultRootFullFilePath,
webSubfolder, GeneralHelpers.FILE_PATH_DELIMITER,
filename);
}
else if (ePlatform == FileStorageIO.PLATFORM_TYPES.azure)
{
//do not use the path to blob storage: DefaultRootWebStoragePath
sPathToContent = string.Format("{0}{1}{2}{3}",
uri.URIDataManager.DefaultWebDomain,
webSubfolder, GeneralHelpers.WEBFILE_PATH_DELIMITER,
filename);
}
return(sPathToContent);
}
public static string AddDirectoryToDirectoryPath(string fromDirectoryPath, string toDirectoryPath)
{
string sFullDirectoryPath = toDirectoryPath;
//deal with when absoluteuripath ends with a delimiter or file name
if (Path.HasExtension(toDirectoryPath))
{
sFullDirectoryPath = GetDirectoryName(toDirectoryPath);
}
char[] cDelimiter = FileStorageIO.GetCDelimiterForFileStorage(fromDirectoryPath);
string sDelimiter = FileStorageIO.GetDelimiterForFileStorage(fromDirectoryPath);
string sLastDirectoryName = string.Empty;
if (fromDirectoryPath.EndsWith(sDelimiter))
{
sLastDirectoryName = GeneralHelpers.GetSubstringFromEnd(
fromDirectoryPath, cDelimiter, 2);
}
else
{
sLastDirectoryName = GeneralHelpers.GetSubstringFromEnd(
fromDirectoryPath, cDelimiter, 1);
}
string sToDelimiter = FileStorageIO.GetDelimiterForFileStorage(toDirectoryPath);
string sLastDirectoryDelimited = string.Concat(sToDelimiter,
sLastDirectoryName, sToDelimiter);
if (!sFullDirectoryPath.EndsWith(sLastDirectoryDelimited))
{
sFullDirectoryPath = Path.Combine(sFullDirectoryPath, sLastDirectoryName);
if (!sFullDirectoryPath.EndsWith(sToDelimiter))
{
sFullDirectoryPath = string.Concat(sFullDirectoryPath, sToDelimiter);
}
}
return(sFullDirectoryPath);
}