private async Task UpdateEntityAsync(string id, ValuesEntity data)
        {
            var entities = await this.GetEntitiesAsync();

            await this.retry.RunAsync(async() =>
            {
                using (var tx = this.stateManager.CreateTransaction())
                {
                    var v = await entities.TryGetValueAsync(tx, id);
                    ValuesEntity entity;
                    if (v.HasValue)
                    {
                        entity                = JsonConvert.DeserializeObject <ValuesEntity>(v.Value);
                        entity.Values         = data.Values;
                        entity.LastModifiedOn = entity.LastAccessedOn = DateTime.UtcNow;
                    }
                    else
                    {
                        entity = new ValuesEntity(id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, data.Values);
                    }
                    await entities.SetAsync(tx, id, JsonConvert.SerializeObject(entity));
                    await tx.CommitAsync();
                }
            });
        }
        public async Task <IActionResult> PutAsync(string id, [FromBody] ValuesEntity value)
        {
            if (string.IsNullOrWhiteSpace(id) || value == null)
            {
                return(this.BadRequest());
            }

            await this.UpdateEntityAsync(id, value);

            return(this.Ok());
        }
        public async Task <IActionResult> PostAsync(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                return(this.BadRequest());
            }

            ValuesEntity s = await this.CreateEntityAsync(id);

            return(new JsonResult(s));
        }
        public async Task <IActionResult> GetAsync(string id)
        {
            if (string.IsNullOrWhiteSpace(id))
            {
                return(this.BadRequest());
            }

            ValuesEntity s = await this.GetEntityAsync(id);

            if (s == null)
            {
                return(this.NotFound());
            }

            return(new JsonResult(s));
        }
        private async Task UpdateEntityAsync(string id, ValuesEntity data)
        {
            var entities = await this.GetEntitiesAsync();

            await this.retry.RunAsync(async() =>
            {
                using (var tx = this.stateManager.CreateTransaction())
                {
                    var v = await entities.TryGetValueAsync(tx, id);
                    ValuesEntity entity = v.HasValue ? new ValuesEntity(id, v.Value.CreatedOn, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, data.Values)
                                                     : new ValuesEntity(id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, DateTime.UtcNow, data.Values);
                    await entities.SetAsync(tx, id, entity);
                    await tx.CommitAsync();
                }
            });
        }
Exemple #6
0
        public void PostAndGetTest()
        {
            string       id      = Guid.NewGuid().ToString();
            var          result1 = this.controller.PostAsync(id).Result;
            JsonResult   json1   = (JsonResult)result1;
            ValuesEntity data1   = (ValuesEntity)json1.Value;

            Assert.AreEqual(data1.Id, id);

            var          result2 = this.controller.GetAsync(id).Result;
            JsonResult   json2   = (JsonResult)result2;
            ValuesEntity data2   = (ValuesEntity)json2.Value;

            Assert.AreEqual(data1.Id, data2.Id);
            Assert.AreEqual(data1.CreatedOn, data2.CreatedOn);
        }
        private async Task <ValuesEntity> CreateEntityAsync(string id)
        {
            ValuesEntity entity   = null;
            var          entities = await this.GetEntitiesAsync();

            await this.retry.RunAsync(async() =>
            {
                entity = new ValuesEntity(id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow);
                using (var tx = this.stateManager.CreateTransaction())
                {
                    await entities.AddAsync(tx, id, JsonConvert.SerializeObject(entity));
                    await tx.CommitAsync();
                }
            });

            return(entity);
        }
        private async Task <ValuesEntity> GetEntityAsync(string id)
        {
            ValuesEntity entity   = null;
            var          entities = await this.GetEntitiesAsync();

            await this.retry.RunAsync(async() =>
            {
                using (var tx = this.stateManager.CreateTransaction())
                {
                    var v = await entities.TryGetValueAsync(tx, id);
                    if (v.HasValue)
                    {
                        entity = JsonConvert.DeserializeObject <ValuesEntity>(v.Value);
                        entity.LastAccessedOn = DateTime.UtcNow;
                        await entities.SetAsync(tx, id, JsonConvert.SerializeObject(entity));
                    }
                    await tx.CommitAsync();
                }
            });

            return(entity);
        }
        private async Task <ValuesEntity> GetEntityAsync(string id)
        {
            ValuesEntity entity   = null;
            var          entities = await this.GetEntitiesAsync();

            await this.retry.RunAsync(async() =>
            {
                using (var tx = this.stateManager.CreateTransaction())
                {
                    var v = await entities.TryGetValueAsync(tx, id);
                    if (v.HasValue)
                    {
                        // 50% this, 50% json

                        entity = new ValuesEntity(v.Value.Id, v.Value.CreatedOn, v.Value.LastModifiedOn, DateTimeOffset.UtcNow, v.Value.Values);
                        await entities.SetAsync(tx, id, entity);
                    }
                    await tx.CommitAsync();
                }
            });

            return(entity);
        }
        private async Task<ValuesEntity> GetEntityAsync(string id)
        {
            ValuesEntity entity = null;
            var entities = await this.GetEntitiesAsync();
            await this.retry.RunAsync(async () =>
            {
                using (var tx = this.stateManager.CreateTransaction())
                {
                    var v = await entities.TryGetValueAsync(tx, id);
                    if (v.HasValue)
                    {
                        // 50% this, 50% json

                        entity = new ValuesEntity(v.Value.Id, v.Value.CreatedOn, v.Value.LastModifiedOn, DateTimeOffset.UtcNow, v.Value.Values);
                        await entities.SetAsync(tx, id, entity);
                    }
                    await tx.CommitAsync();
                }
            });
            return entity;
        }
 private async Task UpdateEntityAsync(string id, ValuesEntity data)
 {
     var entities = await this.GetEntitiesAsync();
     await this.retry.RunAsync(async () =>
     {
         using (var tx = this.stateManager.CreateTransaction())
         {
             var v = await entities.TryGetValueAsync(tx, id);
             ValuesEntity entity;
             if (v.HasValue)
             {
                 entity = JsonConvert.DeserializeObject<ValuesEntity>(v.Value);
                 entity.Values = data.Values;
                 entity.LastModifiedOn = entity.LastAccessedOn = DateTime.UtcNow;
             }
             else
             {
                 entity = new ValuesEntity(id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, data.Values);
             }
             await entities.SetAsync(tx, id, JsonConvert.SerializeObject(entity));
             await tx.CommitAsync();
         }
     });
 }
 private async Task<ValuesEntity> CreateEntityAsync(string id)
 {
     ValuesEntity entity = null;
     var entities = await this.GetEntitiesAsync();
     await this.retry.RunAsync(async () =>
     {
         entity = new ValuesEntity(id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow);
         using (var tx = this.stateManager.CreateTransaction())
         {
             await entities.AddAsync(tx, id, JsonConvert.SerializeObject(entity));
             await tx.CommitAsync();
         }
     });
     return entity;
 }
 private async Task UpdateEntityAsync(string id, ValuesEntity data)
 {
     var entities = await this.GetEntitiesAsync();
     await this.retry.RunAsync(async () =>
     {
         using (var tx = this.stateManager.CreateTransaction())
         {
             var v = await entities.TryGetValueAsync(tx, id);
             ValuesEntity entity = v.HasValue ? new ValuesEntity(id, v.Value.CreatedOn, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, data.Values)
                                              : new ValuesEntity(id, DateTimeOffset.UtcNow, DateTimeOffset.UtcNow, DateTime.UtcNow, data.Values);
             await entities.SetAsync(tx, id, entity);
             await tx.CommitAsync();
         }
     });
 }