/// <summary>
/// Creates a new instance of a Microfocus vision file
/// </summary>
/// <param name="fileDefinition">Definition of the file</param>
/// <param name="filePath">File path</param>
/// <param name="visionLibrary">Library for manage vision file</param>
internal MicrofocusVisionFile(VisionFileDefinition fileDefinition, string filePath, IMicrofocusVisionLibrary visionLibrary)
{
FileDefinition = fileDefinition ?? throw new ArgumentNullException(nameof(fileDefinition));
FilePath = filePath ?? throw new ArgumentNullException(nameof(filePath));
VisionLibrary = visionLibrary ?? throw new ArgumentNullException(nameof(visionLibrary));
DataConverter = new MicrofocusDataConverter(FileDefinition);
}
/// <summary>
/// Converts a Vision file definition to EntityMetadata
/// </summary>
/// <param name="fileDefinition">File definition to convert</param>
/// <returns>Requested metadata</returns>
public static EntityMetadata ToMetadata(this VisionFileDefinition fileDefinition)
{
if (fileDefinition == null)
{
return(null);
}
var result = new EntityMetadata
{
Name = fileDefinition.FileName,
IsReadOnly = false,
Fields = GetFieldsMetadata(fileDefinition)
};
return(result);
}
/// <summary>
/// Get vision record fields as list of field metadata
/// </summary>
/// <param name="fileDefinition">Vision file definition</param>
/// <returns>List of metadata</returns>
private static List <FieldMetadata> GetFieldsMetadata(VisionFileDefinition fileDefinition)
{
var result = new List <FieldMetadata>();
foreach (var field in fileDefinition.Fields.Where(x => !x.IsGroupField))
{
var metadata = new FieldMetadata {
IsReadOnly = false,
IsPrimaryKey = fileDefinition.Keys[0].Fields.Where(x => x.Name == field.Name).Count() > 0,
Name = field.GetDotnetName(),
Scale = field.Scale,
Size = field.Size,
Type = ToFieldDataType(field.FieldType)
};
result.Add(metadata);
}
return(result);
}
/// <summary>
/// Creates a new instance of Microfocus data converter
/// </summary>
/// <param name="fileDefinition">File definition for conversions</param>
public MicrofocusDataConverter(VisionFileDefinition fileDefinition)
{
FileDefinition = fileDefinition ?? throw new ArgumentNullException(nameof(fileDefinition));
}
/// <summary>
/// Creates a new instance of Microfocus Vision record
/// </summary>
/// <param name="fileDefinition">Definition of the file</param>
/// <param name="dataConverter">Data converter between byte array (raw data) and .NET types</param>
internal MicrofocusVisionRecord(VisionFileDefinition fileDefinition, MicrofocusDataConverter dataConverter)
{
FileDefinition = fileDefinition ?? throw new ArgumentNullException(nameof(fileDefinition));
DataConverter = dataConverter ?? throw new ArgumentNullException(nameof(dataConverter));
RawContent = DataConverter.GetEmptyRecordContent();
}
/// <summary>
/// Gets a vision file definition based on its XFD file
/// </summary>
/// <param name="xfdFilePath">XFD file path</param>
/// <returns>Requested file definition</returns>
public VisionFileDefinition LoadFromXfd(string xfdFilePath)
{
if (string.IsNullOrEmpty(xfdFilePath))
{
throw new ArgumentNullException(nameof(xfdFilePath));
}
if (!File.Exists(xfdFilePath))
{
throw new ArgumentException(string.Format("XFD file {0} not found", xfdFilePath), nameof(xfdFilePath));
}
// Load file
var xfd = XElement.Load(xfdFilePath);
// Result
var result = new VisionFileDefinition();
// Identification data
var identification = xfd.Element(XfdNs + "identification");
if (identification == null)
{
throw new IOException(string.Format("Invalid xfd file: {0}", xfdFilePath));
}
result.SelectName = (string)identification.Element(XfdNs + "select-name");
result.FileName = ((string)identification.Element(XfdNs + "table-name")).ToLowerInvariant();
result.Alphabet = (string)identification.Element(XfdNs + "alphabet");
result.MinRecordSize = (int)identification.Element(XfdNs + "minimum-record-size");
result.MaxRecordSize = (int)identification.Element(XfdNs + "maximum-record-size");
result.NumberOfKeys = (int)identification.Element(XfdNs + "number-of-keys");
// Fields
var fields = xfd.Element(XfdNs + "fields");
foreach (var field in fields.Elements(XfdNs + "field"))
{
result.Fields.Add(GetFieldDefiniton(field));
}
// Occurs (Load fields with index suffix)
foreach (var occurs in GetOccurses(fields))
{
result.Occurses.Add(occurs);
}
// Keys
XElement keys = xfd.Element(XfdNs + "keys");
foreach (XElement key in keys.Elements(XfdNs + "key"))
{
var vKey = new VisionKeyDefinition
{
IsUnique = !(bool)key.Attribute(XfdNs + "duplicates-allowed")
};
// Key columns
foreach (XElement keyColumn in key.Element(XfdNs + "key-columns")?.Elements(XfdNs + "key-column"))
{
string fieldName = (string)keyColumn.Attribute(XfdNs + "key-column-name");
vKey.Fields.Add(result.Fields.Single(x => x.Name == fieldName));
}
// Key segments
foreach (var segment in key.Elements(XfdNs + "segments").Elements(XfdNs + "segment"))
{
var strSize = (string)segment.Attribute(XfdNs + "segment-size");
var strOffset = (string)segment.Attribute(XfdNs + "segment-offset");
if (int.TryParse(strSize, out int size) &&
int.TryParse(strOffset, out int offset))
{
vKey.Segments.Add(new VisionKeySegment
{
Offset = offset,
Size = size
});
}
}
result.Keys.Add(vKey);
}
return(result);
}
/// <summary>
/// Vision file manager
/// </summary>
/// <param name="fileDefintion"></param>
/// <param name="fileSystem"></param>
public VisionFileEntityManager(VisionFileDefinition fileDefintion, IVisionFileSystem fileSystem)
{
FileDefinition = fileDefintion ?? throw new ArgumentNullException(nameof(fileDefintion));
FileSystem = fileSystem ?? throw new ArgumentNullException(nameof(fileSystem));
EntityMetadata = FileDefinition.ToMetadata();
}
