public bool TryAddDataSource(DataSource dataSource, Expression <Func <DataSource, bool> > searchExpression)
{
ResolveLocker(typeof(DataSource)).EnterWriteLock();
try
{
var searchedDataSource = GetEntity(searchExpression, DataSourceRepository);
if (searchedDataSource != null)
{
return(false);
}
DataSourceRepository.Add(new EF.DataSource {
FileName = dataSource.FileName
});
DataSourceRepository.Save();
return(true);
}
catch (Exception)
{
throw new ObjectAdditionException(dataSource);
}
finally
{
ResolveLocker(typeof(DataSource)).ExitWriteLock();
}
}
public UserUoW(
ISessionManager sessionManager,
UserRepository userRepository,
RoleRepository roleRepository,
ClaimRepository claimRepository,
UserDataTypeRepository userDataTypeRepository,
ExternalIdentityRepository externalIdentityRepository,
UserContactVersioningProxy userContactRepository,
ResourcePermissionRepository resourcePermissionRepository,
ResourcePermissionTypeActionRepository resourcePermissionTypeActionRepository,
UserDataVersioningProxy userDataVersioningProxy,
LevelOfAssuranceRepository levelOfAssuranceRepository,
DataSourceRepository dataSourceRepository,
ExternalLoginProviderRepository externalLoginProviderRepository,
IDateTimeProvider dateTimeProvider,
IUserDataValidatorManager userDataValidatorManager,
UserDataStructureConvertor userDataStructureConvertor) : base(sessionManager)
{
m_userRepository = userRepository;
m_roleRepository = roleRepository;
m_claimRepository = claimRepository;
m_userDataTypeRepository = userDataTypeRepository;
m_externalIdentityRepository = externalIdentityRepository;
m_userContactRepository = userContactRepository;
m_resourcePermissionRepository = resourcePermissionRepository;
m_resourcePermissionTypeActionRepository = resourcePermissionTypeActionRepository;
m_userDataVersioningProxy = userDataVersioningProxy;
m_levelOfAssuranceRepository = levelOfAssuranceRepository;
m_dataSourceRepository = dataSourceRepository;
m_externalLoginProviderRepository = externalLoginProviderRepository;
m_dateTimeProvider = dateTimeProvider;
m_userDataValidatorManager = userDataValidatorManager;
m_userDataStructureConvertor = userDataStructureConvertor;
}
public ReportController()
{
_dataSources = _database.GetDataSourceRepository();
// Adding additional relation
//_dataSources.First(x => x.Name == typeof (Order).Name)
//.Joins.Add(new DataSourceJoinConfig("Order", "WarehouseID", "Warehouse", "WarehouseID"));
//.WithJoin<Order, Warehouse, int>(x => x.WarehouseID.Value, x => x.WarehouseID);
}
public DataSourceUoW(
ISessionManager sessionManager,
DataSourceRepository dataSourceRepository,
ExternalLoginProviderRepository externalLoginProviderRepository
) : base(sessionManager)
{
m_dataSourceRepository = dataSourceRepository;
m_externalLoginProviderRepository = externalLoginProviderRepository;
}
public DataSourceCache(
DataSourceRepository dataSourceRepository,
ExternalLoginProviderRepository externalLoginProviderRepository
)
{
m_dataSourceRepository = dataSourceRepository;
m_externalLoginProviderRepository = externalLoginProviderRepository;
m_cache = new ConcurrentDictionary <DataSourceEnum, DataSourceEntity>();
m_cacheExternalDource = new ConcurrentDictionary <string, DataSourceEntity>();
}
public UserContactUoW(
ISessionManager sessionManager,
UserContactVersioningProxy userContactRepository,
LevelOfAssuranceRepository levelOfAssuranceRepository,
DataSourceRepository dataSourceRepository) :
base(sessionManager)
{
m_userContactRepository = userContactRepository;
m_levelOfAssuranceRepository = levelOfAssuranceRepository;
m_dataSourceRepository = dataSourceRepository;
}
public virtual T Resolve <T>(ResolveFieldContext <T> ctx) where T : class, new()
{
// call this from generated GraphQueriesContext resolve lambda function
IEnumerable <T> results = DataSourceRepository.Query <T>(ctx.Arguments);
if (results.Count() > 1)
{
Logger.Warning("Top level GraphQuery returned more than one result for the specified arguments ({0})", GetArgumentString(ctx.Arguments));
}
return(results.FirstOrDefault() ?? new T());
}
public void SetUp()
{
Effort.Provider.EffortProviderConfiguration.RegisterProvider();
var connection = DbConnectionFactory.CreateTransient();
_context = new SampleEntities(connection);
_context.Fill();
_repo = new DataSourceRepository();
_repo.AddSource(_context.Things);
}
/// <summary>
/// Sample method to extract DataSourceRepository from a EF DbContext
/// </summary>
/// <param name="context"></param>
/// <param name="ignoreTypes"></param>
/// <returns></returns>
public static DataSourceRepository GetDataSourceRepository(this DbContext context, Type[] ignoreTypes = null)
{
var repo = new DataSourceRepository();
var dbsets = context.GetType().GetProperties().Where(p => p.PropertyType.IsGenericType
&&
p.PropertyType.GetGenericTypeDefinition() ==
typeof(DbSet <>))
.Select(
x =>
new
{
DbSet = (x.GetValue(context) as IQueryable),
PropertyType = x.PropertyType.GetGenericArguments().First()
})
.ToList();
if (dbsets.Any() == false)
{
return(repo);
}
if (ignoreTypes == null)
{
ignoreTypes = new Type[0];
}
foreach (var dbset in dbsets.Where(dbset => ignoreTypes.Any(x => x == dbset.PropertyType) == false))
{
var dataSourceConfig = repo.AddSource(dbset.DbSet, dbset.PropertyType);
var tableInfo = context.Db(dbset.PropertyType);
if (tableInfo == null || tableInfo.Fks.Any() == false)
{
continue;
}
foreach (var fk in tableInfo.Fks)
{
dataSourceConfig.Joins.Add(new DataSourceJoinConfig(dbset.PropertyType.Name, fk.PropertyName,
fk.FkTargetColumn.EntityMap.Type.Name, fk.FkTargetColumn.PropertyName));
}
}
repo.VerifyJoins();
return(repo);
}
private static async Task <IRepository <TEntity> > BuildTypedResult <TEntity>(DataSourceRepositoryConfiguration configuration, IServiceProvider serviceContainer, INamedServiceProvider namedServiceProvider)
where TEntity : IHavePartition <string, string>
{
var dataSource = namedServiceProvider.GetServiceAsync <IDataSource>(configuration.DataSourceName).GetAwaiter().GetResult();
IRepository <TEntity> result = new DataSourceRepository <TEntity>(dataSource, configuration.StoreName);
if (configuration.CacheDataSourceName != null)
{
var cacheDataSource = namedServiceProvider.GetServiceAsync <IDataSource>(configuration.CacheDataSourceName).GetAwaiter().GetResult();
IRepository <TEntity> cache = new DataSourceRepository <TEntity>(cacheDataSource, configuration.StoreName);
Func <Task> clear = () => Task.CompletedTask;
if (cacheDataSource is IClearable clearableCache)
{
clear = () => clearableCache.ClearAsync(configuration.StoreName);
}
result = new CachedRepository <TEntity>(cache, result, clear);
}
return(result);
}
private void InitializeMainTable(long masterReportId)
{
List <DataItemModel> systemTables = Integrity.GetSystemTables();
DataSourceRepository repo = new DataSourceRepository();
DataSourceMasterModel savedModel = repo.GetDataSourceMasterByPrimaryKey(masterReportId);
Dictionary <string, DataSourceTableModel> selectedTables = repo
.GetDataSourceTableByForeignKeyMasterReport_Id(masterReportId)
.ToDictionary(d => d.TableName);
this.MainTable = savedModel == null ? new DataSourceMasterModel {
MasterReport_Id = masterReportId
} : savedModel;
this.MainTable.SourceTables = systemTables.ToArray();
this.uxMainTable.Items.Add(this.MainTable);
this.uxMainTable[0, 0].IsReadOnly = savedModel != null;
foreach (DataItemModel table in systemTables)
{
if (table.DisplayValue == this.MainTable.MainTableName)
{
continue;
}
TreeViewItemTool tableItem = new TreeViewItemTool
{
Header = table.DisplayValue,
IsCheckBox = true,
IsChecked = selectedTables.ContainsKey(table.DisplayValue) ? selectedTables[table.DisplayValue].IsAvailable : false
};
this.uxOtherTables.Items.Add(tableItem);
this.treeTableItems.Add(tableItem);
}
}
/// <summary>
///
/// </summary>
public DataSources()
{
_repo = GetRepo <DataSourceRepository>(true);
CreateDataContext().AddOrgs();
}
public string GetData()
{
return(DataSourceRepository.GetDataFromSource());
}
