public StripeService(string apiKey, IMapper mapper, IRequestor requestor, IParameterBuilder parameterBuilder)
{
ApiKey = apiKey;
Mapper = mapper;
Requestor = requestor;
ParameterBuilder = parameterBuilder;
}
public Parser Create(IFieldPath path, IParameterBuilder builder)
{
Parser parser = null;
if (ParserLookup != null && ParserLookup.ContainsKey(path.Last))
{
parser = ParserLookup[path.Last];
}
else
{
if (path.Last.DataType == typeof(DateTime))
{
parser = new ExtendedDateParser();
}
else if (IsWholeNumber(path.Last.DataType))
{
parser = new ConvertParser <object, long>();
}
else if (IsDecimal(path.Last.DataType))
{
parser = new ConvertParser <object, double>();
}
}
return(parser);
}
public DbParameter[] GetParameters(SqlStringBuilder sqlStrinbuilder)
{
IParameterBuilder paramBuilder = GetService <IParameterBuilder>();
Args.ThrowIfNull(paramBuilder, "IParameterBuilder");
return(paramBuilder.GetParameters(sqlStrinbuilder));
}
public StripeService(string apiKey = null)
{
ApiKey = apiKey;
Mapper = new Mapper();
Requestor = new Requestor(Mapper);
ParameterBuilder = new ParameterBuilder();
}
private void Validate(IParameterBuilder builder, ICommand command)
{
builder.NotNull(nameof(builder));
command.NotNull(nameof(command));
builder.Name.NotNullOrWhiteSpace(nameof(builder.Name));
builder.ParameterInfo.NotNull(nameof(builder.ParameterInfo));
}
public StripeService(string apiKey = null)
{
ApiKey = apiKey;
Mapper = new Mapper();
Requestor = new Requestor(Mapper);
ParameterBuilder = new ParameterBuilder();
}
public StripeService(string apiKey, IMapper mapper, IRequestor requestor, IParameterBuilder parameterBuilder)
{
ApiKey = apiKey;
Mapper = mapper;
Requestor = requestor;
ParameterBuilder = parameterBuilder;
}
/// <summary>Initializes a command service.</summary>
/// <param name="client">WOLF client. Required.</param>
/// <param name="options">Commands options that will be used as default when running a command. Required.</param>
/// <param name="services">Services provider that will be used by all commands. Null will cause a backup provider to be used.</param>
/// <param name="log">Logger to log messages and errors to. If null, all logging will be disabled.</param>
/// <param name="cancellationToken">Cancellation token that can be used for cancelling all tasks.</param>
public CommandsService(IWolfClient client, CommandsOptions options, ILogger log, IServiceProvider services = null, CancellationToken cancellationToken = default)
{
// init private
this._commands = new Dictionary <ICommandInstanceDescriptor, ICommandInstance>();
this._lock = new SemaphoreSlim(1, 1);
this._cts = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
this._disposableServices = new List <IDisposable>(2);
this._started = false;
// init required
this._client = client ?? services?.GetService <IWolfClient>() ?? throw new ArgumentNullException(nameof(client));
this._options = options ?? services?.GetService <CommandsOptions>() ?? throw new ArgumentNullException(nameof(options));
// init optionals
this._log = log ?? services?.GetService <ILogger <CommandsService> >() ?? services?.GetService <ILogger <ICommandsService> >() ?? services.GetService <ILogger>();
this._argumentConverterProvider = services?.GetService <IArgumentConverterProvider>() ?? CreateAsDisposable <ArgumentConverterProvider>();
this._handlerProvider = services?.GetService <ICommandsHandlerProvider>() ?? CreateAsDisposable <CommandsHandlerProvider>();
this._argumentsParser = services?.GetService <IArgumentsParser>() ?? new ArgumentsParser();
this._parameterBuilder = services?.GetService <IParameterBuilder>() ?? new ParameterBuilder();
this._initializers = services?.GetService <ICommandInitializerProvider>() ?? new CommandInitializerProvider();
this._commandsLoader = services?.GetService <ICommandsLoader>() ?? new CommandsLoader(this._initializers, this._log);
// init service provider - use combine, to use fallback one as well
this._fallbackServices = this.CreateFallbackServiceProvider();
this._services = CombinedServiceProvider.Combine(services, this._fallbackServices);
// register event handlers
this._client.AddMessageListener <ChatMessage>(OnMessageReceived);
}
public override ParameterBuilderDTO Create(IParameterBuilder b)
{
var sb = b as LikeBuilder;
if (sb == null)
{
return(base.Create(b));
}
// find the instance of the MatchMode in the static fields
var modes = typeof(MatchMode).GetFields(BindingFlags.Public | BindingFlags.Static);
FieldInfo mode = null;
foreach (var f in modes)
{
if (f.FieldType == typeof(MatchMode) && f.GetValue(null) == sb.Mode)
{
mode = f;
break;
}
}
if (mode == null)
{
throw new ArgumentException("The provided MatchMode does not match an internal static field on MatchMode.");
}
return(new LikeBuilderDTO()
{
Label = sb.Label,
Mode = mode.Name
});
}
public UIElement <UIElement> Build(IFieldPath path, IParameterBuilder builder)
{
UIElement <System.Windows.UIElement> c;
var f = path.Last;
var listArgs = OnListRequired(path);
if (builder is IJunctionBuilder)
{
return(Build(path, ((IJunctionBuilder)builder).Other));
}
else if (builder is IBetweenBuilder)
{
var between = new BetweenElement(Build(path, null), Build(path, null));
if (!String.IsNullOrEmpty(path.Last.DisplayFormat))
{
// assume standard formatting codes
// ^C\d*$ = currency (or "$#.00")
// ^P\d*$ = percent (or "0.00\%")
if (System.Text.RegularExpressions.Regex.IsMatch(path.Last.DisplayFormat.Trim(), @"^([Cc]\d*)|(\$.*)$"))
{
between.PrefixText = System.Globalization.NumberFormatInfo.CurrentInfo.CurrencySymbol;
}
else if (System.Text.RegularExpressions.Regex.IsMatch(path.Last.DisplayFormat.Trim(), @"^([Pp]\d*)|([^%]*%)$"))
{
between.PostfixText = "%";
}
}
return(between);
}
else if (builder is IBooleanBuilder || builder is INullBuilder)
{
return(null);
}
else if (builder is INotBuilder)
{
return(Build(path, ((INotBuilder)builder).Other));
}
else if (f.DataType == typeof(bool))
{
c = new CheckBoxElement();
}
else if (listArgs.List != null)
{
if (listArgs.Type == Configuration.FieldListType.Limited)
{
c = new ListBoxElement(listArgs.List, 400);
}
else
{
c = new ComboBoxElement(listArgs.List, true);
}
}
else
{
c = new TextBoxElement();
}
return(c);
}
private static void SetupDatabases <SSB, SW>(Database reproduceIn, IParameterBuilder paramBuilder)
where SSB : SqlStringBuilder, new()
where SW : SchemaWriter
{
reproduceIn.ServiceProvider.Set <IParameterBuilder>(paramBuilder);
reproduceIn.ServiceProvider.Set <SqlStringBuilder>(new SSB());
reproduceIn.ServiceProvider.SetCtor <SchemaWriter, SW>();
}
internal DbController(IReaderMapper readerMapper, IParameterBuilder parameterBuilder,
string connectionString, DbProviderFactory providerFactory)
{
this.readerMapper = readerMapper ?? throw new ArgumentNullException(nameof(readerMapper));
this.parameterBuilder = parameterBuilder ?? throw new ArgumentNullException(nameof(parameterBuilder));
this.connectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
Provider = providerFactory ?? throw new ArgumentNullException(nameof(providerFactory));
}
internal Query(IParameterBuilder parameterBuilder, IReaderMapper readerMapper, DbConnection connection)
{
this.parameterBuilder = parameterBuilder ?? throw new ArgumentNullException(nameof(parameterBuilder));
this.readerMapper = readerMapper ?? throw new ArgumentNullException(nameof(readerMapper));
this.connection = connection ?? throw new ArgumentNullException(nameof(connection));
disposed = false;
locker = new object();
}
public void Rewrite(IParameterBuilder parameterBuilder, ISqlCommandContext <ISqlCommand> sqlCommandContext, ParameterContext parameterContext)
{
var selectCommandContext = ((SelectCommandContext)sqlCommandContext);
var pagination = selectCommandContext.GetPaginationContext();
pagination.GetOffsetParameterIndex().IfPresent(offsetParameterIndex => RewriteOffset(pagination, offsetParameterIndex.Value, (StandardParameterBuilder)parameterBuilder));
pagination.GetRowCountParameterIndex().IfPresent(
rowCountParameterIndex => rewriteRowCount(pagination, rowCountParameterIndex.Value, (StandardParameterBuilder)parameterBuilder, selectCommandContext));
}
public AuthorsController(IAuthorServices services,
IBookServices bookServices,
IFileServices fileServices,
IParameterBuilder parameterBuilder)
{
_services = services;
_bookServices = bookServices;
_fileServices = fileServices;
_parameterBuilder = parameterBuilder;
}
/// <inheritdoc/>
public async Task <ICommandResult> ExecuteAsync(ICommandContext context, IServiceProvider services, ICommandResult matchResult, object handler, CancellationToken cancellationToken = default)
{
// ensure provided check result is valid
if (matchResult == null)
{
throw new ArgumentNullException(nameof(matchResult));
}
if (!matchResult.IsSuccess)
{
return(CommandExecutionResult.Failure);
}
if (!(matchResult is RegexCommandMatchResult regexMatchResult))
{
throw new ArgumentException($"{nameof(matchResult)} must be of type {typeof(RegexCommandMatchResult).FullName}", nameof(matchResult));
}
// run all custom attributes
foreach (ICommandRequirement check in this.Requirements)
{
if (!await check.CheckAsync(context, services, cancellationToken).ConfigureAwait(false))
{
return(new CommandExecutionResult(false, new string[] { check.ErrorMessage }, null));
}
}
// build params
cancellationToken.ThrowIfCancellationRequested();
IParameterBuilder paramBuilder = services.GetRequiredService <IParameterBuilder>();
ParameterBuilderValues paramBuilderValues = new ParameterBuilderValues
{
Args = regexMatchResult.RegexMatch.Groups.Cast <Group>().Skip(1)
.Select(s => s.Value ?? string.Empty).ToArray(),
ArgumentConverterProvider = services.GetService <IArgumentConverterProvider>(),
CancellationToken = cancellationToken,
Context = context,
Services = services,
CommandInstance = this,
AdditionalObjects = new object[] { regexMatchResult.RegexMatch }
};
ParameterBuildingResult paramsResult = await paramBuilder.BuildParamsAsync(_params, paramBuilderValues, cancellationToken).ConfigureAwait(false);
if (!paramsResult.IsSuccess)
{
return(paramsResult);
}
// execute - if it's a task, await it
cancellationToken.ThrowIfCancellationRequested();
if (this.Method.Invoke(handler, paramsResult.Values) is Task returnTask)
{
await returnTask.ConfigureAwait(false);
}
return(CommandExecutionResult.Success);
}
public RentalsController(
IRentalServices rentalServices,
IParameterBuilder parameterBuilder,
ICustomerServices customerServices,
IBookServices bookServices)
{
_rentalServices = rentalServices;
_customerServices = customerServices;
_bookServices = bookServices;
_parameterBuilder = parameterBuilder;
}
public override ParameterBuilderDTO Create(IParameterBuilder b)
{
if (!(b is T))
{
return(base.Create(b));
}
return(new U()
{
Label = ((T)b).Label
});
}
public BooksController(IBookServices services,
IAuthorServices authorServices,
IGenreServices genreServices,
IParameterBuilder parameterBuilder,
IFileServices fileServices)
{
_services = services;
_authorServices = authorServices;
_genreServices = genreServices;
_fileServices = fileServices;
_parameterBuilder = parameterBuilder;
}
public static RouteBuilder Map(IParameterBuilder id = null)
{
return(new RouteBuilder
{
ControllerName = ControllerName,
ActionName = ActionName,
RouteName = RouteName,
Parameters = new Dictionary <string, IParameterBuilder>
{
{ "id", id }
}
});
}
public static RouteBuilder Map(IParameterBuilder id = null)
{
return new RouteBuilder
{
ControllerName = ControllerName,
ActionName = ActionName,
RouteName = RouteName,
Parameters = new Dictionary<string, IParameterBuilder>
{
{"id", id}
}
};
}
/// <summary>
/// Applies 'From...' attributes from a source parameter to a parameter builder.
/// </summary>
/// <param name="parameterInfo">A parameter info.</param>
/// <param name="parameterBuilder">A parameter builder.</param>
private void ApplyParameterAttributes(
ParameterInfo parameterInfo,
IParameterBuilder parameterBuilder)
{
var attrs = parameterInfo.GetCustomAttributes();
if (attrs == null)
{
return;
}
foreach (var attr in attrs)
{
if (attr is FromBodyAttribute)
{
parameterBuilder.SetCustomAttribute(AttributeUtility.BuildAttribute <FromBodyAttribute>());
}
else if (attr is FromHeaderAttribute)
{
parameterBuilder.SetCustomAttribute(
AttributeUtility.BuildAttribute <FromHeaderAttribute>(
() =>
{
return(this.GetPropertiesAndValues(attr, "Name"));
}));
}
else if (attr is FromQueryAttribute)
{
parameterBuilder.SetCustomAttribute(
AttributeUtility.BuildAttribute <FromQueryAttribute>(
() =>
{
return(this.GetPropertiesAndValues(attr, "Name"));
}));
}
else if (attr is FromRouteAttribute)
{
parameterBuilder.SetCustomAttribute(
AttributeUtility.BuildAttribute <FromRouteAttribute>(
() =>
{
return(this.GetPropertiesAndValues(attr, "Name"));
}));
}
else if (attr is FromServicesAttribute)
{
parameterBuilder.SetCustomAttribute(AttributeUtility.BuildAttribute <FromServicesAttribute>());
}
}
}
public static DataTable Where(QiQuery query)
{
Database db = Db.For(query.cxName);
SqlStringBuilder sql = new SqlStringBuilder();
sql
.Select(query.table, query.columns)
.Where(query);
IParameterBuilder parameterBuilder = db.ServiceProvider.Get <IParameterBuilder>();
DbParameter[] parameters = parameterBuilder.GetParameters(sql);
return(db.GetDataTable(sql, System.Data.CommandType.Text, parameters));
}
public override ParameterBuilderDTO Create(IParameterBuilder b)
{
var sb = b as SimpleBuilder;
if (sb == null)
{
return(base.Create(b));
}
return(new SimpleBuilderDTO()
{
Label = sb.Label,
Operator = sb.Operator
});
}
public override ParameterBuilderDTO Create(IParameterBuilder b)
{
var sb = b as BooleanBuilder;
if (sb == null)
{
return(base.Create(b));
}
return(new BooleanBuilderDTO()
{
Label = sb.Label,
Value = sb.Value
});
}
public override ParameterBuilderDTO Create(IParameterBuilder b)
{
var sb = b as NotBuilder;
if (sb == null)
{
return(base.Create(b));
}
return(new NotBuilderDTO()
{
Label = sb.Label,
Other = Chain.Create(sb.Other)
});
}
public override ParameterBuilderDTO Create(IParameterBuilder b)
{
var sb = b as JunctionBuilder;
if (sb == null)
{
return(base.Create(b));
}
return(new JunctionBuilderDTO()
{
Label = sb.Label,
Type = sb.Type.ToString(),
Other = base.Chain.Create(sb.Other)
});
}
public SqlRewriteContext(SchemaMetaData schemaMetaData, ISqlCommandContext <ISqlCommand> sqlCommandContext, string sql, ParameterContext parameterContext)
{
this._schemaMetaData = schemaMetaData;
this._sqlCommandContext = sqlCommandContext;
this._sql = sql;
this._parameterContext = parameterContext;
AddSqlTokenGenerators(new DefaultTokenGeneratorBuilder().GetSqlTokenGenerators());
if (sqlCommandContext is InsertCommandContext insertCommandContext)
{
_parameterBuilder = new GroupedParameterBuilder(insertCommandContext.GetGroupedParameters());
}
else
{
_parameterBuilder = new StandardParameterBuilder(parameterContext);
}
}
/// <summary>
/// Creates a new instance of <see cref="Parameter" />.
/// </summary>
/// <param name="builder">The builder of this parameter.</param>
/// <param name="command">The command of this parameter.</param>
public Parameter(IParameterBuilder builder, ICommand command)
{
Validate(builder, command);
Name = builder.Name;
Description = builder.Description;
Remarks = builder.Remarks;
IsRemainder = builder.IsRemainder;
IsParams = builder.IsParams;
IsOptional = builder.IsOptional;
DefaultValue = builder.DefaultValue;
TypeParserType = builder.TypeParserType;
Preconditions = builder.Preconditions.ToImmutableArray();
Attributes = builder.Attributes.ToImmutableArray();
ParameterInfo = builder.ParameterInfo;
Command = command;
}
protected virtual void VisitParameter(IParameterBuilder expression)
{
this.Builder.AppendFormat("{0}{1} ", this.Database.QueryFactory.Dialect.PARAMETER, expression.Name);
if (!this.ContainsParameter(expression.Name))
{
this.Parameters.Add(new DatabaseQueryParameter(
expression.Name,
expression.Type,
expression.Size,
expression.Precision,
expression.Scale,
expression.Direction,
expression.IsDeclared,
expression.Column,
expression.Flags
));
}
}
private void ForceUpdateIfExistsInTarget(string uuid, Dao dao)
{
SqlStringBuilder sql = DatabaseToRestoreTo.ServiceProvider.Get <SqlStringBuilder>();
IParameterBuilder parameterBuilder = DatabaseToRestoreTo.ServiceProvider.Get <IParameterBuilder>();
sql.Select(dao.TableName()).Where(Query.Where("Uuid") == uuid);
DataTable table = DatabaseToRestoreTo.GetDataTable(sql.ToString(), CommandType.Text, parameterBuilder.GetParameters(sql));
if (table.Rows.Count == 1)
{
dao.DataRow = table.Rows[0];
dao.ForceUpdate = true;
}
else if (table.Rows.Count > 1)
{
Args.Throw <InvalidOperationException>("More than one instance of the specified Uuid exists in the target database: {0}", uuid);
}
}
private ParameterContext GetParameterContext(IParameterBuilder parameterBuilder, RouteResult routeResult, RouteUnit routeUnit)
{
if (parameterBuilder is StandardParameterBuilder || routeResult.GetOriginalDataNodes().IsEmpty() || parameterBuilder.GetParameterContext().IsEmpty())
{
return(parameterBuilder.GetParameterContext());
}
var result = new ParameterContext();
int count = 0;
foreach (var originalDataNode in routeResult.GetOriginalDataNodes())
{
if (IsInSameDataNode(originalDataNode, routeUnit))
{
result.AddParameters(((GroupedParameterBuilder)parameterBuilder).GetParameterContext(count).GetDbParameters());
}
count++;
}
return(result);
}
/// <summary>
/// Applies method parameter attributes to a parameter builder.
/// </summary>
/// <param name="parmBuilder">A parameter builder.</param>
/// <param name="methodParm">A method parameter attribute.</param>
private void ApplyParameterAttributes(
IParameterBuilder parmBuilder,
ControllerMethodParameterAttribute methodParm)
{
if (methodParm.From == ControllerMethodParameterFromOption.Body)
{
parmBuilder.SetCustomAttribute(AttributeUtility.BuildAttribute <FromBodyAttribute>());
}
else if (methodParm.From == ControllerMethodParameterFromOption.Header)
{
parmBuilder.SetCustomAttribute(AttributeUtility.BuildAttribute <FromHeaderAttribute>(
() =>
{
var prop = typeof(FromHeaderAttribute).GetProperty("Name");
return(new[] { new Tuple <PropertyInfo, object>(prop, methodParm.FromName) });
}));
}
else if (methodParm.From == ControllerMethodParameterFromOption.Query)
{
parmBuilder.SetCustomAttribute(AttributeUtility.BuildAttribute <FromQueryAttribute>(
() =>
{
var prop = typeof(FromQueryAttribute).GetProperty("Name");
return(new[] { new Tuple <PropertyInfo, object>(prop, methodParm.FromName) });
}));
}
else if (methodParm.From == ControllerMethodParameterFromOption.Route)
{
parmBuilder.SetCustomAttribute(AttributeUtility.BuildAttribute <FromRouteAttribute>(
() =>
{
var prop = typeof(FromQueryAttribute).GetProperty("Name");
return(new[] { new Tuple <PropertyInfo, object>(prop, methodParm.FromName) });
}));
}
}
/// <summary>
/// Handles the selections.
/// </summary>
/// <param name="complexDataQuery">The complex data query.</param>
/// <param name="whereType">Type of the where.</param>
/// <param name="complexDataQuerySelections"></param>
/// <exception cref="Org.Sdmxsource.Sdmx.Api.Exception.SdmxSemmanticException">
/// Invalid structure type for component and
/// </exception>
private static void HandleSelections(IComplexDataQuery complexDataQuery, DataParametersAndType whereType, IEnumerable<IComplexDataQuerySelection> complexDataQuerySelections, IParameterBuilder builder)
{
foreach (IComplexDataQuerySelection complexDataQuerySelection in complexDataQuerySelections)
{
builder.Reset();
// Dimension Values inside an OR -or- AND clause
foreach (IComplexComponentValue complexComponentValue in complexDataQuerySelection.Values)
{
var component = complexDataQuery.DataStructure.GetComponent(complexDataQuerySelection.ComponentId);
if (component == null)
{
throw new SdmxSemmanticException(string.Format("Component with ID {0} does not exist in the DSD {1}", complexDataQuerySelection.ComponentId, complexDataQuery.DataStructure));
}
switch (component.StructureType.EnumType)
{
case SdmxStructureEnumType.Dimension:
case SdmxStructureEnumType.MeasureDimension:
{
var dimensionValueType = new DimensionValueType { ID = complexDataQuerySelection.ComponentId };
SetOperatorAndValue(component, complexComponentValue, dimensionValueType);
builder.AddDimension(dimensionValueType);
}
break;
case SdmxStructureEnumType.DataAttribute:
{
var attributeValueType = new AttributeValueType { ID = complexDataQuerySelection.ComponentId };
SetOperatorAndValue(component, complexComponentValue, attributeValueType);
builder.AddAttribute(attributeValueType);
}
break;
default:
throw new SdmxSemmanticException(string.Format("Invalid structure type for component ID : {1} Type {0} ", component.StructureType.EnumType, component.Urn));
}
}
builder.PopulateAndParameter(whereType);
}
}
public StripeChargeService(string apiKey, IMapper mapper, IRequestor requestor, IParameterBuilder parameterBuilder)
: base(apiKey, mapper, requestor, parameterBuilder)
{
}
