public void Delete(AttributeSearch request)
        {
            var matches = Get(request) as List <Attribute>;

            if (true != matches?.Any())
            {
                throw new HttpError(HttpStatusCode.NotFound, "No matches for request");
            }
            matches.ForEach(match =>
            {
                Delete(match);
            });
        }
        public void FixtureSetUp()
        {
            const string assemblyName = "CryoAOP.TestAssembly.dll";
            var assemblyImage = System.Reflection.Assembly.LoadFrom(assemblyName);

            var assemblyLoader = MockRepository.GenerateStub<IAssemblyLoader>();

            assemblyLoader
                .Expect(al => al.GetShadowAssemblies())
                .Return(new[] {new ShadowAssemblyType(assemblyImage, assemblyName)});

            attributeSearch = new AttributeSearch(assemblyLoader);

            interceptAttributes = attributeSearch.FindAttributes<InterceptAttribute>();
        }
Exemple #3
0
        public void FixtureSetUp()
        {
            const string assemblyName  = "CryoAOP.TestAssembly.dll";
            var          assemblyImage = System.Reflection.Assembly.LoadFrom(assemblyName);

            var assemblyLoader = MockRepository.GenerateStub <IAssemblyLoader>();

            assemblyLoader
            .Expect(al => al.GetShadowAssemblies())
            .Return(new[] { new ShadowAssemblyType(assemblyImage, assemblyName) });

            attributeSearch = new AttributeSearch(assemblyLoader);

            interceptAttributes = attributeSearch.FindAttributes <InterceptAttribute>();
        }
