public void GetNearestCSharpProject_returns_null_for_no_project()
{
var path = AppDomain.CurrentDomain.BaseDirectory + @"\..\..\..\..";
var file = FileSupport.GetNearestCSharpProject(path);
Assert.IsNull(file);
}
public void GetNearestCSharpProject_finds_project_from_project_path()
{
var path = AppDomain.CurrentDomain.BaseDirectory + @"\..\..\UtilitiesTests.csproj";
var file = FileSupport.GetNearestCSharpProject(path);
Assert.IsTrue(file.EndsWith(@"\UtilitiesTests.csproj"));
}
public void GetNearestSolution_finds_solution_from_solution_path()
{
var path = AppDomain.CurrentDomain.BaseDirectory + @"\..\..\..\RoslynDom.sln";
var file = FileSupport.GetNearestSolution(path);
Assert.IsTrue(file.EndsWith(@"\RoslynDom.sln"));
}
public void GetNearestSolution_returns_null_for_no_solution()
{
var path = AppDomain.CurrentDomain.BaseDirectory + @"\..\..\..\..\..";
var file = FileSupport.GetNearestSolution(path);
Assert.IsNull(file);
}
protected override void ProcessRecord()
{
ResumeSupport = new Resume.ResumeSupport();
FileSupport = new FileSupport(MarkFileStatus);
if (ResumeSupport.IsPending)
{
Logger.Instance.Info("Last command wasn't successful due to discconnection.");
Console.Write("Last command wasn't successful due to discconnection, enter 'y' to complete or any other key to ignore: ");
String userOption = Console.ReadLine();
if (userOption.ToLower().Equals("y"))
{
Logger.Instance.Info("Copying those files which were missed due to discconnection with following parameters. Source Path:{0} Destination:{1} Forced:{2} Details:{3}",
String.Join(",", ResumeSupport.GetPath), ResumeSupport.GetDestination, ResumeSupport.GetForce, ResumeSupport.GetDetails);
StartCopying(ResumeSupport.GetPath, ResumeSupport.GetDestination, ResumeSupport.GetForce, ResumeSupport.GetDetails);
Logger.Instance.Info("Copying operation completed for missing files");
ResumeSupport.End();
Console.Write("Last command completed, starting current operation");
}
}
Logger.Instance.Info(String.Format("Starting Copy Operation with following parameters. Source Path:{0} Destination:{1} Forced:{2} Details:{3}",
String.Join(",", Path), Destination, Force, Details));
ResumeSupport.Start(Path, Destination, Force, Details);
StartCopying(Path, Destination, Force, Details);
ResumeSupport.End();
Logger.Instance.Info("Command executed successfully");
WriteObject("Files copied successfully");
}
public void GetNearestFilesOfType_adds_period_when_needed()
{
var path = AppDomain.CurrentDomain.BaseDirectory;
var files = FileSupport.GetNearestFilesOfType(path, "dll");
Assert.IsTrue(files.Count() > 0);
}
internal static string MaybeCreateTempFile(bool removeAfterClass = true)
{
string result = null;
Stream temp = null;
if (LuceneTestCase.TestLineDocsFile == LuceneTestCase.DEFAULT_LINE_DOCS_FILE) // Always GZipped
{
temp = typeof(LineFileDocs).FindAndGetManifestResourceStream(LuceneTestCase.TestLineDocsFile);
}
else if (LuceneTestCase.TestLineDocsFile.EndsWith(".gz", StringComparison.Ordinal))
{
temp = new FileStream(LuceneTestCase.TestLineDocsFile, FileMode.Open, FileAccess.Read, FileShare.Read);
}
if (null != temp)
{
var file = removeAfterClass
? LuceneTestCase.CreateTempFile(TEMP_FILE_PREFIX, TEMP_FILE_SUFFIX)
: FileSupport.CreateTempFile(TEMP_FILE_PREFIX, TEMP_FILE_SUFFIX);
result = file.FullName;
using (var gzs = new GZipStream(temp, CompressionMode.Decompress, leaveOpen: false))
using (Stream output = new FileStream(result, FileMode.Open, FileAccess.Write, FileShare.Read))
{
gzs.CopyTo(output);
}
}
return(result);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommonSteps"/> class.
/// Привязка общих шагов к работе с переменным через контекст.
/// </summary>
/// <param name="variableContext">Контекст для работы с переменными.</param>
/// <param name="fileSupport">Контекст для работы с файлами.</param>
/// <param name="consoleOutputHelper">Capturing Output.</param>
public CommonSteps(VariableContext variableContext, FileSupport fileSupport,
ITestOutputHelper consoleOutputHelper)
{
this.variableContext = variableContext;
this.fileSupport = fileSupport;
this.consoleOutputHelper = consoleOutputHelper;
}
public void GetMatchingFiles_doesnt_crash_on_no_files()
{
var path = AppDomain.CurrentDomain.BaseDirectory;
Assert.AreEqual(0, FileSupport.GetMatchingFiles("*.xadman", FileSupport.ProjectPath(path), true).Count());
Assert.AreEqual(0, FileSupport.GetMatchingFiles("*.xadman", FileSupport.ProjectPath(path), false).Count());
}
public void ProjectPath_finds_project_in_higher_directory()
{
// This test expects current file structure
var path = AppDomain.CurrentDomain.BaseDirectory;
Assert.IsNotNull(FileSupport.ProjectPath(path));
}
public void LoadInitialConditions()
{
string pressureFile = string.Format("P{0:d2}.thd", _levelType);
string temperatureFile = string.Format("T{0:d2}.thd", _levelType);
string humidityFile = string.Format("H{0:d2}.thd", _levelType);
string filePath = Path.Combine(SimulationData.WorkFolder, temperatureFile);
if (File.Exists(filePath) == false)
{
throw new FileNotFoundException();
}
DenseMatrix t = FileSupport.LoadMatrixFromFile(filePath);
filePath = Path.Combine(SimulationData.WorkFolder, pressureFile);
if (File.Exists(filePath) == false)
{
throw new FileNotFoundException();
}
DenseMatrix p = FileSupport.LoadMatrixFromFile(filePath);
filePath = Path.Combine(SimulationData.WorkFolder, humidityFile);
if (File.Exists(filePath) == false)
{
throw new FileNotFoundException();
}
DenseMatrix h = FileSupport.LoadMatrixFromFile(filePath);
H = h.EQ();
P = p.EQ();
T = t.EQ();
}
public void Can_load_prop_changed_code_from_file()
{
var str = FileSupport.GetFileContents(@"..\..\PropertyChanged1.cfcs");
var root = RDom.CSharp.Load(str);
Assert.IsNotNull(root);
}
public void IsReadableTest()
{
Assert.True(FileSupport.IsFileReadable(_fixture.UnwritableFilePath));
Assert.True(FileSupport.IsFileReadable(_fixture.WritableFilePath));
Assert.False(FileSupport.IsFileReadable(_fixture.UnreadableFilePath));
Assert.False(FileSupport.IsFileReadable(_fixture.InvalidFilePath));
}
/// <summary>
/// Sort a single partition in-memory. </summary>
internal FileInfo SortPartition(int len)
{
var data = this.Buffer;
FileInfo tempFile = FileSupport.CreateTempFile("sort", "partition", DefaultTempDir());
long start = Environment.TickCount;
sortInfo.SortTime += (Environment.TickCount - start);
using (var @out = new ByteSequencesWriter(tempFile))
{
BytesRef spare;
BytesRefIterator iter = Buffer.Iterator(comparator);
while ((spare = iter.Next()) != null)
{
Debug.Assert(spare.Length <= ushort.MaxValue);
@out.Write(spare);
}
}
// Clean up the buffer for the next partition.
data.Clear();
return(tempFile);
}
/// <summary>
/// Sort a single partition in-memory. </summary>
private FileInfo SortPartition(/*int len*/) // LUCENENET NOTE: made private, since protected is not valid in a sealed class. Also eliminated unused parameter.
{
var data = this.buffer;
FileInfo tempFile = FileSupport.CreateTempFile("sort", "partition", DefaultTempDir());
long start = J2N.Time.NanoTime() / J2N.Time.MillisecondsPerNanosecond; // LUCENENET: Use NanoTime() rather than CurrentTimeMilliseconds() for more accurate/reliable results
sortInfo.SortTime += ((J2N.Time.NanoTime() / J2N.Time.MillisecondsPerNanosecond) - start); // LUCENENET: Use NanoTime() rather than CurrentTimeMilliseconds() for more accurate/reliable results
using (var @out = new ByteSequencesWriter(tempFile))
{
IBytesRefEnumerator iter = buffer.GetEnumerator(comparer);
while (iter.MoveNext())
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(iter.Current.Length <= ushort.MaxValue);
}
@out.Write(iter.Current);
}
}
// Clean up the buffer for the next partition.
data.Clear();
return(tempFile);
}
public void IsWritableTest()
{
Assert.False(FileSupport.IsFileWritable(_fixture.UnwritableFilePath));
Assert.True(FileSupport.IsFileWritable(_fixture.WritableFilePath));
Assert.False(FileSupport.IsFileWritable(_fixture.NonExistentFilePath));
Assert.False(FileSupport.IsFileWritable(_fixture.InvalidFilePath));
}
public override CommandResult Validate(CommandArg arg)
{
CommandResult result = base.Validate(arg);
if (result.Succeeded)
{
string path = arg.Value;
if (!Path.IsPathFullyQualified(path))
{
try
{
path = Path.Combine(GeneralParameters.Instance.WorkingFolder, path);
}
catch (Exception ex)
{
result.Append(new CommandResult(false, "Invalid path:", ex));
}
}
if (result.Succeeded)
{
if (!FileSupport.IsFolderReadable(path))
{
return(new CommandResult(false, $"Folder '{path}' does not exist or is not readable"));
}
arg.ResolvedValue = path;
}
}
return(result);
}
public void Run(DateTime dtInit)
{
if (SimulationData.AvailableSnapshots.Count > 0)
{
int rangeSize = _statsRangeLength;
int totalRanges = (int)Math.Round((float)SimulationData.AvailableSnapshots.Count / (float)rangeSize);
SimDateTime firstSnapshotStart = SimulationData.AvailableSnapshots[0];
for (int id = 0; id < totalRanges; id++)
{
_doneEvents.Add(new ManualResetEvent(false));
ThreadPool.QueueUserWorkItem((c) => ProcessSimRange(dtInit, firstSnapshotStart, rangeSize, (int)c), id);
//ProcessSimRange(dtInit, firstSnapshotStart, rangeSize, id);
}
ManualResetEvent.WaitAll(_doneEvents.ToArray());
TimeSpan tsDiff = DateTime.Now - dtInit;
Console.WriteLine($" -> Statistics completed after {(int)tsDiff.TotalMilliseconds} msec.");
}
FileSupport.WaitForPendingWriteOperations();
}
public void SaveStats(string title, string category)
{
FileSupport.SaveAsStats(TE, title, "T_TE_MAP", category);
FileSupport.SaveAsStats(TW, title, "T_TW_MAP", category);
FileSupport.SaveAsStats(TL, title, "T_TL_MAP", category);
FileSupport.SaveAsStats(TS, title, "T_TS_MAP", category);
FileSupport.SaveAsStats(SNOW, title, "N_00_MAP", category);
FileSupport.SaveAsStats(RAIN, title, "R_00_MAP", category);
FileSupport.SaveAsStats(BLIZZARD, title, "B_00_MAP", category);
FileSupport.SaveAsStats(ALBEDO, title, "A_00_MAP", category);
FileSupport.SaveAsStats(Precip, title, "C_00_MAP", category);
FileSupport.SaveAsStats(TLow, title, "T_SL_MAP", category);
FileSupport.SaveAsStats(THigh, title, "T_SH_MAP", category);
FileSupport.SaveAsStats(LIDX, title, "L_00_MAP", category);
FileSupport.SaveAsStats(FOG, title, "F_SI_MAP", category);
FileSupport.SaveAsStats(TNormLow, title, "T_NL_MAP", category);
FileSupport.SaveAsStats(TNormHigh, title, "T_NH_MAP", category);
FileSupport.SaveAsStats((TLow - TNormLow), title, "T_DL_MAP", category);
FileSupport.SaveAsStats((THigh - TNormHigh), title, "T_DH_MAP", category);
FileSupport.SaveAsStats(0.5f * (TLow - TNormLow + THigh - TNormHigh), title, "T_DA_MAP", category);
}
private static int?LoadFileLockViolationHResult()
{
if (Constants.WINDOWS)
{
return(WIN_HRESULT_FILE_LOCK_VIOLATION);
}
// Skip provoking the exception unless we know we will use the value
if (IS_FILESTREAM_LOCKING_PLATFORM)
{
return(FileSupport.GetFileIOExceptionHResult(provokeException: (fileName) =>
{
using (var lockStream = new FileStream(fileName, FileMode.OpenOrCreate, FileAccess.Write, FileShare.ReadWrite))
{
lockStream.Lock(0, 1); // Create an exclusive lock
using (var stream = new FileStream(fileName, FileMode.Open, FileAccess.Write, FileShare.ReadWrite))
{
// try to find out if the file is locked by writing a byte. Note that we need to flush the stream to find out.
stream.WriteByte(0);
stream.Flush(); // this *may* throw an IOException if the file is locked, but...
// ... closing the stream is the real test
}
}
}));
}
return(null);
}
private void InitGeographicalParams()
{
// ------------
string filePath = ".\\ElevationMap.thd";
if (File.Exists(filePath) == false)
{
throw new FileNotFoundException();
}
Height = FileSupport.LoadMatrixFromFile(filePath);
// ------------
filePath = ".\\LandWaterMask.thd";
if (File.Exists(filePath) == false)
{
throw new FileNotFoundException();
}
var wlMask = FileSupport.LoadMatrixFromFile(filePath);
var he = Height.EQ(8);
WL.Assign((r, c) =>
{
var sgn = 0f;
sgn = Math.Sign(wlMask[r, c]);
if (sgn == 1)
{
return(1);
}
if (he[r, c] >= 50f)
{
return(0);
}
return(1);
});
// ------------
filePath = ".\\ADJ_LR.thd";
if (File.Exists(filePath) == false)
{
throw new FileNotFoundException();
}
this.ADJ_LR = FileSupport.LoadMatrixFromFile(filePath);
// ------------
filePath = ".\\albedo.thd";
if (File.Exists(filePath) == false)
{
throw new FileNotFoundException();
}
this.ALBEDO = FileSupport.LoadMatrixFromFile(filePath);
this.DEF_ALBEDO = FileSupport.LoadMatrixFromFile(filePath);
}
public void Save(string title)
{
FileSupport.Save(TE, title, "T_TE_MAP");
FileSupport.Save(TW, title, "T_TW_MAP");
FileSupport.Save(TL, title, "T_TL_MAP");
FileSupport.Save(TS, title, "T_TS_MAP");
FileSupport.Save(SNOW, title, "N_00_MAP");
FileSupport.Save(RAIN, title, "R_00_MAP");
FileSupport.Save(BLIZZARD, title, "B_00_MAP");
FileSupport.Save(ALBEDO, title, "A_00_MAP");
FileSupport.Save(Precip, title, "C_00_MAP");
FileSupport.Save(TLow, title, "T_SL_MAP");
FileSupport.Save(THigh, title, "T_SH_MAP");
FileSupport.Save(LIDX, title, "L_00_MAP");
FileSupport.Save(FOG, title, "F_SI_MAP");
FileSupport.Save(TNormLow, title, "T_NL_MAP");
FileSupport.Save(TNormHigh, title, "T_NH_MAP");
FileSupport.Save(TLow - TNormLow, title, "T_DL_MAP");
FileSupport.Save(THigh - TNormHigh, title, "T_DH_MAP");
FileSupport.Save(0.5f * (TLow - TNormLow + THigh - TNormHigh).EQ(), title, "T_DA_MAP");
FileSupport.Save((1000 * WL - MatrixFactory.Init(500)), title, "E_00_MAP");
}
/// <summary>
/// Sort a single partition in-memory. </summary>
private FileInfo SortPartition(int len) // LUCENENET NOTE: made private, since protected is not valid in a sealed class
{
var data = this.buffer;
FileInfo tempFile = FileSupport.CreateTempFile("sort", "partition", DefaultTempDir());
long start = Environment.TickCount;
sortInfo.SortTime += (Environment.TickCount - start);
using (var @out = new ByteSequencesWriter(tempFile))
{
BytesRef spare;
IBytesRefIterator iter = buffer.GetIterator(comparer);
while ((spare = iter.Next()) != null)
{
Debug.Assert(spare.Length <= ushort.MaxValue);
@out.Write(spare);
}
}
// Clean up the buffer for the next partition.
data.Clear();
return(tempFile);
}
public ProgressBar(FileSupport sfItem)
{
Finished = false;
CurrentFile = null;
CurrentPct = 0;
CopySfItemObj = sfItem;
}
public static FolderStatus Validate(string path)
{
FolderStatus status = FolderStatus.Valid;
if (String.IsNullOrEmpty(path))
{
status |= FolderStatus.NullPath;
}
else if (!FileSupport.IsValidPath(path))
{
status |= FolderStatus.InvalidPath;
}
else if (!System.IO.Path.IsPathFullyQualified(path))
{
status |= FolderStatus.NotFullyQualified;
}
else if (!Directory.Exists(path))
{
status |= FolderStatus.Nonextant;
}
else if (!FileSupport.IsFolderReadable(path))
{
status |= FolderStatus.Unreadable;
}
return(status);
}
/// <summary>
/// Sort a single partition in-memory. </summary>
private FileInfo SortPartition(/*int len*/) // LUCENENET NOTE: made private, since protected is not valid in a sealed class. Also eliminated unused parameter.
{
var data = this.buffer;
FileInfo tempFile = FileSupport.CreateTempFile("sort", "partition", DefaultTempDir());
long start = Environment.TickCount;
sortInfo.SortTime += (Environment.TickCount - start);
using (var @out = new ByteSequencesWriter(tempFile))
{
IBytesRefEnumerator iter = buffer.GetEnumerator(comparer);
while (iter.MoveNext())
{
if (Debugging.AssertsEnabled)
{
Debugging.Assert(iter.Current.Length <= ushort.MaxValue);
}
@out.Write(iter.Current);
}
}
// Clean up the buffer for the next partition.
data.Clear();
return(tempFile);
}
public void ProjectPath_finds_project_in_parent_directory()
{
// This test expects current file structure
var path = Path.GetDirectoryName(AppDomain.CurrentDomain.BaseDirectory);
Assert.IsNotNull(FileSupport.ProjectPath(path));
}
public void Can_load_code_eventsource_from_file()
{
var str = FileSupport.GetFileContents(@"..\..\EventSource1.cfcs");
var root = RDom.CSharp.Load(str);
Assert.IsNotNull(root);
}
public Atmosphere(EarthModel earth, bool loadFromStateFiles, float defaultValue = 0)
{
this.Earth = earth;
SeaLevel = new SeaLevel(earth, loadFromStateFiles, defaultValue);
MidLevel = new MidLevel(earth, loadFromStateFiles, defaultValue);
TopLevel = new TopLevel(earth, loadFromStateFiles, defaultValue);
JetLevel = new JetLevel(earth, loadFromStateFiles, defaultValue);
if (loadFromStateFiles == false)
{
if (defaultValue == 0)
{
TopLevel.LoadInitialConditions();
MidLevel.LoadInitialConditions();
CalculateAirMassType();
SeaLevel.LoadInitialConditions();
}
else
{
AirMass = MatrixFactory.Init(defaultValue);
}
}
else
{
AirMass = FileSupport.Load(Earth.UTC.Title, "M_00_MAP");
}
}
public void GetFileContents_returns_contents()
{
var path = AppDomain.CurrentDomain.BaseDirectory;
var file = Path.Combine(path, @"..\..\normal.kadcs");
var results = FileSupport.GetFileContents(file);
Assert.IsTrue(results.StartsWith("using KadMan.Common;"));
}
public DownloadAction(FileSupport fileSupport, Client.ShareFileClient client, int downloadId, Models.File child, FileSystemInfo target, ActionType type)
{
this.child = child;
this.client = client;
this.downloadId = downloadId;
this.target = target;
this.actionType = type;
this.fileSupportDelegate = fileSupport;
}
protected override void ProcessRecord()
{
ResumeSupport = new Resume.ResumeSupport();
FileSupport = new FileSupport(MarkFileStatus);
if (Resume)
{
if (ResumeSupport.IsPending)
{
Logger.Instance.Info("Last command wasn't successful due to discconnection.");
WriteObject("Last command wasn't successful due to discconnection, enter 'y' to complete or any other key to ignore: ");
Collection<PSObject> result = InvokeCommand.InvokeScript("Read-Host");
string userOption = result != null && result.Count > 0 ? result[0].ToString() : string.Empty;
if (userOption.ToLower().Equals("y"))
{
Logger.Instance.Info("Copying those files which were missed due to discconnection with following parameters. Source Path:{0} Destination:{1} Forced:{2} Details:{3}",
String.Join(",", ResumeSupport.GetPath), ResumeSupport.GetDestination, ResumeSupport.GetForce, ResumeSupport.GetDetails);
StartCopying(ResumeSupport.GetPath, ResumeSupport.GetDestination, ResumeSupport.GetForce, ResumeSupport.GetDetails);
Logger.Instance.Info("Copying operation completed for missing files");
ResumeSupport.End();
WriteObject("Last command completed, starting current operation");
}
}
}
else
{
ResumeSupport.UnmarkResumeFlag();
}
Logger.Instance.Info(String.Format("Starting Copy Operation with following parameters. Source Path:{0} Destination:{1} Forced:{2} Details:{3}",
String.Join(",", Path), Destination, Force, Details));
if (Resume) ResumeSupport.Start(Path, Destination, Force, Details);
StartCopying(Path, Destination.Trim(), Force, Details);
Thread.Sleep(100);
if (Resume) ResumeSupport.End();
WriteObject("Files copied successfully");
}
/// <summary>
/// Sync-SFItem Command is invoked
/// </summary>
protected override void ProcessRecord()
{
FileSupport = new FileSupport(TestMethod);
ProviderInfo providerInfo;
PSDriveInfo driveInfo;
if (Upload && Download)
{
throw new PSArgumentException("Provide only one switch to Upload or Download the files");
}
if (!string.IsNullOrEmpty(ShareFilePath))
{
if (!Upload && !Download)
{
throw new PSArgumentException("Upload or Download switch must be specified");
}
if (string.IsNullOrEmpty(LocalPath) || string.IsNullOrEmpty(LocalPath.Trim()))
{
// use current user directory location if Local path is not specified in arguments
LocalPath = this.SessionState.Path.CurrentFileSystemLocation.Path;
}
if (Synchronize)
{
Recursive = true;
}
if (Move)
{
Recursive = true;
}
ShareFilePath = ShareFilePath.Trim();
LocalPath = LocalPath.Trim();
ActionType actionType = OverWrite ? ActionType.Force : (Synchronize ? ActionType.Sync : ActionType.None);
int transactionId = new Random((int)DateTime.Now.Ticks).Next();
// if current user directory is local storage and ShareFile path provided withouth drive letter then append the drive letter with sharefile location
if (this.SessionState.Path.CurrentLocation.Provider.ImplementingType != typeof(ShareFileProvider) && ShareFilePath.IndexOf(":") < 1)
{
Collection<PSDriveInfo> providerDrives = this.SessionState.Drive.GetAll();// ForProvider("ShareFile");
foreach (PSDriveInfo driveObj in providerDrives)
{
if (driveObj.Provider.ImplementingType == typeof(ShareFileProvider))
{
if (ShareFilePath.StartsWith("/") || ShareFilePath.StartsWith(@"\"))
{
ShareFilePath = ShareFilePath.Substring(1);
}
string sfDrive = String.Format("{0}:/", driveObj.Name);
ShareFilePath = Path.Combine(sfDrive, ShareFilePath);
break;
}
}
}
var sourcePath = Upload ? LocalPath : ShareFilePath;
// it will resolve paths if wildcards are used e.g. "D:\\*.txt" then get paths of all files with txt extension from D:\\ location
var resolvedPaths = this.GetResolvedProviderPathFromPSPath(sourcePath, out providerInfo);
if (Download)
{
this.SessionState.Path.GetUnresolvedProviderPathFromPSPath(sourcePath, out providerInfo, out driveInfo);
var client = ((ShareFileDriveInfo)driveInfo).Client;
StartDownload(client, driveInfo, resolvedPaths, actionType);
}
else
{
var unresolvedPath = this.SessionState.Path.GetUnresolvedProviderPathFromPSPath(ShareFilePath, out providerInfo, out driveInfo);
var client = ((ShareFileDriveInfo)driveInfo).Client;
Item targetItem = ShareFileProvider.GetShareFileItem((ShareFileDriveInfo)driveInfo, unresolvedPath);
if (targetItem == null && !unresolvedPath.StartsWith(String.Format(@"\{0}\", Utility.DefaultSharefileFolder)))
{
string updatedPath = String.Format(@"\{0}\{1}", Utility.DefaultSharefileFolder, unresolvedPath);
targetItem = ShareFileProvider.GetShareFileItem((ShareFileDriveInfo)driveInfo, updatedPath, null, null);
}
//else if (targetItem == null)
//{
// targetItem = ShareFileProvider.GetShareFileItem((ShareFileDriveInfo)driveInfo, ShareFilePath, null, null);
//}
if (targetItem == null)
{
throw new FileNotFoundException("Destination path not found on ShareFile server.");
}
// if user didn't specify the Sharefile HomeFolder in path then appending in path
// e.g. if user tries sf:/Folder1 as sharefile target then resolve this path to sf:/My Files & Folders/Folder1
if ((targetItem as Folder).Info.IsAccountRoot == true)
{
string updatedPath = String.Format(@"\{0}\{1}", Utility.DefaultSharefileFolder, unresolvedPath);
targetItem = ShareFileProvider.GetShareFileItem((ShareFileDriveInfo)driveInfo, updatedPath, null, null);
}
StartUpload(client, transactionId, targetItem, resolvedPaths, actionType);
}
WriteObject("Sync operation successfully completed.");
}
if (Help)
{
WriteObject("SFCLI version " + Resources.Version);
}
}
