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)}));
}
