private void ValidateVersion(ManifestData manifestData, Action <SemVersion, VersionTag> lifecycleVersionValidator)
{
// Check package version, make sure it's a valid SemVer string.
SemVersion packageVersionNumber;
if (!SemVersion.TryParse(manifestData.version, out packageVersionNumber))
{
AddError("In package.json, \"version\" needs to be a valid \"Semver\". {0}", ErrorDocumentation.GetLinkMessage(k_DocsFilePath, "version-needs-to-be-a-valid-semver"));
return;
}
VersionTag versionTag;
try
{
versionTag = VersionTag.Parse(packageVersionNumber.Prerelease);
}
catch (ArgumentException e)
{
AddError("In package.json, \"version\" doesn't follow our lifecycle rules. {0}. {1}", e.Message, ErrorDocumentation.GetLinkMessage(k_DocsFilePath, "version-is-invalid-tag-must-follow-lifecycle-rules"));
return;
}
lifecycleVersionValidator(packageVersionNumber, versionTag);
ValidateVersionAbilityToPromote(packageVersionNumber, versionTag, manifestData);
}
protected void WriteList(ManifestData Data, IEnumerable<Element> list, string listName, string itemName)
{
Data.Writer.WriteStartElement(listName);
foreach (var item in list)
Data.WriteElement(itemName, "name", item.Name);
Data.Writer.WriteEndElement();
}
public override void Write(ManifestData Data)
{
Data.Writer.WriteStartElement(xmlName);
foreach (var item in Bemerkungen)
item.Write(Data, "bemerkung");
Data.Writer.WriteEndElement();
}
public void ReadManifestPropertiesTest()
{
var m = new ManifestData
{
Desc = "desc",
Heading = "heading",
PubName = "pubname",
Delta = true,
HasUserDefinedFields = true,
Hydration = "hydration",
Fields = new[] { new ManifestData.ManifestField("desc2", "heading2", 1, "pubname2", "type2") }
};
Assert.AreEqual("desc", m.Desc);
Assert.AreEqual("heading", m.Heading);
Assert.AreEqual("pubname", m.PubName);
Assert.AreEqual("hydration", m.Hydration);
Assert.IsTrue(m.Delta);
Assert.IsTrue(m.HasUserDefinedFields);
Assert.AreEqual("desc2", m.Fields[0].Desc);
Assert.AreEqual("heading2", m.Fields[0].Heading);
Assert.AreEqual("pubname2", m.Fields[0].PubName);
Assert.AreEqual("type2", m.Fields[0].Type);
Assert.AreEqual(1, m.Fields[0].Ordinal);
}
private void ValidateManifestMarshalling(ManifestData manifestData)
{
foreach (var marshallError in manifestData.decodingErrors)
{
AddError(marshallError.Message);
}
}
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
WaffenFertigkeit = reader.getFertigkeit("fertigkeit");
Zweihand = reader.getBoolean("zweihand");
Schadenstyp = reader.Universe.Schadenstypen.GetElement(reader.getString("schadenstyp"));
}
public static CharakterMan getChara(string name)
{
Charakter c = new Charakter(name, 0, "Standard");
ManifestData md = new ManifestData(u);
md.SetReader("../../Universe/Charakter/Charakter " + name + ".xml");
c.Init(md);
return (CharakterMan)c.Create(md);
}
public CharakterWerte(ManifestData Data, string Name, string xmlName)
: this(Name, xmlName, Data.Universe)
{
if (!Data.Reader.IsStartElement(xmlName))
throw new NotImplementedException();
while (Data.NextElement())
ReadElement(Data);
Data.End(xmlName);
}
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
Gewicht = reader.getFloat("gewicht");
Bedingung = Bedingung.Parse(reader.getString("bedingung"));
Art = (Kategorie)Enum.Parse(typeof(Kategorie), reader.FlatName, true);
Buffs = reader.GetBuffs();
Boni = reader.getFertigkeiten("boni");
}
public static void LoadData()
{
string strData = System.IO.File.ReadAllText(AssetBundleConfig.PrjRelativeDepsPath);
_manifestData = JsonMapper.ToObject <ManifestData>(strData.Trim());
foreach (var data in _manifestData._assetsMap)
{
UnityEditor.AssetImporter.GetAtPath(data.Key).assetBundleName = data.Value;
}
}
private void ValidateUnityAuthor(ManifestData manifestData)
{
if (manifestData.author != null)
{
// make sure it is not present in order to have a unified presentation of the author for all of our packages
AddError("A Unity package must not have an author field. Please remove the field. {0}",
ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath,
"a_unity_package_must_not_have_an_author_field"));
}
}
private void WriteExtension(XmlWriter writer, string extensionId, ManifestData manifestData)
{
writer.WriteStartElement("BundleExtension");
writer.WriteAttributeString("Id", extensionId);
manifestData.Write(writer);
writer.WriteEndElement();
}
public override void Read(ManifestData data, int ID)
{
base.Read(data, ID);
Kosten = data.getAttribute("kosten");
string s = data.getString("attribut");
if (s.Length > 0)
Attribut = data.Attribute.GetElement(s);
Rettungswurf = data.getBoolean("rettungswurf");
Kategorien = data.getStrings("kategorien");
}
private void ValidateVersion(ManifestData manifestData)
{
SemVersion version;
// Check package version, make sure it's a valid SemVer string.
if (!SemVersion.TryParse(manifestData.version, out version))
{
AddError("In package.json, \"version\" needs to be a valid \"Semver\". {0}", ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "version-needs-to-be-a-valid-semver"));
}
}
public static void Clear()
{
if (_manifestData == null)
{
_manifestData = new ManifestData();
}
else
{
_manifestData._assetsMap.Clear();
}
}
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
reader.NextElement();
BachelorKlassen = reader.Universe.BachelorKlassen.GetElemente(reader.ReadAufzahlung());
reader.NextElement();
reader.NextElement();
MasterKlassen = reader.Universe.MasterKlassen.GetElemente(reader.ReadAufzahlung());
reader.NextElement();
reader.NextElement();
}
private void ValidateAuthor(ManifestData manifestData)
{
if (manifestData.IsAuthoredByUnity())
{
ValidateUnityAuthor(manifestData);
}
else
{
ValidateNonUnityAuthor(manifestData);
}
}
protected void AddUnityAuthoredConditionalError(ManifestData manifest, string message)
{
if (manifest.IsAuthoredByUnity())
{
AddError(message);
}
else
{
AddWarning(message);
}
}
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
Pro = ProObjekt.ProNothing;
Bedingung = Bedingung.Parse(reader.getString("bedingung"));
foreach (var item in Enum.GetNames(typeof(ProObjekt)))
if (Flags.Contains(item))
Pro = (ProObjekt)Enum.Parse(typeof(ProObjekt), item);
Fertigkeiten = reader.Fertigkeiten.GetElemente(reader.getStrings("fertigkeiten"));
InitiativeFertigkeit = reader.getFertigkeit("initiativefertigkeit");
InitiativeWert = reader.getInt("initiativewert");
}
public async Task ReadManifestAsync()
{
var setting = ManifestData.ReadManifestFileSystem(UnitTestInitializeCsv.GetTestPath("training_relation.manifest.json"));
Assert.AreEqual(false, setting.HasFieldHeader);
Assert.AreEqual(19, setting.Columns.Count());
using (var reader = new CsvFileReader(setting.CsvFile(), null))
{
await reader.OpenAsync(UnitTestInitializeCsv.Token);
Assert.AreEqual("object_id", reader.GetColumn(0).Name);
reader.Read();
}
}
public override bool Execute()
{
var serializer = new DataContractJsonSerializer(typeof(ManifestData));
ManifestData manifest = null;
using (var tempFile = File.OpenRead(ManifestPath))
{
manifest = (ManifestData)serializer.ReadObject(tempFile);
}
System.Threading.Tasks.Parallel.ForEach(manifest.FilesToCompress, (file) =>
{
var inputPath = file.Source;
var inputSource = file.InputSource;
var targetCompressionPath = file.Target;
if (!File.Exists(inputSource))
{
Log.LogMessage($"Skipping '{inputPath}' because '{inputSource}' does not exist.");
return;
}
if (File.Exists(targetCompressionPath) && File.GetLastWriteTimeUtc(inputSource) < File.GetLastWriteTimeUtc(targetCompressionPath))
{
// Incrementalism. If input source doesn't exist or it exists and is not newer than the expected output, do nothing.
Log.LogMessage($"Skipping '{inputPath}' because '{targetCompressionPath}' is newer than '{inputSource}'.");
return;
}
try
{
Directory.CreateDirectory(Path.GetDirectoryName(targetCompressionPath));
using var sourceStream = File.OpenRead(inputPath);
using var fileStream = new FileStream(targetCompressionPath, FileMode.Create);
using var stream = new GZipStream(fileStream, CompressionLevel.Optimal);
sourceStream.CopyTo(stream);
}
catch (Exception e)
{
Log.LogErrorFromException(e);
throw;
}
});
return(!Log.HasLoggedErrors);
}
public override void ReadElement(ManifestData Data)
{
int ID = 0;
Data.Section(xmlName, () =>
{
if (Data.FlatName != "bemerkung")
throw new NotImplementedException();
Bemerkung bem = new Bemerkung();
bem.Read(Data, ID++);
Bemerkungen.Add(bem);
Data.NextElement();
});
}
public async Task ReadManifestZip()
{
var setting = ManifestData.ReadManifestZip(UnitTestInitializeCsv.GetTestPath("ces_xxx_v879548171_lo_exempt_status_reason_approver_local_full.zip"));
Assert.AreEqual(false, setting.HasFieldHeader);
Assert.AreEqual(3, setting.Columns.Count());
using (var reader = new CsvFileReader(setting.CsvFile(), null))
{
await reader.OpenAsync(UnitTestInitializeCsv.Token);
Assert.AreEqual("lesrlA_reason_id", reader.GetColumn(0).Name);
reader.Read();
Assert.AreEqual("Other", reader.GetValue(1));
}
}
private ManifestData GetBundleExtensionManifestData(string extensionId)
{
if (!Common.IsIdentifier(extensionId))
{
throw new ArgumentException($"'{extensionId}' is not a valid extensionId");
}
if (!this.BundleExtensionDataById.TryGetValue(extensionId, out var manifestData))
{
manifestData = new ManifestData();
this.BundleExtensionDataById.Add(extensionId, manifestData);
}
return(manifestData);
}
/// <summary>
/// Verify all signatures in the JAR
/// </summary>
/// <param name="jar">JAR to verify</param>
/// <param name="centralManifest">the main MANIFEST.MF</param>
/// <param name="signatures">the set of signatures to verify</param>
/// <param name="certificates">the set of permitted certificates we verify against</param>
/// <returns>true if all signatures verify as valid - otherwise false</returns>
public bool Verify(
IJar jar,
ManifestData centralManifest,
List <Signature> signatures,
IVerificationCertificates certificates)
{
if (jar == null)
{
throw new ArgumentNullException(nameof(jar));
}
if (centralManifest == null)
{
throw new ArgumentNullException(nameof(centralManifest));
}
if (certificates == null)
{
throw new ArgumentNullException(nameof(certificates));
}
if (!signatures.Any())
{
return(false);
}
foreach (Signature sig in signatures)
{
ManifestData signFile = _loader.Load(jar, sig.ManifestPath);
Log.Message($"Signature {sig.BaseName} @ {sig.ManifestPath} with block {sig.Block.Path} type {sig.Block.Type}");
// Sign file hash mismatch
if (!VerifyManifestHashes(centralManifest, signFile))
{
return(false);
}
// Ensure we actually have a certificate to verify against
if (!certificates.Contains(sig.BaseName))
{
throw new MissingCertificateException($"Signature with base name {sig.BaseName} must have a matching certificate " +
$"supplied in order to verify");
}
}
return(signatures.All(s => VerifyPKCS7(jar, s, certificates.Get(s.BaseName))));
}
private void ReadManifests(Options options)
{
if (!options.DontReadManifests)
{
using (var s = m_compression.OpenRead(MANIFEST_FILENAME))
{
if (s == null)
{
throw new InvalidManifestException("No manifest file found in volume");
}
using (var fs = new StreamReader(s, ENCODING))
ManifestData.VerifyManifest(fs.ReadToEnd(), m_blocksize, options.BlockHashAlgorithm, options.FileHashAlgorithm);
}
}
}
private void WriteCompressionManifest()
{
var tempFilePath = Path.GetTempFileName();
var manifest = new ManifestData();
var filesToCompress = new List <CompressedFile>();
foreach (var file in FilesToCompress)
{
filesToCompress.Add(new CompressedFile
{
Source = file.GetMetadata("FullPath"),
InputSource = file.GetMetadata("InputSource"),
Target = file.GetMetadata("TargetCompressionPath"),
});
}
manifest.FilesToCompress = filesToCompress.ToArray();
var serializer = new DataContractJsonSerializer(typeof(ManifestData));
using (var tempFile = File.OpenWrite(tempFilePath))
{
using (var writer = JsonReaderWriterFactory.CreateJsonWriter(tempFile, Encoding.UTF8, ownsStream: false, indent: true))
{
serializer.WriteObject(writer, manifest);
}
}
if (!File.Exists(ManifestPath))
{
File.Move(tempFilePath, ManifestPath);
return;
}
var originalText = File.ReadAllText(ManifestPath);
var newManifest = File.ReadAllText(tempFilePath);
if (!string.Equals(originalText, newManifest, StringComparison.Ordinal))
{
// OnlyWriteWhenDifferent
File.Delete(ManifestPath);
File.Move(tempFilePath, ManifestPath);
}
}
/// <summary>
/// Verify each of the hashes in the sign file against the data in the main MANIFEST.MF
/// </summary>
/// <param name="centralManifest">MANIFEST.MF data</param>
/// <param name="signFile">the .SF data</param>
/// <returns>whether the sign file entries verify OK</returns>
private bool VerifyManifestHashes(ManifestData centralManifest, ManifestData signFile)
{
Log.Message($"Signing file contains {signFile.Entries.Count} entries");
Log.Message($"Expecting main manifest digest of {signFile.ManifestDigest}");
using (var h = new Hasher())
{
// The digest of the manifest in the JAR must match the digest of the manifest
// stated in the sign file
if (centralManifest.ManifestDigest != signFile.ManifestDigest)
{
Log.Message($"Main manifest has unexpected digest {centralManifest.ManifestDigest}");
return(false);
}
int centralEntry = 0;
// Take each entry from our sign file
foreach (ManifestEntry signed in signFile.Entries)
{
// And match it up against the equiavalent entry in the main manifest
//
// TODO: Assuming manifest and SF are always the same order + length which should be true
ManifestEntry central = centralManifest.Entries[centralEntry];
centralEntry++;
Log.Message($"Signed digest check {signed.Path} ({signed.Digest})");
// The hash of each of the three lines in Manifest.MF (Name + Digest + newlines) must match up
// with the digest in the sign file
//
if (h.SHA256(central.Original).ToBase64() != signed.Digest)
{
Log.Message($"{signed.Path} does not match {central.Path} in main manifest ({signed.Digest} != {central.Digest})");
return(false);
}
}
}
return(true);
}
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
Heilwurf = reader.getWurf("heilung");
WiderstandWurf = reader.getWurf("widerstand");
List<Stufe> list = new List<Stufe>();
int min = int.MinValue;
while (reader.NextElement())
{
int max = reader.getInt("widerstand");
ZVektor<Korperwert> Mali = reader.getKorperwerte("mali");
list.Add(new Stufe(min, max, Mali, this));
min = max + 1;
}
Stufen = list.ToArray();
reader.NextElement();
}
public bool AddContentPack(string directory)
{
Regex nameToId = new Regex("[^a-zA-Z0-9_.]");
ProducerFrameworkModEntry.ModMonitor.Log($"Reading content pack called through the API from {directory}");
IContentPack temp = ProducerFrameworkModEntry.Helper.ContentPacks.CreateFake(directory);
ManifestData info = temp.ReadJsonFile <ManifestData>("content-pack.json");
if (info == null)
{
ProducerFrameworkModEntry.ModMonitor.Log($"\tNo content-pack.json found in {directory}!", LogLevel.Warn);
return(false);
}
string id = info.UniqueID ?? nameToId.Replace(info.Author + "." + info.Name, "");
IContentPack contentPack = ProducerFrameworkModEntry.Helper.ContentPacks.CreateTemporary(directory, id, info.Name, info.Description, info.Author, new SemanticVersion(info.Version));
return(DataLoader.LoadContentPack(contentPack, new SaveLoadedEventArgs()));
}
// Require a minor bump of the package version when the minimum Unity version requirement becomes more strict.
// This is to ensure that we have patch versions available for the previous version of the package.
void ValidateUnityVersionBump(ManifestData previousManifest, ManifestData currentManifest)
{
// This is the first version of the package.
if (previousManifest == null)
{
return;
}
// Minimum Unity version requirement did not change.
var currentPackageUnityVersion = GetPackageUnityVersion(currentManifest);
var previousPackageUnityVersion = GetPackageUnityVersion(previousManifest);
if (currentPackageUnityVersion == previousPackageUnityVersion)
{
return;
}
// Minimum Unity version requirement became less strict.
if (currentPackageUnityVersion < previousPackageUnityVersion)
{
AddWarning(
"The Unity version requirement is less strict than in the previous version of the package. " +
"Please confirm that this change is deliberate and intentional. " +
ErrorDocumentation.GetLinkMessage(k_DocsFilePath, k_DocsLessStrictSection));
return;
}
// Major or minor version of package was bumped.
var previousPackageVersion = SemVersion.Parse(previousManifest.version);
var currentPackageVersion = SemVersion.Parse(currentManifest.version);
if (currentPackageVersion.Major > previousPackageVersion.Major ||
currentPackageVersion.Minor > previousPackageVersion.Minor)
{
return;
}
AddUnityAuthoredConditionalError(currentManifest,
"The Unity version requirement is more strict than in the previous version of the package. " +
"Increment the minor version of the package to leave patch versions available for previous version. " +
ErrorDocumentation.GetLinkMessage(k_DocsFilePath, k_DocsMoreStrictSection));
}
private static void FindProfiles(StreamDeckDeviceType streamDeckDeviceType, ManifestData manifest)
{
var profileDictionary = new Dictionary <ProfileType, ProfileData>();
foreach (var profile in manifest.Profiles.Where(x => x.DeviceType == streamDeckDeviceType))
{
var profileType = GetProfileType(profile.Name);
if (profileType != null)
{
profileDictionary.Add((ProfileType)profileType, profile);
Logger.Instance.LogMessage(TracingLevel.INFO,
"Profile Found : " + profile.Name + " for " + profile.DeviceType);
}
}
if (profileDictionary.Count > 1)
{
Profiles.Add(streamDeckDeviceType, profileDictionary);
}
}
public Universe(string Path)
{
this.Path = Path.Verzeichnis();
Attribute = new ElementMenge<Attribut>(this);
Fertigkeiten = new ElementMenge<Fertigkeit>(this);
Talente = new ElementMenge<Talent>(this);
TalentSection = new Section<Talent>(this, data =>
{
Talent t = Talente.GetElement(data.getString("name"));
data.NextElement();
return t;
}
);
Korperwerte = ElementMenge<Korperwert>.EmptyElementMenge(this);
Verletzungen = ElementMenge<Verletzung>.EmptyElementMenge(this);
Schadenstypen = new ElementMenge<Schadenstyp>(this);
Rassen = new ElementMenge<Rasse>(this);
BachelorKlassen = new ElementMenge<Klasse>(this);
MasterKlassen = ElementMenge<Klasse>.EmptyElementMenge(this);
Gegenstande = new ElementMenge<Gegenstand>(this);
Aktionen = new ElementMenge<Aktion>(this);
Techniken = new ElementMenge<Technik>(this);
CharakterDaten = new CharakterErstellungsDaten(this);
ManifestData d = new ManifestData(this, XmlReader.Create(Path));
this.Read(d);
Last = this;
}
// the author field is required for non-unity packages
private void ValidateNonUnityAuthor(ManifestData manifestData)
{
// if authordetails is set, then author == ""
if (String.IsNullOrEmpty(manifestData.author) && manifestData.authorDetails == null)
{
AddError(
"The `author` field is mandatory. Please add an `author` field in your package.json file",
ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "author_is_mandatory"));
return;
}
if (!String.IsNullOrEmpty(manifestData.author) && manifestData.authorDetails == null)
{
return; // valid
}
// non unity packages should have either a string or AuthorDetails { name: ""*, email: "", url: ""}
if (String.IsNullOrEmpty(manifestData.authorDetails.name))
{
AddError(
"Invalid `author` field. The `author` field in your package.json file can be a string or an object ( name, email, url ), where `name` is mandatory. {0}",
ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "author_is_invalid"));
}
}
public override void ReadElement(ManifestData Data)
{
}
protected void AddManifestfile()
{
using (var sr = new StreamWriter(m_compression.CreateFile(MANIFEST_FILENAME, CompressionHint.Compressible, DateTime.UtcNow), ENCODING))
sr.Write(ManifestData.GetManifestInstance(m_blocksize, m_blockhash, m_filehash));
}
public void GenerateReport(string outputPath, ManifestData newPackageManifestData, ManifestData previousPackageManifestData)
{
// no previous package was found.
if (Context.PreviousPackageInfo == null)
{
TestState = TestState.NotRun;
return;
}
var compareData = new PackageCompareData();
compareData.TreeOutput.AppendLine("<" + newPackageManifestData.name + ">");
Compare(compareData, newPackageManifestData.path, previousPackageManifestData.path, 1);
string fileName = Path.Combine(outputPath, newPackageManifestData.name + "@" + newPackageManifestData.version) + ".delta";
StringBuilder Outout = new StringBuilder();
Outout.AppendLine("Package Update Delta Evaluation");
Outout.AppendLine("-------------------------------");
Outout.AppendLine("");
Outout.AppendLine("Package Name: " + newPackageManifestData.name);
Outout.AppendLine("Package Version: " + newPackageManifestData.version);
Outout.AppendLine("Compared to Version: " + previousPackageManifestData.version);
Outout.AppendLine("");
if (compareData.Added.Any())
{
Outout.AppendLine("New in package:");
foreach (var addedFile in compareData.Added)
{
Outout.AppendLine(" " + addedFile.Substring(previousPackageManifestData.path.Length));
}
Outout.AppendLine("");
}
if (compareData.Removed.Any())
{
Outout.AppendLine("Removed from package:");
foreach (var removedFile in compareData.Removed)
{
Outout.AppendLine(" " + removedFile.Substring(newPackageManifestData.path.Length));
}
Outout.AppendLine("");
}
if (compareData.Modified.Any())
{
Outout.AppendLine("Modified:");
foreach (var modifiedFile in compareData.Modified)
{
Outout.AppendLine(" " + modifiedFile.Substring(newPackageManifestData.path.Length));
}
Outout.AppendLine("");
}
Outout.AppendLine("");
Outout.AppendLine("Package Tree");
Outout.AppendLine("------------");
Outout.AppendLine("");
Outout.Append(compareData.TreeOutput);
File.WriteAllText(fileName, Outout.ToString());
}
private void ReadBuffs(ManifestData data)
{
data.Section(() =>
{
switch (data.FlatName)
{
case "attributsmodiauffertigkeiten":
StatischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardStatischeAttributsModiAufFertigkeitenBuff().Create(null), 0);
break;
case "attributsmodiaufrettungswurfe":
StatischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardStatischeAttributsModiAufRettungswurfeBuff().Create(null), 0);
break;
case "attributeauffertigkeiten":
StatischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardStatischeAttributeAufFertigkeitenBuff().Create(null), 0);
break;
case "attributeaufrettungswurfe":
StatischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardStatischeAttributeAufRettungswerteBuff().Create(null), 0);
break;
case "geschlechtattribute":
StatischeBuffs.Attribute.add((BuffMan<Abbildung<Attribut, int>>)new GeschlechtAttributeBuff(data.getAttribute("mannlich"), data.getAttribute("weiblich")).Create(null), 0);
break;
case "harteaufstatischeresistenzen":
StatischeBuffs.Resistenzen.add((BuffMan<Abbildung<Schadenstyp, int>>)new HarteAufStatischeResistenzenBuff().Create(null), 0);
break;
case "itemfertigkeitsboni":
DynamischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardDynamischerItemFertigkeitsboni().Create(null), 0);
break;
case "itemharteboni":
DynamischeBuffs.Resistenzen.add((BuffMan<Abbildung<Schadenstyp, int>>)new StandardDynamischerItemHarteboni().Create(null), 0);
break;
case "ausrustungauffertigkeiten":
StatischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardStatischerAusrustungAufFertigkeitenBuff().Create(null), 0);
break;
case "ausrustungharteboni":
StatischeBuffs.Resistenzen.add((BuffMan<Abbildung<Schadenstyp, int>>)new StandardStatischerAusrustungAufHarteBuff().Create(null), 0);
break;
case "aktioninitiativewert":
DynamischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardDynamischerAktionsWertAufInitiative().Create(null), 0);
break;
case "aktioninitiativefertigkeit":
DynamischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardDynamischerFertigkeitAufInitiative().Create(null), 0);
break;
default:
throw new NotImplementedException();
}
data.NextElement();
});
DynamischeBuffs.Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardDynamischeFertigkeitenBuff().Create(null), 0);
DynamischeBuffs.Resistenzen.add((BuffMan<Abbildung<Schadenstyp, int>>)new StandardDynamischeResistenzenBuff().Create(null), 0);
}
static void TestMacht(Universe Universe)
{
ManifestData d = new ManifestData(Universe);
d.SetWriter("test.xml");
d.Writer.WriteStartElement("test");
foreach (var item in Universe.Talente)
{
if (item.Name.Contains("Macht"))
{
foreach (var f in Universe.Fertigkeiten)
{
if (item.Bedingung.ToString().Contains(f.Name))
{
Technik t = Technik.CreateMacht(item, f);
t.Write(d);
}
}
}
}
d.Writer.WriteEndElement();
d.Writer.Close();
}
private void PreReleaseChecks(ManifestData currentManifest)
{
string errorMsg = String.Empty;
if (Context.AllVersions != null)
{
SemVersion pkgVersion = SemVersion.Parse(currentManifest.version);
// Get all versions that match x.y.z (so, any exp, preview, prerelease, etc).
List <SemVersion> relatedVersions = pkgVersion.GetRelatedVersions(Context.AllVersions);
// Get only the related previous versions
SemVersion prevVersion = relatedVersions.Where(v => v <= pkgVersion).ToList().LastOrDefault();
if (prevVersion != null)
{
if (!PackageLifecyclePhase.IsPreReleaseVersion(prevVersion, VersionTag.Parse(prevVersion.Prerelease)))
{
errorMsg = string.Format(
"The previous version of this package ({0}) is not a Pre-Release. By Lifecycle V2 rules, a Pre-Release package can only be promoted automatically to production when the previous version is also a Pre-Release version. {1}",
prevVersion.ToString(),
ErrorDocumentation.GetLinkMessage(k_DocsFilePath,
"previous-version-of-this-package-is-not-a-pre-release-version"));
}
else
{
SemVersion lastPreVersion = relatedVersions.Where(v =>
{
VersionTag t = VersionTag.Parse(v.Prerelease);
return(PackageLifecyclePhase.IsPreReleaseVersion(v, t));
}).ToList().LastOrDefault();
if (lastPreVersion != null)
{
VersionTag lastTag = VersionTag.Parse(lastPreVersion.Prerelease);
VersionTag pkgTag = VersionTag.Parse(pkgVersion.Prerelease);
if (pkgTag.Iteration <= lastTag.Iteration)
{
errorMsg = string.Format(
"This package iteration ({0}) must be higher than the highest published iteration ({1}). Please update your package version to {2} {3}",
pkgTag.Iteration,
lastTag.Iteration,
string.Format("{0}-{1}.{2}", pkgVersion.VersionOnly(), pkgTag.Tag,
lastTag.Iteration + 1),
ErrorDocumentation.GetLinkMessage(k_DocsFilePath,
"this-package-iteration-(x)-must-be-higher-than-the-highest-published-iteration-(y)"));
}
}
}
}
else
{
errorMsg = string.Format(
"There is no previous Pre-Release version of this package available. By Lifecycle V2 rules, the first Pre-Release iteration of a new version needs to be approved and promoted by Release Management. Please contact Release Management to promote your package. {0}",
ErrorDocumentation.GetLinkMessage(k_DocsFilePath,
"previous-version-of-this-package-is-not-a-pre-release-version"));
}
}
if (errorMsg != String.Empty)
{
AddPromotionConditionalError(errorMsg);
}
}
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
Hartebonus = reader.getSchaden("harteboni");
}
public void Read(ManifestData data)
{
DynamischeBuffs = new CharakterDynamisch(data.Universe);
StatischeBuffs = new CharakterStatisch(data.Universe);
FertigkeitsGeber = Universe.Attribute.GetElemente(data.getStrings("fertigkeitsgeber"));
SkillbareAttribute = Universe.Attribute.GetElemente(data.getStrings("skillbar"));
data.NextElement();
data.Section("charaktererstellungsdaten", () =>
{
switch (data.Reader.Name)
{
case "attribute":
ReadAttribute(data);
break;
case "klassen":
ReadKlassen(data);
break;
case "fertigkeiten":
ReadFertigkeiten(data);
break;
case "now":
Now = data.getDateTime("date");
data.NextElement();
break;
case "buffs":
ReadBuffs(data);
break;
case "standardfertigkeiten":
StandardFertigkeiten = data.ReadAufzahlungFertigkeiten();
data.NextElement();
break;
default:
throw new NotImplementedException();
}
});
}
///// <summary>
///// Kreiert eine ID und erhöht instanzNummern um eins.
///// </summary>
///// <returns>ID des Manifests, das diese Methode aufgerufen hat.</returns>
//protected ulong createID()
//{
// return ((ulong)klasseUndTyp) * KLASSEN_MUL + ((ulong)packet) * PACKET_MUL + ((ulong)instanzNummern++) * INSTANZ_MUL;
//}
//public abstract Manifest createMan();
//public abstract Manifest createMan(Manifest besitzer, string ursache, Manifest urheber);
public abstract Manifest Create(ManifestData Data);
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
this.Bedingung = Bedingung.Parse(reader.getString("bedingung"));
this.Buffs = reader.GetBuffs();
}
private void ValidateManifestData(ManifestData manifestData)
{
// Check the package Name, which needs to start with one of the approved company names.
// This should probably be executed only in internal development, CI and Promotion contexts
if (!PackageNamePrefixList.Any(namePrefix => (manifestData.name.StartsWith(namePrefix) && manifestData.name.Length > namePrefix.Length)))
{
AddError("In package.json, \"name\" needs to start with one of these approved company names: {0}. {1}", string.Join(", ", PackageNamePrefixList), ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "name-needs-to-start-with-one-of-these-approved-company-names"));
}
// There cannot be any capital letters in package names.
if (manifestData.name.ToLower(CultureInfo.InvariantCulture) != manifestData.name)
{
AddError("In package.json, \"name\" cannot contain capital letters. {0}", ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "name-cannot-contain-capital-letters"));
}
// Check name against our regex.
Match match = Regex.Match(manifestData.name, UpmRegex);
if (!match.Success)
{
AddError("In package.json, \"name\" is not a valid name. {0}", ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "name-is-not-a-valid-name"));
}
// Package name cannot end with .framework, .plugin or .bundle.
String[] strings = { ".framework", ".bundle", ".plugin" };
foreach (var value in strings)
{
if (manifestData.name.EndsWith(value))
{
AddError("In package.json, \"name\" cannot end with .plugin, .bundle or .framework. {0}", ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "name-cannot-end-with"));
}
}
if (string.IsNullOrEmpty(manifestData.displayName))
{
AddError("In package.json, \"displayName\" must be set. {0}", ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "displayName-must-be-set"));
}
else if (manifestData.displayName.Length > MaxDisplayNameLength)
{
AddError("In package.json, \"displayName\" is too long. Max Length = {0}. Current Length = {1}. {2}", MaxDisplayNameLength, manifestData.displayName.Length, ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "displayName-is-too-long"));
}
else if (!Regex.Match(manifestData.displayName, UpmDisplayRegex).Success)
{
AddError("In package.json, \"displayName\" cannot have any special characters. {0}", ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "displayName-cannot-have-any-special-characters"));
}
// Check Description, make sure it's there, and not too short.
if (manifestData.description.Length < MinDescriptionSize)
{
AddError("In package.json, \"description\" is too short. Minimum Length = {0}. Current Length = {1}. {2}", MinDescriptionSize, manifestData.description.Length, ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "description-is-too-short"));
}
// check unity field, if it's there
if (!string.IsNullOrEmpty(manifestData.unity) && (manifestData.unity.Length > 6 || !Regex.Match(manifestData.unity, UnityRegex).Success))
{
AddError($"In package.json, \"unity\" is invalid. It should only be <MAJOR>.<MINOR> (e.g. 2018.4). Current unity = {manifestData.unity}. {ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "unity-is-invalid")}");
}
// check unityRelease field, if it's there
if (!string.IsNullOrEmpty(manifestData.unityRelease))
{
// it should be valid
if (!Regex.Match(manifestData.unityRelease, UnityReleaseRegex).Success)
{
AddError(
$"In package.json, \"unityRelease\" is invalid. Current unityRelease = {manifestData.unityRelease}. {ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "unityrelease-is-invalid")}");
}
// it should be accompanied of a unity field
if (string.IsNullOrEmpty(manifestData.unity))
{
AddError(
$"In package.json, \"unityRelease\" needs a \"unity\" field to be used. {ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "unityrelease-without-unity")}");
}
}
// check documentation url field
if (Context.ValidationType == ValidationType.Promotion || Context.ValidationType == ValidationType.CI)
{
if (!string.IsNullOrWhiteSpace(manifestData.documentationUrl))
{
AddError("In package.json, \"documentationUrl\" can't be used for Unity packages. It is a features reserved for enterprise customers. The Unity documentation team will ensure the package's documentation is published in the appropriate fashion");
}
// Check if `repository.url` and `repository.revision` exist and the content is valid
string value;
if (!manifestData.repository.TryGetValue("url", out value) || string.IsNullOrEmpty(value))
{
AddError("In package.json for a published package, there must be a \"repository.url\" field. {0}", ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "for_a_published_package_there_must_be_a_repository.url_field"));
}
if (!manifestData.repository.TryGetValue("revision", out value) || string.IsNullOrEmpty(value))
{
AddError("In package.json for a published package, there must be a \"repository.revision\" field. {0}", ErrorDocumentation.GetLinkMessage(ManifestValidation.k_DocsFilePath, "for_a_published_package_there_must_be_a_repository.revision_field"));
}
}
else
{
AddInformation("Skipping Git tags check as this is a package in development.");
}
}
private void ReadKlassen(ManifestData data)
{
this.StufenBachelor = data.getInt("stufenbachelor");
this.StufenMaster = data.getInt("stufenmaster");
data.NextElement();
}
private void ReadFertigkeiten(ManifestData data)
{
this.MaximalerFertigkeitswert = data.getInt("maximalerfertigkeitswert");
this.MaximalerFertigkeitswertProStufe = data.getInt("maximalerfertigkeitswertprostufe");
this.ErlernteFertigkeitenBachelor = data.getInt("erlerntefertigkeitenbachelor");
this.ErlernteFertigkeitenMaster = data.getInt("erlerntefertigkeitenmaster");
data.NextElement();
}
public CharakterDynamisch(ManifestData Data)
: base(Data, "Dynamische Eigenschaften", "dynamisch")
{
Geschwindigkeit = new Eigenschaft<float>(new SummeF());
Fertigkeiten = new Eigenschaft<Abbildung<Fertigkeit, int>>(new ZVektor<Fertigkeit>(Data.Fertigkeiten));
KannAgieren = new Eigenschaft<bool>(new Verband(Verband.OperationArt.Und));
Resistenzen = new Eigenschaft<Abbildung<Schadenstyp, int>>(new ZVektor<Schadenstyp>(Universe.Schadenstypen));
//Fertigkeiten.add((BuffMan<Abbildung<Fertigkeit, int>>)new StandardDynamischeFertigkeitenBuff().Create(null), 0);
//Geschwindigkeit.add((BuffMan<float>)new StandardDynamischerGeschwindigkeitsBuff().Create(null), 0);
//KannAgieren.add((BuffMan<bool>)new StandardDynamischeKannAgierenBuff().Create(null), 0);
}
public override void Write(ManifestData Data)
{
throw new NotImplementedException();
}
public static void printCharakter(string name)
{
Charakter c = new Charakter(name, 0, "Standard");
ManifestData md = new ManifestData(u);
md.SetReader("../../Universe/Charakter/Charakter " + name + ".xml");
c.Init(md);
CharakterMan cm = (CharakterMan)c.Create(md);
//Charakterbogen cb = new Charakterbogen(cm, u);
//cb.Bogen.createPDF("../../Universe/Charakter/Charakter " + name);
}
public override Manifest Create(ManifestData Data)
{
return new ItemMan(this, InstanzNummern++);
}
public override void Read(ManifestData reader, int ID)
{
base.Read(reader, ID);
}
public void Read(ManifestData data)
{
data.NextElement();
this.Name = data.getString("name");
this.Author = data.getString("author");
data.Section("universe", () =>
{
switch (data.Reader.Name)
{
case "attribute":
Attribute.Read(Path + data.Reader.getString("path"));
break;
case "fertigkeiten":
Fertigkeiten.Read(Path + data.Reader.getString("path"));
break;
case "talente":
Talente.Read(Path + data.Reader.getString("path"));
break;
case "talentsections":
TalentSection.Read(Path + data.Reader.getString("path"));
break;
case "korperwerte":
Korperwerte.Read(Path + data.Reader.getString("path"));
break;
case "verletzungen":
Verletzungen.Read(Path + data.Reader.getString("path"));
break;
case "rassen":
Rassen.Read(Path + data.Reader.getString("path"));
break;
case "bachelorklassen":
BachelorKlassen.Read(Path + data.Reader.getString("path"));
break;
case "masterklassen":
MasterKlassen.Read(Path + data.Reader.getString("path"));
break;
case "gegenstande":
Gegenstande.Read(Path + data.Reader.getString("path"), name =>
{
switch ((Gegenstand.Kategorie)Enum.Parse(typeof(Gegenstand.Kategorie), name, true))
{
case Gegenstand.Kategorie.Nahkampfwaffe:
return new NahkampfWaffe();
case Gegenstand.Kategorie.Fernkampfwaffe:
return new FernkampfWaffe();
case Gegenstand.Kategorie.Schild:
return new Schild();
case Gegenstand.Kategorie.Rustung:
return new Rustung();
case Gegenstand.Kategorie.Gegenstand:
return new Gegenstand();
default:
throw new NotImplementedException();
}
});
break;
case "techniken":
Techniken.Read(Path + data.Reader.getString("path"));
break;
case "aktionen":
Aktionen.Read(Path + data.Reader.getString("path"));
break;
case "daten":
CharakterDaten.Read(Path + data.Reader.getString("path"));
break;
case "schadenstypen":
Schadenstypen.Read(Path + data.Reader.getString("path"));
break;
default:
throw new NotImplementedException();
}
data.NextElement();
});
}
/// <summary>
/// Perform JAR digital signature verification against a JAR filename on disk
/// </summary>
/// <param name="jar">JAR container. The caller is expected to dispose this type themselves - it will not be disposed
/// by this method</param>
/// <param name="certificates">certificate to verify / accept against</param>
/// <param name="nonStandardCountCheck">whether to perform the additional file count verification check against
/// MANIFEST.MF (recommended if the file is actually an arbitrary ZIP)</param>
/// <returns>digital signature verification state of the JAR</returns>
public static VerificationResult Jar(IJar jar, IVerificationCertificates certificates, bool nonStandardCountCheck = true)
{
// Unsigned ZIP and probably not even a JAR
if (!jar.Contains(@"META-INF\MANIFEST.MF"))
{
return(new VerificationResult
{
Status = SigningStatus.NotSigned,
Valid = false
});
}
IManifestLoader manifestLoader = new ManifestLoader();
ManifestData centralManifest = manifestLoader.Load(jar, @"META-INF\MANIFEST.MF");
if (nonStandardCountCheck)
{
// Non-standard check: Ensure that no unsigned files have been ADDED
// to the JAR (file qty. [except signature itself] must match manifest entries)
//
int nonManifestFiles = jar.NonSignatureFiles().Count();
if (centralManifest.Entries.Count != nonManifestFiles)
{
Log.Message($"Expected {centralManifest.Entries.Count} file(s) found {nonManifestFiles}");
return(new VerificationResult
{
Status = SigningStatus.FundamentalHashMismatch,
Valid = false
});
}
}
// Verify the hashes of every file in the JAR
//
using (var h = new Hasher())
{
Log.Message($"Central manifest contains {centralManifest.Entries.Count} entries");
foreach (ManifestEntry e in centralManifest.Entries)
{
Log.Message($"Digest check {e.Path} ({e.Digest})");
// Check each file matches the hash in the manifest
if (jar.SHA256(h, e.Path).ToBase64() != e.Digest)
{
Log.Message($"{e.Path} has an incorrect digest");
return(new VerificationResult
{
Status = SigningStatus.FundamentalHashMismatch,
Valid = false
});
}
}
}
// Detect signatures
//
//
ISignatureFinder finder = new SignatureFinder();
List <Signature> signatures = finder.Find(jar);
if (!signatures.Any())
{
Log.Message("No signatures detected");
return(new VerificationResult
{
Status = SigningStatus.NotSigned,
Valid = false
});
}
Log.Message($"{signatures.Count} signature(s) detected");
// Verify signatures
//
//
SignatureVerifier ver = new SignatureVerifier();
if (ver.Verify(jar, centralManifest, signatures, certificates))
{
return(new VerificationResult
{
Status = SigningStatus.SignedValid,
Valid = true
});
}
else
{
return(new VerificationResult
{
Status = SigningStatus.SignedInvalid,
Valid = false
});
}
}
public void Read(string Path)
{
XmlReader reader = XmlReader.Create(Path);
ManifestData data = new ManifestData(Universe, reader);
this.Read(data);
}
/**
* Can't promote if it's a release or RC
* Can promote -preview, -pre (unless it is the first one, but that is verified somewhere else) and -exp
* Error in Promotion
* Only warn when in CI
*/
private void ValidateVersionAbilityToPromote(SemVersion packageVersionNumber, VersionTag versionTag, ManifestData manifestData)
{
// Make this check only in promotion, to avoid network calls
if (Context.PackageVersionExistsOnProduction)
{
AddPromotionConditionalError("Version " + Context.ProjectPackageInfo.version + " of this package already exists in production.");
}
var message = String.Empty;
if (PackageLifecyclePhase.IsReleasedVersion(packageVersionNumber, versionTag) ||
PackageLifecyclePhase.IsRCForThisEditor(manifestData.name, Context))
{
message = $"Automated promotion of Release or Release Candidate packages is not allowed. Release Management are the only ones that can promote Release and Release Candidate packages to production, if you need this to happen, please go to #devs-pkg-promotion. {ErrorDocumentation.GetLinkMessage(k_DocsFilePath, "a-release-package-must-be-manually-promoted-by-release-management")}";
}
else
{
// We send a message if this is the first version of the package being promoted
if (!Context.PackageExistsOnProduction)
{
message = $"{Context.PublishPackageInfo.name} has never been promoted to production before. Please contact Release Management through slack in #devs-pkg-promotion to promote the first version of your package before trying to use this automated pipeline. {ErrorDocumentation.GetLinkMessage(k_DocsFilePath, "the-very-first-version-of-a-package-must-be-promoted-by-release-management")}";
}
}
if (message != String.Empty)
{
AddPromotionConditionalError(message);
}
}
public override Manifest Create(ManifestData Data)
{
return new FigurZug(this, InstanzNummern++);
}
static SemVersion GetPackageUnityVersion(ManifestData manifest)
{
return(string.IsNullOrEmpty(manifest.unity) ? new SemVersion(0) : UnityVersion.Parse(manifest.unity));
}
private void ReadAttribute(ManifestData data)
{
this.MinimalerWertAttribut = data.getInt("minimalerwert");
this.MaximalerWertAttribut = data.getInt("maximalerwert");
this.SummeAttribute = data.getInt("summe");
this.FertigkeitsGeber = Universe.Attribute.GetElemente(data.getStrings("fertigkeitsgeber"));
this.SkillbareAttribute = Universe.Attribute.GetElemente(data.getStrings("skillbar"));
data.NextElement();
}
