Example #1
0
        public override string GetNameForMessagePair(SdkMessagePair messagePair, IServiceProvider services)
        {
            string returnValue  = string.Empty;
            string defaultValue = base.GetNameForMessagePair(messagePair, services);

            foreach (var namer in _namers)
            {
                Trace.Debug($"Executing naming rule {nameof(GetNameForMessagePair)} using {namer.GetType().FullName}");

                returnValue = namer.GetNameForMessagePair(messagePair, services);
            }

            if (string.IsNullOrEmpty(returnValue))
            {
                returnValue = defaultValue;
            }

            var cacheItem = DynamicsMetadataCache.SdkMessagePairs.GetOrParse(messagePair);

            if (cacheItem != null)
            {
                cacheItem.GeneratedTypeName = returnValue;
            }

            DynamicsMetadataCache.SdkMessagePairs.Set(cacheItem);

            return(returnValue);
        }
Example #2
0
 public MetadataPair(SdkMessagePair pair)
 {
     Id = pair.Id;
     MessageNamespace = pair.MessageNamespace;
     Request          = pair.Request == null ? null : new MetadataRequest(pair.Request);
     Response         = pair.Response == null ? null : new MetadataResponse(pair.Response);
 }
Example #3
0
        /// <inheritdoc />
        public string GetNameForMessagePair(SdkMessagePair messagePair, IServiceProvider services)
        {
            string value = _defaultService.GetNameForMessagePair(messagePair, services);

            value = ModifyPublisher(value);
            return(value);
        }
        public override bool GenerateSdkMessagePair(SdkMessagePair sdkMessagePair, IServiceProvider services)
        {
            bool whitelist, blacklist = false;

            whitelist = _whitelistFilters.Any(filter => filter.GenerateSdkMessagePair(sdkMessagePair, services));

            if (whitelist)
            {
                Trace.TraceInformation($"Whitelist: {sdkMessagePair.Id} is on the whitelist and will be generated.");
            }
            else
            {
                if (Configuration.Filtering.HasWhitelist && Configuration.Filtering.Whitelist.Filter == WhitelistFilter.Exclusive)
                {
                    return(false);
                }

                blacklist = _blacklistFilters.Any(filter => filter.GenerateSdkMessagePair(sdkMessagePair, services));

                if (!blacklist)
                {
                    Trace.TraceInformation($"Blacklist: {sdkMessagePair.Id} is on the blacklist and will not be generated.");
                }
            }

            return(whitelist || blacklist);
        }
        /// <inheritdoc />
        public override string GetNameForMessagePair(SdkMessagePair messagePair, IServiceProvider services)
        {
            string value = base.GetNameForMessagePair(messagePair, services);

            value = ModifyPublisher(value);

            return(value);
        }
        public SdkMessageRequest ToSdk(SdkMessagePair sdk)
        {
            var request = new SdkMessageRequest(sdk, Id, Name);

            foreach (var field in RequestFields)
            {
                request.RequestFields[field.Key] = field.Value.ToSdk(request);
            }

            return(request);
        }
Example #7
0
        public SdkMessagePair ToSdk(SdkMessage sdk)
        {
            var pair = new SdkMessagePair(sdk, Id, MessageNamespace);

            pair.Request = Request.ToSdk(pair);
            if (Response != null)
            {
                pair.Response = Response.ToSdk(sdk);
            }
            return(pair);
        }
Example #8
0
        protected override bool?GenerateSdkMessagePair(SdkMessagePair sdkMessagePair)
        {
            if (sdkMessagePair.Message.IsCustomAction && FilterConfiguration.Customizations.CustomizationStrategy == CustomizationStrategy.UncustomizedOnly)
            {
                return(false);
            }
            else if (!sdkMessagePair.Message.IsCustomAction && FilterConfiguration.Customizations.CustomizationStrategy == CustomizationStrategy.CustomOnly)
            {
                return(false);
            }

            return(FilterConfiguration.Customizations.CustomizationStrategy == CustomizationStrategy.Default ? (bool?)null : true);
        }
