Exemplo n.º 1
0
        private static FileSystemLambdaData ProcessLambda(string lambdaBody)
        {
            FileSystemLambdaData lambdaData = new FileSystemLambdaData();

            var hasRun              = Regex.IsMatch(lambdaBody, @"\.Run\(\)$");
            var hasSchedule         = Regex.IsMatch(lambdaBody, @"\.Schedule\(\)$");
            var hasScheduleParallel = Regex.IsMatch(lambdaBody, @"\.ScheduleParallel\(\)$");

            lambdaData.LaunchType = hasRun ? LaunchType.Run : (hasSchedule ? LaunchType.Schedule : LaunchType.ScheduleParallel);

            lambdaData.Name                  = Regex.Match(lambdaBody, @"\.\s*WithName\s*\(\s*""(.+)""\s*\)")?.Groups[1].Value ?? "";
            lambdaData.QueryField            = Regex.Match(lambdaBody, @"\.\s*WithStoreEntityQueryInField\s*\(\s*ref\s*(.+?)\s*\)")?.Groups[1].Value ?? "";
            lambdaData.SharedComponentFilter = Regex.Match(lambdaBody, @"\.\s*WithSharedComponentFilter\s*\(\s*(.+?)\s*?\)")?.Groups[1].Value ?? "";
            var withAny = Regex.Match(lambdaBody, @"\.\s*WithAny\s*<\s*(.+?)\s*?>")?.Groups[1].Value.Split(',').Select(s => s.Trim()).Where(s => !string.IsNullOrWhiteSpace(s)).ToArray() ?? new string[0];

            lambdaData.WithAny.AddRange(withAny);
            var withAll = Regex.Match(lambdaBody, @"\.\s*WithAll\s*<\s*(.+?)\s*?>")?.Groups[1].Value.Split(',').Select(s => s.Trim()).Where(s => !string.IsNullOrWhiteSpace(s)).ToArray() ?? new string[0];

            lambdaData.WithAll.AddRange(withAll);
            var withNone = Regex.Match(lambdaBody, @"\.\s*WithNone\s*<\s*(.+?)\s*?>")?.Groups[1].Value.Split(',').Select(s => s.Trim()).Where(s => !string.IsNullOrWhiteSpace(s)).ToArray() ?? new string[0];

            lambdaData.WithNone.AddRange(withNone);

            var inParametersMateches = Regex.Matches(lambdaBody, @"in\s+(.+?)\s+(.+?)[\s,]");

            for (int i = 0; i < inParametersMateches.Count; i++)
            {
                var typeName = inParametersMateches[i].Groups[1].Value;
                if (string.IsNullOrWhiteSpace(typeName.Trim()))
                {
                    continue;
                }
                lambdaData.InParameter.Add(typeName);
            }

            var refParametersMateches = Regex.Matches(lambdaBody, @"ref\s+([^a]+?)\s+([^a]+?)[\s,]");

            for (int i = 0; i < refParametersMateches.Count; i++)
            {
                var typeName = refParametersMateches[i].Groups[1].Value;
                if (string.IsNullOrWhiteSpace(typeName.Trim()))
                {
                    continue;
                }
                lambdaData.RefParamter.Add(typeName);
            }

            return(lambdaData);
        }
Exemplo n.º 2
0
        public static SystemLambdaAction FromFile(FileSystemLambdaData data)
        {
            SystemLambdaAction lambda = new SystemLambdaAction()
            {
                _name                 = data.Name,
                _parallelSchedule     = data.LaunchType == LaunchType.ScheduleParallel,
                _hasStructuralChanges = data.LaunchType == LaunchType.Run,
                _queryField           = data.QueryField,
            };

            if (!string.IsNullOrWhiteSpace(data.SharedComponentFilter))
            {
                lambda._sharedFilter = new SharedComponentFilter()
                {
                    FilterName = data.SharedComponentFilter
                };
            }

            var parametersCount = data.WithAll.Count + data.WithAny.Count + data.WithNone.Count + data.RefParamter.Count + data.InParameter.Count;

            lambda._components = new ComponentLink[parametersCount];

            var allTypes = AppDomain.CurrentDomain.GetAssemblies().Reverse().SelectMany(a => a.GetTypes()).ToArray();

            int index = 0;

            for (int i = 0; i < data.WithAll.Count; i++)
            {
                var type = allTypes.First(t => t.Name.Equals(data.WithAll[i]));
                lambda._components[index++] = new ComponentLink()
                {
                    AccessType = ComponentLinkAccessType.Unused, Usage = ComponentLinkUsageType.All, TypeReference = type
                };
            }
            for (int i = 0; i < data.WithAny.Count; i++)
            {
                var type = allTypes.First(t => t.Name.Equals(data.WithAny[i]));
                lambda._components[index++] = new ComponentLink()
                {
                    AccessType = ComponentLinkAccessType.Unused, Usage = ComponentLinkUsageType.Any, TypeReference = type
                };
            }
            for (int i = 0; i < data.WithNone.Count; i++)
            {
                var type = allTypes.First(t => t.Name.Equals(data.WithNone[i]));
                lambda._components[index++] = new ComponentLink()
                {
                    AccessType = ComponentLinkAccessType.Unused, Usage = ComponentLinkUsageType.None, TypeReference = type
                };
            }
            for (int i = 0; i < data.RefParamter.Count; i++)
            {
                var type = allTypes.First(t => t.Name.Equals(data.RefParamter[i]));
                lambda._components[index++] = new ComponentLink()
                {
                    AccessType = ComponentLinkAccessType.ReadWrite, Usage = ComponentLinkUsageType.All, TypeReference = type
                };
            }
            for (int i = 0; i < data.InParameter.Count; i++)
            {
                var type = allTypes.First(t => t.Name.Equals(data.InParameter[i]));
                lambda._components[index++] = new ComponentLink()
                {
                    AccessType = ComponentLinkAccessType.Read, Usage = ComponentLinkUsageType.All, TypeReference = type
                };
            }

            lambda.Initialize();

            return(lambda);
        }