/// <summary>
/// Initializes an instance of <see cref="EnumerableWrapperProvider"/>.
/// </summary>
/// <param name="sourceEnumerableOfT">Type of the original <see cref="IEnumerable{T}" />
/// that is being wrapped.</param>
/// <param name="elementWrapperProvider">The <see cref="IWrapperProvider"/> for the element type.
/// Can be null.</param>
public EnumerableWrapperProvider(
Type sourceEnumerableOfT,
IWrapperProvider elementWrapperProvider)
{
if (sourceEnumerableOfT == null)
{
throw new ArgumentNullException(nameof(sourceEnumerableOfT));
}
var enumerableOfT = ClosedGenericMatcher.ExtractGenericInterface(
sourceEnumerableOfT,
typeof(IEnumerable <>));
if (!sourceEnumerableOfT.IsInterface || enumerableOfT == null)
{
throw new ArgumentException(
Resources.FormatEnumerableWrapperProvider_InvalidSourceEnumerableOfT(typeof(IEnumerable <>).Name),
nameof(sourceEnumerableOfT));
}
_wrapperProvider = elementWrapperProvider;
var declaredElementType = enumerableOfT.GenericTypeArguments[0];
var wrappedElementType = elementWrapperProvider?.WrappingType ?? declaredElementType;
WrappingType = typeof(DelegatingEnumerable <,>).MakeGenericType(wrappedElementType, declaredElementType);
_wrappingTypeConstructor = WrappingType.GetConstructor(new[]
{
sourceEnumerableOfT,
typeof(IWrapperProvider)
});
}
/// <summary>
/// Initializes an instance of <see cref="EnumerableWrapperProvider"/>.
/// </summary>
/// <param name="sourceEnumerableOfT">Type of the original <see cref="IEnumerable{T}" />
/// that is being wrapped.</param>
/// <param name="elementWrapperProvider">The <see cref="IWrapperProvider"/> for the element type.
/// Can be null.</param>
public EnumerableWrapperProvider(
[NotNull] Type sourceEnumerableOfT,
IWrapperProvider elementWrapperProvider)
{
var enumerableOfT = ClosedGenericMatcher.ExtractGenericInterface(
sourceEnumerableOfT,
typeof(IEnumerable<>));
if (!sourceEnumerableOfT.GetTypeInfo().IsInterface || enumerableOfT == null)
{
throw new ArgumentException(
Resources.FormatEnumerableWrapperProvider_InvalidSourceEnumerableOfT(typeof(IEnumerable<>).Name),
nameof(sourceEnumerableOfT));
}
_wrapperProvider = elementWrapperProvider;
var declaredElementType = enumerableOfT.GenericTypeArguments[0];
var wrappedElementType = elementWrapperProvider?.WrappingType ?? declaredElementType;
WrappingType = typeof(DelegatingEnumerable<,>).MakeGenericType(wrappedElementType, declaredElementType);
_wrappingTypeConstructor = WrappingType.GetConstructor(new[]
{
sourceEnumerableOfT,
typeof(IWrapperProvider)
});
}
/// <summary>
/// Initializes an instance of <see cref="EnumerableWrapperProvider"/>.
/// </summary>
/// <param name="sourceEnumerableOfT">Type of the original <see cref="IEnumerable{T}" />
/// that is being wrapped.</param>
/// <param name="elementWrapperProvider">The <see cref="IWrapperProvider"/> for the element type.
/// Can be null.</param>
public EnumerableWrapperProvider(
Type sourceEnumerableOfT,
IWrapperProvider elementWrapperProvider)
{
if (sourceEnumerableOfT == null)
{
throw new ArgumentNullException(nameof(sourceEnumerableOfT));
}
var enumerableOfT = ClosedGenericMatcher.ExtractGenericInterface(
sourceEnumerableOfT,
typeof(IEnumerable <>));
if (!sourceEnumerableOfT.GetTypeInfo().IsInterface || enumerableOfT == null)
{
throw new ArgumentException($"The type must be an interface and must be or derive from '{typeof(IEnumerable<>).Name}'.",
nameof(sourceEnumerableOfT));
}
_wrapperProvider = elementWrapperProvider;
var declaredElementType = enumerableOfT.GenericTypeArguments[0];
var wrappedElementType = elementWrapperProvider?.WrappingType ?? declaredElementType;
WrappingType = typeof(DelegatingEnumerable <,>).MakeGenericType(wrappedElementType, declaredElementType);
_wrappingTypeConstructor = WrappingType.GetConstructor(new[]
{
sourceEnumerableOfT,
typeof(IWrapperProvider)
});
}
/// <summary>
/// Initializes a <see cref="DelegatingEnumerable{TWrapped, TDeclared}"/> with the original
/// <see cref="IEnumerable{T}"/> and the wrapper provider for wrapping individual elements.
/// </summary>
/// <param name="source">The <see cref="IEnumerable{T}"/> instance to get the enumerator from.</param>
/// <param name="elementWrapperProvider">The wrapper provider for wrapping individual elements.</param>
public DelegatingEnumerable(IEnumerable <TDeclared> source, IWrapperProvider elementWrapperProvider)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
_source = source;
_wrapperProvider = elementWrapperProvider;
}
/// <summary>
/// Initializes a <see cref="DelegatingEnumerable{TWrapped, TDeclared}"/> which enumerates
/// over the elements of the original enumerator and wraps them using the supplied
/// <see cref="IWrapperProvider"/>.
/// </summary>
/// <param name="inner">The original enumerator.</param>
/// <param name="wrapperProvider">The wrapper provider to wrap individual elements.</param>
public DelegatingEnumerator(IEnumerator <TDeclared> inner, IWrapperProvider wrapperProvider)
{
if (inner == null)
{
throw new ArgumentNullException(nameof(inner));
}
_inner = inner;
_wrapperProvider = wrapperProvider;
}
public void SaveDatabase <T>(string path, T tracker)
{
IWrapperProvider wrapperProvider = trackerfactory.GetWrapperProvider();
//check if path exist
if (!Directory.Exists(Path.GetDirectoryName(path)))
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
}
//make backup
if (File.Exists(path))
{
BackupDatabase(wrapperProvider, path);
}
//standard serialization
using (TextWriter writer = new StreamWriter(path))
{
var xml = new XmlSerializer(typeof(T));
xml.Serialize(writer, tracker);
}
}
public static dynamic GetAutoQuery <TEntity>(string queryString, Type entityType, IQueryable <TEntity> query, AutoQueryableProfile profile) where TEntity : class
{
// If query string empty select default entity properties.
if (string.IsNullOrEmpty(queryString))
{
IColumnProvider columnProvider = ProviderFactory.GetColumnProvider();
IEnumerable <SelectColumn> selectColumns = EntityColumnHelper.GetSelectableColumns(profile, entityType);
if (profile.UseBaseType)
{
return(query.Select(SelectHelper.GetSelector <TEntity, TEntity>(selectColumns, profile)));
}
return(query.Select(SelectHelper.GetSelector <TEntity, object>(selectColumns, profile)));
}
// Get criteria & clauses from choosen provider (AQ, OData, ...)
string[] queryStringParts = queryString.GetParts();
ICriteriaProvider criteriaProvider = ProviderFactory.GetCriteriaProvider(profile?.ProviderType);
IList <Criteria> criterias = profile.IsClauseAllowed(ClauseType.Filter) ? criteriaProvider.GetCriterias(entityType, queryStringParts, profile).ToList() : null;
IClauseProvider clauseProvider = ProviderFactory.GetClauseProvider(profile?.ProviderType);
Clauses clauses = clauseProvider.GetClauses(queryStringParts, profile);
var countAllRows = false;
IEnumerable <WrapperPartType> wrapperParts = null;
if (clauses.WrapWith != null)
{
IWrapperProvider wrapperProvider = ProviderFactory.GetWrapperProvider();
wrapperParts = wrapperProvider.GetWrapperParts(clauses.WrapWith.Value.Split(','), profile).ToList();
countAllRows = wrapperParts.Contains(WrapperPartType.TotalCount);
}
QueryResult queryResult = QueryBuilder.Build(query, entityType, clauses, criterias, profile, countAllRows);
if (clauses.WrapWith == null || !wrapperParts.Any())
{
return(queryResult.Result);
}
return(DefaultWrapperProvider.GetWrappedResult(wrapperParts, queryResult, clauses, queryString));
}
public void BackupDatabase(IWrapperProvider wrapperProvider, string path)
{
IPathWrapper pathWrapper = wrapperProvider.GetWrapper <IPathWrapper>();
IDirectoryWrapper directoryWrapper = wrapperProvider.GetWrapper <IDirectoryWrapper>();
IFileWrapper fileWrapper = wrapperProvider.GetWrapper <IFileWrapper>();
//copy data.xml to data.xml.bak
//copy data.xml to data_date.bak - it will override last dayily backup. first run of day will create new one
string backupFileName = pathWrapper.GetFileNameWithoutExtension(path) + DateTime.Now.ToString("yyyyMMdd");
string backupPath = pathWrapper.Combine(
pathWrapper.GetDirectoryName(path),
backupFileName);
backupPath = pathWrapper.ChangeExtension(backupPath, pathWrapper.GetExtension(path));
bool backupExists = File.Exists(backupPath);
File.Copy(path, backupPath, true);
if (!backupExists)
{
ManageBackups(path, pathWrapper, directoryWrapper, fileWrapper);
}
}
/// <summary>
/// Initializes a <see cref="DelegatingEnumerable{TWrapped, TDeclared}"/> which enumerates
/// over the elements of the original enumerator and wraps them using the supplied
/// <see cref="IWrapperProvider"/>.
/// </summary>
/// <param name="inner">The original enumerator.</param>
/// <param name="wrapperProvider">The wrapper provider to wrap individual elements.</param>
public DelegatingEnumerator([NotNull] IEnumerator <TDeclared> inner, IWrapperProvider wrapperProvider)
{
_inner = inner;
_wrapperProvider = wrapperProvider;
}
/// <summary>
/// Initializes a <see cref="DelegatingEnumerable{TWrapped, TDeclared}"/> with the original
/// <see cref="IEnumerable{T}"/> and the wrapper provider for wrapping individual elements.
/// </summary>
/// <param name="source">The <see cref="IEnumerable{T}"/> instance to get the enumerator from.</param>
/// <param name="elementWrapperProvider">The wrapper provider for wrapping individual elements.</param>
public DelegatingEnumerable([NotNull] IEnumerable <TDeclared> source, IWrapperProvider elementWrapperProvider)
{
_source = source;
_wrapperProvider = elementWrapperProvider;
}