コード例 #1
0
        public ImageLoader(object FileDir)
        {
            _root = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);  // Get full exe app location on disk.

            var DirPath = Path.Combine(Root, FileDir.ToString());

            if (Directory.Exists(DirPath))  // Check if directory is exists.
            {
                _supportedExtensions = new[] { ".bmp", ".jpeg", ".jpg", ".png" };
                _isCatched           = true;
                _files = Directory.GetFiles(Path.Combine(Root, FileDir.ToString()), "*.*").Where
                             ((ext) => SupportedExtensions.Contains(Path.GetExtension(ext).ToLower()));

                _imageSources = new List <ImageSource>();
                foreach (var file in Files)
                {
                    BitmapImage BMP = new BitmapImage();
                    BMP.BeginInit();
                    BMP.CacheOption = BitmapCacheOption.OnLoad;
                    BMP.UriSource   = new Uri(file, UriKind.Absolute);
                    BMP.EndInit();
                    BMP.Freeze();

                    _imageSources.Add(BMP);
                }
            }
        }
コード例 #2
0
        public bool IsSupportedExtension(string extension)
        {
            if (SupportedExtensions == null || SupportedExtensions.Count == 0)
            {
                return(true);
            }

            return(SupportedExtensions.Contains(extension));
        }
コード例 #3
0
        public static void ParseMetadata(
            DirectoryInfo inputDirectory,
            DirectoryInfo jsonOutputDirectory,
            string sqliteFilepath,
            bool exportSqlite,
            bool exportJson,
            bool shouldOverwrite)
        {
            var files      = inputDirectory.EnumerateFiles();
            var validFiles = files.Where(n => SupportedExtensions.Contains(n.Extension));
            var fileTagMap = new Dictionary <string, IDictionary <string, IEnumerable <string> > >();

            foreach (var file in validFiles)
            {
                var         path    = file.FullName;
                TagLib.File tagFile = null;
                try
                {
                    tagFile = TagLib.File.Create(path);
                }
                catch (Exception)
                {
                    // TODO: Add Logging
                    continue;
                }

                if (tagFile.GetTag(TagLib.TagTypes.Xiph) is TagLib.Ogg.XiphComment xiph)
                {
                    IDictionary <string, IEnumerable <string> > tagMap = xiph.ToDictionary(
                        fieldName => fieldName,
                        fieldName => xiph.GetField(fieldName).AsEnumerable());

                    fileTagMap.Add(file.Name, tagMap);
                    continue;
                }

                if (tagFile.GetTag(TagLib.TagTypes.Id3v2) is TagLib.Id3v2.Tag id3File)
                {
                    IDictionary <string, IEnumerable <string> > tagMap = GetID3v2TagMap(id3File);
                    fileTagMap.Add(file.Name, tagMap);
                    continue;
                }
            }

            if (fileTagMap.Any())
            {
                if (exportSqlite)
                {
                    ExportSqlite(fileTagMap, sqliteFilepath);
                }

                if (exportJson)
                {
                    ExportJson(fileTagMap, jsonOutputDirectory, shouldOverwrite);
                }
            }
        }
コード例 #4
0
        static FontCollection LoadSystemFonts()
        {
            // TODO: currently only supports Windows
            var collection = new FontCollection();

            foreach (var file in Directory.EnumerateFiles(Environment.GetFolderPath(Environment.SpecialFolder.Fonts)))
            {
                if (SupportedExtensions.Contains(Path.GetExtension(file).ToLowerInvariant()))
                {
                    collection.AddFontFile(file, throwOnError: false);
                }
            }

            return(collection);
        }
コード例 #5
0
        public string ModuleName(string filename)
        {
            if (!_fileSystem.File.Exists(filename))
            {
                return(null);
            }

            if (!SupportedExtensions.Contains(_fileSystem.Path.GetExtension(filename)))
            {
                return(null);
            }

            var contents = _fileSystem.File.ReadLines(filename, Encoding.Default);
            var nameLine = contents.FirstOrDefault(line => line.StartsWith("Attribute VB_Name = "));

            if (nameLine == null)
            {
                return(_fileSystem.Path.GetFileNameWithoutExtension(filename));
            }

            //The format is Attribute VB_Name = "ModuleName"
            return(nameLine.Substring("Attribute VB_Name = ".Length + 1, nameLine.Length - "Attribute VB_Name = ".Length - 2));
        }
コード例 #6
0
 public bool SupportsExtension(string oid)
 => SupportedExtensions != null && SupportedExtensions.Contains(oid);
