internal string GetUserName()
{
if (this.Account == ServiceAccount.NetworkService)
{
return(@"NT AUTHORITY\NetworkService");
}
else if (this.Account == ServiceAccount.LocalSystem)
{
return("LocalSystem");
}
else if (this.Account == ServiceAccount.LocalService)
{
return(@"NT AUTHORITY\LocalService");
}
else
{
if (!UserName.IsNullOrWhiteSpace())
{
return(ChoEnvironment.ToDomainUserName(UserName));
}
else
{
ChoConsole.Write("Enter UserId: ");
return(ChoEnvironment.ToDomainUserName(ChoConsole.ReadLine()));
}
}
}
internal string GetPassword()
{
if (this.Account == ServiceAccount.NetworkService)
{
return(String.Empty);
}
else if (this.Account == ServiceAccount.LocalSystem)
{
return(String.Empty);
}
else if (this.Account == ServiceAccount.LocalService)
{
return(String.Empty);
}
else
{
if (!UserName.IsNullOrWhiteSpace())
{
return(Password);
}
else
{
ChoConsole.Write("Enter Password: ");
return(ChoConsole.ReadPassword());
}
}
}
public void Start(ChoConsoleProgressorStart consoleProgressorStart, ChoAsyncCallback callback, object state, int timeout)
{
ChoGuard.NotDisposed(this);
int isStarted = Interlocked.CompareExchange(ref _isStarted, 1, 0);
if (isStarted == 1)
{
return;
}
Interlocked.CompareExchange(ref _stopRequested, 0, 1);
lock (ChoConsole.SyncRoot)
{
ChoConsole.Clear();
ChoConsole.ClearKeys();
IChoAsyncResult result = ChoConsole.OutputQueuedExecutionService.Enqueue(() =>
{
_location = WriteNSavePosition(_msg + " ");
_statusMsgLocation = new ChoPoint(_consolePercentageProgressorSettings.ProgressBarMarginX, _location.Y + 1);
WriteSpinner("/");
});
result.AsyncWaitHandle.WaitOne();
}
Action <ChoConsoleSpinProgressor> wrappedFunc = delegate
{
_threadToKill = Thread.CurrentThread;
try
{
while (true)
{
if (_stopRequested == 1)
{
break;
}
ChoConsole.WriteLine(GetNextSpinChar().ToString(), _location, _foregroundColor, _backgroundColor);
bool retValue = consoleProgressorStart(this, state);
if (!retValue)
{
break;
}
}
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
};
_result = ChoAbortableQueuedExecutionService.Global.Enqueue <ChoConsoleSpinProgressor>(wrappedFunc, this);
}
private void SetStatusMsg(string statusMsg)
{
if (statusMsg != null && statusMsg.Length > _consolePercentageProgressorSettings.ProgressBarStatusMsgSize)
{
statusMsg = statusMsg.Substring(0, _consolePercentageProgressorSettings.ProgressBarStatusMsgSize);
}
ChoConsole.Write(statusMsg.PadRight(_consolePercentageProgressorSettings.ProgressBarStatusMsgSize), _statusMsgLocation, _consolePercentageProgressorSettings.ProgressBarStatusMsgForegroundColor,
_consolePercentageProgressorSettings.ProgressBarStatusMsgBackgroundColor);
}
public void Write(string msg)
{
if (HasPositionSpecified)
{
ChoConsole.Write(msg, _cursorLeft.Value, _cursorTop.Value, _foregroundColor, _backgroundColor);
}
else
{
ChoConsole.Write(msg, _foregroundColor, _backgroundColor);
}
}
private bool SetPercentageComplete(int percentage)
{
if (percentage < MinPercentage)
{
throw new ChoConsoleException(String.Format("Percentage must be >= {0}", MinPercentage));
}
if (percentage > MaxPercentage)
{
throw new ChoConsoleException(String.Format("Percentage must be <= {0}", MaxPercentage));
}
ChoConsole.WriteLine(String.Format("[{0}%]", percentage).PadRight(_padLength + 3), _location, _foregroundColor, _backgroundColor);
return(percentage < MaxPercentage);
}
private void PrintHeader()
{
string applicationName = ApplicationName;
if (applicationName.IsNullOrWhiteSpace())
{
applicationName = ChoGlobalApplicationSettings.Me.ApplicationName;
}
string version = ChoAssembly.GetEntryAssembly().GetName().Version.ToString();
ChoConsole.WriteLine("{0} [Version {1}]".FormatString(applicationName, version));
if (!Copyright.IsNullOrWhiteSpace())
{
ChoConsole.WriteLine(Copyright);
}
ChoConsole.WriteLine();
}
public void StartFileCopy(string sourceDirectory = null, string destDirectory = null)
{
try
{
ChoAppSettings appSettings = new ChoAppSettings();
if (!SettingsFilePath.IsNullOrWhiteSpace())
{
if (!File.Exists(SettingsFilePath))
{
throw new ArgumentException("Can't find '{0}' settings file.".FormatString(SettingsFilePath));
}
appSettings.LoadXml(File.ReadAllText(SettingsFilePath));
}
ChoConsole.WriteLine();
ChoRoboCopyManager _roboCopyManager = new ChoRoboCopyManager(SettingsFilePath);
_roboCopyManager.Status += (sender, e) =>
{
ChoTrace.Write(e.Message);
ChoConsole.Write(e.Message, ConsoleColor.Yellow);
};
_roboCopyManager.AppStatus += (sender, e) =>
{
ChoTrace.Write(e.Message);
ChoConsole.Write(e.Message, ConsoleColor.Yellow);
};
_roboCopyManager.Process(appSettings.RoboCopyFilePath, appSettings.GetCmdLineParams(),
appSettings, true);
}
catch (ThreadAbortException)
{
Console.WriteLine("RoboCopy operation cancelled by user.");
}
catch (Exception ex)
{
Console.WriteLine("RoboCopy operation failed." + Environment.NewLine + ChoApplicationException.ToString(ex));
}
}
public void Start(ChoConsolePercentageProgressorStart consolePercentageProgressorStart, ChoAsyncCallback callback, object state, int timeout)
{
ChoGuard.NotDisposed(this);
//if (_isStarted) return;
int isStarted = Interlocked.CompareExchange(ref _isStarted, 1, 0);
if (isStarted == 1)
{
return;
}
Interlocked.CompareExchange(ref _stopRequested, 0, 1);
lock (ChoConsole.SyncRoot)
{
ChoConsole.Clear();
ChoConsole.ClearKeys();
IChoAsyncResult result = ChoConsole.OutputQueuedExecutionService.Enqueue(() =>
{
_location = WriteNSavePosition(_msg + " ");
_statusMsgLocation = new ChoPoint(_consolePercentageProgressorSettings.ProgressBarMarginX, _location.Y + 1);
WritePercentage("[0%]");
});
result.AsyncWaitHandle.WaitOne();
SetPercentageComplete(MinPercentage);
}
Action <ChoConsolePercentageProgressor, int> wrappedFunc = delegate
{
_threadToKill = Thread.CurrentThread;
try
{
int percentage = MinPercentage;
int retPercentage = MinPercentage;
while (retPercentage < MaxPercentage)
{
if (_stopRequested == 1)
{
break;
}
retPercentage = consolePercentageProgressorStart(this, percentage, state);
if (percentage >= retPercentage)
{
throw new ChoConsoleException("Returned percentage '{0}' value <= running percentage '{1}' value. It may leads to infinite loop.".FormatString(retPercentage, percentage));
}
else
{
percentage = retPercentage;
}
lock (ChoConsole.SyncRoot)
{
SetPercentageComplete(retPercentage);
}
}
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
};
//try
//{
// ChoAPM.InvokeMethod(wrappedFunc, new object[] { this, MinPercentage }, timeout);
//}
//catch (Exception ex)
//{
// ErrorOccured(this, new ChoExceptionEventArgs(ex));
//}
_result = ChoAbortableQueuedExecutionService.Global.Enqueue <ChoConsolePercentageProgressor, int>(wrappedFunc, this, MinPercentage, callback, state, timeout);
}
public void Clear()
{
ChoConsole.Clear();
}
static ChoConsoleSpinProgressor()
{
ChoConsole.Initialize();
}
/// <summary>
/// Reads the next character from the standard input stream within the specified timeout period.
/// </summary>
/// <param name="timeoutInMilliSeconds">A System.TimeSpan that represents the number of milliseconds to wait, or a System.TimeSpan that represents -1 milliseconds to wait indefinitely.</param>
/// <param name="defaultValue">A default value will be returned from this call when the timeout period elapsed while reading from console.</param>
/// <returns>The next line of characters from the input stream, or null if no more lines</returns>
public int Read(int timeoutInMilliSeconds, int?defaultValue)
{
return(ChoConsole.Read(timeoutInMilliSeconds, defaultValue));
}
/// <summary>
/// Reads the next line of characters from the standard input stream within the specified timeout period.
/// </summary>
/// <param name="timeoutInMilliSeconds">A System.TimeSpan that represents the number of milliseconds to wait, or a System.TimeSpan that represents -1 milliseconds to wait indefinitely.</param>
/// <param name="defaultValue">A default value will be returned from this call when the timeout period elapsed while reading from console.</param>
/// <param name="errMsg">A error message used to throw ChoTimeoutException when timeout happens while reading line from console and default value is not specified.</param>
/// <returns>The next line of characters from the input stream, or null if no more lines</returns>
public string ReadLine(int timeoutInMilliSeconds, string defaultValue, string errMsg)
{
return(ChoConsole.ReadLine(timeoutInMilliSeconds, defaultValue, errMsg));
}
public void Start(ChoConsolePercentageProgressorStartEx consolePercentageProgressorStart, ChoAsyncCallback callback, object state, int timeout)
{
ChoGuard.NotDisposed(this);
int isStarted = Interlocked.CompareExchange(ref _isStarted, 1, 0);
if (isStarted == 1)
{
return;
}
Interlocked.CompareExchange(ref _stopRequested, 0, 1);
lock (ChoConsole.SyncRoot)
{
ChoConsole.Clear();
ChoConsole.ClearKeys();
_consoleCoordinate = new ConsoleCoordinate((short)(Console.CursorLeft + _consolePercentageProgressorSettings.ProgressBarMarginX),
(short)(Console.CursorTop + _consolePercentageProgressorSettings.ProgressBarMarginY));
ShowProgress(MinPercentage, _msg);
}
Action <ChoConsolePercentageProgressorEx, int> wrappedFunc = delegate
{
_threadToKill = Thread.CurrentThread;
try
{
int percentage = MinPercentage;
int retPercentage = MinPercentage;
while (retPercentage < MaxPercentage)
{
if (_stopRequested == 1)
{
break;
}
Tuple <int, string> retValue = consolePercentageProgressorStart(this, percentage, state);
retPercentage = retValue.Item1;
if (percentage >= retPercentage)
{
throw new ChoConsoleException("Returned percentage '{0}' value <= running percentage '{1}' value. It may leads to infinite loop.".FormatString(retPercentage, percentage));
}
else
{
percentage = retPercentage;
}
ShowProgress(retPercentage, retValue.Item2);
}
}
catch (ThreadAbortException)
{
Thread.ResetAbort();
}
finally
{
Console.WriteLine();
Console.WriteLine();
Console.ResetColor();
}
};
_result = ChoAbortableQueuedExecutionService.Global.Enqueue <ChoConsolePercentageProgressorEx, int>(wrappedFunc, this, MinPercentage, callback, state, timeout);
}
/// <summary>
/// Writes the default string value, followed by the current line terminator, to the standard output stream.
/// Reads the next line of characters from the standard input stream.
/// </summary>
/// <param name="msg">The string message to be written to the console.</param>
/// <returns>The next line of characters from the input stream, or null if no more lines are available.</returns>
public string PauseLine(string msg)
{
return(ChoConsole.PauseLine(msg));
}
/// <summary>
/// Reads the next character from the standard input stream.
/// </summary>
public int Read()
{
return(ChoConsole.Read());
}
public string ReadPassword(int maxLength)
{
return(ChoConsole.ReadPassword(maxLength));
}
/// <summary>
/// Reads the next character from the standard input stream within the specified timeout period.
/// </summary>
/// <param name="timeoutInMilliSeconds">A System.TimeSpan that represents the number of milliseconds to wait, or a System.TimeSpan that represents -1 milliseconds to wait indefinitely.</param>
/// <param name="defaultValue">A default value will be returned from this call when the timeout period elapsed while reading from console.</param>
/// <param name="errMsg">A error message used to throw ChoTimeoutException when timeout happens while reading line from console and default value is not specified.</param>
/// <returns>
/// A System.ConsoleKeyInfo object that describes the System.ConsoleKey constant and Unicode character, if any, that correspond to the pressed console key.
/// The System.ConsoleKeyInfo object also describes, in a bitwise combination of System.ConsoleModifiers values, whether one or more SHIFT, ALT, or
/// CTRL modifier keys was pressed simultaneously with the console key.
/// </returns>
public ConsoleKeyInfo ReadKey(int timeoutInMilliSeconds)
{
return(ChoConsole.ReadKey(timeoutInMilliSeconds));
}
/// <summary>
/// Reads the next character from the standard input stream within the specified timeout period.
/// </summary>
/// <param name="timeoutInMilliSeconds">A System.TimeSpan that represents the number of milliseconds to wait, or a System.TimeSpan that represents -1 milliseconds to wait indefinitely.</param>
/// <param name="defaultValue">A default value will be returned from this call when the timeout period elapsed while reading from console.</param>
/// <param name="errMsg">A error message used to throw ChoTimeoutException when timeout happens while reading line from console and default value is not specified.</param>
/// <returns>
/// A System.ConsoleKeyInfo object that describes the System.ConsoleKey constant and Unicode character, if any, that correspond to the pressed console key.
/// The System.ConsoleKeyInfo object also describes, in a bitwise combination of System.ConsoleModifiers values, whether one or more SHIFT, ALT, or
/// CTRL modifier keys was pressed simultaneously with the console key.
/// </returns>
public ConsoleKeyInfo ReadKey(int timeoutInMilliSeconds, ConsoleKeyInfo?defaultValue, string errMsg)
{
return(ChoConsole.ReadKey(timeoutInMilliSeconds, defaultValue, errMsg));
}
/// <summary>
/// Reads the next character from the standard input stream.
/// </summary>
/// <returns>
/// A System.ConsoleKeyInfo object that describes the System.ConsoleKey constant and Unicode character, if any, that correspond to the pressed console key.
/// The System.ConsoleKeyInfo object also describes, in a bitwise combination of System.ConsoleModifiers values, whether one or more SHIFT, ALT, or
/// CTRL modifier keys was pressed simultaneously with the console key.
/// </returns>
public ConsoleKeyInfo ReadKey()
{
return(ChoConsole.ReadKey());
}
static ChoConsoleSession()
{
ChoConsole.Initialize();
}
/// <summary>
/// Reads the next character from the standard input stream within the specified timeout period.
/// </summary>
/// <param name="timeoutInMilliSeconds">A System.TimeSpan that represents the number of milliseconds to wait, or a System.TimeSpan that represents -1 milliseconds to wait indefinitely.</param>
/// <param name="defaultValue">A default value will be returned from this call when the timeout period elapsed while reading from console.</param>
/// <param name="errMsg">A error message used to throw ChoTimeoutException when timeout happens while reading line from console and default value is not specified.</param>
/// <returns>The next line of characters from the input stream, or null if no more lines</returns>
public int Read(int timeoutInMilliSeconds, int?defaultValue, string errMsg)
{
return(ChoConsole.Read(timeoutInMilliSeconds, defaultValue, errMsg));
}
/// <summary>
/// Reads the next line of characters from the standard input stream within the specified timeout period.
/// </summary>
/// <param name="timeoutInMilliSeconds">A System.TimeSpan that represents the number of milliseconds to wait, or a System.TimeSpan that represents -1 milliseconds to wait indefinitely.</param>
/// <param name="defaultValue">A default value will be returned from this call when the timeout period elapsed while reading from console.</param>
/// <param name="errMsg">A error message used to throw ChoTimeoutException when timeout happens while reading line from console and default value is not specified.</param>
/// <returns>The next line of characters from the input stream, or null if no more lines</returns>
public string ReadLine(int timeoutInMilliSeconds)
{
return(ChoConsole.ReadLine(timeoutInMilliSeconds));
}
public string ReadPassword(char maskChar, int maxLength)
{
return(ChoConsole.ReadPassword(maskChar, maxLength));
}
/// <summary>
/// Reads the next line of characters from the standard input stream.
/// </summary>
public string ReadLine()
{
return(ChoConsole.ReadLine());
}
public static ConsoleKeyInfo[] ClearKeys()
{
return(ChoConsole.ClearKeys());
}
static ChoConsolePercentageProgressorEx()
{
ChoConsole.Initialize();
}
public static ConsoleKeyInfo[] ClearKeys(bool intercept)
{
return(ChoConsole.ClearKeys(intercept));
}
public string ReadPassword()
{
return(ChoConsole.ReadPassword('*'));
}
/// <summary>
/// Reads the next character from the standard input stream within the specified timeout period.
/// </summary>
/// <param name="timeoutInMilliSeconds">A System.TimeSpan that represents the number of milliseconds to wait, or a System.TimeSpan that represents -1 milliseconds to wait indefinitely.</param>
/// <param name="defaultValue">A default value will be returned from this call when the timeout period elapsed while reading from console.</param>
/// <param name="errMsg">A error message used to throw ChoTimeoutException when timeout happens while reading line from console and default value is not specified.</param>
/// <returns>The next line of characters from the input stream, or null if no more lines</returns>
public int Read(int timeoutInMilliSeconds)
{
return(ChoConsole.Read(timeoutInMilliSeconds));
}
