public List <SCItem> CreateDescendantItems(MetadataTemplate metadataTemplate, SCItem parentItem) { var destItems = new List <SCItem>(); if (metadataTemplate.descendantItems != null) { foreach (var descendantItem in metadataTemplate.descendantItems) { if (descendantItem.isParentChild) { var destDescItem = CreateDescendantItem(descendantItem, parentItem); if (destDescItem != null) { destItems.Add(destDescItem); } } else { var destParentItem = destItems.FirstOrDefault(d => string.Equals(d.Name, descendantItem.parentItemName, StringComparison.InvariantCultureIgnoreCase)); if (destParentItem != null) { var destDescItem = CreateDescendantItem(descendantItem, destParentItem); if (destDescItem != null) { destItems.Add(destDescItem); } } } } } return(destItems); }
public virtual void WriteDescendentItems(MetadataTemplate metadataTemplate, SCItem parentItem) { var descendantItems = _itemFactory.CreateDescendantItems(metadataTemplate, parentItem); foreach (SCItem descendantItem in descendantItems) { _destMasterRepository.AddOrUpdateSitecoreItem(descendantItem); } }
public void DeleteItem(Guid parentId, string itemName, MetadataTemplate metadataTemplate) { var textItem = _destMasterRepository.GetSitecoreChildrenItems(metadataTemplate.destTemplateId, parentId) .FirstOrDefault(item => string.Equals(item.Name, itemName, StringComparison.InvariantCultureIgnoreCase)); if (textItem != null) { _destMasterRepository.DeleteSitecoreItem(textItem); } }
public void GenerateDomainProject(DomainDataService dataService, string outputFolder) { outputFolder = Path.Combine(outputFolder, $"{dataService.Solution.NamespacePrefix}.{dataService.Name}.Domain"); var constantsFolder = Path.Combine(outputFolder, "Constants"); var modelsFolder = Path.Combine(outputFolder, "Models"); var metadataFolder = Path.Combine(outputFolder, "Metadata"); ReplaceDirectories(constantsFolder, modelsFolder, metadataFolder); var session = new Dictionary <string, object>(); session.Add("DomainDataService", dataService); DomainProjectTemplate projectTemplate = new DomainProjectTemplate(); projectTemplate.Session = session; projectTemplate.Initialize(); string content = projectTemplate.TransformText(); File.WriteAllText(Path.Combine(outputFolder, $"{dataService.Solution.NamespacePrefix}.{dataService.Name}.Domain.csproj"), content); DomainConstantsTemplate constantsTemplate = new DomainConstantsTemplate(); constantsTemplate.Session = session; constantsTemplate.Initialize(); content = constantsTemplate.TransformText(); File.WriteAllText(Path.Combine(constantsFolder, $"{dataService.Name}Constants.cs"), content); if (!(dataService.Schemas is null)) { foreach (var domainObject in dataService.Schemas.SelectMany(s => s.Objects)) { session["CurrentObject"] = domainObject; ModelTemplate modelTemplate = new ModelTemplate(); modelTemplate.Session = session; modelTemplate.Initialize(); content = modelTemplate.TransformText(); File.WriteAllText(Path.Combine(modelsFolder, $"{domainObject.ObjectName}.cs"), content); MetadataTemplate metadataTemplate = new MetadataTemplate(); metadataTemplate.Session = session; metadataTemplate.Initialize(); content = metadataTemplate.TransformText(); File.WriteAllText(Path.Combine(metadataFolder, $"{domainObject.ObjectName}Metadata.cs"), content); } } MetadataBundleTemplate bundleTemplate = new MetadataBundleTemplate(); bundleTemplate.Session = session; bundleTemplate.Initialize(); content = bundleTemplate.TransformText(); File.WriteAllText(Path.Combine(metadataFolder, $"{dataService.Name}MetadataBundle.cs"), content); }
public SCItem Create(Guid destTemplateId, SCItem parentItem, string itemName, MetadataTemplate metadataTemplate = null) { if (metadataTemplate != null) { _itemMetadataTemplate = metadataTemplate; } else { _itemMetadataTemplate = _metadataProvider.GetItemMetadataByTemplateId(destTemplateId); } itemName = RemoveInvalidChars(itemName); return(CreateItem(parentItem, itemName)); }
private MetadataTemplate GetItemMetadataByFilePath(string filePath) { // Read json file var itemMeta = System.IO.File.ReadAllText(filePath); // Deserialize Json to Object MetadataTemplate metadataTemplate = JsonConvert.DeserializeObject <MetadataTemplate>(itemMeta); if (string.IsNullOrEmpty(metadataTemplate.baseTemplateMetadataFileName)) { return(metadataTemplate); } var baseTemplateMetadataFilePath = _metadataFiles.FirstOrDefault(f => GetFileName(f).Equals(metadataTemplate.baseTemplateMetadataFileName, StringComparison.InvariantCultureIgnoreCase)); var fullMetadataTemplate = MergeBaseMetadataTemplate(metadataTemplate, baseTemplateMetadataFilePath); return(fullMetadataTemplate); }
public void SetDataForEdit(string name, string value, string data) { this.Text = "Edit Metadata Item"; bool metadataDefExists = false; if (_MetadataTemplate != null && _MetadataTemplate.MetadataDefinitionList != null && _MetadataTemplate.MetadataDefinitionList.Count > 0) { foreach (MetadataDefinition metadataDefItem in _MetadataTemplate.MetadataDefinitionList) { if (metadataDefItem != null) { if (metadataDefItem.Name != null && string.Compare(metadataDefItem.Name, name, false) == 0) { _SelectedMetadataDef = metadataDefItem; metadataDefExists = true; break; } } } } if (metadataDefExists == false) { MetadataDefinition metadataDef = new MetadataDefinition(); metadataDef.CanEditName = true; metadataDef.CanEditValue = true; metadataDef.Name = name; metadataDef.ValueList.Add(value); if (_MetadataTemplate == null) { _MetadataTemplate = new MetadataTemplate(); } if (_MetadataTemplate.MetadataDefinitionList == null) { _MetadataTemplate.MetadataDefinitionList = new List <MetadataDefinition>(); } _MetadataTemplate.MetadataDefinitionList.Add(metadataDef); _SelectedMetadataDef = metadataDef; } _SelectedData = data; _SelectedValue = value; }
private MetadataTemplate MergeBaseMetadataTemplate(MetadataTemplate metadataTemplate, string baseTemplateMetadataFilePath) { if (string.IsNullOrEmpty(baseTemplateMetadataFilePath)) { return(metadataTemplate); } MetadataTemplate baseTemplateMeta = GetItemMetadataByFilePath(baseTemplateMetadataFilePath); if (baseTemplateMeta == null) { return(metadataTemplate); } // Iterate merging if baseTemplate filename is not null if (!string.IsNullOrEmpty(baseTemplateMeta.baseTemplateMetadataFileName)) { var filePath = _metadataFiles.FirstOrDefault(f => f.IndexOf(baseTemplateMeta.baseTemplateMetadataFileName, StringComparison.InvariantCultureIgnoreCase) > -1); baseTemplateMeta = MergeBaseMetadataTemplate(baseTemplateMeta, filePath); } // Merge Fields metadataTemplate.fields = MergeFields(baseTemplateMeta.fields, metadataTemplate.fields); // Merge Descendant Items metadataTemplate.descendantItems = MergeDescendantItems(baseTemplateMeta.descendantItems, metadataTemplate.descendantItems); // Override dataValueType if (string.IsNullOrEmpty(metadataTemplate.dataValueType)) { metadataTemplate.dataValueType = baseTemplateMeta.dataValueType; } // Override dataValueConverter if (string.IsNullOrEmpty(metadataTemplate.dataValueConverter)) { metadataTemplate.dataValueConverter = baseTemplateMeta.dataValueConverter; } return(metadataTemplate); }
public List <SCItem> Convert(SCItem scItem, Guid destParentId) { _itemMetadataTemplate = _metadataProvider.GetItemMetadataByTemplateId(scItem.TemplateID); if (_itemMetadataTemplate.sourceMappingFieldId != null && _itemMetadataTemplate.sourceMappingFieldId != Guid.Empty) { var sourceMappingFieldValue = scItem.Fields .FirstOrDefault(f => f.FieldId == _itemMetadataTemplate.sourceMappingFieldId)?.Value; var mappedMetadataTemplate = _metadataProvider.GetItemMetadataBySourceMappingFieldValue(sourceMappingFieldValue); if (mappedMetadataTemplate != null) { _itemMetadataTemplate = mappedMetadataTemplate; } else { // Add record in conversion analysis _conversionReporter.AddUnmappedFormFieldItem(scItem.ID, sourceMappingFieldValue); } } List <SCItem> destItems = ConvertItemAndFields(scItem, destParentId); return(destItems); }
public override List <SCItem> ConvertValueElementToItems(SCField scField, string elementValue, MetadataTemplate metadataTemplate, SCItem sourceItem) { List <SCItem> convertedItems = new List <SCItem>(); var decodedElementValue = Uri.UnescapeDataString(elementValue).Replace("+", " "); var queryElements = XmlHelper.GetXmlElementNodeList(decodedElementValue, "query"); if (queryElements != null && queryElements.Count > 0) { foreach (XmlNode queryElement in queryElements) { if (queryElement.Attributes != null && queryElement.Attributes["t"] != null) { var queryType = queryElement.Attributes["t"].Value; if (string.Equals(queryType, "default", StringComparison.InvariantCultureIgnoreCase)) { var value = XmlHelper.GetXmlElementValue(queryElement.InnerXml, "value"); var displayName = value; var queryChildrenElements = XmlHelper.GetXmlElementNames(queryElement.InnerXml); foreach (string queryChildrenElementName in queryChildrenElements) { if (!string.Equals(queryChildrenElementName, "value", StringComparison.InvariantCultureIgnoreCase)) { displayName = XmlHelper.GetXmlElementValue(queryElement.InnerXml, queryChildrenElementName); } } if (!string.IsNullOrEmpty(value)) { // Set item value metadataTemplate.fields.newFields .First(field => field.destFieldId == new Guid("{3A07C171-9BCA-464D-8670-C5703C6D3F11}")).value = value; // Set display name metadataTemplate.fields.newFields .First(field => field.destFieldId == new Guid("{B5E02AD9-D56F-4C41-A065-A133DB87BDEB}")).value = displayName; SCItem convertedItem = _itemFactory.Create(metadataTemplate.destTemplateId, sourceItem, value, metadataTemplate); convertedItems.Add(convertedItem); } } } } } return(convertedItems); }
public virtual Guid WriteNewItem(Guid destTemplateId, SCItem parentItem, string itemName, MetadataTemplate metadataTemplate = null) { var destItem = _itemFactory.Create(destTemplateId, parentItem, itemName, metadataTemplate); _destMasterRepository.AddOrUpdateSitecoreItem(destItem); return(destItem.ID); }
/// <summary> /// Generates Go code for service client. /// </summary> /// <param name="serviceClient"></param> /// <returns></returns> public override async Task Generate(CodeModel cm) { var folder = Path.GetFullPath(Settings.Instance.Host.GetValue <string>("output-folder").Result).Replace('\\', '/'); // check if the namespace contains illegal characters var ns = Settings.Instance.Host.GetValue <string>("namespace").Result; if (Settings.Instance.Host.GetValue <bool>("namespace-chk").Result) { NamespaceCheck(ns); } // if preview-chk:true is specified verify that preview swagger is output under a preview subdirectory. // this is a bit of a hack until we have proper support for this in the swagger->sdk bot so it's opt-in. if (Settings.Instance.Host.GetValue <bool>("preview-chk").Result) { PreviewCheck(folder); } var codeModel = cm as CodeModelGo; if (codeModel == null) { throw new Exception("Code model is not a Go Code Model"); } // unfortunately there is an ordering issue here. during model generation we might // flatten some types (but not all depending on type). then during client generation // the validation codegen needs to know if a type was flattened so it can generate // the correct code, so we need to generate models before clients. // Models var modelsTemplate = new ModelsTemplate { Model = codeModel }; await Write(modelsTemplate, FormatFileName("models")); // Enums - while initially enums should be part of the models, to decrease the size of the models.go file, // we separate the enums definitions out of the models.go file var enums = codeModel.EnumTypes.Cast <EnumTypeGo>().ToList(); if (enums.Any()) { var enumsTemplate = new EnumsTemplate { Model = codeModel }; await Write(enumsTemplate, FormatFileName("enums")); } // Service client var serviceClientTemplate = new ServiceClientTemplate { Model = codeModel }; await Write(serviceClientTemplate, FormatFileName("client")); // by convention the methods in the method group with an empty // name go into the client template so skip them here. HashSet <string> ReservedFiles = new HashSet <string>(StringComparer.OrdinalIgnoreCase) { "models", "client", "version", "interfaces", "enums", }; foreach (var methodGroup in codeModel.MethodGroups.Where(mg => !string.IsNullOrEmpty(mg.Name))) { if (ReservedFiles.Contains(methodGroup.Name.Value)) { methodGroup.Name += "group"; } ReservedFiles.Add(methodGroup.Name); var methodGroupTemplate = new MethodGroupTemplate { Model = methodGroup }; await Write(methodGroupTemplate, FormatFileName(methodGroup.Name).ToLowerInvariant()); } // interfaces var interfacesTemplate = new InterfacesTemplate { Model = codeModel }; await Write(interfacesTemplate, FormatFileName($"{CodeNamerGo.InterfacePackageName(codeModel.Namespace)}/interfaces")); // Version var versionTemplate = new VersionTemplate { Model = codeModel }; await Write(versionTemplate, FormatFileName("version")); // go.mod file, opt-in by specifying the gomod-root arg var modRoot = Settings.Instance.Host.GetValue <string>("gomod-root").Result; if (!string.IsNullOrWhiteSpace(modRoot)) { var i = folder.IndexOf(modRoot); if (i == -1) { throw new Exception($"didn't find module root '{modRoot}' in output path '{folder}'"); } var goVersion = Settings.Instance.Host.GetValue <string>("go-version").Result; if (string.IsNullOrWhiteSpace(goVersion)) { goVersion = defaultGoVersion; } // module name is everything to the right of the start of the module root var gomodTemplate = new GoModTemplate { Model = new GoMod(folder.Substring(i), goVersion) }; await Write(gomodTemplate, $"{StagingDir()}go.mod"); } // metadata var metadataOutputFolder = Settings.Instance.Host.GetValue <string>("metadata-output-folder").Result; if (!string.IsNullOrWhiteSpace(metadataOutputFolder)) { var metadataTemplate = new MetadataTemplate { Model = new MetadataGo(Settings.Instance.Host.GetValue <string[]>("input-file").Result, folder, ns) }; var tag = Settings.Instance.Host.GetValue <string>("tag").Result; await Write(metadataTemplate, $"{metadataOutputFolder}/{tag}.json"); } }
public override List <SCItem> ConvertValueElementToItems(SCField scField, string elementValue, MetadataTemplate metadataTemplate, SCItem sourceItem) { List <SCItem> convertedItems = new List <SCItem>(); var decodedElementValue = Uri.UnescapeDataString(elementValue).Replace("+", " "); XmlNodeList queryElements = null; try { queryElements = XmlHelper.GetXmlElementNodeList(decodedElementValue, "query", true); } catch (Exception ex) { _logger.Log(new LogEntry(LoggingEventType.Error, string.Format("ConvertValueElementToItems - Failed to parse Xml value. ItemID = {0} - FieldID = {1} - ElementName = {2} - ElementValue_Decoded = {3}", scField.ItemId, scField.Id, "query", decodedElementValue), ex)); } if (queryElements != null && queryElements.Count > 0) { foreach (XmlNode queryElement in queryElements) { if (queryElement.Attributes != null && queryElement.Attributes["t"] != null) { var queryType = queryElement.Attributes["t"].Value; if (string.Equals(queryType, "default", StringComparison.InvariantCultureIgnoreCase)) { var value = XmlHelper.GetXmlElementValue(queryElement.InnerXml, "value"); var displayName = value; var displayNames = new Dictionary <Tuple <string, int>, string>(); var queryChildrenElements = XmlHelper.GetXmlElementNames(queryElement.InnerXml); foreach (string queryChildrenElementName in queryChildrenElements) { if (!string.Equals(queryChildrenElementName, "value", StringComparison.InvariantCultureIgnoreCase)) { displayName = XmlHelper.GetXmlElementValue(queryElement.InnerXml, queryChildrenElementName); displayNames.Add(new Tuple <string, int>(queryChildrenElementName, 1), displayName); } } if (!string.IsNullOrEmpty(value)) { // Set item value metadataTemplate.fields.newFields .First(field => field.destFieldId == new Guid("{3A07C171-9BCA-464D-8670-C5703C6D3F11}")).value = value; // Set display name if (displayNames.Any()) { metadataTemplate.fields.newFields .First(field => field.destFieldId == new Guid("{B5E02AD9-D56F-4C41-A065-A133DB87BDEB}")).values = displayNames; } else { metadataTemplate.fields.newFields .First(field => field.destFieldId == new Guid("{B5E02AD9-D56F-4C41-A065-A133DB87BDEB}")).value = displayName; } SCItem convertedItem = _itemFactory.Create(metadataTemplate.destTemplateId, sourceItem, value, metadataTemplate); convertedItems.Add(convertedItem); } } } } } return(convertedItems); }
public void Init(MetadataTemplate metadataTemplate) { _MetadataTemplate = metadataTemplate; }
public virtual List <SCItem> ConvertValueElementToItems(SCField scField, string elementValue, MetadataTemplate metadataTemplate, SCItem sourceItem) { return(new List <SCItem>()); }