public virtual IList <DataModelType> GetModels()
{
using (DataModelProvider <DataModelType> dataProvider = this.CreateDataProvider())
{
return(dataProvider.GetModels());
}
}
public static void RegisterContext(DataModelProvider model, ContextConfiguration config, bool defaultModel)
{
// Just in case no model has been created yet
MetaModel m = new MetaModel();
if (defaultModel)
{
m = MetaModel.Default;
}
Exception exception = null;
MetaModel registered = null;
try {
registered = MetaModel.GetModel(model.ContextType);
} catch (Exception) {
// ignore
}
try {
if (registered == null)
{
m.RegisterContext(model, config);
}
} catch (InvalidOperationException ex) {
exception = ex;
}
if (exception != null)
{
Console.WriteLine("RegisterContext exception:");
Console.WriteLine(exception);
}
}
public void Delete(User user, OperationInfo opInfo)
{
using (DataModelProvider <UserDataModel> dataModelProvider = this.DataModelProviderFactory.CreateDataProvider <UserDataModel>())
{
UserDataModel model = dataModelProvider.SelectById(user.Id);
dataModelProvider.Update(model);
this.UserEvents.OnDeleted(user, opInfo);
}
}
public override CacheType GetCache(object key)
{
DataModelType model = null;
using (DataModelProvider <DataModelType> dataProvider = this.CreateDataProvider())
{
model = dataProvider.SelectById(key);
}
return(this.Map(model));
}
public DataServiceTableProvider(DataModelProvider model, PropertyInfo prop)
: base(model)
{
this._prop = prop;
Name = prop.Name;
EntityType = _prop.PropertyType.GetGenericArguments()[0];
_columns = new Collection <ColumnProvider>();
_readOnlyColumns = new ReadOnlyCollection <ColumnProvider>(_columns);
AddColumnsRecursive(EntityType);
}
public void Change(UserChangeInfo changeInfo)
{
this.UserEvents.OnChanging(changeInfo);
using (DataModelProvider <UserDataModel> dataModelProvider = this.DataModelProviderFactory.CreateDataProvider <UserDataModel>())
{
UserDataModel model = dataModelProvider.SelectById(changeInfo.ChangeUser.Id);
this.MapperFactory.Map <UserDataModel, UserChangeInfo>(model, changeInfo);
dataModelProvider.Update(model);
this.UserEvents.OnChanged(changeInfo);
}
}
public void RegisterContext(DataModelProvider dataModelProvider, ContextConfiguration configuration)
{
if (dataModelProvider == null)
{
throw new ArgumentNullException("dataModelProvider");
}
CheckRegistrationError();
try {
RegisterContextCore(dataModelProvider, configuration);
} catch (Exception ex) {
registration_exception = ex;
throw;
}
}
public void CreateDataProviderByModelType()
{
TestEFDataModelProviderFactory factroy = new TestEFDataModelProviderFactory();
DataModelProvider <TestDataModel> testModelProvider = factroy.CreateDataProvider <TestDataModel>();
Assert.IsNotNull(testModelProvider);
Assert.True(testModelProvider is TestDataModelProvider);
DataModelProvider <TestDataModel_1> testModel_1Provider = factroy.CreateDataProvider <TestDataModel_1>();
Assert.IsNotNull(testModel_1Provider);
Assert.True(testModel_1Provider is EFDataModelProvider <TestDataModel_1>);
}
public User Create(UserCreateInfo createInfo)
{
this.UserEvents.OnCreating(createInfo);
UserDataModel model = this.MapperFactory.Map <UserDataModel, UserCreateInfo>(createInfo);
using (DataModelProvider <UserDataModel> dataModelProvider = this.DataModelProviderFactory.CreateDataProvider <UserDataModel>())
{
dataModelProvider.Insert(model);
}
User user = this.MapperFactory.Map <User, UserDataModel>(model);
this.UserEvents.OnCreated(user, createInfo);
return(user);
}
public SimpleTableProvider(DataModelProvider model, Type entityType, object dataObject)
: base(model)
{
Name = entityType.Name;
EntityType = entityType;
var columns = new Collection <ColumnProvider>();
// Add a column for each public property we find
foreach (PropertyDescriptor columnProp in TypeDescriptor.GetProperties(dataObject))
{
columns.Add(new SimpleColumnProvider(this, columnProp));
}
_columns = new ReadOnlyCollection <ColumnProvider>(columns);
}
void RegisterContextCore(DataModelProvider dataModelProvider, ContextConfiguration configuration)
{
RegisterModel(dataModelProvider.ContextType, this, configuration);
var l = new List <MetaTable> (Tables);
foreach (var t in dataModelProvider.Tables)
{
l.Add(new MetaTable(this, t, configuration));
}
Tables = new ReadOnlyCollection <MetaTable> (l);
foreach (MetaTable t in l)
{
t.Init();
}
VisibleTables = l;
}
public MyTableProvider(DataModelProvider model)
: base(model)
{
}
public static void RegisterContext(DataModelProvider model)
{
RegisterContext(model, null);
}
public void LoadData <TId>(TId dataModelId) where TId : struct
{
_dataModel = DataModelProvider.GetById(dataModelId);
}
/// <summary>
/// Register context using give model provider. Uses default context configuration.
/// </summary>
/// <param name="dataModelProvider"></param>
public void RegisterContext(DataModelProvider dataModelProvider)
{
RegisterContext(dataModelProvider, new ContextConfiguration());
}
public virtual void RegisterContext(DataModelProvider dataModelProvider, ContextConfiguration configuration)
{
if (dataModelProvider == null)
{
throw new ArgumentNullException("dataModelProvider");
}
if (configuration == null)
{
throw new ArgumentNullException("configuration");
}
if (_registerGlobally)
{
CheckForRegistrationException();
}
// check if context has already been registered
if (_contextTypes.Contains(dataModelProvider.ContextType))
{
throw new InvalidOperationException(String.Format(CultureInfo.CurrentCulture, DynamicDataResources.MetaModel_ContextAlreadyRegistered, dataModelProvider.ContextType.FullName));
}
try {
IEnumerable <TableProvider> tableProviders = dataModelProvider.Tables;
// create and validate model
var tablesToInitialize = new List <MetaTable>();
foreach (TableProvider tableProvider in tableProviders)
{
RegisterMetadataTypeDescriptionProvider(tableProvider, configuration.MetadataProviderFactory);
MetaTable table = CreateTable(tableProvider);
table.CreateColumns();
var tableNameAttribute = tableProvider.Attributes.OfType <TableNameAttribute>().SingleOrDefault();
string nameOverride = tableNameAttribute != null ? tableNameAttribute.Name : null;
table.SetScaffoldAndName(configuration.ScaffoldAllTables, nameOverride);
CheckTableNameConflict(table, nameOverride, tablesToInitialize);
tablesToInitialize.Add(table);
}
_contextTypes.Add(dataModelProvider.ContextType);
if (_registerGlobally)
{
MetaModelManager.AddModel(dataModelProvider.ContextType, this);
}
foreach (MetaTable table in tablesToInitialize)
{
AddTable(table);
}
// perform initialization at the very end to ensure all references will be properly registered
foreach (MetaTable table in tablesToInitialize)
{
table.Initialize();
}
}
catch (Exception e) {
if (_registerGlobally)
{
s_registrationException = e;
}
throw;
}
}
public void RegisterContext(DataModelProvider dataModelProvider)
{
RegisterContext(dataModelProvider, null);
}
public static void RegisterContext(DataModelProvider model, ContextConfiguration config)
{
RegisterContext(model, config, true);
}
