private static bool ValidateEntry(MetaDataModel.Entry entry, MetaDataEntry doc, IWorkspaceItem item, out string defaultMessage)
{
const string DONT_SHOW = "DONT SHOW";
if (entry.IsArray)
{
if (doc.Value == null)
{
foreach (var value in doc.Entries)
{
if (!ValidateSingleMetaEntry(entry, value.Value, item, out defaultMessage))
{
return(false);
}
}
defaultMessage = DONT_SHOW;
return(true);
}
else
{
defaultMessage = DONT_SHOW;
return(false);
}
}
else if (doc.Value == null)
{
defaultMessage = "Entry has to contain a value";
return(false);
}
else
{
return(ValidateSingleMetaEntry(entry, doc.Value, item, out defaultMessage));
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 14 && entry is MetadataByte data)
{
var isSmall = (data.Value & 0x01) != 0;
SetSmall(isSmall);
var hasArms = (data.Value & 0x04) != 0;
var noBasePlate = (data.Value & 0x08) != 0;
var setMarker = (data.Value & 0x10) != 0;
if (setMarker)
{
Width = 0f;
Height = 0f;
NoAi = true;
}
//IsInvisible = setMarker;
var renderer = ModelRenderer;
if (renderer != null)
{
renderer.SetVisibility("leftarm", hasArms);
renderer.SetVisibility("rightarm", hasArms);
renderer.SetVisibility("baseplate", !noBasePlate);
}
}
else if (entry.Index >= 15 && entry.Index <= 20 && entry is MetadataRotation rotation)
{
switch (entry.Index)
{
case 15: //Head
SetHeadRotation(rotation.Rotation);
break;
case 16: //Body
SetBodyRotation(rotation.Rotation);
break;
case 17: //Left Arm
SetArmRotation(rotation.Rotation, true);
break;
case 18: //Right Arm
SetArmRotation(rotation.Rotation, false);
break;
case 19: //Left Leg
SetLegRotation(rotation.Rotation, true);
break;
case 20: //Right Leg
SetLegRotation(rotation.Rotation, false);
break;
}
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 14 && entry is MetadataFloat flt)
{
//Additional hearts
//HealthManager.MaxHealth
}
else if (entry.Index == 15 && entry is MetadataVarInt score)
{
Score = score.Value;
}
else if (entry.Index == 16 && entry is MetadataByte data)
{
SkinFlags.Value = data.Value;
if (ModelRenderer != null)
{
SkinFlags.ApplyTo(ModelRenderer);
}
}
else if (entry.Index == 17 && entry is MetadataByte metaByte)
{
IsLeftHanded = metaByte.Value == 0;
}
}
//TODO: Handle hand animations
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
/*if (entry.Index == 7 && entry is MetadataByte data)
* {
* bool handActive = (data.Value & 0x01) != 0;
*
* if (handActive)
* {
* bool offHandActive = (data.Value & 0x02) != 0;
* var item = GetItemInHand(!offHandActive);
*
* if (item != null)
* {
* if (item is ItemEdible) //Food or drink
* {
*
* }
* else if (item.ItemType == ItemType.Sword || item.ItemType == ItemType.Shield)
* {
*
* }
* else if (item.ItemType == ItemType.AnyTool)
* {
*
* }
* }
* }
* }
* else*/if (entry.Index == 8 && entry is MetadataFloat flt)
{
HealthManager.Health = flt.Value;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index >= 15 && entry.Index <= 20 && entry is MetadataRotation rotation)
{
switch (entry.Index)
{
case 15: //Head
SetHeadRotation(rotation.Rotation);
break;
case 16: //Body
SetBodyRotation(rotation.Rotation);
break;
case 17: //Left Arm
SetArmRotation(rotation.Rotation, true);
break;
case 18: //Right Arm
SetArmRotation(rotation.Rotation, false);
break;
case 19: //Left Leg
SetLegRotation(rotation.Rotation, true);
break;
case 20: //Right Leg
SetLegRotation(rotation.Rotation, false);
break;
}
}
}
internal XmlDocument ToXml(string group, ITestResultSerializerFactory serializerFactory)
{
XmlDocument doc = new XmlDocument();
//Check Metadata for xml serializer type, TDS is default value
MetaDataEntry entry = ServiceLocator.Resolve <ConfigurationHolder>().GetFromMetaData(this.ProjectID, group, "XMLVersion");
XMLAdapter.AdapterType xmlType = XMLAdapter.AdapterType.TDS;
if (entry != null)
{
xmlType = Utilities.Utility.Value(entry.TextVal, XMLAdapter.AdapterType.TDS);
}
// if set to 1/true, any demographics in the file will be preserved
// Used only in the OSS environment to minimize configuration
entry = ServiceLocator.Resolve <ConfigurationHolder>().GetFromMetaData(this.ProjectID, group, "IncludeAllDemographics");
SerializationConfig config = null;
if (entry != null && Convert.ToBoolean(entry.IntVal))
{
config = new SerializationConfigIncludeAllDemographics();
}
else
{
//get the serialization config from the project metadata
config = new SerializationConfig(/*ConfigurationHolder.IncludeAccommodations(ProjectID, group),*/
ServiceLocator.Resolve <ConfigurationHolder>().GetRTSAttributes(this.projectID, group));
}
doc.LoadXml(serializerFactory.CreateSerializer(xmlType.ToString(), this).Serialize(config));
return(doc);
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 18 && entry is MetadataBool boolean)
{
IsBegging = boolean.Value;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 8 && entry is MetadataFloat flt)
{
HealthManager.Health = flt.Value;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 18 && entry is MetadataVarInt varint)
{
Variant = (ParrotType)varint.Value;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 15 && entry is MetadataVarInt mtd)
{
Size = mtd.Value;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 15 && entry is MetadataByte meta)
{
IsHanging = (meta.Value & 0x01) != 0;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 18 && entry is MetadataBool val)
{
IsChested = val.Value;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 16 && entry is MetadataVarInt variant)
{
TryUpdateTexture("minecraft:fox", variant.Value == 0 ? "red" : "arctic");
}
}
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 16 && entry is MetadataString variant)
{
TryUpdateTexture("minecraft:mooshroom", variant.Value == "red" ? "default" : "brown");
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 21 && entry is MetadataVarInt variant)
{
SetVariant(variant.Value);
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 17 && entry is MetadataByte metaByte)
{
IsLeftHanded = metaByte.Value == 0;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 15 && entry is MetadataByte mtd)
{
IsWallClimbing = (mtd.Value & 0x01) != 0;
}
}
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 16 && entry is MetadataByte meta)
{
SetSheared((meta.Value & 0x10) != 0);
SetColor(meta.Value & 0x0F);
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 17 && entry is MetadataVillagerData villagerData)
{
string texture = villagerData.Profession.ToString().ToLower();
TryUpdateTexture("minecraft:villager", texture);
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 7 && entry is MetadataPosition position)
{
KnownPosition.X = position.Position.X;
KnownPosition.Y = position.Position.Y;
KnownPosition.Z = position.Position.Z;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 16 && entry is MetadataByte meta)
{
IsSitting = (meta.Value & 0x01) != 0;
IsAngry = (meta.Value & 0x02) != 0;
IsTamed = (meta.Value & 0x04) != 0;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 16 && entry is MetadataBool charged)
{
IsCharged = charged.Value;
}
else if (entry.Index == 17 && entry is MetadataBool ignited)
{
IsIgnited = ignited.Value;
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 7 && entry is MetadataSlot slot)
{
var item = JavaWorldProvider.GetItemFromSlotData(slot.Value);
if (item != null)
{
SetItem(item);
}
}
}
private static void AddMetaDataEntry(Block block, LineInfo lineInfo, string ln, int offset, int remainingSpaces, int length = -1, bool isAddOffsetRequired = true)
{
int pos = lineInfo.LineOffset;
int line = lineInfo.LineNumber;
int index = ln.IndexOf(':');
if (index > -1)
{
string name = ln.Substring(0, index);
var entry = new MetaDataEntry {
Name = name, NameStartPosition = pos, LineNumber = line
};
for (int i = index + 1; i < ln.Length; i++)
{
if (ln[i] == '[' || ln[i] == '"' || char.IsLetterOrDigit(ln[i]))
{
index = i;
break;
}
}
string value = ln.Substring(index).Trim('\n', ' ', '\t', '"');
if (value.Length > 0)
{
if (value[0] == '[')
{
var values = value.Split(',');
for (int i = 0; i < values.Length; i++)
{
values[i] = values[i].Trim('[', ']', ' ');
if (values[i].Length > 0)
{
entry.Entries.Add(new MetaDataEntry {
Value = values[i].Trim('"')
});
}
}
}
else
{
entry.Value = value;
}
entry.ValueStartPosition = index + pos;
entry.ValueLength = ln.Length - index;
}
block.MetaData.Entries.Add(entry);
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 16 && entry is MetadataByte meta)
{
IsAngry = (meta.Value & 0x02) != 0;
HasStung = (meta.Value & 0x04) != 0;
HasNectar = (meta.Value & 0x08) != 0;
}
if (entry.Index == 17 && entry is MetadataVarInt angerTime)
{
AngerTime = angerTime.Value;
}
}
private void SaveValidationResult(MetaDataEntry result)
{
try
{
if (result.Status == "ERRORS" && result.ContactEmail != null && result.ContactEmail != "" && result.ContactEmail.Contains('@'))
{
using (var session = MvcApplication.Store.OpenSession())
{
session.Store(result);
session.SaveChanges();
}
}
}
catch (Exception ex) {
Log.Error(ex.Message);
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 14 && entry is MetadataByte bitMask)
{
//NoAi = ((bitMask.Value & 0x01) != 0);
if ((bitMask.Value & 0x02) != 0) //Left Handed
{
IsLeftHanded = true;
}
else
{
IsLeftHanded = false;
}
}
}
/// <inheritdoc />
protected override void HandleJavaMeta(MetaDataEntry entry)
{
base.HandleJavaMeta(entry);
if (entry.Index == 16 && entry is MetadataByte data)
{
IsTamed = (data.Value & 0x02) != 0;
IsSaddled = (data.Value & 0x04) != 0;
HasBred = (data.Value & 0x08) != 0;
IsEating = (data.Value & 0x10) != 0;
IsRearing = (data.Value & 0x20) != 0;
IsMouthOpen = (data.Value & 0x40) != 0;
}
if (entry.Index == 17 && entry is MetadataOptUUID uuid)
{
Owner = uuid.HasValue ? uuid.Value : null;
}
}
public void GetAllMetadata()
{
MetadataIndexViewModel model = new MetadataIndexViewModel();
int offset = 1;
int limit = 50;
model = _metadataService.SearchMetadata("", "", offset, limit);
foreach (var item in model.MetadataItems)
{
MetaDataEntry md = ValidateMetadata(item.Uuid);
SaveValidationResult(md);
}
int numberOfRecordsMatched = model.TotalNumberOfRecords;
int next = model.OffsetNext();
try
{
while (next < numberOfRecordsMatched)
{
model = _metadataService.SearchMetadata("", "", next, limit);
foreach (var item in model.MetadataItems)
{
MetaDataEntry md = ValidateMetadata(item.Uuid);
SaveValidationResult(md);
}
next = model.OffsetNext();
if (next == 0)
{
break;
}
}
}
catch (Exception e)
{
Log.Error(e.Message);
}
}
/// <summary>
/// get all Filenames inside a folder and adds it into a List
/// </summary>
/// <param name="folder"></param>
private void getFilesInFolder(List <string> folder)
{
int i = 1;
foreach (string rootFolder in _allFolders)
{
Console.WriteLine("**************************************************************************************************");
List <MetaDataEntry> metaDataEntries = new List <MetaDataEntry>();
DirectoryInfo di = new DirectoryInfo(rootFolder);
if (di.GetFiles().Length > 0)
{
foreach (FileInfo fileInfo in di.GetFiles())
{
if (!fileInfo.Name.EndsWith(".xml") && !fileInfo.Name.EndsWith(".ffs_db") && !fileInfo.Name.EndsWith(".db"))
{
string tmp_Name = fileInfo.FullName.Remove(0, RootPath.Length);
string uriPath = Helper.convert(tmp_Name);
MetaDataEntry entry = new MetaDataEntry(fileInfo.Name, _iniReader.Read("RootPath", "Web") + uriPath);
metaDataEntries.Add(entry);
}
}
_fileWriter.PathForMetadataXml = rootFolder;
_fileWriter.WriteMetadataXml(metaDataEntries);
}
Console.WriteLine($"{i} von {_allFolders.Count} verarbeitet.");
Console.WriteLine("");
Console.WriteLine("**************************************************************************************************");
i++;
}
}
/***** private members ***********************************************/
/**
* AddFile adds a new entry (hash, path, lastwritetime, metadata)
* to the list of shared files.
*/
private void AddFile(string filePathQ)
{
try
{
// add file to hashing queue
try
{
m_HashingQueue.Lock();
if (!m_HashingQueue.Contains(filePathQ))
{
m_HashingQueue.Enqueue(filePathQ);
}
}
finally
{
m_HashingQueue.Unlock();
}
// if no hashing thread is running, start a new hashing thread
if (m_HashingThread == null || !m_HashingThread.IsAlive)
{
m_HashingThread = new Thread(delegate()
{
while (!m_HashingQueue.IsEmpty)
{
try
{
string filePath = string.Empty;
try
{
m_HashingQueue.Lock();
filePath = m_HashingQueue.Dequeue();
}
finally
{
m_HashingQueue.Unlock();
}
if (File.Exists(filePath))
{
byte[] fileHash = null;
string hashSource = "unknown";
SharedFileEntry knownSharedFileEntry = null;
// check to see if the file is already in the database
try
{
m_SharedFileEntries.Lock();
foreach (SharedFileEntry sharedFileEntry in m_SharedFileEntries.Values)
{
if (Path.GetFileName(sharedFileEntry.FilePath).Equals(Path.GetFileName(filePath)) &&
new FileInfo(filePath).LastWriteTime.Equals(sharedFileEntry.LastWriteTime))
{
knownSharedFileEntry = sharedFileEntry;
break;
}
}
if (knownSharedFileEntry != null)
{
// file is already known, use the existing hash
m_SharedFileEntries.Remove(knownSharedFileEntry.FilePath);
fileHash = knownSharedFileEntry.FileHash;
hashSource = "database";
}
else
{
// file is not known, so we have to calculate the hash
FileStream fileStream = null;
while (fileStream == null)
{
try
{
fileStream = new FileStream(filePath, FileMode.Open, FileAccess.Read, FileShare.Read);
}
catch (System.IO.IOException)
{
}
}
//FileStream fileStream = new FileStream(filePath, FileMode.Open);
fileHash = ComputeHashes.SHA512Compute(fileStream);
fileStream.Close();
hashSource = "new file";
}
// check if hashed file is still valid (not removed during hashing)
// and add to shared file entries
foreach (string sharedDir in m_SharedDirectories)
{
if (filePath.Contains(sharedDir))
{
m_SharedFileEntries[filePath] = new SharedFileEntry(filePath, fileHash, new FileInfo(filePath).LastWriteTime);
goto fileValid;
}
}
}
finally
{
m_SharedFileEntries.Unlock();
}
continue;
fileValid:
// add to meta data entries and shared files
try
{
m_SharedFiles.Lock();
string fileHashString = Core.ByteArrayToString(fileHash);
if (!m_SharedFiles.ContainsKey(fileHashString))
{
MetaDataEntry metaDataEntry;
if (!m_MetaDataEntries.TryGetValue(fileHashString, out metaDataEntry))
metaDataEntry = new MetaDataEntry();
m_SharedFiles.Add(new SharedFile(filePath, fileHash, metaDataEntry.MetaData, metaDataEntry.Comment, metaDataEntry.Rating, metaDataEntry.LastRequest));
}
}
finally
{
m_SharedFiles.Unlock();
}
m_Logger.Log("Added file from {0} \"{1}\"", hashSource, filePath);
}
else
{
m_Logger.Log("AddFile: File does not exist: \"{0}\"", filePath);
}
}
catch (Exception ex)
{
m_Logger.Log("AddFile: An exception was thrown during hashing: {0}", ex);
}
}
});
m_HashingThread.IsBackground = true;
m_HashingThread.Priority = ThreadPriority.Lowest;
m_HashingThread.Start();
}
}
catch (Exception ex)
{
m_Logger.Log(ex, "An exception was thrown while adding a shared file!");
}
}
/**
* AddDirectory adds a directory path to the list of shared
* directories. All files in the shared directory and its subdirectory
* are hashed and added to the shred files list. The contents of the
* shared directory are atomatically tracked and updated via a
* FileSystemWatcher object.
*/
public bool AddDirectory(string sharedDirectory)
{
if (sharedDirectory == null)
throw new ArgumentNullException("sharedDirectory");
try
{
if (!Directory.Exists(sharedDirectory))
{
m_Logger.Log("AddDirectory: Directory does not exist: \"{0}\"", sharedDirectory);
return false;
}
// check if parent or passed directory is already shared
// 2007-08-06 fix for Ticket #71 T.Norad
bool hasParent = false;
bool isAlreadyShared = false;
DirectoryInfo parentDirectory = Directory.GetParent(sharedDirectory);
foreach (string sharedDir in m_SharedDirectories)
{
// is the directory already shared?
if (sharedDirectory.Equals(sharedDir))
{
isAlreadyShared = true;
break;
}
// is the parent already shared?
if (parentDirectory != null && parentDirectory.FullName.Contains(sharedDir))
{
hasParent = true;
break;
}
}
if (!(hasParent || isAlreadyShared))
{
// add directory
m_SharedDirectories.Add(sharedDirectory);
// add directory watcher
FileSystemWatcher watcher = new FileSystemWatcher();
watcher.Path = sharedDirectory;
watcher.IncludeSubdirectories = true;
watcher.NotifyFilter = NotifyFilters.LastWrite | NotifyFilters.FileName | NotifyFilters.DirectoryName;
watcher.Changed += new FileSystemEventHandler(OnChanged);
watcher.Created += new FileSystemEventHandler(OnChanged);
watcher.Deleted += new FileSystemEventHandler(OnChanged);
watcher.Renamed += new RenamedEventHandler(OnRenamed);
watcher.EnableRaisingEvents = true;
m_DirectoryWatchers[sharedDirectory] = watcher;
m_Logger.Log(Properties.Resources_Core.AddedDirectory, sharedDirectory);
}
// index and hash contained files
try
{
FileInfo[] fileInfos = null;
while (fileInfos == null)
{
try
{
fileInfos = new DirectoryInfo(sharedDirectory).GetFiles("*", SearchOption.AllDirectories);
}
catch(Exception ex)
{
m_Logger.Log(ex, "An Exception was thrown while retrieving file information from directory \"{0}\"!", sharedDirectory);
// T.Norad BZ 134. break the loop if an exception is raised
return false;
}
}
SharedFileEntry sharedFileEntry;
foreach (FileInfo fileInfo in fileInfos)
{
if (m_SharedFileEntries.TryGetValue(fileInfo.FullName, out sharedFileEntry))
{
string fileHashString = Core.ByteArrayToString(sharedFileEntry.FileHash);
try
{
m_SharedFiles.Lock();
if (!m_SharedFiles.ContainsKey(fileHashString))
{
MetaDataEntry metaDataEntry;
if (!m_MetaDataEntries.TryGetValue(fileHashString, out metaDataEntry))
metaDataEntry = new MetaDataEntry();
m_SharedFiles.Add(new SharedFile(sharedFileEntry.FilePath, sharedFileEntry.FileHash, metaDataEntry.MetaData, metaDataEntry.Comment, metaDataEntry.Rating, metaDataEntry.LastRequest));
}
}
finally
{
m_SharedFiles.Unlock();
}
}
else
{
AddFile(fileInfo.FullName);
}
}
}
catch (Exception ex)
{
m_Logger.Log(ex, "An exception was thrown while indexing shared directory \"{0}\"!", sharedDirectory);
return false;
}
}
catch (Exception ex)
{
m_Logger.Log(ex, "An exception was thrown while adding a shared directory!");
return false;
}
return true;
}
