private String thePath; // Path of this file
// ------------------------------------------------------------------------------------------
/// <summary>
/// Constructor
/// </summary>
/// <param name="path">Path of the file to be parsed</param>
public AudioFileReader(String path)
{
thePath = path;
theFactory = AudioReaderFactory.GetInstance();
audioData = theFactory.GetDataReader(path);
metaData = theFactory.GetMetaReader(path, audioData);
}
public UploadedFileRepository(IFileStore fileStore, IFileWriter fileWriter, IMetadataReader metadataReader, ILogger <UploadedFileRepository> logger)
{
this._fileStore = fileStore;
this._logger = logger;
this._metadataReader = metadataReader;
this._fileWriter = fileWriter;
}
private String thePath; // Path of this file
// ------------------------------------------------------------------------------------------
/// <summary>
/// Constructor
/// </summary>
/// <param name="path">Path of the file to be parsed</param>
public AudioFileReader(String path)
{
thePath = path;
theFactory = AudioReaderFactory.GetInstance();
audioData = theFactory.GetDataReader(path);
metaData = theFactory.GetMetaReader(path, audioData);
}
#pragma warning restore IDE0032
public ModuleSupervisor(DirectoryInfo directory,
IMetadataReader metadataReader,
ILogger <ModuleSupervisor> logger = null)
{
if (directory == null)
{
throw new ArgumentNullException(nameof(directory));
}
if (metadataReader == null)
{
throw new ArgumentNullException(nameof(metadataReader));
}
Directory = directory;
_metadataReader = metadataReader;
_logger = logger;
// Volatile write op (Is avtually not necessary here, because the CLR enforces thread-safety.)
_state = ModuleSupervisorState.Initializing;
_metadataLazy = new DisposableAsyncLazy <IModuleMetadata>(
factory: LookupMetadataAsync,
options: DisposableAsyncLazyOptions.Autostart | DisposableAsyncLazyOptions.ExecuteOnCallingThread | DisposableAsyncLazyOptions.RetryOnFailure);
_supervisorProcess = new AsyncProcess(SupervisorProcessRoutine, start: true);
_disposeHelper = new AsyncDisposeHelper(DisposeInternalAsync);
}
private TypeSpec GetTypeSpec(Type type, IMetadataReader metadataReader)
{
if (!type.HasExportAttribute(metadataReader))
{
throw new CoreException($"Type '{type.FullName}' should have an ExportAttribute attribute");
}
var exportAttribute = metadataReader.GetAttributes(type).FirstOrDefault(a => a is ExportAttribute) as ExportAttribute;
IEnumerable <Attribute> additionalAttributes = metadataReader.GetAttributes(type)
.Where(a => !(a is ExportAttribute))
.OfType <Attribute>();
var typeSpec = new TypeSpec(exportAttribute);
foreach (Attribute additionalAttribute in additionalAttributes)
{
typeSpec.AdditionalAttributes.Add(additionalAttribute);
}
foreach (MemberInfo memberInfo in type.GetTsExportableMembers(metadataReader, false))
{
IEnumerable <Attribute> attributes = metadataReader
.GetAttributes(memberInfo)
.OfType <Attribute>();
typeSpec.MemberAttributes.Add(memberInfo.Name, attributes.ToList());
}
return(typeSpec);
}
private void connectBtnClicked(object sender, EventArgs e)
{
if (_currentConnection == null)
{
return;
}
toolStripStatusLabel1.Text = string.Format("Connecting to {0}...", _currentConnection.Name);
statusStrip1.Refresh();
Cursor.Current = Cursors.WaitCursor;
try
{
tablesListBox.DataSource = null;
tablesListBox.DisplayMember = "Name";
sequencesComboBox.Items.Clear();
metadataReader = MetadataFactory.GetReader(_currentConnection.Type, _currentConnection.ConnectionString);
toolStripStatusLabel1.Text = "Retrieving owners...";
statusStrip1.Refresh();
PopulateOwners();
toolStripStatusLabel1.Text = string.Empty;
}
catch (Exception ex)
{
toolStripStatusLabel1.Text = ex.Message;
}
finally
{
Cursor.Current = Cursors.Default;
}
}
public void AddMetadataReader(IMetadataReader reader)
{
lock (_metadataReadersSyncRoot)
{
var currentReader = MetadataReader;
MetadataReader = currentReader == null ? reader : new MetadataReader(reader, currentReader);
}
}
public void ShouldCreateTheAppropriateMetadataReader()
{
IMetadataReader metadataReader = MetadataFactory.GetReader(ServerType.Oracle, "conn");
Assert.That(metadataReader, Is.TypeOf(typeof (OracleMetadataReader)));
metadataReader = MetadataFactory.GetReader(ServerType.SqlServer, "conn");
Assert.That(metadataReader, Is.TypeOf(typeof (SqlServerMetadataReader)));
}
internal CameraFileNameConverter(
IMetadataReader metadataReader,
CameraFileFactory cameraFileFactory,
IFileSystem fileSystem)
{
_metadataReader = metadataReader;
_cameraFileFactory = cameraFileFactory;
_fileSystem = fileSystem;
}
public MetadataAccessor(IMetadataReader metadataReader)
{
if (metadataReader == null)
{
throw new ArgumentNullException(nameof(metadataReader));
}
_metadataReader = metadataReader;
}
/// <summary>
/// Checks if a type is marked with an ExportTs... attribute
/// </summary>
/// <param name="type"></param>
/// <param name="reader"></param>
/// <returns></returns>
public static bool HasExportAttribute(this Type type, IMetadataReader reader)
{
Requires.NotNull(type, nameof(type));
Requires.NotNull(reader, nameof(reader));
return(reader.GetAttribute <ExportTsClassAttribute>(type) != null ||
reader.GetAttribute <ExportTsInterfaceAttribute>(type) != null ||
reader.GetAttribute <ExportTsEnumAttribute>(type) != null);
}
/// <summary>
/// Creates mapping schema using provided EF.Core data model and metadata provider.
/// </summary>
/// <param name="model">EF.Core data model.</param>
/// <param name="metadataReader">Additional optional LINQ To DB database metadata provider.</param>
/// <returns>Mapping schema for provided EF.Core model.</returns>
public virtual MappingSchema GetMappingSchema(IModel model, IMetadataReader metadataReader)
{
var schema = new MappingSchema();
if (metadataReader != null)
{
schema.AddMetadataReader(metadataReader);
}
return(schema);
}
public ModuleSupervisorFactory(IMetadataReader metadataReader, ILoggerFactory loggerFactory = null)
{
if (metadataReader == null)
{
throw new ArgumentNullException(nameof(metadataReader));
}
_metadataReader = metadataReader;
_loggerFactory = loggerFactory;
}
internal void AddReader(IMetadataReader reader)
{
// creation of new list is cheaper than lock on each method call
var newReaders = new List <IMetadataReader>(_readers.Count + 1)
{
reader
};
newReaders.AddRange(_readers);
Volatile.Write(ref _readers, newReaders);
}
public MetadataListCommand(
List <string> args,
IMetadataReader metadataReader,
IFile fileWrapper,
IOutputWriter outputWriter)
{
_args = args;
_metadataReader = metadataReader;
_fileWrapper = fileWrapper;
_outputWriter = outputWriter;
}
public TsContentGenerator(ITypeDependencyService typeDependencyService,
ITypeService typeService,
ITemplateService templateService,
ITsContentParser tsContentParser,
IMetadataReader metadataReader)
{
_typeDependencyService = typeDependencyService;
_typeService = typeService;
_templateService = templateService;
_tsContentParser = tsContentParser;
_metadataReader = metadataReader;
}
private async Task ConnectToInfoBase(object parameter)
{
TreeNodeViewModel treeNode = parameter as TreeNodeViewModel;
if (treeNode == null)
{
return;
}
Server server = treeNode.NodePayload as Server;
if (server == null)
{
return;
}
IMetadataReader metadataReader = _shell.GetService <IMetadataReader>();
List <Database> databases = metadataReader.GetDatabases(server);
if (databases.Count == 0)
{
return;
}
SelectInfoBaseDialog dialog = new SelectInfoBaseDialog(databases);
_ = dialog.ShowDialog();
if (dialog.Result == null)
{
return;
}
string databaseName = ((Database)dialog.Result).Name;
Database database = (Database)server.Domains.Where(i => i.Name == databaseName).FirstOrDefault();
if (database != null)
{
return;
}
database = new Database()
{
Name = databaseName, Owner = server
};
server.Domains.Add(database);
await DoWorkAsync(database);
IController controller = GetController <DatabaseController>();
controller.BuildTreeNode(database, out TreeNodeViewModel childNode);
treeNode.TreeNodes.Add(childNode);
//Persist(database);
}
public LookupClient(
IMetadataLocator locator,
IMetadataProvider provider,
IMetadataFetcher fetcher,
IMetadataReader reader,
ICertificateValidator validator)
{
this.locator = locator;
this.provider = provider;
this.fetcher = fetcher;
this.reader = reader;
this.validator = validator;
}
public HomeController(ILogger <HomeController> logger, IConfiguration config, IFileUploader fileUploader,
IChangeFeedReader changeFeedReader,
IMetadataReader metadataReader)
{
_logger = logger;
this.fileUploader = fileUploader;
this.metadataReader = metadataReader;
this.changeFeedReader = changeFeedReader;
var value = config.GetSection("Configuration");
this.containerConnectionString = value.GetValue <string>(Constants.ConnectionStrings.ContainerPropertyName);
}
public List<IMetadataReader> GetMetaData()
{
//GetItems();
//itemcount = FolderItemList.Count;
int i = 0;
foreach (Shell32.FolderItem2 item2 in _objFolder.Items())
{
metadata = new MetadataReader.MetadataReader(i, Folderpath);
_metaList.Add(metadata);
i++;
}
return _metaList;
}
public ModuleInstaller(IMetadataReader metadataReader, IServiceProvider serviceProvider)
{
if (metadataReader == null)
{
throw new ArgumentNullException(nameof(metadataReader));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
_metadataReader = metadataReader;
_serviceProvider = serviceProvider;
}
public GenerateCommand(
List <string> args,
ITransformer transformer,
IMetadataReader metadataReader,
IDirectory directoryWrapper,
IFile fileWrapper,
IOutputWriter outputWriter)
{
_args = args;
_transformer = transformer;
_metadataReader = metadataReader;
_directoryWrapper = directoryWrapper;
_fileWrapper = fileWrapper;
_outputWriter = outputWriter;
}
public ModuleSearchEngine(IMetadataReader metadataReader,
IEntityStorageEngine entityStorageEngine)
{
if (metadataReader == null)
{
throw new ArgumentNullException(nameof(metadataReader));
}
if (entityStorageEngine == null)
{
throw new ArgumentNullException(nameof(entityStorageEngine));
}
_metadataReader = metadataReader;
_entityStorageEngine = entityStorageEngine;
}
public static ValueTask <IModuleMetadata> GetMetadataAsync(this IModuleSource moduleSource,
ModuleReleaseIdentifier moduleRelease,
IMetadataReader moduleMetadataReader,
CancellationToken cancellation = default)
{
if (moduleSource == null)
{
throw new ArgumentNullException(nameof(moduleSource));
}
if (moduleRelease == default)
{
throw new ArgumentDefaultException(nameof(moduleRelease));
}
return(moduleSource.GetMetadataAsync(moduleRelease.Module, moduleRelease.Version, moduleMetadataReader, cancellation));
}
private void ConnectToServer(object parameter)
{
InputStringDialog dialog = new InputStringDialog();
_ = dialog.ShowDialog();
if (dialog.Result == null)
{
return;
}
IMetadataReader metadataProvider = _shell.GetService <IMetadataReader>();
string serverName = (string)dialog.Result;
Server server = new Server()
{
Address = serverName
};
if (!metadataProvider.CheckServerConnection(server))
{
_ = MessageBox.Show(
"Unable to connect server!",
ONE_C_SHARP,
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
var treeNode = new TreeNodeViewModel()
{
NodeText = server.Address,
NodeIcon = new BitmapImage(new Uri(LOCAL_SERVER)),
NodePayload = server
};
treeNode.ContextMenuItems.Add(new MenuItemViewModel()
{
MenuItemHeader = "Connect to database...",
MenuItemIcon = new BitmapImage(new Uri(CONNECT_TO_DATABASE)),
MenuItemCommand = new AsyncCommand(ConnectToInfoBase, CanExecuteConnectToInfoBase),
MenuItemPayload = treeNode
});
_shell.AddTreeNode(treeNode);
}
public CommandFactory(
IDbSchemaReader dbSchemaReader,
IAssemblyReader assemblyReader,
IMetadataWriter <DbModel> dbModelMetadataWriter,
IMetadataWriter <AssemblyModel> assemblyMetadataWriter,
IMetadataReader metadataReader,
ITransformer transformer,
IOutputWriter outputWriter,
IDirectory directoryWrapper,
IFile fileWrapper,
CommandContext context)
{
RegisterCommand("h", "help", () => new HelpCommand(outputWriter));
RegisterCommand("v", "version", () => new VersionCommand(outputWriter));
RegisterCommand("metadata-dotnet", () => new MetadataDotNetCommand(
context.CommandArgs,
assemblyReader,
assemblyMetadataWriter,
outputWriter));
RegisterCommand("metadata-sqlclient", () => new MetadataSqlClientCommand(
context.CommandArgs,
dbSchemaReader,
dbModelMetadataWriter,
outputWriter));
RegisterCommand("metadata-oledb", () => new MetadataOledbCommand());
RegisterCommand("metadata-list", () => new MetadataListCommand(
context.CommandArgs,
metadataReader,
fileWrapper,
outputWriter));
RegisterCommand("generate", () => new GenerateCommand(
context.CommandArgs,
transformer,
metadataReader,
directoryWrapper,
fileWrapper,
outputWriter));
}
private void generateMapclass()
{
var Mapclasssettings = new Connection();
string mapTempPath = Path.GetTempPath();
if (mapTempPath.EndsWith(@"\") == false)
{
mapTempPath += @"\";
}
mapTempPath += @"Mapping\";
if (Directory.Exists(mapTempPath) == false)
{
Directory.CreateDirectory(mapTempPath);
}
Mapclasssettings.Domainfolderpath = mapTempPath;
Mapclasssettings.ConnectionString = ConfigurationManager.AppSettings["ConnectionString"];
Mapclasssettings.EntityName = "Entity";
if ((RecoEngine_BI.Common.iDBType) == (int)Enums.DBType.Oracle)
{
Mapclasssettings.Type = ServerType.Oracle;
}
metadataReader = MetadataFactory.GetReader(Mapclasssettings.Type, Mapclasssettings.ConnectionString);
var owners = metadataReader.GetOwners();
IList <Table> tblList = metadataReader.GetTables("RECOUSR");
int tableindex = 0;
for (int i = 0; i < tblList.Count; i++)
{
if (tblList[i].Name == "OPPORTUNITY")
{
tableindex = i;
break;
}
}
Table table = tblList[tableindex];
table.PrimaryKey = metadataReader.DeterminePrimaryKeys(table);
metadataReader.GetTableDetails(table, "RECOUSR");
var applicationPreferences = GetApplicationPreferences(table, false, Mapclasssettings);
new ApplicationController(applicationPreferences, table).Generate();
}
private async Task DoWorkAsync(Database database)
{
IMetadataReader metadataReader = _shell.GetService <IMetadataReader>();
_shell.ShowStatusBarMessage(string.Empty);
try
{
Progress <string> progress = new Progress <string>(ReportProgress);
Stopwatch stopwatch = Stopwatch.StartNew();
await metadataReader.ReadMetadataAsync(database, progress);
stopwatch.Stop();
_shell.ShowStatusBarMessage(stopwatch.ElapsedMilliseconds.ToString());
}
catch (Exception error)
{
_ = MessageBox.Show($"{error.Message}", "ONE-C-SHARP", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
}
public ModuleInstallationManager(IMetadataReader metadataReader,
IModuleInstaller moduleInstaller,
IModuleSupervisorFactory moduleSupervisorFactory,
IServiceProvider serviceProvider,
IOptions <ModuleManagementOptions> optionsAccessor)
{
if (metadataReader == null)
{
throw new ArgumentNullException(nameof(metadataReader));
}
if (moduleInstaller == null)
{
throw new ArgumentNullException(nameof(moduleInstaller));
}
if (moduleSupervisorFactory == null)
{
throw new ArgumentNullException(nameof(moduleSupervisorFactory));
}
if (serviceProvider == null)
{
throw new ArgumentNullException(nameof(serviceProvider));
}
if (optionsAccessor == null)
{
throw new ArgumentNullException(nameof(optionsAccessor));
}
_metadataReader = metadataReader;
_moduleInstaller = moduleInstaller;
_moduleSupervisorFactory = moduleSupervisorFactory;
_serviceProvider = serviceProvider;
var options = optionsAccessor.Value ?? new ModuleManagementOptions();
_installationDirectory = new DirectoryInfo(options.ModuleInstallationDirectory);
_initializationHelper = new AsyncInitializationHelper(InitializeInternalAsync);
}
/// <summary>
/// Reads attributes of <paramref name="memberInfo"/> and tries to create metadata for each one.
/// </summary>
/// <param name="memberInfo">Reflection source.</param>
/// <returns>Collection of metadata values.</returns>
protected virtual MetadataCollection BuildMetadata(MemberInfo memberInfo)
{
MetadataCollection collection = new MetadataCollection();
foreach (Attribute attribute in memberInfo.GetCustomAttributes(true))
{
IMetadataReader reader = attribute as IMetadataReader;
if (reader != null)
{
reader.Apply(collection);
}
else
{
IAttributeMetadataReader attributeReader;
if (MetadataReaderCollection.TryGet(attribute.GetType(), out attributeReader))
{
attributeReader.Apply(attribute, collection);
}
}
}
return(collection);
}
public static MediaFile GetMediaFile(string filePath)
{
int duration, fps = 0, height = 0, width = 0;
bool hasVideo, hasAudio;
string audioCodec = "", videoCodec = "";
MultimediaFactory factory;
IMetadataReader reader = null;
try{
factory = new MultimediaFactory();
reader = factory.getMetadataReader();
reader.Open(filePath);
duration = (int)reader.GetMetadata(MetadataType.Duration);
hasVideo = (bool)reader.GetMetadata(MetadataType.HasVideo);
hasAudio = (bool)reader.GetMetadata(MetadataType.HasAudio);
if (hasAudio)
{
audioCodec = (string)reader.GetMetadata(MetadataType.AudioEncoderType);
}
if (hasVideo)
{
videoCodec = (string)reader.GetMetadata(MetadataType.VideoEncoderType);
fps = (int)reader.GetMetadata(MetadataType.Fps);
}
height = (int)reader.GetMetadata(MetadataType.DimensionX);
width = (int)reader.GetMetadata(MetadataType.DimensionY);
return(new MediaFile(filePath, duration * 1000, (ushort)fps,
hasAudio, hasVideo, videoCodec, audioCodec,
(uint)height, (uint)width));
}
catch (GLib.GException ex) {
throw new Exception(Catalog.GetString("Invalid video file:") + "\n" + ex.Message);
}
finally {
reader.Close();
reader.Dispose();
}
}
private void connectBtnClicked(object sender, EventArgs e)
{
errorLabel.Text = string.Empty;
Cursor.Current = Cursors.WaitCursor;
try
{
tablesListBox.Items.Clear();
sequencesComboBox.Items.Clear();
metadataReader = MetadataFactory.GetReader((ServerType)serverTypeComboBox.SelectedItem,
connStrTextBox.Text);
PopulateOwners();
PopulateTablesAndSequences();
}
catch (Exception ex)
{
errorLabel.Text = ex.Message;
}
finally
{
Cursor.Current = Cursors.Default;
}
}
private void connectBtnClicked(object sender, EventArgs e)
{
if (_currentConnection == null)
return;
toolStripStatusLabel.Text = string.Format("Connecting to {0}...", _currentConnection.Name);
statusStrip1.Refresh();
Cursor.Current = Cursors.WaitCursor;
try
{
tablesListBox.DataSource = null;
tablesListBox.DisplayMember = "Name";
sequencesComboBox.Items.Clear();
metadataReader = MetadataFactory.GetReader(_currentConnection.Type, _currentConnection.ConnectionString);
toolStripStatusLabel.Text = "Retrieving owners...";
statusStrip1.Refresh();
PopulateOwners();
toolStripStatusLabel.Text = string.Empty;
}
catch (Exception ex)
{
toolStripStatusLabel.Text = ex.Message;
}
finally
{
Cursor.Current = Cursors.Default;
}
}
/// <summary>
/// Calls the Metadata.MetadataReader with the passed parameters, and places the returned data to
/// the list _metaList
/// </summary>
/// <param name="folderPath">A path to the musicnumber</param>
/// <param name="musicnumber">The musicnumber that are to be pased on to the metadataReader</param>
private void GetFileMetaData(string folderPath, string musicnumber)
{
metadata = new Metadata.MetadataReader(folderPath, musicnumber);
_metaList.Add(metadata);
}