コード例 #7
0
        protected void AddNodesToQueue(IEnumerable <XElement> nodes, string type)
        {
            if (_searchConfiguration.EnableIndexing == false)
            {
                LogHelper.Info <ElasticPublishedContentMediaIndexer>("Skipping AddNodesToQueue. EnableIndexing is configured to disabled.");
                return;
            }

            var umbracoContext = GetUmbracoContext();

            if (umbracoContext == null)
            {
                LogHelper.Info <ElasticPublishedContentMediaIndexer>(() => "Skipping AddNodesToQueue as a valid UmbracoContext was unobtainable.");
                return;
            }

            var fullUrlResolverService = new UmbracoContextFullUrlResolverService(umbracoContext);

            using (var searchIndexingQueueService = new SearchIndexingQueueService(_searchConfiguration))
            {
                LogHelper.Info <ElasticPublishedContentMediaIndexer>("AddNodesToQueue: {0} node(s) for index type {1}.", () => nodes.Count(), () => type);

                foreach (var node in nodes)
                {
                    DataService.LogService.AddVerboseLog((int)node.Attribute("id"), string.Format("AddSingleNodeToIndex with type: {0}", type));

                    int nodeId = int.Parse(node.Attribute(XName.Get("id")).Value);

                    var values = GetDataToIndex(node, type);
                    //raise the event and assign the value to the returned data from the event
                    var indexingNodeDataArgs = new IndexingNodeDataEventArgs(node, nodeId, values, type);
                    OnGatheringNodeData(indexingNodeDataArgs);
                    values = indexingNodeDataArgs.Fields;

                    values.TryGetValue("nodeName", out string nodeName);
                    string publishDate = string.Empty;
                    if (!values.TryGetValue("reviewedDate", out publishDate))
                    {
                        if (!values.TryGetValue("publishedDate", out publishDate))
                        {
                            if (values.TryGetValue("updateDate", out publishDate))
                            {
                                // Defaulted to updateDate property
                            }
                        }
                    }

                    var document = new SearchIndexDocumentModel()
                    {
                        NodeId    = nodeId,
                        Site      = _site,
                        Published = DateTime.Parse(publishDate),
                        Title     = nodeName
                    };

                    // Determine if this is content or media
                    if (string.Equals(type, UmbracoExamine.IndexTypes.Content, StringComparison.OrdinalIgnoreCase))
                    {
                        var url = fullUrlResolverService.ResolveContentFullUrlById(nodeId);

                        // Get content based on content fields in order of priority
                        var contentBuilder = new StringBuilder();

                        foreach (var contentField in values.Where(x => IndexerData.UserFields.Select(y => y.Name).Contains(x.Key)))
                        {
                            var contentFieldValue = contentField.Value;
                            // Check if it has a value and append it
                            if (string.IsNullOrEmpty(contentFieldValue) == false)
                            {
                                if (contentFieldValue.DetectIsJson() && JsonUtility.TryParseJson(contentFieldValue, out object parsedJson))
                                {
                                    var processedJsonValue = ProcessJsonValue(parsedJson);

                                    if (string.IsNullOrEmpty(processedJsonValue) == false)
                                    {
                                        contentBuilder.AppendLine(processedJsonValue);
                                    }
                                }
                                else
                                {
                                    var sanitisedValue = contentFieldValue.StripHtml().Trim();

                                    if (string.IsNullOrWhiteSpace(sanitisedValue) == false)
                                    {
                                        contentBuilder.AppendLine(sanitisedValue);
                                    }
                                }
                            }
                        }


                        string content = contentBuilder.ToString().Trim();

                        document.Url     = url;
                        document.Content = content;

                        // index the node
                        searchIndexingQueueService.QueueUpsert(document);
                    }
                    else if (string.Equals(type, UmbracoExamine.IndexTypes.Media, StringComparison.OrdinalIgnoreCase))
                    {
                        var fileExtension = node.Elements().FirstOrDefault(x =>
                        {
                            if (x.Attribute("alias") != null)
                            {
                                return((string)x.Attribute("alias") == this.UmbracoExtensionProperty);
                            }
                            else
                            {
                                return(x.Name == this.UmbracoExtensionProperty);
                            }
                        });

                        if (HasNode(fileExtension) == false)
                        {
                            LogHelper.Warn <ElasticPublishedContentMediaIndexer>("Media name " + nodeName + " with ID " + nodeId + " has not been pushed up to SQS. Reason: " + UmbracoExtensionProperty + " value was not present.");
                            continue;
                        }

                        if (!SupportedExtensions.Contains(fileExtension.Value, StringComparer.OrdinalIgnoreCase))
                        {
                            LogHelper.Info <ElasticPublishedContentMediaIndexer>("Media name " + nodeName + " with ID " + nodeId + " has not been pushed up to SQS. Reason: File extension, " + fileExtension.Value + ", is not supported.");
                            continue;
                        }

                        var filePath = node.Elements().FirstOrDefault(x =>
                        {
                            if (x.Attribute("alias") != null)
                            {
                                return((string)x.Attribute("alias") == this.UmbracoFileProperty);
                            }
                            else
                            {
                                return(x.Name == this.UmbracoFileProperty);
                            }
                        });


                        if (HasNode(filePath) == false)
                        {
                            LogHelper.Warn <ElasticPublishedContentMediaIndexer>("Media name " + nodeName + " with ID " + nodeId + " has not been pushed up to SQS. Reason: " + UmbracoFileProperty + " value was not present.");
                            continue;
                        }

                        //get the file path from the data service
                        var fullPath = this.DataService.MapPath((string)filePath);

                        if (System.IO.File.Exists(fullPath) == false)
                        {
                            LogHelper.Warn <ElasticPublishedContentMediaIndexer>("Media name " + nodeName + " with ID " + nodeId + " has not been pushed up to SQS. Reason: Physical file does not exist.");
                            continue;
                        }

                        var fileInfo = new FileInfo(fullPath);
                        var url      = fullUrlResolverService.ResolveMediaFullUrl(filePath.Value);
                        // index the node

                        var pdf        = System.IO.File.ReadAllBytes(fullPath);
                        var pdfEncoded = Convert.ToBase64String(pdf);

                        document.Url               = url;
                        document.Content           = "Umbraco Media File";
                        document.FileBase64Encoded = pdfEncoded;
                        document.FileExtension     = fileInfo.Extension;
                        document.FileSizeInBytes   = fileInfo.Length;

                        searchIndexingQueueService.QueueUpsert(document);
                    }
                }
            }
        }
