public override async Task <bool> Handle()
{
if (MainObject.Type != "https://www.w3.org/ns/activitystreams#Like")
{
return(true);
}
var userData = Actor.Data;
string targetCollectionId = null;
targetCollectionId = userData["liked"].SingleOrDefault()?.Id;
if (targetCollectionId == null)
{
return(true);
}
var targetCollection = await EntityStore.GetEntity(targetCollectionId, false);
var objectEntity = await EntityStore.GetEntity(MainObject.Data["object"].Single().Id, true);
if (objectEntity == null)
{
throw new InvalidOperationException($"Cannot {MainObject.Type.ToLower()} a non-existant object!");
}
await _collection.AddToCollection(targetCollection, objectEntity);
return(true);
}
public void Delete(ModelViewModel viewModel)
{
Model toRemove = EntityStore.Models.Find(viewModel.Id);
EntityStore.Models.Remove(toRemove);
EntityStore.SaveChanges();
}
public ContactsEndpoint(EntityStore<ContactEntity, int> contacts)
: base("/contacts")
{
Get["/"] = parameters =>
{
string token = Request.Query.token;
if (token.ToNullableGuid() != FakeyAuth.Token)
{
return new Response()
{
StatusCode = HttpStatusCode.Forbidden
};
}
return contacts.GetAll();
};
Post["/"] = parameters =>
{
var contact = this.Bind<ContactEntity>();
contact.Created = DateTime.UtcNow;
ValidationUtil.AssertIsValid(contact);
contacts.Save(contact);
return contact;
};
}
public void WhereClauseWithGetDatePartWeekDay()
{
var store = new EntityStore(_dbConnection);
var singleEmployee = store.GetSingle <Employee>(e => SqlFunctions.GetWeekday(e.Birthdate) >= 2);
Xunit.Assert.NotNull(singleEmployee);
}
public void WhereClauseWithGetDatePartMillisecond()
{
var store = new EntityStore(_dbConnection);
var singleEmployee = store.GetSingle <Order>(o => SqlFunctions.GetMillisecond(o.OrderDate) >= 0);
Xunit.Assert.NotNull(singleEmployee);
}
public void WhereClauseWithGetDatePartYear()
{
var store = new EntityStore(_dbConnection);
var singleEmployee = store.GetSingle <Employee>(e => SqlFunctions.GetYear(e.Birthdate) <= DateTime.Now.Year);
Xunit.Assert.NotNull(singleEmployee);
}
public void WhereClauseWithGetDatePartDayOfYear1()
{
var store = new EntityStore(_dbConnection);
var order = store.GetSingle <Order>(o => SqlFunctions.GetDayOfYear(o.OrderDate) <= DateTime.Now.DayOfYear);
Xunit.Assert.NotNull(order);
}
public void WhereClauseWithAddWeeks()
{
var store = new EntityStore(_dbConnection);
var singleEmployee = store.GetSingle <Employee>(e => SqlFunctions.AddWeeks(e.Birthdate, -3) >= DateTime.Now.AddMonths(-90 * 12));
Xunit.Assert.NotNull(singleEmployee);
}
public void WhereClauseWithAddMilliseconds()
{
var store = new EntityStore(_dbConnection);
var singleEmployee = store.GetSingle <Order>(o => SqlFunctions.AddMilliseconds(o.OrderDate, 30000) >= DateTime.Now.AddMonths(-90 * 12));
Xunit.Assert.NotNull(singleEmployee);
}
public void SeletTop2()
{
var store = new EntityStore(_dbConnection);
int skip = 10, take = 10;
var sortOrder = new List <SortOrderField>
{
new SortOrderField(typeof(Employee), "LastName"),
new SortOrderField(typeof(Employee), "FirstName"),
new SortOrderField(typeof(Employee), "City", SortOrder.Descending)
};
var selectQuery = store.GetSelectQuery <Employee>()
.GetTopRows(skip + take)
.Where(e => e.Id > 1)
.OrderBy(sortOrder);
var employeeSet = store.ExecuteQuery(selectQuery);
Xunit.Assert.NotNull(employeeSet);
var returnSet = employeeSet.Skip(skip).Take(take);
Xunit.Assert.NotNull(returnSet);
Xunit.Assert.True(returnSet.Count() == take);
}
public void WhereClauseWithAddMinutes()
{
var store = new EntityStore(_dbConnection);
var singleEmployee = store.GetSingle <Order>(o => SqlFunctions.AddMinutes(o.OrderDate, -3) >= DateTime.Now.AddMinutes(-90 * 12 * 30 * 24 * 60));
Xunit.Assert.NotNull(singleEmployee);
}
public void SelectByKey()
{
var store = new EntityStore(_dbConnection);
var SteveEmployeeId = 1;
var employee = store.GetByKey <Employee>(1);
var employee1 = store.GetByKey <Employee>(new { Id = 1 });
var employee2 = store.GetByKey <Employee>(new Employee {
Id = 1, FirstName = "Steve", LastName = "Rogers"
});
var employee3 = store.GetByKey <Employee>(SteveEmployeeId);
var order = store.GetByKey <Order>(1);
var order1 = store.GetByKey <Order>(new { Id = 1 });
Xunit.Assert.NotNull(employee);
Xunit.Assert.NotNull(employee1);
Xunit.Assert.NotNull(employee2);
Xunit.Assert.NotNull(employee3);
Xunit.Assert.True(employee.Id == 1);
Xunit.Assert.True(employee1.Id == 1);
Xunit.Assert.True(employee2.Id == 1);
Xunit.Assert.True(employee3.Id == 1);
Xunit.Assert.NotNull(order);
Xunit.Assert.NotNull(order1);
Xunit.Assert.True(order.Id == 1);
Xunit.Assert.True(order1.Id == 1);
}
//public static async AsyncReply<T> CreateResourceAsync<T>(this IServiceProvider serviceProvider, T properties = null) where T : class, IResource
//{
// var options = serviceProvider.GetService<IDbContextOptions>().FindExtension<EsiurExtensionOptions<T>>();
// var resource = await Warehouse.New<T>("", options.Store, null, null, null, properties);
// resource.Instance.Managers.AddRange(options.Store.Instance.Managers.ToArray());
// return resource;
//}
//public static T CreateResource<T>(this IServiceProvider serviceProvider, object properties = null) where T : class, IResource
// => CreateResourceAsync<T>(serviceProvider, properties).Wait();
public static DbContextOptionsBuilder UseEsiur(this DbContextOptionsBuilder optionsBuilder,
EntityStore store,
Func <DbContext> getter = null
//IServiceCollection services = null
//string name = null,
//IResource parent = null,
//IPermissionsManager manager = null,
//Func<DbContext> dbContextProvider = null
)
{
var extension = optionsBuilder.Options.FindExtension <EsiurExtensionOptions>();
if (extension == null)
{
if (store == null)
{
return(optionsBuilder);
}
store.Options = optionsBuilder.Options;
extension = new EsiurExtensionOptions(store);
}
((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension);
return(optionsBuilder);
}
public override async Task <bool> Handle()
{
if (MainObject.Type != "https://www.w3.org/ns/activitystreams#Delete")
{
return(true);
}
var oldObject = await EntityStore.GetEntity(MainObject.Data["object"].Single().Id, true);
var newData = oldObject.Data;
foreach (var kv in newData)
{
if (!DeleteWhitelist.Contains(kv.Key))
{
kv.Value.Clear();
}
}
newData.Type.Clear();
newData.Type.Add("https://www.w3.org/ns/activitystreams#Tombstone");
newData.Replace("deleted", ASTerm.MakePrimitive(DateTime.Now.ToString("o")));
var newObject = APEntity.From(newData);
await EntityStore.StoreEntity(newObject);
return(true);
}
public override async Task <bool> Handle()
{
if (MainObject.Type != "Like" && MainObject.Type != "Follow")
{
return(true);
}
var userData = Actor.Data;
string targetCollectionId = null;
if (MainObject.Type == "Like")
{
targetCollectionId = (string)userData["likes"].Single().Primitive;
}
else if (MainObject.Type == "Follow")
{
targetCollectionId = (string)userData["following"].Single().Primitive;
}
var targetCollection = await EntityStore.GetEntity(targetCollectionId, false);
var objectEntity = await EntityStore.GetEntity((string)MainObject.Data["object"].Single().Primitive, true);
if (objectEntity == null)
{
throw new InvalidOperationException($"Cannot {MainObject.Type.ToLower()} a non-existant object!");
}
await _collection.AddToCollection(targetCollection, objectEntity);
return(true);
}
public Bootstrap(IDbConnection dbConnection)
{
lock (_lockObject)
{
if (!EntityMapper.Entities.Keys.Any())
{
var assembliesOfModelTypes = new[]
{
Assembly.Load("FluentSql.Tests")
};
var store = new EntityStore(dbConnection);
var fluentTestDb = new Database
{
Name = TestConstants.TestDatabaseName,
TableNamesInPlural = true,
NameSpace = "FluentSql.Tests.Models"
};
var sqlGenerator = new SqlServerSqlGenerator(includeDbNameInQuery: true);
var databases = new List <Database> {
fluentTestDb
};
store.ExecuteScript(SqlScripts.CREATE_DATABASE, null, false, CommandType.Text);
store.ExecuteScript(SqlScripts.CREATE_TABLES, null, false, CommandType.Text);
new EntityMapper(dbConnection, databases, assembliesOfModelTypes, null, onPostEntityMapping, null);
}
}
}
public virtual EntityStore UpdateEntityStore(EntityStore entity)
{
if (entity.IsTransient())
{
return(entity);
}
EntityStore other = GetEntityStore(entity.StoreId);
if (entity.Equals(other))
{
return(entity);
}
string sql = @"Update EntityStore set [ID]=@ID
, [EntityID]=@EntityID
, [EntityType]=@EntityType
, [CreatedOn]=@CreatedOn
where StoreID=@StoreID" ;
SqlParameter[] parameterArray = new SqlParameter[] {
new SqlParameter("@StoreID", entity.StoreId)
, new SqlParameter("@ID", entity.Id)
, new SqlParameter("@EntityID", entity.EntityId)
, new SqlParameter("@EntityType", entity.EntityType)
, new SqlParameter("@CreatedOn", entity.CreatedOn)
};
SqlHelper.ExecuteNonQuery(this.ConnectionString, CommandType.Text, sql, parameterArray);
return(GetEntityStore(entity.StoreId));
}
public override async Task <bool> Handle()
{
if (_entityData.IsActivity(MainObject.Data))
{
return(true);
}
var data = MainObject.Data;
var createActivity = new ASObject();
createActivity["type"].Add(new ASTerm("Create"));
createActivity["to"].AddRange(data["to"]);
createActivity["bto"].AddRange(data["bto"]);
createActivity["cc"].AddRange(data["cc"]);
createActivity["bcc"].AddRange(data["bcc"]);
createActivity["audience"].AddRange(data["audience"]);
createActivity["actor"].Add(new ASTerm(Actor.Id));
createActivity["object"].Add(new ASTerm(MainObject.Id));
createActivity["id"].Add(new ASTerm(await _entityData.FindUnusedID(EntityStore, createActivity)));
var activityEntity = await EntityStore.StoreEntity(APEntity.From(createActivity, true));
MainObject = activityEntity;
return(true);
}
async Task <IEntityStore <string, TwinStoreEntity> > GetTwinStore(IComponentContext context)
{
string entityName = "EdgeTwin";
Option <IEntityStore <string, TwinStoreEntity> > twinStoreOption = Option.None <IEntityStore <string, TwinStoreEntity> >();
var storeProvider = await context.Resolve <Task <IStoreProvider> >();
if (this.encryptTwinStore)
{
Option <IEncryptionProvider> encryptionProvider = await context.Resolve <Task <Option <IEncryptionProvider> > >();
twinStoreOption = encryptionProvider.Map(
e =>
{
IEntityStore <string, string> underlyingEntityStore = storeProvider.GetEntityStore <string, string>($"underlying{entityName}");
IKeyValueStore <string, string> es = new UpdatableEncryptedStore <string, string>(underlyingEntityStore, e);
ITypeMapper <string, string> keyMapper = new JsonMapper <string>();
ITypeMapper <TwinStoreEntity, string> valueMapper = new JsonMapper <TwinStoreEntity>();
IKeyValueStore <string, TwinStoreEntity> dbStoreMapper = new KeyValueStoreMapper <string, string, TwinStoreEntity, string>(es, keyMapper, valueMapper);
IEntityStore <string, TwinStoreEntity> tes = new EntityStore <string, TwinStoreEntity>(dbStoreMapper, entityName);
return(tes);
});
}
IEntityStore <string, TwinStoreEntity> twinStore = twinStoreOption.GetOrElse(
() => storeProvider.GetEntityStore <string, TwinStoreEntity>(entityName));
return(twinStore);
}
public virtual EntityStore InsertEntityStore(EntityStore entity)
{
EntityStore other = new EntityStore();
other = entity;
if (entity.IsTransient())
{
string sql = @"Insert into EntityStore ( [StoreID]
,[ID]
,[EntityID]
,[EntityType]
,[CreatedOn] )
Values
( @StoreID
, @ID
, @EntityID
, @EntityType
, @CreatedOn );
Select scope_identity()" ;
SqlParameter[] parameterArray = new SqlParameter[] {
new SqlParameter("@StoreID", entity.StoreId)
, new SqlParameter("@ID", entity.Id)
, new SqlParameter("@EntityID", entity.EntityId)
, new SqlParameter("@EntityType", entity.EntityType)
, new SqlParameter("@CreatedOn", entity.CreatedOn)
};
var identity = SqlHelper.ExecuteScalar(this.ConnectionString, CommandType.Text, sql, parameterArray);
if (identity == DBNull.Value)
{
throw new DataException("Identity column was null as a result of the insert operation.");
}
return(GetEntityStore(Convert.ToInt32(identity)));
}
return(entity);
}
public void TestInitialize()
{
this.serializerMock = new Mock <ISerializer>();
this.savedDataHandlerMock = new Mock <ISavedDataHandler>();
this.entityUpdateSubCenterMock = new Mock <IEntityUpdateSubscriptionCenter <IIdEntity <string>, string> >();
this.storeUnderTest = new EntityStore <IIdEntity <string>, string>(this.serializerMock.Object, this.savedDataHandlerMock.Object, this.entityUpdateSubCenterMock.Object);
}
public override async Task <bool> Handle()
{
if (MainObject.Type != "https://www.w3.org/ns/activitystreams#Block")
{
return(true);
}
var activityData = MainObject.Data;
var toBlock = activityData["object"].First().Id;
var entity = await EntityStore.GetEntity(toBlock, true);
if (entity == null)
{
throw new InvalidOperationException("Cannot block a non-existant object");
}
var blockscollection = await EntityStore.GetEntity(Actor.Data["blocks"].First().Id, false);
await _collection.AddToCollection(blockscollection, MainObject);
var blockedcollection = await EntityStore.GetEntity(blockscollection.Data["blocked"].First().Id, false);
await _collection.AddToCollection(blockedcollection, entity);
return(true);
}
public async Task GetServiceIdentityFromServiceTest()
{
// Arrange
var store = new EntityStore <string, string>(new InMemoryDbStore(), "cache");
var serviceAuthenticationNone = new ServiceAuthentication(ServiceAuthenticationType.None);
var serviceAuthenticationSas = new ServiceAuthentication(new SymmetricKeyAuthentication(GetKey(), GetKey()));
var si_device = new ServiceIdentity("d2", "1234", Enumerable.Empty <string>(), serviceAuthenticationNone, ServiceIdentityStatus.Enabled);
var si_module = new ServiceIdentity("d1", "m1", "1234", Enumerable.Empty <string>(), serviceAuthenticationSas, ServiceIdentityStatus.Disabled);
var serviceProxy = new Mock <IServiceProxy>();
serviceProxy.Setup(s => s.GetServiceIdentity("d2")).ReturnsAsync(Option.Some(si_device));
serviceProxy.Setup(s => s.GetServiceIdentity("d1", "m1")).ReturnsAsync(Option.Some(si_module));
DeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await DeviceScopeIdentitiesCache.Create(serviceProxy.Object, store, TimeSpan.FromHours(1));
// Act
Option <ServiceIdentity> deviceServiceIdentity = await deviceScopeIdentitiesCache.GetServiceIdentityFromService("d2");
Option <ServiceIdentity> moduleServiceIdentity = await deviceScopeIdentitiesCache.GetServiceIdentityFromService("d1/m1");
// Assert
Assert.True(deviceServiceIdentity.HasValue);
Assert.True(si_device.Equals(deviceServiceIdentity.OrDefault()));
Assert.True(moduleServiceIdentity.HasValue);
Assert.True(si_module.Equals(moduleServiceIdentity.OrDefault()));
}
public override async Task <bool> Handle()
{
if (MainObject.Type != "https://www.w3.org/ns/activitystreams#Accept" &&
MainObject.Type != "https://www.w3.org/ns/activitystreams#Reject")
{
return(true);
}
var subObject = await EntityStore.GetEntity(MainObject.Data["object"].Single().Id, true);
var requestedUser = await EntityStore.GetEntity(subObject.Data["actor"].First().Id, true);
if (subObject.Type != "https://www.w3.org/ns/activitystreams#Follow")
{
return(true);
}
if (subObject.Data["object"].Single().Id != Actor.Id)
{
return(true);
}
bool isAccept = MainObject.Type == "https://www.w3.org/ns/activitystreams#Accept";
var followers = await EntityStore.GetEntity(Actor.Data["followers"].Single().Id, false);
if (isAccept && !await _collection.Contains(followers, requestedUser.Id))
{
await _collection.AddToCollection(followers, requestedUser);
}
if (!isAccept && await _collection.Contains(followers, requestedUser.Id))
{
await _collection.RemoveFromCollection(followers, requestedUser);
}
return(true);
}
public void Post(ModelDetailsViewModel model)
{
if (model.Id == 0)
{
AddNewModel(model);
}
else
{
UpdateExistingModel(model);
}
try {
EntityStore.SaveChanges();
}
catch (DbEntityValidationException ex) {
StringBuilder sb = new StringBuilder();
foreach (DbEntityValidationResult validationErrors in ex.EntityValidationErrors)
{
foreach (DbValidationError validationError in validationErrors.ValidationErrors)
{
sb.Append(string.Format("{0} - {1}", validationError.PropertyName, validationError.ErrorMessage));
}
}
throw new Exception(sb.ToString());
}
}
public override async Task <bool> Handle()
{
if (_entityData.IsActivity(MainObject.Data))
{
return(true);
}
var data = MainObject.Data;
var createActivity = new ASObject();
createActivity.Type.Add("https://www.w3.org/ns/activitystreams#Create");
createActivity["to"].AddRange(data["to"]);
createActivity["bto"].AddRange(data["bto"]);
createActivity["cc"].AddRange(data["cc"]);
createActivity["bcc"].AddRange(data["bcc"]);
createActivity["audience"].AddRange(data["audience"]);
createActivity["actor"].Add(ASTerm.MakeId(Actor.Id));
createActivity["object"].Add(ASTerm.MakeId(MainObject.Id));
createActivity.Id = await _entityData.FindUnusedID(EntityStore, createActivity);
var activityEntity = await EntityStore.StoreEntity(APEntity.From(createActivity, true));
MainObject = activityEntity;
return(true);
}
public async Task InitializeFromStoreTest()
{
// Arrange
var iterator = new Mock <IServiceIdentitiesIterator>();
iterator.Setup(i => i.HasNext).Returns(true);
iterator.Setup(i => i.GetNext()).ThrowsAsync(new InvalidOperationException("Some error"));
var serviceProxy = new Mock <IServiceProxy>();
serviceProxy.Setup(s => s.GetServiceIdentitiesIterator()).Returns(iterator.Object);
var store = new EntityStore <string, string>(new InMemoryDbStore(), "cache");
var serviceAuthentication = new ServiceAuthentication(ServiceAuthenticationType.None);
var si1 = new ServiceIdentity("d1", "1234", Enumerable.Empty <string>(), serviceAuthentication, ServiceIdentityStatus.Enabled);
var si2 = new ServiceIdentity("d2", "m1", "2345", Enumerable.Empty <string>(), serviceAuthentication, ServiceIdentityStatus.Enabled);
var storedSi1 = new DeviceScopeIdentitiesCache.StoredServiceIdentity(si1);
await store.Put(si1.Id, storedSi1.ToJson());
var storedSi2 = new DeviceScopeIdentitiesCache.StoredServiceIdentity(si2);
await store.Put(si2.Id, storedSi2.ToJson());
// Act
IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await DeviceScopeIdentitiesCache.Create(serviceProxy.Object, store, TimeSpan.FromHours(1));
Option <ServiceIdentity> receivedServiceIdentity1 = await deviceScopeIdentitiesCache.GetServiceIdentity("d1");
Option <ServiceIdentity> receivedServiceIdentity2 = await deviceScopeIdentitiesCache.GetServiceIdentity("d2/m1");
// Assert
Assert.True(si1.Equals(receivedServiceIdentity1.OrDefault()));
Assert.True(si2.Equals(receivedServiceIdentity2.OrDefault()));
}
void Start()
{
if (!Application.isPlaying)
{
return;
}
List <Point3D> blocksToInit;
IChunkGenerator generator;
string entityID;
Setup(out blocksToInit, out generator, out entityID);
entityStore = new EntityStore(generator, entityID);
chunkStore = new ChunkStore(entityStore, Material, transform);
blocksToInit.AddRange(entityStore.GetSavedChunks());
blocksToInit = blocksToInit.Distinct().ToList();
pendingChunks = blocksToInit.Select(chunkPos => new PendingChunk()
{
ChunkPos = chunkPos,
WorldPos = transform.TransformPoint(TransformVertex(new Vector3(chunkPos.x, chunkPos.y, chunkPos.z) * Chunk.BlockSize))
}).ToList();
OnSetupCompleted();
}
public override async Task <bool> Handle()
{
if (MainObject.Type != "Block")
{
return(true);
}
var activityData = MainObject.Data;
var toBlock = (string)activityData["object"].First().Primitive;
var entity = await EntityStore.GetEntity(toBlock, true);
if (entity == null)
{
throw new InvalidOperationException("Cannot block a non-existant object");
}
var blockscollection = await EntityStore.GetEntity((string)Actor.Data["blocks"].First().Primitive, false);
await _collection.AddToCollection(blockscollection, MainObject);
var blockedcollection = await EntityStore.GetEntity((string)blockscollection.Data["_blocked"].First().Primitive, false);
await _collection.AddToCollection(blockedcollection, entity);
return(true);
}
public static CheckpointStore Create(IDbStoreProvider dbStoreProvider)
{
IDbStore dbStore = Preconditions.CheckNotNull(dbStoreProvider, nameof(dbStoreProvider)).GetDbStore(Constants.CheckpointStorePartitionKey);
IEntityStore <string, CheckpointEntity> underlyingStore = new EntityStore <string, CheckpointEntity>(dbStore, nameof(CheckpointEntity), 12);
return(new CheckpointStore(underlyingStore));
}
public void Post(MakeViewModel viewModel)
{
if (viewModel.Id == 0)
{
Make make = new Make {
Name = viewModel.Name, Location = viewModel.Location, ImageUrl = viewModel.ImageUrl
};
EntityStore.Makes.Add(make);
}
else
{
Make make = EntityStore.Makes.Find(viewModel.Id);
make.Name = viewModel.Name;
make.Location = viewModel.Location;
make.ImageUrl = viewModel.ImageUrl;
}
try {
EntityStore.SaveChanges();
}
catch (DbEntityValidationException ex) {
StringBuilder sb = new StringBuilder();
foreach (DbEntityValidationResult validationErrors in ex.EntityValidationErrors)
{
foreach (DbValidationError validationError in validationErrors.ValidationErrors)
{
sb.Append(string.Format("{0} - {1}", validationError.PropertyName, validationError.ErrorMessage));
}
}
throw new Exception(sb.ToString());
}
}
public EntityStoreTests()
{
_simpleType = EntityTypes.Register<TestClass>();
_aliasedType = EntityTypes.Register<AliasedColumnsClass>(et => {
et.Alias(t => t.Name, "ADifferentName")
.Alias(t => t.Description, null);
});
_simpleEntityStore = new EntityStore<TestClass, int>();
_aliasedEntityStore = new EntityStore<AliasedColumnsClass, int>();
}
public void Setup()
{
Mappings = SetupMappings();
_entityStore = new EntityStore();
_factory = new EntityContextFactory().WithEntitySource(CreateEntitySource)
.WithOntology(new DefaultOntologiesProvider())
.WithOntology(new LifeOntology())
.WithOntology(new TestOntologyProvider(IncludeFoaf))
.WithOntology(new ChemOntology())
.WithMappings(BuildMappings)
.WithMetaGraphUri(MetaGraphUri)
.WithEntityStore(() => _entityStore);
ChildSetup();
}
static void Main(string[] args)
{
if (args.Length != 3)
{
Console.WriteLine("You need to provide 3 arguments: the login, the emailaddress and the password");
return;
}
var user = new User(args[0], args[1]);
user.SetPassword(args[2]);
var entityStore = new EntityStore(new MongoContext());
entityStore.Save(user);
}
public SqliteDbAccessTests()
{
var file = GetDbFile();
if (File.Exists(file))
File.Delete(file);
CreateDatabase();
var conn = GetDbConnection();
EntityTypes.Register<Manufacturer>();
EntityTypes.Register<Product>();
_manufacturerStore = new EntityStore<Manufacturer, int>(conn, new SqliteGenerator());
_productStore = new EntityStore<Product, int>(conn, new SqliteGenerator());
}
public void Setup()
{
_entityStore = new EntityStore();
}
protected CommandTestFixture()
{
MongoContext = new MongoTestContext();
EntityStore = new EntityStore(MongoContext);
}
public void ThrowsOnUnregisteredType()
{
var ex = Assert.Throws<Exception>(() => {
var s = new EntityStore<UnregisteredClass, int>();
});
Assert.Equal("You must register your type with EntityTypes before instantiating an EntityStore.", ex.Message);
}