Exemple #4
0
        public static void InterceptAspects()
        {
            var attributeFinder = new AttributeSearch(new AssemblyLoader());
            var results         = attributeFinder.FindAttributes <InterceptAttribute>();

            var groupedByAssembly = results.GroupBy(r => r.Type.Assembly);

            foreach (var group in groupedByAssembly)
            {
                var shadowAssembly = group.First().ShadowAssembly;
                LoadAssembly(shadowAssembly.OriginalAssemblyPath);
                foreach (var result in group)
                {
                    if (result.IsForType())
                    {
                        InterceptType(result.TypeName, result.Attribute.Scope);
                        Console.WriteLine(
                            "CryoAOP -> Intercepted {0}\\{1}\\*"
                            .FormatWith(
                                Path.GetFileName(
                                    shadowAssembly.OriginalAssemblyPath),
                                result.TypeName));
                    }
                    if (result.IsForMethod())
                    {
                        InterceptMethod(result.TypeName, result.MethodName, result.Attribute.Scope);
                        Console.WriteLine(
                            "CryoAOP -> Intercepted {0}\\{1}\\{2}"
                            .FormatWith(
                                Path.GetFileName(shadowAssembly.OriginalAssemblyPath),
                                result.TypeName,
                                result.MethodName));
                    }
                    if (result.IsForProperty())
                    {
                        InterceptProperty(result.TypeName, result.PropertyName, result.Attribute.Scope);
                        Console.WriteLine(
                            "CryoAOP -> Intercepted {0}\\{1}\\{2}"
                            .FormatWith(
                                Path.GetFileName(shadowAssembly.OriginalAssemblyPath),
                                result.TypeName,
                                result.PropertyName));
                    }
                }
                SaveAssembly(shadowAssembly.OriginalAssemblyPath);
            }
        }
        public static void InterceptAspects()
        {
            var attributeFinder = new AttributeSearch(new AssemblyLoader());
            var results = attributeFinder.FindAttributes<InterceptAttribute>();

            var groupedByAssembly = results.GroupBy(r => r.Type.Assembly);
            foreach (var group in groupedByAssembly)
            {
                var shadowAssembly = group.First().ShadowAssembly;
                LoadAssembly(shadowAssembly.OriginalAssemblyPath);
                foreach (var result in group)
                {
                    if (result.IsForType())
                    {
                        InterceptType(result.TypeName, result.Attribute.Scope);
                        Console.WriteLine(
                            "CryoAOP -> Intercepted {0}\\{1}\\*"
                                .FormatWith(
                                    Path.GetFileName(
                                        shadowAssembly.OriginalAssemblyPath),
                                    result.TypeName));
                    }
                    if (result.IsForMethod())
                    {
                        InterceptMethod(result.TypeName, result.MethodName, result.Attribute.Scope);
                        Console.WriteLine(
                            "CryoAOP -> Intercepted {0}\\{1}\\{2}"
                                .FormatWith(
                                    Path.GetFileName(shadowAssembly.OriginalAssemblyPath),
                                    result.TypeName,
                                    result.MethodName));
                    }
                    if (result.IsForProperty())
                    {
                        InterceptProperty(result.TypeName, result.PropertyName, result.Attribute.Scope);
                        Console.WriteLine(
                            "CryoAOP -> Intercepted {0}\\{1}\\{2}"
                                .FormatWith(
                                    Path.GetFileName(shadowAssembly.OriginalAssemblyPath),
                                    result.TypeName,
                                    result.PropertyName));
                    }
                }
                SaveAssembly(shadowAssembly.OriginalAssemblyPath);
            }
        }
        private IQueryable <DocEntityAttribute> _ExecSearch(AttributeSearch request, DocQuery query)
        {
            request = InitSearch <Attribute, AttributeSearch>(request);
            IQueryable <DocEntityAttribute> entities = null;

            query.Run(session =>
            {
                entities = query.SelectAll <DocEntityAttribute>();
                if (!DocTools.IsNullOrEmpty(request.FullTextSearch))
                {
                    var fts  = new AttributeFullTextSearch(request);
                    entities = GetFullTextSearch <DocEntityAttribute, AttributeFullTextSearch>(fts, entities);
                }

                if (null != request.Ids && request.Ids.Any())
                {
                    entities = entities.Where(en => en.Id.In(request.Ids));
                }

                if (!DocTools.IsNullOrEmpty(request.Updated))
                {
                    entities = entities.Where(e => null != e.Updated && e.Updated.Value.Date == request.Updated.Value.Date);
                }
                if (!DocTools.IsNullOrEmpty(request.UpdatedBefore))
                {
                    entities = entities.Where(e => null != e.Updated && e.Updated <= request.UpdatedBefore);
                }
                if (!DocTools.IsNullOrEmpty(request.UpdatedAfter))
                {
                    entities = entities.Where(e => null != e.Updated && e.Updated >= request.UpdatedAfter);
                }
                if (!DocTools.IsNullOrEmpty(request.Created))
                {
                    entities = entities.Where(e => null != e.Created && e.Created.Value.Date == request.Created.Value.Date);
                }
                if (!DocTools.IsNullOrEmpty(request.CreatedBefore))
                {
                    entities = entities.Where(e => null != e.Created && e.Created <= request.CreatedBefore);
                }
                if (!DocTools.IsNullOrEmpty(request.CreatedAfter))
                {
                    entities = entities.Where(e => null != e.Created && e.Created >= request.CreatedAfter);
                }
                if (true == request.Archived?.Any() && currentUser.HasProperty(DocConstantModelName.ATTRIBUTE, nameof(Reference.Archived), DocConstantPermission.VIEW))
                {
                    entities = entities.Where(en => en.Archived.In(request.Archived));
                }
                else
                {
                    entities = entities.Where(en => !en.Archived);
                }
                if (true == request.Locked?.Any())
                {
                    entities = entities.Where(en => en.Locked.In(request.Locked));
                }
                if (!DocTools.IsNullOrEmpty(request.AttributeName) && !DocTools.IsNullOrEmpty(request.AttributeName.Id))
                {
                    entities = entities.Where(en => en.AttributeName.Id == request.AttributeName.Id);
                }
                if (true == request.AttributeNameIds?.Any())
                {
                    entities = entities.Where(en => en.AttributeName.Id.In(request.AttributeNameIds));
                }
                else if (!DocTools.IsNullOrEmpty(request.AttributeName) && !DocTools.IsNullOrEmpty(request.AttributeName.Name))
                {
                    entities = entities.Where(en => en.AttributeName.Name == request.AttributeName.Name);
                }
                if (true == request.AttributeNameNames?.Any())
                {
                    entities = entities.Where(en => en.AttributeName.Name.In(request.AttributeNameNames));
                }
                if (!DocTools.IsNullOrEmpty(request.AttributeType) && !DocTools.IsNullOrEmpty(request.AttributeType.Id))
                {
                    entities = entities.Where(en => en.AttributeType.Id == request.AttributeType.Id);
                }
                if (true == request.AttributeTypeIds?.Any())
                {
                    entities = entities.Where(en => en.AttributeType.Id.In(request.AttributeTypeIds));
                }
                else if (!DocTools.IsNullOrEmpty(request.AttributeType) && !DocTools.IsNullOrEmpty(request.AttributeType.Name))
                {
                    entities = entities.Where(en => en.AttributeType.Name == request.AttributeType.Name);
                }
                if (true == request.AttributeTypeNames?.Any())
                {
                    entities = entities.Where(en => en.AttributeType.Name.In(request.AttributeTypeNames));
                }
                if (!DocTools.IsNullOrEmpty(request.Interval) && !DocTools.IsNullOrEmpty(request.Interval.Id))
                {
                    entities = entities.Where(en => en.Interval.Id == request.Interval.Id);
                }
                if (true == request.IntervalIds?.Any())
                {
                    entities = entities.Where(en => en.Interval.Id.In(request.IntervalIds));
                }
                if (true == request.IsCharacteristic?.Any())
                {
                    entities = entities.Where(en => en.IsCharacteristic.In(request.IsCharacteristic));
                }
                if (true == request.IsOutcome?.Any())
                {
                    entities = entities.Where(en => en.IsOutcome.In(request.IsOutcome));
                }
                if (true == request.IsPositive?.Any())
                {
                    if (request.IsPositive.Any(v => v == null))
                    {
                        entities = entities.Where(en => en.IsPositive.In(request.IsPositive) || en.IsPositive == null);
                    }
                    else
                    {
                        entities = entities.Where(en => en.IsPositive.In(request.IsPositive));
                    }
                }
                if (!DocTools.IsNullOrEmpty(request.UniqueKey))
                {
                    entities = entities.Where(en => en.UniqueKey.Contains(request.UniqueKey));
                }
                if (!DocTools.IsNullOrEmpty(request.UniqueKeys))
                {
                    entities = entities.Where(en => en.UniqueKey.In(request.UniqueKeys));
                }
                if (!DocTools.IsNullOrEmpty(request.ValueType) && !DocTools.IsNullOrEmpty(request.ValueType.Id))
                {
                    entities = entities.Where(en => en.ValueType.Id == request.ValueType.Id);
                }
                if (true == request.ValueTypeIds?.Any())
                {
                    entities = entities.Where(en => en.ValueType.Id.In(request.ValueTypeIds));
                }

                entities = ApplyFilters <DocEntityAttribute, AttributeSearch>(request, entities);

                if (request.Skip > 0)
                {
                    entities = entities.Skip(request.Skip.Value);
                }
                if (request.Take > 0)
                {
                    entities = entities.Take(request.Take.Value);
                }
                if (true == request?.OrderBy?.Any())
                {
                    entities = entities.OrderBy(request.OrderBy);
                }
                if (true == request?.OrderByDesc?.Any())
                {
                    entities = entities.OrderByDescending(request.OrderByDesc);
                }
            });
            return(entities);
        }
 public object Get(AttributeSearch request) => GetSearchResultWithCache <Attribute, DocEntityAttribute, AttributeSearch>(DocConstantModelName.ATTRIBUTE, request, _ExecSearch);
 public object Post(AttributeSearch request) => Get(request);