1607 lines
46 KiB
Plaintext
1607 lines
46 KiB
Plaintext
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseClass.cs
|
|
|
|
using System;
|
|
using Microsoft.Extensions.Logging;
|
|
using xCommons.Extensions;
|
|
using xExceptions.Constants;
|
|
|
|
namespace xModels.Base {
|
|
/// <summary>
|
|
/// a Base class which carry required things as a Father for it's childs ...
|
|
/// </summary>
|
|
public abstract class XBaseClass {
|
|
//
|
|
#region Properties ...
|
|
/// <summary>
|
|
/// LogTag which Specified for this class ...
|
|
/// </summary>
|
|
private readonly string LOG_TAG;
|
|
|
|
/// <summary>
|
|
/// logger instance ...
|
|
/// </summary>
|
|
private readonly ILogger logger;
|
|
#endregion
|
|
|
|
//
|
|
#region Constructor ...
|
|
public XBaseClass (ILoggerFactory loggerFactory) {
|
|
//
|
|
// Preparing Log Tag ...
|
|
LOG_TAG = this.GetType ().Name;
|
|
|
|
//
|
|
Type classType = this.GetType ();
|
|
logger = loggerFactory.CreateLogger (classType);
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Protected ...
|
|
/// <summary>
|
|
/// Extract Prepared Log MEssage ...
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <returns></returns>
|
|
protected virtual string GetLogMessage (string message) {
|
|
//
|
|
// Prepare Log Message ...
|
|
message = $"{LOG_TAG} => {message}";
|
|
return message;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Logging specific Message ...
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <param name="logLevel"></param>
|
|
protected virtual void LogMessage (
|
|
string message,
|
|
LogLevel logLevel = LogLevel.Information
|
|
) {
|
|
//
|
|
// Validate Args ...
|
|
if (message.IsNullOrEmpty ()) {
|
|
throw XException.InvalidArgs
|
|
.ToException ();
|
|
}
|
|
|
|
//
|
|
// Prepare Log Message ...
|
|
message = GetLogMessage (message);
|
|
|
|
//
|
|
// Logging Message ...
|
|
logger.Log (
|
|
message: message,
|
|
logLevel: logLevel
|
|
);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Logging specific Message to Console ...
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
protected virtual void ConsoleMessage (string message) {
|
|
//
|
|
// Validate Args ...
|
|
if (message.IsNullOrEmpty ()) {
|
|
throw XException.InvalidArgs
|
|
.ToException ();
|
|
}
|
|
|
|
//
|
|
// Prepare Log Message ...
|
|
message = GetLogMessage (message);
|
|
|
|
//
|
|
// Logging Message ...
|
|
Console.WriteLine (message);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseDescriptor.cs
|
|
|
|
namespace xModels.Base {
|
|
/// <summary>
|
|
/// Descriptors classes Map required data for creating Entities on Seeding time ...
|
|
/// this is a Base Descriptor class ...
|
|
/// </summary>
|
|
public abstract class XBaseDescriptor { }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseDto.cs
|
|
|
|
namespace xModels.Base {
|
|
/// <summary>
|
|
/// DTO - Data Transfer Objects is a kind of classes which Represent Entities ...
|
|
/// this is base Dto class ...
|
|
/// </summary>
|
|
public abstract class XBaseDto { }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseEntity.cs
|
|
|
|
using System.ComponentModel.DataAnnotations;
|
|
|
|
namespace xModels.Base {
|
|
/// <summary>
|
|
/// Base Entity Class
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public abstract class XBaseEntity<T> {
|
|
/// <summary>
|
|
/// Entity Id
|
|
/// </summary>
|
|
/// <value>entity unique id</value>
|
|
[Key]
|
|
[Required]
|
|
public T Id { get; set; }
|
|
|
|
/// <summary>
|
|
/// Provided Soft Delete Behaviour ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public bool Deleted { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseEntityDto.cs
|
|
|
|
namespace xModels.Base
|
|
{
|
|
/// <summary>
|
|
/// Base Entity Related Dto Class ...
|
|
/// </summary>
|
|
/// <typeparam name="TKey"></typeparam>
|
|
public abstract class XBaseEntityDto<TKey>
|
|
{
|
|
/// <summary>
|
|
/// Entity Id
|
|
/// </summary>
|
|
/// <value>entity unique id</value>
|
|
public TKey Id { get; set; }
|
|
|
|
/// <summary>
|
|
/// Provided Soft Delete Behaviour ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public bool Deleted { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseGuidIDEntity.cs
|
|
|
|
using System;
|
|
|
|
namespace xModels.Base {
|
|
/// <summary>
|
|
/// a BaseEntity Class which has Id of Guid type
|
|
/// </summary>
|
|
public class XBaseGuidIDEntity : XBaseEntity<Guid> { }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseGuidIDEntityDto.cs
|
|
|
|
using System;
|
|
|
|
namespace xModels.Base
|
|
{
|
|
public class XBaseGuidIDEntityDto : XBaseEntityDto<Guid>
|
|
{ }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseIntIDEntity.cs
|
|
|
|
using System.ComponentModel.DataAnnotations;
|
|
|
|
namespace xModels.Base {
|
|
/// <summary>
|
|
/// a BaseEntity Class which has Id of int type
|
|
/// </summary>
|
|
public abstract class XBaseIntIDEntity : XBaseEntity<int> { }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseIntIDEntityDto.cs
|
|
|
|
namespace xModels.Base
|
|
{
|
|
public class XBaseIntIDEntityDto : XBaseEntityDto<int>
|
|
{ }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseLongIDEntity.cs
|
|
|
|
namespace xModels.Base
|
|
{
|
|
public class XBaseLongIDEntity : XBaseEntity<long>
|
|
{ }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseLongIDEntityDto.cs
|
|
|
|
namespace xModels.Base
|
|
{
|
|
public class XBaseLongIDEntityDto : XBaseEntityDto<long>
|
|
{ }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseRangeRequest.cs
|
|
|
|
using System.Collections.Generic;
|
|
|
|
namespace xModels.Base {
|
|
/// <summary>
|
|
/// Range Request Classes Carry a List of Objects
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
public class XBaseRangeRequest<T> {
|
|
public IEnumerable<T> Items { get; set; } = new HashSet<T> ();
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseStorableDto.cs
|
|
|
|
namespace xModels.Base {
|
|
public abstract class XBaseStorableDto<TKey> : XBaseDto {
|
|
public abstract TKey Id { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseStorableDtoEventModel.cs
|
|
|
|
namespace xModels.Base
|
|
{
|
|
public class XBaseStorableDtoEventModel<T>
|
|
{
|
|
public T Model { get; set; }
|
|
|
|
public XBaseStorableDtoEventModel(T model)
|
|
{
|
|
Model = model;
|
|
}
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseStoreEvent.cs
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Reactive.Linq;
|
|
using System.Reactive.Subjects;
|
|
using xModels.Interfaces;
|
|
|
|
namespace xModels.Base
|
|
{
|
|
public abstract class XBaseStoreEvent<T, TKey> : IXBaseStoreEvents<T, TKey>
|
|
where T : XBaseStorableDto<TKey>
|
|
{
|
|
//
|
|
private readonly ISubject<XBaseStorableDtoEventModel<T>> onAddSubject;
|
|
private readonly ISubject<XBaseStorableDtoEventModel<T>> onUpdateSubject;
|
|
private readonly ISubject<XBaseStorableDtoEventModel<T>> onRemoveSubject;
|
|
|
|
//
|
|
private readonly ISubject<XBaseStorableDtoEventModel<IEnumerable<T>>> onAddManySubject;
|
|
private readonly ISubject<XBaseStorableDtoEventModel<IEnumerable<T>>> onUpdateManySubject;
|
|
private readonly ISubject<XBaseStorableDtoEventModel<IEnumerable<T>>> onRemoveManySubject;
|
|
|
|
//
|
|
public IObservable<XBaseStorableDtoEventModel<T>> OnAddObservable => onAddSubject.AsObservable();
|
|
|
|
public IObservable<XBaseStorableDtoEventModel<T>> OnUpdateObservable => onUpdateSubject.AsObservable();
|
|
|
|
public IObservable<XBaseStorableDtoEventModel<T>> OnRemoveObservable => onRemoveSubject.AsObservable();
|
|
|
|
//
|
|
|
|
public IObservable<XBaseStorableDtoEventModel<IEnumerable<T>>> OnAddManyObservable => onAddManySubject.AsObservable();
|
|
|
|
public IObservable<XBaseStorableDtoEventModel<IEnumerable<T>>> OnUpdateManyObservable => onUpdateManySubject.AsObservable();
|
|
|
|
public IObservable<XBaseStorableDtoEventModel<IEnumerable<T>>> OnRemoveManyObservable => onRemoveManySubject.AsObservable();
|
|
|
|
//
|
|
protected XBaseStoreEvent()
|
|
{
|
|
//
|
|
onAddSubject = new ReplaySubject<XBaseStorableDtoEventModel<T>>(1);
|
|
onUpdateSubject = new ReplaySubject<XBaseStorableDtoEventModel<T>>(1);
|
|
onRemoveSubject = new ReplaySubject<XBaseStorableDtoEventModel<T>>(1);
|
|
|
|
//
|
|
onAddManySubject = new ReplaySubject<XBaseStorableDtoEventModel<IEnumerable<T>>>(1);
|
|
onUpdateManySubject = new ReplaySubject<XBaseStorableDtoEventModel<IEnumerable<T>>>(1);
|
|
onRemoveManySubject = new ReplaySubject<XBaseStorableDtoEventModel<IEnumerable<T>>>(1);
|
|
}
|
|
|
|
//
|
|
#region Base Actions ...
|
|
public void AddEvent(XBaseStorableDtoEventModel<T> model)
|
|
{
|
|
onAddSubject.OnNext(model);
|
|
}
|
|
|
|
public void AddManyEvent(XBaseStorableDtoEventModel<IEnumerable<T>> model)
|
|
{
|
|
onAddManySubject.OnNext(model);
|
|
}
|
|
|
|
public void RemoveEvent(XBaseStorableDtoEventModel<T> model)
|
|
{
|
|
onRemoveSubject.OnNext(model);
|
|
}
|
|
|
|
public void RemoveManyEvent(XBaseStorableDtoEventModel<IEnumerable<T>> model)
|
|
{
|
|
onRemoveManySubject.OnNext(model);
|
|
}
|
|
|
|
public void UpdateEvent(XBaseStorableDtoEventModel<T> model)
|
|
{
|
|
onUpdateSubject.OnNext(model);
|
|
}
|
|
|
|
public void UpdateManyEvent(XBaseStorableDtoEventModel<IEnumerable<T>> model)
|
|
{
|
|
onUpdateManySubject.OnNext(model);
|
|
}
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseStringIDEntity.cs
|
|
|
|
using System;
|
|
|
|
namespace xModels.Base {
|
|
/// <summary>
|
|
/// a BaseEntity Class which has Id of string type
|
|
/// </summary>
|
|
public class XBaseStringIDEntity : XBaseEntity<string> { }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseStringIDEntityDto.cs
|
|
|
|
namespace xModels.Base
|
|
{
|
|
public class XBaseStringIDEntityDto : XBaseEntityDto<string>
|
|
{ }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Base\XBaseValueContainer.cs
|
|
|
|
namespace xModels.Base
|
|
{
|
|
public class XBaseValueContainer<T>
|
|
{
|
|
public T Value { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XBaseIndexedDto.cs
|
|
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Dtos
|
|
{
|
|
public class XBaseIndexedDto<T, TKey, TIndex> : XBaseDto
|
|
{
|
|
public T Item { get; set; }
|
|
public TKey Key { get; set; }
|
|
public TIndex Index { get; set; }
|
|
}
|
|
|
|
public class XBaseIntIndexedDto<T> : XBaseIndexedDto<T, string, int> { }
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XDeviceDto.cs
|
|
|
|
using xCommons.Constants;
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Dtos {
|
|
public class XDeviceDto : XBaseDto {
|
|
/// <summary>
|
|
/// Operating System
|
|
/// </summary>
|
|
/// <value>device operating system identifier</value>
|
|
public string Os { get; set; }
|
|
/// <summary>
|
|
/// Operating System Version
|
|
/// </summary>
|
|
/// <value>which version of operatin system is in use</value>
|
|
public string OsVersion { get; set; }
|
|
/// <summary>
|
|
/// Device Browser
|
|
/// </summary>
|
|
/// <value>the Browser identifier</value>
|
|
public string Browser { get; set; }
|
|
/// <summary>
|
|
/// Browser Engine Agent
|
|
/// </summary>
|
|
/// <value>browser engine Agent</value>
|
|
public string UserAgent { get; set; }
|
|
/// <summary>
|
|
/// Type of client Device
|
|
/// </summary>
|
|
/// <value>represent device type <see>XDeviceType</see></value>
|
|
public XDeviceType DeviceType { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XFileDto.cs
|
|
|
|
using System;
|
|
using System.ComponentModel.DataAnnotations;
|
|
using xCommons.Constants;
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Dtos {
|
|
public partial class XFileDto : XBaseDto {
|
|
[Required]
|
|
public string AuthorId { get; set; }
|
|
|
|
public XFileType Type { get; set; }
|
|
|
|
[Required]
|
|
[StringLength (255)]
|
|
public string Name { get; set; }
|
|
|
|
[StringLength (255)]
|
|
public string Thumb { get; set; }
|
|
|
|
[Required]
|
|
[StringLength (255)]
|
|
public string Path { get; set; }
|
|
|
|
[StringLength (255)]
|
|
public string ThumbPath { get; set; }
|
|
|
|
[Required]
|
|
public DateTime UploadedOn { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XObjectResponseResult.cs
|
|
|
|
namespace xModels.Dtos {
|
|
/// <summary>
|
|
/// Some Requests Get Object Response Result of Data ...
|
|
/// </summary>
|
|
public struct XObjectResponseResult<T> {
|
|
|
|
public XObjectResponseResult (T responseObject, string responseText) {
|
|
this.Object = responseObject;
|
|
this.Text = responseText;
|
|
}
|
|
|
|
public T Object { get; }
|
|
|
|
public string Text { get; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XPersonDto.cs
|
|
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Dtos
|
|
{
|
|
/// <summary>
|
|
/// Since in Many Cases we have to Retrieve Specified User's Minimal
|
|
/// Infos for Handle Data Transfering, this Dto is Used ...
|
|
/// </summary>
|
|
public class XPersonDto : XBaseDto
|
|
{
|
|
public string Username { get; set; }
|
|
public string Firstname { get; set; }
|
|
public string Lastname { get; set; }
|
|
public string Avatar { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XQuery.cs
|
|
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Dtos {
|
|
/// <summary>
|
|
/// Request a Page of Data Based on Query ...
|
|
/// this can used in every Data Providers ...
|
|
/// </summary>
|
|
public class XQuery : XBaseDto {
|
|
/// <summary>
|
|
/// an string for filtering results
|
|
/// </summary>
|
|
/// <value></value>
|
|
public string Filter { get; set; } = null;
|
|
|
|
/// <summary>
|
|
/// determines fully load object with it's relational fields or not
|
|
/// </summary>
|
|
/// <value></value>
|
|
public bool ContainsDetail { get; set; } = false;
|
|
|
|
/// <summary>
|
|
/// specifiy sorting of items
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string SortBy { get; set; } = nameof (XBaseIntIDEntity.Id);
|
|
|
|
/// <summary>
|
|
/// specify sorting direction
|
|
/// </summary>
|
|
/// <value></value>
|
|
public bool IsAscending { get; set; } = true;
|
|
|
|
/// <summary>
|
|
/// specify page number
|
|
/// </summary>
|
|
/// <value></value>
|
|
public int Page { get; set; } = 1;
|
|
|
|
/// <summary>
|
|
/// specify page size
|
|
/// </summary>
|
|
/// <value></value>
|
|
public int PageSize { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XQueryResult.cs
|
|
|
|
using System.Collections.Generic;
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Dtos {
|
|
/// <summary>
|
|
/// Result of a Requested Page of Data Based on Query ...
|
|
/// this can used in every Data Providers ...
|
|
/// </summary>
|
|
public class XQueryResult<T> : XBaseDto {
|
|
/// <summary>
|
|
/// a collection of items for a page ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public IEnumerable<T> Items { get; set; }
|
|
|
|
/// <summary>
|
|
/// Current Page Number ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public long Page { get; set; }
|
|
|
|
/// <summary>
|
|
/// Current Page Size ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public long PageSize { get; set; }
|
|
|
|
/// <summary>
|
|
/// Total Pages ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public long TotalPages { get; set; }
|
|
|
|
/// <summary>
|
|
/// Total Filtered Items Pages Count ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public int TotalFilteredPages { get; set; }
|
|
|
|
/// <summary>
|
|
/// Total Filtered Items ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public long TotalFilteredItems { get; set; }
|
|
|
|
/// <summary>
|
|
/// Total Exists Items ...
|
|
/// </summary>
|
|
/// <value></value>
|
|
public long TotalItems { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XResourceDto.cs
|
|
|
|
using System.Collections.Generic;
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Dtos
|
|
{
|
|
public class XLocaleResourceDto : XBaseDto
|
|
{
|
|
public string Language { get; set; }
|
|
public string Value { get; set; }
|
|
}
|
|
|
|
public class XResourceDto : XBaseDto
|
|
{
|
|
public string Resource { get; set; }
|
|
public IEnumerable<XLocaleResourceDto> Locales { get; set; } = new HashSet<XLocaleResourceDto>();
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Dtos\XValidateRevisionRequest.cs
|
|
|
|
using System.ComponentModel.DataAnnotations;
|
|
|
|
namespace xModels.Dtos {
|
|
/// <summary>
|
|
/// in some cases we have to validate a revision of request, this is a model
|
|
/// which used to request a revision validator ...
|
|
/// </summary>
|
|
public class XValidateRevisionRequest {
|
|
[Required]
|
|
public string Revision { get; set; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Extensions\DIExtensions.cs
|
|
|
|
using Microsoft.Extensions.DependencyInjection;
|
|
using xCommons.Extensions;
|
|
using xExceptions.Constants;
|
|
using xModels.Base;
|
|
using xModels.Interfaces;
|
|
|
|
namespace xModels.Extensions {
|
|
public static class DIExtensions {
|
|
/// <summary>
|
|
/// Register an Specific Store in DI ...
|
|
/// </summary>
|
|
/// <param name="services">DI service collection ...</param>
|
|
/// <param name="store">an implementation of inetrface of store ...</param>
|
|
/// <param name="lifeTime">service lifetime</param>
|
|
/// <typeparam name="TImplementation">implementation of TType ...</typeparam>
|
|
/// <typeparam name="TType">an inetrface which implements IXBaseStore<TStoreItemDto, TKey></typeparam>
|
|
/// <typeparam name="TStoreItemDto">type of an instance of XBaseStorable<TKey></typeparam>
|
|
/// <typeparam name="TKey">type of key of StorableItem</typeparam>
|
|
/// <returns></returns>
|
|
public static void AddXStore<TImplementation, TType, TStoreItemDto, TKey> (
|
|
this IServiceCollection services,
|
|
TImplementation store,
|
|
ServiceLifetime lifeTime = ServiceLifetime.Singleton
|
|
)
|
|
where TImplementation : TType
|
|
where TType : IXBaseStore<TStoreItemDto, TKey>
|
|
where TStoreItemDto : XBaseStorableDto<TKey> {
|
|
//
|
|
// Validate Args ...
|
|
if (store.IsNull ()) {
|
|
throw XException.InvalidArgs
|
|
.ToException ();
|
|
}
|
|
|
|
//
|
|
// Register Service in DI ...
|
|
services.Add (new ServiceDescriptor (typeof (TType), typeof (TImplementation), lifeTime));
|
|
}
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Extensions\XModelExtensions.cs
|
|
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using xCommons.Extensions;
|
|
using xModels.Dtos;
|
|
|
|
namespace xModels.Extensions
|
|
{
|
|
public static class XModelExtensions
|
|
{
|
|
/// <summary>
|
|
/// Check to XDevice instance to be same or not
|
|
/// </summary>
|
|
/// <param name="source"></param>
|
|
/// <param name="dest"></param>
|
|
/// <returns></returns>
|
|
public static bool IsSameAs(this XDeviceDto source, XDeviceDto dest)
|
|
{
|
|
//
|
|
if (source.IsNull() ||
|
|
dest.IsNull())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//
|
|
var isSame = source.Os.ToNormalString() == dest.Os.ToNormalString() &&
|
|
source.OsVersion.ToNormalString() == dest.OsVersion.ToNormalString() &&
|
|
source.Browser.ToNormalString() == dest.Browser.ToNormalString() &&
|
|
source.UserAgent.ToNormalString() == dest.UserAgent.ToNormalString() &&
|
|
source.DeviceType == dest.DeviceType;
|
|
|
|
//
|
|
return isSame;
|
|
}
|
|
|
|
public static IEnumerable<T> AsEnumerable<T, TKey, TIndex>(
|
|
this IEnumerable<XBaseIndexedDto<T, TKey, TIndex>> source
|
|
)
|
|
{
|
|
return source.Select(i => i.Item);
|
|
}
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Interfaces\IXAuditable.cs
|
|
|
|
using System;
|
|
|
|
namespace xModels.Interfaces {
|
|
/// <summary>
|
|
/// Some times we need to wrap Entities by some logs or audits ...
|
|
/// this class provide Audit fields for an Auditable Entity ...
|
|
/// </summary>
|
|
public interface IXAuditable {
|
|
string UserAgent { get; }
|
|
string UserIp { get; }
|
|
DateTime TransactionTime { get; }
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Interfaces\IXBaseStore.cs
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq.Expressions;
|
|
using System.Threading.Tasks;
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Interfaces {
|
|
public interface IXBaseStore<T, TKey> where T : XBaseStorableDto<TKey> {
|
|
//
|
|
#region Retrieve ...
|
|
/// <summary>
|
|
/// Retrieve all Exists Items ...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
Task<IEnumerable<T>> GetAll ();
|
|
|
|
/// <summary>
|
|
/// Retrieve specific Item by key ...
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
Task<T> Get (TKey key);
|
|
|
|
/// <summary>
|
|
/// retrieve items based on specific condition ...
|
|
/// </summary>
|
|
/// <param name="condition"></param>
|
|
/// <returns></returns>
|
|
Task<IEnumerable<T>> FindMany (Expression<Func<T, bool>> condition);
|
|
|
|
/// <summary>
|
|
/// retrieve item based on specific condition ...
|
|
/// </summary>
|
|
/// <param name="condition"></param>
|
|
/// <returns></returns>
|
|
Task<T> FindOne (Expression<Func<T, bool>> condition);
|
|
#endregion
|
|
|
|
//
|
|
#region Add ...
|
|
/// <summary>
|
|
/// add specific item to Store ...
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <returns></returns>
|
|
Task<bool> Add (T item);
|
|
|
|
/// <summary>
|
|
/// Add a Collection of Items on Store ...
|
|
/// </summary>
|
|
/// <param name="items"></param>
|
|
/// <returns></returns>
|
|
Task<bool> AddMany (XBaseRangeRequest<T> items);
|
|
#endregion
|
|
|
|
//
|
|
#region Remove ...
|
|
/// <summary>
|
|
/// Remove an item from store ...
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <returns></returns>
|
|
Task<bool> Remove (T item);
|
|
|
|
/// <summary>
|
|
/// remove an item by it's Key ...
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
Task<bool> RemoveByKey (TKey key);
|
|
|
|
/// <summary>
|
|
/// remove a collection of items at once ...
|
|
/// </summary>
|
|
/// <param name="items"></param>
|
|
/// <returns></returns>
|
|
Task<bool> RemoveMany(XBaseRangeRequest<T> items);
|
|
#endregion
|
|
|
|
//
|
|
#region Update ...
|
|
/// <summary>
|
|
/// Update Exists Item in store ...
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <param name="propertyWhiteList"></param>
|
|
/// <param name="propertyBlackList"></param>
|
|
/// <param name="propertyValueProviders"></param>
|
|
/// <param name="updateWithNullOrEmptyValues"></param>
|
|
/// <returns></returns>
|
|
Task<T> Update (
|
|
T item,
|
|
ICollection<string> propertyWhiteList = null,
|
|
ICollection<string> propertyBlackList = null,
|
|
ICollection<KeyValuePair<string, Func<T, object>>> propertyValueProviders = null,
|
|
bool updateWithNullOrEmptyValues = false
|
|
);
|
|
|
|
/// <summary>
|
|
/// Update a Collection of Exists Items ...
|
|
/// </summary>
|
|
/// <param name="items"></param>
|
|
/// <param name="propertyWhiteList"></param>
|
|
/// <param name="propertyBlackList"></param>
|
|
/// <param name="propertyValueProviders"></param>
|
|
/// <param name="updateWithNullOrEmptyValues"></param>
|
|
/// <returns></returns>
|
|
Task<bool> UpdateMany (
|
|
XBaseRangeRequest<T> items,
|
|
ICollection<string> propertyWhiteList = null,
|
|
ICollection<string> propertyBlackList = null,
|
|
ICollection<KeyValuePair<string, Func<T, object>>> propertyValueProviders = null,
|
|
bool updateWithNullOrEmptyValues = false
|
|
);
|
|
#endregion
|
|
|
|
//
|
|
#region Exists ...
|
|
/// <summary>
|
|
/// retrieve item(s) exists based on specific condition ...
|
|
/// </summary>
|
|
/// <param name="condition"></param>
|
|
/// <returns></returns>
|
|
Task<bool> IsExists (Expression<Func<T, bool>> condition);
|
|
|
|
/// <summary>
|
|
/// is exists an item by providing it's key ...
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
Task<bool> IsExistsByKey (TKey key);
|
|
#endregion
|
|
|
|
//
|
|
#region Count ...
|
|
/// <summary>
|
|
/// Count Exists items ...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
Task<int> Count ();
|
|
#endregion
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Interfaces\IXBaseStoreEvents.cs
|
|
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using xModels.Base;
|
|
|
|
namespace xModels.Interfaces
|
|
{
|
|
public interface IXBaseStoreEvents<T, TKey> where T : XBaseStorableDto<TKey>
|
|
{
|
|
//
|
|
void AddEvent(XBaseStorableDtoEventModel<T> model);
|
|
void UpdateEvent(XBaseStorableDtoEventModel<T> model);
|
|
void RemoveEvent(XBaseStorableDtoEventModel<T> model);
|
|
|
|
//
|
|
void AddManyEvent(XBaseStorableDtoEventModel<IEnumerable<T>> model);
|
|
void UpdateManyEvent(XBaseStorableDtoEventModel<IEnumerable<T>> model);
|
|
void RemoveManyEvent(XBaseStorableDtoEventModel<IEnumerable<T>> model);
|
|
|
|
//
|
|
IObservable<XBaseStorableDtoEventModel<T>> OnAddObservable { get; }
|
|
IObservable<XBaseStorableDtoEventModel<T>> OnUpdateObservable { get; }
|
|
IObservable<XBaseStorableDtoEventModel<T>> OnRemoveObservable { get; }
|
|
|
|
//
|
|
IObservable<XBaseStorableDtoEventModel<IEnumerable<T>>> OnAddManyObservable { get; }
|
|
IObservable<XBaseStorableDtoEventModel<IEnumerable<T>>> OnUpdateManyObservable { get; }
|
|
IObservable<XBaseStorableDtoEventModel<IEnumerable<T>>> OnRemoveManyObservable { get; }
|
|
|
|
}
|
|
}
|
|
|
|
### FILE: C:\Users\SaherElm\Documents\Projects\xSaherelmWorkspace\Modules\xModels\Providers\XBaseInMemoryStore.cs
|
|
|
|
using System;
|
|
using System.Collections.Concurrent;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Linq.Expressions;
|
|
using System.Threading.Tasks;
|
|
using xCommons.Extensions;
|
|
using xModels.Base;
|
|
using xModels.Interfaces;
|
|
|
|
namespace xModels.Providers
|
|
{
|
|
public abstract class XBaseInMemoryStore<T, TKey> : IXBaseStore<T, TKey>
|
|
where T : XBaseStorableDto<TKey>
|
|
{
|
|
/// <summary>
|
|
/// this is main store of items ...
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <returns></returns>
|
|
private static ConcurrentBag<T> STORE = new ConcurrentBag<T>();
|
|
|
|
//
|
|
private readonly IXBaseStoreEvents<T, TKey> events;
|
|
|
|
//
|
|
#region Constructor ...
|
|
protected XBaseInMemoryStore(
|
|
IXBaseStoreEvents<T, TKey> events = null
|
|
)
|
|
{
|
|
this.events = events;
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Retrieve ...
|
|
/// <summary>
|
|
/// Retrieve all Exists Items ...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Task<IEnumerable<T>> GetAll()
|
|
{
|
|
//
|
|
var result = STORE.AsEnumerable();
|
|
return Task.FromResult(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieve specific Item by key ...
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public Task<T> Get(TKey key)
|
|
{
|
|
//
|
|
return IsExistsByKey(key)
|
|
.ContinueWith(isExistsTask =>
|
|
{
|
|
//
|
|
var isExists = isExistsTask
|
|
.RunTask();
|
|
|
|
//
|
|
if (!isExists)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
//
|
|
try
|
|
{
|
|
var result = STORE
|
|
.FirstOrDefault(i => GetKey(i).Equals(key));
|
|
return result;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// retrieve items based on specific condition ...
|
|
/// </summary>
|
|
/// <param name="condition"></param>
|
|
/// <returns></returns>
|
|
public Task<IEnumerable<T>> FindMany(Expression<Func<T, bool>> condition)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (condition.IsNull())
|
|
{
|
|
return Task.FromResult(new List<T>().AsEnumerable());
|
|
}
|
|
|
|
//
|
|
var whereFunc = condition.Compile();
|
|
var result = STORE.Where(whereFunc);
|
|
|
|
//
|
|
return Task.FromResult(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// retrieve item based on specific condition ...
|
|
/// </summary>
|
|
/// <param name="condition"></param>
|
|
/// <returns></returns>
|
|
public Task<T> FindOne(Expression<Func<T, bool>> condition)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (condition.IsNull())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
//
|
|
var whereFunc = condition.Compile();
|
|
var result = STORE.FirstOrDefault(whereFunc);
|
|
|
|
//
|
|
return Task.FromResult(result);
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Add ...
|
|
/// <summary>
|
|
/// add specific item to Store ...
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <returns></returns>
|
|
public Task<bool> Add(T item)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (item.IsNull() || GetKey(item).IsNull())
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
// Try to add item ...
|
|
return IsExistsByKey(GetKey(item))
|
|
.ContinueWith(isExistsTask =>
|
|
{
|
|
//
|
|
// Check item exists in Store or not ...
|
|
var isExists = isExistsTask.RunTask();
|
|
if (isExists)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Add Item to Store ...
|
|
STORE.Add(item);
|
|
OnAdd(item);
|
|
|
|
//
|
|
return true;
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Add a Collection of Items on Store ...
|
|
/// </summary>
|
|
/// <param name="items"></param>
|
|
/// <returns></returns>
|
|
public Task<bool> AddMany(XBaseRangeRequest<T> items)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
items.IsNull() ||
|
|
!items.Items.HasChild()
|
|
)
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
// Retrieve Must Add Items ...
|
|
var mustAddItems = items.Items
|
|
.Where(i => !GetKey(i)
|
|
.IsNull() && !STORE
|
|
.Any(si => GetKey(i).Equals(GetKey(si)))
|
|
);
|
|
if (!mustAddItems.HasChild())
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
// Add Items ...
|
|
try
|
|
{
|
|
//
|
|
mustAddItems
|
|
.ToList()
|
|
.ForEach(mi => STORE.Add(mi));
|
|
|
|
//
|
|
OnAddMany(mustAddItems);
|
|
|
|
//
|
|
return Task.FromResult(true);
|
|
}
|
|
catch
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Remove ...
|
|
/// <summary>
|
|
/// Remove an item from store ...
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <returns></returns>
|
|
public Task<bool> Remove(T item)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
item.IsNull() ||
|
|
!STORE
|
|
.Any(i => GetKey(i)
|
|
.Equals(GetKey(item)))
|
|
)
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
try
|
|
{
|
|
//
|
|
RemoveItemFromStore(item);
|
|
return Task.FromResult(true);
|
|
}
|
|
catch
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// remove an item by it's Key ...
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public Task<bool> RemoveByKey(TKey key)
|
|
{
|
|
return Get(key)
|
|
.ContinueWith(getTask =>
|
|
{
|
|
//
|
|
// retrieve item by it's Key ...
|
|
var item = getTask
|
|
.RunTask();
|
|
|
|
//
|
|
// Check item exists ...
|
|
if (item.IsNull())
|
|
{
|
|
return false;
|
|
}
|
|
|
|
//
|
|
// Try to remove item ...
|
|
var result = false;
|
|
try
|
|
{
|
|
//
|
|
result = Remove(item)
|
|
.RunTask();
|
|
}
|
|
catch
|
|
{
|
|
result = false;
|
|
}
|
|
|
|
//
|
|
return result;
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// remove a collection of items at once ...
|
|
/// </summary>
|
|
/// <param name="items"></param>
|
|
/// <returns></returns>
|
|
public Task<bool> RemoveMany(XBaseRangeRequest<T> items)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
items.IsNull() ||
|
|
!items.Items.HasChild()
|
|
)
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
var mustRemovedItems = items.Items
|
|
.Where(i => STORE
|
|
.Any(si => GetKey(si).Equals(GetKey(i)))
|
|
);
|
|
if (!mustRemovedItems.HasChild())
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
try
|
|
{
|
|
//
|
|
RemoveItemsFromStore(mustRemovedItems);
|
|
return Task.FromResult(true);
|
|
}
|
|
catch
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Update ...
|
|
/// <summary>
|
|
/// Update Exists Item in store ...
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <param name="propertyWhiteList"></param>
|
|
/// <param name="propertyBlackList"></param>
|
|
/// <param name="propertyValueProviders"></param>
|
|
/// <param name="updateWithNullOrEmptyValues"></param>
|
|
/// <returns></returns>
|
|
public Task<T> Update(
|
|
T item,
|
|
ICollection<string> propertyWhiteList = null,
|
|
ICollection<string> propertyBlackList = null,
|
|
ICollection<KeyValuePair<string, Func<T, object>>> propertyValueProviders = null,
|
|
bool updateWithNullOrEmptyValues = false
|
|
)
|
|
{
|
|
return Get(GetKey(item))
|
|
.ContinueWith(getTask =>
|
|
{
|
|
//
|
|
var existsItem = getTask
|
|
.RunTask();
|
|
|
|
//
|
|
// Validate item Exists ...
|
|
if (existsItem.IsNull())
|
|
{
|
|
return null;
|
|
}
|
|
|
|
//
|
|
try
|
|
{
|
|
//
|
|
var updatedItem = existsItem;
|
|
updatedItem.UpdateData(
|
|
updateWith: item,
|
|
propertyWhiteList: propertyWhiteList,
|
|
propertyBlackList: propertyBlackList,
|
|
propertyValueProviders: propertyValueProviders,
|
|
updateWithNullOrEmptyValues: updateWithNullOrEmptyValues,
|
|
throwExceptionOnFails: true
|
|
);
|
|
|
|
//
|
|
RemoveItemFromStore(existsItem);
|
|
STORE.Add(updatedItem);
|
|
OnUpdate(item);
|
|
|
|
//
|
|
return updatedItem;
|
|
}
|
|
catch
|
|
{
|
|
return null;
|
|
}
|
|
});
|
|
}
|
|
|
|
/// <summary>
|
|
/// Update a Collection of Exists Items ...
|
|
/// </summary>
|
|
/// <param name="items"></param>
|
|
/// <param name="propertyWhiteList"></param>
|
|
/// <param name="propertyBlackList"></param>
|
|
/// <param name="propertyValueProviders"></param>
|
|
/// <param name="updateWithNullOrEmptyValues"></param>
|
|
/// <returns></returns>
|
|
public Task<bool> UpdateMany(
|
|
XBaseRangeRequest<T> items,
|
|
ICollection<string> propertyWhiteList = null,
|
|
ICollection<string> propertyBlackList = null,
|
|
ICollection<KeyValuePair<string, Func<T, object>>> propertyValueProviders = null,
|
|
bool updateWithNullOrEmptyValues = false
|
|
)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (
|
|
items.IsNull() ||
|
|
!items.Items.HasChild()
|
|
)
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
// retrieve must updated items ...
|
|
var mustUpdateItems = items
|
|
.Items
|
|
.Where(i => STORE
|
|
.Any(
|
|
si => GetKey(i).Equals(GetKey(si)))
|
|
);
|
|
if (!mustUpdateItems.HasChild())
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
// Do Tasks ...
|
|
var mustUpdateTasks = mustUpdateItems.Select(i => Update(
|
|
i,
|
|
propertyWhiteList: propertyWhiteList,
|
|
propertyBlackList: propertyBlackList,
|
|
propertyValueProviders: propertyValueProviders,
|
|
updateWithNullOrEmptyValues: updateWithNullOrEmptyValues
|
|
));
|
|
return Task.WhenAll(mustUpdateTasks)
|
|
.ContinueWith(updateTasks =>
|
|
{
|
|
//
|
|
var updatedItems = updateTasks
|
|
.RunTask();
|
|
|
|
//
|
|
if (!updatedItems.HasChild())
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
OnUpdateMany(mustUpdateItems);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Exists ...
|
|
/// <summary>
|
|
/// retrieve item(s) exists based on specific condition ...
|
|
/// </summary>
|
|
/// <param name="condition"></param>
|
|
/// <returns></returns>
|
|
public Task<bool> IsExists(Expression<Func<T, bool>> condition)
|
|
{
|
|
//
|
|
// Validate Args ...
|
|
if (condition.IsNull())
|
|
{
|
|
return Task.FromResult(false);
|
|
}
|
|
|
|
//
|
|
var whereFunc = condition.Compile();
|
|
var result = STORE.Any(whereFunc);
|
|
|
|
//
|
|
return Task.FromResult(result);
|
|
}
|
|
|
|
/// <summary>
|
|
/// is exists an item by providing it's key ...
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public Task<bool> IsExistsByKey(TKey key)
|
|
{
|
|
return Task.Run(() =>
|
|
{
|
|
return STORE.Any(i => GetKey(i).Equals(key));
|
|
});
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Count ...
|
|
/// <summary>
|
|
/// Count Exists items ...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Task<int> Count()
|
|
{
|
|
//
|
|
var result = STORE.Count();
|
|
return Task.FromResult(result);
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Keys ...
|
|
/// <summary>
|
|
/// set Object Key ...
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <param name="id"></param>
|
|
public void SetKey(
|
|
ref T item,
|
|
TKey id
|
|
)
|
|
{
|
|
//
|
|
var props = item.GetType().GetProperties();
|
|
var keyProp = props.FirstOrDefault(p => p.Name == "Id");
|
|
if (keyProp.IsNull())
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
Type t = Nullable.GetUnderlyingType(keyProp.PropertyType) ?? keyProp.PropertyType;
|
|
object safeValue = (id == null) ? null : Convert.ChangeType(id, t);
|
|
keyProp.SetValue(item, safeValue, null);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get Object Key ...
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <returns></returns>
|
|
public TKey GetKey(T item)
|
|
{
|
|
//
|
|
var props = item.GetType().GetProperties();
|
|
var keyProp = props.FirstOrDefault(p => p.Name == "Id");
|
|
|
|
//
|
|
var keyString = string.Empty;
|
|
if (keyProp.IsNull())
|
|
{
|
|
keyString = string.Empty;
|
|
}
|
|
else
|
|
{
|
|
keyString = keyProp.GetValue(item).ToString();
|
|
}
|
|
|
|
//
|
|
if (keyString.IsNullOrEmpty())
|
|
{
|
|
return default(TKey);
|
|
}
|
|
|
|
//
|
|
// Prevent Deserializing issues throug JsonReader ...
|
|
if (keyString.IsGuid() && typeof(TKey) == typeof(Guid))
|
|
{
|
|
return item.Id;
|
|
}
|
|
|
|
//
|
|
TKey result;
|
|
try
|
|
{
|
|
result = keyString.FromJSON<TKey>();
|
|
}
|
|
catch
|
|
{
|
|
result = keyString.ConvertTo<TKey>();
|
|
}
|
|
return result;
|
|
}
|
|
#endregion
|
|
|
|
//
|
|
#region Private ...
|
|
private void RemoveItemFromStore(T item)
|
|
{
|
|
//
|
|
STORE = new ConcurrentBag<T>(
|
|
STORE.Except(new[] { item })
|
|
);
|
|
|
|
//
|
|
OnRemove(item);
|
|
}
|
|
|
|
private void RemoveItemsFromStore(IEnumerable<T> items)
|
|
{
|
|
//
|
|
STORE = new ConcurrentBag<T>(
|
|
STORE.Except(items)
|
|
);
|
|
|
|
//
|
|
OnRemoveMany(items);
|
|
}
|
|
|
|
//
|
|
#region Event Notifiers ...
|
|
private void OnAdd(T item)
|
|
{
|
|
//
|
|
if (!events.IsNull())
|
|
{
|
|
events.AddEvent(new XBaseStorableDtoEventModel<T>(item));
|
|
}
|
|
}
|
|
private void OnUpdate(T item)
|
|
{
|
|
//
|
|
if (!events.IsNull())
|
|
{
|
|
events.UpdateEvent(new XBaseStorableDtoEventModel<T>(item));
|
|
}
|
|
}
|
|
|
|
private void OnRemove(T item)
|
|
{
|
|
//
|
|
if (!events.IsNull())
|
|
{
|
|
events.RemoveEvent(new XBaseStorableDtoEventModel<T>(item));
|
|
}
|
|
}
|
|
|
|
private void OnAddMany(IEnumerable<T> items)
|
|
{
|
|
//
|
|
if (!events.IsNull())
|
|
{
|
|
events.AddManyEvent(new XBaseStorableDtoEventModel<IEnumerable<T>>(items));
|
|
}
|
|
}
|
|
|
|
private void OnUpdateMany(IEnumerable<T> items)
|
|
{
|
|
//
|
|
if (!events.IsNull())
|
|
{
|
|
events.UpdateManyEvent(new XBaseStorableDtoEventModel<IEnumerable<T>>(items));
|
|
}
|
|
}
|
|
|
|
private void OnRemoveMany(IEnumerable<T> items)
|
|
{
|
|
//
|
|
if (!events.IsNull())
|
|
{
|
|
events.RemoveManyEvent(new XBaseStorableDtoEventModel<IEnumerable<T>>(items));
|
|
}
|
|
}
|
|
#endregion
|
|
#endregion
|
|
}
|
|
}
|