コード例 #8
0
        private void ScanImagesThread(
            BackgroundWorker imagesScanner,
            DoWorkEventArgs e)
        {
            IndexOfCurImg = -2;
            int count = 0;

            if (UiStartDirectory != null)
            {
                var directoryInfo = new DirectoryInfo(UiStartDirectory);

                foreach (var imageFile in directoryInfo.GetFiles().Where(s => s.Extension.Length >= 3 && SupportedExtensions.Contains(
                                                                             s.Extension.ToLower())))
                {
                    Dispatcher.Invoke(new Action(() =>
                    {
                        var img = new Image
                        {
                            Source    = DefImage,
                            Tag       = imageFile.FullName,
                            MaxWidth  = SizeImage,
                            MaxHeight = SizeImage * 0.8,
                            Stretch   = Stretch.UniformToFill,
                            Margin    = new Thickness(3)
                        };

                        img.MouseLeftButtonUp += OnImageWrapPanelClick;
                        img.MouseEnter        += OnStartHover;
                        img.MouseLeave        += OnEndHover;

                        imgWrapList.Children.Add(img);

                        var timeToolTip = new ToolTip
                        {
                            PlacementTarget = img,
                            Content         = imageFile.Name
                        };

                        img.ToolTip = timeToolTip;
                        count       = imgWrapList.Children.Count;
                        if (count != 1)
                        {
                            return;
                        }

                        UcImageViewer.ImageList.IndexOfCurImg = 0;
                        OnImageWrapPanelClick(imgWrapList.Children[0],
                                              new RoutedEventArgs());
                    }), null);
                }

                for (int i = 0; i < count; i++)
                {
                    var counter = i;
                    Dispatcher.Invoke(new Action(() =>
                    {
                        if (imgWrapList.Children.Count == 0)
                        {
                            return;
                        }

                        var img    = ((Image)imgWrapList.Children[counter]);
                        img.Source = ImageUtils.GetSmallImage(img.Tag.ToString(),
                                                              (int)SizeImage + 30);
                    }), null);

                    Thread.Sleep(40);
                }
            }
        }
コード例 #9
0
ファイル: Initialization.cs プロジェクト: Iemnur/SceneNavi
 public static bool CheckForExtension(string NeededExt)
 {
     return(SupportedExtensions.Contains(NeededExt));
 }