public MetadataTree Analyze()
{
if (string.IsNullOrWhiteSpace(this._mTree.RootString))
{
throw new NullReferenceException("元数据树的根节点(RootString)不能为空");
}
if (string.IsNullOrWhiteSpace(this._mTree.Location))
{
throw new NullReferenceException("元数据树的所在的位置(Location)不能为空");
}
if (!Directory.Exists(this._mTree.FullLocation))
{
Directory.CreateDirectory(this._mTree.FullLocation);
}
DirectoryInfo diLocation = new DirectoryInfo(this._mTree.FullLocation);
DirectoryInfo[] directoryInfoArr = diLocation.GetDirectories();
foreach (DirectoryInfo directoryInfo in directoryInfoArr)
{
IMetadataItem dMetadataItem = this.ConvertToMetadataItem(directoryInfo);
this._mTree.ChildItems.Add(dMetadataItem);
}
return(this._mTree);
}
private IMetadataItem ConvertToMetadataItem(DirectoryInfo dInfo)
{
IMetadataItem dirMetadataItem = new DirMetadataItem(this._mTree);
FileInfo[] fileInfoArr = dInfo.GetFiles();
if (fileInfoArr != null && fileInfoArr.Length > 0)
{
foreach (FileInfo fileInfo in fileInfoArr)
{
IMetadataItem mTtem = this.ConvertToMetadataItem(fileInfo);
mTtem.Parent = dirMetadataItem;
dirMetadataItem.ChildItems.Add(mTtem);
}
}
DirectoryInfo[] directoryInofArr = dInfo.GetDirectories();
if (directoryInofArr != null && directoryInofArr.Length > 0)
{
foreach (DirectoryInfo directoryInfo in directoryInofArr)
{
dirMetadataItem.ChildItems.Add(ConvertToMetadataItem(directoryInfo));
}
}
return(dirMetadataItem);
}
private JArray LoadItemData(IMetadataItem item)
{
// prepare the requirements of the data provider
IDataLocation dataLocation = ((IDataSourceItemMetadata)item).DataLocation;
IList <ISchemaColumn> schema = this._metadataLayerService.GetSchema(dataLocation);
var dataRequest = new ConnectorsDataRequest(dataLocation)
{
RequestSettings = new DataRequestSettings {
CacheMode = CacheUsageMode.DefaultMode
}
};
var builder = new ConnectorsTableBuilder();
var requirements = new ConnectorsDataRequirements()
{
DataProvider = this._dataProvider,
DataRequest = dataRequest,
Retrieve = new ConnectorsRetrieve(dataLocation, schema, MaxRowsLimit)
};
// load data in table
this._dataProvider.LoadData(requirements, builder);
// convert table to json object
return(builder.ResultAsJson(schema));
}
public static void AssertMetadataItemAreEqual(IMetadataItem expectedMetadataItem, IMetadataItem testedMetadataItem)
{
Assert.AreEqual(expectedMetadataItem.GetType(), testedMetadataItem.GetType());
if (expectedMetadataItem is RequiredMetadataItem)
{
Assert.AreEqual((expectedMetadataItem as RequiredMetadataItem).IsRequired, (testedMetadataItem as RequiredMetadataItem).IsRequired);
}
else if (expectedMetadataItem is ReadonlyMetadataItem)
{
Assert.AreEqual((expectedMetadataItem as ReadonlyMetadataItem).IsReadonly, (testedMetadataItem as ReadonlyMetadataItem).IsReadonly);
}
else if (expectedMetadataItem is HiddenMetadataItem)
{
Assert.AreEqual((expectedMetadataItem as HiddenMetadataItem).IsHidden, (testedMetadataItem as HiddenMetadataItem).IsHidden);
}
else if (expectedMetadataItem is DisplayNameMetadataItem)
{
Assert.AreEqual((expectedMetadataItem as DisplayNameMetadataItem).Name, (testedMetadataItem as DisplayNameMetadataItem).Name);
}
else
{
throw new NotSupportedException("Not supported yet.");
}
}
public static void AssertMetadataItemAreEqual(IMetadataItem expectedMetadataItem, IMetadataItem testedMetadataItem)
{
Assert.AreEqual(expectedMetadataItem.GetType(), testedMetadataItem.GetType());
if (expectedMetadataItem is RequiredMetadataItem)
{
Assert.AreEqual((expectedMetadataItem as RequiredMetadataItem).IsRequired, (testedMetadataItem as RequiredMetadataItem).IsRequired);
}
else if (expectedMetadataItem is ReadonlyMetadataItem)
{
Assert.AreEqual((expectedMetadataItem as ReadonlyMetadataItem).IsReadonly, (testedMetadataItem as ReadonlyMetadataItem).IsReadonly);
}
else if (expectedMetadataItem is HiddenMetadataItem)
{
Assert.AreEqual((expectedMetadataItem as HiddenMetadataItem).IsHidden, (testedMetadataItem as HiddenMetadataItem).IsHidden);
}
else if (expectedMetadataItem is DisplayNameMetadataItem)
{
Assert.AreEqual((expectedMetadataItem as DisplayNameMetadataItem).Name, (testedMetadataItem as DisplayNameMetadataItem).Name);
}
else
{
throw new NotSupportedException("Not supported yet.");
}
}
public string ToCSDL()
{
StringBuilder sbCsdl = new StringBuilder();
#region Write the <EntityType> element
if (this.BaseType != null)
{
sbCsdl.AppendFormat(_entityTypeWithBaseTypeTemplate, Name, this.BaseType.Name);
}
else
{
sbCsdl.AppendFormat(_entityTypeTemplate, Name);
}
#endregion Write the <EntityType> element
#region Write the <Properties>
foreach (EDMProperty EDMProperty in this.Properties)
{
IMetadataItem im = EDMProperty as IMetadataItem;
sbCsdl.Append(im.ToCSDL());
}
#endregion
#region Write the </EDMEntityType>
sbCsdl.Append("</ComplexType>");
#endregion
return(sbCsdl.ToString());
}
/// <summary>Adds the metadata.</summary>
/// <param name="metadataItem">The metadata item.</param>
public void AddMetadata(IMetadataItem metadataItem)
{
if (MetadataItems == null)
{
MetadataItems = new List <IMetadataItem> ();
}
MetadataItems.Add(metadataItem);
}
private void EvaluateItem(IMetadataItem item)
{
DebugCheck.NotNull(item);
foreach (var rule in _ruleSet.GetRules(item))
{
rule.Evaluate(_context, item);
}
}
private void EvaluateItem(IMetadataItem item)
{
DebugCheck.NotNull(item);
foreach (var rule in _ruleSet.GetRules(item))
{
rule.Evaluate(_context, item);
}
}
public virtual void WriteXml(string targetDir, string metadataFileName, IMetadataItem metadataItem)
{
var xmlSerializer = new XmlSerializer(typeof(MetadataItem));
var streamWriter = new StreamWriter(Path.Combine(targetDir, metadataFileName));
xmlSerializer.Serialize(streamWriter, metadataItem);
streamWriter.Flush();
streamWriter.Close();
}
public static T WithMetadata <T>(this T target, IMetadataItem medatata)
where T : IMetadataItem
{
foreach (var(key, val) in medatata.Metadata)
{
target.Metadata.Add(key, val);
}
return(target);
}
public void AddError(IMetadataItem item, string propertyName, string errorMessage)
{
RaiseDataModelValidationEvent(
new DataModelErrorEventArgs
{
ErrorMessage = errorMessage,
Item = item,
PropertyName = propertyName,
}
);
}
public MetadataItemWrapper(IMetadataItem metadataItem)
{
Details = new List<KeyValuePair<string, string>>();
foreach (var detail in metadataItem.Details)
{
if (!string.IsNullOrEmpty(detail.Name) && !string.IsNullOrEmpty(detail.Value))
{
Details.Add(new KeyValuePair<string, string>(detail.Name.Trim(), detail.Value.Trim().ToUpper()));
}
}
}
public void AddError(IMetadataItem item, string propertyName, string errorMessage)
{
RaiseDataModelValidationEvent(
new DataModelErrorEventArgs
{
ErrorMessage = errorMessage,
Item = item,
PropertyName = propertyName,
}
);
}
public void MetadataItemToXml(IMetadataItem metadataItem, string targetDir)
{
var xmlSerializer = new XmlSerializer(typeof(MetadataItem));
var streamWriter = new StreamWriter(Path.Combine(targetDir, metadataItem.MetadataFilename));
xmlSerializer.Serialize(streamWriter, metadataItem);
streamWriter.Flush();
streamWriter.Close();
File.Copy(metadataItem.OrginalPath, Path.Combine(targetDir, metadataItem.ContentFilename));
}
private void OnCmdSpeichern()
{
if (CheckRequiredFields())
{
_metadataItem = new MetadataItem(this);
_fileSystemService.AddFile(_metadataItem, IsRemoveFileEnabled, _filePath);
_navigateBack();
}
else
{
MessageBox.Show("Es müssen alle Pflichtfelder ausgewählt werden");
}
}
public void AddError(IMetadataItem item, string propertyName, string errorMessage)
{
DebugCheck.NotNull(item);
DebugCheck.NotEmpty(errorMessage);
RaiseDataModelValidationEvent(
new DataModelErrorEventArgs
{
ErrorMessage = errorMessage,
Item = item,
PropertyName = propertyName,
}
);
}
public void AddError(IMetadataItem item, string propertyName, string errorMessage)
{
DebugCheck.NotNull(item);
DebugCheck.NotEmpty(errorMessage);
RaiseDataModelValidationEvent(
new DataModelErrorEventArgs
{
ErrorMessage = errorMessage,
Item = item,
PropertyName = propertyName,
}
);
}
public string GetData(string filePath)
{
try
{
IMetadataItem item = this.GetMetadataItemFromFile(filePath);
return(this.LoadDataAsJson(item));
}
catch (Exception ex)
{
// TODO: log the exception
throw ex;
}
}
public void AddFile(IMetadataItem metadataItem, bool deleteFile)
{
var repositoryDir = _appSettingService.GetRepositoryDir();
var year = metadataItem.ValutaDatum.Year;
var documentId = Guid.NewGuid();
var extension = Path.GetExtension(metadataItem.OrginalPath);
var contentFileName = _filenameGenerator.GetContentFilename(documentId, extension);
var metadataFileName = _filenameGenerator.GetMetadataFilename(documentId);
var targetDir = Path.Combine(repositoryDir, year.ToString());
metadataItem.ContentFileExtension = extension;
metadataItem.ContentFilename = contentFileName;
metadataItem.MetadataFilename = metadataFileName;
metadataItem.DocumentId = documentId;
metadataItem.ValutaYear = year.ToString();
if (!Directory.Exists(targetDir))
{
Directory.CreateDirectory(targetDir);
}
WriteXml(targetDir, metadataFileName, metadataItem);
//move file
File.Copy(metadataItem.OrginalPath, Path.Combine(targetDir, contentFileName));
if (deleteFile)
{
var task = Task.Factory.StartNew(
() =>
{
Task.Delay(500);
File.Delete(metadataItem.OrginalPath);
});
try
{
Task.WaitAll(task);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
}
public void DeleteFile(IMetadataItem metadataItem, bool deleteFile)
{
if (deleteFile)
{
var task = Task.Factory.StartNew(() =>
{
Task.Delay(500);
File.Delete(metadataItem.OrginalPath);
});
try
{
Task.WaitAll(task);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
}
}
string IMetadataItem.ToCSDL()
{
StringBuilder sbCSDL = new StringBuilder();
if (this.IsKey)
{
sbCSDL.AppendFormat(_csdlKeyTemplate, Name);
}
sbCSDL.AppendFormat(_csdlTemplate, Name, Type.FullName.Replace("System", "Edm"), this.IsNullable.ToString().ToLower());
#region Append any annotations available
if (CustomAnnotation != null)
{
IMetadataItem im = CustomAnnotation as IMetadataItem;
sbCSDL.Append(im.ToCSDL());
}
#endregion
sbCSDL.Append(" />");
return(sbCSDL.ToString());
}
public string ToCSDL()
{
StringBuilder sbCsdl = new StringBuilder();
#region Write the <EntityType> element
if (this.BaseType != null)
{
sbCsdl.AppendFormat(_entityTypeWithBaseTypeTemplate, Name, this.BaseType.Namespace, this.BaseType.Name);
}
else
{
sbCsdl.AppendFormat(_entityTypeTemplate, Name);
}
#endregion Write the <EntityType> element
#region Write the <Properties>
foreach (EDMProperty EDMProperty in this.Properties)
{
IMetadataItem im = EDMProperty as IMetadataItem;
sbCsdl.Append(im.ToCSDL());
}
if (this.ComplexTypeProperties != null)
{
foreach (EDMComplexType EDMProperty in this.ComplexTypeProperties)
{
sbCsdl.AppendFormat("<Property Name=\"{0}\" Nullable=\"false\" Type=\"{1}.{2}\" />",
EDMProperty.Name, EDMProperty.Namespace, EDMProperty.Name);
}
}
#endregion
#region Write the </EDMEntityType>
sbCsdl.Append("</EntityType>");
#endregion
return(sbCsdl.ToString());
}
public void AddFile(IMetadataItem metadataItem, bool isRemoveFileEnabled, string sourcePath)
{
MetaDataIteam = metadataItem;
var documentId = GuidGeneratorService.GetNewGuid();
var extension = DirectoryService.GetExtension(sourcePath);
MetaDataIteam.ContentFilename = FilenameGeneratorService.GetContentFilename(documentId, extension);
MetaDataIteam.MetadataFilename = FilenameGeneratorService.GetMetadataFilename(documentId);
var targetDir = DirectoryService.Combine(TargetPath, MetaDataIteam.ValutaYear);
MetaDataIteam.OrginalPath = sourcePath;
MetaDataIteam.PathInRepo = targetDir + @"\" + MetaDataIteam.ContentFilename;
MetaDataIteam.ContentFileExtension = extension;
MetaDataIteam.ContentFilename = MetaDataIteam.ContentFilename;
MetaDataIteam.DocumentId = documentId;
DirectoryService.CreateDirectoryFolder(targetDir);
XmlService.MetadataItemToXml(MetaDataIteam, targetDir);
DirectoryService.DeleteFile(MetaDataIteam, isRemoveFileEnabled);
}
protected IMetadataItem GetMetadataItemFromFile(string filePath)
{
string fileDirectory = Path.GetDirectoryName(filePath);
string fileName = Path.GetFileName(filePath);
// replace the original root folder with the one where the desired file is located
ISettingsProvider settings = this._dataProviderServices.GetSettingsProvider(LocalFileProviderName);
string originalFolder = settings.GetSetting(LocalFileProviderRootFolder, string.Empty);
settings.SetSetting(LocalFileProviderRootFolder, fileDirectory);
// get the metadata of the desired file
IDataSourceMetadata localRoot = this._metadataLayerService.GetDataSourceMetadata(new ServerLocation(new DataSource {
Id = DataSourceId, Provider = LocalFileProviderName
}));
IList <IMetadataItem> children = this._metadataLayerService.GetContentMetadata(localRoot);
IMetadataItem item = children.FirstOrDefault(c => c.DisplayName == fileName);
// restore the original root folder
settings.SetSetting(LocalFileProviderRootFolder, originalFolder);
return(item);
}
public string GetData(string filePath, string[] sheetNames)
{
try
{
if (sheetNames == null || sheetNames.All(x => string.IsNullOrEmpty(x)))
{
return(string.Empty);
}
IMetadataItem item = this.GetMetadataItemFromFile(filePath);
// find the desired sheet in item's children array
IList <IMetadataItem> itemChildren = this._metadataLayerService.GetContentMetadata(item);
IEnumerable <IMetadataItem> sheets = itemChildren.Where(c => c.ItemType == MetadataConstants.SHEET && sheetNames.Contains(c.DisplayName, new StringIgnoreCaseComparer()));
return(this.LoadDataAsJson(sheets));
}
catch (Exception ex)
{
// TODO: log the exception
throw ex;
}
}
public FileMetadataItem(IMetadataItem parent, MetadataType mType)
: base(parent)
{
this.MetadataType = mType;
}
public static void WriteComplexType(EDMComplexType EDMComplexType, StringBuilder sbCsdl)
{
IMetadataItem im = EDMComplexType as IMetadataItem;
sbCsdl.Append(im.ToCSDL());
}
public DirMetadataItem(IMetadataItem parent, MetadataType mType)
: base(parent, mType)
{
}
protected string LoadDataAsJson(IMetadataItem item)
{
return(this.LoadDataAsJson(Enumerable.Repeat(item, 1)));
}
public XmlMetadataItem(IMetadataItem parent)
: base(parent, MetadataType.Xml)
{
}
internal abstract void Evaluate(EdmModelValidationContext context, IMetadataItem item);
private void WriteMetadataItem(string text, IMetadataItem mi)
{
//this.writer.Write(String.Format(@"{{\rtf1 {0}\v #0x{1:x08}\v0}}", text, mi.Token), false);
this.writer.WriteLink(text, String.Format("0x{0:x08}", mi.Token));
}
internal abstract void Evaluate(EdmModelValidationContext context, IMetadataItem item);
/// <summary>Initializes a new instance of the <see cref="MetadataAttribute" /> class.</summary>
/// <param name="metadataItem">The metadata item.</param>
public MetadataAttribute(IMetadataItem metadataItem)
{
MetadataItem = metadataItem;
}
internal IEnumerable<DataModelValidationRule> GetRules(IMetadataItem itemToValidate)
{
DebugCheck.NotNull(itemToValidate);
return _rules.Where(r => r.ValidatedType.IsInstanceOfType(itemToValidate));
}
internal override void Evaluate(EdmModelValidationContext context, IMetadataItem item)
{
_validate(context, (TItem)item);
}
public DllMetadataItem(IMetadataItem parent)
: base(parent, MetadataType.Dll)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="MetadataItemWrapper"/> class.
/// </summary>
/// <param name="metadataItem">The metadata item.</param>
/// <param name="metadataLayerLevel">The metadata layer level.</param>
public MetadataItemWrapper( IMetadataItem metadataItem, int metadataLayerLevel )
{
MetadataItem = metadataItem;
MetadataLayerLevel = metadataLayerLevel;
}