Example #9
0
        async Task <string> INamingService.GetNameForMessagePairAsync(SdkMessagePair messagePair, IServiceProvider services)
        {
            await CrmSvcUtil.CrmSvcUtilLogger.TraceMethodStartAsync("Entering {0}", MethodBase.GetCurrentMethod().Name);

            if (this._knowNames.ContainsKey(messagePair.Id.ToString()))
            {
                await CrmSvcUtil.CrmSvcUtilLogger.TraceMethodStopAsync("Exiting {0}", MethodBase.GetCurrentMethod().Name);

                return(this._knowNames[messagePair.Id.ToString()]);
            }
            var text = this.CreateValidTypeName(messagePair.Request.Name);

            this._knowNames.Add(messagePair.Id.ToString(), text);
            await CrmSvcUtil.CrmSvcUtilLogger.TraceMethodStopAsync("Exiting {0}", MethodBase.GetCurrentMethod().Name);

            return(text);
        }
        public override bool GenerateSdkMessagePair(SdkMessagePair sdkMessagePair, IServiceProvider services)
        {
            if (DynamicsMetadataCache.SdkMessagePairs.HasBy(sdkMessagePair))
            {
                return(true);
            }

            Services = services;
            bool?value = GenerateSdkMessagePair(sdkMessagePair);

            switch (Strategy)
            {
            case FilterListStrategy.Whitelist:
                var whitelistConfig = FilterConfiguration as WhitelistElement;

                if (value.HasValue)
                {
                    if (value.Value)
                    {
                        DynamicsMetadataCache.SdkMessagePairs.AddBy(sdkMessagePair);
                    }

                    return(value.Value);
                }
                else
                {
                    if (whitelistConfig.Filter == WhitelistFilter.Inclusive)
                    {
                        DynamicsMetadataCache.SdkMessagePairs.AddBy(sdkMessagePair);
                    }
                }

                return(whitelistConfig.Filter == WhitelistFilter.Inclusive);

            case FilterListStrategy.Blacklist:
                return(!value.HasValue ? true : !value.Value);
            }

            // never gets here.
            return(value.Value);
        }
 protected override bool?GenerateSdkMessagePair(SdkMessagePair sdkMessagePair)
 {
     return(null);
 }
Example #12
0
 /// <inheritdoc />
 public string GetNameForMessagePair(SdkMessagePair messagePair, IServiceProvider services)
 {
     return(NamingServiceImplementation.GetNameForMessagePair(messagePair, services));
 }
 protected abstract bool?GenerateSdkMessagePair(SdkMessagePair sdkMessagePair);
 public SdkMessagePairCacheItem(SdkMessagePair metadata) : this()
 {
     ParseMetadata(metadata);
 }
