/// <summary>
/// Main method.
/// </summary>
/// <param name="args">Arguments for the notification.</param>
static void Main(string[] args)
{
//Initialize application type. TODO: Replace this with dependency injection.
Globals.ApplicationType = ApplicationTypes.WindowsDesktop;
var arguments = ArgumentManager.ProcessArguments(args);
if (arguments == null)
{
WriteLine($"{Globals.HelpForNullMessage}{Globals.HelpForErrors}");
ArgumentManager.DisplayHelp();
}
else
{
if (arguments.Register)
{
if (ShortcutHelper.CreateShortcutIfNeeded(arguments.ApplicationId, arguments.ApplicationName))
{
WriteLine(string.Format(Globals.HelpForRegisterSuccess, arguments.ApplicationId, arguments.ApplicationName));
}
else
{
WriteLine(string.Format(Globals.HelpForRegisterFail, arguments.ApplicationId, arguments.ApplicationName));
}
}
if (arguments.NotificationsCheck)
{
WriteLine(RegistryHelper.AreNotificationsEnabled(arguments.NotificationCheckAppId));
}
if (arguments.PushNotificationCheck)
{
WriteLine(RegistryHelper.ArePushNotificationsEnabled());
}
if (string.IsNullOrEmpty(arguments.Errors) && !string.IsNullOrEmpty(arguments.Message))
{
SendNotification(arguments);
while (arguments.Wait)
{
System.Threading.Thread.Sleep(500);
}
}
else
{
WriteLine($"{(arguments.Errors ?? string.Empty)}");
}
}
}
private void CheckForExtraHelpArguments(ParseResult <TOption> result, ArgumentManager argumentManager)
{
var unusedArg = argumentManager.UnusedArguments
.Where(a => string.Equals(a.Argument, m_helpOptionName, StringComparison.InvariantCultureIgnoreCase) ||
string.Equals(a.Argument, m_helpOptionNameLong, StringComparison.InvariantCultureIgnoreCase))
.FirstOrDefault();
if (unusedArg == null)
{
return;
}
result.HelpRequestedFor = unusedArg.ArgModel ?? this;
}
/// <summary>
/// Handles the call
/// </summary>
/// <param name="method"></param>
/// <param name="arguments"></param>
public override void HandleMethodCall(MethodInfo method, object[] arguments)
{
Method = method;
if (ArgumentManager.HasBeenUsed)
{
ArgumentManager.ValidateMethodSignature(method);
Arguments = ArgumentManager.GetConstraints();
ReturnArguments = ArgumentManager.GetReturnValues();
SetExpectedCount(new Range(1, null));
ArgumentManager.Clear();
return;
}
var argumentNullCount = 0;
var parameters = method.GetParameters();
var constraints = new AbstractConstraint[parameters.Length];
for (int index = 0; index < parameters.Length; index++)
{
var parameter = parameters[index];
if (parameter.IsOut)
{
constraints[index] = Is.Anything();
}
else
{
var argument = arguments[index];
if (argument == null)
{
argumentNullCount++;
}
constraints[index] = Is.Equal(argument);
}
}
if (argumentNullCount == parameters.Length)
{
for (int index = 0; index < parameters.Length; index++)
{
constraints[index] = Is.Anything();
}
}
Arguments = constraints;
}
/// <summary>
/// Constructs an instance of the Mock Repository.
/// </summary>
/// <remarks>
/// There is very little reason to instantiate an instance of MockRepository.
/// This is intended for internal use only.
/// </remarks>
public MockRepository()
{
delegateRepository = new RepositoryForDelegates();
generatorOptions = new ProxyGenerationOptions
{
Selector = new RhinoSelector(),
};
generatorOptions.AdditionalAttributes
.Add(AttributeUtil.CreateBuilder <__ProtectAttribute>());
defaultOptions = new ProxyGenerationOptions
{
Selector = new RhinoSelector(),
};
ArgumentManager.Clear();
}
/// <summary>
/// Parses the commandline arguments
/// </summary>
/// <param name="args">arguments from the commandline</param>
/// <returns>The result of the parsing, <see cref="IParserResult{TResult}"/></returns>
public IParserResult <TOption> Parse(string[] args)
{
var errors = new List <Exception>();
var result = new ParseResult <TOption>();
var argumentManager = new ArgumentManager(args, ParserOptions, m_helpOptionName, m_helpOptionNameLong, m_commands, m_options.Values.Cast <ICommandLineOption>().ToArray());
ParseCommands(errors, result, argumentManager);
ParseOptions(errors, result, argumentManager);
CheckForExtraHelpArguments(result, argumentManager);
result.MergeResult(errors);
AutoExecuteCommands(result);
AutoPrintUsageAndErrors(result, args.Length == 0);
return(result);
}
private ArgumentManager InitializeArgs()
{
var args = Environment.GetCommandLineArgs();
//var temp = new string[temp.Length - 1];
//for (int i = 1; i < temp.Length; ++i)
// temp[i - 1] = args[i];
//args = temp;
foreach (var s in args)
{
SimpleIoc.Default.GetInstance <ILogService>().GetLogger("Arguments").Info(s);
}
var manager = new ArgumentManager(args);
SimpleIoc.Default.Register(() => manager);
return(manager);
}
static void Main(string[] args)
{
Console.Out.WriteLine("Cha0s Data Tools - SDK Wrapper");
Console.Out.WriteLine("==============================");
try
{
CrmServiceClient service = null;
Arguments arguments = ArgumentManager.ParseArguments(args);
if (!string.IsNullOrWhiteSpace(arguments.ConnectionString))
{
service = ServiceManager.CreateOrganizationService(arguments.ConnectionString);
}
else if (arguments.Url != null)
{
service = ServiceManager.CreateOrganizationService(arguments.Url.ToString(), arguments.Username, arguments.Password);
}
switch (arguments.Action)
{
case "pluginassembly":
Console.Out.WriteLine("Register Plugin Assembly");
PluginManager.UpdateAssembly(service, arguments.Solution, arguments.AdditionalArgs.First());
Console.Out.WriteLine("Completed Plugin Assembly Registration");
break;
default:
Console.Out.WriteLine("Unrecognized command, exiting...");
break;
}
}
catch (Exception ex)
{
Console.Error.WriteLine(ex.ToString());
}
}
/// <summary>
/// Parses the commandline arguments async
/// </summary>
/// <param name="args">arguments from the commandline</param>
/// <param name="cancellationToken"></param>
/// <returns>The result of the parsing, <see cref="IParserResult{TResult}"/></returns>
public async Task <IParserResult <TOption> > ParseAsync(string[] args, CancellationToken cancellationToken = default)
{
var errors = new List <Exception>();
var result = new ParseResult <TOption>();
ArgumentManager.Process(args, errors, this);
CheckForGlobalHelpOption(result);
await ParseCommandsAsync(errors, result, cancellationToken);
ParseOptions(errors, result);
await ValidateAsync(m_option, result, errors, cancellationToken);
result.MergeResult(errors);
await AutoExecuteCommandsAsync(result, cancellationToken);
AutoPrintUsageAndErrors(result, NoActualArgsSupplied(args.Length));
return(result);
}
/// <summary>
/// Handles the call
/// </summary>
/// <param name="method"></param>
/// <param name="arguments"></param>
public override void HandleMethodCall(MethodInfo method, object[] arguments)
{
if (!method.IsSpecialName)
{
throw new InvalidOperationException("Property expectations can only be set for properties.");
}
var methodName = method.Name;
if (!methodName.StartsWith("get_") && !methodName.StartsWith("set_"))
{
throw new InvalidOperationException("Property expectations can only be set for properties.");
}
var propertyName = method.Name.Substring(4);
PropertyInfo property;
if (methodName.StartsWith("get_"))
{
var types = new Type[arguments.Length];
if (arguments.Length > 0)
{
for (int argumentIndex = 0; argumentIndex < arguments.Length; argumentIndex++)
{
types[argumentIndex] = arguments[argumentIndex].GetType();
}
}
property = method.DeclaringType.GetProperty(propertyName, types);
}
else
{
var argumentLength = (arguments.Length - 1);
var types = new Type[argumentLength];
if (argumentLength > 0)
{
for (int argumentIndex = 0; argumentIndex < argumentLength; argumentIndex++)
{
types[argumentIndex] = arguments[argumentIndex].GetType();
}
}
property = method.DeclaringType.GetProperty(propertyName, types);
}
MethodGet = property.GetGetMethod(true);
MethodSet = property.GetSetMethod(true);
if (MethodGet == null || MethodSet == null)
{
throw new InvalidOperationException("Property must be read/write.");
}
if (ArgumentManager.HasBeenUsed)
{
ArgumentManager.ValidateMethodSignature(method);
Arguments = ArgumentManager.GetConstraints();
ReturnArguments = ArgumentManager.GetReturnValues();
SetExpectedCount(new Range(1, null));
ArgumentManager.Clear();
return;
}
var parameters = method.GetParameters();
var constraints = new AbstractConstraint[parameters.Length];
for (int index = 0; index < parameters.Length; index++)
{
var parameter = parameters[index];
constraints[index] = (parameter.IsOut)
? Is.Anything()
: Is.Equal(arguments[index]);
}
Arguments = constraints;
}
