private DataSet DataSetFromSqlText(IDataAccessStrategy dataAccess) { var dataSet = dataAccess.ReadData(); dataSet.Tables[0].TableName = CreateTableName(reportStructure); return(dataSet); }
public SqlRepositoryEntityFrameworkDisconnected(IEntityFrameworkDbContext ctx, ILogger logger, IMapper mapper, IDataAccessStrategy <T> dataAccessStrategy) : base(ctx, logger, mapper) { this.dataAccessStrategy = dataAccessStrategy; }
public static IDataManager CreateDataManager(IReportModel reportModel, ReportParameters reportParameters) { if (reportModel == null) { throw new ArgumentNullException("reportModel"); } IDataManager dataManager = null; ConnectionObject connectionObject = null; IDataAccessStrategy accesStrategy = null; if (reportParameters != null) { connectionObject = reportParameters.ConnectionObject; } if (connectionObject != null) { accesStrategy = new SqlDataAccessStrategy(reportModel.ReportSettings, connectionObject); } else { accesStrategy = new SqlDataAccessStrategy(reportModel.ReportSettings, null); } dataManager = DataManager.CreateInstance(reportModel.ReportSettings, accesStrategy); if (dataManager == null) { throw new MissingDataManagerException(); } return(dataManager); }
private DataManager (ReportSettings reportSettings,IDataAccessStrategy dataAccess) { DataSet dataSet = dataAccess.ReadData(); this.Init(reportSettings,dataSet.Tables[0]); this.dataViewStrategy = new TableStrategy((DataTable)this.dataSource, reportSettings); }
private DataManager(ReportSettings reportSettings, IDataAccessStrategy dataAccess) { DataSet dataSet = dataAccess.ReadData(); this.Init(reportSettings, dataSet.Tables[0]); this.dataViewStrategy = new TableStrategy((DataTable)this.dataSource, reportSettings); }
public static IDataManager CreateInstance (ReportSettings reportSettings ,IDataAccessStrategy dataAccess) { if (reportSettings == null) { throw new ArgumentNullException("reportSettings"); } if (dataAccess == null) { throw new ArgumentNullException("dataAccess"); } return new DataManager (reportSettings,dataAccess); }
private DataManager (ReportSettings reportSettings,IDataAccessStrategy dataAccess) { this.dataAccess = dataAccess; if (this.dataAccess.OpenConnection()) { DataSet t = this.dataAccess.ReadData(); this.Init(reportSettings,t.Tables[0]); this.dataViewStrategy = new TableStrategy((DataTable)this.dataSource, reportSettings); } }
public static IDataManager CreateInstance(ReportSettings reportSettings, IDataAccessStrategy dataAccess) { if (reportSettings == null) { throw new ArgumentNullException("reportSettings"); } if (dataAccess == null) { throw new ArgumentNullException("dataAccess"); } return(new DataManager(reportSettings, dataAccess)); }
private DataManager(ReportSettings reportSettings, IDataAccessStrategy dataAccess) { this.dataAccess = dataAccess; if (this.dataAccess.OpenConnection()) { DataSet t = this.dataAccess.ReadData(); this.Init(reportSettings, t.Tables[0]); this.dataViewStrategy = new TableStrategy((DataTable)this.dataSource, reportSettings); } }
public AccountController(ApplicationUserManager userManager, ApplicationSignInManager signInManager, IAuthenticationManager authenticationManager, ITaskManagerUow taskManagerUow, IDataAccessStrategy <ApplicationUser> dataAccessStrategy, TaskManagerTranslator taskManagerTranslator, IUserDataService userDataService) { this.userManager = userManager; this.signInManager = signInManager; this.authenticationManager = authenticationManager; this.taskManagerUow = taskManagerUow; this.dataAccessStrategy = dataAccessStrategy; this.taskManagerTranslator = taskManagerTranslator; this.userDataService = userDataService; }
private DataSet DataSetFromStoredProcedure(IDataAccessStrategy dataAccess) { DataSet dataSet = ResultPanel.CreateDataSet(); IProcedure procedure = reportStructure.IDatabaseObjectBase as IProcedure; var sqlParamCollection = CreateSqlParameters(procedure); if (sqlParamCollection.Count > 0) { reportStructure.SqlQueryParameters.AddRange(sqlParamCollection); model.ReportSettings.SqlParameters.AddRange(sqlParamCollection); CollectParamValues(model.ReportSettings); } dataSet = dataAccess.ReadData(); dataSet.Tables[0].TableName = procedure.Name; return(dataSet); }
public virtual Task <bool> DeleteAndCommitWithOptimisticConcurrencyAsync(T entity, IPrincipal principal, Action <string, string> writeError, IDataAccessStrategy <T> savingStrategy = default) { savingStrategy = savingStrategy ?? dataAccessStrategy; savingStrategy.ThrowIfNull(nameof(savingStrategy)); Task <bool> result; if (!savingStrategy.CanDelete(entity)) { writeError("", Resources.ErrorMessages.AccessDenied); result = Task.FromResult(false); } else { result = DeleteAndCommitWithOptimisticConcurrencyAsync(entity, writeError); } return(result); }
public DataUser(IDataAccessStrategy dataAccessStrategy) { _dataAccessStrategy = dataAccessStrategy; }
public SqlRepositoryEntityFrameworkDisconnected(IEntityFrameworkDbContext ctx, ILogger logger, IMapper mapper) : base(ctx, logger, mapper) { dataAccessStrategy = ServiceLocator.Current.GetInstance <IDataAccessStrategy <T> >(); }
public async Task <bool> SaveNewAsync <TInput>(TInput input, IPrincipal principal, IDataAccessStrategy <T> savingStrategy = default, params object[] args) { savingStrategy = savingStrategy ?? dataAccessStrategy; savingStrategy.ThrowIfNull(nameof(savingStrategy)); bool result = false; args = args.Concat(input); bool canAdd = await savingStrategy.CanAdd(args); if (canAdd) { savingStrategy.PrepareForAdd(args); await SaveNewAsync(input); //I tak EF nie obsługuje operacji równoległych result = true; } return(result); }
public virtual async Task <bool> SaveUpdatedWithOptimisticConcurrencyAsync(IHasRowVersion input, IPrincipal principal, Action <string, string> writeError, IDataAccessStrategy <T> savingStrategy = default) { bool result = false; var entity = mapper.Map <T>(input); result = await SaveUpdatedWithOptimisticConcurrencyAsync(entity, principal, writeError, savingStrategy); if (result) { mapper.Map(entity, input); } return(result); }
public virtual async Task <TOutput> SaveUpdatedWithOptimisticConcurrencyAsync <TOutput>(IHasRowVersion source, T destination, IPrincipal principal, Action <string, string> writeError, IDataAccessStrategy <T> savingStrategy = default) { savingStrategy = savingStrategy ?? dataAccessStrategy; savingStrategy.ThrowIfNull(nameof(savingStrategy)); TOutput result = default; if (savingStrategy.CanUpdate(destination)) { if (savingStrategy.CanUpdateAllProperties(destination)) { mapper.Map(source, destination); } else { var properties = savingStrategy.GetPropertiesForUpdate(destination); UpdateWithIncludeOrExcludeProperties(source, destination, true, properties); } bool success = await SaveUpdatedWithOptimisticConcurrencyAsync(destination, writeError, false); if (success) { result = mapper.Map <TOutput>(destination); } } else { writeError("", Resources.ErrorMessages.AccessDenied); } return(result); }
public virtual Task <bool> SaveUpdatedWithOptimisticConcurrencyAsync(T entity, IPrincipal principal, Action <string, string> writeError, IDataAccessStrategy <T> savingStrategy = default) { savingStrategy = savingStrategy ?? dataAccessStrategy; savingStrategy.ThrowIfNull(nameof(savingStrategy)); Task <bool> result; if (savingStrategy.CanUpdate(entity)) { if (savingStrategy.CanUpdateAllProperties(entity)) { Update(entity); } else { var properties = savingStrategy.GetPropertiesForUpdate(entity); UpdateWithIncludeOrExcludeProperties(entity, true, properties); } result = SaveUpdatedWithOptimisticConcurrencyAsync(entity, writeError, false); } else { writeError("", Resources.ErrorMessages.AccessDenied); result = Task.FromResult(false); } return(result); }
public ProductDataAccess(IDataParserStrategy <IProduct, string> parserStrategy, IDataAccessStrategy <string> accessStrategy) { ParserStrategy = parserStrategy; AccessStrategy = accessStrategy; }
public TransactionDataAccess(IDataParserStrategy <ITransaction, string> parserStrategy, IDataAccessStrategy <string> accessStrategy) { ParserStrategy = parserStrategy; AccessStrategy = accessStrategy; }
public TicketDataAccessStrategy(IPrincipal principal, IDataAccessStrategy <File> fileDataAccessStrategy) : base(principal) { this.fileDataAccessStrategy = fileDataAccessStrategy; }
public DataAccessHandler(IDataAccessStrategy strategy) { this.strategy = strategy; }
private DataSet DataSetFromSqlText(IDataAccessStrategy dataAccess) { var dataSet = dataAccess.ReadData(); dataSet.Tables[0].TableName = CreateTableName (reportStructure); return dataSet; }
public DataAccessContext(IDataAccessStrategy dataAccessStrategy) { _dataAccessStrategy = dataAccessStrategy; }
public TicketRepository(IEntityFrameworkDbContext ctx, ILogger logger, IMapper mapper, IDataAccessStrategy <Ticket> strategy) : base(ctx, logger, mapper, strategy) { }
public virtual async Task <TOutput> SaveUpdatedWithOptimisticConcurrencyAsync <TOutput>(IHasRowVersion input, IPrincipal principal, Action <string, string> writeError, IDataAccessStrategy <T> savingStrategy = default) { TOutput result = default; var entity = mapper.Map <T>(input); bool success = await SaveUpdatedWithOptimisticConcurrencyAsync(entity, principal, writeError, savingStrategy); if (success) { result = mapper.Map <TOutput>(entity); } return(result); }
public UserDataAccess(IDataParserStrategy <IUser, string> parserStrategy, IDataAccessStrategy <string> accessStrategy) { ParserStrategy = parserStrategy; AccessStrategy = accessStrategy; }
public FileService(ITaskManagerUow taskManagerUow, IDataAccessStrategy <File> dataAccessStrategy) { this.taskManagerUow = taskManagerUow; this.dataAccessStrategy = dataAccessStrategy; }
private DataSet DataSetFromStoredProcedure(IDataAccessStrategy dataAccess) { DataSet dataSet = ResultPanel.CreateDataSet(); IProcedure procedure = reportStructure.IDatabaseObjectBase as IProcedure; var sqlParamCollection = CreateSqlParameters(procedure); if (sqlParamCollection.Count > 0) { reportStructure.SqlQueryParameters.AddRange(sqlParamCollection); model.ReportSettings.SqlParameters.AddRange(sqlParamCollection); CollectParamValues(model.ReportSettings); } dataSet = dataAccess.ReadData(); dataSet.Tables[0].TableName = procedure.Name; return dataSet; }