static CodeTypeDeclaration BuildMessageRequest(SdkMessagePair messagePair, SdkMessageRequest sdkMessageRequest, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var requestClass = Class(string.Format(CultureInfo.InvariantCulture, "{0}{1}", new object[] {serviceProvider.NamingService.GetNameForMessagePair(messagePair, serviceProvider), RequestClassSuffix}), RequestClassBaseType, new[] {Attribute(typeof (DataContractAttribute), new[] {AttributeArg("Namespace", messagePair.MessageNamespace)}), Attribute(typeof (RequestProxyAttribute), new[] {AttributeArg(null, messagePair.Request.Name)})}); var flag = false; var statements = new CodeStatementCollection(); if ((sdkMessageRequest.RequestFields != null) & (sdkMessageRequest.RequestFields.Count > 0)) { foreach (var field in sdkMessageRequest.RequestFields.Values) { var requestField = BuildRequestField(sdkMessageRequest, field, serviceProvider); if (requestField.Type.Options == CodeTypeReferenceOptions.GenericTypeParameter) { Trace.TraceInformation("Request Field {0} is generic. Adding generic parameter to the {1} class.", new object[] {requestField.Name, requestClass.Name}); flag = true; ConvertRequestToGeneric(messagePair, requestClass, requestField); } requestClass.Members.Add(requestField); if (!field.IsOptional) { statements.Add(AssignProp(requestField.Name, new CodeDefaultValueExpression(requestField.Type))); } } } if (!flag) { var constructor = Constructor(new CodeExpression[0]); constructor.Statements.Add(AssignProp(RequestNamePropertyName, new CodePrimitiveExpression(messagePair.Request.Name))); constructor.Statements.AddRange(statements); requestClass.Members.Add(constructor); } Trace.TraceInformation("Exiting {0}: SDK Request Class {1} defined", new object[] {MethodBase.GetCurrentMethod().Name, requestClass.Name}); return requestClass; }
static CodeTypeMember BuildAttribute(EntityMetadata entity, AttributeMetadata attribute, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var type = serviceProvider.TypeMappingService.GetTypeForAttributeType(entity, attribute, serviceProvider); var property = PropertyGet(type, serviceProvider.NamingService.GetNameForAttribute(entity, attribute, serviceProvider), new CodeStatement[0]); property.HasSet = attribute.IsValidForCreate.GetValueOrDefault() ? true : attribute.IsValidForUpdate.GetValueOrDefault(); property.HasGet = attribute.IsValidForRead.GetValueOrDefault() || property.HasSet; if (property.HasGet) { property.GetStatements.AddRange(BuildAttributeGet(attribute, type)); } if (property.HasSet) { property.SetStatements.AddRange(BuildAttributeSet(entity, attribute)); } property.CustomAttributes.Add(Attribute(AttributeLogicalNameAttribute, new[] {AttributeArg(attribute.LogicalName)})); if (attribute.DeprecatedVersion != null) { property.CustomAttributes.Add(Attribute(ObsoleteFieldAttribute)); } property.Comments.AddRange(CommentSummary(attribute.Description)); Trace.TraceInformation("Exiting {0}: {1}.Attribute {2} defined", new object[] {MethodBase.GetCurrentMethod().Name, entity.LogicalName, property.Name}); return property; }
static CodeTypeDeclarationCollection BuildMessage(SdkMessage message, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var declarations = new CodeTypeDeclarationCollection(); foreach (var pair in message.SdkMessagePairs.Values) { if (serviceProvider.CodeMessageFilterService.GenerateSdkMessagePair(pair, serviceProvider)) { declarations.Add(BuildMessageRequest(pair, pair.Request, serviceProvider)); declarations.Add(BuildMessageResponse(pair, pair.Response, serviceProvider)); } else { Trace.TraceInformation("Skipping {0}.Message Pair from being generated.", new object[] {message.Name, pair.Request.Name}); } } Trace.TraceInformation("Exiting {0}", new object[] {MethodBase.GetCurrentMethod().Name}); return declarations; }
static CodeTypeDeclarationCollection BuildOptionSets(OptionSetMetadataBase[] optionSetMetadata, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var declarations = new CodeTypeDeclarationCollection(); foreach (var base2 in optionSetMetadata) { if ((serviceProvider.CodeFilterService.GenerateOptionSet(base2, serviceProvider) && base2.IsGlobal.HasValue) && base2.IsGlobal.Value) { var declaration = BuildOptionSet(null, base2, serviceProvider); if (declaration != null) { declarations.Add(declaration); } else { Trace.TraceInformation("Skipping OptionSet {0} of type {1} from being generated.", new object[] {base2.Name, base2.GetType()}); } } else { Trace.TraceInformation("Skipping OptionSet {0} from being generated.", new object[] {base2.Name}); } } Trace.TraceInformation("Exiting {0}", new object[] {MethodBase.GetCurrentMethod().Name}); return declarations; }
static CodeTypeDeclarationCollection BuildServiceContext(EntityMetadata[] entityMetadata, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var declarations = new CodeTypeDeclarationCollection(); if (serviceProvider.CodeFilterService.GenerateServiceContext(serviceProvider)) { var declaration = Class(serviceProvider.NamingService.GetNameForServiceContext(serviceProvider), ServiceContextBaseType, new CodeAttributeDeclaration[0]); declaration.Members.Add(ServiceContextConstructor()); declaration.Comments.AddRange(CommentSummary("Represents a source of entities bound to a CRM service. It tracks and manages changes made to the retrieved entities.")); foreach (var metadata in from metadata in entityMetadata orderby metadata.LogicalName select metadata) { if (serviceProvider.CodeFilterService.GenerateEntity(metadata, serviceProvider) && !string.Equals(metadata.LogicalName, "calendarrule", StringComparison.Ordinal)) { declaration.Members.Add(BuildEntitySet(metadata, serviceProvider)); } else { Trace.TraceInformation("Skipping {0} entity set and AddTo method from being generated.", new object[] {metadata.LogicalName}); } } declarations.Add(declaration); } else { Trace.TraceInformation("Skipping data context from being generated."); } Trace.TraceInformation("Exiting {0}", new object[] {MethodBase.GetCurrentMethod().Name}); return declarations; }
static CodeTypeMember BuildOneToMany(EntityMetadata entity, EntityMetadata otherEntity, OneToManyRelationshipMetadata oneToMany, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var typeParameter = serviceProvider.TypeMappingService.GetTypeForRelationship(oneToMany, otherEntity, serviceProvider); var reflexiveRole = (oneToMany.ReferencingEntity == entity.LogicalName) ? ((EntityRole?) 1) : null; var property = PropertyGet(IEnumerable(typeParameter), serviceProvider.NamingService.GetNameForRelationship(entity, oneToMany, reflexiveRole, serviceProvider), new CodeStatement[0]); property.GetStatements.Add(BuildRelationshipGet("GetRelatedEntities", oneToMany, typeParameter, reflexiveRole)); property.SetStatements.AddRange(BuildRelationshipSet("SetRelatedEntities", oneToMany, typeParameter, reflexiveRole)); property.CustomAttributes.Add(BuildRelationshipSchemaNameAttribute(oneToMany.SchemaName, reflexiveRole)); property.Comments.AddRange(CommentSummary("1:N " + oneToMany.SchemaName)); Trace.TraceInformation("Exiting {0}: {1}.OneToMany {2} defined", new object[] {MethodBase.GetCurrentMethod().Name, entity.LogicalName, property.Name}); return property; }
static CodeTypeMember BuildOption(OptionSetMetadataBase optionSet, OptionMetadata option, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var field = Field(serviceProvider.NamingService.GetNameForOption(optionSet, option, serviceProvider), typeof (int), option.Value.Value, new[] {Attribute(typeof (EnumMemberAttribute))}); Trace.TraceInformation("Exiting {0}: {1}.Option {2} defined", new object[] {MethodBase.GetCurrentMethod().Name, optionSet.Name, field.Name}); return field; }
static CodeTypeDeclarationCollection BuildEntity(EntityMetadata entity, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var declarations = new CodeTypeDeclarationCollection(); var entityClass = Class(serviceProvider.NamingService.GetNameForEntity(entity, serviceProvider), TypeRef(EntityClassBaseType), new[] {Attribute(typeof (DataContractAttribute)), Attribute(EntityLogicalNameAttribute, new[] {AttributeArg(entity.LogicalName)})}); InitializeEntityClass(entityClass, entity); CodeTypeMember member = null; foreach (var metadata in from metadata in entity.Attributes orderby metadata.LogicalName select metadata) { if (serviceProvider.CodeFilterService.GenerateAttribute(metadata, serviceProvider)) { member = BuildAttribute(entity, metadata, serviceProvider); entityClass.Members.Add(member); if ((entity.PrimaryIdAttribute == metadata.LogicalName) && metadata.IsPrimaryId.GetValueOrDefault()) { entityClass.Members.Add(BuildIdProperty(entity, metadata, serviceProvider)); } } else { Trace.TraceInformation("Skipping {0}.Attribute {1} from being generated.", new object[] {entity.LogicalName, metadata.LogicalName}); } var declaration = BuildAttributeOptionSet(entity, metadata, member, serviceProvider); if (declaration != null) { declarations.Add(declaration); } var declaration2 = BuildAttributeOptionSetForPickList(entity, metadata, serviceProvider); if (declaration2 != null) { var codeTypeMember = entityClass.Members.Cast<CodeTypeMember>().FirstOrDefault(x => x.Name == declaration2.Name); if (codeTypeMember != null) { //dont re inject type continue; } entityClass.Members.Add(declaration2); } } entityClass.Members.AddRange(BuildOneToManyRelationships(entity, serviceProvider)); entityClass.Members.AddRange(BuildManyToManyRelationships(entity, serviceProvider)); entityClass.Members.AddRange(BuildManyToOneRelationships(entity, serviceProvider)); declarations.Add(entityClass); Trace.TraceInformation("Exiting {0}: Entity Class {1} defined", new object[] {MethodBase.GetCurrentMethod().Name, entityClass.Name}); return declarations; }
static CodeTypeMember BuildEntitySet(EntityMetadata entity, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var typeForEntity = serviceProvider.TypeMappingService.GetTypeForEntity(entity, serviceProvider); var property = PropertyGet(IQueryable(typeForEntity), serviceProvider.NamingService.GetNameForEntitySet(entity, serviceProvider), new CodeStatement[] {Return(ThisMethodInvoke("CreateQuery", typeForEntity, new CodeExpression[0]))}); property.Comments.AddRange(CommentSummary(string.Format(CultureInfo.InvariantCulture, "Gets a binding to the set of all <see cref=\"{0}\"/> entities.", new object[] {typeForEntity.BaseType}))); Trace.TraceInformation("Exiting {0}: {1} entity set '{2}' defined", new object[] {MethodBase.GetCurrentMethod().Name, entity.LogicalName, property.Name}); return property; }
static CodeNamespace BuildCodeDom(IOrganizationMetadata organizationMetadata, string outputNamespace, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var namespace2 = Namespace(outputNamespace); namespace2.Types.AddRange(BuildOptionSets(organizationMetadata.OptionSets, serviceProvider)); namespace2.Types.AddRange(BuildEntities(organizationMetadata.Entities, serviceProvider)); namespace2.Types.AddRange(BuildServiceContext(organizationMetadata.Entities, serviceProvider)); namespace2.Types.AddRange(BuildMessages(organizationMetadata.Messages, serviceProvider)); Trace.TraceInformation("Exiting {0}", new object[] {MethodBase.GetCurrentMethod().Name}); return namespace2; }
static CodeTypeDeclarationCollection BuildEntities(EntityMetadata[] entityMetadata, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var declarations = new CodeTypeDeclarationCollection(); foreach (var metadata in from metadata in entityMetadata orderby metadata.LogicalName select metadata) { if (serviceProvider.CodeFilterService.GenerateEntity(metadata, serviceProvider)) { declarations.AddRange(BuildEntity(metadata, serviceProvider)); } else { Trace.TraceInformation("Skipping Entity {0} from being generated.", new object[] {metadata.LogicalName}); } } Trace.TraceInformation("Exiting {0}", new object[] {MethodBase.GetCurrentMethod().Name}); return declarations; }
static CodeTypeMember BuildCalendarRuleAttribute(EntityMetadata entity, EntityMetadata otherEntity, OneToManyRelationshipMetadata oneToMany, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var property = PropertyGet(IEnumerable(serviceProvider.TypeMappingService.GetTypeForRelationship(oneToMany, otherEntity, serviceProvider)), "CalendarRules", new CodeStatement[0]); property.GetStatements.AddRange(BuildEntityCollectionAttributeGet("calendarrules", property.Type)); property.SetStatements.Add(BuildEntityCollectionAttributeSet("calendarrules")); property.CustomAttributes.Add(Attribute(AttributeLogicalNameAttribute, new[] {AttributeArg("calendarrules")})); property.Comments.AddRange(CommentSummary("1:N " + oneToMany.SchemaName)); Trace.TraceInformation("Exiting {0}: {1}.Attribute {2} defined", new object[] {MethodBase.GetCurrentMethod().Name, entity.LogicalName, property.Name}); return property; }
static CodeTypeDeclaration BuildAttributeOptionSetForPickList(EntityMetadata entity, AttributeMetadata attribute, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var attributeOptionSet = TypeMappingService.GetAttributeOptionSet(attribute); if ((attributeOptionSet == null) || !((attributeOptionSet.OptionSetType.Value) == OptionSetType.Picklist)) { if (attributeOptionSet != null) { Trace.TraceInformation("Exiting {0}: No type created for {1}", new object[] {MethodBase.GetCurrentMethod().Name, attributeOptionSet.Name}); } return null; } if (!attributeOptionSet.IsCustomOptionSet.GetValueOrDefault()) { Trace.TraceInformation("Exiting {0}: No type created for {1} of type {2} since it is not custom.", new object[] { MethodBase.GetCurrentMethod().Name, attributeOptionSet.Name, attributeOptionSet.GetType() }); return null; } var declaration = BuildOptionSet(entity, attributeOptionSet, serviceProvider); if (declaration == null) { Trace.TraceInformation("Exiting {0}: No type created for {1} of type {2}", new object[] {MethodBase.GetCurrentMethod().Name, attributeOptionSet.Name, attributeOptionSet.GetType()}); return null; } return declaration; }
static CodeTypeDeclaration BuildAttributeOptionSet(EntityMetadata entity, AttributeMetadata attribute, CodeTypeMember attributeMember, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var attributeOptionSet = TypeMappingService.GetAttributeOptionSet(attribute); if ((attributeOptionSet == null) || !serviceProvider.CodeFilterService.GenerateOptionSet(attributeOptionSet, serviceProvider)) { if (attributeOptionSet != null) { Trace.TraceInformation("Exiting {0}: No type created for {1}", new object[] {MethodBase.GetCurrentMethod().Name, attributeOptionSet.Name}); } return null; } var declaration = BuildOptionSet(entity, attributeOptionSet, serviceProvider); if (declaration == null) { Trace.TraceInformation("Exiting {0}: No type created for {1} of type {2}", new object[] {MethodBase.GetCurrentMethod().Name, attributeOptionSet.Name, attributeOptionSet.GetType()}); return null; } Trace.TraceInformation("Exiting {0}: Type {1} created for {2}", new object[] {MethodBase.GetCurrentMethod().Name, declaration.Name, attributeOptionSet.Name}); UpdateAttributeMemberStatements(attribute, attributeMember); return declaration; }
static CodeTypeDeclaration BuildMessageResponse(SdkMessagePair messagePair, SdkMessageResponse sdkMessageResponse, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var declaration = Class(string.Format(CultureInfo.InvariantCulture, "{0}{1}", new object[] {serviceProvider.NamingService.GetNameForMessagePair(messagePair, serviceProvider), ResponseClassSuffix}), ResponseClassBaseType, new[] {Attribute(typeof (DataContractAttribute), new[] {AttributeArg("Namespace", messagePair.MessageNamespace)}), Attribute(typeof (ResponseProxyAttribute), new[] {AttributeArg(null, messagePair.Request.Name)})}); declaration.Members.Add(Constructor(new CodeExpression[0])); if ((sdkMessageResponse != null) && ((sdkMessageResponse.ResponseFields != null) & (sdkMessageResponse.ResponseFields.Count > 0))) { foreach (var field in sdkMessageResponse.ResponseFields.Values) { declaration.Members.Add(BuildResponseField(sdkMessageResponse, field, serviceProvider)); } } else { Trace.TraceInformation("SDK Response Class {0} has not fields", new object[] {declaration.Name}); } Trace.TraceInformation("Exiting {0}: SDK Response Class {1} defined", new object[] {MethodBase.GetCurrentMethod().Name, declaration.Name}); return declaration; }
static CodeTypeMember BuildIdProperty(EntityMetadata entity, AttributeMetadata attribute, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var property = PropertyGet(TypeRef(typeof (Guid)), "Id", new CodeStatement[0]); property.CustomAttributes.Add(Attribute(AttributeLogicalNameAttribute, new[] {AttributeArg(attribute.LogicalName)})); property.Attributes = MemberAttributes.Public | MemberAttributes.Override; property.HasSet = attribute.IsValidForCreate.GetValueOrDefault() ? true : attribute.IsValidForUpdate.GetValueOrDefault(); property.HasGet = attribute.IsValidForRead.GetValueOrDefault() || property.HasSet; property.GetStatements.Add(Return(BaseProp("Id"))); if (property.HasSet) { property.SetStatements.Add(AssignValue(ThisProp(serviceProvider.NamingService.GetNameForAttribute(entity, attribute, serviceProvider)), VarRef("value"))); } else { property.SetStatements.Add(AssignValue(BaseProp("Id"), VarRef("value"))); } Trace.TraceInformation("Exiting {0}: {1}.Attribute Id defined", new object[] {MethodBase.GetCurrentMethod().Name, entity.LogicalName}); return property; }
static CodeTypeDeclarationCollection BuildMessages(SdkMessages sdkMessages, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var declarations = new CodeTypeDeclarationCollection(); foreach (var message in sdkMessages.MessageCollection.Values) { if (serviceProvider.CodeMessageFilterService.GenerateSdkMessage(message, serviceProvider)) { declarations.AddRange(BuildMessage(message, serviceProvider)); } else { Trace.TraceInformation("Skipping SDK Message {0} from being generated.", new object[] {message.Name}); } } Trace.TraceInformation("Exiting {0}", new object[] {MethodBase.GetCurrentMethod().Name}); return declarations; }
static CodeTypeMember BuildManyToMany(EntityMetadata entity, EntityMetadata otherEntity, ManyToManyRelationshipMetadata manyToMany, string propertyName, EntityRole? entityRole, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var typeParameter = serviceProvider.TypeMappingService.GetTypeForRelationship(manyToMany, otherEntity, serviceProvider); var property = PropertyGet(IEnumerable(typeParameter), propertyName, new CodeStatement[0]); property.GetStatements.Add(BuildRelationshipGet("GetRelatedEntities", manyToMany, typeParameter, entityRole)); property.SetStatements.AddRange(BuildRelationshipSet("SetRelatedEntities", manyToMany, typeParameter, entityRole)); property.CustomAttributes.Add(BuildRelationshipSchemaNameAttribute(manyToMany.SchemaName, entityRole)); property.Comments.AddRange(CommentSummary("N:N " + manyToMany.SchemaName)); Trace.TraceInformation("Exiting {0}: {1}.ManyToMany {2} defined", new object[] {MethodBase.GetCurrentMethod().Name, entity.LogicalName, propertyName}); return property; }
static CodeTypeMemberCollection BuildOneToManyRelationships(EntityMetadata entity, ServiceProvider serviceProvider) { var members = new CodeTypeMemberCollection(); if (entity.OneToManyRelationships != null) { foreach (var metadata in from metadata in entity.OneToManyRelationships orderby metadata.SchemaName select metadata) { var entityMetadata = GetEntityMetadata(metadata.ReferencingEntity, serviceProvider); if (string.Equals(metadata.SchemaName, "calendar_calendar_rules", StringComparison.Ordinal) || string.Equals(metadata.SchemaName, "service_calendar_rules", StringComparison.Ordinal)) { members.Add(BuildCalendarRuleAttribute(entity, entityMetadata, metadata, serviceProvider)); } else if (serviceProvider.CodeFilterService.GenerateEntity(entityMetadata, serviceProvider) && serviceProvider.CodeFilterService.GenerateRelationship(metadata, entityMetadata, serviceProvider)) { members.Add(BuildOneToMany(entity, entityMetadata, metadata, serviceProvider)); } else { Trace.TraceInformation("Skipping {0}.OneToMany {1} from being generated.", new object[] {entity.LogicalName, metadata.SchemaName}); } } } return members; }
static CodeTypeMemberCollection BuildManyToManyRelationships(EntityMetadata entity, ServiceProvider serviceProvider) { var members = new CodeTypeMemberCollection(); if (entity.ManyToManyRelationships != null) { foreach (var metadata in from metadata in entity.ManyToManyRelationships orderby metadata.SchemaName select metadata) { var entityLogicalName = (entity.LogicalName != metadata.Entity1LogicalName) ? metadata.Entity1LogicalName : metadata.Entity2LogicalName; var entityMetadata = GetEntityMetadata(entityLogicalName, serviceProvider); if (serviceProvider.CodeFilterService.GenerateEntity(entityMetadata, serviceProvider) && serviceProvider.CodeFilterService.GenerateRelationship(metadata, entityMetadata, serviceProvider)) { if (entityMetadata.LogicalName != entity.LogicalName) { EntityRole? reflexiveRole = null; var propertyName = serviceProvider.NamingService.GetNameForRelationship(entity, metadata, reflexiveRole, serviceProvider); EntityRole? entityRole = null; var member = BuildManyToMany(entity, entityMetadata, metadata, propertyName, entityRole, serviceProvider); members.Add(member); } else { var str3 = serviceProvider.NamingService.GetNameForRelationship(entity, metadata, 0, serviceProvider); var member2 = BuildManyToMany(entity, entityMetadata, metadata, str3, 0, serviceProvider); members.Add(member2); var str4 = serviceProvider.NamingService.GetNameForRelationship(entity, metadata, EntityRole.Referenced, serviceProvider); var member3 = BuildManyToMany(entity, entityMetadata, metadata, str4, EntityRole.Referenced, serviceProvider); members.Add(member3); } } else { Trace.TraceInformation("Skipping {0}.ManyToMany {1} from being generated.", new object[] {entity.LogicalName, metadata.SchemaName}); } } } return members; }
static CodeTypeDeclaration BuildOptionSet(EntityMetadata entity, OptionSetMetadataBase optionSet, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var declaration = Enum(serviceProvider.NamingService.GetNameForOptionSet(entity, optionSet, serviceProvider), new[] {Attribute(typeof (DataContractAttribute))}); var metadata = optionSet as OptionSetMetadata; if (metadata == null) { return null; } foreach (var metadata2 in metadata.Options) { if (Char.IsDigit(serviceProvider.NamingService.GetNameForOption(optionSet, metadata2, serviceProvider).First())) { Trace.TraceInformation("Skipping {0}.Option {1} from being generated because it starts with a number.", new object[] { optionSet.Name, metadata2.Value.Value }); return null; } if (serviceProvider.CodeFilterService.GenerateOption(metadata2, serviceProvider)) { declaration.Members.Add(BuildOption(optionSet, metadata2, serviceProvider)); } else { Trace.TraceInformation("Skipping {0}.Option {1} from being generated.", new object[] {optionSet.Name, metadata2.Value.Value}); } } Trace.TraceInformation("Exiting {0}: OptionSet Enumeration {1} defined", new object[] {MethodBase.GetCurrentMethod().Name, declaration.Name}); return declaration; }
static CodeTypeMember BuildManyToOne(EntityMetadata entity, EntityMetadata otherEntity, OneToManyRelationshipMetadata manyToOne, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var type = serviceProvider.TypeMappingService.GetTypeForRelationship(manyToOne, otherEntity, serviceProvider); var reflexiveRole = (otherEntity.LogicalName == entity.LogicalName) ? ((EntityRole?) 0) : null; var property = PropertyGet(type, serviceProvider.NamingService.GetNameForRelationship(entity, manyToOne, reflexiveRole, serviceProvider), new CodeStatement[0]); property.GetStatements.Add(BuildRelationshipGet("GetRelatedEntity", manyToOne, type, reflexiveRole)); var metadata = entity.Attributes.Single(attribute => attribute.LogicalName == manyToOne.ReferencingAttribute); if (metadata.IsValidForCreate.GetValueOrDefault() || metadata.IsValidForUpdate.GetValueOrDefault()) { property.SetStatements.AddRange(BuildRelationshipSet("SetRelatedEntity", manyToOne, type, reflexiveRole)); } property.CustomAttributes.Add(Attribute(AttributeLogicalNameAttribute, new[] {AttributeArg(manyToOne.ReferencingAttribute)})); property.CustomAttributes.Add(BuildRelationshipSchemaNameAttribute(manyToOne.SchemaName, reflexiveRole)); property.Comments.AddRange(CommentSummary("N:1 " + manyToOne.SchemaName)); Trace.TraceInformation("Exiting {0}: {1}.ManyToOne {2} defined", new object[] {MethodBase.GetCurrentMethod().Name, entity.LogicalName, property.Name}); return property; }
static CodeMemberProperty BuildResponseField(SdkMessageResponse response, SdkMessageResponseField field, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var typeForResponseField = serviceProvider.TypeMappingService.GetTypeForResponseField(field, serviceProvider); var property = PropertyGet(typeForResponseField, serviceProvider.NamingService.GetNameForResponseField(response, field, serviceProvider), new CodeStatement[0]); property.HasSet = false; property.HasGet = true; property.GetStatements.Add(BuildResponseFieldGetStatement(field, typeForResponseField)); Trace.TraceInformation("Exiting {0}: {1}.Response Property {2} defined", new object[] {MethodBase.GetCurrentMethod().Name, response.Id, property.Name}); return property; }
static CodeTypeMemberCollection BuildManyToOneRelationships(EntityMetadata entity, ServiceProvider serviceProvider) { var members = new CodeTypeMemberCollection(); if (entity.ManyToOneRelationships != null) { foreach (var metadata in from metadata in entity.ManyToOneRelationships orderby metadata.SchemaName select metadata) { var entityMetadata = GetEntityMetadata(metadata.ReferencedEntity, serviceProvider); if (serviceProvider.CodeFilterService.GenerateEntity(entityMetadata, serviceProvider) && serviceProvider.CodeFilterService.GenerateRelationship(metadata, entityMetadata, serviceProvider)) { var member = BuildManyToOne(entity, entityMetadata, metadata, serviceProvider); members.Add(member); } else { Trace.TraceInformation("Skipping {0}.ManyToOne {1} from being generated.", new object[] {entity.LogicalName, metadata.SchemaName}); } } } return members; }
static EntityMetadata GetEntityMetadata(string entityLogicalName, ServiceProvider serviceProvider) { return serviceProvider.MetadataProviderService.LoadMetadata().Entities.SingleOrDefault(e => (e.LogicalName == entityLogicalName)); }
static void WriteFile(string outputFile, string language, CodeNamespace codenamespace, ServiceProvider serviceProvider) { Trace.TraceInformation("Entering {0}", new object[] {MethodBase.GetCurrentMethod().Name}); var codeUnit = new CodeCompileUnit(); codeUnit.Namespaces.Add(codenamespace); codeUnit.AssemblyCustomAttributes.Add(Attribute(typeof (ProxyTypesAssemblyAttribute))); serviceProvider.CodeCustomizationService.CustomizeCodeDom(codeUnit, serviceProvider); var options = new CodeGeneratorOptions { BlankLinesBetweenMembers = true, BracingStyle = "C", IndentString = "\t", VerbatimOrder = true }; using (var writer = new StreamWriter(outputFile)) { using (var provider = CodeDomProvider.CreateProvider(language)) { provider.GenerateCodeFromCompileUnit(codeUnit, writer, options); } } Trace.TraceInformation("Exit {0}: Code file written to {1}", new object[] {MethodBase.GetCurrentMethod().Name, outputFile}); Console.Out.WriteLine(string.Format(CultureInfo.InvariantCulture, "Code written to {0}.", new object[] {Path.GetFullPath(outputFile)})); }