public static CanvasDocument Load(Stream streamToMsapp, ErrorContainer errors)
{
if (streamToMsapp == null)
{
throw new ArgumentNullException(nameof(streamToMsapp));
}
// Read raw files.
// Apply transforms.
var app = new CanvasDocument();
app._checksum = new ChecksumJson(); // default empty. Will get overwritten if the file is present.
app._templateStore = new EditorState.TemplateStore();
app._editorStateStore = new EditorState.EditorStateStore();
ComponentsMetadataJson componentsMetadata = null;
DataComponentTemplatesJson dctemplate = null;
DataComponentSourcesJson dcsources = null;
ChecksumMaker checksumMaker = new ChecksumMaker();
// key = screen, value = index
var screenOrder = new Dictionary <string, double>();
ZipArchive zipOpen;
try
{
zipOpen = new ZipArchive(streamToMsapp, ZipArchiveMode.Read);
}
catch (Exception e)
{
// Catch cases where stream is corrupted, can't be read, or unavailable.
errors.MsAppFormatError(e.Message);
return(null);
}
using (var z = zipOpen)
{
foreach (var entry in z.Entries)
{
checksumMaker.AddFile(entry.FullName, entry.ToBytes());
var fullName = entry.FullName;
var kind = FileEntry.TriageKind(FilePath.FromMsAppPath(fullName));
switch (kind)
{
default:
// Track any unrecognized files so we can save back.
app.AddFile(FileEntry.FromZip(entry));
break;
case FileKind.Resources:
app._resourcesJson = ToObject <ResourcesJson>(entry);
foreach (var resource in app._resourcesJson.Resources)
{
if (resource.ResourceKind == "LocalFile")
{
app._entropy.LocalResourceRootPaths.Add(resource.Name, resource.RootPath);
resource.RootPath = null;
}
}
break;
case FileKind.Asset:
app.AddAssetFile(FileEntry.FromZip(entry, name: fullName.Substring("Assets\\".Length)));
break;
case FileKind.Checksum:
app._checksum = ToObject <ChecksumJson>(entry);
break;
case FileKind.OldEntityJSon:
errors.FormatNotSupported($"This is using an older v1 msapp format that is not supported.");
throw new DocumentException();
case FileKind.DataComponentTemplates:
dctemplate = ToObject <DataComponentTemplatesJson>(entry);
break;
case FileKind.ComponentsMetadata:
componentsMetadata = ToObject <ComponentsMetadataJson>(entry);
break;
case FileKind.DataComponentSources:
dcsources = ToObject <DataComponentSourcesJson>(entry);
break;
case FileKind.Properties:
app._properties = ToObject <DocumentPropertiesJson>(entry);
break;
case FileKind.Themes:
app._themes = ToObject <ThemesJson>(entry);
break;
case FileKind.Header:
app._header = ToObject <HeaderJson>(entry);
app._entropy.SetHeaderLastSaved(app._header.LastSavedDateTimeUTC);
app._header.LastSavedDateTimeUTC = null;
break;
case FileKind.PublishInfo:
app._publishInfo = ToObject <PublishInfoJson>(entry);
break;
case FileKind.AppCheckerResult:
app._appCheckerResultJson = ToObject <AppCheckerResultJson>(entry);
break;
case FileKind.ComponentSrc:
case FileKind.ControlSrc:
case FileKind.TestSrc:
{
var control = ToObject <ControlInfoJson>(entry);
var sf = SourceFile.New(control);
// Add to screen order, only screens have meaningful indices, components may have collisions
if (!ExcludeControlFromScreenOrdering(sf))
{
screenOrder.Add(control.TopParent.Name, control.TopParent.Index);
}
var flattenedControlTree = sf.Flatten();
foreach (var ctrl in flattenedControlTree)
{
// Add PublishOrderIndex to Entropy so it doesn't affect the editorstate diff.
app._entropy.PublishOrderIndices.Add(ctrl.Name, ctrl.PublishOrderIndex);
// For component instances, also track their index in Entropy
if (ctrl.Index == 0.0 || ctrl.Template.Id == "http://microsoft.com/appmagic/screen")
{
continue;
}
app._entropy.ComponentIndexes.Add(ctrl.Name, ctrl.Index);
}
IRStateHelpers.SplitIRAndState(sf, app._editorStateStore, app._templateStore, app._entropy, out var controlIR);
if (kind == FileKind.ComponentSrc)
{
app._components.Add(sf.ControlName, controlIR);
}
else
{
app._screens.Add(sf.ControlName, controlIR);
}
}
break;
case FileKind.DataSources:
{
var dataSources = ToObject <DataSourcesJson>(entry);
Utilities.EnsureNoExtraData(dataSources.ExtensionData);
int iOrder = 0;
foreach (var ds in dataSources.DataSources)
{
app.AddDataSourceForLoad(ds, iOrder);
iOrder++;
}
}
break;
case FileKind.Templates:
{
app._templates = ToObject <TemplatesJson>(entry);
int iOrder = 0;
foreach (var template in app._templates.UsedTemplates)
{
app._entropy.Add(template, iOrder);
iOrder++;
}
iOrder = 0;
foreach (var template in app._templates.ComponentTemplates ?? Enumerable.Empty <TemplateMetadataJson>())
{
app._entropy.AddComponent(template, iOrder);
iOrder++;
}
}
break;
}
} // foreach zip entry
foreach (var componentTemplate in app._templates.ComponentTemplates ?? Enumerable.Empty <TemplateMetadataJson>())
{
if (!app._templateStore.TryGetTemplate(componentTemplate.Name, out var template))
{
continue;
}
template.TemplateOriginalName = componentTemplate.OriginalName;
template.IsComponentLocked = componentTemplate.IsComponentLocked;
template.ComponentChangedSinceFileImport = componentTemplate.ComponentChangedSinceFileImport;
template.ComponentAllowCustomization = componentTemplate.ComponentAllowCustomization;
template.ComponentExtraMetadata = componentTemplate.ExtensionData;
if (template.Version != componentTemplate.Version)
{
app._entropy.SetTemplateVersion(template.Name, componentTemplate.Version);
}
}
app._screenOrder = screenOrder.OrderBy(kvp => kvp.Value).Select(kvp => kvp.Key).ToList();
// Checksums?
var currentChecksum = checksumMaker.GetChecksum();
// This is debug only. The server checksum is out of date with the client checksum
// The main checksum validation that matters is the repack after unpack
#if DEBUG
if (app._checksum.ServerStampedChecksum != null && app._checksum.ServerStampedChecksum != currentChecksum.wholeChecksum)
{
// The server checksum doesn't match the actual contents.
// likely has been tampered.
errors.ChecksumMismatch("Checksum doesn't match on extract.");
if (app._checksum.ServerPerFileChecksums != null)
{
foreach (var file in app._checksum.ServerPerFileChecksums)
{
if (!currentChecksum.perFileChecksum.TryGetValue(file.Key, out var fileChecksum))
{
errors.ChecksumMismatch("Missing file " + file.Key);
}
if (fileChecksum != file.Value)
{
errors.ChecksumMismatch($"File {file.Key} checksum does not match on extract");
}
}
foreach (var file in currentChecksum.perFileChecksum)
{
if (!app._checksum.ServerPerFileChecksums.ContainsKey(file.Key))
{
errors.ChecksumMismatch("Extra file " + file.Key);
}
}
}
}
#endif
app._checksum.ClientStampedChecksum = currentChecksum.wholeChecksum;
app._checksum.ClientPerFileChecksums = currentChecksum.perFileChecksum;
// Normalize logo filename.
app.TranformLogoOnLoad();
if (app._properties.LibraryDependencies != null)
{
var refs = Utilities.JsonParse <ComponentDependencyInfo[]>(app._properties.LibraryDependencies);
app._libraryReferences = refs;
app._properties.LibraryDependencies = null;
}
if (app._properties.LocalConnectionReferences != null)
{
var cxs = Utilities.JsonParse <IDictionary <String, ConnectionJson> >(app._properties.LocalConnectionReferences);
app._connections = cxs;
app._properties.LocalConnectionReferences = null;
}
if (!string.IsNullOrEmpty(app._properties.LocalDatabaseReferences))
{
var dsrs = Utilities.JsonParse <IDictionary <String, LocalDatabaseReferenceJson> >(app._properties.LocalDatabaseReferences);
app._dataSourceReferences = dsrs;
app._properties.LocalDatabaseReferences = null;
app._entropy.LocalDatabaseReferencesAsEmpty = false;
}
else
{
app._entropy.LocalDatabaseReferencesAsEmpty = true;
}
if (componentsMetadata?.Components != null)
{
int order = 0;
foreach (var x in componentsMetadata.Components)
{
var manifest = ComponentManifest.Create(x);
if (!app._templateStore.TryGetTemplate(x.TemplateName, out var templateState))
{
errors.FormatNotSupported("Component Metadata contains template not present in the app");
throw new DocumentException();
}
templateState.ComponentManifest = manifest;
app._entropy.Add(x, order);
order++;
}
}
// Only for data-compoents.
if (dctemplate?.ComponentTemplates != null)
{
int order = 0;
foreach (var x in dctemplate.ComponentTemplates)
{
if (x.ComponentType == null)
{
errors.FormatNotSupported($"Data component {x.Name} is using an outdated format");
throw new DocumentException();
}
if (!app._templateStore.TryGetTemplate(x.Name, out var templateState))
{
errors.FormatNotSupported("Component Metadata contains template not present in the app");
throw new DocumentException();
}
ComponentManifest manifest = templateState.ComponentManifest; // Should already exist
app._entropy.SetTemplateVersion(x.Name, x.Version);
app._entropy.Add(x, order);
manifest.Apply(x);
order++;
}
}
if (dcsources?.DataSources != null)
{
// Component Data sources only appear if the data component is actually
// used as a data source in this app.
foreach (var x in dcsources.DataSources)
{
if (x.Type != DataComponentSourcesJson.NativeCDSDataSourceInfo)
{
throw new NotImplementedException(x.Type);
}
var ds = new DataSourceEntry
{
Name = x.Name,
DataComponentDetails = x, // pass in all details for full-fidelity
Type = DataSourceModel.DataComponentType
};
app.AddDataSourceForLoad(ds);
}
}
}
app.ApplyAfterMsAppLoadTransforms(errors);
app.OnLoadComplete(errors);
return(app);
}