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;
}
public DataUser(IDataAccessStrategy dataAccessStrategy)
{
_dataAccessStrategy = dataAccessStrategy;
}
