public EntityUpdaterConcurrencyDecorator(
IEntityUpdater entityUpdater,
string propertyName = "RowVersion",
IEnumerable<Type> typesToExclude = null)
{
Init(entityUpdater,propertyName,typesToExclude);
}
protected IActionResult WrapUpdate <T>(long id, IEntityUpdater <T> updater)
where T : IEntity
{
return(_sessionHelper.TryUpdateEntity(updater, id, out var errors)
? Ok(SaveResultDto.SuccessResult(id))
: Error(errors));
}
public EntityUpdaterConcurrencyDecorator(
IEntityUpdater entityUpdater,
string propertyName = "RowVersion",
IEnumerable <Type> typesToExclude = null)
{
Init(entityUpdater, propertyName, typesToExclude);
}
public EventsController(IMapper mapper,
IEventsRepository gamesRepository,
IOrderByPropertyMappingService <EventDto, Event> orderByPropertyMappingService,
IEntityUpdater <Event, Guid> entityUpdater)
: base(mapper, gamesRepository, entityUpdater, orderByPropertyMappingService)
{
}
public PlayersController(IMapper mapper,
IPlayersRepository playersRepository,
IOrderByPropertyMappingService <PlayerDto, Player> orderByPropertyMappingService,
IEntityUpdater <Player, Guid> entityUpdater)
: base(mapper, playersRepository, entityUpdater, orderByPropertyMappingService)
{
}
public GamesController(IMapper mapper,
IGamesRepository gamesRepository,
IOrderByPropertyMappingService <GameDto, Game> orderByPropertyMappingService,
IEntityUpdater <Game, Guid> entityUpdater)
: base(mapper, gamesRepository, entityUpdater, orderByPropertyMappingService)
{
}
public SitesController(IMapper mapper,
ISitesRepository gamesRepository,
IOrderByPropertyMappingService <SiteDto, Site> orderByPropertyMappingService,
IEntityUpdater <Site, Guid> entityUpdater,
ILogger <SitesController> logger)
: base(mapper, gamesRepository, entityUpdater, orderByPropertyMappingService, logger: logger)
{
}
public World(IEntityUpdater <Player> playerUpdater, IRegionRepository regionRepository, IEntityList <Player> playerEntityList)
{
_playerUpdater = playerUpdater;
RegionRepository = regionRepository;
_playerEntityList = playerEntityList;
_cancellationTokenSource = new CancellationTokenSource();
_cancellationToken = _cancellationTokenSource.Token;
}
public PlayerCollectionsController(
IMapper mapper,
IPlayersRepository playersRepository,
IOrderByPropertyMappingService <PlayerDto, Player> orderByPropertyMappingService,
IEntityUpdater <Player, Guid> entityUpdater
) : base(mapper, playersRepository, entityUpdater, orderByPropertyMappingService)
{
_playersRepository = NullX.Throw(playersRepository, nameof(playersRepository));
}
public TestResourceController(
IMapper mapper,
IResourceRepository <TestEntity, Guid> resourceRepository,
IOrderByPropertyMappingService <TestDto, TestEntity> orderByPropertyMappingService,
IEntityUpdater <TestEntity, Guid> entityUpdater,
Action <HateoasConfig> config = null)
: base(mapper, resourceRepository, entityUpdater, orderByPropertyMappingService, config)
{
}
public Silenter(IEntityUpdater <T> listenerRegister, object target)
{
_ListenerRegister = listenerRegister;
_Target = target as T;
if (_Target != null)
{
_ListenerRegister.OnExit(_Target);
}
}
/// <summary>
/// Instantiates the class using default components
/// </summary>
/// <param name="dbContext">Context in which to perform the merge operation</param>
/// <param name="modelsNamespace">Namespace in which all context entities are defined (all models must be within
/// the same namespace. If model type is in a different namespace, an exception will be thrown when instantiating
/// the type. This is, hopefully, a temporary workaround, until I find a good solution for this)</param>
/// <param name="modelAssemblyName">Name of assembly which contains all context enties. Again, just like with the
/// namespace parameter, this is a temporary workaround</param>
public DefaultEntityChangesMerger(DbContext dbContext, string modelsNamespace, string modelAssemblyName)
{
DbContext = dbContext;
reflector = new DbContextReflector(DbContext, modelsNamespace, modelAssemblyName);
scalarUpdater = new ScalarPropertyUpdater(DbContext, reflector);
entityComparer = new EntityComparerByNonForeignKeys();
collectionMerger = new CollectionMerger(entityComparer);
navUpdater = new NavigationPropertyUpdater(DbContext, scalarUpdater, reflector);
}
protected DbContextBase(
IExceptionMapper exceptionMapper = null,
IEntityAdder entityAdder = null,
IEntityUpdater entityUpdater = null,
IEntityDeleter entityDeleter = null,
IEntityDetacher entityDetacher = null)
: base()
{
Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
}
public DefaultOperationHandlerProvider(
IEntityReader entityReader,
IEntityCreator entityCreator,
IEntityUpdater entityUpdater,
IODataEntityDtoBuilderFactory dtoBuilderFactory)
{
this.getOperationHandler = new GetEntityOperationHandler(entityReader, dtoBuilderFactory);
this.patchOperationHandler = new PatchEntityOperationHandler(entityReader, entityUpdater, dtoBuilderFactory);
this.postOperationHandler = new PostEntityOperationHandler(entityReader, entityCreator, dtoBuilderFactory);
}
public EntityUpdaterController(IWebAppContext appContext
, ISolutionService solutionService
, IEntityUpdater entityCreater
, IEntityFinder entityFinder
)
: base(appContext, solutionService)
{
_entityUpdater = entityCreater;
_entityFinder = entityFinder;
}
private FullListenerRegister(Action <INotifyPropertyChanged> propertyOn, Action <INotifyPropertyChanged> propertyOff,
Action <INotifyCollectionChanged> collectionOn, Action <INotifyCollectionChanged> collectionOff,
Action <JsCommandBase> jsCommandOn, Action <JsCommandBase> jsCommandOff)
{
Property = new ListenerRegister <INotifyPropertyChanged>(propertyOn, propertyOff);
Collection = new ListenerRegister <INotifyCollectionChanged>(collectionOn, collectionOff);
Command = new ListenerRegister <JsCommandBase>(jsCommandOn, jsCommandOff);
On = new ObjectChangesListener(Property.OnEnter, Collection.OnEnter, Command.OnEnter);
Off = new ObjectChangesListener(Property.OnExit, Collection.OnExit, Command.OnExit);
}
protected DbContextBase(
IExceptionMapper exceptionMapper = null,
IEntityAdder entityAdder = null,
IEntityUpdater entityUpdater = null,
IEntityDeleter entityDeleter = null,
IEntityDetacher entityDetacher = null)
: base()
{
Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
}
public EntityUpdaterConcurrencyDecorator(
IEntityUpdater entityUpdater,
Expression<Func<object, byte[]>> propertyExpr,
IEnumerable<Type> typesToExclude = null)
{
if (propertyExpr == null)
throw new ArgumentNullException("propertyExpr");
Init(entityUpdater, ExpressionHelper.GetMemberName(propertyExpr), typesToExclude);
}
public DbContextBase(
string nameOrConnectionString,
IExceptionMapper exceptionMapper = null,
IEntityAdder entityAdder = null,
IEntityUpdater entityUpdater = null,
IEntityDeleter entityDeleter = null,
IEntityDetacher entityDetacher = null)
: base(nameOrConnectionString)
{
Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
}
public WorkstationsController(
AlohaContext dbContext,
IClassMapping <Workstation, WorkstationDto> workstationToWorkstationDtoMapping,
IClassMapping <WorkstationDto, Workstation> workstationDtoToWorkstationMapping,
IEntityUpdater <Workstation> workstationUpdater)
{
this.dbContext = dbContext;
this.workstationToWorkstationDtoMapping = workstationToWorkstationDtoMapping;
this.workstationDtoToWorkstationMapping = workstationDtoToWorkstationMapping;
this.workstationUpdater = workstationUpdater;
}
public DbContextBase(
string nameOrConnectionString,
IExceptionMapper exceptionMapper = null,
IEntityAdder entityAdder = null,
IEntityUpdater entityUpdater = null,
IEntityDeleter entityDeleter = null,
IEntityDetacher entityDetacher = null)
: base(nameOrConnectionString)
{
Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
}
public DbContextBase(
DbConnection existingConnection,
bool contextOwnsConnection,
IExceptionMapper exceptionMapper = null,
IEntityAdder entityAdder = null,
IEntityUpdater entityUpdater = null,
IEntityDeleter entityDeleter = null,
IEntityDetacher entityDetacher = null)
: base(existingConnection, contextOwnsConnection)
{
Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
}
public DbContextBase(
ObjectContext objectContext,
bool dbContextOwnsObjectContext,
IExceptionMapper exceptionMapper = null,
IEntityAdder entityAdder = null,
IEntityUpdater entityUpdater = null,
IEntityDeleter entityDeleter = null,
IEntityDetacher entityDetacher = null)
: base(objectContext, dbContextOwnsObjectContext)
{
Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
}
public EntityUpdaterConcurrencyDecorator(
IEntityUpdater entityUpdater,
Expression <Func <object, byte[]> > propertyExpr,
IEnumerable <Type> typesToExclude = null)
{
if (propertyExpr == null)
{
throw new ArgumentNullException("propertyExpr");
}
Init(entityUpdater, ExpressionHelper.GetMemberName(propertyExpr), typesToExclude);
}
public EntityImporter(IAppContext appContext
, IEntityCreater entityCreater
, IEntityUpdater entityUpdater
, IEntityFinder entityFinder
, IAttributeImporter attributeImporter)
{
_appContext = appContext;
_entityCreater = entityCreater;
_entityUpdater = entityUpdater;
_entityFinder = entityFinder;
_attributeImporter = attributeImporter;
}
public OrdersController(IEntityGetter <Order, OrderItemViewModel> getter,
IEntityCollectionGetter <Order, OrderItemViewModel> collectionGetter,
IEntityCreator <OrderBindingModel, Order> creator,
IEntityUpdater <OrderQuantityBindingModel, Order> updater,
IEntityDeleter <Order> deleter)
{
_getter = getter;
_collectionGetter = collectionGetter;
_creator = creator;
_deleter = deleter;
_updater = updater;
}
public DbContextBase(
DbConnection existingConnection,
bool contextOwnsConnection,
IExceptionMapper exceptionMapper = null,
IEntityAdder entityAdder = null,
IEntityUpdater entityUpdater = null,
IEntityDeleter entityDeleter = null,
IEntityDetacher entityDetacher = null)
: base(existingConnection, contextOwnsConnection)
{
Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
}
public DbContextBase(
ObjectContext objectContext,
bool dbContextOwnsObjectContext,
IExceptionMapper exceptionMapper = null,
IEntityAdder entityAdder = null,
IEntityUpdater entityUpdater = null,
IEntityDeleter entityDeleter = null,
IEntityDetacher entityDetacher = null)
: base(objectContext, dbContextOwnsObjectContext)
{
Init(exceptionMapper, entityAdder, entityUpdater, entityDeleter, entityDetacher);
}
public ListenerUpdater(IJsUpdaterFactory jsUpdaterFactory)
{
_JsUpdaterFactory = jsUpdaterFactory;
_JsUpdaterFactory.OnJavascriptSessionReady += _JsUpdaterFactory_OnJavascriptSessionReady;
_Property = new ListenerRegister <INotifyPropertyChanged>(n => n.PropertyChanged += OnCSharpPropertyChanged, n => n.PropertyChanged -= OnCSharpPropertyChanged);
_Collection = new ListenerRegister <INotifyCollectionChanged>(n => n.CollectionChanged += OnCSharpCollectionChanged, n => n.CollectionChanged -= OnCSharpCollectionChanged);
var command = new ListenerRegister <ICommand>(c => c.CanExecuteChanged += OnCommandCanExecuteChanged, c => c.CanExecuteChanged -= OnCommandCanExecuteChanged);
var updatableCommand = new ListenerRegister <IUpdatableCommand>(c => c.CanExecuteChanged += OnCommandCanExecuteChanged, c => c.CanExecuteChanged -= OnCommandCanExecuteChanged);
On = new ObjectChangesListener(_Property.OnEnter, _Collection.OnEnter, command.OnEnter, updatableCommand.OnEnter);
Off = new ObjectChangesListener(_Property.OnExit, _Collection.OnExit, command.OnExit, updatableCommand.OnExit);
}
public WorkersController(
AlohaContext alohaContext,
IClassMapping <Worker, WorkerDto> workerToWorkerDtoMapping,
IClassMapping <WorkerDto, Worker> workerDtoToWorkerMapping,
IEntityUpdater <Worker> workerUpdater,
ISecurityService securityService)
{
this.alohaContext = alohaContext;
this.workerToWorkerDtoMapping = workerToWorkerDtoMapping;
this.workerDtoToWorkerMapping = workerDtoToWorkerMapping;
this.workerUpdater = workerUpdater;
this.securityService = securityService;
}
private void Init(
IExceptionMapper exceptionMapper,
IEntityAdder entityAdder,
IEntityUpdater entityUpdater,
IEntityDeleter entityDeleter,
IEntityDetacher entityDetacher)
{
SetExceptionMapper(exceptionMapper);
SetEntityAdder(entityAdder);
SetEntityUpdater(entityUpdater);
SetEntityDeleter(entityDeleter);
SetEntityDetacher(entityDetacher);
}
public FloorsController(
AlohaContext dbContext,
IClassMapping <Floor, FloorDto> floorToFloorDtoMapping,
IClassMapping <FloorDto, Floor> floorDtoToFloorMapping,
IClassMapping <Workstation, WorkstationDto> workstationToWorkstationDtoMapping,
IEntityUpdater <Floor> floorUpdater)
{
this.dbContext = dbContext;
this.floorToFloorDtoMapping = floorToFloorDtoMapping;
this.floorDtoToFloorMapping = floorDtoToFloorMapping;
this.workstationToWorkstationDtoMapping = workstationToWorkstationDtoMapping;
this.floorUpdater = floorUpdater;
}
public OfficesController(
AlohaContext dbContext,
IClassMapping <Office, OfficeDto> officeToOfficeDtoMapping,
IClassMapping <OfficeDto, Office> officeDtoToOfficeMapping,
IClassMapping <Floor, FloorDto> floorToFloorDtoMapping,
IEntityUpdater <Office> officeUpdater)
{
this.dbContext = dbContext;
this.officeToOfficeDtoMapping = officeToOfficeDtoMapping;
this.officeDtoToOfficeMapping = officeDtoToOfficeMapping;
this.floorToFloorDtoMapping = floorToFloorDtoMapping;
this.officeUpdater = officeUpdater;
}
public PropertyChangedSilenter(IEntityUpdater <INotifyPropertyChanged> listenerRegister, object target, string propertyName)
{
_ListenerRegister = listenerRegister;
_PropertyName = propertyName;
_Target = target as INotifyPropertyChanged;
if (_Target == null)
{
return;
}
_Target.PropertyChanged += TargetPropertyChanged;
_ListenerRegister.OnExit(_Target);
_ListenerRegister.OnEnter(this);
}
/// <summary>
///
/// </summary>
/// <param name="mapper">AutoMapper instance</param>
/// <param name="resourceRepository">Resource repository instance</param>
/// <param name="entityUpdater">Entity ID Updater required for Upserts </param>
/// <param name="orderByPropertyMappingService">Optional services to map resource property names to entity property names</param>
/// <param name="config">Optional configuration overides.</param>
/// <param name="logger">Optional logger.</param>
protected ResourceControllerBase([NotNull] IMapper mapper,
[NotNull] IResourceRepository <TEntity, TId> resourceRepository,
IEntityUpdater <TEntity, TId> entityUpdater,
IOrderByPropertyMappingService <TDto, TEntity> orderByPropertyMappingService = null,
Action <HateoasConfig> config = null,
ILogger <ResourceControllerBase <TDto, TEntity, TId> > logger = null)
{
Logger = logger;
ConfigureHateoas(config);
Mapper = NullX.Throw(mapper, nameof(mapper));
_restResourceRepository = NullX.Throw(resourceRepository, nameof(resourceRepository));
_orderByPropertyMappingService = NullX.Throw(orderByPropertyMappingService, nameof(orderByPropertyMappingService));
_entityUpdater = NullX.Throw(entityUpdater, nameof(entityUpdater));
}
public GraphService(
WinContext winContext,
IClassMapping <Graph, GraphDto> graphToGraphDtoMapping,
IClassMapping <GraphDto, Graph> graphDtoToGraphMapping,
IEntityUpdater <Graph> graphUpdater,
IClassMapping <Concept, ConceptDto> conceptToConceptDtoMapping,
IClassMapping <ConceptDto, Concept> conceptDtoToConceptMapping,
IEntityUpdater <Concept> conceptUpdater
)
{
this.winContext = winContext;
this.graphToGraphDtoMapping = graphToGraphDtoMapping;
this.graphDtoToGraphMapping = graphDtoToGraphMapping;
this.graphUpdater = graphUpdater;
this.conceptToConceptDtoMapping = conceptToConceptDtoMapping;
this.conceptDtoToConceptMapping = conceptDtoToConceptMapping;
this.conceptUpdater = conceptUpdater;
}
private void Init(
IEntityUpdater entityUpdater,
string propertyName,
IEnumerable<Type> typesToExclude)
{
if (entityUpdater == null)
{
throw new ArgumentNullException("entityUpdater");
}
if (string.IsNullOrWhiteSpace(propertyName))
{
throw new ArgumentNullException("propertyName");
}
_entityUpdater = entityUpdater;
_propertyName = propertyName;
_typesToExclude = typesToExclude ?? Enumerable.Empty<Type>();
}
protected virtual void SetEntityUpdater(IEntityUpdater entityUpdater)
{
_entityUpdater = entityUpdater ?? new EntityUpdater();
}
private void Init(
IExceptionMapper exceptionMapper,
IEntityAdder entityAdder,
IEntityUpdater entityUpdater,
IEntityDeleter entityDeleter,
IEntityDetacher entityDetacher)
{
SetExceptionMapper(exceptionMapper);
SetEntityAdder(entityAdder);
SetEntityUpdater(entityUpdater);
SetEntityDeleter(entityDeleter);
SetEntityDetacher(entityDetacher);
}
