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) { }