public static MetadataPackageRepository Create(MetadataPackage branchPackage)
{
switch (branchPackage.MetadataType)
{
case MetadataType.Xmp:
return new XmpMetadataRepository(branchPackage);
case MetadataType.Exif:
if (branchPackage is ExifPackage)
{
return new ExifMetadataRepository(branchPackage);
}
return new OneLevelMetadataRepository(branchPackage);
case MetadataType.Iptc:
return new IptcMetadataRepository(branchPackage);
case MetadataType.ID3V2:
return new ID3V2TagRepository(branchPackage);
case MetadataType.Matroska:
if (branchPackage is MatroskaTag)
{
return new MatroskaTagRepository(branchPackage);
}
if (branchPackage is MatroskaTrack)
{
return new MatroskaTrackRepository(branchPackage);
}
return new OneLevelMetadataRepository(branchPackage);
case MetadataType.FileFormat:
return new FileTypeRepository(branchPackage);
case MetadataType.VCard:
if (branchPackage is VCardCard)
{
return new VCardRepository(branchPackage);
}
return new OneLevelMetadataRepository(branchPackage);
case MetadataType.Asf:
if (branchPackage is AsfPackage)
{
return new AsfRepository(branchPackage);
}
if (branchPackage is AsfCodec)
{
return new AsfCodecRepository(branchPackage);
}
if (branchPackage is AsfBaseStreamProperty)
{
return new AsfStreamRepository(branchPackage);
}
return new OneLevelMetadataRepository(branchPackage);
case MetadataType.OpenType:
if (branchPackage is OpenTypeFont)
{
return new OpenTypeRepository(branchPackage);
}
return new OneLevelMetadataRepository(branchPackage);
case MetadataType.DigitalSignature:
return new DigitalSignatureRepository(branchPackage);
default:
return new OneLevelMetadataRepository(branchPackage);
}
}
public MetadataPackage GetPackageByPath(MetadataPackage branchPackage, string path)
{
foreach (var packageInfo in GetPackages(branchPackage, path))
{
return(packageInfo.Package);
}
return(null);
}
private IEnumerable <NestedPackageInfo> GetPackages(MetadataPackage branchPackage, string path)
{
var parts = path.Split(PathSeparator);
var current = branchPackage;
int i = 0;
while (i < parts.Length && current != null)
{
MetadataPackage next = null;
if (current.Contains(parts[i]))
{
var property = current[parts[i]];
if (property.Value != null)
{
if (property.Value.Type == MetadataPropertyType.Metadata)
{
next = property.Value.ToClass <MetadataPackage>();
}
else if (property.Value.Type == MetadataPropertyType.MetadataArray)
{
var packages = property.Value.ToArray <MetadataPackage>();
i++;
if (i < parts.Length)
{
int index;
if (int.TryParse(parts[i], out index))
{
next = packages[index];
}
}
else
{
for (int j = 0; j < packages.Length; j++)
{
yield return(new NestedPackageInfo(packages[j], CombinePath(path, j.ToString()), j));
}
}
}
}
}
current = next;
i++;
}
if (current != null)
{
yield return(new NestedPackageInfo(current, path));
}
}
public bool Delete(MetadataPackage entity)
{
Contract.Requires(entity != null);
Contract.Requires(entity.Id >= 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <MetadataPackage> repo = uow.GetRepository <MetadataPackage>();
entity = repo.Reload(entity);
repo.Delete(entity);
uow.Commit();
}
// if any problem was detected during the commit, an exception will be thrown!
return(true);
}
public MetadataPackage Update(MetadataPackage entity)
{
Contract.Requires(entity != null, "provided entity can not be null");
Contract.Requires(entity.Id >= 0, "provided entity must have a permanent ID");
Contract.Ensures(Contract.Result <MetadataPackage>() != null && Contract.Result <MetadataPackage>().Id >= 0, "No entity is persisted!");
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <MetadataPackage> repo = uow.GetRepository <MetadataPackage>();
repo.Put(entity); // Merge is required here!!!!
uow.Commit();
}
return(entity);
}
public MetadataAttributeUsage AddMetadataAtributeUsage(MetadataPackage package, MetadataAttribute attribute, string label, string description, int minCardinality, int maxCardinality)
{
Contract.Requires(package != null && package.Id >= 0);
Contract.Requires(attribute != null && attribute.Id >= 0);
Contract.Ensures(Contract.Result <MetadataAttributeUsage>() != null && Contract.Result <MetadataAttributeUsage>().Id >= 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
var metadataPackageRepo = uow.GetReadOnlyRepository <MetadataPackage>();
var attributesRepo = uow.GetReadOnlyRepository <MetadataAttribute>();
attribute = attributesRepo.Get(attribute.Id);
metadataPackageRepo.Reload(package);
metadataPackageRepo.LoadIfNot(package.MetadataAttributeUsages);
int count = 0;
try
{
count = (from v in package.MetadataAttributeUsages
where v.MetadataAttribute.Id.Equals(attribute.Id)
select v
)
.Count();
}
catch { }
MetadataAttributeUsage usage = new MetadataAttributeUsage()
{
MetadataPackage = package,
MetadataAttribute = attribute,
// if there is no label provided, use the attribute name and a sequence number calculated by the number of occurrences of that attribute in the current structure
Label = !string.IsNullOrWhiteSpace(label) ? label : (count <= 0 ? attribute.Name : string.Format("{0} ({1})", attribute.Name, count)),
Description = description,
MinCardinality = minCardinality,
MaxCardinality = maxCardinality,
};
package.MetadataAttributeUsages.Add(usage);
attribute.UsedIn.Add(usage);
IRepository <MetadataAttributeUsage> repo = uow.GetRepository <MetadataAttributeUsage>();
repo.Put(usage);
uow.Commit();
return(usage);
}
}
public void Save(MetadataPackage package, string path, ProjectType projectType)
{
string projectFolder = Path.GetDirectoryName(path);
if (!Directory.Exists(projectFolder))
{
Directory.CreateDirectory(projectFolder);
}
_settings = new CfProjectSettings()
{
Type = projectType,
Version = package.GetType().Assembly.GetName().Version.ToString(),
MdInternalsVersion = this.GetType().Assembly.GetName().Version.ToString(),
PackageType = package.GetType().FullName
};
package.MetadataObjects.AsParallel().ForAll(m =>
{
string relativePath = GetRelativePath(m, projectType);
FileInfo fileInfo = null;
if (m.ImageRow.BodyType == ImageRowTypes.CompressedImage)
{
fileInfo = UnloadImage(projectFolder, relativePath, m, projectType);
}
else
{
fileInfo = UnloadElement(projectFolder, relativePath, m, projectType);
}
lock (this._settings)
{
this._settings.Files.Add(fileInfo);
}
});
var settings = new XmlWriterSettings()
{
Indent = true
};
using (XmlWriter xmlWriter = XmlWriter.Create(path, settings))
{
System.Windows.Markup.XamlWriter.Save(_settings, xmlWriter);
}
}
public IEnumerable <NestedPackageInfo> GetRegisteredPackages(MetadataPackage branchPackage)
{
yield return(new NestedPackageInfo(branchPackage, string.Empty));
var packageType = branchPackage.GetType();
if (metadataPaths.ContainsKey(packageType))
{
foreach (var packagePath in metadataPaths[packageType])
{
foreach (var nestedPackage in GetPackages(branchPackage, packagePath))
{
yield return(nestedPackage);
}
}
}
}
public void Save(MetadataPackage package, string folder, ProjectType projectType)
{
_settings = new CfProjectSettings()
{
Type = projectType
};
package.MetadataObjects.AsParallel().ForAll(m => UnloadObject(folder, m as ImageRowElement, projectType));
var settings = new XmlWriterSettings()
{
Indent = true
};
using (XmlWriter xmlWriter = XmlWriter.Create(folder + "/" + package.PackagePart.GeneralProperties.Name + ".cfproj", settings))
{
System.Windows.Markup.XamlWriter.Save(_settings, xmlWriter);
}
}
public static void UnloadCommonModules(MetadataPackage mp, string folder)
{
var requestModules = from o in mp.MetadataObjects.OfType <CommonModule>()
select o;
var requestContent = from module in requestModules
join ir in mp.MetadataObjects on module.ImageRow.FileName + ".0" equals ir.ImageRow.FileName
where ir.ImageRow.Body is Image
orderby module.Name
select new { FileName = module.Name, OriginalImage = ((Image)ir.ImageRow.Body), Module = ((Image)ir.ImageRow.Body).Rows.Where(i => i.FileName == "info").FirstOrDefault(), Image = ((Image)ir.ImageRow.Body).Rows.Where(i => i.FileName == "image").FirstOrDefault() };
var files = requestContent.ToArray();
foreach (var file in files)
{
if (file.Image == null)
{
continue;
}
string fileName = file.FileName;
string opCodeString = file.Image.Body.ToString();
//if (!(fileName == "Инт_СистемаСервер" || fileName == "Инт_СистемаСерверКэшируемый"))
// continue;
using (StreamWriter outfile =
new StreamWriter(folder + fileName + ".opcode"))
{
outfile.Write(opCodeString);
}
CodeReader reader = new CodeReader(opCodeString, false);
string decompiledString = reader.GetSourceCode();
using (StreamWriter outfile =
new StreamWriter(folder + fileName + ".txt"))
{
outfile.Write(decompiledString);
}
}
}
public MetadataPackage Create(string name, string description, bool isEnabled = false)
{
Contract.Requires(!string.IsNullOrWhiteSpace(name));
Contract.Ensures(Contract.Result <MetadataPackage>() != null && Contract.Result <MetadataPackage>().Id >= 0);
MetadataPackage e = new MetadataPackage()
{
Name = name,
Description = description,
IsEnabled = isEnabled,
};
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <MetadataPackage> repo = uow.GetRepository <MetadataPackage>();
repo.Put(e);
uow.Commit();
}
return(e);
}
private static List <LinkElementModel> getChildrenFromMetadataPackage(long metadataPackageId, LinkElementPostion pos)
{
MetadataPackageManager metadataPackageManager = new MetadataPackageManager();
try
{
MetadataPackage metadataPackage = metadataPackageManager.MetadataPackageRepo.Get(metadataPackageId);
List <LinkElementModel> tmp = new List <LinkElementModel>();
foreach (var attr in metadataPackage.MetadataAttributeUsages)
{
LinkElementComplexity complexity = LinkElementComplexity.None;
LinkElementType type = LinkElementType.ComplexMetadataAttribute;
complexity = attr.MetadataAttribute.Self is MetadataSimpleAttribute
? LinkElementComplexity.Simple
: LinkElementComplexity.Complex;
//type = attr.Member.Self is MetadataSimpleAttribute
// ? LinkElementType.SimpleMetadataAttribute
// : LinkElementType.ComplexMetadataAttribute;
type = LinkElementType.MetadataNestedAttributeUsage;
tmp.Add(
new LinkElementModel(
0,
attr.Id,
type, attr.Label, "", pos, complexity, attr.Description)
);
}
return(tmp);
}
finally
{
metadataPackageManager.Dispose();
}
}
public DigitalSignatureRepository(MetadataPackage branchPackage) : base(branchPackage)
{
}
public VCardRepository(MetadataPackage branchPackage) : base(branchPackage)
{
}
public MetadataPackageUsage AddMetadataPackageUsage(MDS.MetadataStructure structure, MetadataPackage package, string label, string description, int minCardinality, int maxCardinality, XmlDocument extra = null)
{
Contract.Requires(package != null && package.Id >= 0);
Contract.Requires(structure != null && structure.Id >= 0);
Contract.Ensures(Contract.Result <MetadataPackageUsage>() != null && Contract.Result <MetadataPackageUsage>().Id >= 0);
using (IUnitOfWork uow = this.GetUnitOfWork())
{
IRepository <MetadataPackageUsage> repo = uow.GetRepository <MetadataPackageUsage>();
IRepository <MDS.MetadataStructure> repo2 = uow.GetRepository <MDS.MetadataStructure>();
repo2.Reload(structure);
repo2.LoadIfNot(structure.MetadataPackageUsages);
int count = 0;
try
{
count = (from v in structure.MetadataPackageUsages
where v.MetadataPackage.Id.Equals(package.Id)
select v
)
.Count();
}
catch { }
MetadataPackageUsage usage = new MetadataPackageUsage()
{
MetadataPackage = package,
MetadataStructure = structure,
// if no label is provided, use the package name and a sequence number calculated by the number of occurrences of that package in the current structure
Label = !string.IsNullOrWhiteSpace(label) ? label : (count <= 0 ? package.Name : string.Format("{0} ({1})", package.Name, count)),
Description = description,
MinCardinality = minCardinality,
MaxCardinality = maxCardinality,
Extra = extra
};
structure.MetadataPackageUsages.Add(usage);
package.UsedIn.Add(usage);
repo.Put(usage);
uow.Commit();
return(usage);
}
}
public OpenTypeRepository(MetadataPackage branchPackage) : base(branchPackage, EnumMap)
{
}
public NestedPackageInfo(MetadataPackage package, string path) : this(package, path, -1)
{
}
private XElement setChildren(XElement element, BaseUsage usage, XDocument importDocument = null)
{
MetadataAttribute metadataAttribute = null;
MetadataPackage metadataPackage = null;
if (usage is MetadataAttributeUsage)
{
MetadataAttributeUsage metadataAttributeUsage = (MetadataAttributeUsage)usage;
metadataAttribute = metadataAttributeUsage.MetadataAttribute;
}
else if (usage is MetadataNestedAttributeUsage)
{
MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)usage;
metadataAttribute = mnau.Member;
}
else
{
MetadataPackageUsage mpu = (MetadataPackageUsage)usage;
metadataPackage = mpu.MetadataPackage;
}
if (metadataAttribute != null && metadataAttribute.Self is MetadataCompoundAttribute)
{
MetadataCompoundAttribute mca = this.GetUnitOfWork().GetReadOnlyRepository <MetadataCompoundAttribute>().Get(metadataAttribute.Self.Id);
foreach (MetadataNestedAttributeUsage nestedUsage in mca.MetadataNestedAttributeUsages)
{
if (importDocument != null)
{
string parentPath = element.GetAbsoluteXPathWithIndex();
string usagePath = parentPath + "/" + nestedUsage.Label;
XElement usageElement = importDocument.XPathSelectElement(usagePath);
List <XElement> typeList = new List <XElement>();
if (usageElement != null && usageElement.HasElements)
{
int num = usageElement.Elements().Count();
if (num == 0)
{
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
}
else
{
typeList = AddAndReturnAttribute(element, nestedUsage, 1, num);
}
}
else
{
Debug.WriteLine("NULL OR EMPTY:------> " + usagePath);
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
}
foreach (var type in typeList)
{
setChildren(type, nestedUsage, importDocument);
}
}
else
{
List <XElement> typeList = new List <XElement>();
typeList = AddAndReturnAttribute(element, nestedUsage, 1, 1);
setChildren(typeList.FirstOrDefault(), nestedUsage, importDocument);
}
}
}
else
{
if (metadataPackage != null)
{
foreach (MetadataAttributeUsage attrUsage in metadataPackage.MetadataAttributeUsages)
{
if (importDocument != null)
{
string parentPath = element.GetAbsoluteXPathWithIndex();
string usagePath = parentPath + "/" + attrUsage.Label;
XElement usageElement = importDocument.XPathSelectElement(usagePath);
List <XElement> typeList = new List <XElement>();
if (usageElement != null && usageElement.HasElements)
{
int num = usageElement.Elements().Count();
if (num == 0)
{
typeList = AddAndReturnAttribute(element, attrUsage, 1, 1);
}
else
{
typeList = AddAndReturnAttribute(element, attrUsage, 1, num);
}
}
else
{
Debug.WriteLine("NULL OR EMPTY:------> " + usagePath);
typeList = AddAndReturnAttribute(element, attrUsage, 1, 1);
}
foreach (var type in typeList)
{
setChildren(type, attrUsage, importDocument);
}
}
else
{
List <XElement> typeList = new List <XElement>();
typeList = AddAndReturnAttribute(element, attrUsage, 1, 1);
setChildren(typeList.FirstOrDefault(), attrUsage, importDocument);
}
}
}
}
return(element);
}
public NestedPackageInfo(MetadataPackage package, string path, int index)
{
Package = package;
Path = path;
Index = index;
}
public OneLevelMetadataRepository(MetadataPackage branchPackage) : base(branchPackage)
{
}
public AsfStreamRepository(MetadataPackage branchPackage) : base(branchPackage, EnumMap)
{
}
public MatroskaTrackRepository(MetadataPackage branchPackage) : base(branchPackage, EnumMap)
{
}
public AsfCodecRepository(MetadataPackage branchPackage) : base(branchPackage, EnumMap)
{
}
protected EnumMapperRepository(MetadataPackage branchPackage, IDictionary <string, Type> enumMap) : base(branchPackage)
{
this.enumMap = enumMap;
}
protected MetadataPackageRepository(MetadataPackage branchPackage)
{
BranchPackage = branchPackage;
}
public CanonMakerNoteRepository(MetadataPackage branchPackage) : base(branchPackage)
{
}
public MatroskaTagRepository(MetadataPackage branchPackage) : base(branchPackage)
{
}
public void ConvertMetadataAttributeModels(BaseUsage source, long metadataStructureId, int stepId)
{
Source = source;
//if (Source is MetadataAttributeUsage)
//{
// MetadataAttributeUsage mau = (MetadataAttributeUsage)Source;
// if (mau.MetadataAttribute.Self is MetadataCompoundAttribute)
// {
// MetadataCompoundAttribute mca = (MetadataCompoundAttribute)mau.MetadataAttribute.Self;
// if (mca != null)
// {
// foreach (MetadataNestedAttributeUsage usage in mca.MetadataNestedAttributeUsages)
// {
// if (UsageHelper.IsSimple(usage))
// {
// MetadataAttributeModels.Add(MetadataAttributeModel.Convert(usage, mau, metadataStructureId, Number));
// }
// }
// }
// }
//}
//if (Source is MetadataNestedAttributeUsage)
//{
// MetadataNestedAttributeUsage mnau = (MetadataNestedAttributeUsage)Source;
// if (mnau.Member.Self is MetadataCompoundAttribute)
// {
// MetadataCompoundAttribute mca = (MetadataCompoundAttribute)mnau.Member.Self;
// if (mca != null)
// {
// foreach (MetadataNestedAttributeUsage usage in mca.MetadataNestedAttributeUsages)
// {
// if (UsageHelper.IsSimple(usage))
// {
// MetadataAttributeModels.Add(MetadataAttributeModel.Convert(usage, mnau, metadataStructureId, Number));
// }
// }
// }
// }
//}
if (Source is MetadataPackageUsage)
{
MetadataPackageUsage mpu = (MetadataPackageUsage)Source;
if (mpu.MetadataPackage is MetadataPackage)
{
MetadataPackage mp = mpu.MetadataPackage;
if (mp != null)
{
foreach (MetadataAttributeUsage usage in mp.MetadataAttributeUsages)
{
if (metadataStructureUsageHelper.IsSimple(usage))
{
MetadataAttributeModels.Add(FormHelper.CreateMetadataAttributeModel(usage, mpu, metadataStructureId, Number, stepId));
}
}
}
}
}
}
public XmpMetadataRepository(MetadataPackage branchPackage) : base(branchPackage)
{
}
public ID3V2TagRepository(MetadataPackage branchPackage) : base(branchPackage)
{
}