Example #15
0
        public void GetNameForEntityTest()
        {
            NamingService namingService = new NamingService(_namingServiceMock, _configuration);

            _configuration.Naming.Publisher.Add(new PublisherElement("beedev_"));
            EntityMetadata acountMetadata       = JsonConvert.DeserializeObject <EntityMetadata>("{\"SchemaName\":\"Account\", \"CollectionSchemaName\":\"AccountSet\"}");
            EntityMetadata sampleEntityMetadata = JsonConvert.DeserializeObject <EntityMetadata>("{\"SchemaName\":\"beedev_SampleEntity\", \"CollectionSchemaName\":\"beedev_SampleEntitySet\"}");

            Assert.AreEqual("Account", namingService.GetNameForEntity(acountMetadata, _serviceProvider));
            Assert.AreEqual("SampleEntity", namingService.GetNameForEntity(sampleEntityMetadata, _serviceProvider));

            Assert.AreEqual("AccountSet", namingService.GetNameForEntitySet(acountMetadata, _serviceProvider));
            Assert.AreEqual("SampleEntitySet", namingService.GetNameForEntitySet(sampleEntityMetadata, _serviceProvider));

            Assert.AreEqual("Name", namingService.GetNameForAttribute(null, new AttributeMetadata {
                SchemaName = "Name"
            }, _serviceProvider));
            Assert.AreEqual("Name", namingService.GetNameForAttribute(null, new AttributeMetadata {
                SchemaName = "beedev_Name"
            }, _serviceProvider));

            Assert.AreEqual("Name", namingService.GetNameForOptionSet(acountMetadata, new OptionSetMetadata {
                Name = "Name"
            }, _serviceProvider));
            Assert.AreEqual("Name", namingService.GetNameForOptionSet(acountMetadata, new OptionSetMetadata {
                Name = "beedev_Name"
            }, _serviceProvider));

            Assert.AreEqual("Name", namingService.GetNameForOption(new OptionSetMetadata(), new OptionMetadata {
                Label = new Label("Name", 1033)
                {
                    UserLocalizedLabel = new LocalizedLabel("Name", 1033)
                }
            }, _serviceProvider));
            Assert.AreEqual("Name", namingService.GetNameForOption(new OptionSetMetadata(), new OptionMetadata {
                Label = new Label("beedev_Name", 1033)
                {
                    UserLocalizedLabel = new LocalizedLabel("beedev_Name", 1033)
                }
            }, _serviceProvider));

            Assert.AreEqual("Account_Opportunities", namingService.GetNameForRelationship(acountMetadata, new ManyToManyRelationshipMetadata {
                SchemaName = "Account_Opportunities"
            }, new EntityRole?(), _serviceProvider));
            Assert.AreEqual("SampleEntity_Opportunities", namingService.GetNameForRelationship(acountMetadata, new ManyToManyRelationshipMetadata {
                SchemaName = "beedev_SampleEntity_Opportunities"
            }, new EntityRole?(), _serviceProvider));

            Assert.AreEqual("ServiceContextName", namingService.GetNameForServiceContext(_serviceProvider));

            SdkMessagePair createMessagePair   = new SdkMessagePair(new SdkMessage(Guid.NewGuid(), "Create", false), Guid.NewGuid(), "");
            SdkMessagePair beedevCreateMessage = new SdkMessagePair(new SdkMessage(Guid.NewGuid(), "beedev_Create", false), Guid.NewGuid(), "");

            Assert.AreEqual("Create", namingService.GetNameForMessagePair(createMessagePair, _serviceProvider));
            Assert.AreEqual("Create", namingService.GetNameForMessagePair(beedevCreateMessage, _serviceProvider));

            Assert.AreEqual("RequestField", namingService.GetNameForRequestField(new SdkMessageRequest(createMessagePair, Guid.NewGuid(), "CreateRequest"), new SdkMessageRequestField(new SdkMessageRequest(createMessagePair, Guid.NewGuid(), "CreateRequest"), 0, "RequestField", "", true), _serviceProvider));
            Assert.AreEqual("RequestField", namingService.GetNameForRequestField(new SdkMessageRequest(createMessagePair, Guid.NewGuid(), "CreateRequest"), new SdkMessageRequestField(new SdkMessageRequest(createMessagePair, Guid.NewGuid(), "CreateRequest"), 0, "beedev_RequestField", "", true), _serviceProvider));

            Assert.AreEqual("ResponseField", namingService.GetNameForResponseField(new SdkMessageResponse(Guid.NewGuid()), new SdkMessageResponseField(0, "ResponseField", "", null), _serviceProvider));
            Assert.AreEqual("ResponseField", namingService.GetNameForResponseField(new SdkMessageResponse(Guid.NewGuid()), new SdkMessageResponseField(0, "beedev_ResponseField", "", null), _serviceProvider));
        }
Example #16
0
 public string GetNameForMessagePair(SdkMessagePair messagePair, IServiceProvider services)
 {
     return(DefaultService.GetNameForMessagePair(messagePair, services));
 }
Example #17
0
 public CodeGenerationType GetTypeForMessagePair(SdkMessagePair messagePair, IServiceProvider services)
 {
     return(GetTypeForMessagePairInternal(messagePair, services));
 }
Example #18
0
 protected virtual CodeGenerationType GetTypeForMessagePairInternal(SdkMessagePair messagePair, IServiceProvider services)
 {
     return(DefaultService.GetTypeForMessagePair(messagePair, services));
 }
        async Task <bool> ICodeWriterMessageFilterService.GenerateSdkMessagePairAsync(SdkMessagePair messagePair,
                                                                                      IServiceProvider services)
        {
            await CrmSvcUtil.CrmSvcUtilLogger.TraceMethodStartAsync("Entering {0}", MethodBase.GetCurrentMethod().Name);

            await CrmSvcUtil.CrmSvcUtilLogger.TraceMethodStopAsync("Exiting {0}", MethodBase.GetCurrentMethod().Name);

            return((this._generateMessages || this._generateCustomActions) && !CodeWriterFilterService.ExcludedNamespaces.Contains(messagePair.MessageNamespace.ToUpperInvariant()) && (!this._generateCustomActions || messagePair.Message.IsCustomAction) && (string.IsNullOrEmpty(this._messageNamespace) || string.Equals(this._messageNamespace, messagePair.MessageNamespace, StringComparison.OrdinalIgnoreCase)));
        }
Example #20
0
 public CodeGenerationType GetTypeForMessagePair(SdkMessagePair messagePair, IServiceProvider services)
 {
     return(DefaultService.GetTypeForMessagePair(messagePair, services));
 }
Example #21
0
 public bool GenerateSdkMessagePair(SdkMessagePair messagePair, IServiceProvider services)
 {
     return(this.DefaultService.GenerateSdkMessagePair(messagePair, services));
 }