private static StorageProviderItem CreateStorageProviderItem(StorageProviderItem parent, Metadata item) { var result = new StorageProviderItem { Name = item.Name, Id = Path.Combine(parent.Id, item.PathLower), ParentReferenceId = parent.Id }; if (item.IsFile) { result.Type = StorageProviderItemType.File; // result.Id = item.AsFile.Id; // Path.Combine(parent.Id, item.PathLower) result.LastModifiedDateTime = item.AsFile.ServerModified; } else if (item.IsFolder) { result.Type = StorageProviderItemType.Folder; // result.Id = item.AsFolder.Id; // Path.Combine(parent.Id, item.PathLower); } else { result.Type = StorageProviderItemType.Unknown; } return result; }
public Asset (string name, string desc, Model[] models, Metadata data, Location location) { this.name = name; this.desc = desc; this.models = models; this.data = data; this.location = location; }
public TextExtractionResult Extract(Func<Metadata, InputStream> streamFactory) { try { var parser = new AutoDetectParser(); var metadata = new Metadata(); var outputWriter = new StringWriter(); var parseContext = new ParseContext(); //use the base class type for the key or parts of Tika won't find a usable parser parseContext.set(typeof(org.apache.tika.parser.Parser), parser); using (var inputStream = streamFactory(metadata)) { try { parser.parse(inputStream, getTransformerHandler(outputWriter), metadata, parseContext); } finally { inputStream.close(); } } return assembleExtractionResult(outputWriter.ToString(), metadata); } catch (Exception ex) { throw new TextExtractionException("Extraction failed.", ex); } }
/// <summary> /// The order mapping is a file named order in the same virtual path. /// </summary> private static Func<string, Metadata> GetMetadataMapping(string virtualPath) { var vpp = HostingEnvironment.VirtualPathProvider; string metadataFile = VirtualPathUtility.AppendTrailingSlash(virtualPath) + MetadataFile; var mapping = new Dictionary<string, Metadata>(); int index = 0; if (vpp.FileExists(metadataFile)) { VirtualFile file = vpp.GetFile(metadataFile); Stream stream = file.Open(); using (var reader = new StreamReader(stream)) { string line = null; while ((line = reader.ReadLine()) != null) { mapping[Normalize(line)] = new Metadata { Order = index++ }; } } } return title => { Metadata metadata; if (mapping.TryGetValue(title, out metadata)) { return metadata; } return Metadata.Empty; }; }
public Asset (string name, string desc, Model[] models, Metadata data) { this.name = name; this.desc = desc; this.models = models; this.data = data; location = new Location(); }
public void Should_Schedule_Reconnections_In_The_Background() { var lbp = new RoundRobinPolicy(); var config = new Configuration( new Cassandra.Policies(lbp, new ConstantReconnectionPolicy(1000), FallthroughRetryPolicy.Instance), new ProtocolOptions(), null, new SocketOptions(), new ClientOptions(), NoneAuthProvider.Instance, null, new QueryOptions(), new DefaultAddressTranslator()); var testCluster = TestClusterManager.GetNonShareableTestCluster(1, DefaultMaxClusterCreateRetries, true, false); var metadata = new Metadata(config); metadata.AddHost(new IPEndPoint(IPAddress.Parse(testCluster.InitialContactPoint), ProtocolOptions.DefaultPort)); var clusterMock = new Mock<ICluster>(); clusterMock.Setup(c => c.AllHosts()).Returns(() => metadata.Hosts.ToCollection()); lbp.Initialize(clusterMock.Object); using (var cc = NewInstance(testCluster, config, metadata)) { cc.Init(); var host = metadata.Hosts.First(); testCluster.Stop(1); host.SetDown(); Thread.Sleep(2000); Assert.False(host.IsUp); testCluster.Start(1); host.BringUpIfDown(); //Should reconnect using timer Thread.Sleep(5000); Assert.DoesNotThrow(() => cc.Query("SELECT key FROM system.local", false)); } testCluster.ShutDown(); }
public async Task<Metadata> SaveData(StoreLocation location, Metadata metadata, UpdateAuditInfo audit, Func<IWriteAsyncStream, Task<long?>> savingFunc, CancellationToken token) { var current = await GetMetadata(location).ConfigureAwait(false); var info = current == null ? new AuditInfo() : current.Audit; info.UpdatedBy = audit == null ? "0" : audit.UpdatedBy; info.UpdatedByName = audit == null ? string.Empty : audit.UpdatedByName; info.UpdatedOn = DateTime.UtcNow; info.CreatedBy = info.CreatedBy ?? info.UpdatedBy; info.CreatedByName = info.CreatedByName ?? info.UpdatedByName; info.CreatedOn = info.CreatedOn ?? info.UpdatedOn; metadata = metadata ?? new Metadata(); metadata.Audit = info; var key = GetObjectKey(location); long? length = null; using(var stream = new AmazonMultiUploadStream(_client, _bucket, key, metadata)) { length = await savingFunc(stream).ConfigureAwait(false); await stream.Complete(token).ConfigureAwait(false); metadata.Snapshot = stream.VersionId; } if (length.HasValue && (metadata == null || !metadata.ContentLength.HasValue)) { metadata[MetadataConstants.ContentLengthMetadataKey] = length.Value.ToString(CultureInfo.InvariantCulture); // Save the length straight away before the snapshot... metadata = await SaveMetadata(location, metadata).ConfigureAwait(false); } return metadata; }
public void TestConstructFromDictionary1() { string owner = "Washington State University Libraries"; string ownerGroup = "Washington State University"; string[] coOwners = { "CoOwner1", "CoOwner2" }; long created = DateTime.Now.ToBinary(); long updated = DateTime.Now.AddDays(1).ToBinary(); string target = "http://wsulibs.wsu.edu/"; string status = Metadata.MetadataStatus.Public; IDictionary<string, string> map = new Dictionary<string, string>(); map.Add(Metadata.MetadataKeys.Owner, owner); map.Add(Metadata.MetadataKeys.OwnerGroup, ownerGroup); map.Add(Metadata.MetadataKeys.CoOwners, string.Join(";", coOwners)); map.Add(Metadata.MetadataKeys.Created, created.ToString()); map.Add(Metadata.MetadataKeys.Updated, updated.ToString()); map.Add(Metadata.MetadataKeys.Target, target); map.Add(Metadata.MetadataKeys.Status, status); Metadata metadata = new Metadata(map); Assert.IsTrue(metadata.Owner == owner); Assert.IsTrue(metadata.OwnerGroup == ownerGroup); Assert.IsTrue(metadata.CoOwners.Count == coOwners.Length); Assert.IsTrue(metadata.CoOwners[0] == coOwners[0]); Assert.IsTrue(metadata.CoOwners[1] == coOwners[1]); Assert.IsTrue(metadata.Created == created); Assert.IsTrue(metadata.Updated == updated); Assert.IsTrue(metadata.Target == target); Assert.IsTrue(metadata.Status == status); }
public unsafe PdbInfo(IO.FileStream inputStream, Metadata.Reader reader) { this.reader = reader; this.pdbFunctionMap = PdbFile.LoadFunctionMap(inputStream, out tokenToSourceMapping, out sourceServerData, reader); //inputStream.Seek(0L, IO.SeekOrigin.Begin); //this.remapTable = PdbFile.LoadRemapTable(inputStream); }
/// <summary> /// Initializes a new instance of the <see cref="UpdateMetadataRequest"/> class /// with the given metadata. /// </summary> /// <param name="metadata">The metadata.</param> /// <exception cref="ArgumentNullException">If <paramref name="metadata"/> is <c>null</c>.</exception> public UpdateMetadataRequest(Metadata metadata) { if (metadata == null) throw new ArgumentNullException("metadata"); Metadata = metadata; }
public TextExtractionResult Extract(Func<Metadata, InputStream> streamFactory) { try { var parser = new AutoDetectParser(); var metadata = new Metadata(); var parseContext = new ParseContext(); //use the base class type for the key or parts of Tika won't find a usable parser parseContext.set(typeof(Parser), parser); var content = new System.IO.StringWriter(); var contentHandlerResult = new TextExtractorContentHandler(content); using (var inputStream = streamFactory(metadata)) { try { parser.parse(inputStream, contentHandlerResult, metadata, parseContext); } finally { inputStream.close(); } } return AssembleExtractionResult(content.ToString(), metadata); } catch (Exception ex) { throw new TextExtractionException("Extraction failed.", ex); } }
protected override void OnCreate(Bundle bundle) { base.OnCreate (bundle); // Set our view from the "main" layout resource SetContentView (Resource.Layout.Main); FindViewById<Button> (Resource.Id.NotifyButton).Click += delegate { String empty = null; try { empty.Contains ("null exception"); } catch (Exception e) { // You can add extra metadata to the error report to better debug it. // This information will show up in the Bugsnag web app. var md = new Metadata (); md.AddToTab ("Tab1", "key1", "value1"); md.AddToTab ("Tab1", "key2", "value2"); // Send the error to bugsnag AndroidApp.BugsnagClient.Notify (e, ErrorSeverity.Warning, md); } }; FindViewById<Button> (Resource.Id.CrashButton).Click += delegate { // When the application crashes, Bugsnag library intercepts the error, writes it to disk and // submits it next time the application starts. throw new NotSupportedException ("Crash ahoy!"); }; }
public void DefaultCtorSplitsAtDashes() { // Given Engine engine = new Engine(); Metadata metadata = new Metadata(engine); Pipeline pipeline = new Pipeline("Pipeline", engine, null); IExecutionContext context = new ExecutionContext(engine, pipeline); IDocument[] inputs = { new Document(metadata).Clone(@"FM1 FM2 --- Content1 Content2") }; string frontMatterContent = null; FrontMatter frontMatter = new FrontMatter(new Execute(x => { frontMatterContent = x.Content; return new [] {x}; })); // When IEnumerable<IDocument> documents = frontMatter.Execute(inputs, context); // Then Assert.AreEqual(1, documents.Count()); Assert.AreEqual(@"FM1 FM2 ", frontMatterContent); Assert.AreEqual(@"Content1 Content2", documents.First().Content); }
public MetadataEditorDialog(Metadata originalMetaData) { _originalMetaData = originalMetaData; InitializeComponent(); _metadataEditorControl.Metadata = _returnMetaData = originalMetaData.DeepCopy(); ShowCreator = true; }
public MachineParamsManager(Guid plowmachineId, Metadata.MetadataManager manager) { _plowMachineId = plowmachineId; _manager = manager; _connection = DBConnectionProvider.GetConnection(); _connection.Open(); }
public AmazonMultiUploadStream(AmazonS3Client client, string bucket, string key, Metadata metadata) { _client = client; _bucket = bucket; _key = key; _metadata = metadata; }
ushort GetStructDef(Type type, Metadata metadata, Metadata[] fields) { var index = Schema.structs.Count; var structDef = new StructDef(); Schema.structs.Add(structDef); structDef.metadata = metadata; var baseType = type.GetBaseSchemaType(); if (baseType != null) structDef.base_def = GetTypeDef(baseType); var i = 0; foreach (var field in type.GetSchemaFields()) { var fieldDef = new FieldDef { id = field.Id, metadata = fields[i++], type = GetTypeDef(field.GetSchemaType()) }; structDef.fields.Add(fieldDef); } return (ushort) index; }
/// <summary> /// Gets the metadata link tag. /// </summary> /// <param name="metadata">The metadata.</param> /// <param name="metadataListPage">Metadata filtered list page, can be null.</param> /// <returns></returns> public static string GetMetadataLinkTag(Metadata metadata, Page metadataListPage) { string tag = string.Empty; if (metadata == null) return string.Empty; if (metadataListPage == null) { metadataListPage = Litium.Plus.Utilities.PageUtilities.GetFirstPublishedPageTypeInstance("MetadataFilteredList", CurrentState.Current.WebSiteID, Litium.Foundation.GUI.FoundationContext.Current.Token); } string metadataTranslation = metadata.Translations.GetMetadataTranslation(CurrentState.Current.WebSite.Culture).Translation; if (string.IsNullOrEmpty(metadataTranslation)) return string.Empty; if (metadataListPage == null) { tag = "<span class=\"metadataSpanTag\">" + metadataTranslation + "</span>"; } else { string linkTag = string.Format("<a href=\"{0}?MetadataID={1}\">{2}</a>", metadataListPage.GetUrlToPage(), metadata.ID, metadata.Translations.GetMetadataTranslation(CurrentState.Current.WebSite.Culture).Translation); tag = "<span class=\"metadataSpanTag\">" + linkTag + "</span>"; } return tag; }
public static void SetMetadata(this NetInfo prefab, Metadata metadata) { if (metadata.info != prefab) { throw new Exception("NoPillars: wrong metadata!"); } prefab.m_canCollide = metadata.collide; var r2 = prefab.m_netAI as RoadAI; if (r2 != null) { r2.m_enableZoning = metadata.zoning; } if (Pillars.networkSkinsEnabled) { return; } var ta = prefab.m_netAI as TrainTrackBridgeAI; if (ta != null) { ta.m_bridgePillarInfo = metadata.bpi; ta.m_middlePillarInfo = metadata.bmi; } var ra = prefab.m_netAI as RoadBridgeAI; if (ra != null) { ra.m_bridgePillarInfo = metadata.bpi; ra.m_middlePillarInfo = metadata.bmi; } var pa = prefab.m_netAI as PedestrianBridgeAI; if (pa != null) { pa.m_bridgePillarInfo = metadata.bpi; } }
public static Metadata GetMetadata(this NetInfo prefab) { var mNetAi = prefab.m_netAI; var si = new Metadata { collide = prefab.m_canCollide, info = prefab }; var ta = mNetAi as TrainTrackBridgeAI; if (ta != null) { si.bpi = ta.m_bridgePillarInfo; si.bmi = ta.m_middlePillarInfo; } var ra = mNetAi as RoadBridgeAI; if (ra != null) { si.bpi = ra.m_bridgePillarInfo; si.bmi = ra.m_middlePillarInfo; } var pa = mNetAi as PedestrianBridgeAI; if (pa != null) { si.bpi = pa.m_bridgePillarInfo; } var r2 = mNetAi as RoadAI; if (r2 != null) { si.zoning = r2.m_enableZoning; } return si; }
public void DashStringDoesNotSplitAtNonmatchingDashes() { // Given Engine engine = new Engine(); Metadata metadata = new Metadata(engine); Pipeline pipeline = new Pipeline("Pipeline", engine, null); IExecutionContext context = new ExecutionContext(engine, pipeline); IDocument[] inputs = { new Document(metadata).Clone(@"FM1 FM2 --- Content1 Content2") }; bool executed = false; FrontMatter frontMatter = new FrontMatter("-", new Execute(x => { executed = true; return new[] { x }; })); // When IEnumerable<IDocument> documents = frontMatter.Execute(inputs, context); // Then Assert.AreEqual(1, documents.Count()); Assert.IsFalse(executed); Assert.AreEqual(@"FM1 FM2 --- Content1 Content2", documents.First().Content); }
public void Test_AmoebaConverter_Box() { var key = new Key(HashAlgorithm.Sha256, new byte[32]); var metadata = new Metadata(1, key, CompressionAlgorithm.Xz, CryptoAlgorithm.Aes256, new byte[32 + 32]); var seed = new Seed(metadata); seed.Name = "aaaa.zip"; seed.Keywords.AddRange(new KeywordCollection { "bbbb", "cccc", "dddd", }); seed.CreationTime = DateTime.Now; seed.Length = 10000; var box = new Box(); box.Name = "Box"; box.Seeds.Add(seed); box.Boxes.Add(new Box() { Name = "Box" }); Box box2; using (var streamBox = AmoebaConverter.ToBoxStream(box)) { box2 = AmoebaConverter.FromBoxStream(streamBox); } Assert.AreEqual(box, box2, "AmoebaConverter #3"); }
static void Assign(Metadata to, Metadata from) { foreach (var kvp in from) { to.Add(kvp.Key, kvp.Value); } }
public void UpdatePeersInfoModifiesPool() { var metadata = new Metadata(new Configuration()); var cc = NewInstance(metadata); cc.Host = TestHelper.CreateHost("127.0.0.1"); metadata.AddHost(cc.Host.Address); var hostAddress2 = IPAddress.Parse("127.0.0.2"); var hostAddress3 = IPAddress.Parse("127.0.0.3"); var rows = TestHelper.CreateRows(new List<Dictionary<string, object>> { new Dictionary<string, object>{{"rpc_address", hostAddress2}, {"peer", null}, { "data_center", "ut-dc2" }, { "rack", "ut-rack2" }, {"tokens", null}}, new Dictionary<string, object>{{"rpc_address", IPAddress.Parse("0.0.0.0")}, {"peer", hostAddress3}, { "data_center", "ut-dc3" }, { "rack", "ut-rack3" }, {"tokens", null}} }); cc.UpdatePeersInfo(rows); Assert.AreEqual(3, metadata.AllHosts().Count); //using rpc_address var host2 = metadata.GetHost(new IPEndPoint(hostAddress2, ProtocolOptions.DefaultPort)); Assert.NotNull(host2); Assert.AreEqual("ut-dc2", host2.Datacenter); Assert.AreEqual("ut-rack2", host2.Rack); //with rpc_address = 0.0.0.0, use peer var host3 = metadata.GetHost(new IPEndPoint(hostAddress3, ProtocolOptions.DefaultPort)); Assert.NotNull(host3); Assert.AreEqual("ut-dc3", host3.Datacenter); Assert.AreEqual("ut-rack3", host3.Rack); }
public static List<IWriteFile> ReadHeader(string path) { List<IWriteFile> subfiles = null; using (BinaryReader reader = new BinaryReader(File.OpenRead(path))) { if (!VerifyHeader(path)) throw new InvalidDataException("The supplied file is not a PP archive."); byte[] versionHeader = reader.ReadBytes(8); int version = BitConverter.ToInt32(DecryptHeaderBytes(reader.ReadBytes(4)), 0); DecryptHeaderBytes(reader.ReadBytes(1)); // first byte int numFiles = BitConverter.ToInt32(DecryptHeaderBytes(reader.ReadBytes(4)), 0); byte[] buf = DecryptHeaderBytes(reader.ReadBytes(numFiles * 288)); subfiles = new List<IWriteFile>(numFiles); for (int i = 0; i < numFiles; i++) { int offset = i * 288; ppSubfile subfile = new ppSubfile(path); subfile.Name = Utility.EncodingShiftJIS.GetString(buf, offset, 260).TrimEnd(new char[] { '\0' }); subfile.size = BitConverter.ToUInt32(buf, offset + 260); subfile.offset = BitConverter.ToUInt32(buf, offset + 264); Metadata metadata = new Metadata(); metadata.LastBytes = new byte[20]; System.Array.Copy(buf, offset + 268, metadata.LastBytes, 0, 20); subfile.Metadata = metadata; subfiles.Add(subfile); } } return subfiles; }
private static string GetDataTypeName(Metadata metadata) { if (metadata.Hidden.HasValue && metadata.Hidden.Value) { return "HiddenInput"; } return metadata.DataTypeName; }
static string GetTemplateHint(Metadata metadata) { if (metadata.Hidden.HasValue && metadata.Hidden.Value) { return "HiddenInput"; } return metadata.TemplateHint; }
private Metadata metadata; // the metadata assoc w/ raster /// <summary> /// No arg constructor /// </summary> /// <remark> /// Used before calling Read() /// </remark> public ImageHeader() { this.dimensions = new Dimensions(0,0); this.bandType = System.TypeCode.Byte; this.bandSize = 0; this.bandCount = 0; this.metadata = new Metadata(); }
protected string GetMetadataTranslation(Metadata metadata) { MetadataTranslation translation = metadata.Translations.GetMetadataTranslation(FoundationContext.Culture); string trans = "No translation available for " + FoundationContext.Culture.IetfLanguageTag; if (translation != null) trans = translation.Translation; return trans; }
protected void WriteData(StoreLocation location, Metadata m, byte[] data) { var ct = CancellationToken.None; _store.SaveData(location, m, null, async (s) => { await s.WriteAsync(data, 0, data.Length, ct).ConfigureAwait(false); return data.Length; }, ct).Wait(); }
public VariableDeclarationsInspector(Metadata metadata) : base(metadata) { }
public ContentSeriesInfo(string name, string link, string img) { Metadata.Add("name", name); Metadata.Add("link", link); Metadata.Add("img", img); }
public IEnumerable <Metadata> Transform(Metadata metadata, TransformOptions opts) { if (metadata.Vref != null && metadata.Vref.Source == "ksp-avc") { var json = metadata.Json(); Log.InfoFormat("Executing internal AVC transformation with {0}", metadata.Kref); Log.DebugFormat("Input metadata:{0}{1}", Environment.NewLine, json); var noVersion = metadata.Version == null; if (noVersion) { json["version"] = "0"; // TODO: DBB: Dummy version necessary to the next statement doesn't throw } var mod = CkanModule.FromJson(json.ToString()); if (noVersion) { json.Remove("version"); } var file = _http.DownloadPackage(metadata.Download, metadata.Identifier, metadata.RemoteTimestamp); var avc = _moduleService.GetInternalAvc(mod, file, metadata.Vref.Id); if (avc != null) { Log.Info("Found internal AVC version file"); var remoteUri = GetRemoteAvcUri(avc); if (remoteUri != null) { try { var remoteJson = _github?.DownloadText(remoteUri) ?? _http.DownloadText(remoteUri); var remoteAvc = JsonConvert.DeserializeObject <AvcVersion>(remoteJson); if (avc.version.CompareTo(remoteAvc.version) == 0) { // Local AVC and Remote AVC describe the same version, prefer Log.Info("Remote AVC version file describes same version as local AVC version file, using it preferrentially."); avc = remoteAvc; } } catch (Exception e) { Log.InfoFormat("An error occured fetching the remote AVC version file, ignoring: {0}", e.Message); Log.Debug(e); } } ApplyVersions(json, avc); // It's cool if we don't have version info at all, it's optional in the AVC spec. Log.DebugFormat("Transformed metadata:{0}{1}", Environment.NewLine, json); } yield return(new Metadata(json)); } else { yield return(metadata); } }
/// <summary> /// Forwards the email to the relay email address. /// </summary> /// <param name="mimeMessage">The MIME message.</param> public void ForwardEmail(MimeMessage mimeMessage) { Metadata metadata = MetadataFactory.GenerateFrom(mimeMessage); // Add tags to the subject string subject = mimeMessage.Subject; IEmailEntry emailEntry = emailEntryCache.Get(toCache.Get(mimeMessage)); if (!string.IsNullOrEmpty(emailEntry?.Tag)) { metadata.Tag = emailEntry.Tag; subject = $"[{emailEntry.Tag}] {subject}"; } Email email = new Email( new System.Net.Mail.MailAddress(_options.GetSender()), new System.Net.Mail.MailAddress(_options.RelayEmail)) { Subject = subject, }; foreach (MimeEntity mimeEntity in mimeMessage.BodyParts) { if (mimeEntity.IsAttachment) { if (!(mimeEntity is MimePart mimePart)) { continue; } Attachment temporaryAttachment; using (MemoryStream memoryStream = new MemoryStream()) { mimePart.Content.DecodeTo(memoryStream); memoryStream.Seek(0, SeekOrigin.Begin); temporaryAttachment = new TemporaryAttachment(memoryStream) { DisplayFileName = mimePart.FileName, ContentType = mimePart.ContentType.MimeType, Encoding = mimePart.ContentTransferEncoding.GetRaw(), }; } email.Attachments.Add(temporaryAttachment); } else if (mimeEntity is TextPart textPart) { string text = textPart.Text; if (textPart.ContentType.MimeType == Constants.TextMimeType) { text = MetadataSerializer.SerializeForText(metadata, text); } else if (textPart.ContentType.MimeType == Constants.HtmlMimeType) { text = MetadataSerializer.SerializeForHtml(metadata, text); } email.TextContents.Add( new Text() { RawText = text, MimeType = textPart.ContentType.MimeType, Charset = textPart.ContentType.Charset, }); } } _sender.SendEmail(email); emailEntryCache.Clear(); toCache.Clear(); }
public Sku() { this.Attributes = new Metadata(); this.Metadata = new Metadata(); }
public UnitButtonInspector(Metadata metadata) : base(metadata) { }
public void RemoveCustom(BEncodedString key) { Check.Key(key); Metadata.Remove(key); }
private void BUT_samplephoto_Click(object sender, EventArgs e) { OpenFileDialog ofd = new OpenFileDialog(); ofd.Filter = "*.jpg|*.jpg"; ofd.ShowDialog(); if (File.Exists(ofd.FileName)) { string fn = ofd.FileName; Metadata lcMetadata = null; try { FileInfo lcImgFile = new FileInfo(fn); // Loading all meta data lcMetadata = JpegMetadataReader.ReadMetadata(lcImgFile); } catch (JpegProcessingException ex) { log.InfoFormat(ex.Message); return; } foreach (AbstractDirectory lcDirectory in lcMetadata) { foreach (var tag in lcDirectory) { Console.WriteLine(lcDirectory.GetName() + " - " + tag.GetTagName() + " " + tag.GetTagValue().ToString()); } if (lcDirectory.ContainsTag(ExifDirectory.TAG_EXIF_IMAGE_HEIGHT)) { TXT_imgheight.Text = lcDirectory.GetInt(ExifDirectory.TAG_EXIF_IMAGE_HEIGHT).ToString(); } if (lcDirectory.ContainsTag(ExifDirectory.TAG_EXIF_IMAGE_WIDTH)) { TXT_imgwidth.Text = lcDirectory.GetInt(ExifDirectory.TAG_EXIF_IMAGE_WIDTH).ToString(); } if (lcDirectory.ContainsTag(ExifDirectory.TAG_FOCAL_PLANE_X_RES)) { var unit = lcDirectory.GetFloat(ExifDirectory.TAG_FOCAL_PLANE_UNIT); // TXT_senswidth.Text = lcDirectory.GetDouble(ExifDirectory.TAG_FOCAL_PLANE_X_RES).ToString(); } if (lcDirectory.ContainsTag(ExifDirectory.TAG_FOCAL_PLANE_Y_RES)) { var unit = lcDirectory.GetFloat(ExifDirectory.TAG_FOCAL_PLANE_UNIT); // TXT_sensheight.Text = lcDirectory.GetDouble(ExifDirectory.TAG_FOCAL_PLANE_Y_RES).ToString(); } if (lcDirectory.ContainsTag(ExifDirectory.TAG_FOCAL_LENGTH)) { try { var item = lcDirectory.GetFloat(ExifDirectory.TAG_FOCAL_LENGTH); num_focallength.Value = (decimal)item; } catch { } } if (lcDirectory.ContainsTag(ExifDirectory.TAG_DATETIME_ORIGINAL)) { } } } }
protected override void ConvertToConfiguration(Metadata data) { }
/// <summary> /// Appends OpenTelemetry headers for every outgoing request to Stackdriver Backend. /// </summary> /// <param name="metadata">The metadata that is sent with every outgoing http request.</param> private static void StackdriverCallHeaderAppender(Metadata metadata) { metadata.Add("AGENT_LABEL_KEY", "g.co/agent"); metadata.Add("AGENT_LABEL_VALUE_STRING", $"{OpenTelemetryExporterVersion}; stackdriver-exporter {StackdriverExportVersion}"); }
private List <Token> MergeMultipleExtractions(string text, List <ExtractResult> extractionResults) { var ret = new List <Token>(); var metadata = new Metadata { PossiblyIncludePeriodEnd = true }; if (extractionResults.Count <= 1) { return(ret); } var idx = 0; while (idx < extractionResults.Count - 1) { var middleBegin = extractionResults[idx].Start + extractionResults[idx].Length ?? 0; var middleEnd = extractionResults[idx + 1].Start ?? 0; if (middleBegin >= middleEnd) { idx++; continue; } var middleStr = text.Substring(middleBegin, middleEnd - middleBegin).Trim().ToLowerInvariant(); var match = this.config.TillRegex.Match(middleStr); if (match.Success && match.Index == 0 && match.Length == middleStr.Length) { var periodBegin = extractionResults[idx].Start ?? 0; var periodEnd = (extractionResults[idx + 1].Start ?? 0) + (extractionResults[idx + 1].Length ?? 0); // handle "from/between" together with till words (till/until/through...) var beforeStr = text.Substring(0, periodBegin).Trim().ToLowerInvariant(); if (this.config.GetFromTokenIndex(beforeStr, out int fromIndex) || this.config.GetBetweenTokenIndex(beforeStr, out fromIndex)) { periodBegin = fromIndex; } ret.Add(new Token(periodBegin, periodEnd, metadata)); // merge two tokens here, increase the index by two idx += 2; continue; } if (this.config.HasConnectorToken(middleStr)) { var periodBegin = extractionResults[idx].Start ?? 0; var periodEnd = (extractionResults[idx + 1].Start ?? 0) + (extractionResults[idx + 1].Length ?? 0); // handle "between...and..." case var beforeStr = text.Substring(0, periodBegin).Trim().ToLowerInvariant(); if (this.config.GetBetweenTokenIndex(beforeStr, out int beforeIndex)) { periodBegin = beforeIndex; ret.Add(new Token(periodBegin, periodEnd, metadata)); // merge two tokens here, increase the index by two idx += 2; continue; } } idx++; } return(ret); }
public ContentSeries(string name, SeriesInstallment[] installments) { Metadata.Add("name", name); Installments = installments; }
public ListAdaptor(Metadata metadata, VariableDeclarationsInspector parentInspector) : base(metadata, parentInspector) { this.parentInspector = parentInspector; alwaysDragAndDrop = true; }
public virtual bool CanSetRequired(bool isRequired, ConfigurationSource configurationSource) => (configurationSource.Overrides(Metadata.GetIsNullableConfigurationSource()) || (Metadata.IsNullable == !isRequired)) && (isRequired || Metadata.ClrType.IsNullableType() || (configurationSource == ConfigurationSource.Explicit)); // let it throw for Explicit
public void Write() { try { using (Stream objectsMS = GetTempStream()) { using (Stream metaMS = GetTempStream()) { using (AssetsWriter writer = new AssetsWriter(objectsMS)) { int ctr = 0; foreach (var obj in Metadata.ObjectInfos) { ctr++; var offset = (int)objectsMS.Position; obj.GetObjectForWrite().Write(writer); writer.Flush(); obj.DataOffset = offset; var origSize = obj.DataSize; obj.DataSize = (int)(objectsMS.Position - obj.DataOffset); writer.AlignTo(8); } } using (AssetsWriter writer = new AssetsWriter(metaMS)) { Metadata.Write(writer); } Header.FileSize = Header.HeaderSize + (int)objectsMS.Length + (int)metaMS.Length; Header.ObjectDataOffset = Header.HeaderSize + (int)metaMS.Length; int diff; int alignment = 16; //or 32, I don't know which //data has to be at least 4096 inward from the start of the file if (Header.ObjectDataOffset < 4096) { diff = 4096 - Header.ObjectDataOffset; } else { diff = alignment - (Header.ObjectDataOffset % alignment); if (diff == alignment) { diff = 0; } } if (diff > 0) { Header.ObjectDataOffset += diff; Header.FileSize += diff; } Header.MetadataSize = (int)metaMS.Length; objectsMS.Seek(0, SeekOrigin.Begin); metaMS.Seek(0, SeekOrigin.Begin); lock (this) { try { CloseBaseStream(); FileProvider.DeleteFiles(AssetsRootPath.CombineFwdSlash(AssetsFilename + ".split*")); using (Stream outputStream = GetTempStream()) { using (AssetsWriter writer = new AssetsWriter(outputStream)) { Header.Write(writer); } metaMS.CopyTo(outputStream); if (diff > 0) { outputStream.Write(new byte[diff], 0, diff); } objectsMS.CopyTo(outputStream); outputStream.Seek(0, SeekOrigin.Begin); if (FileWasSplit) { int splitCtr = 0; byte[] buffer = new byte[1024 * 1024]; do { Stream outFile = FileProvider.GetWriteStream($"{AssetsRootPath.CombineFwdSlash(AssetsFilename)}.split{splitCtr}"); var readLen = (int)(outputStream.Length - outputStream.Position); if (readLen < buffer.Length) { outputStream.Read(buffer, 0, readLen); outFile.Write(buffer, 0, readLen); break; } outputStream.Read(buffer, 0, buffer.Length); outFile.Write(buffer, 0, buffer.Length); splitCtr++; } while (true); } else { Stream writeStream = FileProvider.GetWriteStream(AssetsRootPath.CombineFwdSlash(AssetsFilename)); outputStream.CopyTo(writeStream); } } FileProvider.Save(); _hasChanges = false; foreach (var ptr in _knownPointers.Where(x => x.Owner.ObjectInfo.ParentFile == this && x.IsNew)) { ptr.IsNew = false; } OpenBaseStream(); } catch (Exception ex) { throw new Exception("CRITICAL: writing and reopening the file failed, the file is possibly destroyed and this object is in an unknown state.", ex); } } } } } finally { CleanupTempFiles(); } }
public override string ToString() { return("BeatInfo{" + "port=" + Port + ", ip='" + Ip + '\'' + ", weight=" + Weight + ", serviceName='" + ServiceName + '\'' + ", cluster='" + Cluster + '\'' + ", metadata=" + Metadata.ToJsonString() + ", scheduled=" + Scheduled + ", period=" + Period + ", stopped=" + Stopped + '}'); }
protected internal Layer(string name, Metadata metadata) { Name = name ?? throw new ArgumentNullException(nameof(name)); Metadata = metadata ?? throw new ArgumentNullException(nameof(metadata)); }
public Metadata(string name, Metadata parent) : base(name) { Parent = parent; }
public void RegisterMetadata(Type type, Metadata metadata) { throw new NotImplementedException(); }
private List <Token> MergeMultipleExtractions(string text, List <ExtractResult> extractionResults) { var ret = new List <Token>(); var metadata = new Metadata { PossiblyIncludePeriodEnd = true, }; if (extractionResults.Count <= 1) { return(ret); } var idx = 0; while (idx < extractionResults.Count - 1) { var middleBegin = extractionResults[idx].Start + extractionResults[idx].Length ?? 0; var middleEnd = extractionResults[idx + 1].Start ?? 0; if (middleBegin >= middleEnd) { idx++; continue; } var middleStr = text.Substring(middleBegin, middleEnd - middleBegin).Trim(); var endPointStr = extractionResults[idx + 1].Text; if (config.TillRegex.IsExactMatch(middleStr, trim: true) || (string.IsNullOrEmpty(middleStr) && config.TillRegex.MatchBegin(endPointStr, trim: true).Success)) { var periodBegin = extractionResults[idx].Start ?? 0; var periodEnd = (extractionResults[idx + 1].Start ?? 0) + (extractionResults[idx + 1].Length ?? 0); // handle "from/between" together with till words (till/until/through...) var beforeStr = text.Substring(0, periodBegin); var beforeMatch = this.config.RangePrefixRegex.MatchEnd(beforeStr, trim: true); if (beforeMatch.Success) { periodBegin = beforeMatch.Index; } else { var afterStr = text.Substring(periodEnd); var afterMatch = this.config.RangeSuffixRegex.MatchBegin(afterStr, trim: true); if (afterMatch.Success) { periodEnd += afterMatch.Index + afterMatch.Length; } } ret.Add(new Token(periodBegin, periodEnd, metadata)); // merge two tokens here, increase the index by two idx += 2; continue; } idx++; } return(ret); }
public IEnumerable <AdamItem> Items(int appId, string contentType, Guid guid, string field, string subfolder, bool usePortalRoot = false) { var wrapLog = Log.Call <IEnumerable <AdamItem> >("Items", $"adam items a:{appId}, i:{guid}, field:{field}, subfold:{subfolder}, useRoot:{usePortalRoot}"); var state = new AdamSecureState(SxcInstance, appId, contentType, field, guid, usePortalRoot, Log); Log.Add("starting permissions checks"); if (state.UserIsRestricted && !state.FieldPermissionOk(GrantSets.ReadSomething)) { return(wrapLog("user is restricted, and doesn't have permissions on field - return null", null)); } // check that if the user should only see drafts, he doesn't see items of published data if (!state.UserIsNotRestrictedOrItemIsDraft(guid, out var _)) { return(wrapLog("user is restricted (no read-published rights) and item is published - return null", null)); } Log.Add("first permission checks passed"); // get root and at the same time auto-create the core folder in case it's missing (important) state.ContainerContext.Folder(); // try to see if we can get into the subfolder - will throw error if missing var currentAdam = state.ContainerContext.Folder(subfolder, false); var folderManager = FolderManager.Instance; var currentDnn = folderManager.GetFolder(currentAdam.Id); // ensure that it's super user, or the folder is really part of this item if (!state.SuperUserOrAccessingItemFolder(currentDnn.PhysicalPath, out var exp)) { Log.Add("user is not super-user and folder doesn't seem to be an ADAM folder of this item - will throw"); throw exp; } var subfolders = folderManager.GetFolders(currentDnn); var files = folderManager.GetFiles(currentDnn); var all = new List <AdamItem>(); // currentFolder is needed to get allowEdit for Adam root folder var currentFolder = new AdamItem(currentDnn, usePortalRoot, state) { Name = ".", MetadataId = Metadata.GetMetadataId(state.AdamAppContext.AppRuntime, currentDnn.FolderID, true) }; all.Insert(0, currentFolder); var adamFolders = subfolders.Where(s => s.FolderID != currentDnn.FolderID) .Select(f => new AdamItem(f, usePortalRoot, state) { MetadataId = Metadata.GetMetadataId(state.AdamAppContext.AppRuntime, f.FolderID, true) }) .ToList(); all.AddRange(adamFolders); var adamFiles = files .Select(f => new AdamItem(f, usePortalRoot, state) { MetadataId = Metadata.GetMetadataId(state.AdamAppContext.AppRuntime, f.FileId, false), Type = Classification.TypeName(f.Extension) }) .ToList(); all.AddRange(adamFiles); Log.Add($"items complete - will return fld⋮{adamFolders.Count}, files⋮{adamFiles.Count} tot⋮{all.Count}"); return(all); }
public Token(int s, int e, Metadata metadata = null) { Start = s; End = e; Metadata = metadata; }
private static IEnumerable <ModuleMetadata> EnumerateModules(Metadata metadata) { return((metadata.Kind == MetadataImageKind.Assembly) ? ((AssemblyMetadata)metadata).GetModules().AsEnumerable() : SpecializedCollections.SingletonEnumerable((ModuleMetadata)metadata)); }
private void FixCollisions(System.Management.Automation.PSCmdlet cmdlet, MappingToolDatabaseDataContext mapDatabaseContext, List <CollisionInfo> collisions) { List <QueryMapRelationship> relationshipsToReconnect = new List <QueryMapRelationship>(); foreach (CollisionInfo collision in collisions) { cmdlet.WriteWarning("Fixing collision."); IEnumerable <QueryMapRelationship> relationships = Consumer.GetRelationships(collision.CollisionPoint); foreach (QueryMapRelationship relationship in relationships) { IEnumerable <QueryMapNode> nodes = Consumer.GetNodes(relationship, collision.CollisionPoint); foreach (QueryMapNode node in nodes) { var rootMapIds = from qNode in mapDatabaseContext.Nodes where qNode.NodeUid == node.NodeUid select qNode.RootMapUid; Guid?rootMapId = rootMapIds.FirstOrDefault(); if (rootMapId != null && rootMapId == collision.CollidingRootMap.NodeUid) { relationshipsToReconnect.Add(relationship); } } } DateTime currentTimestamp = DateTime.Now; Node copiedNode = new Node(); copiedNode.NodeUid = Guid.NewGuid(); copiedNode.DomainUid = collision.CollisionPoint.DomainUid; copiedNode.RootMapUid = collision.CollidingRootMap.NodeUid; copiedNode.NodeTypeUid = collision.CollisionPoint.NodeTypeUid; copiedNode.NodeOriginalId = collision.CollisionPoint.NodeOriginalId; copiedNode.Created = currentTimestamp; copiedNode.Modified = currentTimestamp; mapDatabaseContext.Nodes.InsertOnSubmit(copiedNode); mapDatabaseContext.SubmitChanges(); var originalMetadata = from qMetadata in Consumer.Metadata where qMetadata.NodeUid == collision.CollisionPoint.NodeUid select qMetadata; foreach (var originalMetadatum in originalMetadata) { Metadata copiedMetadata = new Metadata(); copiedMetadata.MetadataId = Guid.NewGuid(); copiedMetadata.RootMapUid = collision.CollidingRootMap.NodeUid; copiedMetadata.DomainUid = copiedNode.DomainUid; copiedMetadata.MetadataTypeUid = originalMetadatum.MetadataTypeUid; copiedMetadata.NodeUid = copiedNode.NodeUid; copiedMetadata.RelationshipUid = originalMetadatum.RelationshipUid; copiedMetadata.DescriptorTypeUid = originalMetadatum.DescriptorTypeUid; copiedMetadata.MetadataName = originalMetadatum.MetadataName; copiedMetadata.MetadataValue = originalMetadatum.MetadataValue; copiedMetadata.Created = currentTimestamp; copiedMetadata.Modified = currentTimestamp; mapDatabaseContext.Metadatas.InsertOnSubmit(copiedMetadata); } mapDatabaseContext.SubmitChanges(); foreach (QueryMapRelationship relationshipToReconnect in relationshipsToReconnect) { var descriptors = from qDescriptor in mapDatabaseContext.Descriptors where qDescriptor.NodeUid == collision.CollisionPoint.NodeUid && qDescriptor.RelationshipUid == relationshipToReconnect.RelationshipUid select qDescriptor; if (descriptors != null && descriptors.Count() > 0) { foreach (Descriptor descriptor in descriptors) { descriptor.NodeUid = copiedNode.NodeUid; } } mapDatabaseContext.SubmitChanges(); } } }
/// <summary> /// Extract tiff information (used by raw files) /// </summary> /// <param name="aMetadata">where to extract information</param> /// <returns>the information extracted</returns> public Metadata ExtractTiff(Metadata aMetadata) { return(this.ExtractIFD(aMetadata, 0)); }
public ContentResource(MediaType resourceType, string link) { Metadata.Set("type", resourceType.ToString()); Metadata.Set("link", link); }
/// <summary> /// Performs the Exif data extraction, adding found values to the specified instance of Metadata. /// </summary> /// <param name="aMetadata">where to add meta data</param> /// <returns>the aMetadata</returns> public override Metadata Extract(Metadata metadata) { this.metadata = metadata; if (base.data == null) { return(this.metadata); } // once we know there'str some data, create the directory and start working on it AbstractDirectory directory = this.metadata.GetDirectory("com.drew.metadata.exif.ExifDirectory"); if (base.data.Length <= 14) { directory.HasError = true; Trace.TraceError("Exif data segment must contain at least 14 bytes"); return(this.metadata); } if (!"Exif\0\0".Equals(Utils.Decode(base.data, 0, 6, false))) { directory.HasError = true; Trace.TraceError("Exif data segment doesn't begin with 'Exif'"); return(this.metadata); } // this should be either "MM" or "II" string byteOrderIdentifier = Utils.Decode(base.data, 6, 2, false); if (!SetByteOrder(byteOrderIdentifier)) { directory.HasError = true; Trace.TraceError("Unclear distinction between Motorola/Intel byte ordering"); return(this.metadata); } // Check the next two values for correctness. if (Get16Bits(8) != 0x2a) { directory.HasError = true; Trace.TraceError("Invalid Exif start - should have 0x2A at offSet 8 in Exif header"); return(this.metadata); } int firstDirectoryOffSet = Get32Bits(10) + TIFF_HEADER_START_OFFSET; // David Ekholm sent an digital camera image that has this problem if (firstDirectoryOffSet >= base.data.Length - 1) { directory.HasError = true; Trace.TraceError("First exif directory offSet is beyond end of Exif data segment"); // First directory normally starts 14 bytes in -- try it here and catch another error in the worst case firstDirectoryOffSet = 14; } // 0th IFD (we merge with Exif IFD) //ProcessDirectory(directory, firstDirectoryOffSet); // after the extraction process, if we have the correct tags, we may be able to extract thumbnail information //ExtractThumbnail(directory); Dictionary <int, string> processedDirectoryOffsets = new Dictionary <int, string>(); // 0th IFD (we merge with Exif IFD) ProcessDirectory(directory, processedDirectoryOffsets, firstDirectoryOffSet, TIFF_HEADER_START_OFFSET); // after the extraction process, if we have the correct tags, we may be able to store thumbnail information StoreThumbnailBytes(directory, TIFF_HEADER_START_OFFSET); return(this.metadata); }
public override void SetMetadata(Metadata data) { throw new NotImplementedException(); }
public SeriesInstallment(string name, string link) : base() { Metadata.Add("name", name); Metadata.Add("link", link); }
public Metadata GetMetadata(HttpRequestMessage request) { var host = request.RequestUri.Scheme + "://" + request.RequestUri.Authority + request.GetRequestContext().VirtualPathRoot; var descriptions = config.Services.GetApiExplorer().ApiDescriptions; var documentationProvider = config.Services.GetDocumentationProvider(); ILookup <HttpControllerDescriptor, ApiDescription> apiGroups = descriptions .Where(a => !a.ActionDescriptor.ControllerDescriptor.ControllerType.IsAbstract && !a.RelativePath.Contains("Swagger") && !a.RelativePath.Contains("docs")) .ToLookup(a => a.ActionDescriptor.ControllerDescriptor); var metadata = new Metadata { Definitions = from d in apiGroups where !d.Key.ControllerType.IsExcluded() select new ControllerDefinition { Name = d.Key.ControllerName, Description = documentationProvider == null ? "" : documentationProvider.GetDocumentation(d.Key) ?? "", ActionMethods = from a in descriptions where !a.ActionDescriptor.ControllerDescriptor.ControllerType.IsExcluded() && !a.ActionDescriptor.IsExcluded() && !a.RelativePath.Contains("Swagger") && !a.RelativePath.Contains("docs") && a.ActionDescriptor.ControllerDescriptor.ControllerName == d.Key.ControllerName select new ActionMethodDefinition { Name = a.ActionDescriptor.ActionName, BodyParameter = (from b in a.ParameterDescriptions where b.Source == ApiParameterSource.FromBody select new ParameterDefinition { Name = b.ParameterDescriptor.ParameterName, Type = ParseType(b.ParameterDescriptor.ParameterType), Description = b.Documentation ?? "" }).FirstOrDefault(), UrlParameters = from b in a.ParameterDescriptions.Where(p => p.ParameterDescriptor != null) where b.Source == ApiParameterSource.FromUri select new ParameterDefinition { Name = b.ParameterDescriptor.ParameterName, Type = ParseType(b.ParameterDescriptor.ParameterType), Description = b.Documentation ?? "", IsOptional = b.ParameterDescriptor.IsOptional, DefaultValue = b.ParameterDescriptor.DefaultValue }, Url = a.RelativePath, Description = a.Documentation ?? "", ReturnType = ParseType(a.ResponseDescription.ResponseType ?? a.ResponseDescription.DeclaredType), Type = a.HttpMethod.Method } }, Models = models, Host = (null != host && host.Length > 0 && host[host.Length - 1] != '/') ? string.Concat(host, "/") : host }; metadata.Definitions = metadata.Definitions.Distinct().OrderBy(d => d.Name); metadata.Models = metadata.Models.Distinct(new ModelDefinitionEqualityComparer()).OrderBy(d => d.Name); return(metadata); }