Exemplo n.º 1
0
        public async Task <string> Add(FilterAggregate filter)
        {
            if (filter == null)
            {
                throw new ArgumentNullException(nameof(filter));
            }

            var record = filter.ToModel();

            record.Id             = Guid.NewGuid().ToString();
            record.CreateDateTime = DateTime.UtcNow;
            record.UpdateDateTime = DateTime.UtcNow;
            if (record.Rules != null)
            {
                foreach (var rule in record.Rules)
                {
                    rule.Id = Guid.NewGuid().ToString();
                }
            }

            _context.Filters.Add(record);
            await _context.SaveChangesAsync().ConfigureAwait(false);

            return(record.Id);
        }
Exemplo n.º 2
0
        public async Task <bool> Update(FilterAggregate filter)
        {
            if (filter == null)
            {
                throw new ArgumentNullException(nameof(filter));
            }

            var record = await _context.Filters.Include(f => f.Rules).FirstOrDefaultAsync(f => f.Id == filter.Id).ConfigureAwait(false);

            if (record == null)
            {
                return(false);
            }

            record.Name           = filter.Name;
            record.UpdateDateTime = DateTime.UtcNow;
            record.Rules.Clear();
            if (filter.Rules != null)
            {
                foreach (var rule in filter.Rules)
                {
                    var newRule = rule.ToModel();
                    newRule.Id = Guid.NewGuid().ToString();
                    record.Rules.Add(newRule);
                }
            }

            await _context.SaveChangesAsync().ConfigureAwait(false);

            return(true);
        }
 public void PASS_Create()
 {
     FilterAggregate agg = new FilterAggregate("filter-name", new TermFilter("field", "value"));
     Assert.IsNotNull(agg);
     Assert.AreEqual("filter-name", agg.Name);
     Assert.AreEqual("field", (agg.Filter as TermFilter).Field);
     Assert.AreEqual("value", (agg.Filter as TermFilter).Value);
 }
        public void PASS_Serialize()
        {
            FilterAggregate agg = new FilterAggregate("filter-name", new TermFilter("field", "value"));
            string json = JsonConvert.SerializeObject(agg);
            Assert.IsNotNull(json);

            string expectedJson = "{\"filter-name\":{\"filter\":{\"term\":{\"field\":\"value\"}}}}";
            Assert.AreEqual(expectedJson, json);
        }
 public static FilterAggregate Copy(this FilterAggregate filter)
 {
     return(new FilterAggregate
     {
         CreateDateTime = filter.CreateDateTime,
         Id = filter.Id,
         Name = filter.Name,
         UpdateDateTime = filter.UpdateDateTime,
         Rules = filter.Rules == null ? new List <FilterAggregateRule>() : filter.Rules.Select(r => r.Copy())
     });
 }
        public Task <string> Add(FilterAggregate filter)
        {
            if (filter == null)
            {
                throw new ArgumentNullException(nameof(filter));
            }

            filter.Id             = Guid.NewGuid().ToString();
            filter.CreateDateTime = filter.CreateDateTime;
            _filters.Add(filter.Copy());
            return(Task.FromResult(filter.Id));
        }
Exemplo n.º 7
0
        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
        {
            Dictionary<string, object> wholeDict = serializer.Deserialize<Dictionary<string, object>>(reader);
            Dictionary<string, object> aggDict = JsonConvert.DeserializeObject<Dictionary<string, object>>(wholeDict.First().Value.ToString());

            FilterAggregate agg = new FilterAggregate(
                wholeDict.First().Key, 
                JsonConvert.DeserializeObject<IFilter>(aggDict.GetString(AggregationTypeEnum.Filter.ToString())));

            agg.SubAggregations = BucketAggregationBase.DeserializeSubAggregations(aggDict);
            return agg;
        }
Exemplo n.º 8
0
        public static Filter ToModel(this FilterAggregate filter)
        {
            if (filter == null)
            {
                throw new ArgumentNullException(nameof(filter));
            }

            return(new Filter
            {
                Name = filter.Name,
                Rules = filter.Rules == null ? new List <FilterRule>() : filter.Rules.Select(r => r.ToModel()).ToList()
            });
        }
        public void PASS_Serialize_Subs()
        {
            FilterAggregate agg = new FilterAggregate("filter-name", new TermFilter("field", "value"))
            {
                SubAggregations = new List<IAggregation>() 
                { 
                    new SumAggregate("sum-name", "field")
                }
            };
            string json = JsonConvert.SerializeObject(agg);
            Assert.IsNotNull(json);

            string expectedJson = "{\"filter-name\":{\"filter\":{\"term\":{\"field\":\"value\"}},\"aggregations\":{\"sum-name\":{\"sum\":{\"field\":\"field\"}}}}}";
            Assert.AreEqual(expectedJson, json);
        }
Exemplo n.º 10
0
        public static FilterResponse ToDto(this FilterAggregate filter)
        {
            if (filter == null)
            {
                throw new ArgumentNullException(nameof(filter));
            }

            return(new FilterResponse
            {
                Id = filter.Id,
                CreateDateTime = filter.CreateDateTime,
                UpdateDateTime = filter.UpdateDateTime,
                Name = filter.Name,
                Rules = filter.Rules == null ? new List <FilterRuleResponse>() : filter.Rules.Select(r => r.ToDto())
            });
        }
        public Task <bool> Update(FilterAggregate filter)
        {
            if (filter == null)
            {
                throw new ArgumentNullException(nameof(filter));
            }

            var record = _filters.FirstOrDefault(f => f.Id == filter.Id);

            if (filter == null)
            {
                return(Task.FromResult(false));
            }

            record.Name           = filter.Name;
            record.Rules          = filter.Rules;
            record.CreateDateTime = filter.CreateDateTime;
            record.UpdateDateTime = DateTime.UtcNow;
            return(Task.FromResult(true));
        }