public ParameterParser(IParameterParser parameterParser)
{
if (parameterParser == null)
{
throw new ArgumentNullException("parameterParser cannot be null.");
}
_parser = parameterParser;
}
public PathFinder(IOperationParser operationParser, IResponseParser responseParser,
IParameterParser parameterParser,
string generationFunctionName = null)
{
this.operationParser = operationParser;
this.responseParser = responseParser;
this.parameterParser = parameterParser;
GenerationFunctionName = generationFunctionName ?? "Swagger";
}
/// <summary>
/// 初始化一个<see cref="AuthorizationResult"/>类型的实例
/// </summary>
/// <param name="raw">授权接口返回的原始消息</param>
/// <param name="success">是否成功</param>
/// <param name="type">参数解析器类型</param>
public AuthorizationResult(string raw, Func <AuthorizationResult, bool> success,
ParameterParserType type = ParameterParserType.Json)
{
Raw = raw;
IParameterParserFactory factory = new ParameterParserFactory();
_parser = factory.CreateParameterParser(type);
_parser.LoadData(raw);
Success = success(this);
}
public HttpMessageReceivedHandler(IParameterParser parameterParser,
ISerializer serializer,
IOptions <RpcOptions> rpcOptions,
IServiceExecutor serviceExecutor)
: base(parameterParser,
serializer,
rpcOptions,
serviceExecutor)
{
}
internal void Initialize(IFileSystem fileSystem, IEventSource eventSource,
IEnvironmentProvider environmentProvider, ISubmissionService submissionService,
IParameterParser parameterParser, ILogDataBuilderFactory logDataBuilderFactory)
{
_environmentProvider = environmentProvider;
_parameters = parameterParser.Parse(Parameters);
if (string.IsNullOrWhiteSpace(_parameters.Token))
{
_environmentProvider.WriteLine("BuildCrossCheck Token is not present");
return;
}
if (string.IsNullOrWhiteSpace(_parameters.CloneRoot))
{
_environmentProvider.WriteLine("BuildCrossCheck CloneRoot is not present");
return;
}
if (string.IsNullOrWhiteSpace(_parameters.Owner))
{
_environmentProvider.WriteLine("BuildCrossCheck Owner is not present");
return;
}
if (string.IsNullOrWhiteSpace(_parameters.Repo))
{
_environmentProvider.WriteLine("BuildCrossCheck Repo is not present");
return;
}
if (string.IsNullOrWhiteSpace(_parameters.Hash))
{
_environmentProvider.WriteLine("BuildCrossCheck Hash is not present");
return;
}
if (!_parameters.PullRequestNumber.HasValue)
{
_environmentProvider.WriteLine("BuildCrossCheck PullRequestNumber is not present");
return;
}
_environmentProvider.WriteLine("BuildCrossCheck Enabled");
_configuration = LoadCheckRunConfiguration(fileSystem, _parameters.ConfigurationFile);
_logDataBuilder = logDataBuilderFactory.BuildLogDataBuilder(_parameters, _configuration);
_submissionService = submissionService;
eventSource.BuildStarted += EventSourceOnBuildStarted;
eventSource.BuildFinished += EventSourceOnBuildFinished;
eventSource.WarningRaised += EventSourceOnWarningRaised;
eventSource.ErrorRaised += EventSourceOnErrorRaised;
}
protected MessageReceivedHandlerBase(
IParameterParser parameterParser,
ISerializer serializer,
IOptions <RpcOptions> rpcOptions,
IServiceExecutor serviceExecutor)
{
_parameterParser = parameterParser;
_serializer = serializer;
_serviceExecutor = serviceExecutor;
_rpcOptions = rpcOptions.Value;
}
public CreateNotificationInstanceCommandHandler(
ILogger <CreateNotificationInstanceCommandHandler> logger,
INotificationDefQueryRepository notificationDefQueryRepository,
INotificationInstanceCommandRepository notificationInstanceCommandRepository,
IParameterParser parameterParser)
{
_logger = logger;
_notificationDefQueryRepository = notificationDefQueryRepository;
_notificationInstanceCommandRepository = notificationInstanceCommandRepository;
_parameterParser = parameterParser;
}
public WsMessageReceivedHandler(IParameterParser parameterParser,
ISerializer serializer,
IOptions <RpcOptions> rpcOptions,
IServiceExecutor serviceExecutor,
IRemoteServiceInvoker remoteServiceInvoker,
IOptions <GovernanceOptions> governanceOptions)
: base(parameterParser,
serializer,
rpcOptions,
serviceExecutor)
{
}
public void AddParameter(string name, EndpointParameterType parameterType, IParameterParser parser)
{
var functions = new List <Func <IEndpointRequest, string, string> >();
if (parameterType.HasFlag(EndpointParameterType.QueryString))
{
functions.Add(QueryStringParam);
}
if (parameterType.HasFlag(EndpointParameterType.Header))
{
functions.Add(HeaderParam);
}
if (parameterType.HasFlag(EndpointParameterType.PathSegment))
{
var placeholder = "{" + name + "}";
for (var i = 0; i < _pathElements.Length; i++)
{
var index = i;
if (string.Equals(placeholder, _pathElements[i], StringComparison.OrdinalIgnoreCase))
{
functions.Add((r, n) => PathSegmentParam(r, index));
break;
}
}
}
if (parameterType.HasFlag(EndpointParameterType.FormField))
{
functions.Add(FormFieldParam);
}
var parameter = new EndpointParameter
{
Name = name,
ParameterType = parameterType,
Parser = parser,
Functions = functions.ToArray()
};
if (_parameters == null)
{
_parameters = new[] { parameter };
}
else
{
var parameters = _parameters.ToList();
parameters.Add(parameter);
_parameters = parameters.ToArray();
}
}
public InstantiateSubTaskCommandHandler(
IHumanTaskInstanceQueryRepository humanTaskInstanceQueryRepository,
IHumanTaskInstanceCommandRepository humanTaskInstanceCommandRepository,
IParameterParser parameterParser,
IMediator mediator,
ILogger <InstantiateSubTaskCommandHandler> logger)
{
_humanTaskInstanceQueryRepository = humanTaskInstanceQueryRepository;
_humanTaskInstanceCommandRepository = humanTaskInstanceCommandRepository;
_parameterParser = parameterParser;
_mediator = mediator;
_logger = logger;
}
public ProcessDeadLinesJob(IParameterParser parameterParser,
IMediator mediator,
IDistributedLock distributedLock,
IOptions <CommonOptions> options,
ILogger <BaseScheduledJob> logger,
IScheduledJobStore scheduledJobStore,
IServiceScopeFactory serviceScopeFactory) : base(distributedLock, options, logger, scheduledJobStore)
{
_parameterParser = parameterParser;
_mediator = mediator;
var serviceProvider = serviceScopeFactory.CreateScope().ServiceProvider;
_humanTaskInstanceQueryRepository = serviceProvider.GetService <IHumanTaskInstanceQueryRepository>();
_humanTaskInstanceCommandRepository = serviceProvider.GetService <IHumanTaskInstanceCommandRepository>();
}
public CompleteHumanTaskInstanceCommandHandler(
IHumanTaskInstanceQueryRepository humanTaskInstanceQueryRepository,
IHumanTaskInstanceCommandRepository humanTaskInstanceCommandRepository,
IParameterParser parameteParser,
IHttpClientFactory httpClientFactory,
IServiceProvider serviceProvider,
IOptions <HumanTaskServerOptions> options,
ILogger <CompleteHumanTaskInstanceCommandHandler> logger)
{
_humanTaskInstanceQueryRepository = humanTaskInstanceQueryRepository;
_humanTaskInstanceCommandRepository = humanTaskInstanceCommandRepository;
_parameterParser = parameteParser;
_serviceProvider = serviceProvider;
_httpClientFactory = httpClientFactory;
_options = options.Value;
_logger = logger;
}
public CreateHumanTaskInstanceCommandHandler(
IHumanTaskDefQueryRepository humanTaskDefQueryRepository,
IHumanTaskInstanceCommandRepository humanTaskInstanceCommandRepository,
IHumanTaskDefCommandRepository humanTaskDefCommandRepository,
IAuthorizationHelper authorizationHelper,
IParameterParser parameterParser,
IDeadlineParser deadLineParser,
ILogger <CreateHumanTaskInstanceCommandHandler> logger)
{
_humanTaskDefQueryRepository = humanTaskDefQueryRepository;
_humanTaskDefCommandRepository = humanTaskDefCommandRepository;
_humanTaskInstanceCommandRepository = humanTaskInstanceCommandRepository;
_authorizationHelper = authorizationHelper;
_parameterParser = parameterParser;
_deadlineParser = deadLineParser;
_logger = logger;
}
public ApiAction(MethodInfo method)
{
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (!method.IsPublic)
{
throw new ArgumentOutOfRangeException(nameof(method), "方法必须为public类型");
}
if (method.IsGenericMethod)
{
throw new ArgumentException($"{method.Name}不能为泛型方法", nameof(method));
}
Method = method;
Name = method.Name;
Obsolete = method.GetCustomAttribute <ObsoleteAttribute>() ??
method.ReflectedType.GetCustomAttribute <ObsoleteAttribute>() ??
method.DeclaringType.GetCustomAttribute <ObsoleteAttribute>();
var paras = method.GetParameters();
var parasLength = paras.Length;
var parsers = new IParameterParser[parasLength];
for (var i = 0; i < parasLength; i++)
{
var p = paras[i];
if (p.IsOut || p.ParameterType.IsByRef)
{
throw new ArgumentException("不支持out或ref参数");
}
parsers[i] = ParameterParserFactory.Create(p);
if (p.Attributes.HasFlag(ParameterAttributes.HasDefault) ||
p.HasDefaultValue)
{
parsers[i].DefaultValue = p.RawDefaultValue;
}
}
_parameterParsers = parsers;
_parameterLength = _parameterParsers.Length;
}
public void Setup()
{
parser = new ParameterParser();
}
public int Run(string[] args)
{
const char splitter = '=';
Dictionary <string, string> paramDictionary = new Dictionary <string, string>();
IParameterParser IPP = ActiveDirectoryFactory.GetParameterParserInterface();
paramDictionary = IPP.ParseParameters(args, splitter);
bool domainFlag = false;
string domainString = string.Empty;
bool userFlag = false;
string userString = string.Empty;
bool groupFlag = false;
string groupString = string.Empty;
bool passwordFlag = false;
string passwordString = string.Empty;
foreach (KeyValuePair <string, string> keyValuePair in paramDictionary)
{
switch (keyValuePair.Key)
{
case "-h":
IHelper IH = ActiveDirectoryFactory.GetHelperDirectoryInterface();
Console.WriteLine("Help:");
IH.DisplayHelp();
return(0);
break;
case "-d":
domainString = keyValuePair.Value;
if (domainString == string.Empty)
{
Console.WriteLine("Connection string for -d parameter can not be empty!");
return(1);
}
domainFlag = true;
break;
case "-u":
userString = keyValuePair.Value;
if (userString == string.Empty)
{
Console.WriteLine("User string for -u parameter can not be empty!");
return(1);
}
userFlag = true;
break;
case "-g":
groupString = keyValuePair.Value;
if (groupString == string.Empty)
{
Console.WriteLine("Group string for -g parameter can not be empty!");
return(1);
}
groupFlag = true;
break;
case "-p":
passwordString = keyValuePair.Value;
if (passwordString == string.Empty)
{
Console.WriteLine("Password string for -p parameter can not be empty!");
return(1);
}
passwordFlag = true;
break;
default:
Console.WriteLine("Wrong parameters insertion.");
return(1);
break;
}
}
if ((groupFlag == true) && (userFlag == false))
{
Console.WriteLine("User was not specified! Use -g with combination of -u .");
return(1);
}
if ((passwordFlag == true) && (userFlag == false))
{
Console.WriteLine("User was not specified! Use -p with combination of -u .");
return(1);
}
if ((groupFlag == true) && (passwordFlag == true))
{
Console.WriteLine("Wrong parameter combination, -g and -p can't be used together, exiting!");
return(1);
}
IActiveDirectory IAD;
IHelper iHelper = ActiveDirectoryFactory.GetHelperDirectoryInterface();
if (domainFlag == true)
{
// Use external domain.
IAD = ActiveDirectoryFactory.GetActiveDirectoryInterface(domainString);
}
else
{
// Use current domain.
IAD = ActiveDirectoryFactory.GetActiveDirectoryInterface();
}
if (userFlag == true)
{
if (groupFlag == true)
{
// Prcoess -u + -g paramter compbination.
if (IAD.IsUserWithinGroup(userString, groupString) == true)
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
}
else if (passwordFlag == true)
{
// Prcoess -u + -p paramter compbination.
if (IAD.IsUsersPassword(userString, passwordString) == true)
{
Console.WriteLine("true");
}
else
{
Console.WriteLine("false");
}
}
else
{
// Process -u parameter only.
string domainName = IAD.ReturnDomainName();
ArrayList allOfGroups = new ArrayList();
allOfGroups = IAD.GetUsersGroups(userString);
if (allOfGroups.Count == 0)
{
Console.WriteLine("No groups found for user \"{0}\" within {1} .", userString, domainName);
}
else
{
Console.WriteLine("User \"{0}\", within " + domainName + ", is member of the following groups:\n", userString);
iHelper.PrintArrayListsContent(allOfGroups);
}
}
}
return(0); // Run function end. All is OK.
}
/// <summary>
/// 初始化一个<see cref="ParameterParserBase"/>类型的实例
/// </summary>
/// <param name="parser">参数解析器</param>
protected ParameterParserBase(IParameterParser parser) : this(parser.GetDictionary())
{
}
public ParameterEvaluator(IParameterParser parameterParser)
{
_parameterParser = DIHelper.VerifyParameter(parameterParser);
}
