// Only data components have this.
        internal void Apply(TemplateMetadataJson x)
        {
            x.Validate();

            // $$$ Consistency checks? Or we can just catch this on round-tripping?
            SetGuid(x.Name);

            this.DataComponentDefinitionKey = x.DataComponentDefinitionKey;

            // Clear out volatile state. Will repopulate on write.
            this.DataComponentDefinitionKey.ControlUniqueId = null;
        }
 public void AddComponent(TemplateMetadataJson entry, int order)
 {
     this.OrderComponentTemplate[entry.Name] = order;
 }
 public int GetComponentOrder(TemplateMetadataJson entry)
 {
     return(this.OrderComponentTemplate.GetOrDefault <string, int>(entry.Name, -1));
 }
Example #4
0
        // Get everything that should be stored as a file in the .msapp.
        private static IEnumerable <FileEntry> GetMsAppFiles(this CanvasDocument app, ErrorContainer errors)
        {
            // Loose files
            foreach (var file in app._unknownFiles.Values)
            {
                yield return(file);
            }

            yield return(ToFile(FileKind.Themes, app._themes));

            var header = app._header.JsonClone();

            header.LastSavedDateTimeUTC = app._entropy.GetHeaderLastSaved();
            yield return(ToFile(FileKind.Header, header));

            var props = app._properties.JsonClone();

            if (app._connections != null)
            {
                var json = Utilities.JsonSerialize(app._connections);
                props.LocalConnectionReferences = json;
            }
            if (app._dataSourceReferences != null)
            {
                var json = Utilities.JsonSerialize(app._dataSourceReferences);

                // Some formats serialize empty as "", some serialize as "{}"
                if (app._dataSourceReferences.Count == 0)
                {
                    if (app._entropy.LocalDatabaseReferencesAsEmpty)
                    {
                        json = "";
                    }
                    else
                    {
                        json = "{}";
                    }
                }

                props.LocalDatabaseReferences = json;
            }

            if (app._libraryReferences != null)
            {
                var json = Utilities.JsonSerialize(app._libraryReferences);
                props.LibraryDependencies = json;
            }

            yield return(ToFile(FileKind.Properties, props));

            var(publishInfo, logoFile) = app.TransformLogoOnSave();
            yield return(logoFile);

            if (publishInfo != null)
            {
                yield return(ToFile(FileKind.PublishInfo, publishInfo));
            }

            // "DataComponent" data sources are not part of DataSource.json, and instead in their own file
            var dataSources = new DataSourcesJson
            {
                DataSources = app.GetDataSources()
                              .SelectMany(x => x.Value)
                              .Where(x => !x.IsDataComponent)
                              .OrderBy(x => app._entropy.GetOrder(x))
                              .ToArray()
            };

            yield return(ToFile(FileKind.DataSources, dataSources));

            var sourceFiles = new List <SourceFile>();



            var idRestorer           = new UniqueIdRestorer(app._entropy);
            var maxPublishOrderIndex = app._entropy.PublishOrderIndices.Any() ? app._entropy.PublishOrderIndices.Values.Max() : 0;

            // Rehydrate sources before yielding any to be written, processing component defs first
            foreach (var controlData in app._screens.Concat(app._components)
                     .OrderBy(source =>
                              (app._editorStateStore.TryGetControlState(source.Value.Name.Identifier, out var control) &&
                               (control.IsComponentDefinition ?? false)) ? -1 : 1))
            {
                var sourceFile = IRStateHelpers.CombineIRAndState(controlData.Value, errors, app._editorStateStore, app._templateStore, idRestorer, app._entropy);
                // Offset the publishOrderIndex based on Entropy.json
                foreach (var ctrl in sourceFile.Flatten())
                {
                    if (app._entropy.PublishOrderIndices.TryGetValue(ctrl.Name, out var index))
                    {
                        ctrl.PublishOrderIndex = index;
                    }
                    else
                    {
                        ctrl.PublishOrderIndex = ++maxPublishOrderIndex;
                    }
                }
                sourceFiles.Add(sourceFile);
            }

            CheckUniqueIds(errors, sourceFiles);

            // Repair order when screens are unchanged
            if (sourceFiles.Where(file => !ExcludeControlFromScreenOrdering(file)).Count() == app._screenOrder.Count &&
                sourceFiles.Where(file => !ExcludeControlFromScreenOrdering(file)).All(file => app._screenOrder.Contains(file.ControlName)))
            {
                double i = 0.0;
                foreach (var screen in app._screenOrder)
                {
                    sourceFiles.First(file => file.ControlName == screen).Value.TopParent.Index = i;
                    i += 1;
                }
            }
            else
            {
                // Make up an order, it doesn't really matter.
                double i = 0.0;
                foreach (var sourceFile in sourceFiles)
                {
                    if (ExcludeControlFromScreenOrdering(sourceFile))
                    {
                        continue;
                    }
                    sourceFile.Value.TopParent.Index = i;
                    i += 1;
                }
            }

            RepairComponentInstanceIndex(app._entropy?.ComponentIndexes ?? new Dictionary <string, double>(), sourceFiles);


            // This ordering is essential, we need to match the order in which Studio writes the files to replicate certain order-dependent behavior.
            foreach (var sourceFile in sourceFiles.OrderBy(file => file.GetMsAppFilename()))
            {
                yield return(sourceFile.ToMsAppFile());
            }

            var componentTemplates = new List <TemplateMetadataJson>();

            foreach (var template in app._templateStore.Contents.Where(template => template.Value.IsComponentTemplate ?? false))
            {
                if (((template.Value.CustomProperties?.Any() ?? false) || template.Value.ComponentAllowCustomization.HasValue) &&
                    !(template.Value.ComponentManifest?.IsDataComponent ?? false))
                {
                    componentTemplates.Add(template.Value.ToTemplateMetadata(app._entropy));
                }
            }

            app._templates = new TemplatesJson()
            {
                ComponentTemplates = componentTemplates.Any() ? componentTemplates.OrderBy(x => app._entropy.GetComponentOrder(x)).ToArray() : null,
                UsedTemplates      = app._templates.UsedTemplates.OrderBy(x => app._entropy.GetOrder(x)).ToArray()
            };

            yield return(ToFile(FileKind.Templates, app._templates));

            var componentsMetadata = new List <ComponentsMetadataJson.Entry>();
            var dctemplate         = new List <TemplateMetadataJson>();


            foreach (var componentTemplate in app._templateStore.Contents.Values.Where(state => state.ComponentManifest != null))
            {
                var manifest = componentTemplate.ComponentManifest;
                componentsMetadata.Add(new ComponentsMetadataJson.Entry
                {
                    Name          = manifest.Name,
                    TemplateName  = manifest.TemplateGuid,
                    ExtensionData = manifest.ExtensionData
                });

                if (manifest.IsDataComponent)
                {
                    var controlId = GetDataComponentDefinition(sourceFiles.Select(source => source.Value), manifest.TemplateGuid, errors).ControlUniqueId;

                    var template = new TemplateMetadataJson
                    {
                        Name              = manifest.TemplateGuid,
                        ComponentType     = ComponentType.DataComponent,
                        Version           = app._entropy.GetTemplateVersion(manifest.TemplateGuid),
                        IsComponentLocked = false,
                        ComponentChangedSinceFileImport = true,
                        ComponentAllowCustomization     = true,
                        CustomProperties           = componentTemplate.CustomProperties,
                        DataComponentDefinitionKey = manifest.DataComponentDefinitionKey
                    };

                    // Rehydrate fields.
                    template.DataComponentDefinitionKey.ControlUniqueId = controlId;

                    dctemplate.Add(template);
                }
            }

            if (componentsMetadata.Count > 0)
            {
                // If the components file is present, then write out all files.
                yield return(ToFile(FileKind.ComponentsMetadata, new ComponentsMetadataJson
                {
                    Components = componentsMetadata
                                 .OrderBy(x => app._entropy.GetOrder(x))
                                 .ToArray()
                }));
            }

            if (dctemplate.Count > 0)
            {
                yield return(ToFile(FileKind.DataComponentTemplates, new DataComponentTemplatesJson
                {
                    ComponentTemplates = dctemplate
                                         .OrderBy(x => app._entropy.GetOrder(x))
                                         .ToArray()
                }));
            }


            // Rehydrate the DataComponent DataSource file.
            {
                IEnumerable <DataComponentSourcesJson.Entry> ds =
                    from item in app.GetDataSources().SelectMany(x => x.Value).Where(x => x.IsDataComponent)
                    select item.DataComponentDetails;

                var dsArray = ds.ToArray();

                // backcompat-nit: if we have any DC, then always emit the DC Sources file, even if empty.
                // if (dcmetadataList.Count > 0)
                if (dctemplate.Count > 0 || dsArray.Length > 0)
                {
                    yield return(ToFile(FileKind.DataComponentSources, new DataComponentSourcesJson
                    {
                        DataSources = dsArray
                    }));
                }
            }

            if (app._appCheckerResultJson != null)
            {
                yield return(ToFile(FileKind.AppCheckerResult, app._appCheckerResultJson));
            }

            if (app._resourcesJson != null)
            {
                var resources = app._resourcesJson.JsonClone();
                foreach (var resource in resources.Resources)
                {
                    if (resource.ResourceKind == "LocalFile")
                    {
                        var rootPath = string.Empty;
                        if (app._entropy?.LocalResourceRootPaths.TryGetValue(resource.Name, out rootPath) ?? false)
                        {
                            resource.RootPath = rootPath;
                        }
                        else
                        {
                            resource.RootPath = string.Empty;
                        }
                    }
                }
                yield return(ToFile(FileKind.Resources, resources));
            }

            foreach (var assetFile in app._assetFiles)
            {
                yield return(new FileEntry {
                    Name = FilePath.RootedAt("Assets", assetFile.Value.Name), RawBytes = assetFile.Value.RawBytes
                });
            }
        }