public FileIndexItem XmpGetSidecarFile(FileIndexItem databaseItem) { if (databaseItem == null) { databaseItem = new FileIndexItem(); } // Parse an xmp file for this location var xmpSubPath = ExtensionRolesHelper.ReplaceExtensionWithXmp(databaseItem.FilePath); // also add when the file is a jpeg, we are not writing to it then if (_iStorage.ExistFile(xmpSubPath)) { databaseItem.AddSidecarExtension("xmp"); } // Read content from sidecar xmp file if (!ExtensionRolesHelper.IsExtensionForceXmp(databaseItem.FilePath) || !_iStorage.ExistFile(xmpSubPath)) { return(databaseItem); } // Read the text-content of the xmp file. var xmp = new PlainTextFileHelper().StreamToString(_iStorage.ReadStream(xmpSubPath)); // Get the data from the xmp databaseItem = GetDataFromString(xmp, databaseItem); return(databaseItem); }
/// <summary> /// Update compared values /// </summary> /// <param name="sourceIndexItem">the source object</param> /// <param name="updateObject">the item with changed values</param> /// <param name="differenceList">typeName of item</param> /// <returns></returns> public static FileIndexItem SetCompare(FileIndexItem sourceIndexItem, FileIndexItem updateObject, List <string> differenceList) { if (updateObject == null) { updateObject = new FileIndexItem(); } PropertyInfo[] propertiesA = sourceIndexItem.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); PropertyInfo[] propertiesB = updateObject.GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance); int count = propertiesA.Length; for (int i = 0; i < count; i++) { if ((!propertiesA[i].CanRead) || (!propertiesB[i].CanRead)) { continue; } if (!differenceList.Contains(propertiesA[i].Name)) { continue; } var newRotationValue = propertiesB [i].GetValue(updateObject, null); sourceIndexItem.GetType().GetProperty(propertiesA[i].Name).SetValue(sourceIndexItem, newRotationValue, null); } return(sourceIndexItem); }
public static List <FileIndexItem> SearchAndReplace(List <FileIndexItem> fileIndexResultsList, string fieldName, string search, string replace) { foreach (var fileIndexItem in fileIndexResultsList.Where( p => p.Status == FileIndexItem.ExifStatus.Ok || p.Status == FileIndexItem.ExifStatus.Deleted)) { var searchInObject = FileIndexCompareHelper.Get(fileIndexItem, fieldName); var replacedToObject = new object(); PropertyInfo[] propertiesA = new FileIndexItem().GetType().GetProperties( BindingFlags.Public | BindingFlags.Instance); PropertyInfo property = propertiesA.FirstOrDefault(p => string.Equals( p.Name, fieldName, StringComparison.InvariantCultureIgnoreCase)); if (property.PropertyType == typeof(string)) { var searchIn = ( string )searchInObject; // Replace Ignore Case replacedToObject = Regex.Replace( searchIn, Regex.Escape(search), replace.Replace("$", "$$"), RegexOptions.IgnoreCase ); } // only string types are added here, other types are ignored for now FileIndexCompareHelper.Set(fileIndexItem, fieldName, replacedToObject); } return(fileIndexResultsList); }
/// <summary> /// Set values by string name. fieldContent must by the right type /// wrong types are ignored by default /// </summary> /// <param name="sourceIndexItem">fileIndexItem to add to</param> /// <param name="fieldName">name e.g. tags or description</param> /// <param name="fieldContent">the content, type must match exact</param> /// <returns>fileIndexItem</returns> public static FileIndexItem Set(FileIndexItem sourceIndexItem, string fieldName, object fieldContent) { if (sourceIndexItem == null) { sourceIndexItem = new FileIndexItem(); } if (!CheckIfPropertyExist(fieldName)) { return(sourceIndexItem); } // Compare input types, fieldType(object=string) fileIndexType(FileIndexItem.field=string) // wrong types are ignored by default PropertyInfo[] propertiesA = new FileIndexItem().GetType().GetProperties( BindingFlags.Public | BindingFlags.Instance); var property = propertiesA.FirstOrDefault(p => string.Equals(p.Name, fieldName, StringComparison.InvariantCultureIgnoreCase)); var fieldType = fieldContent.GetType(); var fileIndexType = property.PropertyType; if (fileIndexType == fieldType) { property.SetValue(sourceIndexItem, fieldContent, null); } return(sourceIndexItem); }
/// <summary> /// Check if property exist in FileIndexItem /// </summary> /// <param name="fieldName">name e.g. Tags</param> /// <returns>bool, true=exist</returns> public static bool CheckIfPropertyExist(string fieldName) { PropertyInfo[] propertiesA = new FileIndexItem().GetType().GetProperties( BindingFlags.Public | BindingFlags.Instance); return(propertiesA.Any(p => string.Equals(p.Name, fieldName, StringComparison.InvariantCultureIgnoreCase))); }
/// <summary> /// Create a XMP file when it not exist /// </summary> /// <param name="updateModel">model</param> /// <param name="inputSubPaths">list of paths</param> /// <returns>void</returns> internal async Task CreateXmpFileIsNotExist(FileIndexItem updateModel, List <string> inputSubPaths) { foreach (var subPath in inputSubPaths) { // only for raw files if (!ExtensionRolesHelper.IsExtensionForceXmp(subPath)) { return; } var withXmp = ExtensionRolesHelper.ReplaceExtensionWithXmp(subPath); if (_iStorage.IsFolderOrFile(withXmp) != FolderOrFileModel.FolderOrFileTypeList.Deleted) { continue; } new ExifCopy(_iStorage, _thumbnailStorage, _exifTool, _readMeta).XmpCreate(withXmp); var comparedNames = FileIndexCompareHelper.Compare(new FileIndexItem(), updateModel); var command = ExifToolCommandLineArgs(updateModel, comparedNames, true); await _exifTool.WriteTagsAsync(withXmp, command); } }
/// <summary> /// Update Async with ExifTool /// </summary> /// <param name="updateModel">data</param> /// <param name="inputSubPaths">paths</param> /// <param name="comparedNames">changed</param> /// <param name="includeSoftware">overwrite Starsky name</param> /// <param name="renameThumbnail">update name</param> /// <returns>Tuple (command, hash)</returns> public async Task <ValueTuple <string, List <string> > > UpdateAsync(FileIndexItem updateModel, List <string> inputSubPaths, List <string> comparedNames, bool includeSoftware, bool renameThumbnail) { // Creation and update .xmp file with all available content await CreateXmpFileIsNotExist(updateModel, inputSubPaths); // Rename .dng files .xmp to update in exifTool var subPathsList = PathsListTagsFromFile(inputSubPaths); var command = ExifToolCommandLineArgs(updateModel, comparedNames, includeSoftware); var fileHashes = new List <string>(); foreach (var path in subPathsList.Where(path => _iStorage.ExistFile(path))) { // to rename to filename of the thumbnail to the new hash if (!renameThumbnail) { await _exifTool.WriteTagsAsync(path, command); continue; } fileHashes.Add((await _exifTool.WriteTagsAndRenameThumbnailAsync(path, command)).Value); } if (!string.IsNullOrEmpty(updateModel.FileHash) && _thumbnailStorage.ExistFile(updateModel.FileHash)) { await _exifTool.WriteTagsThumbnailAsync(updateModel.FileHash, command); } return(new ValueTuple <string, List <string> >(command, fileHashes)); }
public void GetAllFiles_DisposedItem() { var serviceScope = CreateNewScope(); var scope = serviceScope.CreateScope(); var dbContext = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>(); var query = new Query(dbContext, new AppSettings(), serviceScope, new FakeIWebLogger(), _memoryCache); // item sub folder var item = new FileIndexItem("/test_821827/test_0191919.jpg"); dbContext.FileIndex.Add(item); dbContext.SaveChanges(); // Important to dispose! dbContext.Dispose(); item.Tags = "test"; query.UpdateItem(item); var getItem = query.GetAllFiles("/test_821827"); Assert.IsNotNull(getItem); Assert.AreEqual("test", getItem.FirstOrDefault().Tags); query.RemoveItem(getItem.FirstOrDefault()); }
/// <summary> /// Copy the metaData over the output path /// </summary> /// <param name="item">all the meta data</param> /// <param name="outputPath">absolute path on host disk</param> private async Task MetaData(FileIndexItem item, string outputPath) { if (!_subPathStorage.ExistFile(item.FilePath)) { return; } // Write the metadata to the new created file var comparedNames = FileIndexCompareHelper.Compare( new FileIndexItem(), item); // Output has already rotated the image var rotation = nameof(FileIndexItem.Orientation).ToLowerInvariant(); if (comparedNames.Contains(rotation)) { comparedNames.Remove(rotation); } // Write it back await new ExifToolCmdHelper(_exifTool, _hostFileSystemStorage, _thumbnailStorage, null).UpdateAsync(item, new List <string> { outputPath }, comparedNames, false, false); }
/// <summary> /// Add a new item to the database /// </summary> /// <param name="updateStatusContent">the item</param> /// <returns>item with id</returns> public FileIndexItem AddItem(FileIndexItem updateStatusContent) { if (string.IsNullOrWhiteSpace(updateStatusContent.FileName) && updateStatusContent.IsDirectory == false) { throw new MissingFieldException("use filename (exception: the root folder can have no name)"); } try { _context.FileIndex.Add(updateStatusContent); _context.SaveChanges(); } catch (ObjectDisposedException) { var context = new InjectServiceScope(_scopeFactory).Context(); context.FileIndex.Add(updateStatusContent); context.SaveChanges(); } catch (DbUpdateConcurrencyException e) { _logger?.LogInformation("AddItem catch-ed DbUpdateConcurrencyException (ignored)", e); } AddCacheItem(updateStatusContent); return(updateStatusContent); }
public FileIndexItem GetDataFromString(string xmpDataAsString, FileIndexItem databaseItem = null) { // Does not require appSettings if (databaseItem == null) { databaseItem = new FileIndexItem(); } try { var xmp = XmpMetaFactory.ParseFromString(xmpDataAsString); // ContentNameSpace is for example : Namespace=http://... databaseItem = GetDataContentNameSpaceTypes(xmp, databaseItem); // NullNameSpace is for example : string.Empty databaseItem = GetDataNullNameSpaceTypes(xmp, databaseItem); } catch (XmpException e) { Console.WriteLine($"XmpException {databaseItem.FilePath} >>\n{e}\n <<XmpException"); databaseItem.Tags = "XmpException"; databaseItem.ColorClass = ColorClassParser.Color.None; } return(databaseItem); }
/// <summary> /// Compare Rotation and All other tags /// </summary> /// <param name="changedFileIndexItemName">Per file stored string{FilePath}, /// List*string*{FileIndexItem.name (e.g. Tags) that are changed}</param> /// <param name="collectionsFileIndexItem">DetailView input, only to display changes</param> /// <param name="statusModel">object that include the changes</param> /// <param name="append">true= for tags to add</param> /// <param name="rotateClock">rotation value 1 left, -1 right, 0 nothing</param> public void CompareAllLabelsAndRotation(Dictionary <string, List <string> > changedFileIndexItemName, FileIndexItem collectionsFileIndexItem, FileIndexItem statusModel, bool append, int rotateClock) { if (changedFileIndexItemName == null) { throw new MissingFieldException(nameof(changedFileIndexItemName)); } // compare and add changes to collectionsDetailView var comparedNamesList = FileIndexCompareHelper .Compare(collectionsFileIndexItem, statusModel, append); // if requested, add changes to rotation collectionsFileIndexItem = RotationCompare(rotateClock, collectionsFileIndexItem, comparedNamesList); if (!changedFileIndexItemName.ContainsKey(collectionsFileIndexItem.FilePath)) { // add to list changedFileIndexItemName.Add(collectionsFileIndexItem.FilePath, comparedNamesList); return; } // overwrite list if already exist changedFileIndexItemName[collectionsFileIndexItem.FilePath] = comparedNamesList; }
public void ExifToolCmdHelper_Update_UpdateLocationAltitudeCommandTest() { var updateModel = new FileIndexItem { LocationAltitude = -41, }; var comparedNames = new List <string> { nameof(FileIndexItem.LocationAltitude).ToLowerInvariant(), }; var folderPaths = new List <string> { "/" }; var inputSubPaths = new List <string> { "/test.jpg" }; var storage = new FakeIStorage(folderPaths, inputSubPaths, null); var fakeExifTool = new FakeExifTool(storage, _appSettings); var helperResult = new ExifToolCmdHelper(fakeExifTool, storage, storage, new FakeReadMeta()).Update(updateModel, inputSubPaths, comparedNames); Assert.AreEqual(true, helperResult.Contains("-GPSAltitude=\"-41")); Assert.AreEqual(true, helperResult.Contains("gpsaltituderef#=\"1")); }
public async Task Update_Write_GPX() { var changedFileIndexItemName = new Dictionary <string, List <string> > { { "/test.gpx", new List <string> { "Tags" } } }; await _iStorageFake.WriteStreamAsync(new MemoryStream(CreateAnGpx.Bytes), "/test.gpx"); var updateItem = new FileIndexItem("/test.gpx") { Tags = "test", Status = FileIndexItem.ExifStatus.Ok }; var query = new FakeIQuery(); await query.AddItemAsync(updateItem); var fileIndexResultsList = new List <FileIndexItem> { updateItem }; var readMeta = new FakeReadMetaSubPathStorage(); var service = new MetaUpdateService(query, _exifTool, new FakeSelectorStorage(_iStorageFake), new FakeMetaPreflight(), new FakeIWebLogger(), readMeta); await service.UpdateAsync(changedFileIndexItemName, fileIndexResultsList, updateItem, false, false, 0); Assert.IsTrue(_iStorageFake.ExistFile("/.starsky.test.gpx.json")); }
public async Task GetAllObjectsAsync_DisposedItem() { var serviceScope = CreateNewScope(); var scope = serviceScope.CreateScope(); var dbContext = scope.ServiceProvider.GetRequiredService <ApplicationDbContext>(); var query = new Query(dbContext, new AppSettings(), serviceScope, new FakeIWebLogger(), _memoryCache); // item sub folder var item = new FileIndexItem("/test_3457834583/test_0191919.jpg"); await dbContext.FileIndex.AddAsync(item); await dbContext.SaveChangesAsync(); // Important to dispose! await dbContext.DisposeAsync(); item.Tags = "test"; await query.UpdateItemAsync(item); var getItem = await query.GetAllObjectsAsync("/test_3457834583"); Assert.IsNotNull(getItem); Assert.AreEqual("test", getItem.FirstOrDefault().Tags); await query.RemoveItemAsync(getItem.FirstOrDefault()); }
private void InsertSearchData() { if (!string.IsNullOrEmpty( _query.GetSubPathByHash("09876543456789"))) { return; } _insertSearchDatahiJpgInput = _query.AddItem(new FileIndexItem { FileName = "hi.jpg", ParentDirectory = "/basic", FileHash = "09876543456789", ColorClass = ColorClassParser.Color.Winner, // 1 Tags = "", Title = "", IsDirectory = false }); _insertSearchDatahi2JpgInput = _query.AddItem(new FileIndexItem { FileName = "hi2.jpg", Tags = "!delete!", ParentDirectory = "/basic", IsDirectory = false }); _insertSearchDatahi2SubfolderJpgInput = _query.AddItem(new FileIndexItem { FileName = "hi2.jpg", ParentDirectory = "/basic/subfolder", FileHash = "234567876543", IsDirectory = false }); }
public async Task <FileIndexItem.ExifStatus> ManualSync(string subPath, string operationId = null) { var fileIndexItem = await _query.GetObjectByFilePathAsync(subPath); // on a new database -> if (subPath == "/" && fileIndexItem == null) { fileIndexItem = new FileIndexItem(); } if (fileIndexItem == null) { _logger.LogInformation($"[ManualSync] NotFoundNotInIndex skip for: {subPath}"); return(FileIndexItem.ExifStatus.NotFoundNotInIndex); } if (_cache.TryGetValue(ManualSyncCacheName + subPath, out _)) { // also used in removeCache _query.RemoveCacheParentItem(subPath); _logger.LogInformation($"[ManualSync] Cache hit skip for: {subPath}"); return(FileIndexItem.ExifStatus.OperationNotSupported); } _cache.Set(ManualSyncCacheName + subPath, true, new TimeSpan(0, 1, 0)); _bgTaskQueue.QueueBackgroundWorkItem(async _ => { await BackgroundTask(fileIndexItem.FilePath, operationId); }); return(FileIndexItem.ExifStatus.Ok); }
/// <summary> /// Cache Only! Private api within Query to remove cached items /// This Does remove a SINGLE item from the cache NOT from the database /// </summary> /// <param name="updateStatusContent"></param> public void RemoveCacheItem(FileIndexItem updateStatusContent) { // Add protection for disabled caching if (_cache == null || _appSettings?.AddMemoryCache == false) { return; } var queryCacheName = CachingDbName(nameof(FileIndexItem), updateStatusContent.ParentDirectory); if (!_cache.TryGetValue(queryCacheName, out var objectFileFolders)) { return; } var displayFileFolders = (List <FileIndexItem>)objectFileFolders; // Order by filename displayFileFolders = displayFileFolders .Where(p => p.FilePath != updateStatusContent.FilePath) .OrderBy(p => p.FileName).ToList(); _cache.Remove(queryCacheName); // generate list again _cache.Set(queryCacheName, displayFileFolders, new TimeSpan(1, 0, 0)); }
/// <summary> /// When the file is not supported or does not exist return status /// </summary> /// <param name="subPath">relative path</param> /// <returns>item with status</returns> private FileIndexItem CheckForStatusNotOk(string subPath) { var statusItem = new FileIndexItem(subPath) { Status = FileIndexItem.ExifStatus.Ok }; // File extension is not supported if (!ExtensionRolesHelper.IsExtensionSyncSupported(subPath)) { statusItem.Status = FileIndexItem.ExifStatus.OperationNotSupported; return(statusItem); } // File check if jpg #not corrupt var imageFormat = ExtensionRolesHelper.GetImageFormat(_subPathStorage.ReadStream(subPath, 160)); if (imageFormat == ExtensionRolesHelper.ImageFormat.notfound) { statusItem.Status = FileIndexItem.ExifStatus.NotFoundSourceMissing; return(statusItem); } // ReSharper disable once InvertIf if (!ExtensionRolesHelper.ExtensionSyncSupportedList.Contains(imageFormat.ToString())) { statusItem.Status = FileIndexItem.ExifStatus.OperationNotSupported; return(statusItem); } return(statusItem); }
public void UpdateService_Update_defaultTest() { var item0 = _query.AddItem(new FileIndexItem { Status = FileIndexItem.ExifStatus.Ok, Tags = "thisKeywordHasChanged", FileName = "test_default.jpg", Description = "noChanges", ParentDirectory = "/" }); var changedFileIndexItemName = new Dictionary <string, List <string> > { { "/test_default.jpg", new List <string> { nameof(FileIndexItem.Tags) } }, }; var fileIndexResultsList = new List <FileIndexItem> { new FileIndexItem { Status = FileIndexItem.ExifStatus.Ok, Tags = "initial tags (from database)", FileName = "test_default.jpg", ParentDirectory = "/", Description = "keep", } }; var updateItem = new FileIndexItem { Status = FileIndexItem.ExifStatus.Ok, Tags = "only used when Caching is disabled", FileName = "test_default.jpg", Description = "noChanges", ParentDirectory = "/" }; var readMeta = new ReadMetaSubPathStorage( new FakeSelectorStorage(_iStorageFake), _appSettings, _memoryCache); var service = new MetaUpdateService(_query, _exifTool, new FakeSelectorStorage(_iStorageFake), new FakeMetaPreflight(), new FakeIWebLogger(), readMeta); service.UpdateAsync(changedFileIndexItemName, fileIndexResultsList, updateItem, false, false, 0); // check for item (Referenced) Assert.AreEqual("thisKeywordHasChanged", item0.Tags); // db Assert.AreEqual("thisKeywordHasChanged", _query.SingleItem("/test_default.jpg").FileIndexItem.Tags); Assert.AreEqual("noChanges", _query.SingleItem("/test_default.jpg").FileIndexItem.Description); _query.RemoveItem(item0); }
public async Task ExportControllerTest__ThumbFalse_CreateListToExport() { var selectorStorage = _serviceProvider.GetRequiredService <ISelectorStorage>(); var hostFileSystemStorage = selectorStorage.Get(SelectorStorage.StorageServices .HostFilesystem); var export = new ExportService(_query, _appSettings, selectorStorage, new FakeIWebLogger()); var createAnImageNoExif = new CreateAnImageNoExif(); var item = new FileIndexItem { FileName = createAnImageNoExif.FileName, ParentDirectory = "/", FileHash = createAnImageNoExif.FileName.Replace(".jpg", "-test"), Status = FileIndexItem.ExifStatus.Ok }; await _query.AddItemAsync(item); var fileIndexResultsList = new List <FileIndexItem> { item }; var filePaths = await export.CreateListToExport(fileIndexResultsList, false); Assert.AreEqual(true, filePaths.FirstOrDefault().Contains(item.FileName)); Assert.AreEqual(FolderOrFileModel.FolderOrFileTypeList.File, hostFileSystemStorage.IsFolderOrFile(filePaths.FirstOrDefault())); hostFileSystemStorage.FileDelete(createAnImageNoExif.FullFilePathWithDate); }
/// <summary> /// Add child item to parent cache /// Private api within Query to add cached items /// Assumes that the parent directory already exist in the cache /// @see: AddCacheParentItem to add parent item /// </summary> /// <param name="updateStatusContent">the content to add</param> internal void AddCacheItem(FileIndexItem updateStatusContent) { // If cache is turned of if (_cache == null || _appSettings?.AddMemoryCache == false) { return; } var queryCacheName = CachingDbName(nameof(FileIndexItem), updateStatusContent.ParentDirectory); if (!_cache.TryGetValue(queryCacheName, out var objectFileFolders)) { return; } var displayFileFolders = (List <FileIndexItem>)objectFileFolders; displayFileFolders.Add(updateStatusContent); // Order by filename displayFileFolders = displayFileFolders.OrderBy(p => p.FileName).ToList(); _cache.Remove(queryCacheName); _cache.Set(queryCacheName, displayFileFolders, new TimeSpan(1, 0, 0)); }
private static RelativeObjects GetNextPrevInSubFolder( FileIndexItem currentFileIndexItem, List <FileIndexItem> fileIndexItemsList, SortType sortType) { // Check if this is item is not !deleted! yet if (currentFileIndexItem == null) { return(new RelativeObjects()); } fileIndexItemsList = SortHelper.Helper(fileIndexItemsList, sortType).ToList(); var currentIndex = fileIndexItemsList.FindIndex(p => p.FilePath == currentFileIndexItem.FilePath); var relativeObject = new RelativeObjects(); if (currentIndex != fileIndexItemsList.Count - 1) { relativeObject.NextFilePath = fileIndexItemsList[currentIndex + 1].FilePath; relativeObject.NextHash = fileIndexItemsList[currentIndex + 1].FileHash; } if (currentIndex >= 1) { relativeObject.PrevFilePath = fileIndexItemsList[currentIndex - 1].FilePath; relativeObject.PrevHash = fileIndexItemsList[currentIndex - 1].FileHash; } return(relativeObject); }
public async Task UpdateAsync_ShouldUpdate_IncludeFileHash() { var updateModel = new FileIndexItem { Tags = "tags", Description = "Description", FileHash = "_hash_test" // < - - - - include here }; var comparedNames = new List <string> { nameof(FileIndexItem.Tags).ToLowerInvariant(), nameof(FileIndexItem.Description).ToLowerInvariant(), }; var storage = new FakeIStorage(new List <string> { "/" }, new List <string> { "/test.jpg" }, new List <byte[]>()); var fakeExifTool = new FakeExifTool(storage, _appSettings); var helperResult = (await new ExifToolCmdHelper(fakeExifTool, storage, storage, new FakeReadMeta()).UpdateAsync(updateModel, comparedNames, true)); Assert.IsTrue(helperResult.Item1.Contains("tags")); Assert.IsTrue(helperResult.Item1.Contains("Description")); }
public void FileIndexItemTest_SetMakeModel_WrongPipeLength() { var item = new FileIndexItem(); item.SetMakeModel("Apple", 95); // this index (95) never exist }
public async Task Inflate_Test() { // Minimal 10 items var testContent = new FileIndexItem { Tags = "test, testung" }; _dbContext.FileIndex.AddRange(new List <FileIndexItem> { testContent, testContent, testContent, testContent, testContent, testContent, testContent, testContent, testContent, testContent, testContent, testContent, testContent }); await _dbContext.SaveChangesAsync(); await new SearchSuggestionsInflateHostedService(_scopeFactory, _memoryCache, new FakeIWebLogger(), new AppSettings()).StartAsync(new CancellationToken()); var allSuggestions = await new SearchSuggestionsService(_dbContext, _memoryCache, new FakeIWebLogger(), new AppSettings()) .GetAllSuggestions(); var result = allSuggestions.FirstOrDefault(p => p.Key == "test"); Assert.IsNotNull(result); }
public void FileIndexItemTest_GetColorClassListString() { var input = "string"; var output = FileIndexItem.GetColorClassList(input); Assert.AreEqual(0, output.Count); // <= 0 }
/// <summary> /// Filter for WideSearch /// Always after wideSearch /// </summary> /// <param name="model"></param> /// <returns></returns> public SearchViewModel NarrowSearch(SearchViewModel model) { if (model.FileIndexItems == null) { model = new SearchViewModel(); } for (var i = 0; i < model.SearchIn.Count; i++) { var propertyStringName = FileIndexItem.FileIndexPropList().FirstOrDefault(p => String.Equals(p, model.SearchIn[i], StringComparison.InvariantCultureIgnoreCase)); if (string.IsNullOrEmpty(propertyStringName)) { continue; } PropertyInfo property = new FileIndexItem().GetType().GetProperty(propertyStringName); // skip OR searches if (!model.SearchOperatorContinue(i, model.SearchIn.Count)) { continue; } PropertySearch(model, property, model.SearchFor[i], model.SearchForOptions[i]); } return(model); }
//private Synchronize _sync; private void CreateFoldersAndFilesInDatabase() { _folderExist = _query.AddItem(new FileIndexItem { FileName = "exist", ParentDirectory = "/", AddToDatabase = DateTime.UtcNow, FileHash = "34567898765434567487984785487", IsDirectory = true }); _fileInExist = _query.AddItem(new FileIndexItem { FileName = "file.jpg", ParentDirectory = "/exist", IsDirectory = false }); _folder1Exist = _query.AddItem(new FileIndexItem { FileName = "folder1", ParentDirectory = "/", IsDirectory = true, FileHash = "3497867df894587", }); _parentFolder = _query.AddItem(new FileIndexItem { FileName = "/", ParentDirectory = "/", IsDirectory = true, }); }
private FileIndexItem ReadExifAndXmpFromFileDirect(string subPath) { if (_iStorage.ExistFile(subPath) && ExtensionRolesHelper.IsExtensionForceGpx(subPath)) { return(ReadMetaGpx.ReadGpxFromFileReturnAfterFirstField(_iStorage.ReadStream(subPath), subPath)); } var fileIndexItemWithPath = new FileIndexItem(subPath); // Read first the sidecar file var xmpFileIndexItem = _readXmp.XmpGetSidecarFile(fileIndexItemWithPath.Clone()); if (xmpFileIndexItem.IsoSpeed == 0 || string.IsNullOrEmpty(xmpFileIndexItem.Make) || xmpFileIndexItem.DateTime.Year == 0 || xmpFileIndexItem.ImageHeight == 0) { // so the sidecar file is not used var fileExifItemFile = _readExif.ReadExifFromFile(subPath, fileIndexItemWithPath); // overwrite content with incomplete sidecar file (this file can contain tags) FileIndexCompareHelper.Compare(fileExifItemFile, xmpFileIndexItem); return(fileExifItemFile); } return(xmpFileIndexItem); }
} // proc CloseZipStream private void ZipFileItem(CmdletNotify notify, CmdletProgress bar, Stream src, ZipOutputStream zip, FileIndexItem item) { var entry = new ZipEntry(ZipEntry.CleanName(item.RelativePath)); entry.DateTime = item.LastWriteTimeUtc; entry.Size = src.Length; entry.Comment = item.GetComment(); entry.CompressionMethod = ZipFile(item.RelativePath) ? CompressionMethod.Deflated : CompressionMethod.Stored; zip.PutNextEntry(entry); Stuff.CopyRawBytes(bar, item.RelativePath, src.Length, src, zip); zip.CloseEntry(); zip.Flush(); } // proc ZipFileItem
} // proc ZipFileItem private void GZipFileItem(CmdletNotify notify, CmdletProgress bar, Stream src, DirectoryInfo targetPath, FileIndexItem item) { using (var dst = new FileWrite(notify, new FileInfo(Path.Combine(targetPath.FullName, item.ArchiveName)), false, CompressMode.Auto)) { Stuff.CopyRawBytes(bar, item.RelativePath, src.Length, src, dst.Stream); dst.Commit(); } } // proc GZipFileItem