private bool CreateItemProperty(string propertyName, TemplateFieldItem sitecoreField, CodeTypeMemberCollection members) { var type = _fieldMappingProvider.GetFieldType(sitecoreField.Type); if (type == null) { Log.Warn("Synthesis: Field type resolution for " + sitecoreField.InnerItem.Parent.Parent.Name + "::" + sitecoreField.Name + " failed; no mapping found for field type " + sitecoreField.Type, this); return(false); } var backingFieldName = "_" + propertyName[0].ToString(CultureInfo.InvariantCulture).ToLower() + propertyName.Substring(1); var backingField = new CodeMemberField(new CodeTypeReference(type), backingFieldName); backingField.Attributes = MemberAttributes.Private; var property = new CodeMemberProperty { // ReSharper disable BitwiseOperatorOnEnumWithoutFlags Attributes = MemberAttributes.Public | MemberAttributes.Final, // ReSharper restore BitwiseOperatorOnEnumWithoutFlags Type = new CodeTypeReference(type), Name = propertyName, HasGet = true }; // add [IndexField] attribute property.CustomAttributes.Add(GetIndexFieldAttribute(sitecoreField.Name)); // if(backingField == null) // backingField = new SynthesisFieldType(new Lazy<Field>(() => InnerItem.Fields["xxx"], GetSearchFieldValue("index-field-name")); var initializerLambda = new CodeSnippetExpression(string.Format("new global::System.Lazy<global::Sitecore.Data.Fields.Field>(() => InnerItem.Fields[\"{0}\"])", sitecoreField.ID)); var initializerSearchReference = new CodeMethodInvokeExpression(new CodeThisReferenceExpression(), "GetSearchFieldValue", new CodePrimitiveExpression(_indexFieldNameTranslator.GetIndexFieldName(sitecoreField.Name))); var backingFieldNullCheck = new CodeConditionStatement(); backingFieldNullCheck.Condition = new CodeSnippetExpression(string.Format("{0} == null", backingFieldName)); backingFieldNullCheck.TrueStatements.Add(new CodeAssignStatement(new CodeVariableReferenceExpression(backingFieldName), new CodeObjectCreateExpression(property.Type, initializerLambda, initializerSearchReference))); property.GetStatements.Add(backingFieldNullCheck); // return backingField; property.GetStatements.Add(new CodeMethodReturnStatement(new CodeVariableReferenceExpression(backingFieldName))); AddCommentsToFieldProperty(property, sitecoreField); members.Add(backingField); members.Add(property); return(true); }
public TemplateGenerationMetadata GenerateMetadata() { var timer = new Stopwatch(); timer.Start(); // load the templates we'll be generating into a state storage collection var templateData = CreateTemplateData(); foreach (var template in templateData.Templates) { HashSet <string> fieldKeys = GetBaseFieldSet(); // get fields on base type fieldKeys.Add(template.TypeName); // member names cannot be the same as their enclosing type so we add the type name to the fields collection foreach (var baseTemplate in template.Template.AllNonstandardBaseTemplates) // similarly names can't be the same as any of their base templates' names (this would cause an incompletely implemented interface) { if (templateData.Contains(baseTemplate.TemplateId)) { fieldKeys.Add(templateData[baseTemplate.TemplateId].TypeName); } else { fieldKeys.Add(baseTemplate.Name.AsIdentifier()); // NOTE: you could break this if you have a base template called Foo and a field called Foo that IS NOT on the Foo template (but why would you have that?) } } // generate item properties foreach (var field in template.Template.Fields) { if (_templateInputProvider.IsFieldIncluded(field.Id)) // query the template input provider and make sure the field is included { string propertyName = field.Name.AsNovelIdentifier(fieldKeys); var fieldInfo = new FieldPropertyInfo(field); fieldInfo.FieldPropertyName = propertyName; if (_parameters.EnableContentSearch) { fieldInfo.SearchFieldName = _indexFieldNameMapper.MapToSearchField(field); } fieldInfo.FieldType = _fieldMappingProvider.GetFieldType(field); if (fieldInfo.FieldType == null) { Log.Warn("Synthesis: Field type resolution for " + field.Template.Name + "::" + field.Name + " failed; no mapping found for field type " + field.Type, this); continue; // skip adding the field for generation } // record usage of the property name fieldKeys.Add(propertyName); // add the field to the metadata template.FieldsToGenerate.Add(fieldInfo); } } // generates interfaces to represent the Sitecore template inheritance hierarchy TemplateInfo baseInterface = GenerateInheritedInterfaces(template.Template, templateData); if (baseInterface != null) { template.InterfacesImplemented.Add(baseInterface); } } timer.Stop(); Log.Info($"Synthesis: Generated metadata for {templateData.Templates.Count} concrete templates and {templateData.Interfaces.Count} interface templates in {timer.ElapsedMilliseconds} ms", this); return(templateData); }