public static IBoundClient <CrmSolution.Shared.Dto.CustomerDto> Sum(this IBoundClient <CrmSolution.Shared.Dto.CustomerDto> customersController, int n1, int n2)
{
return(customersController.Function("Sum").Set(new
{
n1, n2
}));
}
protected virtual async Task BuildRetrieveDataTask(DtoSyncConfigSyncFromInformation dtoSyncConfigSyncFromInformation, CancellationToken cancellationToken)
{
if (dtoSyncConfigSyncFromInformation == null)
{
throw new ArgumentNullException(nameof(dtoSyncConfigSyncFromInformation));
}
try
{
IBoundClient <IDictionary <string, object> > query = (dtoSyncConfigSyncFromInformation.DtoSetSyncConfig.OnlineDtoSetForGet ?? dtoSyncConfigSyncFromInformation.DtoSetSyncConfig.OnlineDtoSet)(ODataClient);
if (dtoSyncConfigSyncFromInformation.MaxVersion == 0)
{
query = query.Where($"{nameof(ISyncableDto.IsArchived)} eq false");
}
else
{
query = query.Where($"{nameof(ISyncableDto.Version)} gt {dtoSyncConfigSyncFromInformation.MaxVersion}");
}
string oDataGetAndVersionFilter = await query
.GetCommandTextAsync(cancellationToken)
.ConfigureAwait(false);
string oDataUri = $"{ClientAppProfile.ODataRoute}{oDataGetAndVersionFilter}";
using (HttpResponseMessage response = await HttpClient.GetAsync(oDataUri, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false))
{
response.EnsureSuccessStatusCode();
#if DotNetStandard2_0 || UWP
using Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
#elif Android || iOS || DotNetStandard2_1
await using Stream stream = await response.Content.ReadAsStreamAsync().ConfigureAwait(false);
#else
await using Stream stream = await response.Content.ReadAsStreamAsync(cancellationToken).ConfigureAwait(false);
#endif
{
using (StreamReader reader = new StreamReader(stream))
{
using (JsonReader jsonReader = new JsonTextReader(reader))
{
JToken jToken = await JToken.LoadAsync(jsonReader, new JsonLoadSettings
{
CommentHandling = CommentHandling.Ignore,
LineInfoHandling = LineInfoHandling.Ignore
}, cancellationToken).ConfigureAwait(false);
dtoSyncConfigSyncFromInformation.RecentlyChangedOnlineDtos = ((IEnumerable)(jToken)["value"] !.ToObject(typeof(List <>).MakeGenericType(dtoSyncConfigSyncFromInformation.DtoType)) !).Cast <ISyncableDto>().ToArray();
}
}
}
}
}
catch (Exception exp)
{
dtoSyncConfigSyncFromInformation.RecentlyChangedOnlineDtos = Array.Empty <ISyncableDto>();
ExceptionHandler.OnExceptionReceived(exp);
}
}
public static async Task <IEnumerable <T> > FindEntriesWithLogsAsync <T>(this IBoundClient <T> boundClient, ILogger logger, bool resultRequired = true) where T : class, IDynamicsEntity
{
logger.LogInformation($"Executing Dynamics Query: {await boundClient.GetCommandTextAsync()}");
var result = await boundClient.FindEntriesAsync(resultRequired);
return(result);
}
public static async Task <T> FindEntryWithLogsAsync <T>(this IBoundClient <T> boundClient, ILogger logger) where T : class, IDynamicsEntity
{
logger.LogInformation($"Executing Dynamics Query: {await boundClient.GetCommandTextAsync()}");
var result = await boundClient.FindEntryAsync();
return(result);
}
public static IBoundClient <Ntt_breathingspacedebt> ExpandDebt(this IBoundClient <Ntt_breathingspacedebt> debtQuery)
{
return(debtQuery
.Expand(x => x.ntt_BreathingSpaceMoratoriumId)
.Expand(x => x.ntt_debttypeid)
.Expand(x => x.ntt_creditorid)
.Expand(x => x.ntt_SoldToCreditorId)
.Expand(x => x.ntt_breathingspacedebt_ntt_debteligibilityreview_DebtId));
}
public async Task <int> Count(Expression <Func <T, bool> > expression)
{
//bounder = bounder.Count();
bounder = bounder.Filter(expression);
var count = await bounder.Count().FindScalarAsync <int>();
Dispose();
return(count);
}
private static void RemoveFilterExpression(IBoundClient <IDictionary <string, object> > client)
{
var cmdprop = client.GetType().GetProperty("Command", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
object fluentcmd = cmdprop.GetValue(client);
var detailsProp = fluentcmd.GetType().GetProperty("Details", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
var cmdDetails = detailsProp.GetValue(fluentcmd);
var filterExpressionProp = cmdDetails.GetType().GetProperty("FilterExpression", System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);
filterExpressionProp.SetValue(cmdDetails, null);
}
public static async Task <T1> UpdateEntryWithLogsAsync <T1>(this IBoundClient <T1> boundClient, ILogger logger, bool resultRequired = true) where T1 : class, IDynamicsEntity
{
logger.LogDebug($"Executing update entry {Environment.NewLine} {Environment.StackTrace}");
logger.LogInformation($"Updating type: {typeof(T1)}");
logger.LogInformation($"Executing Dynamics Query: {await boundClient.GetCommandTextAsync()}");
var result = await boundClient.UpdateEntryAsync(resultRequired);
logger.LogInformation($"Updated entry with Id: {result.GetId()}");
return(result);
}
public static IBoundClient <T> Include <T>(this IBoundClient <T> client, params ODataExpression[] associations)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.Expand(associations: associations));
}
public static Task <T> CreateEntryAsync <T>(this IBoundClient <T> client, CancellationToken cancellationToken)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.InsertEntryAsync(cancellationToken));
}
public static IBoundClient <T> Where <T>(this IBoundClient <T> client, string where)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.Filter(filter: where));
}
public static IBoundClient <T> Include <T>(this IBoundClient <T> client, IEnumerable <string> associations)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.Expand(associations: associations));
}
public static Task <T> CreateEntryAsync <T>(this IBoundClient <T> client, bool resultRequired)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.InsertEntryAsync(resultRequired));
}
public static IBoundClient <T> Take <T>(this IBoundClient <T> client, int count)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.Top(count: count));
}
public static IBoundClient <T> Include <T>(this IBoundClient <T> client, ODataExpandOptions includeOptions, params string[] associations)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.Expand(expandOptions: includeOptions, associations: associations));
}
public static IBoundClient <T> Include <T>(this IBoundClient <T> client, Expression <Func <T, object> > expression)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.Expand(expression: expression));
}
public static IBoundClient <T> Where <T>(this IBoundClient <T> client, ODataExpression expression)
where T : class
{
if (client == null)
{
throw new ArgumentNullException(nameof(client));
}
return(client.Filter(expression: expression));
}
public static async Task LinkEntryWithLogsAsync <T1, T2>(this IBoundClient <T1> boundClient, ILogger logger, T2 linkedEntryKey, string linkName)
where T1 : class, IDynamicsEntity
where T2 : class, IDynamicsEntity
{
logger.LogDebug($"Linking entry {Environment.NewLine} {Environment.StackTrace}");
logger.LogInformation($"Linking type: {typeof(T1)} to type: {typeof(T2)} with Id: {linkedEntryKey.GetId()}");
logger.LogInformation($"Executing Dynamics Query: {await boundClient.GetCommandTextAsync()}");
await boundClient.LinkEntryAsync <T2>(linkedEntryKey, linkName);
logger.LogInformation($"Link completed successfully.");
}
/// <summary>
/// Filters a sequence of values based on a <paramref name="predicate"/> only <paramref name="when"/> <c>true</c>.
/// </summary>
/// <typeparam name="TElement">The element <see cref="Type"/>.</typeparam>
/// <param name="query">The query.</param>
/// <param name="when">Indicates to perform an underlying <see cref="IFluentClient{TElement, FT}.Filter(Expression{Func{TElement, bool}})"/> only when <c>true</c>;
/// otherwise, no <b>Where</b> is invoked.</param>
/// <param name="predicate">A function to test each element for a condition.</param>
/// <returns>The resulting query.</returns>
public static IBoundClient <TElement> FilterWhen <TElement>(this IBoundClient <TElement> query, bool when, Expression <Func <TElement, bool> > predicate) where TElement : class
{
var q = Check.NotNull(query, nameof(query));
if (when)
{
return(q.Filter(predicate));
}
else
{
return(q);
}
}
public async Task <IEnumerable <T> > ResultAsync(Expression <Func <T, bool> > expression)
{
try
{
bounder = bounder.Filter(expression);
var result = await bounder.FindEntriesAsync();
Dispose();
return(result);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
protected virtual async Task <IEnumerable <T> > GetAllRecordsAsync <T>(IBoundClient <T> query) where T : class
{
var annotations = new ODataFeedAnnotations();
var entities = await query.FindEntriesAsync(annotations);
var result = entities.ToList();
while (annotations.NextPageLink != null)
{
entities = await query.FindEntriesAsync(annotations.NextPageLink, annotations);
result.AddRange(entities);
}
return(result);
}
public async Task <T> FirstAsync(Expression <Func <T, bool> > expression)
{
try
{
bounder = bounder.Filter(expression);
string command = await bounder.GetCommandTextAsync();
var result = await bounder.FindEntryAsync();
Dispose();
return(result);
}
catch (Exception ex)
{
//configuration.ExceptionTrace?.Invoke(new ExceptionObject() { Exception = ex, ODataCommand = await bounder.GetCommandTextAsync() });
return(null);
}
}
public ODataSet(ODataConfiguration config)
{
this.Configuration = config;
settings = new ODataClientSettings();
settings.PreferredUpdateMethod = ODataUpdateMethod.Put;
settings.IgnoreUnmappedProperties = true;
settings.BaseUri = new Uri(config.BaseUrl);
settings.BeforeRequest = (request) =>
{
//if (config.AccessToken != null)
//{
// request.Headers.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("bearer", config.AccessToken);
//}
};
if (config.OnTrance != null)
{
settings.OnTrace = config.OnTrance;
}
bounder = new ODataClient(settings).For <T>();
}
/// <summary>
/// Filters a sequence of values based on a <paramref name="predicate"/> only when the <paramref name="with"/> is not the default value for the <see cref="Type"/>.
/// </summary>
/// <typeparam name="TElement">The element <see cref="Type"/>.</typeparam>
/// <typeparam name="T">The with value <see cref="Type"/>.</typeparam>
/// <param name="query">The query.</param>
/// <param name="with">Indicates to perform an underlying <see cref="IFluentClient{TElement, FT}.Filter(Expression{Func{TElement, bool}})"/> only when the with is not the default
/// value; otherwise, no <b>Where</b> is invoked.</param>
/// <param name="predicate">A function to test each element for a condition.</param>
/// <returns>The resulting query.</returns>
public static IBoundClient <TElement> FilterWith <TElement, T>(this IBoundClient <TElement> query, T with, Expression <Func <TElement, bool> > predicate) where TElement : class
{
var q = Check.NotNull(query, nameof(query));
if (Comparer <T> .Default.Compare(with, default !) != 0 && Comparer <T> .Default.Compare(with, default !) != 0)
public static BoundClient <T> AsBoundClient <T>(this IBoundClient <T> client) where T : class
{
return(client as BoundClient <T>);
}
public Pageable(IBoundClient <T> client)
{
_client = client;
}
public static Task <T> CreateEntryAsync <T>(this IBoundClient <T> client)
where T : class
{
return(client.InsertEntryAsync());
}
public static Task <T> CreateEntryAsync <T>(this IBoundClient <T> client, bool resultRequired)
where T : class
{
return(client.InsertEntryAsync(resultRequired));
}
public virtual async Task CallSyncFrom(DtoSetSyncConfig[] fromServerDtoSetSyncMaterials, CancellationToken cancellationToken)
{
if (fromServerDtoSetSyncMaterials == null)
{
throw new ArgumentNullException(nameof(fromServerDtoSetSyncMaterials));
}
if (fromServerDtoSetSyncMaterials.Any())
{
await GetMetadataIfNotRetrievedAlready(cancellationToken).ConfigureAwait(false);
await using (EfCoreDbContextBase offlineContextForSyncFrom = Container.Resolve <EfCoreDbContextBase>())
{
((IsSyncDbContext)offlineContextForSyncFrom).IsSyncDbContext = true;
List <DtoSyncConfigSyncFromInformation> dtoSyncConfigSyncFromInformationList = new List <DtoSyncConfigSyncFromInformation>();
int id = 0;
foreach (DtoSetSyncConfig fromServerSyncConfig in fromServerDtoSetSyncMaterials)
{
IQueryable <ISyncableDto> offlineSet = fromServerSyncConfig.OfflineDtoSet(offlineContextForSyncFrom);
var mostRecentOfflineDto = await offlineSet
.IgnoreQueryFilters()
.AsNoTracking()
.Select(e => new { e.Version })
.OrderByDescending(e => e.Version)
.FirstOrDefaultAsync(cancellationToken)
.ConfigureAwait(false);
long maxVersion = mostRecentOfflineDto?.Version ?? 0;
DtoSyncConfigSyncFromInformation dtoSyncConfigSyncFromInformation = new DtoSyncConfigSyncFromInformation
{
Id = id++,
DtoSetSyncConfig = fromServerSyncConfig,
DtoType = offlineSet.ElementType.GetTypeInfo(),
HadOfflineDtoBefore = mostRecentOfflineDto != null,
MaxVersion = maxVersion
};
IBoundClient <IDictionary <string, object> > query = (dtoSyncConfigSyncFromInformation.DtoSetSyncConfig.OnlineDtoSetForGet ?? dtoSyncConfigSyncFromInformation.DtoSetSyncConfig.OnlineDtoSet)(ODataClient);
if (dtoSyncConfigSyncFromInformation.MaxVersion == 0)
{
query = query.Where($"{nameof(ISyncableDto.IsArchived)} eq false");
}
else
{
query = query.Where($"{nameof(ISyncableDto.Version)} gt {dtoSyncConfigSyncFromInformation.MaxVersion}");
}
string oDataGetAndVersionFilter = await query
.GetCommandTextAsync(cancellationToken)
.ConfigureAwait(false);
dtoSyncConfigSyncFromInformation.ODataGetUri = $"{ClientAppProfile.HostUri}{ClientAppProfile.ODataRoute}{oDataGetAndVersionFilter}";
dtoSyncConfigSyncFromInformationList.Add(dtoSyncConfigSyncFromInformation);
}
StringBuilder batchRequests = new StringBuilder();
batchRequests.AppendLine(@"
{
""requests"": [");
foreach (DtoSyncConfigSyncFromInformation?dtoSyncConfigSyncFromInformation in dtoSyncConfigSyncFromInformationList)
{
batchRequests.AppendLine(@$ "
{{
" "id" ": " "{dtoSyncConfigSyncFromInformation.Id}" ",
" "method" ": " "GET" ",
" "url" ": " "{dtoSyncConfigSyncFromInformation.ODataGetUri}" "
}}{(dtoSyncConfigSyncFromInformation != dtoSyncConfigSyncFromInformationList.Last() ? ", " : " ")}");
}
batchRequests.AppendLine(@"
]
}");
using (HttpResponseMessage batchResponbse = await HttpClient.PostAsync($"{ClientAppProfile.ODataRoute}$batch", new StringContent(batchRequests.ToString(), Encoding.UTF8, "application/json"), cancellationToken).ConfigureAwait(false))
{
batchResponbse.EnsureSuccessStatusCode();
if (batchResponbse.Content.Headers.ContentType.MediaType != "application/json")
{
throw new InvalidOperationException($"{batchResponbse.Content.Headers.ContentType.MediaType} content type is not supported.");
}
#if UWP || DotNetStandard2_0
using (Stream stream = await batchResponbse.Content.ReadAsStreamAsync().ConfigureAwait(false))
#else
await using (Stream stream = await batchResponbse.Content.ReadAsStreamAsync().ConfigureAwait(false))
#endif
{
using (StreamReader reader = new StreamReader(stream))
{
using (JsonReader jsonReader = new JsonTextReader(reader))
{
JToken jToken = await JToken.LoadAsync(jsonReader, new JsonLoadSettings
{
CommentHandling = CommentHandling.Ignore,
LineInfoHandling = LineInfoHandling.Ignore
}, cancellationToken).ConfigureAwait(false);
foreach (JToken response in jToken["responses"] !)
{
int responseId = response.Value <int>("id");
DtoSyncConfigSyncFromInformation?dtoSyncConfigSyncFromInformation = dtoSyncConfigSyncFromInformationList.ExtendedSingle($"Getting dtoSyncConfigSyncFromInformation with id {responseId}", item => item.Id == responseId);
dtoSyncConfigSyncFromInformation.RecentlyChangedOnlineDtos = ((IEnumerable)response["body"] !["value"] !.ToObject(typeof(List <>).MakeGenericType(dtoSyncConfigSyncFromInformation.DtoType)) !).Cast <ISyncableDto>().ToArray();
public static Task <T> CreateEntryAsync <T>(this IBoundClient <T> client, CancellationToken cancellationToken)
where T : class
{
return(client.InsertEntryAsync(cancellationToken));
}
