public static string MapServerPath(this HttpServerUtilityBase httpServerUtility, string localPath)
{
string domainRootLocalPath = httpServerUtility.MapPath("/");
string relativeLocalPath = ExtendedPath.GetRelativePath(domainRootLocalPath, localPath);
string serverPath = relativeLocalPath.Replace('\\', '/');
return(serverPath);
}
public static string GetExternalLinkFromLocalPath(string fullLocalPath, string baseLocalPath, string baseUrl)
{
var relativePath = ExtendedPath.GetRelativePath(baseLocalPath, fullLocalPath);
var relativeUrl = relativePath.Replace("\\", "/");
var fullUrl = UrlPath.Combine(baseUrl, relativeUrl);
return(fullUrl);
}
public static object ListObjectsFromFile(
[ExcelArgument(Name = "path", Description = "The path", AllowReference = true)]
object xlPath,
[ExcelArgument(Name = "fileName", Description = "The file name", AllowReference = true)]
object xlFileName,
[ExcelArgument(Name = "fileFormat", Description = "[Optional] The file format; the file extension will be used by default", AllowReference = true)]
object xlFileFormat)
{
try
{
IExcelDataQuery fileFormatDataQuery = ExcelDataQuery.Create(xlFileFormat, "File format");
string fileName;
IObjectStreamer objectStreamer;
if (fileFormatDataQuery.IsEmpty == true)
{
fileName = GetFileName(xlPath, xlFileName, ObjectStreamer.GetFileExtensions());
if (ObjectStreamer.TryGetObjectStreamerByFileExtension(ExtendedPath.GetExtension(fileName), out objectStreamer) == false)
{
throw new ArgumentException("Invalid file extension '" + ExtendedPath.GetExtension(fileName) + "', used default file extensions or specify the file format.");
}
}
else
{
if (fileFormatDataQuery.TryGetPoolValue <IObjectStreamer>(ObjectStreamer.TryGetObjectStreamer, out objectStreamer, dataAdvice: ExcelDataAdvice.Create(ObjectStreamer.GetNames())) == false)
{
throw new ArgumentException("Invalid file format " + fileFormatDataQuery.ToString(0, 0) + ".");
}
fileName = GetFileName(xlPath, xlFileName, objectStreamer.FileExtension);
fileFormatDataQuery.QueryCompleted();
}
StreamReader streamReader = new StreamReader(fileName);
IObjectStreamReader objectStreamReader = objectStreamer.GetStreamReader(streamReader);
var objectNames = ExcelPool.GetObjectNames(objectStreamReader);
int n = objectNames.Count();
object[,] output = new object[n + 1, 2];
output[0, 0] = "Name";
output[0, 1] = "Type";
int j = 1;
foreach (var obj in objectNames)
{
output[j, 0] = obj.Item2;
output[j, 1] = obj.Item1.Name.String;
j++;
}
objectStreamReader.Close();
return(ExcelDataConverter.GetExcelRangeOutput(output));
}
catch (Exception e)
{
return(ExcelDataConverter.GetExcelRangeErrorMessage(e));
}
}
private string GetRequestLogFileName(string ip)
{
var fileName = $"{ip}";
fileName = ExtendedPath.GetRightFileNameFromString(fileName);
fileName += ".txt";
var fullFileName = Path.Combine(_logDir, fileName);
return(fullFileName);
}
protected void OpenFile()
{
//if (!File.Exists(_logFileName))
//{
//}
int openingNewFileAttempts = 0;
tryToOpenFileAgain:
try
{
_logFileStream = new StreamWriter(_logFileName, true, utf8Encoding);
if (_writeLogMode == WriteLogOptions.LockAndFlushAfterEveryWrite)
{
_logFileStream.AutoFlush = true;
}
}
catch (DirectoryNotFoundException)
{
try
{
string logDir = Path.GetDirectoryName(_logFileName);
Directory.CreateDirectory(logDir);
goto tryToOpenFileAgain;
}
catch { }
}
catch (SystemException systemException)
{
if (systemException is IOException ||
systemException is UnauthorizedAccessException ||
systemException is SecurityException)
{
if (openingNewFileAttempts > 0)
{
return;
}
//string fileNameWithoutExt = Path.GetFileNameWithoutExtension(_logFileName);
//string fileExt = Path.GetExtension(_logFileName);
//int fileNameNumber;
//string fileNameExceptNumber;
//GetFileNameNumber(fileNameWithoutExt, out fileNameNumber, out fileNameExceptNumber);
//fileNameNumber++;
//_logFileName = string.Format("{0}({1}){2}", fileNameExceptNumber, fileNameNumber, fileExt);
_logFileName = ExtendedPath.GetIncrementedPath(_logFileName, "({0})");
if (!File.Exists(_logFileName))
{
openingNewFileAttempts++;
}
goto tryToOpenFileAgain;
}
}
}
public static object LoadObjectsFromFile(
[ExcelArgument(Name = "path", Description = "The path", AllowReference = true)]
object xlPath,
[ExcelArgument(Name = "fileName", Description = "The file name", AllowReference = true)]
object xlFileName,
[ExcelArgument(Name = "objectNames", Description = "[Optional] A list of object names to load; all objects will be loaded by default", AllowReference = true)]
object xlObjectNames,
[ExcelArgument(Name = "fileFormat", Description = "[Optional] The file format; the file extension will be used by default", AllowReference = true)]
object xlFileFormat)
{
try
{
IExcelDataQuery fileFormatDataQuery = ExcelDataQuery.Create(xlFileFormat, "File format");
string fileName;
IObjectStreamer objectStreamer;
if (fileFormatDataQuery.IsEmpty == true)
{
fileName = GetFileName(xlPath, xlFileName, ObjectStreamer.GetFileExtensions());
if (ObjectStreamer.TryGetObjectStreamerByFileExtension(ExtendedPath.GetExtension(fileName), out objectStreamer) == false)
{
throw new ArgumentException("Invalid file extension '" + Path.GetExtension(fileName) + "', used default file extensions or specify the file format.");
}
}
else
{
if (fileFormatDataQuery.TryGetPoolValue <IObjectStreamer>(ObjectStreamer.TryGetObjectStreamer, out objectStreamer, dataAdvice: ExcelDataAdvice.Create(ObjectStreamer.GetNames())) == false)
{
throw new ArgumentException("Invalid file format " + fileFormatDataQuery.ToString(0, 0) + ".");
}
fileName = GetFileName(xlPath, xlFileName, objectStreamer.FileExtension);
fileFormatDataQuery.QueryCompleted();
}
IExcelDataQuery objectNamesDataQuery = ExcelDataQuery.Create(xlObjectNames, "Object names");
IEnumerable <string> objectNames = objectNamesDataQuery.GetColumnVector <string>();
objectNamesDataQuery.QueryCompleted();
StreamReader streamReader = new StreamReader(fileName);
IObjectStreamReader objectStreamReader = objectStreamer.GetStreamReader(streamReader);
string infoMessage;
IEnumerable <ExcelPoolItem> excelPoolItems;
ExcelPool.TryLoadObjectsByName(objectStreamReader, objectNames, out infoMessage, out excelPoolItems);
objectStreamReader.Close();
return(infoMessage.ToTimeStampString());
}
catch (Exception e)
{
return(ExcelDataConverter.GetExcelRangeErrorMessage(e));
}
}
public static string GetExtension(string url)
{
int lastDotIndex = url.LastIndexOf('.');
if (lastDotIndex == -1)
{
return(null);
}
var extension = url.Substring(lastDotIndex);
if (ExtendedPath.ContainsInvalidFileNameChars(extension))
{
return(null);
}
return(extension);
}
public virtual void LoadFromDisk(int depth = -1)
{
logger.Info("Loading Directory {0}", LocalPath);
if (!Directory.Exists(this.LocalPath))
{
throw new DirectoryNotFoundException(String.Format("Directory '{0}' not found", LocalPath));
}
DirectoryInfo info = new DirectoryInfo(LocalPath);
this.Name = info.Name;
this.Created = info.CreationTimeUtc;
this.LastEdited = info.LastWriteTimeUtc;
// ## Update files ##
try
{
foreach (string item in Directory.GetFiles(LocalPath))
{
string fileName = System.IO.Path.GetFileName(item);
if (files.ContainsKey(fileName))
{
files[fileName].LoadFromDisk();
}
else
{
FileObject newFile = new FileObject();
newFile.Name = fileName;
newFile.LocalPath = item;
AddFile(newFile);
newFile.LoadFromDisk();
}
}
}
catch (DirectoryNotFoundException)
{
files = new Dictionary <string, FileObject>();
}
//TODO test if this really works!
files.Values.Where(x => !File.Exists(LocalPath)).Select(x => files.Remove(x.Name));
// ## Update directories ##
try
{
foreach (string item in Directory.GetDirectories(LocalPath))
{
try
{
string dirName = ExtendedPath.GetDirectoryName(item);
if (!directories.ContainsKey(dirName))
{
DirectoryObject newDir = new DirectoryObject();
newDir.Name = dirName;
newDir.LocalPath = item;
if (depth > 1 || depth < 0)
{
newDir.LoadFromDisk(depth - 1);
}
AddDirectory(newDir);
}
}
catch (IOException)
{
}
}
}
catch (DirectoryNotFoundException)
{
directories = new Dictionary <string, DirectoryObject>();
}
directories.Values.Where(x => !Directory.Exists(x.LocalPath)).Select(x => directories.Remove(x.Name));
directories.Values.Select(x => { x.LoadFromDisk(); return(x); });
}
public void TestMethod()
{
var p = ExtendedPath.GetPath(@"test.txt\some\test.txt");
}
