public void MetadataApiFactory_CreateMetadataApi_Creates_Instance() { var configuration = new ConfigurationBuilder() .AddInMemoryCollection(inMemoryConfig) .Build(); // Arrange MetadataApiFactory target = new MetadataApiFactory(configuration); Uri expectedUri; if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("EDQ_ElectronicUpdates_ServiceUri"))) { expectedUri = new Uri(Environment.GetEnvironmentVariable("EDQ_ElectronicUpdates_ServiceUri")); } else { expectedUri = new Uri("https://ws.updates.qas.com/metadata/V2/"); } // Act IMetadataApi result = target.CreateMetadataApi(); // Assert Assert.NotNull(result); Assert.IsType(typeof(MetadataApi), result); Assert.Equal(expectedUri, result.ServiceUri); Assert.Equal("AuthToken", result.Token); }
public static void MetadataApiFactory_CreateMetadataApi_Creates_Instance() { // Arrange Mock <MetadataApiFactory> mock = new Mock <MetadataApiFactory>(); mock.CallBase = true; mock.Setup((p) => p.GetConfigSetting("UserName")).Returns("MyUserName"); mock.Setup((p) => p.GetConfigSetting("Password")).Returns("MyPassword"); Uri expectedUri; if (!string.IsNullOrEmpty(Environment.GetEnvironmentVariable("QAS_ElectronicUpdates_ServiceUri"))) { expectedUri = new Uri(Environment.GetEnvironmentVariable("QAS_ElectronicUpdates_ServiceUri")); } else { expectedUri = new Uri("https://ws.updates.qas.com/metadata/V1/"); } MetadataApiFactory target = mock.Object; // Act IMetadataApi result = target.CreateMetadataApi(); // Assert Assert.NotNull(result); Assert.IsType(typeof(MetadataApi), result); Assert.Equal(expectedUri, result.ServiceUri); Assert.Equal("MyUserName", result.UserName); }
public IoTDeviceRestfulDataEnricher(ITelemetryClient telemetryClient, IConfiguration config, ILogger <IoTDeviceRestfulDataEnricher> logger) { this.telemetryClient = telemetryClient; this.config = config; this.logger = logger; client = RestService.For <IMetadataApi>(config.GetValue <string>("REST_SERVICE_URL")); }
/// <summary> /// Gets the download <see cref="Uri"/> for the specified file as an asynchronous operation. /// </summary> /// <param name="value">The <see cref="IMetadataApi"/> to get the download URI.</param> /// <param name="fileName">The name of the file to download.</param> /// <param name="fileHash">The hash of the file to download.</param> /// <returns> /// A <see cref="Task{T}"/> containing the <see cref="Uri"/> to download the file specified by /// <paramref name="fileName"/> and <paramref name="fileHash"/> from as an asynchronous operation. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="value"/> is <see langword="null"/>. /// </exception> public static async Task <Uri> GetDownloadUriAsync(this IMetadataApi value, string fileName, string fileHash) { if (value == null) { throw new ArgumentNullException("value"); } return(await value.GetDownloadUriAsync(fileName, fileHash, null, null)); }
public MongoCollectionInitializer(IDocumentStorageManager documentStorageManager, IJsonObjectSerializer jsonObjectSerializer, IMetadataApi metadataApi, ILog log) : base(1) { _documentStorageManager = documentStorageManager; _jsonObjectSerializer = jsonObjectSerializer; _metadataApi = metadataApi; _log = log; }
public static async Task IMetadataApiExtensions_GetDownloadUriAsync_Throws_If_Value_Is_Null() { // Arrange IMetadataApi value = null; string fileName = "MyFileName.dts"; string fileHash = "58b653e3762e8048995e00024a512c53"; // Act and Assert await Assert.ThrowsAsync <ArgumentNullException>("value", () => value.GetDownloadUriAsync(fileName, fileHash)); }
public static async Task <HttpResponseMessage> Run( [HttpTrigger(AuthorizationLevel.Anonymous, methods: new string[] { "GET", "PUT", "OPTIONS" })] HttpRequestMessage req, TraceWriter log, [Inject(typeof(IMetadataApi))] IMetadataApi metadataApi) { var httpMethods = new Dictionary <string, Func <HttpRequestMessage, TraceWriter, Task <HttpResponseMessage> > > { { "GET", async(r, l) => await metadataApi.Get(r, l) }, { "PUT", async(r, l) => await metadataApi.Put(r, l) }, }; var response = httpMethods.ContainsKey(req.Method.Method) ? await httpMethods[req.Method.Method](req, log) : req.CreateResponse(req.Method.Method == "OPTIONS" ? HttpStatusCode.OK : HttpStatusCode.NotFound); AddCORSHeader(req, response, "GET, PUT, OPTIONS"); return(response); }
public void MetadataApiFactory_CreateMetadataApi_Creates_Instance_If_Invalid_Service_Uri_Configured() { // Arrange var configuration = new ConfigurationBuilder() .AddInMemoryCollection(inMemoryConfig) .Build(); // Arrange MetadataApiFactory target = new MetadataApiFactory(configuration); // Act IMetadataApi result = target.CreateMetadataApi(); // Assert Assert.NotNull(result); Assert.IsType(typeof(MetadataApi), result); Assert.Equal(new Uri("https://ws.updates.qas.com/metadata/V2/"), result.ServiceUri); Assert.Equal("AuthToken", result.Token); }
public static void MetadataApiFactory_CreateMetadataApi_Creates_Instance_If_Invalid_Service_Uri_Configured() { // Arrange Mock <MetadataApiFactory> mock = new Mock <MetadataApiFactory>(); mock.CallBase = true; mock.Setup((p) => p.GetConfigSetting("ServiceUri")).Returns("NotAUri"); mock.Setup((p) => p.GetConfigSetting("UserName")).Returns("MyUserName"); mock.Setup((p) => p.GetConfigSetting("Password")).Returns("MyPassword"); MetadataApiFactory target = mock.Object; // Act IMetadataApi result = target.CreateMetadataApi(); // Assert Assert.NotNull(result); Assert.IsType(typeof(MetadataApi), result); Assert.Equal(new Uri("https://ws.updates.qas.com/metadata/V1/"), result.ServiceUri); Assert.Equal("MyUserName", result.UserName); }
public static async Task IMetadataApiExtensions_GetDownloadUriAsync_Calls_Interface_Method_With_No_File_Range() { // Arrange string fileName = "MyFileName.dts"; string fileHash = "58b653e3762e8048995e00024a512c53"; Uri uri = new Uri("https://dn.updates.qas.com/MyFile.dts"); Mock <IMetadataApi> mock = new Mock <IMetadataApi>(); mock.Setup((p) => p.GetDownloadUriAsync(fileName, fileHash, null, null)) .ReturnsAsync(uri) .Verifiable(); IMetadataApi value = mock.Object; // Act and Assert Uri result = await value.GetDownloadUriAsync(fileName, fileHash); mock.Verify(); Assert.Same(uri, result); }
/// <summary> /// Конструктор /// </summary> /// <param name="metadataApi">Провайдер метаданных сервисной части</param> /// <param name="schema">Схема данных документа, к которому выполняется запрос</param> public QueryCriteriaAnalyzer(IMetadataApi metadataApi, dynamic schema) { var metadataIterator = new SchemaIterator(metadataApi) { OnObjectProperty = schemaObject => { if (schemaObject.IsResolve) { _resolveProperties.Add(schemaObject); } }, OnArrayProperty = schemaObject => { if (schemaObject.IsDocumentArray) { _resolveProperties.Add(schemaObject); } } }; metadataIterator.ProcessSchema(schema); }
public SchemaIterator(IMetadataApi metadataApi) { _metadataApi = metadataApi; }
/// <summary> /// Initializes a new instance of the <see cref="ExtensionObjectSerializer"/> class. /// </summary> /// <param name="metadataApi">The metadata API.</param> public ExtensionObjectSerializer(IMetadataApi metadataApi) { this.metadataApi = metadataApi; }
private static void AssertFieldMetadata(IMetadataApi metadataApi, Guid objectMetadataId) { IFieldMetadata fieldMetadata = metadataApi.GetField(objectMetadataId, "Name"); Assert.AreEqual("Name", fieldMetadata.Name); Assert.AreEqual(FieldType.String, fieldMetadata.Type); Assert.AreEqual(1, fieldMetadata.Ordinal); Assert.IsTrue(fieldMetadata.IsRequired); fieldMetadata = metadataApi.GetField(objectMetadataId, "Birthday"); Assert.AreEqual("Birthday", fieldMetadata.Name); Assert.AreEqual(FieldType.DateTime, fieldMetadata.Type); Assert.AreEqual(2, fieldMetadata.Ordinal); Assert.IsFalse(fieldMetadata.IsRequired); fieldMetadata = metadataApi.GetField(objectMetadataId, "Level"); Assert.AreEqual("Level", fieldMetadata.Name); Assert.AreEqual(FieldType.Integer, fieldMetadata.Type); Assert.AreEqual(3, fieldMetadata.Ordinal); Assert.IsTrue(fieldMetadata.IsRequired); fieldMetadata = metadataApi.GetField(objectMetadataId, "Salary"); Assert.AreEqual("Salary", fieldMetadata.Name); Assert.AreEqual(FieldType.Decimal, fieldMetadata.Type); Assert.AreEqual(4, fieldMetadata.Ordinal); Assert.IsTrue(fieldMetadata.IsRequired); fieldMetadata = metadataApi.GetField(objectMetadataId, "Position"); Assert.AreEqual("Position", fieldMetadata.Name); Assert.AreEqual(FieldType.Hierarchy, fieldMetadata.Type); Assert.AreEqual(5, fieldMetadata.Ordinal); Assert.IsTrue(fieldMetadata.IsRequired); HierarchyFieldMetadata hierarchyFieldMetadata = fieldMetadata as HierarchyFieldMetadata; Assert.AreEqual(1, hierarchyFieldMetadata.Node.Length); Assert.AreEqual("Director", hierarchyFieldMetadata.Node[0].Name); fieldMetadata = metadataApi.GetField(objectMetadataId, "HuKou"); Assert.AreEqual("HuKou", fieldMetadata.Name); Assert.AreEqual(FieldType.Enumeration, fieldMetadata.Type); Assert.AreEqual(6, fieldMetadata.Ordinal); Assert.IsFalse(fieldMetadata.IsRequired); IEnumerable<IFieldMetadata> allFieldMetadata = metadataApi.GetFields(objectMetadataId); Assert.AreEqual(6, allFieldMetadata.Count()); }
public MetadataApiHttpService(IMetadataApi metadataApi) { _metadataApi = metadataApi; }
/// <summary> /// Downloads the available data files from the QAS Electronic Updates Metadata REST API as an asynchronous operation. /// </summary> /// <returns> /// A <see cref="Task"/> representing the asynchronous operation to download any data files. /// </returns> internal static async Task MainAsync() { PrintBanner(); // Get the configuration settings for downloading files string downloadRootPath = MetadataApiFactory.GetAppSetting("DownloadRootPath"); string verifyDownloadsString = MetadataApiFactory.GetAppSetting("ValidateDownloads"); bool verifyDownloads; if (!bool.TryParse(verifyDownloadsString, out verifyDownloads)) { verifyDownloads = true; } if (string.IsNullOrEmpty(downloadRootPath)) { downloadRootPath = "QASData"; } downloadRootPath = Path.GetFullPath(downloadRootPath); // Create the service implementation IMetadataApiFactory factory = new MetadataApiFactory(); IMetadataApi service = factory.CreateMetadataApi(); Console.WriteLine("QAS Electronic Updates Metadata REST API: {0}", service.ServiceUri); Console.WriteLine(); Console.WriteLine("User Name: {0}", service.UserName); Console.WriteLine(); // Query the packages available to the account AvailablePackagesReply response = await service.GetAvailablePackagesAsync(); Console.WriteLine("Available Package Groups:"); Console.WriteLine(); // Enumerate the package groups and list their packages and files if (response.PackageGroups != null && response.PackageGroups.Count > 0) { using (CancellationTokenSource tokenSource = new CancellationTokenSource()) { // Cancel the tasks if Ctrl+C is entered to the console Console.CancelKeyPress += (sender, e) => { if (!tokenSource.IsCancellationRequested) { tokenSource.Cancel(); } e.Cancel = true; }; try { Stopwatch stopwatch = Stopwatch.StartNew(); // Create a file store in which to cache information about which files // have already been downloaded from the Metadata API service. using (IFileStore fileStore = new LocalFileStore()) { foreach (PackageGroup group in response.PackageGroups) { Console.WriteLine("Group Name: {0} ({1})", group.PackageGroupCode, group.Vintage); Console.WriteLine(); Console.WriteLine("Packages:"); Console.WriteLine(); foreach (Package package in group.Packages) { Console.WriteLine("Package Name: {0}", package.PackageCode); Console.WriteLine(); Console.WriteLine("Files:"); Console.WriteLine(); foreach (DataFile file in package.Files) { if (fileStore.ContainsFile(file.MD5Hash)) { // We already have this file, download not required Console.WriteLine("File with hash '{0}' already downloaded.", file.MD5Hash); } else { // Download the file await DownloadFileAsync( service, fileStore, group, file, downloadRootPath, verifyDownloads, tokenSource.Token); } } Console.WriteLine(); } Console.WriteLine(); } } stopwatch.Stop(); Console.WriteLine("Downloaded data in {0:hh\\:mm\\:ss}.", stopwatch.Elapsed); } catch (OperationCanceledException ex) { // Only an error if not cancelled by the user if (ex.CancellationToken != tokenSource.Token) { throw; } Console.WriteLine("File download cancelled by user."); } Console.WriteLine(); } } }
/// <summary> /// Downloads the specified file from the specified package group as an asynchronous operation. /// </summary> /// <param name="service">The Metadata API to use to get the download URI.</param> /// <param name="fileStore">The file store to register the download with if successfully downloaded.</param> /// <param name="group">The package group to download the file from.</param> /// <param name="file">The data file to download.</param> /// <param name="downloadRootPath">The root path to download data to.</param> /// <param name="verifyDownloads">Whether to verify file downloads.</param> /// <param name="cancellationToken">The cancellation token to use to cancel any downloads.</param> /// <returns> /// A <see cref="Task"/> representing the asynchronous operation. /// </returns> private static async Task DownloadFileAsync( IMetadataApi service, IFileStore fileStore, PackageGroup group, DataFile file, string downloadRootPath, bool verifyDownloads, CancellationToken cancellationToken) { if (cancellationToken.IsCancellationRequested) { return; } Console.WriteLine("File name: {0}", file.FileName); Console.WriteLine("File hash: {0}", file.MD5Hash); Console.WriteLine("File size: {0:N0}", file.Size); // Query the URIs to download the file from Uri uri = await service.GetDownloadUriAsync(file.FileName, file.MD5Hash); if (uri == null) { Console.WriteLine("File '{0}' is not available for download at this time.", file.FileName); Console.WriteLine(); return; } Console.WriteLine("File URI: {0}", uri); Console.WriteLine(); // Create the path to the directory to download the file to string directoryPath = Path.Combine( downloadRootPath, group.PackageGroupCode, group.Vintage); string filePath = Path.GetFullPath(Path.Combine(directoryPath, file.FileName)); // Create the directory if it doesn't already exist if (!Directory.Exists(directoryPath)) { Directory.CreateDirectory(directoryPath); } // Download the file Console.WriteLine("Downloading '{0}' ({1}) to '{2}'...", file.FileName, file.MD5Hash, filePath); using (HttpClient client = new HttpClient()) { using (HttpResponseMessage response = await client.GetAsync(uri, cancellationToken)) { response.EnsureSuccessStatusCode(); using (Stream stream = await response.Content.ReadAsStreamAsync()) { using (Stream fileStream = File.Open(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.None)) { // Ensure any existing file is overwritten fileStream.SetLength(0L); await stream.CopyToAsync(fileStream, 4096, cancellationToken); } } } } // Validate the download is correct, if configured. // Don't register the file in the file store as the file download became corrupted somehow. if (!verifyDownloads || VerifyDownload(filePath, file.MD5Hash)) { // Register the file with the file store so further invocations // of the application don't unnecessarily download the file again fileStore.RegisterFile(file.MD5Hash, filePath); } }
public PrintViewApi(IMetadataApi metadataApi, IPrintViewBuilder printViewBuilder) { _metadataApi = metadataApi; _printViewBuilder = printViewBuilder; }