public PackageViewModel(PackageReader reader)
{
_reader = reader;
SourcePackageViewModel=new PackageViewModel()
{
Name = reader.GetRulesSourcePropertyValueByName(Package, "name"),
DisplayName = reader.GetRulesSourcePropertyValueByName(Package, "display-name"),
Architecture = reader.GetRulesSourcePropertyValueByName(Package, "arch"),
Feed = reader.GetRulesSourcePropertyValueByName(Package, "feed"),
Location = reader.GetRulesSourcePropertyValueByName(Package, "location"),
Publisher = reader.GetRulesSourcePropertyValueByName(Package, "publisher"),
Version = reader.GetRulesSourcePropertyValueByName(Package, "version"),
IsEditable = true,
IsSource = true,
};
Name = reader.GetRulesPropertyValueByName(Package, "name");
DisplayName = reader.GetRulesPropertyValueByName(Package, "display-name");
Architecture = reader.GetRulesPropertyValueByName(Package, "arch");
Feed = reader.GetRulesPropertyValueByName(Package, "feed");
Location = reader.GetRulesPropertyValueByName(Package, "location");
Publisher = reader.GetRulesPropertyValueByName(Package, "publisher");
Version = reader.GetRulesPropertyValueByName(Package, "version");
IsEditable = false;
SourceString = reader.GetRulesSourceStringPropertyValueByName(Package);
SourcePackageViewModel.PropertyChanged += EvaluatedChanged;
}
public void PackageReader_LegacyFolders()
{
// Verify legacy folder names such as 40 and 35 parse to frameworks
var zip = TestPackages.GetZip(TestPackages.GetLegacyFolderPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(4, groups.Count());
Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework);
Assert.Equal("lib/a.dll", groups[0].Items.ToArray()[0]);
Assert.Equal(NuGetFramework.Parse("net35"), groups[1].TargetFramework);
Assert.Equal("lib/35/b.dll", groups[1].Items.ToArray()[0]);
Assert.Equal(NuGetFramework.Parse("net4"), groups[2].TargetFramework);
Assert.Equal("lib/40/test40.dll", groups[2].Items.ToArray()[0]);
Assert.Equal("lib/40/x86/testx86.dll", groups[2].Items.ToArray()[1]);
Assert.Equal(NuGetFramework.Parse("net45"), groups[3].TargetFramework);
Assert.Equal("lib/45/a.dll", groups[3].Items.ToArray()[0]);
}
}
public MetadataViewModel(PackageReader reader)
{
_reader = reader;
Summary = reader.GetRulesPropertyValueByName(Metadata, "summary");
Description = reader.GetRulesPropertyValueByName(Metadata, "description");
AuthorVersion = reader.GetRulesPropertyValueByName(Metadata, "author-version");
BugTracker = reader.GetRulesPropertyValueByName(Metadata, "bug-tracker");
Stability = reader.GetRulesPropertyValueByName(Metadata, "stability");
Licenses = reader.GetRulesPropertyValueByName(Metadata, "licenses");
IsEditable = false;
SourceMetadataViewModel = new MetadataViewModel()
{
Summary = reader.GetRulesSourcePropertyValueByName(Metadata, "summary"),
Description = reader.GetRulesSourcePropertyValueByName(Metadata, "description"),
AuthorVersion = reader.GetRulesSourcePropertyValueByName(Metadata, "author-version"),
BugTracker = reader.GetRulesSourcePropertyValueByName(Metadata, "bug-tracker"),
Stability = reader.GetRulesSourcePropertyValueByName(Metadata, "stability"),
Licenses = reader.GetRulesSourcePropertyValueByName(Metadata, "licenses"),
IsEditable = true,
IsSource = true,
};
SourceString = reader.GetRulesSourceStringPropertyValueByName(Metadata);
SourceMetadataViewModel.PropertyChanged += EvaluatedChanged;
}
//withparam name?
public AssemblyRoleViewModel(PackageReader reader)
: base()
{
// Root = root;
ApplicationCollection = new ObservableCollection<ApplicationItemViewModel>();
foreach (string parameter in reader.ReadParameters("assembly"))
{
ObservableCollection<ItemViewModel> includeCollection = new ObservableCollection<ItemViewModel>(reader.ApplicationIncludeList("assembly", parameter, "include"));
ApplicationItemViewModel model = new ApplicationItemViewModel()
{
Label = "Assembly",
EditCollectionViewModel = new EditCollectionViewModel(reader, includeCollection),
Name = parameter,
// Root = root,
};
ApplicationCollection.Add(model);
}
SourceString = reader.GetRulesSourceStringPropertyValueByName("assembly");
ApplicationCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(base.FilesCollectionCollectionChanged);
}
public PackageCompositionViewModel(PackageReader reader)
{
// List<string> parameters = reader.ReadPackageCompositionParameters();
// string a = reader.GetRulesPropertyValuesByNameForSigning("package-composition", "symlinks", "exes");
// Symlinks = reader.GetRulesPropertyValuesByNameForSigning("package-composition", "symlinks", "exes");
SourceString = reader.GetRulesSourceStringPropertyValueByName("package-composition");
}
public RequiresViewModel(PackageReader reader)
{
EditCollectionViewModel = new EditCollectionViewModel(reader,
reader.GetRulesSourceValuesByNameForEditableCollections(
"requires", "package"));
SourceString = reader.GetRulesSourceStringPropertyValueByName("requires");
}
public OnlineStage(Socket socket, AgentCore core)
{
_Core = core;
_Socket = socket;
_Reader = new PackageReader<ResponsePackage>();
_Writer = new PackageWriter<RequestPackage>(OnlineStage.LowFps);
_Sends = new Collection.Queue<RequestPackage>();
_Receives = new Collection.Queue<ResponsePackage>();
}
public new void InstallSecurity(string path, IProcessingContext context)
{
Assert.ArgumentNotNullOrEmpty(path, "path");
Assert.ArgumentNotNull((object)context, "context");
Log.Info("Installing security from package: " + path, (object)this);
PackageReader packageReader = new PackageReader(path);
AccountInstaller accountInstaller = new AccountInstaller();
accountInstaller.Initialize(context);
packageReader.Populate((ISink<PackageEntry>)accountInstaller);
accountInstaller.Flush();
accountInstaller.Finish();
}
public EditCollectionViewModel(PackageReader reader, ObservableCollection<ItemViewModel> collection)
{
_reader = reader;
// Root = root;
_editableItems = collection;
if(this.EditableItems.Count>0)
{
_updateSource = this.EditableItems.FirstOrDefault().UpdateSource;
}
_editableItems.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(FilesCollectionCollectionChanged);
}
public Peer(Socket client)
{
_EnableLock = new object();
_Socket = client;
_SoulProvider = new SoulProvider(this, this);
_Responses = new Regulus.Collection.Queue<ResponsePackage>();
_Requests = new Regulus.Collection.Queue<RequestPackage>();
_Enable = true;
_Reader = new PackageReader<RequestPackage>();
_Writer = new PackageWriter<ResponsePackage>();
}
public SigningViewModel(PackageReader reader)
{
_reader = reader;
ReplaceSignature = _reader.GetRulesPropertyValueByName(Signing, "replace-signature") == "true";
CompanyAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "company",false);
DescriptionAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "description",false);
ProductNameAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "product-name",false);
ProductVersion = reader.GetRulesByNameForSigning(Signing, "attributes", "product-version",false);
FileVersionAttribute = reader.GetRulesByNameForSigning(Signing, "attributes", "file-version",false);
EditCollectionViewModel = new EditCollectionViewModel(reader, reader.GetRulesSourceValuesByNameForEditableCollections(Signing, "include"));
IsEditable = false;
IsReadOnly = true;
SourceSigningViewModel = new SigningViewModel()
{
ReplaceSignature =
_reader.GetRulesSourcePropertyValueByName(Signing, "replace-signature") ==
"true",
CompanyAttribute =
reader.GetRulesByNameForSigning(Signing,
"attributes",
"company", true),
DescriptionAttribute =
reader.GetRulesByNameForSigning(Signing,
"attributes",
"description", true),
ProductNameAttribute =
reader.GetRulesByNameForSigning(Signing,
"attributes",
"product-name", true),
ProductVersion =
reader.GetRulesByNameForSigning(Signing,
"attributes",
"product-version", true),
FileVersionAttribute =
reader.GetRulesByNameForSigning(Signing,
"attributes",
"file-version", true),
EditCollectionViewModel = this.EditCollectionViewModel,
IsEditable = true,
IsReadOnly = false,
IsSource = true,
};
SourceString = reader.GetRulesSourceStringPropertyValueByName(Signing);
SourceSigningViewModel.PropertyChanged += EvaluatedChanged;
}
public FilesViewModel(PackageReader reader)
{
_filesCollection = new ObservableCollection<FilesItemViewModel>();
foreach (string parameter in reader.ReadParameters("files"))
{
ObservableCollection<ItemViewModel> includeCollection = new ObservableCollection<ItemViewModel>(reader.GetRulesSourceValuesByParameterForEditableCollections("files", parameter, "include"));
FilesItemViewModel model = new FilesItemViewModel()
{
FilesRoot = reader.GetFilesRulesPropertyValueByParameterAndName(parameter, "root"),
TrimPath = reader.GetFilesRulesPropertyValueByParameterAndName(parameter, "trim-path"),
EditCollectionViewModel = new EditCollectionViewModel(reader, includeCollection),
Name = parameter,
};
_filesCollection.Add(model);
}
SourceString = reader.GetRulesSourceStringPropertyValueByName("files");
_filesCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(FilesCollectionCollectionChanged);
}
public ManifestViewModel(PackageReader reader)
{
_manifestCollection = new ObservableCollection<ManifestItemViewModel>();
foreach (string parameter in reader.ReadParameters("manifest"))
{
var includeCollection = new ObservableCollection<ItemViewModel>(reader.GetRulesSourceValuesByParameterForEditableCollections("manifest", parameter, "include"));
var assemblyCollection = new ObservableCollection<ItemViewModel>(reader.GetRulesSourceValuesByParameterForEditableCollections("manifest", parameter, "assembly"));
var model = new ManifestItemViewModel()
{
AssemblyCollection = new EditCollectionViewModel(reader, assemblyCollection),
IncludeCollection = new EditCollectionViewModel(reader, includeCollection),
Name = parameter,
};
_manifestCollection.Add(model);
}
SourceString = reader.GetRulesSourceStringPropertyValueByName("manifest");
_manifestCollection.CollectionChanged += new System.Collections.Specialized.NotifyCollectionChangedEventHandler(FilesCollectionCollectionChanged);
}
public void PackageReader_RespectReferencesAccordingToDifferentFrameworks()
{
// Copy of the InstallPackageRespectReferencesAccordingToDifferentFrameworks functional test
// Arrange
var zip = TestPackages.GetZip(TestPackages.GetNearestReferenceFilteringPackage());
var reader = new PackageReader(zip);
// Act
var references = reader.GetReferenceItems();
var netResult = NuGetFrameworkUtility.GetNearest<FrameworkSpecificGroup>(references, NuGetFramework.Parse("net45"));
var slResult = NuGetFrameworkUtility.GetNearest<FrameworkSpecificGroup>(references, NuGetFramework.Parse("sl5"));
// Assert
Assert.Equal(2, netResult.Items.Count());
Assert.Equal(1, slResult.Items.Count());
Assert.Equal("lib/sl40/a.dll", slResult.Items.First());
Assert.Equal("lib/net40/one.dll", netResult.Items.First());
Assert.Equal("lib/net40/three.dll", netResult.Items.Skip(1).First());
}
public CompatibilityPolicyViewModel(PackageReader reader)
{
_reader = reader;
Minimum = reader.GetRulesPropertyValueByName(CompatibilityPolicy, "minimum");
Maximum = reader.GetRulesPropertyValueByName(CompatibilityPolicy, "maximum");
Versions = reader.GetRulesPropertyValueByName(CompatibilityPolicy, "versions");
IsEditable = false;
SourceValueCompatibilityPolicyViewModel = new CompatibilityPolicyViewModel()
{
Minimum = reader.GetRulesSourcePropertyValueByName(CompatibilityPolicy, "minimum"),
Maximum = reader.GetRulesSourcePropertyValueByName(CompatibilityPolicy, "maximum"),
Versions = reader.GetRulesSourcePropertyValueByName(CompatibilityPolicy, "versions"),
IsEditable = true,
IsSource = true,
};
SourceString = reader.GetRulesSourceStringPropertyValueByName(CompatibilityPolicy);
SourceValueCompatibilityPolicyViewModel.PropertyChanged += EvaluatedChanged;
}
public void PackageFolderReader_Basic()
{
var packageNupkg = TestPackages.GetLegacyTestPackage();
var zip = new ZipArchive(packageNupkg.OpenRead());
PackageReader zipReader = new PackageReader(zip);
var folder = Path.Combine(packageNupkg.Directory.FullName, Guid.NewGuid().ToString());
var zipFile = new ZipArchive(File.OpenRead(packageNupkg.FullName));
zipFile.ExtractAll(folder);
var folderReader = new PackageFolderReader(folder);
Assert.Equal(zipReader.GetIdentity(), folderReader.GetIdentity(), new PackageIdentityComparer());
Assert.Equal(zipReader.GetLibItems().Count(), folderReader.GetLibItems().Count());
Assert.Equal(zipReader.GetReferenceItems().Count(), folderReader.GetReferenceItems().Count());
Assert.Equal(zipReader.GetReferenceItems().First().Items.First(), folderReader.GetReferenceItems().First().Items.First());
}
public LicenseViewModel(PackageReader reader)
{
_reader = reader;
License = reader.GetRulesPropertyValueByName(LicenseString, "license");
LicenseType = reader.GetRulesPropertyValueByName(LicenseString, "license-type");
LicenseUrl = reader.GetRulesPropertyValueByName(LicenseString, "license-url");
_sourceValueLicenseViewModel = new LicenseViewModel()
{
License =
reader.GetRulesSourcePropertyValueByName(LicenseString, "license"),
LicenseType =
reader.GetRulesSourcePropertyValueByName(LicenseString, "license-type"),
LicenseUrl =
reader.GetRulesSourcePropertyValueByName(LicenseString, "license-url"),
IsEditable = true,
IsSource = true,
};
SourceString = reader.GetRulesSourceStringPropertyValueByName(LicenseString);
SourceValueLicenseViewModel.PropertyChanged += EvaluatedChanged;
}
public ApplicationRoleViewModel(PackageReader reader)
{
_applicationCollection = new ObservableCollection<RoleItemViewModel>();
foreach (string parameter in reader.ReadParameters("application"))
{
var includeCollection =
new ObservableCollection<ItemViewModel>(reader.ApplicationIncludeList("application", parameter,
"include"));
var model = new RoleItemViewModel()
{
Label = "Application",
EditCollectionViewModel =
new EditCollectionViewModel(reader, includeCollection),
Name = parameter,
};
_applicationCollection.Add(model);
}
SourceString = reader.GetRulesSourceStringPropertyValueByName("application");
_applicationCollection.CollectionChanged +=
new System.Collections.Specialized.NotifyCollectionChangedEventHandler(FilesCollectionCollectionChanged);
}
public void PackageReader_NestedReferenceItemsMixed()
{
var zip = TestPackages.GetZip(TestPackages.GetLibEmptyFolderPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(3, groups.Count());
Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework);
Assert.Equal(2, groups[0].Items.Count());
Assert.Equal("lib/a.dll", groups[0].Items.ToArray()[0]);
Assert.Equal("lib/x86/b.dll", groups[0].Items.ToArray()[1]);
Assert.Equal(NuGetFramework.Parse("net40"), groups[1].TargetFramework);
Assert.Equal(2, groups[1].Items.Count());
Assert.Equal("lib/net40/test40.dll", groups[1].Items.ToArray()[0]);
Assert.Equal("lib/net40/x86/testx86.dll", groups[1].Items.ToArray()[1]);
Assert.Equal(NuGetFramework.Parse("net45"), groups[2].TargetFramework);
Assert.Equal(0, groups[2].Items.Count());
}
}
public void PackageReader_ReferencesWithoutGroups()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackageWithPre25References());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(3, groups.Count());
Assert.Equal(NuGetFramework.AnyFramework, groups[0].TargetFramework);
Assert.Equal(1, groups[0].Items.Count());
Assert.Equal("lib/test.dll", groups[0].Items.Single());
Assert.Equal(NuGetFramework.Parse("net40"), groups[1].TargetFramework);
Assert.Equal(1, groups[1].Items.Count());
Assert.Equal("lib/net40/test.dll", groups[1].Items.Single());
Assert.Equal(NuGetFramework.Parse("net451"), groups[2].TargetFramework);
Assert.Equal(1, groups[1].Items.Count());
Assert.Equal("lib/net451/test.dll", groups[2].Items.Single());
}
}
internal UTexture2D(PackageReader reader, Stream ubulk, long bulkOffset) : base(reader)
{
Serialize(reader, ubulk, bulkOffset);
}
internal static void Validate(PackageValidatorSettings packageValidatorSettings,
PackageReader packageReader,
bool logReplacement,
ValidationResults log,
ManifestReaderSettings manifestSettings,
bool fixLrmViolations,
out ManifestReader manifestReader)
{
ValidatorResources.Culture = Thread.CurrentThread.CurrentCulture;;
if (packageReader == null)
{
throw new ArgumentNullException("packageReader");
}
ValidationResults manifestLog;
XPathNavigator manifest;
packageReader.CreateManifestNavigator(packageValidatorSettings.LrmRequirementValidation, fixLrmViolations, out manifestLog, out manifest);
if (manifestLog != null)
{
foreach (ValidationResult result in manifestLog.Results)
{
log.AddResult(result);
}
}
manifestReader = new ManifestReader(packageReader, manifestSettings, packageValidatorSettings, logReplacement, log, manifest);
if (packageValidatorSettings.MlcRequirementValidation != ValidationBehavior.None)
{
int activityCount = 0;
if (manifestReader.Organizations.Count > 0)
{
foreach (OrganizationNodeReader nodeReader in manifestReader.Organizations)
{
activityCount += nodeReader.Activities.Count;
}
if (activityCount == 0)
{
ProcessError(packageValidatorSettings.MlcRequirementValidation,
ValidatorResources.MlcViolationActivityMissing,
log);
}
}
else
{
ProcessError(packageValidatorSettings.MlcRequirementValidation,
ValidatorResources.MlcViolationOrganizationMissing,
log);
}
}
ManifestValidator.Validate(manifestReader);
// Add all files in the manifest to a Dictionary
Dictionary <string, bool> manifestFilePaths = new Dictionary <string, bool>(StringComparer.OrdinalIgnoreCase);
foreach (ResourceNodeReader r in manifestReader.Resources.Values)
{
foreach (FileNodeReader fileNode in r.Files)
{
if (!fileNode.Location.IsAbsoluteUri)
{
// get the path component of the Location property, and URL decode the string
// so it is a proper file path.
string path = System.Web.HttpUtility.UrlDecode(RemoveQueryAndAnchor(fileNode.Location.OriginalString));
if (!manifestFilePaths.ContainsKey(path))
{
manifestFilePaths.Add(path, true);
}
}
}
}
ReadOnlyCollection <string> packageFilePaths = packageReader.GetFilePaths();
CheckManifestFiles(packageFilePaths, manifestFilePaths, log, packageValidatorSettings);
CheckPackageFiles(packageFilePaths, manifestFilePaths, log, packageValidatorSettings);
}
public void PackageReader_ContentNoFrameworks()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyContentPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetContentItems().ToArray();
Assert.Equal(1, groups.Count());
Assert.Equal(NuGetFramework.AnyFramework, groups.Single().TargetFramework);
Assert.Equal(3, groups.Single().Items.Count());
}
}
public UObject(PackageReader reader, bool structFallback) : this(reader, reader.ExportMap.Sum(e => e.SerialSize), structFallback)
{
}
// https://github.com/EpicGames/UnrealEngine/blob/bf95c2cbc703123e08ab54e3ceccdd47e48d224a/Engine/Source/Runtime/CoreUObject/Private/UObject/Class.cpp#L930
public UObject(PackageReader reader) : this(reader, reader.ExportMap.Sum(e => e.SerialSize), false)
{
}
public static void OnAssetLoadedImpl(string name, object asset, Dictionary <string, byte[]> userData)
{
if (!userData.TryGetValue(DataKey, out var bytes))
{
return;
}
Debug.Log($"Found custom effect data for {name}");
var propEffectsDict = new Dictionary <string, PropInfo.Effect[]>();
var vehicleEffectsDict = new Dictionary <string, VehicleInfo.Effect[]>();
using (var stream = new MemoryStream(bytes))
{
using (var reader = new PackageReader(stream))
{
var propEffectsDictCount = reader.ReadInt32();
for (var p = 0; p < propEffectsDictCount; p++)
{
var prefabName = reader.ReadString();
var effectCount = reader.ReadInt32();
var propEffects = new List <PropInfo.Effect>(effectCount);
for (var e = 0; e < effectCount; e++)
{
var effectName = reader.ReadString();
var propEffect = new PropInfo.Effect
{
m_effect = EffectCollection.FindEffect(effectName),
m_position = reader.ReadVector3(),
m_direction = reader.ReadVector3()
};
if (propEffect.m_effect != null)
{
propEffects.Add(propEffect);
Debug.LogError($"Adding effect \"{effectName}\" for ${prefabName}");
}
else
{
Debug.LogError($"Effect \"{effectName}\" not found while loading {prefabName}!");
}
}
propEffectsDict[prefabName] = propEffects.ToArray();
}
var vehicleEffectsDictCount = reader.ReadInt32();
for (var v = 0; v < vehicleEffectsDictCount; v++)
{
var prefabName = reader.ReadString();
var effectCount = reader.ReadInt32();
var propEffects = new List <VehicleInfo.Effect>(effectCount);
for (var e = 0; e < effectCount; e++)
{
var effectName = reader.ReadString();
var vehicleEffect = new VehicleInfo.Effect
{
m_effect = EffectCollection.FindEffect(effectName),
m_vehicleFlagsRequired = (Vehicle.Flags)reader.ReadInt32(),
m_vehicleFlagsForbidden = (Vehicle.Flags)reader.ReadInt32(),
m_parkedFlagsRequired = (VehicleParked.Flags)reader.ReadInt32(),
m_parkedFlagsForbidden = (VehicleParked.Flags)reader.ReadInt32()
};
if (vehicleEffect.m_effect != null)
{
propEffects.Add(vehicleEffect);
}
else
{
Debug.LogError($"Effect \"{effectName}\" not found while loading {prefabName}!");
}
}
vehicleEffectsDict[prefabName] = propEffects.ToArray();
}
}
}
if (asset is PropInfo propPrefab)
{
ApplyCustomEffects(propPrefab, propEffectsDict);
if (propPrefab.m_variations != null)
{
foreach (var variation in propPrefab.m_variations)
{
ApplyCustomEffects(variation.m_prop, propEffectsDict);
}
}
}
else if (asset is VehicleInfo vehiclePrefab)
{
ApplyCustomEffects(vehiclePrefab, vehicleEffectsDict);
if (vehiclePrefab.m_trailers != null)
{
foreach (var trailer in vehiclePrefab.m_trailers)
{
ApplyCustomEffects(trailer.m_info, vehicleEffectsDict);
}
}
}
}
internal FCompressedOffsetData(PackageReader reader)
{
OffsetData = reader.ReadTArray(() => reader.ReadInt32());
StripSize = reader.ReadInt32();
}
private LockFileTargetLibrary CreateLockFileTargetLibrary(LocalPackageInfo package, RestoreTargetGraph targetGraph, DefaultPackagePathResolver defaultPackagePathResolver, string correctedPackageName)
{
var lockFileLib = new LockFileTargetLibrary();
var framework = targetGraph.Framework;
var runtimeIdentifier = targetGraph.RuntimeIdentifier;
// package.Id is read from nuspec and it might be in wrong casing.
// correctedPackageName should be the package name used by dependency graph and
// it has the correct casing that runtime needs during dependency resolution.
lockFileLib.Name = correctedPackageName ?? package.Id;
lockFileLib.Version = package.Version;
IList <string> files;
var contentItems = new ContentItemCollection();
HashSet <string> referenceFilter = null;
using (var nupkgStream = File.OpenRead(package.ZipPath))
{
var packageReader = new PackageReader(nupkgStream);
files = packageReader.GetFiles().Select(p => p.Replace(Path.DirectorySeparatorChar, '/')).ToList();
contentItems.Load(files);
var dependencySet = packageReader.GetPackageDependencies().GetNearest(framework);
if (dependencySet != null)
{
var set = dependencySet.Packages;
if (set != null)
{
lockFileLib.Dependencies = set.ToList();
}
}
var referenceSet = packageReader.GetReferenceItems().GetNearest(framework);
if (referenceSet != null)
{
referenceFilter = new HashSet <string>(referenceSet.Items, StringComparer.OrdinalIgnoreCase);
}
// TODO: Remove this when we do #596
// ASP.NET Core isn't compatible with generic PCL profiles
if (!string.Equals(framework.Framework, FrameworkConstants.FrameworkIdentifiers.AspNetCore, StringComparison.OrdinalIgnoreCase)
&&
!string.Equals(framework.Framework, FrameworkConstants.FrameworkIdentifiers.DnxCore, StringComparison.OrdinalIgnoreCase))
{
var frameworkAssemblies = packageReader.GetFrameworkItems().GetNearest(framework);
if (frameworkAssemblies != null)
{
foreach (var assemblyReference in frameworkAssemblies.Items)
{
lockFileLib.FrameworkAssemblies.Add(assemblyReference);
}
}
}
}
var nativeCriteria = targetGraph.Conventions.Criteria.ForRuntime(targetGraph.RuntimeIdentifier);
var managedCriteria = targetGraph.Conventions.Criteria.ForFrameworkAndRuntime(framework, targetGraph.RuntimeIdentifier);
var compileGroup = contentItems.FindBestItemGroup(managedCriteria, targetGraph.Conventions.Patterns.CompileAssemblies, targetGraph.Conventions.Patterns.RuntimeAssemblies);
if (compileGroup != null)
{
lockFileLib.CompileTimeAssemblies = compileGroup.Items.Select(t => new LockFileItem(t.Path)).ToList();
}
var runtimeGroup = contentItems.FindBestItemGroup(managedCriteria, targetGraph.Conventions.Patterns.RuntimeAssemblies);
if (runtimeGroup != null)
{
lockFileLib.RuntimeAssemblies = runtimeGroup.Items.Select(p => new LockFileItem(p.Path)).ToList();
}
var resourceGroup = contentItems.FindBestItemGroup(managedCriteria, targetGraph.Conventions.Patterns.ResourceAssemblies);
if (resourceGroup != null)
{
lockFileLib.ResourceAssemblies = resourceGroup.Items.Select(ToResourceLockFileItem).ToList();
}
var nativeGroup = contentItems.FindBestItemGroup(nativeCriteria, targetGraph.Conventions.Patterns.NativeLibraries);
if (nativeGroup != null)
{
lockFileLib.NativeLibraries = nativeGroup.Items.Select(p => new LockFileItem(p.Path)).ToList();
}
// COMPAT: Support lib/contract so older packages can be consumed
var contractPath = "lib/contract/" + package.Id + ".dll";
var hasContract = files.Any(path => path == contractPath);
var hasLib = lockFileLib.RuntimeAssemblies.Any();
if (hasContract &&
hasLib &&
!framework.IsDesktop())
{
lockFileLib.CompileTimeAssemblies.Clear();
lockFileLib.CompileTimeAssemblies.Add(new LockFileItem(contractPath));
}
// Apply filters from the <references> node in the nuspec
if (referenceFilter != null)
{
// Remove anything that starts with "lib/" and is NOT specified in the reference filter.
// runtimes/* is unaffected (it doesn't start with lib/)
lockFileLib.RuntimeAssemblies = lockFileLib.RuntimeAssemblies.Where(p => !p.Path.StartsWith("lib/") || referenceFilter.Contains(p.Path)).ToList();
lockFileLib.CompileTimeAssemblies = lockFileLib.CompileTimeAssemblies.Where(p => !p.Path.StartsWith("lib/") || referenceFilter.Contains(p.Path)).ToList();
}
return(lockFileLib);
}
// https://github.com/EpicGames/UnrealEngine/blob/bf95c2cbc703123e08ab54e3ceccdd47e48d224a/Engine/Source/Runtime/CoreUObject/Private/UObject/Class.cpp#L930
public UObject(PackageReader reader) : this(reader, false)
{
}
private void WriteTargetsAndProps(PackageSpec project, List <RestoreTargetGraph> targetGraphs, NuGetv3LocalRepository repository)
{
// Get the runtime-independent graphs
var tfmGraphs = targetGraphs.Where(g => string.IsNullOrEmpty(g.RuntimeIdentifier)).ToList();
if (tfmGraphs.Count > 1)
{
var name = $"{project.Name}.nuget.targets";
var path = Path.Combine(project.BaseDirectory, name);
_log.LogInformation($"Generating MSBuild file {name}");
GenerateMSBuildErrorFile(path);
return;
}
var graph = tfmGraphs[0];
var pathResolver = new DefaultPackagePathResolver(repository.RepositoryRoot);
var targets = new List <string>();
var props = new List <string>();
foreach (var library in graph.Flattened.Distinct().OrderBy(g => g.Data.Match.Library))
{
var package = repository.FindPackagesById(library.Key.Name).FirstOrDefault(p => p.Version == library.Key.Version);
if (package != null)
{
var criteria = graph.Conventions.Criteria.ForFramework(graph.Framework);
var contentItemCollection = new ContentItemCollection();
using (var nupkgStream = File.OpenRead(package.ZipPath))
{
var reader = new PackageReader(nupkgStream);
contentItemCollection.Load(reader.GetFiles());
}
// Find MSBuild thingies
var buildItems = contentItemCollection.FindBestItemGroup(criteria, graph.Conventions.Patterns.MSBuildFiles);
if (buildItems != null)
{
// We need to additionally filter to items that are named "{packageId}.targets" and "{packageId}.props"
// Filter by file name here and we'll filter by extension when we add things to the lists.
var items = buildItems.Items
.Where(item => Path.GetFileNameWithoutExtension(item.Path).Equals(package.Id, StringComparison.OrdinalIgnoreCase))
.ToList();
targets.AddRange(items
.Select(c => c.Path)
.Where(path => Path.GetExtension(path).Equals(".targets", StringComparison.OrdinalIgnoreCase))
.Select(path => Path.Combine(pathResolver.GetPackageDirectory(package.Id, package.Version), path.Replace('/', Path.DirectorySeparatorChar))));
props.AddRange(items
.Select(c => c.Path)
.Where(path => Path.GetExtension(path).Equals(".props", StringComparison.OrdinalIgnoreCase))
.Select(path => Path.Combine(pathResolver.GetPackageDirectory(package.Id, package.Version), path.Replace('/', Path.DirectorySeparatorChar))));
}
}
}
// Generate the files as needed
var targetsName = $"{project.Name}.nuget.targets";
var propsName = $"{project.Name}.nuget.props";
var targetsPath = Path.Combine(project.BaseDirectory, targetsName);
var propsPath = Path.Combine(project.BaseDirectory, propsName);
if (targets.Any())
{
_log.LogInformation($"Generating MSBuild file {targetsName}");
GenerateImportsFile(repository, targetsPath, targets);
}
else if (File.Exists(targetsPath))
{
File.Delete(targetsPath);
}
if (props.Any())
{
_log.LogInformation($"Generating MSBuild file {propsName}");
GenerateImportsFile(repository, propsPath, props);
}
else if (File.Exists(propsPath))
{
File.Delete(propsPath);
}
}
internal USoundWave(PackageReader reader, Stream ubulk, long ubulkOffset) : base(reader)
{
Serialize(reader, ubulk, ubulkOffset);
}
// Binary serialization, tagged property serialization otherwise
// https://github.com/EpicGames/UnrealEngine/blob/7d9919ac7bfd80b7483012eab342cb427d60e8c9/Engine/Source/Runtime/CoreUObject/Private/UObject/Class.cpp#L2146
internal UScriptStruct(PackageReader reader, FName structName) : this(reader, structName.String)
{
}
private void SaveSavegameDatabase()
{
var packageReader = new PackageReader(storyFilePath.Text);
Package package = packageReader.Read();
AbstractFileInfo globalsLsf = package.Files.FirstOrDefault(p => p.Name == "globals.lsf");
if (globalsLsf == null)
{
MessageBox.Show("The specified package is not a valid savegame (globals.lsf not found)", "Load Failed", MessageBoxButtons.OK, MessageBoxIcon.Error);
return;
}
// Load globals.lsf
Resource resource;
Stream rsrcStream = globalsLsf.MakeStream();
try
{
using (var rsrcReader = new LSFReader(rsrcStream))
{
resource = rsrcReader.Read();
}
}
finally
{
globalsLsf.ReleaseStream();
}
// Save story resource and pack into the Story.Story attribute in globals.lsf
using (var storyStream = new MemoryStream())
{
var storyWriter = new StoryWriter();
storyWriter.Write(storyStream, _story);
LSLib.LS.Node storyNode = resource.Regions["Story"].Children["Story"][0];
storyNode.Attributes["Story"].Value = storyStream.ToArray();
}
// Save globals.lsf
var rewrittenStream = new MemoryStream();
FileVersion version;
if (OriginalSavePakVersion == PackageVersion.V15)
{
version = FileVersion.VerBG3;
}
else
{
version = FileVersion.VerExtendedNodes;
}
var rsrcWriter = new LSFWriter(rewrittenStream, version);
rsrcWriter.Write(resource);
rewrittenStream.Seek(0, SeekOrigin.Begin);
// Re-package global.lsf
var rewrittenPackage = new Package();
StreamFileInfo globalsRepacked = StreamFileInfo.CreateFromStream(rewrittenStream, "globals.lsf");
rewrittenPackage.Files.Add(globalsRepacked);
List <AbstractFileInfo> files = package.Files.Where(x => x.Name != "globals.lsf").ToList();
rewrittenPackage.Files.AddRange(files);
using (var packageWriter = new PackageWriter(rewrittenPackage, $"{storyFilePath.Text}.tmp"))
{
packageWriter.Version = OriginalSavePakVersion;
packageWriter.Compression = CompressionMethod.Zlib;
packageWriter.CompressionLevel = CompressionLevel.DefaultCompression;
packageWriter.Write();
}
rewrittenStream.Dispose();
packageReader.Dispose();
// Create a backup of the original .lsf
string backupPath = $"{storyFilePath.Text}.backup";
if (!File.Exists(backupPath))
{
File.Move(storyFilePath.Text, backupPath);
}
else
{
File.Delete(storyFilePath.Text);
}
// Replace original savegame with new one
File.Move($"{storyFilePath.Text}.tmp", storyFilePath.Text);
}
internal FFrameNumber(PackageReader reader)
{
Value = reader.ReadFloat();
}
internal FPackageIndex(PackageReader reader)
{
Index = reader.ReadInt32();
Reader = reader;
}
internal TMovieSceneEvaluationTree(PackageReader reader)
{
BaseTree = new FMovieSceneEvaluationTree(reader);
Data = new TEvaluationTreeEntryContainer <T>(reader);
}
public UObject(PackageReader reader, long maxSize) : this(reader, maxSize, false)
{
}
private void InstallSitecorePackage([NotNull] string fileName)
{
Context.SetActiveSite("shell");
using (new SecurityDisabler())
{
using (new ProxyDisabler())
{
using (new SyncOperationContext())
{
var context = new SimpleProcessingContext();
var defaultItemInstallerEvents = new DefaultItemInstallerEvents(new BehaviourOptions(InstallMode.Overwrite, MergeMode.Clear));
context.AddAspect(defaultItemInstallerEvents);
var defaultFileInstallerEvents = new DefaultFileInstallerEvents(true);
context.AddAspect(defaultFileInstallerEvents);
var installer = new Installer();
installer.InstallPackage(FileUtil.MapPath(fileName), context);
var packageReader = new PackageReader(FileUtil.MapPath(fileName));
var previewContext = Installer.CreatePreviewContext();
var view = new MetadataView(previewContext);
var sink = new MetadataSink(view);
sink.Initialize(previewContext);
packageReader.Populate(sink);
installer.ExecutePostStep(view.PostStep, previewContext);
}
}
}
}
internal StrProperty(PackageReader reader, FPropertyTag tag)
{
Value = reader.ReadFString();
}
internal static void DeleteFiles(IMSBuildNuGetProjectSystem msBuildNuGetProjectSystem,
ZipArchive zipArchive,
IEnumerable <string> otherPackagesPath,
FrameworkSpecificGroup frameworkSpecificGroup,
IDictionary <FileTransformExtensions, IPackageFileTransformer> fileTransformers)
{
var packageTargetFramework = frameworkSpecificGroup.TargetFramework;
IPackageFileTransformer transformer;
var directoryLookup = frameworkSpecificGroup.Items.ToLookup(
p => Path.GetDirectoryName(ResolveTargetPath(msBuildNuGetProjectSystem,
fileTransformers,
fte => fte.UninstallExtension,
GetEffectivePathForContentFile(packageTargetFramework, p),
out transformer)));
// Get all directories that this package may have added
var directories = from grouping in directoryLookup
from directory in FileSystemUtility.GetDirectories(grouping.Key, altDirectorySeparator: false)
orderby directory.Length descending
select directory;
// Remove files from every directory
foreach (var directory in directories)
{
var directoryFiles = directoryLookup.Contains(directory) ? directoryLookup[directory] : Enumerable.Empty <string>();
if (!Directory.Exists(Path.Combine(msBuildNuGetProjectSystem.ProjectFullPath, directory)))
{
continue;
}
try
{
foreach (var file in directoryFiles)
{
if (IsEmptyFolder(file))
{
continue;
}
// Resolve the path
string path = ResolveTargetPath(msBuildNuGetProjectSystem,
fileTransformers,
fte => fte.UninstallExtension,
GetEffectivePathForContentFile(packageTargetFramework, file),
out transformer);
if (msBuildNuGetProjectSystem.IsSupportedFile(path))
{
if (transformer != null)
{
// TODO: use the framework from packages.config instead of the current framework
// which may have changed during re-targeting
NuGetFramework projectFramework = msBuildNuGetProjectSystem.TargetFramework;
List <InternalZipFileInfo> matchingFiles = new List <InternalZipFileInfo>();
foreach (var otherPackagePath in otherPackagesPath)
{
using (var otherPackageStream = File.OpenRead(otherPackagePath))
{
var otherPackageZipArchive = new ZipArchive(otherPackageStream);
var otherPackageZipReader = new PackageReader(otherPackageZipArchive);
// use the project framework to find the group that would have been installed
var mostCompatibleContentFilesGroup = GetMostCompatibleGroup(projectFramework, otherPackageZipReader.GetContentItems(), altDirSeparator: true);
if (mostCompatibleContentFilesGroup != null && IsValid(mostCompatibleContentFilesGroup))
{
foreach (var otherPackageItem in mostCompatibleContentFilesGroup.Items)
{
if (GetEffectivePathForContentFile(packageTargetFramework, otherPackageItem)
.Equals(GetEffectivePathForContentFile(packageTargetFramework, file), StringComparison.OrdinalIgnoreCase))
{
matchingFiles.Add(new InternalZipFileInfo(otherPackagePath, otherPackageItem));
}
}
}
}
}
try
{
var zipArchiveFileEntry = zipArchive.GetEntry(PathUtility.ReplaceDirSeparatorWithAltDirSeparator(file));
if (zipArchiveFileEntry != null)
{
transformer.RevertFile(zipArchiveFileEntry, path, matchingFiles, msBuildNuGetProjectSystem);
}
}
catch (Exception e)
{
msBuildNuGetProjectSystem.NuGetProjectContext.Log(MessageLevel.Warning, e.Message);
}
}
else
{
var zipArchiveFileEntry = zipArchive.GetEntry(PathUtility.ReplaceDirSeparatorWithAltDirSeparator(file));
if (zipArchiveFileEntry != null)
{
DeleteFileSafe(path, zipArchiveFileEntry.Open, msBuildNuGetProjectSystem);
}
}
}
}
// If the directory is empty then delete it
if (!GetFilesSafe(msBuildNuGetProjectSystem, directory).Any() &&
!GetDirectoriesSafe(msBuildNuGetProjectSystem, directory).Any())
{
DeleteDirectorySafe(msBuildNuGetProjectSystem, directory, recursive: false);
}
}
finally
{
}
}
}
public void PackageReader_MinClientVersion(string minClientVersion, string expected)
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackageMinClient(minClientVersion));
using (PackageReader reader = new PackageReader(zip))
{
var version = reader.GetMinClientVersion();
Assert.Equal(expected, version.ToNormalizedString());
}
}
internal DoubleProperty(PackageReader reader)
{
Position = reader.Position;
Value = reader.ReadDouble();
}
public void PackageReader_ContentWithFrameworks()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyContentPackageWithFrameworks());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetContentItems().ToArray();
Assert.Equal(3, groups.Count());
}
}
protected override void ProcessRecord()
{
var fileName = Path;
PerformInstallAction(() =>
{
if (!System.IO.Path.IsPathRooted(fileName))
{
var packagePath = FullPackagePath(fileName);
WriteVerbose($"Path is not rooted. Updating to {packagePath}.");
if (!FileUtil.Exists(packagePath))
{
packagePath =
System.IO.Path.GetFullPath(
System.IO.Path.Combine(
CurrentProviderLocation("FileSystem").ProviderPath, fileName));
WriteVerbose($"Path could not be found. Updating to {packagePath}.");
if (!FileUtil.Exists(packagePath))
{
WriteVerbose("Path still could not be found. Check that the file actually exists in the Sitecore package directory.");
}
}
fileName = packagePath;
}
if (ShouldProcess(fileName, "Install package"))
{
var indexSetting = Sitecore.Configuration.Settings.Indexing.Enabled;
if (DisableIndexing.IsPresent)
{
Sitecore.Configuration.Settings.Indexing.Enabled = false;
}
try
{
IProcessingContext context = new SimpleProcessingContext();
IItemInstallerEvents instance1 = new DefaultItemInstallerEvents(new BehaviourOptions(InstallMode, MergeMode));
context.AddAspect(instance1);
IFileInstallerEvents instance2 = new DefaultFileInstallerEvents(true);
context.AddAspect(instance2);
var installer = new Installer();
installer.InstallPackage(fileName, context);
ISource<PackageEntry> source = new PackageReader(fileName);
var previewContext = Installer.CreatePreviewContext();
var view = new MetadataView(previewContext);
var metadataSink = new MetadataSink(view);
metadataSink.Initialize(previewContext);
source.Populate(metadataSink);
installer.ExecutePostStep(view.PostStep, previewContext);
}
finally
{
if (DisableIndexing.IsPresent)
{
Sitecore.Configuration.Settings.Indexing.Enabled = indexSetting;
}
}
}
});
}
public void PackageReader_NoReferences()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
Assert.Equal(3, groups.Count());
Assert.Equal(4, groups.SelectMany(e => e.Items).Count());
}
}
public void PackageReader_EmptyLibFolder()
{
var zip = TestPackages.GetZip(TestPackages.GetLibEmptyFolderPackage());
using (PackageReader reader = new PackageReader(zip))
{
var groups = reader.GetReferenceItems().ToArray();
var emptyGroup = groups.Where(g => g.TargetFramework == NuGetFramework.ParseFolder("net45")).Single();
Assert.Equal(0, emptyGroup.Items.Count());
}
}
public void PackageReader_SupportedFrameworks()
{
var zip = TestPackages.GetZip(TestPackages.GetLegacyTestPackage());
using (PackageReader reader = new PackageReader(zip))
{
string[] frameworks = reader.GetSupportedFrameworks().Select(f => f.DotNetFrameworkName).ToArray();
Assert.Equal("Any,Version=v0.0", frameworks[0]);
Assert.Equal(".NETFramework,Version=v4.0", frameworks[1]);
Assert.Equal(".NETFramework,Version=v4.5", frameworks[2]);
Assert.Equal(3, frameworks.Length);
}
}
internal static void DeserializeMeshFilter(Package package, MeshFilter meshFilter, PackageReader reader)
{
string checksum = reader.ReadString();
Mesh mesh;
if (Sharing.instance.shareMeshes && Sharing.instance.meshes.TryGetValue(checksum, out mesh))
{
Sharing.instance.meshit++;
}
else
{
mesh = PackageManager.FindAssetByChecksum(checksum).Instantiate <Mesh>();
Sharing.instance.meshes[checksum] = mesh;
Sharing.instance.mesload++;
}
meshFilter.sharedMesh = mesh;
}
/// <summary>
/// Deploys an update to an existing model from a specified package.
/// </summary>
/// <param name="packageFile">File name of the input package.</param>
/// <param name="versionName">Name of the version of master data to update.</param>
private static void DeployUpdate(string packageFile, string versionName)
{
Console.WriteLine("Deploying package {0}, updating version {1} of the master data", packageFile, versionName);
ModelDeployer deployer = new ModelDeployer();
ModelReader reader = new ModelReader();
// Deploy it.
Warnings errorsAsWarnings = null;
using (var package = new PackageReader(packageFile))
{
// Get the ID for the model named in the package
var firstPackage = package.FirstOrDefault();
if (firstPackage != null)
{
Identifier modelId = GetModelIdentifier(reader, firstPackage.ModelId.Name);
// Now get the version Id for that model and the given version name.
reader.ModelId = modelId;
}
Identifier versionId = GetVersionIdentifier(reader, versionName);
errorsAsWarnings = deployer.DeployUpdate(package.GetEnumerator(), true, versionId);
}
Console.WriteLine("Package was deployed with {0} warnings", errorsAsWarnings.Count);
}
public static bool RenameSave(string pathToSave, string newName)
{
try
{
string baseOldName = Path.GetFileNameWithoutExtension(pathToSave);
string baseNewName = Path.GetFileNameWithoutExtension(newName);
string output = Path.ChangeExtension(Path.Combine(Path.GetDirectoryName(pathToSave), newName), ".lsv");
using (var reader = new PackageReader(pathToSave))
{
Package package = reader.Read();
AbstractFileInfo saveScreenshotImage = package.Files.FirstOrDefault(p => p.Name.EndsWith(".png"));
if (saveScreenshotImage != null)
{
saveScreenshotImage.Name = saveScreenshotImage.Name.Replace(Path.GetFileNameWithoutExtension(saveScreenshotImage.Name), baseNewName);
DivinityApp.Log($"Renamed internal screenshot '{saveScreenshotImage.Name}' in '{output}'.");
}
// Edit the saved date in the meta.lsf to avoid "corruption" messages
/*
* AbstractFileInfo metaFile = package.Files.FirstOrDefault(p => p.Name == "meta.lsf");
* if (metaFile != null)
* {
* Resource resource;
* System.IO.MemoryStream ms = null;
* System.IO.Stream rsrcStream = null;
* try
* {
* rsrcStream = metaFile.MakeStream();
* using (var rsrcReader = new LSFReader(rsrcStream))
* {
* resource = rsrcReader.Read();
*
* if (resource != null)
* {
* var saveTimeNode = resource.FindNode("SaveTime");
*
* if (saveTimeNode != null)
* {
* NodeAttribute yearAtt = null;
* NodeAttribute monthAtt = null;
* NodeAttribute dayAtt = null;
* NodeAttribute hoursAtt = null;
* NodeAttribute minutesAtt = null;
* NodeAttribute secondsAtt = null;
* NodeAttribute millisecondsAtt = null;
*
* saveTimeNode.Attributes.TryGetValue("Year", out yearAtt);
* saveTimeNode.Attributes.TryGetValue("Month", out monthAtt);
* saveTimeNode.Attributes.TryGetValue("Day", out dayAtt);
* saveTimeNode.Attributes.TryGetValue("Hours", out hoursAtt);
* saveTimeNode.Attributes.TryGetValue("Minutes", out minutesAtt);
* saveTimeNode.Attributes.TryGetValue("Seconds", out secondsAtt);
* saveTimeNode.Attributes.TryGetValue("Milliseconds", out millisecondsAtt);
*
* var time = DateTime.Now;
*
* DivinityApp.LogMessage($"Year: {yearAtt.Type}");
* DivinityApp.LogMessage($"Month: {monthAtt.Type}");
* DivinityApp.LogMessage($"Day: {dayAtt.Type}");
* DivinityApp.LogMessage($"Hours: {hoursAtt.Type}");
* DivinityApp.LogMessage($"Minutes: {minutesAtt.Type}");
* DivinityApp.LogMessage($"Seconds: {secondsAtt.Type}");
* DivinityApp.LogMessage($"Milliseconds: {millisecondsAtt.Type}");
*
* yearAtt.Value = (Byte)time.Year;
* monthAtt.Value = (Byte)time.Month;
* dayAtt.Value = (Byte)time.Day;
* hoursAtt.Value = (Byte)time.Hour;
* minutesAtt.Value = (Byte)time.Minute;
* secondsAtt.Value = (Byte)time.Second;
* millisecondsAtt.Value = (UInt16)time.Millisecond;
*
* DivinityApp.LogMessage($"Updated SaveTime in save's meta.lsf.");
* }
* else
* {
* DivinityApp.LogMessage($"Couldn't find SaveTime node '{String.Join(";", resource.Regions.Values.First().Children.Keys)}'.");
* }
*
* ms = new System.IO.MemoryStream(new byte[4096], true);
* var rscrWriter = new LSFWriter(ms, FileVersion.CurrentVersion);
* rscrWriter.Write(resource);
* ms.Position = 0;
* var data = ms.ToArray();
*
* if (!ms.CanRead) DivinityApp.LogMessage("MemoryStream is not readable!");
* if(!ms.CanWrite) DivinityApp.LogMessage("MemoryStream is not writable!");
* if(!rsrcStream.CanRead) DivinityApp.LogMessage("rsrcStream is not readable!");
* if(!rsrcStream.CanWrite) DivinityApp.LogMessage("rsrcStream is not writable!");
*
* rsrcStream.Write(data, 0, data.Length);
* ms.Close();
* }
* }
* }
* finally
* {
* if (metaFile != null) metaFile.ReleaseStream();
* if (ms != null) ms.Dispose();
* if (rsrcStream != null) rsrcStream.Dispose();
* }
* }
*/
using (var writer = new PackageWriter(package, output))
{
writer.Version = Package.CurrentVersion;
writer.Compression = LSLib.LS.Enums.CompressionMethod.Zlib;
writer.CompressionLevel = CompressionLevel.DefaultCompression;
writer.Write();
}
File.SetLastWriteTime(output, File.GetLastWriteTime(pathToSave));
File.SetLastAccessTime(output, File.GetLastAccessTime(pathToSave));
return(true);
}
}
catch (Exception ex)
{
DivinityApp.Log($"Failed to rename save: {ex}");
}
return(false);
}
internal FloatProperty(PackageReader reader, FPropertyTag tag)
{
Value = reader.ReadFloat();
}
internal static void DeserializeMeshRenderer(Package package, MeshRenderer renderer, PackageReader reader)
{
int count = reader.ReadInt32();
Material[] materials = new Material[count];
for (int i = 0; i < count; i++)
{
string checksum = reader.ReadString();
Material material;
if (!Sharing.instance.materials.TryGetValue(checksum, out material))
{
material = PackageManager.FindAssetByChecksum(checksum).Instantiate <Material>();
Sharing.instance.materials[checksum] = material;
Sharing.instance.matload++;
}
else
{
Sharing.instance.mathit++;
}
materials[i] = material;
}
renderer.sharedMaterials = materials;
}
internal Int16Property(PackageReader reader)
{
Position = reader.Position;
Value = reader.ReadInt16();
}
internal FPackageIndex(PackageReader reader, int index)
{
Index = index;
Reader = reader;
}
/// <summary>
/// Deploys a copy of a model from a package, with a new name.
/// </summary>
/// <param name="packageFile">File name of the input package.</param>
/// <param name="modelName">New name for the model being deployed.</param>
private static void DeployNew(string packageFile, string modelName)
{
Console.WriteLine("Deploying package {0} using new model name {1}", packageFile, modelName);
ModelDeployer deployer = new ModelDeployer();
// Deploy the package.
Warnings errorsAsWarnings = null;
using (var package = new PackageReader(packageFile))
{
Identifier newId = null;
errorsAsWarnings = deployer.DeployNew(package.GetEnumerator(), modelName, out newId);
}
Console.WriteLine("Package was deployed with {0} warnings", errorsAsWarnings.Count);
}
internal FLevelSequenceLegacyObjectReference(PackageReader reader)
{
ObjectId = new FUniqueObjectGuid(reader);
ObjectPath = reader.ReadFString();
}
internal UInt32Property(PackageReader reader, FPropertyTag tag)
{
Position = reader.Position;
Value = reader.ReadUInt32();
}
internal Transform(PackageReader reader)
{
SourceText = new FText(reader);
TransformType = (ETransformType)reader.ReadByte();
}
internal ObjectProperty(PackageReader reader, FPropertyTag tag)
{
Value = new FPackageIndex(reader);
}
internal TextProperty(PackageReader reader, FPropertyTag tag)
{
Value = new FText(reader);
}
