public async Task Store(object id, object model, long arrivedAt)
{
await _database.Connection.InsertOrReplaceAsync(model);
await _database.Connection.InsertOrReplaceAsync(new CascadeModelMeta()
{
model_id = CascadeModelMeta.GenerateId <Model>(id),
arrived_at = arrivedAt
});
}
public async Task <OpResponse> Fetch(RequestOp requestOp)
{
if (requestOp.Type != typeof(Model))
{
throw new Exception("requestOp.Type != typeof(Model)");
}
switch (requestOp.Verb)
{
case RequestVerb.Get:
var id = (IdType?)CascadeTypeUtils.ConvertTo(typeof(IdType), requestOp.Id); // ((IdType)requestOp.Id)!;
if (id == null)
{
throw new Exception("Unable to get right value for Id");
}
if (await _database.Exists <Model>(id))
{
var meta = await _database.Get <CascadeModelMeta>(CascadeModelMeta.GenerateId <Model>(id));
return(new OpResponse(
requestOp,
Cascade !.NowMs,
connected: true,
exists: true,
result: await _database.Get <Model>(id),
arrivedAtMs: meta?.arrived_at
));
}
else
{
return(new OpResponse(
requestOp,
Cascade !.NowMs,
connected: true,
exists: false,
result: null,
arrivedAtMs: null
));
}
break;
case RequestVerb.Query:
var collection = await _database.Get <CascadeCollection>(CascadeCollection.GenerateId <Model>(requestOp.Key !));
if (collection != null)
{
return(new OpResponse(
requestOp,
Cascade !.NowMs,
connected: true,
exists: true,
result: collection.objectIds,
arrivedAtMs: collection.arrived_at
));
}
else
{
return(new OpResponse(
requestOp,
Cascade !.NowMs,
connected: true,
exists: false,
result: null,
arrivedAtMs: null
));
}
break;
default:
throw new NotImplementedException($"Unsupported {requestOp.Verb}");
}
}
public async Task Remove(object id)
{
await _database.Delete <Model>(id);
await _database.Delete <CascadeModelMeta>(CascadeModelMeta.GenerateId <Model>(id));
}
public async Task TestMetadata()
{
var path = System.IO.Path.GetTempFileName();
var conn = new SQLite.SQLiteAsyncConnection(path);
var db = new TestDatabase(conn);
await db.Reset();
var sqliteThingCache = new SqliteClassCache <Parent, long>(db);
await sqliteThingCache.Setup();
var sqliteGadgetCache = new SqliteClassCache <Child, string>(db);
await sqliteGadgetCache.Setup();
var cache1 = new ModelCache(aClassCache: new Dictionary <Type, IModelClassCache>()
{
{ typeof(Parent), sqliteThingCache },
{ typeof(Child), sqliteGadgetCache }
});
// read from origin
var cascade = new CascadeDataLayer(origin, new ICascadeCache[] { cache1 }, new CascadeConfig()
{
DefaultFreshnessSeconds = 1
});
var thing5 = new Parent()
{
id = 5,
colour = "red"
};
var thing5ArrivedAt = cascade.NowMs;
await sqliteThingCache.Store(thing5.id, thing5, thing5ArrivedAt);
origin.IncNowMs();
var gadget6 = new Child()
{
id = "abc",
weight = 2.5,
power = 9.2
};
var gadget6ArrivedAt = cascade.NowMs;
await sqliteGadgetCache.Store(gadget6.id, gadget6, gadget6ArrivedAt);
origin.IncNowMs();
var opResponse = await sqliteThingCache.Fetch(RequestOp.GetOp <Parent>(thing5.id, cascade.NowMs));
var loaded5 = (opResponse.Result as Parent) !;
Assert.AreEqual(thing5ArrivedAt, opResponse.ArrivedAtMs);
Assert.AreEqual(thing5.colour, loaded5.colour);
opResponse = await sqliteGadgetCache.Fetch(RequestOp.GetOp <Child>(gadget6.id, cascade.NowMs));
var loaded6 = (opResponse.Result as Child) !;
Assert.AreEqual(gadget6ArrivedAt, opResponse.ArrivedAtMs);
Assert.AreEqual(gadget6.weight, loaded6.weight);
await sqliteGadgetCache.Clear();
// thing unaffected
opResponse = await sqliteThingCache.Fetch(RequestOp.GetOp <Parent>(thing5.id, cascade.NowMs));
Assert.NotNull(opResponse.Result);
Assert.AreEqual(thing5ArrivedAt, opResponse.ArrivedAtMs);
// gadget cleared including metadata
opResponse = await sqliteGadgetCache.Fetch(RequestOp.GetOp <Child>(gadget6.id, cascade.NowMs));
Assert.IsNull(opResponse.Result);
Assert.IsNull(opResponse.ArrivedAtMs);
var meta6 = await db.Get <CascadeModelMeta>(CascadeModelMeta.GenerateId <Child>(6));
Assert.IsNull(meta6);
}
