Esempio n. 1
0
        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 (models.ContainsKey(id))
                {
                    return(new OpResponse(
                               requestOp,
                               Cascade.NowMs,
                               connected: true,
                               exists: true,
                               result: models[id].Item1,
                               arrivedAtMs: models[id].Item2
                               ));
                }
                else
                {
                    return(new OpResponse(
                               requestOp,
                               Cascade.NowMs,
                               connected: true,
                               exists: false,
                               result: null,
                               arrivedAtMs: null
                               ));
                }
                break;

            case RequestVerb.Query:
                if (collections.ContainsKey(requestOp.Key !))
                {
                    return(new OpResponse(
                               requestOp,
                               Cascade.NowMs,
                               connected: true,
                               exists: true,
                               result: collections[requestOp.Key !].Item1,
Esempio n. 2
0
        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}");
            }
        }