diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index a5f2d4ec..c8cf7d76 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -40,9 +40,9 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S | `Render` | Render plan (timing modes), preparation pass, geometry, `RenderPipeline`, self-test suite | | `Export` | Preset resolution, encoder selection with fallbacks, output naming | | `Video` (+ `Mp4`, `Avi`, `Bitstream`, `Yuv`, `Managed`) | `IVideoEncoderProvider`, MP4 muxer and inspector, AVI-MJPEG, NV12/P010, managed encoders (MJPEG-AVI, GIF, APNG, image sequences) | -| `Archiving` | Archive layout and paths, sidecars (`sequence.json`, `project.json`), scanner, index snapshot, leases, thumbnail packs, verify, adopt, rename plans | -| `Import` | Card scan, session detection, import plan, hash-verified copy, card eraser (re-hash before delete) | -| `Naming` | Folder/file templates and tokens | +| `Archiving` | Archive layout and paths, sidecars (`sequence.json`, `project.json`), scanner, index snapshot, leases, thumbnail packs, verify, adopt, rename plans (`RenamePlanner`: folder, title and file templates, `RenameTemplates`, the plan's fingerprint, which pins every file rename by its digest and not the frames version; `FileRenames`: a sequence's new file names; `FileRenameJournal`: two-phase renames through temporary names, `.chronos/rename-files.json`, a recovery safe to run again from wherever it stopped, a new name taken meanwhile sending that photo and its companions back together to their old names or a free `_2`, those that took their new names already with them; `FrameCompanions`: the XMP files that follow a photo, one rule for the trash and Reorganize, matched whatever their case and each folder listed once by `FrameCompanions.Index`) | +| `Import` | Card scan, session detection, import plan (photos named through `FrameNaming` with the camera and lens of their session's first photo), hash-verified copy, card eraser (re-hash before delete) | +| `Naming` | Folder/file templates and tokens (folder levels scans skip escaped with `_`; `ExpandText` for titles; `ExpandFile` shortens a long file name before its `.{ext}`); `FrameNaming` (the naming context and unique file name of a frame, shared by import, upload and Reorganize: the sequence's camera and lens, the first frame for folders; `UniqueNames`: `_2`, `_3`… in linear time); `TemplateRules` (what every place a template is typed or sent refuses, the archive engine's new or changed templates included: a folder scans skip, a lost extension, names that repeat) | | `Model` | Domain entities and enums (§5) shared by Data, Server and clients | | `Packaging` | TPK1 installer payload writer/reader, staged install transaction | | `Diagnostics` | `Log` (never throws: a line its sink cannot write is dropped), `FileLogSink` with `LogFileOptions` (level, daily or hourly files, numbered parts past a size, pruning by age and by the total size, never the file being written), synthetic sequences, `SecretScrubber`, `DiagnosticsArchive` (scrubbed diagnostics zip) | @@ -54,11 +54,11 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S |---|---| | `Sqlite`, `Postgres` | SQLite P/Invoke binding (winsqlite3 / libsqlite3), in-house PostgreSQL wire protocol v3 client with pool and LISTEN | | `Migrations/{sqlite,postgres}/NNNN_name.sql` | Embedded, applied in one transaction at open (`MigrationRunner`) | -| `Repositories` | `ChronosDatabase` facade: archives, sequences, frames, tags, renders, jobs, cards, users, tokens, uploads, render nodes, settings, audit, schedules (`ScheduleRepository`: system rows seeded without overwriting edits and never deleted, the compare-and-set claim of a run), tombstones of removed photos (`FrameRemovalRepository`, `frame_removals`, written from the sidecar's `removed` list); `DatabaseBackups` (`VACUUM INTO` copies of an SQLite index into `backups` next to it, every copy keeping as many as the backup schedules keep (`KeptAsync`), the newest copy that seeds the `index-backup` schedule (`Newest`, `SystemSchedule.LastDone`), restore staged for the next start and carried out before the index opens, so it also recovers one that no longer opens) | +| `Repositories` | `ChronosDatabase` facade: archives, sequences, frames, tags, renders, jobs, cards, users, tokens, uploads, render nodes, settings, audit, schedules (`ScheduleRepository`: system rows seeded without overwriting edits and never deleted, the compare-and-set claim of a run), tombstones of removed photos (`FrameRemovalRepository`, `frame_removals`, written from the sidecar's `removed` list), `SequenceRepository.GetStampAsync` (a digest of what a Reorganize plans from in the index), `RenderRepository.RebaseFolderAsync` (the export paths that follow a moved folder); `DatabaseBackups` (`VACUUM INTO` copies of an SQLite index into `backups` next to it, every copy keeping as many as the backup schedules keep (`KeptAsync`), the newest copy that seeds the `index-backup` schedule (`Newest`, `SystemSchedule.LastDone`), restore staged for the next start and carried out before the index opens, so it also recovers one that no longer opens) | | `Jobs` | `JobEngine` (one job at a time; reviews the priority queue and makes a lower running job yield, requeued with its checkpoint; no history purge, the housekeeping schedule's clean-up does it), `JobPriorityQueue` (a level per job kind, the claim order, settings round trip), `IJobHandler`, `IJobHandlerProvider`, `JobContext` (progress, checkpoints, follow-up jobs that never interrupt their parent), `JobThroughput`/`JobEta` (rate and bounded time left) | | `Scheduling` | `Scheduler` (one per host: seeds the host's system schedules, claims due runs by compare-and-set, catch-up, clock changes, create/edit/reset/delete/run now as API v1 DTOs), `ScheduleRecurrence` (the in-house `every:`/`daily:`/`weekly:`/`monthly:` form, wall-clock times across DST), `ScheduleActions` (action names, parameters, availability, the archive jobs a run queues), `IScheduleHost` and `SystemSchedule` (what the server and the desktop supply), `ScheduleOutcome`, `ScheduleMapping` (model ↔ DTO) | | `Housekeeping` | `BackupJobHandler`, `CleanupJobHandler`, `ICleanupStep` with the shared steps (`CleanupSteps`: job history, audit log, trash report that never deletes); hosts add their own steps through `ArchiveServiceOptions.CleanupSteps` | -| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index), `ArchiveIndexer` (scan, rebuild), `ArchiveIngest` (uploads and imports), `ImportService`, `ArchiveVerifier`, `ArchiveImages` (thumbnail and proxy passes, several photos at once through `OrderedWork`, which hands results back in frame order), `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance`, `MassRenamer`, `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails; lists sequence and photo entries; `SequenceTrash.Empty`: the emptying's dry run, fingerprint and erase, each entry checked against its fingerprint again under its lease), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed), job handlers | +| `Archiving` | `ArchiveService` (create/adopt/open, archive settings written to `archive.json` then the index, `ArchiveSettings.CheckTemplates` and `TemplateRuleException` holding a template given anew to the template rules; `UnderLeaseAsync`: a write under a sequence's lease with its row read under it), `ArchiveIndexer` (scan, rebuild; a sequence found in another folder takes its exports' paths along), `ArchiveIngest` (uploads and imports, named through `FrameNaming`), `ImportService`, `ArchiveVerifier`, `ArchiveImages` (thumbnail and proxy passes, several photos at once through `OrderedWork`, which hands results back in frame order), `FrameTiers` (decode tier, `PreviewOnly`/`Undecodable` flags and preview size of frames, written to sidecar and index by the light analysis, deep analysis, renders and image passes), `GprCompanions` (the JPEG of each GoPro GPR, found in the index when an import kept it in another sequence), `ArchiveMaintenance`, `MassRenamer` (mass rename and Reorganize: the dry run reads each sidecar for a file template; each step checked under its leases before anything of it moves (where its sequences are, what is inside and at its new folder, a sidecar of a newer format, the title it was planned from when it changes it or names the folder or files after it), then the folder, with the sequences of the plan an earlier step left as they were inside it (taken along, their title and file names kept), every index row (the frame paths and render paths of the exports inside it, a file or an image-sequence folder, its own unless the export is still at the old place and another sequence's when it moved with it, follow it in one transaction; a sidecar that cannot be read or written then still has its row follow, and fails the step), then the files under the plan's journal in `journal/` (a sequence whose photos changed since, such as one still receiving them, or whose files are found changed or in use or have their new names taken keeps its file names, the renames being pinned by digest, and the step and the plan go on); the journal keeps the tally of the whole plan, and a plan its job held (paused, cancelled or failed) is left to that job, only its half-done file renames completed at an archive open, which completes any other plan an interruption left and tells each sequence changed; the file renames of a step: sidecar, a sequence whose sidecar cannot be read staying as it is with every folder around it, index (`FrameRepository.RenameFilesAsync`) and the sequence's journal), `SequenceFolders` (`Holds`: the folder the index has for a sequence is there and its sidecar names no other sequence; every writer into a sequence's folder asks it), `SequenceTrash` (delete into the archive's hidden trash with a dry run, restore; the folder moves back when the index step fails; lists sequence and photo entries; `SequenceTrash.Empty`: the emptying's dry run, fingerprint and erase, each entry checked against its fingerprint again under its lease), `FrameTrash` (photos of a sequence into `trash/photos` with a dry run, a journal that undoes an interrupted deletion whose entry stays unlisted until its sidecar is written, tombstones (a photo never hashed is hashed as it goes; one whose original is missing goes without a file or tombstone; a frame that stays and may be a twin is hashed, its hash kept), positions parked and placed back, proxies and thumbnails moved to follow their frames; `FrameTrash.Restore`: restore re-hashes each file and says why each kept photo stayed (`KeptReason`), under a journal of its own into the sequence that another writer settles only under the entry's lease, into a new sequence through the ingest when theirs is gone, each original staged inside its own entry and the record rewritten after each photo filed), job handlers | | `Processing` | `ProcessingService`, `SequenceAnalyser`, `DeepReports` (a saved deep report while it still describes the frames), `SequenceRender`, `ProjectStore`, `ProjectBundles` (a `.chronos` file for a sequence, and the sequence a file names), `RenderNodeClient`, job handlers | | `Sync` | `SyncService` (sync table of one server: compare, link by content, settle conflicts, enqueue transfers), `SyncRules` (status, settings merge and differences, no I/O), `SyncTombstones` (photos either side removed are not offered back, a replaced photo counts as its replacement), `SyncPositions` (the settings' frame positions translated by photo to the frames of the copy they go to), `SyncLinkStore` (`sync_links`, `sync_state`), `SyncTransfers` and `SyncJobHandler` (resumable, hash-verified uploads and downloads as jobs; downloads commit through the archive ingest), `SyncAgent` (background comparison, server events, backoff, offline proxies), `ProxyCache` and `RemoteSequence` (server sequences opened with proxies), `ISyncRemote` (the server calls; `ChronosSyncRemote` over `ChronosClient`) | @@ -71,10 +71,10 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S | `Library` | Filter, facets, pager, timeline, saved views, quick and mass actions, remote cards and thumbnails, thumbnail cache, list export | | `Editor` | `EditorSession` (project, undo/redo, saving, merges), `ISequenceSource` (`LocalSequenceSource`, `RemoteSequenceSource`), the steps of the Edit path (`EditPath`: their order, each step's state, the step of each finding, the memory of the step shown; tabs Analysis, Frames, Exposure, Motion, Camera, Time, Stack, Export), `PreviewRenderer`, `ExportPlanner`, `ExportSync`, `SavedCopies`, `SequenceJobs`, `ProjectFiles` (save and open `.chronos` project files) | | `Import` | `CardPool` (inserted cards, remembered cards, folders), camera profiles, plans and choices, destinations (archive, folder, server through `ServerImportSink`), card actions (verified delete, format, eject) | -| `Archive` | `CurrentArchive`, `ArchiveTree`, figures for the charts, maintenance reports, mass rename and move, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`, `TrashEmptyPlans`: Empty… behind a dry run and a typed confirmation), `ArchiveFailures` | +| `Archive` | `CurrentArchive`, `ArchiveTree`, figures for the charts, maintenance reports, Reorganize (`ReorganizeDialogViewModel`: folder, file and title templates each with its switch, the dry run, Apply queues the `move` job of that plan; `ReorganizePlans`: each template's check, the plan as rows and a summary; `ReorganizeOffer`: per archive, the templates Settings › Archive's toast offers, joined while that archive's toast is up), retag, delete and trash dialogs (`SequenceDeletion`, `DeletePlans`, `TrashEmptyPlans`: Empty… behind a dry run and a typed confirmation), `ArchiveFailures` | | `Server` | `ServerSession`, `ConnectFlow` (trust on first use), `SyncHost` (sync engine, agent, metered hold, editor connections, Export Sync), sync table, `RemoteSequenceApi` | | `Jobs`, `Settings`, `About` | Job list and buffering, `JobNotices` (which job endings raise a toast; `JobEndings` lets a batch speak once); the schedules of Jobs › Scheduled (`DesktopScheduleHost`: the desktop's `IScheduleHost` and its system schedules `archive-scan`, `index-backup`, `housekeeping`; `CacheTrimStep`, the host's clean-up step; `SchedulesViewModel`, `ScheduleRowViewModel`, `ScheduleEditorViewModel` and `ScheduleDialogs.xaml`, the in-window editor; `ScheduleText`); settings rows (`LogSettingsRows`: Advanced's log rows), encoder and format inventories, `ProcessingTuning` (Settings › Rendering and Analysis applied to each job: parallelism, memory budget, quality), `InterfacePriority`, language catalog, naming preview; `AboutViewModel` (owned by the shell, not a section: Settings › About, the update notice of Settings › Updates and the update check on start), update check and download | -| `Infrastructure` | `AppServices` (composition root), `AppSettings`, `AppLogging` (Settings › Advanced › Logs applied to the log files from their first line, a launch that only hands over included, and at every save), `AppEnvironment` (installed or portable), `AppClock` (today's date, frozen by `--capture`), `StartWithWindows` (this copy's sign-in entry), `UiLanguage`, `LiveRegion`, `RenderNodeHost`, `DiagnosticsBundle`, `ShellActions` (BRIEF §8.6), `SingleInstance` (one Chronos per data folder; a later launch hands its file over a named pipe, or waits for a closing one to exit and starts in its place), device monitor | +| `Infrastructure` | `AppServices` (composition root; `SequenceReorganized`, raised after each Reorganize step, reloads an editor open on that sequence), `AppSettings`, `AppLogging` (Settings › Advanced › Logs applied to the log files from their first line, a launch that only hands over included, and at every save), `AppEnvironment` (installed or portable), `AppClock` (today's date, frozen by `--capture`), `StartWithWindows` (this copy's sign-in entry), `UiLanguage`, `LiveRegion`, `RenderNodeHost`, `DiagnosticsBundle`, `ShellActions` (BRIEF §8.6), `SingleInstance` (one Chronos per data folder; a later launch hands its file over a named pipe, or waits for a closing one to exit and starts in its place), device monitor | | `DesignTime` | `SampleData`: the archive, jobs and server the screenshots and smoke tests run on, dated from the fixed `SampleData.Now` | ### 2.4 Chronos.Ui and Chronos.Server @@ -82,13 +82,13 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S | Folder | Content | |---|---| | `Ui/Themes`, `Ui/Theming` | DESIGN tokens (light, dark), typography, control styles, `ThemeManager` | -| `Ui/Controls` | `ChronosWindow` (chrome, language direction), `NavRail`, `JobBar`, `ToastHost`, `Field` (placeholder, icon, error), `Chip`, `AutoSlider`, `StatusGlyph`, `EmptyState`, `Icon`, `Bidi` (right-to-left rules), `Motion` (animations off for screenshots) | +| `Ui/Controls` | `ChronosWindow` (chrome, language direction), `NavRail`, `JobBar`, `ToastHost` (`Toast.Closed` once a toast leaves the screen), `Field` (placeholder, icon, error), `Chip`, `AutoSlider`, `StatusGlyph`, `EmptyState`, `Icon`, `Bidi` (right-to-left rules), `Motion` (animations off for screenshots) | | `Ui/Interop` | DWM calls of the window chrome; `TrayIcon` (`Shell_NotifyIconW`: the Uploader's tray, the client's Windows notifications) | | `Ui/Visuals` | `DrawingElement` (hover readout, item keyboard and activation) and its charts (`BarChart`, `SeriesChart`, `StackedBar`, `HeatmapStrip`, `TimelineBands`), `Filmstrip`, `PreviewViewport`, `CurveEditor`, `SequenceCard`, `VirtualizingWrapPanel`, `SegmentedControl`, `SplitButton` | -| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty), API errors, the WebSocket `EventHub` | +| `Server/Api`, `Server/Events` | Endpoint groups (`XxxEndpoints.Map`; `ScheduleEndpoints`: `/api/v1/schedules`; `LibraryEndpoints`: the Library filters' facets, sequence thumbnail, photo delete, bulk delete/retag/jobs; `TrashEndpoints`: list, restore, empty; `ArchiveEndpoints`: settings, statistics, scan jobs, Reorganize's dry run and `move` job, with `ReorganizePlanCache`: a dry run's plan, made apart from its request, kept a few minutes while what it reads from the index stays, for the same dry run and its confirmation), API errors, the WebSocket `EventHub` | | `Server/Security` | Accounts, password hashing, tokens, session cookies, login guard, access rules, audit log | -| `Server/Storage`, `Server/Jobs` | Archive and processing modules, uploads (`UploadMaintenance`: recovery at start, and the sweep that is the `uploads` clean-up step), render store; `JobEngineHost`, `SchedulerHost` (the `Scheduler` on the engine, started after it; archive.json read every 10 minutes whatever the scan schedule does; every schedule change and run published as a `scheduleChanged` event) and `ServerScheduleHost` (time zone, archive refreshed from archive.json, system schedules), render node service, monitor and availability | -| `Server/Hosting`, `Server/Admin/web` | `ServerHost`, `ServerLogging` (console and file levels the logging filters read at every line, the file sink's limits, the engine's level; applied again when Settings › Logs is saved), certificates, discovery beacon, embedded static files (`EmbeddedStaticFiles`: `no-cache` and a content ETag, so an upgrade never mixes old and new modules), Windows service (start and stop failures in the Application event log); the admin panel (ES modules, one per page; `schedules.js` is the Jobs page's Scheduled tab; the Library's views in `pages/library/`: `sequence.js` a sequence and its photo viewer, `trash.js` the archive's trash, `shared.js` cards, selection, grid keyboard and the retry of thumbnails a finished job may have built; `upload.js` the upload dialog the Library opens on demand, hashing in the module worker `hash-worker.js` with the in-house incremental SHA-256 of `sha256.js`, self-tested before its first use, and sending the capture time `capture-time.js` reads: the Exif DateTimeOriginal of a JPEG or TIFF-based file, else the file's time) | +| `Server/Storage`, `Server/Jobs` | Archive and processing modules (the archive module's `SequenceChanged` publishes `sequenceChanged` `reorganized`), uploads (`UploadMaintenance`: recovery at start, and the sweep that is the `uploads` clean-up step; `UploadService.ReceiveAgainAsync`: a verified upload whose filing was refused for now goes back to receiving, 503), render store (files a render under the sequence's lease, where the index has the folder then; `FolderMovedException`, 503 `folder_moved`, when the sequence is not in it); `JobEngineHost`, `SchedulerHost` (the `Scheduler` on the engine, started after it; archive.json read every 10 minutes whatever the scan schedule does; every schedule change and run published as a `scheduleChanged` event) and `ServerScheduleHost` (time zone, archive refreshed from archive.json, system schedules), render node service, monitor and availability | +| `Server/Hosting`, `Server/Admin/web` | `ServerHost`, `ServerLogging` (console and file levels the logging filters read at every line, the file sink's limits, the engine's level; applied again when Settings › Logs is saved), certificates, discovery beacon, embedded static files (`EmbeddedStaticFiles`: `no-cache` and a content ETag, so an upgrade never mixes old and new modules), Windows service (start and stop failures in the Application event log); the admin panel (ES modules, one per page; `schedules.js` is the Jobs page's Scheduled tab; the Library's views in `pages/library/`: `sequence.js` a sequence and its photo viewer, `trash.js` the archive's trash, `shared.js` cards, selection, grid keyboard and the retry of thumbnails a finished job may have built; `upload.js` the upload dialog the Library opens on demand, hashing in the module worker `hash-worker.js` with the in-house incremental SHA-256 of `sha256.js`, self-tested before its first use, and sending the capture time `capture-time.js` reads: the Exif DateTimeOriginal of a JPEG or TIFF-based file, else the file's time; `reorganize.js` the Reorganize dialog of the Library's selection and of the Archive page's save toast: template switches and fields, a live dry run of `POST /archive/reorganize` one request at a time, Apply that sends the shown plan's fingerprint back) | ### 2.5 Hosts @@ -115,7 +115,8 @@ Dependencies point one way: `Core` ← `Core.Windows`, `Data`, `Protocol` ← `S | `Backup` | `Housekeeping/BackupJobHandler` (via `ArchiveService.CreateJobHandlers`; an SQLite index file only) | yes | SQLite only | | `Cleanup` | `Housekeeping/CleanupJobHandler` (shared steps, plus the host's from `ArchiveServiceOptions.CleanupSteps`) | yes | yes | | `EmptyTrash` | `Archiving/Jobs/EmptyTrashJobHandler` (erases exactly a confirmed plan's trash entries; refuses a stale fingerprint) | yes | yes | -| `Adopt`, `Move` | none: done synchronously (`ArchiveService` actions) | — | — | +| `Move` | `Archiving/Jobs/MoveJobHandler` (Reorganize, `MoveJobParameters`: the templates, the sequences and the confirmed fingerprint; plans again from the templates, applies the plan only while it is the one confirmed, holds it when paused, cancelled or failed, keeps it while the archive is offline, tells each sequence changed as its step completes) | yes | yes | +| `Adopt` | none: done synchronously (`ArchiveService` actions) | — | — | A job engine claims only kinds it has handlers for. Light analysis is queued by the engine (`JobContext` follow-up) after an import or a scan that indexed something; screens never queue it again. Recurring work is queued by the host's @@ -146,7 +147,19 @@ after an import or a scan that indexed something; screens never queue it again. ``` The sidecars are the truth; the index is derived and can always be rebuilt (`ScanMode.Rebuild`, using the index -snapshot when fresh). Writers coordinate through lease files, so a desktop and a server may share an archive. +snapshot when fresh). Writers coordinate through lease files, so a desktop and a server may share an archive. A writer takes a sequence's +folder from its index row read under the sequence's lease (`SequenceWriter.FolderAsync`): a Reorganize moves the folder, +its row and the paths of the renders inside it under that lease, so writers of the same index (uploads, proxies and +exports a server files, exports a sync fetches, editor saves, sync applies and "Save both" copies) write where the +sequence is. The image passes hold the thumbnail lease, which a Reorganize takes too: the thumbnail pass for all of it, +the proxy pass a batch at a time (a quarter of the lease wait), reading the folder and sidecar again for each batch. A +folder another index moved is found by this index's next scan, which moves the row, its frames and its exports' paths +(`ArchiveIndexer.RebaseRendersAsync`; an export, a file or an image-sequence folder, still at the old place keeps its +path, unless the old folder is another sequence's now, and an export of the sequence that holds the old folder never +follows); until then these writers, a render job as it starts and a proxy pass at each batch refuse when they find the +folder gone or holding another sequence (`SequenceFolders.Holds`; the server's render filing with a 503 that keeps the +upload), and a deep analysis that loses it records nothing. A render whose folder another index moves while it runs is +not stopped: its output can land in a folder created again at the old place, where its row keeps finding it. Sync (desktop ↔ server, BRIEF §14.5) reuses the same paths: `SyncService` compares the local index with the server's listing (settings and tags carry version counters), uploads go through the chunked protocol into the server's diff --git a/docs/BRIEF.md b/docs/BRIEF.md index 4440aaf9..9563bd9e 100644 --- a/docs/BRIEF.md +++ b/docs/BRIEF.md @@ -308,9 +308,12 @@ Primary entities (identical concepts in SQLite and PostgreSQL; ids are UUIDv7 st thumbs, render, import, upload-commit, maintenance; backup, cleanup, and the read-only duplicates and orphans reports; empty-trash, stored as 18, which erases exactly the trash entries of a confirmed plan, erases nothing when the trash changed since, and is never - scheduled: amended 2026-10-26, R6), target ids, state (queued, running, paused, done, failed, - cancelled), progress (done/total, fps, eta), log tail, created by, node id, attempts, - error, schedule id (the schedule that queued it; amended 2026-10-26, R10). + scheduled: amended 2026-10-26, R6; move, stored as 14, a Reorganize that applies exactly a + confirmed plan of new folders, titles and file names to sequences of the archive, its target, + and holds the rest of it when paused, cancelled or failed: amended 2026-10-26, R7), target + ids, state (queued, running, paused, done, failed, cancelled), progress (done/total, fps, + eta), log tail, created by, node id, attempts, error, schedule id (the schedule that queued + it; amended 2026-10-26, R10). - **Schedule** (amended 2026-10-26, R10) — id, system key (set, and unique, on a host's system schedules, §14.6), name, action (scan, verify, thumbnails, proxies, analysis, maintenance, backup, cleanup, duplicates, orphans), target (`current`: the host's @@ -421,6 +424,7 @@ The archive is the source of truth; the database is an index that can be rebuilt │ ├── archive.json { id, name, schemaVersion, created, layoutTemplates, proxyPolicy } │ ├── index-snapshot.bin optional accelerator for rebuild (all sidecars concatenated + hash); ignored if stale │ ├── locks/ lease files for concurrent writers (server + client on same share) +│ ├── journal/ rename-.json: a mass rename or Reorganize being applied (below; amended 2026-10-26, R7) │ └── trash/ deleted sequences and photos, kept until Empty (below; amended 2026-10-26, R6) ├── 2026/ │ └── 2026-09-28 Canon EOS R5 - Harbour sunset/ folder = expanded FolderTemplate @@ -432,6 +436,7 @@ The archive is the source of truth; the database is an index that can be rebuilt │ ├── analysis.json full deep-analysis report │ ├── project.json render settings (the "project") │ ├── thumbs.pack packed thumbnails (one file per sequence, indexed; avoids 100k tiny files on SMB) +│ ├── rename-files.json the file renames of a Reorganize a crash interrupted (below; amended 2026-10-26, R7) │ └── *.pending.json journals of an ingest, a photo deletion or a restore a crash interrupted (below) ``` @@ -474,10 +479,48 @@ is re-keyed so the frames that stay keep theirs (while a thumbnail pass holds th pass draws them again). Filing a photo into the sequence again (an import, a restore, an explicit upload again, §14.4) drops its tombstone; emptying the trash does not. +Reorganize (amended 2026-10-26, R7; §12.5, §14.8) applies a confirmed plan step by step, a +step being one sequence and the sequences nested in a folder that moves with it: +- `journal/rename-.json` holds the plan (its steps, templates and the sequences it was + made for), the steps completed and what they did; it is written before the first step and + deleted after the last. A plan whose job was paused, cancelled or failed is marked held and + waits for that job; any other is completed at the next archive open. A journal that cannot be + read is logged and left where it is: the archive opens, the plan is not resumed and its job + fails with the reason. +- Each step takes the leases of its sequences, then their thumbnail leases, and checks under + them, before anything of it moves, that the plan still fits: the sequences where the index + had them, nothing indexed since inside a folder that moves or at its new place, no sidecar of + a newer format to rewrite, the title the plan started from where it changes the title or + names the folder or files after it, the folder and title the templates give from the first + photo as it is now, and the file renames planned again from the sidecar (compared by digest). + What no longer fits refuses the rest of the plan, except photos changed since, whose + sequence keeps its names (§12.5). +- Then the folder moves (a change of case only through a temporary name, never onto another + folder of that exact name), and in one transaction the index follows: the sequence's folder + and title, its frames' paths and the paths of the exports that moved with the folder. Only + then are files renamed; once its folder moved, a step always goes to its end. +- A sequence of the plan that an earlier step left as it was inside a folder that moves later + (it changed after the plan, or the folder that was to carry it stayed) goes with that folder, + under the same leases, keeping its title and file names. Before a held plan resumes, a folder + that moves may hold only such sequences and those of the steps still to come; any other + refuses the plan, which is then given up. +- File renames run under `rename-files.json` in the sequence's `.chronos/`: every file first to + a hidden temporary name beside it (`.chronos-rename--.tmp`), then every file to its + new name, so chains and swaps of names never meet a name another file holds and no file is + ever written over; then the sidecar names the new files (frame order and ids unchanged, + frames version + 1), then the index, then the journal goes. A failure while files move puts + every file back. After a crash the next writer of the sequence (any `ReadLocked`, the plan's + resume) completes the renames, safely run again from wherever it stopped: a new name taken + meanwhile sends that photo and its companions back together to their old names, or to the + first free `_2`, `_3`…, and the journal stays while a temporary file is left. +- Proxies (named by frame index), thumbnails (by index and content hash), tombstones and trash + records need nothing; a photo restored from the trash comes back under the name it had. + Rules: originals are immutable (never rewritten; edits are settings); every write of a sidecar goes to a temp file, `fsync`, rename; the folder name is derived from templates at -import time and never auto-renamed afterwards (renaming is a user mass-operation that -updates sidecars and DB together). Network drives: UNC or mapped paths; long-path aware +import time and never auto-renamed afterwards: only Reorganize, an explicit user action +behind a dry run, moves and renames what is filed, updating sidecars and DB together +(amended 2026-10-26, R7). Network drives: UNC or mapped paths; long-path aware (`\\?\` prefix); no `FileSystemWatcher` reliance — periodic polling by mtime/size (the *Archive scan* system schedule of each host, §14.6; amended 2026-10-26, R10) plus manual rescan; offline detection with graceful read-only state. @@ -491,6 +534,31 @@ name, ext, title`. `{token:format}` passes the format to the .NET formatter. Ill characters are replaced, never passed through; templates are validated live in the UI with a preview of the first three names. +One naming rule for import, upload and Reorganize (amended 2026-10-26, R7): +- A photo is named in its sequence with the sequence's camera and lens (its first photo's, or + the camera hint its creator gave): a second body in a whole-folder import, or a lens changed + during a session, does not show in the names. `{n}` is its place in the sequence, `{name}` + its name on the card, `{ext}` its file's extension (the card name's when the file lost the + extension of a photo), and a frame recorded without a capture time takes the sequence's + start (its first frame's time, else when it was made; never today's date). A name already + given, or held by a file that stays, gets `_2`, `_3`… before the extension. Folder and title + templates see the sequence's first photo as filing saw it. +- So a Reorganize with the archive's own templates changes nothing filing named. It gives + other names, which its dry run lists, where filing could not know the sequence as it is now: + `{session}` of a card's second session on (an import numbers its sessions, a sequence is + one), `{n}` after photos skipped mid-session as duplicates or filed out of capture order, and + a folder or title from a photo that is no longer first. +- Rules every template meets wherever it is typed or sent (Settings › Archive, Import, + Reorganize, the admin panel's Archive): a folder template may not write a level scans never + enter (starting with `.`, or `originals`, `proxies`, `exports`, `.chronos`); a file template + must keep the photo's extension (appended, or after `.{ext}`: `{n}{ext}` is refused), tell + the photos of a session apart (three sample photos two seconds apart must get three names) + and hold no slash. A level a value such as a title would hide that way is written with a + leading `_`. A file name longer than 200 characters is shortened before its `.{ext}`, never + through it. A title template gives text, not a file name (`Paris: night` stays), at most 200 + characters. A template `archive.json` already holds, saved before these rules, is kept + through edits of other settings; changing it holds it to them, and a new archive meets them all. + --- ## 8. Image pipeline @@ -795,8 +863,10 @@ player smoke test on Windows CI. - Card: hero thumbnail, title (user title or `{date} {camera}`), count · camera · span, status chips: `✓` analysed, `▣` proxies, `▶n` renders, `☁` synced/origin, `!` warnings. Hover reveals quick actions: Open, Analyse, Render preset, Sync. -- Multi-select → mass actions bar (Analyse, Build proxies, Verify, Tag, Rate, Move, - Upload, Download, Delete, Export list as CSV). +- Multi-select → mass actions bar (Analyse, Build proxies, Verify, Tag, Rate, + Reorganize…, Upload, Download, Delete, Export list as CSV). Reorganize… (amended + 2026-10-26, R7; formerly Move) takes the selected sequences of one archive, never a + server-only one, into the dialog of §12.5. - Filters are chips; saved views (e.g. "Night, 4K, not rendered"); search is instant (indexed columns); everything virtualized (in-house `VirtualizingWrapPanel`). - Photos deleted from a sequence (amended 2026-10-26, R6; on the admin panel, §14.8, or by @@ -907,7 +977,7 @@ player smoke test on Windows CI. │ Index health: ✓ sidecars 412/412 · ⚠ 3 sequences without proxies · ⚠ 1 unverified since 90 days │ │ Recent maintenance: 2026-09-20 verify ✓ · 2026-09-01 vacuum ✓ │ ├──────────────────────────────────────────────────────────────────────────────────────────────────────┤ -│ Mass operations on filtered set (412): [Analyse] [Proxies] [Thumbnails] [Verify] [Move] [Retag] [Export CSV] [Delete] │ +│ Mass operations on filtered set (412): [Analyse] [Proxies] [Thumbnails] [Verify] [Reorganize…] [Retag] [Export CSV] [Delete] │ ``` Operations: **Scan** (incremental, mtime/size), **Rebuild index** (from sidecars; falls @@ -938,6 +1008,50 @@ those entries and nothing when the trash changed since; an entry that changes wh is kept, and the job then fails after erasing the others. It is the only way the product erases trash entries; no schedule runs it (§14.6). +*Reorganize…* (amended 2026-10-26, R7; it replaces Rename… and Move…) applies new templates +to sequences already filed: the set (online), the Library's selection (§12.2), or every +sequence of the archive from the toast of Settings › Archive (§12.8). The admin panel offers +the same (§14.8), through the same engine and job. +- An in-window dialog: Folders (`{title}` is the new title), File names (as filing names + them, §7.1) and Titles (`{title}` is the current title), each with its switch and field, + checked as it is typed against the rules of §7.1; a template switched off never blocks the + others. Folders and File names start on with the archive's templates, read again when the + dialog opens; Titles starts off, with `{title}`. +- The dry run (nothing touched) follows the typing (400 ms; Enter, or leaving a field, at + once) and lists, in the order the changes apply, each sequence with its folder, title and + first three file names before → after, *Follows its folder* for a sequence nested in a folder + that moves, how many files get a new name, and the photos that keep their names with why: + kept in place outside `originals/` (a tree someone else keeps), never verified (verify the + sequence first), missing; or that the sequence stays as it is, with every folder around it, + because its sequence file cannot be read (damaged, another sequence's, or from a newer + Chronos). The summary reads "12 of 36 change · 3,600 files renamed · 20 names kept". +- *Apply* (enabled only for the dry run of the templates on screen, when something changes) + queues the *Reorganize* job of exactly that plan at user priority; the dialog closes and a + toast links to Jobs. Cancel is the default button. +- The job (desktop and server) plans again and applies the plan only while it is the one + confirmed (its fingerprint, §14.3); otherwise it fails and nothing changes, a sequence + deleted since named in its log. It changes one step at a time. Pause or cancel stops + between two steps and holds the rest for the job's resume or retry; a failed job holds it too + (also when the archive's volume went away), and its retry completes it while it still fits. + A retry while the archive is still offline fails as offline and keeps the plan: a plan + journal it cannot reach is never taken for one completed. + An archive open completes a plan an interruption left (a crash, a yield to another job, the + program closing), not one its job holds. +- What changed after the dry run: a sequence moved or gone, one indexed inside a folder that + moves, a new folder taken, a title edited that the plan changes or names a folder or files + after, a sidecar of a newer Chronos it would rewrite: the rest of the plan is refused, the + steps done stay, and a new dry run is needed. Photos changed since (a sequence still + receiving them) refuse nothing: that sequence keeps its file names, and its folder and title + change while the templates still give them from its first photo as it is now, otherwise it + stays as it was, and so do the sequences its folder was to carry. A sequence left as it was + inside a folder that a later step moves goes with that folder, keeping its title and file + names, so the folder around it still moves. A photo in use or a new name taken keeps that + sequence's file names (every file back). These sequences are listed in the job's log, and + the job fails at the end, after the others changed, saying how many; its retry plans again. +- Deleting sequences of the archive is refused while a Reorganize job runs or is paused. The + Archive and Library screens read the archive again when it ends; an editor open on a + sequence it changed reloads where the sequence is now after that sequence's step. + ### 12.6 Jobs Two tabs, a *Queue | Scheduled* segmented control first in the toolbar (amended 2026-10-26, @@ -998,7 +1112,11 @@ mine / take server / save both). Sections (list on the left, controls on the right, no descriptions — tooltips only): General (language, theme, startup, notifications), Archive (root, templates, proxy policy, thumbnail size; the rescans are the Archive scan schedule of Jobs › Scheduled, §12.6, so -*Rescan every* is gone; amended 2026-10-26, R10), Import (defaults, session rules, verify, +*Rescan every* is gone; amended 2026-10-26, R10; a new folder or file template names only what +is filed next, so once the archive took it, and holds sequences, a toast offers *Reorganize…* +for every sequence with the changed templates switched on, a change made while that archive's +toast is up joining it; on the Archive screen it never replaces an open dialog, and opens once +that one closes: amended 2026-10-26, R7), Import (defaults, session rules, verify, post-actions), Analysis (widths, thresholds, deep analysis auto-run), Rendering (quality profile, memory budget, spill folder, parallelism = photos the running job processes at once, priority queue with a level per job kind, encoders detected, hardware preference; amended 2026-10-16, R2), @@ -1048,7 +1166,8 @@ update check on start (§18) runs whatever screen is open. "already imported" state remembered per card + file (path, size, mtime) for fast re-inserts. - Rename during import: templates (§7.1) with live preview; original name kept in the - sidecar. + sidecar. Every photo of a session is named with its first photo's camera and lens, the ones + its sequence carries, as Reorganize names it (amended 2026-10-26, R7). - Post-actions: keep / delete imported files (only those verified) / format card (OS dialog) / eject; run deep analysis automatically (default on, background, low priority). - Failure handling: card removed mid-copy → partial files deleted, plan resumable on @@ -1135,6 +1254,7 @@ WS /api/v1/events {type: jobProgress|jobState|sequenceCh POST /api/v1/nodes/register · POST /nodes/{id}/heartbeat · POST /nodes/{id}/claim → job · POST /nodes/{id}/jobs/{jobId}/result (chunked upload of output) GET/PUT /api/v1/archive/settings · POST /archive/scan · /rebuild · /verify · GET /archive/stats · POST /archive/maintenance (admin) +POST /api/v1/archive/reorganize {sequenceIds|all, folderTemplate?, fileTemplate?, titleTemplate?, dryRun, fingerprint?} → plan | 202 move job (admin) GET /api/v1/archive/trash · POST /archive/trash/{name}/restore · POST /archive/trash/empty {names?, dryRun, fingerprint} (admin) GET /api/v1/i18n/{culture} strings for the web admin ``` @@ -1188,6 +1308,56 @@ Library and trash (amended 2026-10-26, R6): - The manifest gains `removed: [{sha256, replacement, reason: deleted|replaced, at}]` (null when there are none; covered by its ETag, since a deletion moves the frames version). +Reorganize (amended 2026-10-26, R7; ManageArchive; §7, §12.5, §14.8): +- The request names exactly one of `sequenceIds` (1–1,000) and `all`; a null template keeps + that part, at least one is given, each usable and within the rules of §7.1. A dry run + answers `{steps, sequences, files, kept, fingerprint}` and changes nothing: a step for each + sequence that changes, is carried or keeps photo names, in the order they apply, + `{sequenceId, fromFolder, toFolder, fromTitle, toTitle, carried, framesVersion, fileChanges, + fileSamples: [{from, to}] (at most 3, relative to the sequence folder), blocked: [{reason: + in_place|unhashed|missing|unreadable, photos, message}]}` (`unreadable`: the whole sequence + stays, 0 photos; the message in the request's language). The change sends the dry run's + fingerprint back and answers 202 with the `move` job. Errors: 400 `bad_request` + (`sequenceIds`, `templates`, `fingerprint`), `invalid_template` (below); 404 `not_found` + (`sequence`); 409 `nested_target` (details: the folder that would lie inside a sequence's + folder), `plan_changed` (details: the fingerprint now), `job_unavailable`; 503 + `archive_offline`, `plan_dropped`. Audited `archive_reorganized` (sequences, files renamed, + templates). The job publishes `sequenceChanged` with the change `reorganized` for each + sequence once its step is journaled (at once for a step that failed after its folder moved + and its index rows followed); a plan the server completes as it starts tells no one, as no + client is connected yet. +- The fingerprint is a SHA-256 of the steps as the dry run shows them (folders, titles, + carried, file counts, samples, what stays and why), every file rename by its digest, and the + file template; not the frames version, so photos a sequence receives under the names the + plan leaves them keep it. +- The server keeps a dry run's plan, and a refusal (`nested_target`, `not_found`), for 5 + minutes, keyed by the archive, the selection (all, or the ids in their order, which decides + which folder gets " (2)"), the templates, and a stamp of what the plan reads from the index: + every sequence's id and folder; the planned sequences' title, first capture, camera, lens, + photo count, frames version and how many of their photos are hashed; the title of the others + inside their folders. The same dry run again, and its confirmation, take the kept plan. A + plan is made apart from its request (one a proxy cuts off leaves it to be made, and asking + again waits for it), at most 2 at once and 8 kept or being made; one still being made 15 + minutes after it was asked, let go for newer ones, or when the server stops is stopped, and + its requests answer 503 `plan_dropped`. A change made on disk alone is not in the stamp: the + confirmation then answers 202, and the job, which plans again, fails without changing anything. +- `invalid_template`, here and from `PUT /archive/settings`: the details name the field and, + after a colon, the rule a template that parses breaks (`folderTemplate:reserved_folder`, + `fileTemplate:file_separator`, `fileTemplate:extension`, `fileTemplate:not_unique`), the + message saying why in the request's language (`Errors.Template.`); a blank, invalid or + unusable template keeps the bare field and the generic message. `PUT /archive/settings` holds + a template to the rules only when the save changes it; every template must still parse and + expand. +- Writers that file into a sequence's folder take it from the index row read under the + sequence's lease, so they write where a Reorganize put it. Completing a render upload or a + render node's result that cannot be filed for now answers 503 and keeps the upload + receiving, to be completed again: `sequence_busy` (the sequence held past the lease wait), + `archive_offline` (the archive offline or read-only) or `folder_moved` (the sequence's folder + not where the index has it, or holding another sequence, after another program moved them; + the server's next scan finds it). The node keeps its job while it retries. A proxy upload + answers 503 `sequence_busy` while the sequence is held, 404 `frame` when the sequence or its + folder is gone, or the folder is another sequence's. + Uploads (amended 2026-10-26, R3, R6): `server/info` lists `extensions`, the photo file extensions the archive files (lower case, no dot), which the admin panel's dialog keeps to. A frame upload whose file name starts with `.` is 400 `invalid_file_name`. A start whose @@ -1297,6 +1467,25 @@ missing here and *Download* fetches and drops it each time; a photo never hashed original was already missing when it was deleted leaves no tombstone, so a copy elsewhere (another PC, a card) is not known to be deleted and can come back. +Folders moved by another program (amended 2026-10-26, R7). When a desktop and a server share +an archive, a Reorganize by one index (or a folder moved by hand) is found by the other's next +scan, which moves the sequence's row, its frames and the paths of the exports that moved with +the folder (a file or, for an image sequence, a folder; an export written at the old place +after the move keeps its path there, and another sequence's export saved inside follows only +when it moved with the folder). The other program may also have moved another sequence into +the old folder (its sidecar names that sequence): the moving sequence's exports then follow to +its new folder, and an export of the sequence that took the old folder never follows, so no +row names another sequence's file. Until that scan nothing writes into the old place, which +would create it again, nor into another sequence that took it: *Save both* and *Take server* +answer that the folder is not where the index has it (try again after the next scan), and so +do a render job as it starts, exports fetched by sync, a proxy pass, and a thumbnail pass that +finds another sequence's sidecar there; the editor's save says the sequence is no longer in +the archive, and a deep analysis that loses its folder records nothing. A render of the other +program whose folder moves while it runs is not stopped. Known limitation: an export a +sequence saved into another sequence's folder (the Export folder picker), before the other +program moved that sequence away and the first one into its folder, keeps naming the old +path; the file is intact, moved with the other sequence. + ### 14.6 Job engine Persistent queue in the DB; jobs run one at a time, and the parallelism (configurable, @@ -1414,7 +1603,8 @@ available and says so in the job log. Pages: Login · Dashboard · Library (amended 2026-10-26, R6; below) · Users (table; create/edit/disable/reset/roles/quota) · Archive (path, templates, proxy policy, -scan/rebuild/verify, stats, and *Trash*, which opens the Library's trash view; R6) · Jobs +scan/rebuild/verify, stats, and *Trash*, which opens the Library's trash view; R6; a save +that changes a template offers Reorganize, R7) · Jobs (two tabs in the header, amended 2026-10-26, R10: *Queue*, the queue/history/nodes with cancel/retry, where `#/jobs?job=` opens a job's log and a job a schedule queued carries a *Scheduled* pill @@ -1488,6 +1678,33 @@ operations; it queues no deep analysis (the API's `bulk/jobs` takes `deep`). - The audit log and the Dashboard name photo deletions, trash restores and emptyings asked for. +Reorganize (amended 2026-10-26, R7), the panel's way to the Reorganize of §12.5 through +`POST /archive/reorganize` (§14.3): +- The Library's selection bar has *Reorganize…*: the selected sequences, up to 1,000 (one + plan, one job); above that, every sequence of the archive, only while the selection is + exactly *Select all* without a filter and the archive still holds as many; any other larger + selection is refused with a message, never split. +- On Archive, a save that changes the folder or file template, when the archive has + sequences, shows *Saved* with *Reorganize…*: the dialog for every sequence, with the saved + templates and only the changed parts switched on. Saving alone never renames anything. +- The dialog: Folders (`{title}` the new title), Files (named as filing names them) and Titles + (`{title}` the current title), each with its switch and field, from the archive's settings; + Titles starts off and empty. Each change asks the server for a dry run 400 ms after typing + stops (Enter at once), one at a time, a change made meanwhile planned right after. The + table shows each sequence in the order the changes apply, 200 at a time: title, folder and + renamed files before and after (up to three samples), *Carried* for a sequence that moves + only with a folder it is inside, and the photos that keep their names with why, or why the + sequence stays as it is; totals of sequences changed, files renamed and names kept. A refused + template is marked on its field with the server's reason; a nested target on Folders. +- *Apply…* (enabled only while the table is the plan of the fields and changes something) + asks for a confirmation that counts the sequences, folders and photos (nothing is deleted, + so nothing is typed), then sends that plan's fingerprint; the toast offers *Open job*. When + the archive changed meanwhile (`plan_changed`), or a new plan answered during the + confirmation, the dialog shows the new plan and Apply waits. +- A toast with an action stays 15 s and pauses under the pointer or the keyboard focus. The + audit log and the Dashboard read "… reorganized the archive · N sequences · M files renamed + · templates". + Upload (amended 2026-10-26, R3): Library › *Upload* (no sequence) and a sequence's *Add photos* open the upload dialog (§14.4), a module the pages import only on demand. - Target: the given sequence, or a choice between an existing sequence (a search box, then a @@ -1990,6 +2207,8 @@ questions asked and the answers; DECISIONS rows give the reasons. | 2026-10-26 | Owner review 2, R11 | §12.8, §14.1, §14.3, §14.8, §14.9, §19.6 | Log settings: file and console levels apart on the server (`CHRONOS_LOG_LEVEL` locks both, `CHRONOS_LOG_CONSOLE_LEVEL` the console), retention, a file size limit with numbered parts, a total size limit, daily or hourly rotation, audit retention and the diagnostics share, in the admin panel's Settings › Logs (applied at once, `lockedBy` naming the variable) and the desktop's Settings › Advanced (from the first log line); the server's files take Debug and Trace when asked; logging never fails a job. | | 2026-10-26 | Owner review 2, R6 | §5, §7, §12.2, §12.5, §14.3, §14.4, §14.5, §14.8 | The admin panel manages, never edits: a Library page (filters from facets, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete), a sequence's page with a photo viewer, cover, downloads and photo deletion, and the trash view with Restore and Empty; photos deleted into `trash/photos` under journals, a photo never hashed hashed as it goes, tombstones in the sidecar (`removed`) and the index (`frame_removals`, migration 0008) that keep sync and uploads from bringing a deleted photo back unless the user restores it or uploads it again on purpose; trash kinds, restore reasons, and Empty as the `empty-trash` job behind a dry run, a typed confirmation and a fingerprint, never scheduled; the library, trash and bulk endpoints; the panel's files revalidated (`no-cache`, ETag). | | 2026-10-26 | Owner review 2, R3 | §14.3, §14.4, §14.8 | Upload from the admin panel into an existing or a new sequence (file picker, drag and drop, no folders), hashed in the browser by a self-tested in-house SHA-256 in a module worker, the capture time read from Exif, sent in resumable chunks through the upload API and verified by the server; `server/info` lists the photo extensions; hidden dot files are refused for every client. | +| 2026-10-26 | Owner review 2, R7 (Reorganize) | §5, §7, §12.2, §12.5, §12.8, §14.3, §14.5, §14.8 | Reorganize on the desktop (Archive manager, Library, the toast of Settings › Archive) and the admin panel (Library, the toast of Archive): folder, file and title templates applied to sequences already filed, behind a dry run that lists each sequence's changes, the photos that keep their names and why (in place outside `originals/`, never hashed, missing) and the sequences that stay whole (unreadable sidecar); applied by the `move` job of exactly the confirmed plan (fingerprint), which holds the rest when paused, cancelled or failed and lets a sequence still receiving photos keep its file names; crash-safe plan and file journals (two-phase renames through hidden temporary names, recovery by the next writer); a sequence of the plan left as it was inside a moving folder goes with it; the index, frames and exports follow a moved folder in one transaction, on this index and at another index's next scan; writers take the folder under the lease, never create a left one again and never write into a folder another sequence took; `POST /api/v1/archive/reorganize` with a kept, bounded plan cache and `sequenceChanged` `reorganized`; Rename… and Move… replaced. | +| 2026-10-26 | Owner review 2, R7 (naming) | §7.1, §13, §14.3 | One naming rule for import, upload and Reorganize: the sequence's camera and lens, `{n}` its place, a frame without a time at the sequence's start; template rules everywhere a template is typed or sent (no folder level scans skip, one a value such as a title gives escaped with `_`; a file template keeps the extension, tells photos apart, holds no slash; long names shortened before `.{ext}`; titles as text), held to a template only when it is given anew; `invalid_template` names the rule. | ## Appendix A — `CLAUDE.md` content (create verbatim in Phase 0, keep updated) diff --git a/docs/CHANGELOG.md b/docs/CHANGELOG.md index ca983001..197c0fe2 100644 --- a/docs/CHANGELOG.md +++ b/docs/CHANGELOG.md @@ -5,6 +5,105 @@ commits follow Conventional Commits (release notes are generated from them by `C ## [Unreleased] +## [0.1.0-rc.6] — 2026-10-27 + +### Added +- **Reorganize** on the desktop and the admin panel (owner review 2, R7): apply new folder, file and title templates to + sequences already in the archive. Each template has its switch. A dry run lists, in the order the changes apply, + each sequence's folder and title before and after, how many photos get a new name with the first three, the + sequences that only follow a folder they are in, and the photos that keep their names with why (kept in place + outside `originals`, never verified, missing), or why a whole sequence stays as it is (its sequence file cannot be + read). Nothing changes until you apply: a *Reorganize* job then makes exactly the changes shown, and you can pause, + resume and retry it in Jobs. +- Desktop: *Reorganize…* in the Archive manager's set bar and in the Library's mass bar (the sequences of one archive) + replaces *Rename…* and *Move…*. Folders and file names start from the archive's templates, titles off with + `{title}`; the dry run follows your typing. +- Desktop: after a folder or file template is changed in Settings › Archive, a toast offers *Reorganize…* for every + sequence of the archive with the changed templates switched on. A dialog already open on the Archive screen is never + replaced: Reorganize opens when it closes. +- Admin panel: *Reorganize…* in the Library's selection bar (up to 1,000 selected sequences, or every sequence after + *Select all* without a filter), and in the *Saved* toast after new folder or file templates on the Archive page. A + live dry run as you type, a confirmation that counts the sequences, folders and photos, then a toast with *Open job*. +- Reorganize is crash-safe: files move in two phases through hidden temporary names under a journal in the sequence + (`.chronos/rename-files.json`), so chains and swaps of names work and no file is ever written over; a failure puts + every file back, and a crash is completed by the next program that writes the sequence. XMP files follow their + photo. The plan's journal lets an interrupted Reorganize finish at the next archive open; one whose job was paused, + cancelled or failed waits for that job to be resumed or retried (a job that failed because the archive's drive went + away completes the plan once the drive is back; retried while the drive is still away, it fails and keeps the plan). +- A folder that moves takes along the sequences nested in it and the exports inside it; an editor open on a + reorganized sequence reloads where it is now (desktop). +- A sequence still receiving photos does not stop a Reorganize: it keeps its file names, and its folder and title + change while its first photo still gives them, else it stays as it is; the others go on, and the job then says how + many sequences were not reorganized as planned. A new Reorganize completes them. A selected sequence left as it is + inside a selected folder that moves goes with that folder, keeping its title and file names. +- API v1: `POST /api/v1/archive/reorganize` (archive administrators): a dry run with the plan and its fingerprint, then + the change as a `move` job (202) for exactly that plan, 409 `plan_changed` when the archive changed since, 503 + `plan_dropped` when the server stopped making a plan; the server keeps a dry run a few minutes for its confirmation. + `sequenceChanged` with the change `reorganized`; the audit log and the Dashboard name reorganizations. +- Known limitations: while one sequence's files are renamed, a program that reads them without the sequence's lease + (an editor open on it, a render node or a download fetching originals) can miss a file for a moment; a change made + on disk alone after a server dry run (a folder made by hand, a desktop writing to a shared archive before the + server's scan) is found by the job, which then fails and changes nothing; a photo restored from the trash after a + Reorganize comes back under its old name; a Reorganize job cancelled and never retried leaves its held plan in + `.chronos/journal` (only the file renames a step left half-way are completed at an archive open); deleting + sequences is refused while a Reorganize job runs or is paused; a render of another program whose folder moves while + it runs is not stopped, and its output can land in a folder created again at the old place; a plan journal that + cannot be read is logged and left in `.chronos/journal`: the archive opens, its plan is not resumed and its job + fails with the reason; a render node retries a result the server cannot file for now for about 30 seconds, then + its job fails and a retry renders it again; an export one sequence saved into another's folder (the Export folder + picker) keeps naming its old path when another program then moves that other sequence away and the first one into + its folder (the file is intact: it moved with the other sequence). + +### Changed +- Import, upload and Reorganize name photos by one rule: every photo of a sequence is named with the sequence's camera + and lens (its first photo's, or the camera its creator named), so a whole-folder import of two bodies, or a lens + changed during a session, no longer shows in the file names; a sequence's folder comes from its first photo. A + Reorganize with the archive's own templates changes nothing filing named; where filing could not know the sequence + as it is now (`{session}` of a card's second session, numbers after a photo skipped as a duplicate), its dry run + lists the renames. +- Templates are checked alike everywhere (Settings › Archive, Import, Reorganize, the admin panel's Archive page): a + folder template may not write a folder scans skip (one starting with `.`, or named `originals`, `proxies`, + `exports`); a file template must keep the photo's extension (`{n}{ext}` is refused, `{n}.{ext}` is fine), tell a + session's photos apart and hold no slash. A folder a title would hide that way gets a leading `_`, and a file name + over 200 characters is shortened before its extension, never through it. +- **Upgrade:** a template saved before these rules stays as it is through edits of other settings, on the desktop and + the server; changing it holds it to the rules. Creating an archive (Welcome › Create, adopting a new folder) with + this PC's templates that break a rule is refused, and the message names the rule: fix it in Settings › Archive. + There is no migration. +- Server: `invalid_template` from `PUT /api/v1/archive/settings` and `POST /api/v1/archive/reorganize` names the broken + rule after a colon (`fileTemplate:extension`, `fileTemplate:not_unique`, `fileTemplate:file_separator`, + `folderTemplate:reserved_folder`) with its sentence in the request's language; the admin panel shows it on the + field. +- Renaming a sequence's files raises its frames version: an editor or client holding the old one reloads once. +- Proxy passes hold the thumbnail lease one batch (about 30 s) at a time, so another program's Reorganize, sequence + deletion or pack compaction waits for one batch rather than the whole pass. +- Server: a render upload or a render node's result that cannot be filed for now answers 503 and keeps the upload, to + be completed again: `sequence_busy` (the sequence busy past the lease wait), `archive_offline`, or the new + `folder_moved` (another program sharing the archive moved its folder, or moved another sequence into it, until the + server's next scan); the node keeps its job. A proxy upload answers 503 `sequence_busy` while the sequence is busy. +- The job kind *Move* is now *Reorganize*. + +### Fixed +- After another program moved a sequence away and another sequence into its folder: a render resumed after a crash + no longer deletes a file of the same name in the folder the sequence left, and *Download originals* restores missing + photos only where the sequence is now (under its lease); until this PC's next scan it fails with "folder moved" and + keeps the downloaded copies for the retry. Before, the photo could land in the other sequence's folder. +- Renaming titles with a template (former *Rename…*) turned characters a file name cannot hold into `_` (`Paris: + night` became `Paris_ night`); titles now keep them. +- Moving folders with a template (former *Move…*) could flip a sequence between "… (2)" and "… (3)" at every run, + could give two sequences folders that differ only in case, named a folder after today's date when a sequence had no + capture time in the index, and failed on sequences created without photos; folders now come from the sequence's + first photo, and such sequences are left out. +- Exports stay reachable when another program sharing the archive moves their sequence's folder (its Reorganize, or a + folder moved by hand): the next scan moves their paths with the folder, image-sequence exports included, and when + another sequence was moved into the old folder each sequence keeps naming its own exports. Before, they answered + 404 there. +- A writer that read a sequence before its folder moved (an upload, a proxy, an export, an editor save, a sync, a deep + analysis) writes where the sequence is now, or, when another program moved it, refuses until the next scan instead + of creating the old folder again, and also when that program moved another sequence into the folder it left, so + nothing lands in the other sequence's folder. Desktop: *Save both* and *Take server* on such a sequence say that + its folder is not where the index has it, and a render job of it does not start. + ## [0.1.0-rc.5] — 2026-10-27 ### Added diff --git a/docs/DECISIONS.md b/docs/DECISIONS.md index 0612f7e0..af57fec0 100644 --- a/docs/DECISIONS.md +++ b/docs/DECISIONS.md @@ -151,7 +151,7 @@ One line per decision: date · decision · alternative · reason. | 2026-10-03 | Import omits the Convert row and the profile "New" button: card profiles are born on first insertion and shared through camera profiles (settings row followed by the cards of that camera; a card without settings joins automatically). | Conversion at import / card-less profiles | A converted file breaks the hash-verified erase/format gate and immutable originals; a profile needs a card identity (§13 "rules shared by all cards of that camera"). | | 2026-10-03 | Import sessions merge in the session table and split per photo in Show plan (merges only into the earlier session of the same body and format). Folder and Server destinations run in the screen with a partial result on failure; a server 4xx (not 401/403) fails only that file. Automatic import always goes to this PC's archive. | New job kinds / abort on any error | No job handlers exist for those destinations; §13 lists errors per file; the archive is the gated destination for erase/format. | | 2026-10-03 | Format gate: every photo on the card must be verified by the job's own import records; non-photo files are listed in the typed confirmation, not blocking; the card is re-listed right before SHFormatDrive, behind a typed confirmation of the card name; a card that leaves needs a new check. | Count only DCIM photos / block on any file | Sony and Canon cards always carry camera files; §8.6 and DESIGN §4. | -| 2026-10-03 | Archive manager: Overview (tree, tiles, charts, mass operations on the tree selection narrowed by a Camera/Status/Tag filter) and Maintenance (health with one fix per line, recent runs, duplicates, orphans); duplicates/orphans searches and retag run in-screen, cancellable and logged; rename apply is journaled and completed at the next open; Maintenance adds a database backup. No Merge/split yet (Delete… and Trash… exist since 2026-10-06, through the engine's trash). | Engine jobs for every action / Archive.html's single page | No result store for read-only reports; deleting or moving frames needs engine operations (the trash lives in the server). | +| 2026-10-03 | (Partly superseded by the 2026-10-26 Reorganize job row: a plan its job paused, cancelled or failed is left to that job, not completed at the next open.) Archive manager: Overview (tree, tiles, charts, mass operations on the tree selection narrowed by a Camera/Status/Tag filter) and Maintenance (health with one fix per line, recent runs, duplicates, orphans); duplicates/orphans searches and retag run in-screen, cancellable and logged; rename apply is journaled and completed at the next open; Maintenance adds a database backup. No Merge/split yet (Delete… and Trash… exist since 2026-10-06, through the engine's trash). | Engine jobs for every action / Archive.html's single page | No result store for read-only reports; deleting or moving frames needs engine operations (the trash lives in the server). | | 2026-10-06 | Radio buttons that bind TwoWay are grouped by their shared panel, never by GroupName (kept only for chips in item templates, which bind OneWay). | GroupName on every group | WPF shares a GroupName across every window not yet connected to the screen, so the installer capture (one window per stage, each with its own view model) cross-wired Just me / All users into an endless loop; the same applies to views built in tests and captures. | | 2026-10-06 | Reading direction is set by ChronosWindow (constructor plus Loc.CultureChanged while shown, applied through the Dispatcher). UiLanguage keeps only a Window.Loaded class handler for plain windows such as FullScreenPreview. The Uploader's WindowDirection and Setup's own code are removed. | Keep three mechanisms (UiLanguage loop plus class handler, Uploader WindowDirection, SetupWindow code) | One place covers the client, Uploader and Setup windows created before or after a language switch. The class handler is still needed for the one non-ChronosWindow window. | | 2026-10-06 | Toasts are announced with a UIA notification event on the host: errors use ImportantAll (assertive), other notices use All (polite). | LiveSetting on each toast container plus LiveRegionChanged | A toast is a new element, not a text that changes, and the host's peer is always in the UIA tree, whereas an item container's peer may not be. | @@ -168,7 +168,7 @@ One line per decision: date · decision · alternative · reason. | 2026-10-06 | Index health duplicates line: after a duplicates search it shows the groups found (warning with a Mark copies fix); before any search it shows the flagged-copy count ('No copies flagged' / 'n duplicate frames' with Show) | Only reword the line to flagged copies, or hide it until a search has run | The line can never be a green tick while the Duplicates card lists groups, and it keeps the flagged-copy information that already existed. | | 2026-10-06 | All orphan kinds use the Warning glyph (▲ amber) | Add a neutral/info StatusKind in the shared kit | Every orphan line is an actionable issue with a fix button, and Warning is readable in both themes without a kit change. | | 2026-10-06 | Archive failures become a toast with the action's title, one localized cause sentence from ArchiveFailures.Cause and a Retry action that re-runs the same command; relink Retry re-opens the folder picker | Open logs as in Shell.ReportError, or retry with the same folder | BRIEF 0.2 rule 6 asks for one sentence plus one action. Retry fits these I/O failures. Re-picking the folder covers both 'drive is back' and 'wrong folder'. | -| 2026-10-06 | Dialog failures appear as an error line (✕ Error StatusGlyph, raw text in its tooltip) with no separate Retry button; Apply stays the retry, and a failed apply re-runs the dry run | Add a Retry button to the Rename and Retag dialogs | DESIGN allows two dialog buttons at most. Re-planning shows what is left after a partial or stale apply. | +| 2026-10-06 | (Partly superseded by the 2026-10-26 desktop Reorganize row: Rename is now Reorganize, whose Apply queues a job; the rule stays for the other dialogs.) Dialog failures appear as an error line (✕ Error StatusGlyph, raw text in its tooltip) with no separate Retry button; Apply stays the retry, and a failed apply re-runs the dry run | Add a Retry button to the Rename and Retag dialogs | DESIGN allows two dialog buttons at most. Re-planning shows what is left after a partial or stale apply. | | 2026-10-06 | Cancel is the default (Enter) button in the Rebuild, Rename and Retag dialogs | No default button, or Apply as default | DESIGN: the safe action is left and default. Enter in the text fields is already handled by EditBehavior. | | 2026-10-06 | Rebuild counts show '—' with the reason (offline sentence or failure cause) in the tooltip when they cannot be counted | Remove the two count rows when they cannot be counted | The dialog keeps the same shape, and the reason sits next to the value it explains. | | 2026-10-06 | Rename the Overview/Maintenance segment to 'Health' (new key Archive.View.Health; it: 'Stato') and keep the toolbar's 'Maintenance ▾' | Rename the toolbar menu to 'Tools ▾', or change the English value of Archive.View.Maintenance | BRIEF 12.5 names the toolbar menu Maintenance. A new key makes the missing translations visible in i18n check instead of leaving stale ones. | @@ -195,7 +195,7 @@ One line per decision: date · decision · alternative · reason. | 2026-10-06 | Trash layout: /.chronos/trash/[-stamp] plus a .json record (index row and renders). Restore re-indexes from the sidecar with the same ids, into the old folder or 'folder (n)'. A folder without its sidecar is adopted under the same id with the record's title, tags, rating and notes; a missing hero frame is dropped. | A trash in the database only, or erasing the files. | BRIEF §0.2 rule 8: nothing is erased, and sidecars stay authoritative. | | 2026-10-06 | Delete is refused per sequence for an offline archive, the archive root, folders holding other sequences, busy sequences, a foreign sidecar or a missing folder. Busy covers running or paused jobs on the sequence, plus archive-wide Scan, Rebuild, Import, Maintenance and Verify-all on its archive. Sequences with no folder and no frames lose only their rows. | Block only on jobs that name the sequence. | Archive-wide jobs name the archive, not the sequences, and an import's target folders are known only to its plan. | | 2026-10-06 | Server DELETE maps refusals to codes: 503 archive_offline, 409 sequence_busy (busy, stale plan or lease), 409 archive_root / contains_sequences / sidecar_mismatch / folder_missing / folder_in_use, 404 when the sequence vanished. | A single 409 sequence_busy for every refusal. | Clients show the right sentence, and an offline archive is a retryable service state. | -| 2026-10-06 | Move works on the sequences of one archive at a time, as a new folder layout through MassRenamer with a dry run. | Cross-archive move (copy, verify, then trash the source). | The task names the engine's existing move and rename facilities, and there is no engine operation for a cross-archive move. | +| 2026-10-06 | (Superseded by the 2026-10-26 desktop Reorganize row: Move… is Reorganize…, still for the sequences of one archive, applied by a job.) Move works on the sequences of one archive at a time, as a new folder layout through MassRenamer with a dry run. | Cross-archive move (copy, verify, then trash the source). | The task names the engine's existing move and rename facilities, and there is no engine operation for a cross-archive move. | | 2026-10-06 | Saved views are app-scope settings rows (library.view.) listed in a menu next to the layout switch (show, save, rename, delete with Undo). They are not a chip row. | Chips under the toolbar. | Width at 1200 px: the filters already wrap. | | 2026-10-06 | The timeline is year bands with photos per month above the virtualised card grid, which stays visible. A month (click, or Enter from the keyboard) narrows to its year and scrolls to its first card once. | Replace the grid with a separate timeline list. | It reuses the virtualised grid and keeps the cards in sight (BRIEF §12.2 'timeline (year/month bands with density)'). | | 2026-10-06 | Origin filter: All origins / On this PC / Only on server. 'Only on server' means server sequences without a copy here; local copies that came from the server count as 'On this PC'. Remote cards count in the Year and Camera choices and in the timeline. | Filter by Sequence.Origin, which would mix local copies into 'Only on server'. | A remote card is what the user cannot open without proxies (BRIEF §4.4 mixed mode). | @@ -497,3 +497,28 @@ One line per decision: date · decision · alternative · reason. | 2026-10-26 | No folder upload on the web panel: the dialog has no `webkitdirectory` or directory picker (a test checks), and folders dropped on it are detected with `webkitGetAsEntry`, counted as *Folders skipped* and left out. Only files whose extension `server/info` lists (the new optional `extensions`, from `ImageFormatInfo.Known`, the scanner's list), not empty and within `limits.maxUploadBytes`, are taken. (Owner review 2, R3, R9.) | Upload folders; a list of extensions in JavaScript | The owner's request: importing a whole folder stays on the desktop. A copy of the list would drift, and the archive would ignore files that are not photos. | | 2026-10-26 | Web upload pacing: two photos and two chunks per photo at once (four of the server's eight chunks per account); a call with no answer, 429 or 503 retried after 1, 2 and 4 s; 401, 403, 507, an unknown target (404 `sequence`) and a failed self-test stop the remaining photos (*Not sent*) with the server's message; a completion refused with 409 `upload_state` is read again after 1, 2, 4 and then every 8 s, about a minute; two copies of one photo in a run go one after the other. A new target is created by one `POST /sequences`, never retried, and stays the dialog's target. Each start carries the capture time: the Exif DateTimeOriginal of a JPEG or TIFF-based file (from its first 256 KiB, every offset checked), else the file's modification time as local wall time, which the ingest uses only for a photo with no time of its own. (Owner review 2, R3.) | Send everything at once; `capturedAt` null | Room for the user's other clients; a refusal that would refuse every photo stops at once; a lost answer must not create two sequences; photos without Exif keep their order instead of taking their arrival time. | | 2026-10-26 | Cancel deletes, Close keeps: Cancel aborts the requests, stops the worker and deletes the uploads the run started and did not complete; an upload that failed otherwise (507 at completion, say) stays receiving and the next run resumes it (same user, hash, size and sequence), abandoned ones expiring after the upload retention. During a run Esc is held by a capture-phase listener on the document and leaving the page asks first, so only Cancel stops it. (Owner review 2, R3.) | Delete every unfinished upload on Close; let Esc close the dialog | Cancel frees the space at once; a failure the user can fix is resumed without sending the photo again; a stray Esc must not discard uploads. | +| 2026-10-26 | Import, upload and Reorganize name photos through one rule, `FrameNaming`: a frame in its sequence, `{n}` = index + 1, the sequence as one session from its first frame, the sequence's camera and lens (its first photo's, or its creator's camera hint) for every photo, `{name}` the name on the card, `{ext}` the file's extension (the card name's when the file lost a photo extension), a frame without a capture time at the sequence's start (its first frame's time, else when it was made; never `DateTime.Now` or today). Uploads, card and folder imports (each session with its first photo's camera and lens) and the folder of a new sequence (from its first frame) use it, so a whole-folder import of two bodies, or a lens changed during a session, no longer shows in the names. Where filing could not know the sequence as it is now (`{session}` of a card's second session on, `{n}` after duplicates skipped mid-session or photos filed out of capture order, a first photo that changed), Reorganize gives other names, which its dry run lists. (Owner review 2, R7.) | Each photo's own Make, Model and LensModel; a naming of Reorganize's own | A Reorganize with the archive's own templates must plan nothing for what filing named; the sidecar keeps no camera or lens per frame; a dry run and its apply must agree on frames without a time. | +| 2026-10-26 | Reorganize renames only photos under `originals/` whose SHA-256 is known and whose file is there, each within its own folder; photos adopted in place (outside `originals/`), never hashed or missing keep their names and are listed with the reason (`in_place`, `unhashed`, `missing`). A sequence whose sidecar cannot be read, is another sequence's or is of a newer format stays whole (`unreadable`, 0 photos), and so does every folder around it, which then claims no new folder. The folder and title templates see the sidecar's first frame, the index row only without a sidecar, and a sequence with no time known keeps its folder and title. Sequences created without photos (no folder yet) are left out of rename plans. (Owner review 2, R7.) | Rename adopted trees too; hash the photos first; move a folder without the sequence inside it | An adopted tree belongs to a layout someone else keeps; an unhashed photo can be neither checked against the plan nor followed by sync and the trash; a folder that cannot take a sequence along would leave its index row behind; today's date would move the folder again another day, and a title rename of an empty sequence failed at apply. | +| 2026-10-26 | New file names are given in index order; a name already given, or held by a file that stays (a frame left alone, a file no frame lists, a companion that stays), gets `_2`, `_3`… before the extension, as filing does, so the same frames, template and folder always give the same names and a second Reorganize renames nothing. XMP companions (`stem.xmp`, `name.xmp`, any case) follow their photo with the same tail, a stem two frames share going with the first; `FrameCompanions` serves the trash and Reorganize alike. `UniqueNames` remembers, per name, the first number not yet taken, giving the same names in linear time (a `{title}` plan over 20,000 photos in well under a second, about 28 s before); import, ingest and Reorganize use it. (Owner review 2, R7.) | Refuse a plan with colliding names; search from `_2` for every photo | Deterministic and idempotent; companions keep describing their photo; a quadratic search made a large dry run outlast an HTTP timeout. | +| 2026-10-26 | A step's file renames run under `.chronos/rename-files.json` (the frames version, the phase, every file's old, temporary and new name): every file first to a hidden temporary name beside it (`.chronos-rename--.tmp`), the journal then at phase 2, then every file to its new name, never with overwrite; then the sidecar (frames version + 1, frame order and ids unchanged, so an editor holding the old version reloads once), the index (`FrameRepository.RenameFilesAsync`, only from the version the renames started at), and the journal goes. A failure while files move puts every file back; when one cannot go back, the journal completes the renames at once. After a crash the next writer of the sequence (`SequenceWriter.ReadLocked`; the plan's resume; an archive open for a held plan's unfinished steps) rolls forward, safe to run again from any point: phase 1 becomes phase 2 once every file is at its temporary name, a new name taken meanwhile sends the photo and its companions together back to their old names or the first free `_n` (journaled before they move), and the journal stays while a temporary file is left; the index follows at the plan's resume or the next scan. (Owner review 2, R7.) | Rename one file at a time in place; roll a crash back | Chains (A→B, B→C) and swaps never meet a name another file holds and nothing is ever written over; once files reached their new names, rolling forward is the shorter way to a sidecar that matches the disk. | +| 2026-10-26 | Each step (a sequence and those nested in a folder that moves with it) takes the sequence leases, then the thumbnail leases, by id, and checks under them, before anything of it moves: the sequences where the plan has them, no sequence indexed since inside a folder that moves, nothing at its new folder (`TargetTaken`: a folder on disk, or an index row there, around or inside it), no sidecar of a newer format to rewrite, the title it was planned from where it changes the title or names the folder or files after it (`NamedByTitle`), the folder and title the templates give from the settled sidecar, and the file renames planned again (by digest). Those that refuse (all but the names and the file renames) also run up front, without the leases, before a fresh or a held plan starts. Then the folder moves, every index row of the step follows (folder and title, frame paths, export paths, one transaction), and only then are files renamed; once its folder moved, a step goes to its end whatever is cancelled. A sidecar that cannot be read or written after the move still has its row follow (title kept, no scan stamps), every sequence of the step is told, and the step fails so the job holds the plan. (Owner review 2, R7.) | Rename the files first; check only when the plan starts | Nothing of a step is half-applied when the plan no longer fits, the index never names a folder the sequence left, and no writer works in a folder while it moves or its files are renamed. | +| 2026-10-26 | A Reorganize is confirmed by its plan's fingerprint: the SHA-256 of the file template and of the steps as the dry run shows them (ids, folders, titles, carried, file count, samples, what stays and why) with each step's file renames as one digest (`RenameStep.FileDigest`), not the frames version. The `move` job's parameters (`MoveJobParameters`) carry the templates, the sequences that have a step in the order the plan was made for (which decides the folder that gets " (2)") and the fingerprint, no file list; the job plans again and applies only a plan of the same fingerprint, else fails with "The archive changed after this plan was made" and nothing changes, naming in its log a sequence deleted since. The server answers a confirmation whose plan differs 409 `plan_changed` with the fingerprint now. (Owner review 2, R7.) | Store the plan or its file list in the job; include the frames version | The change made is exactly the one shown (destructive operations rule); the parameters stay small for 100,000 photos; photos uploaded under the names the plan leaves them (the archive's file template is the Reorganize's, the usual case after saving templates) must not refuse it. | +| 2026-10-26 | Photos changed after the plan (received, removed, hashed or copied in, so that the renames planned again differ) refuse nothing: under its leases that sequence keeps its file names (`FilesKept`), and its folder and title change as planned while the templates still give them from its first photo as it is now (the plan journals its folder and title templates; `RenamePlanner.Names`, `Gives`: the expansion or its " (n)"); otherwise its title and file names stay, and its folder too (`Dropped`; `TitlesKept` when an interrupted run moved its folder already), and so do the sequences its folder was to carry (`CarriedKept`). A sequence so left inside the folder of a later step that moves goes with that folder (next row); the folder around it is never kept in place for it. The other steps go on, and the job fails at the end saying how many sequences were not reorganized as planned. A title edited since, a folder taken, a sequence moved or indexed inside a moving folder, or a sidecar of a newer format refuse the rest of the plan instead (a plan an interruption left drops that step, or keeps what no longer fits). A plan journaled before its templates were kept is applied as planned. (Owner review 2, R7.) | Refuse the step, or the whole plan, as soon as a photo arrives | A time-lapse camera uploading every few seconds would make a file Reorganize impossible; a folder or title must never be named after a photo that is no longer first; a user's title edit is never written over. | +| 2026-10-26 | A sequence of the plan that an earlier step left as it was (it changed after the plan, such as photos that make the templates name it otherwise now, or, when a plan resumes, whatever drops a step), or that stayed with a folder that was to carry it, is taken along by a later step whose folder moves while the index still has it inside that folder (at its own folder, or where an interrupted run's move took it): `MassRenamer.LeftInsideAsync` adds it to that step as a carried sequence with its title and file names as they are, locked, leased, moved and recorded with the folder. The tally counts it as titles kept (`TitlesKept`, logged "Title and file names kept, changed after the plan") instead of dropped; one whose carrier stayed is no longer kept when it was only to move, and is titles kept when it was to be retitled or renamed too; one a newer Chronos wrote stays counted as newer. Before a held plan resumes, the check without the leases (`RefuseStaleAsync`) accepts inside each moving folder only the sequences of the remaining steps and the completed ones so left there; any other refuses the plan, which is given up. (Owner review 2, R7.) | Refuse the outer step, which failed the plan at every retry; keep the outer folder in place with all it holds | Nested sequences move out first, so one that stayed was found inside the outer folder as a stranger and the plan stayed held for ever; the outer folder's change does not depend on the nested one's, and moving the nested sequence with its index row leaves no row behind. | +| 2026-10-26 | Reorganize is a job on both hosts: `JobKind.Move` (stored 14, wire `move`, now labelled *Reorganize*), user priority, target the archive, handled by `MoveJobHandler` through `ArchiveService.CreateJobHandlers`; the desktop dialog keeps its dry run in-window and Apply queues the job. Progress counts the steps that change; the checkpoint is `plan:` once the plan's journal exists. Paused or cancelled by the user, or failed, the job stops between two steps and holds the plan (`RenameJournal.Held`): an archive open leaves it to the job (completing only file renames a step left half-way), and the job's resume or retry completes it while it still fits, else gives it up (journal deleted). A yield to another job or a host that stops leaves it unheld, completed at the next open. A failed job whose plan is over (completed with sequences kept, or given up) checkpoints `applied`, so its retry plans again; one that failed because the archive's volume went away keeps its plan, and its retry completes it once the volume is back. A plan journal not found on an archive that cannot be reached (`ArchiveVolume.Probe` offline) tells nothing: a failed job then keeps its `plan:` checkpoint instead of `applied`, and a retry while the archive is offline fails as offline ("The archive … is offline") instead of logging that the plan was completed at an archive open and ending done. Deleting sequences of the archive is refused while the job runs or is paused. (Owner review 2, R7.) | Apply inside the dialog, as the 2026-10-03 and 2026-10-06 rename dialog did; complete held plans at the next open | A Reorganize can rename every photo of an archive: as a job it is paused, resumed after a restart, followed and retried in Jobs, on the same path as the panel; an archive open must not finish behind the user's back what they paused; an unplugged drive must not make a held plan look completed. | +| 2026-10-26 | The plan's journal keeps a tally of the whole plan (`RenameJournal.Done`: changed, files, dropped, files kept, titles kept, files busy, newer, carried kept), so the job log covers every run: "Sequences changed: N, files renamed: M", then one line per sequence not changed as planned, with why. The job then fails with one error: kept first ("changed after the plan"), then newer (a sequence file from a newer Chronos, met only when resuming), then busy (a photo in use or its new name taken); sequences kept because the folder around them stayed follow their carrier's reason. (Owner review 2, R7.) | Report only the last run; one generic error | A plan applied over several runs reports what it did as a whole, and each sentence must be true. | +| 2026-10-26 | Each sequence a Reorganize changed is told through `ArchiveServiceOptions.SequenceChanged` (change `reorganized`) once its step is journaled, by its job or by an archive open that completed an interrupted plan, and at once for a step that failed after its folder moved; a failure to tell is logged, never passed on. The server publishes `sequenceChanged` `reorganized` with the row's versions (its open at start has no hook: no client is connected yet); the desktop raises `AppServices.SequenceReorganized`, and an editor open on that local sequence reloads where it is now while the job goes on (`LocalSequenceSource` reads the frames again when the folder changed while it listed them). (Owner review 2, R7.) | One event when the job ends | Steps done before a pause or a failure are told; an open editor would otherwise decode from paths that moved. | +| 2026-10-26 | A folder move rebases the archive-relative paths of the exports inside it in the same transaction as the sequence row and its frames (`RenderRepository.RebaseFolderAsync`, `ArchiveIndexer.RebaseRendersAsync`). An export is a file, or a folder for an image sequence. The sequence's own exports follow unless one was written at the old place after the move (there and not at the new place, the old folder not another sequence's now), and so does one whose old path another sequence's export now names; another sequence's export saved inside (the Export folder picker) follows only when it moved with the folder, and never one of the sequence that holds the old folder now (next row); absolute paths and other folders stay. A scan that finds a sequence in another folder (another index's Reorganize, a folder moved by hand) applies the same rule. (Owner review 2, R7.) | Leave render rows to be recorded again; rebase by sequence only | Exports must stay downloadable and syncable on every host after a move, and a row must keep naming where its file is. | +| 2026-10-26 | When another index moved a sequence out of its folder and another sequence into that folder, this index's rebase of the first one reads once which other sequence the old folder holds now (`SequenceFolders.OtherSequence`, the id its sidecar names): the first sequence's own exports follow to its new folder even when an export of that name is at the old path (it is the other sequence's), a render row of the sequence that holds the old folder never follows, whatever the scan order, and no other row counts as left behind at the old path while that folder holds another sequence (a third sequence's export saved there through the picker follows when its file moved with the folder) (`RenderRepository.RebaseFolderAsync` gives the rule each row's owner). Known limitation: an export that sequence had saved through the Export folder picker into the first one's folder, before it took that folder, keeps naming the old path; the file is intact in the first sequence's new folder, and no scan repairs the row. (Owner review 2, R7.) | Let every row under a taken old folder follow; keep any row whose path still holds a file | When the scan rebased the holder first, its row then followed the other sequence and named that sequence's file, its own export left without a row for good; a row must never name another sequence's file, and the case left out needs an export saved into another sequence's folder before two moves by another program. | +| 2026-10-26 | A render job's checkpoint records the sequence's archive-relative folder with the output it chose (`RenderCheckpoint.Folder`; older checkpoints read it as null). On resume, a crash's leftovers are rebased by a folder move and removed only inside the sequence's current exports or outside the archive (an export folder chosen on a client); anywhere else in the archive they are left alone and the render takes the next free name. (Owner review 2, R7.) | Delete the pending output at the path the checkpoint recorded | After another program moved the sequence and another sequence into its folder, that path was the other sequence's export, deleted on resume; leftovers of a crash into an export folder chosen inside the archive are no longer cleaned up, the price of never deleting where the sequence is not. | +| 2026-10-26 | *Download originals* restores the originals flagged missing after its transfers, under the sequence's lease, at each frame's path in the folder the index has then, and only when that folder holds the sequence (`SequenceFolders.Holds`); otherwise it restores nothing, keeps the staged copies for the retry and fails with `Errors.Archive.FolderMoved` after its other work. (Owner review 2, R7.) | Restore at the path read when the job started, without the lease | A folder moved by another program sent the photo into the sequence that took the folder (adopted there at its next scan) or recreated the moved-away folder; after this PC's next scan the retry restores into the new folder. | +| 2026-10-26 | A writer takes a sequence's folder from the index row read under the sequence's lease (`SequenceWriter.FolderAsync`; renders a client or a node sends through `ArchiveService.UnderLeaseAsync`), so it writes where a Reorganize put the sequence and never creates the folder it left. A folder another index moved is not where this index has it until its next scan, and neither is one that holds another sequence now (next row): *Take server* and *Save both*, exports fetched by sync, proxies made and a render job as it starts refuse it with "The folder of this sequence is not where the index has it; try again after the next scan" (`Errors.Archive.FolderMoved`), proxies received with 404 `frame`, the server's render filing with 503 `folder_moved` (`FolderMovedException`) and the editor's save with "This sequence is no longer in the archive"; a deep analysis records nothing. Render filing that meets a sequence held past the lease wait, an offline archive or such a folder answers 503 (`sequence_busy`, `archive_offline`, `folder_moved`) and puts the upload back to receiving, the node keeping its job while its client retries (about 30 s; a node then reports the job failed, and its retry renders again); a proxy upload answers 503 `sequence_busy`, or 404 `frame` once its sequence or folder is gone. (Owner review 2, R7.) | Let writers create the old folder again; answer 409, or 500 as before | A folder created again holds files no index row names; `ChronosClient` retries only 503s and a render node fails its job on any other error, which would discard a finished render (a 500 left the upload stuck in Committing until a restart). | +| 2026-10-26 | A sequence is in the folder the index has for it only while that folder exists and its sidecar, when it has one, names no other sequence (`SequenceFolders.Holds`; a sidecar that cannot be read does not count as another's). Every writer that files into a sequence's folder asks it, so a folder another index moved the sequence out of, and another sequence into, is refused exactly like a missing folder until this index's next scan: settings sync and *Take server* (nothing written), *Save both*'s copy and its clean-up (which deletes nothing in such a folder), exports fetched by sync (the download stays staged), the server's render filing, a render job as it starts, proxies received, proxy passes, the deep analysis's checkpoint and the editor's save; a thumbnail pass refuses a sidecar of another sequence before it opens the pack. (Owner review 2, R7.) | Check only that the folder exists; check the sidecar's id in some writers | With only the folder checked, *Take server* wrote the server's settings into the other sequence's `project.json`, *Save both* wrote this PC's copy into its `.chronos` and a render sent for the sequence was filed among its exports; one check shared by every writer leaves none out. | +| 2026-10-26 | The proxy pass holds the thumbnail lease one batch at a time: a quarter of the lease wait (30 s by default), at least one photo, then lets it go for 750 ms (1.5 × `LeaseFile.LongestPoll`, 500 ms) and reads the folder, sidecar and companions again; a folder gone, or holding another sequence now, stops the job with the folder-moved error (resumed from its checkpoint after the scan), and photos changed between batches leave `ProxiesBuilt` unset. File renames take the thumbnail leases too; the thumbnail pass still holds its lease for its whole run. Cost: up to about 2.5 % on long passes. Another process's thumbnail pass may take the lease in a gap, and one longer than the lease wait then fails the running proxy pass, which resumes from its checkpoint. (Owner review 2, R7.) | Hold the lease for the whole pass; no lease | Another program's Reorganize, sequence deletion or pack compaction waits for one batch instead of failing after two minutes behind an hours-long pass, and no pass writes proxies into a folder that moved. | +| 2026-10-26 | A sequence keeps its folder when it already is what the template gives, or that name with the " (n)" filing or an earlier Reorganize gave it, in the template's case; a change of case only is planned while no other folder holds that exact name (another sequence's, or on a case-sensitive file system a folder on disk beside the sequence's own: `RenamePlanner.ExistsExactly` compares every level exactly) and moves through a temporary name. No two sequences of a plan get folders that differ only in case. Under the step's leases a case-only target that now exists beside the sequence's own folder refuses the step (dropped when resuming), as `MoveFolder` would; a change of case in an outer level moves on every file system. (Owner review 2, R7.) | Compare folder names without case; make every target unique again | A second Reorganize must plan nothing (a folder flipped between " (2)" and " (3)" before); NTFS ignores case and Linux does not; a plan that fails at every archive open must never be journaled. | +| 2026-10-26 | Template rules (`TemplateRules`, checked on three sample photos two seconds apart): a folder template may not write a level scans never enter (`ReservedFolder`: starting with `.`, or `originals`, `proxies`, `exports`, `.chronos`); a file template may hold no slash (`FileSeparator`), must keep the photo's extension (`Extension`: `PathTemplate.KeepsExtension`, the extension appended or after `.{ext}`) and must give a session's photos different names (`NotUnique`). What a template does not write itself is made safe instead: a folder level a title gives that scans skip gets a leading `_` (`ExpandFolder`, for import, upload and Reorganize alike), a file name over 200 characters is shortened before its `.{ext}` without splitting a surrogate pair, and a title template expands as text (`ExpandText`: control characters as spaces, at most 200 characters, no file-name sanitizing). Each rule has its sentence (`Errors.Template.`). (Owner review 2, R7.) | Check only that a template parses | `{n}{ext}` drops the dot, and with it the extension every decoder goes by; a folder scans skip vanishes from a rebuilt index; repeating names fill a session with `_2`, `_3`; titles became `Paris_ night`. | +| 2026-10-26 | The rules hold wherever a template is typed or sent: the desktop's Settings › Archive, Import and Reorganize fields (`NamingPreview`), the server's Reorganize and `PUT /archive/settings`, and the archive engine (`ArchiveSettings.Problem`, `CheckTemplates`). A template `archive.json` already holds (saved by 0.1.0-rc.5 or earlier) is held to them only when an edit changes it: the engine's `UpdateSettingsAsync` and the server's PUT check the rules only for templates that differ from the stored ones, every template still having to be non-blank, valid and expandable (the PUT compares with the archive as the server last read `archive.json`; when that file changed since, a desktop's edit say, and the engine refuses a template the form still sends, the answer is still `invalid_template` with the rule, never 409 `archive_policy`); `CreateAsync`, and so adopting a new folder, holds both to every rule (this PC's templates saved by an older version then refuse Welcome › Create, the toast naming the rule, fixed in Settings › Archive). A broken rule is a `TemplateRuleException` (an `ArgumentException` naming the field, with the rule), whose sentence the desktop's toasts show; the API's `invalid_template` details are `:` (`fileTemplate:extension`) with that sentence in the request's language, a blank or invalid template keeping the bare field and the generic message. (Owner review 2, R7.) | Refuse every save while a stored template breaks a rule; check the rules in the user interfaces only | A pre-rules template must not block an edit of the name, the proxy size or the other template, on the desktop or the panel; neither the engine nor the server accepts from another client what the fields refuse. | +| 2026-10-26 | The server keeps Reorganize dry runs (`ReorganizePlanCache`), keyed by the archive, the selection (all, or the ids in their order), the templates and `SequenceRepository.GetStampAsync`: a SHA-256 of what the planner reads from the index (every row's id and folder; for the planned rows their title, first capture, camera make and model, lens, photo count, frames version and how many of their photos are hashed; for others inside a planned folder their title). Uploads into other sequences, ingest status writes, verifies of other sequences and tag or note edits keep a plan; a verify that hashed planned photos plans again. A plan, or a refusal (`nested_target`, `not_found`), is kept 5 minutes from when it was made (a timer per plan, checked again on access); failures and stopped plans are not. Plans are made apart from the request (a request cut off only stops waiting), once per key, at most 2 at once (`Concurrency`) and 8 kept or being made (`Capacity`: a new one lets go the kept plan asked for first, else the one being made asked for first, which stops); one still being made 15 minutes after it was asked (`PlanTimeout`, the wait for a turn included), let go, or running when the server stops is cancelled and answered 503 `plan_dropped`. The confirmation forgets its key once the job is queued. (Owner review 2, R7.) | Plan again at every request; plan in a background job with progress | An `all` dry run reads every sidecar and photo folder, minutes over SMB, and behind a proxy's timeout it was never shown; the job plans again and compares fingerprints, so a kept plan that is stale can only fail, never change what the dry run did not show (a change made on disk alone answers 202, then the job fails changing nothing). | +| 2026-10-26 | `POST /api/v1/archive/reorganize` (ManageArchive): exactly one of `sequenceIds` (1–1,000) and `all`, a null template kept, at least one given; a dry run answers the plan (`ReorganizePlanDto`: steps with folders, titles, carried, frames version, file count, up to 3 samples and what stays, its reason in snake case with a sentence in the request's language; totals; fingerprint); the change answers 202 with the `move` job. 400 `bad_request` (`sequenceIds`, `templates`, `fingerprint`), `invalid_template`; 404 `not_found` (`sequence`); 409 `nested_target` (details: the folder), `plan_changed` (details: the fingerprint now), `job_unavailable`; 503 `archive_offline`, `plan_dropped`. Audited `archive_reorganized` ("sequences · files · folder, file and title templates"), which the panel's audit log and Dashboard show as a sentence. (Owner review 2, R7.) | Separate rename and move endpoints; every planned name in the answer | One request carries the three templates as both programs do; a dry run of 100,000 photos answers counts and samples, not every name. | +| 2026-10-26 | Panel: the Library's *Reorganize…* sends the selected ids, up to 1,000, and `all: true` only above that while the selection is exactly *Select all* without a filter and the total has not changed; any other larger selection is refused with a toast, never split into several plans or jobs. The dialog's switches start on for the parts with a template (Titles off and empty, the archive having no title template; from the Archive page's toast only the changed parts), templates are sent trimmed, a dry run runs 400 ms after typing (Enter at once) with one request in flight and a change meanwhile planned right after, an older request's refusal is not shown, and Apply runs only while the shown plan is the fields' and changes a sequence. The confirmation has two buttons and asks for nothing typed (nothing is deleted); a different plan answered during it is shown, not applied. `toast(message, isError, action)` takes an optional link or button; such toasts stay 15 s and pause under the pointer or the keyboard focus. (Owner review 2, R7.) | Split a large selection into several jobs; a typed confirmation | One dialog is one plan and one job, and separate plans could give two sequences one destination; a typed word is for what cannot be undone. | +| 2026-10-26 | Desktop: one *Reorganize…* dialog replaces Rename… and Move… of the Archive manager and Move… of the Library, for the sequences of one archive as Move was: Folders and File names on with the archive's templates (read again from the index when it opens), Titles off with `{title}`; the dry run follows the typing (400 ms; Enter or leaving a field plans at once unless that dry run is on screen or under way, so a click on Apply is never turned off under it), and only the latest dry run publishes its result. After Settings › Archive saves a new folder or file template into an archive with sequences, a toast offers *Reorganize…* for every sequence with the changed parts on, one offer per archive, a change made while its toast is up (8 s) joining it (`ReorganizeOffer`, `Toast.Closed`); on the Archive screen an open dialog is never replaced: Reorganize waits, says so, and opens when it closes. The old Rename and Move keys were pruned from every language (`i18n prune`); the capture scene is `archive-reorganize-*`. (Owner review 2, R7.) | Keep Rename (titles) beside Reorganize; a modal question or an automatic Reorganize after a template change | One concept and one button for how filed sequences are named, with the same three templates as the panel; templates only name what is filed next, so a toast offers without interrupting and nothing moves without the dry run; a new key shows as untranslated instead of 36 languages keeping "Move". | diff --git a/docs/STATUS.md b/docs/STATUS.md index f6d68b43..c03dddca 100644 --- a/docs/STATUS.md +++ b/docs/STATUS.md @@ -16,7 +16,7 @@ by its `windows` job once a Windows runner is registered (`WINDOWS_RUNNER`), and | 8 Release readiness | Release pipeline end to end (installers, portable and server zips, SHA256SUMS, release notes, optional signing, server image in the Gitea container registry, optional separate releases repository), update check with verified download, scrubbed diagnostics bundles (desktop and server), performance gates, 38 cultures (`en`, `it` and 36 machine translations with glossaries and independent reviews), RTL pass (`ar`, `he`: mirrored windows, left-to-right islands for media, charts, numbers and paths; any right-to-left culture added later follows), accessibility pass (names, live regions, keyboard paths for charts and the curve editor). The installer test (silent install of the packed installers, run, upgrade in place, uninstall: files, Add/Remove Programs, shortcuts, file type, user data kept, exit codes) runs in CI's `windows` job on a Windows runner. Pending: the interactive install on a real PC, Unraid template validation on a real server. | | 8.1 Owner review 1 | In progress (request, answers and plan: `docs/requests/2026-10-15-owner-review-1.md`). Phase 1 done: stalled thumbnail and proxy jobs no longer fail and stay Running (frame-counted progress, bounded time left, final state always written); the editor's cancelled decodes stay in their tasks (no debugger stops in `WicDecoderProvider.cs`); WIC decodes RAW only through the Raw Image Extension and never DNG; GoPro DNGs converted by Adobe software are DNGs, developed natively for videos, read through their embedded preview for analyses and previews, and reclassified in existing archives by the next light analysis. Phase 2 done: jobs run one at a time on the desktop and the server; Parallelism is how many photos the running job processes at once (thumbnail and proxy passes, tier probes, deep analysis, render decodes); pausing the running job starts the next; an optional priority queue by job kind (Settings › Rendering, admin panel › Settings › Jobs, `CHRONOS_PRIORITY_QUEUE`) pauses lower jobs and resumes them by themselves; `CHRONOS_PARALLELISM` replaces `CHRONOS_WORKERS`. Phase 3a done: the rail is 200 px and collapses to icons with ≡ or Ctrl+B (tooltips then name the sections, the choice saved at once); the admin panel's sidebar is 256 px and collapses the same way. Phase 3b done: the Sequence section is now Edit, one sequence at a time chosen in a picker inside the section (Change sequence, Ctrl+O; the sequence edited last selected first), and the editor's tabs are the steps of a guided, freely navigable path from a new Analysis step (every finding with the step that deals with it) to Export, each step showing where it stands, with Previous and Next. Next, after owner review 2 (the owner's order): phase 4, the visual crop locked to the output's proportions (R5) and mirroring, 90° rotations, straightening and colour filters (R6). | | 8.2 Chronos on Gitea | Done (request: `docs/requests/2026-10-23-chronos-gitea.md`): Titano renamed Chronos everywhere, translations' grammar included; repository, update check, links, issue forms and registry moved to the self-hosted Gitea; Gitea Actions CI, release, nightly image and performance workflows for the Linux runner, with the Windows programs cross-compiled and checked (`pe-check`); new `Chronos.Tools` commands `zip`, `gitea-release`, `postgres-ci`, `pe-check`. Pre-releases `v0.1.0-rc.1` and `v0.1.0-rc.2` (the update check builds its links from `ChronosReleasesUrl`, since Gitea's use its LAN ROOT_URL) published; `REGISTRY_TOKEN` is set and the `v0.1.0-rc.2` server image is in the registry. | -| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. | +| 8.3 Owner review 2 | In progress (request, answers and plan: `docs/requests/2026-10-26-owner-review-2.md`). Phase 1 done and released as `v0.1.0-rc.3` (one adversarial review round, 19 findings fixed; strings in all 38 languages): `:latest` follows the highest stable release, or the highest pre-release while none is stable (`Chronos.Tools release-channels`), `:nightly` stays the nightly build of `main` (R1); `CHRONOS_SPACE_PATH` and the Unraid template's *Array view* (`/mnt/user0/` read-only at `/space`) make the admin panel show the array's free space, the cache apart as *Write volume*, the file system in the tooltip, and completing an upload checks the archive volume first (507, resumable) (R2); the Settings icon is a toothed gear and the admin panel docks Settings at the foot of its sidebar (R4); About is the last page of Settings on the desktop and the last group of Settings on the admin panel (R5); Import › Folder… › *Whole folder* imports a folder as one sequence per format, titled after the folder (R9). Phase 2 done and released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): scheduled jobs (R10) — schedules (migration 0007) with an in-house recurrence form, one scheduler per host claiming runs by compare-and-set with catch-up, and Jobs › Scheduled on the desktop and the admin panel (`/api/v1/schedules`, `scheduleChanged`); every timer that queued work is a visible system schedule (server: archive scan, upload clean-up every 6 h, index backup at 03:00, job history and audit log clean-ups; desktop: archive scan, daily index backup, housekeeping with cache trim), the archive still scanned at start; new Backup and Clean-up jobs, duplicates and orphans reports as jobs, one backup retention, the trash only reported; log settings (R11) — file and console levels, retention, file and total size limits, daily or hourly rotation, audit retention (the audit clean-up schedule's) and the diagnostics share in the admin panel's Settings › Logs (`CHRONOS_LOG_*`, `lockedBy`) and the desktop's Settings › Advanced; the server's files take Debug and Trace again, and logging never fails a job. Phase 3 done and released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; Library, photo delete and restore and the web upload tried by hand): the admin panel manages and never edits (R6) — a Library page (facets filters, cards or list, keyboard selection, mass Analyse, Proxies, Thumbnails, Verify, Tags, Export CSV and Delete, 1,000 sequences a request), a sequence's page (inline title, tags, rating, notes, photo viewer, cover, downloads, photo delete) and the trash view (Restore, Empty… behind a dry run, the typed word and a fingerprint); photos deleted into `trash/photos` under crash-safe journals with tombstones in the sidecar and `frame_removals` (migration 0008), so sync and uploads never bring them back unless restored or uploaded again on purpose; trash kinds, restore reasons and the `EmptyTrash` job on the desktop's Trash… too (typed entry count); the panel's files revalidated (`no-cache`, ETag); upload from the panel (R3) — file picker or drop, no folders, a self-tested in-house SHA-256 in a module worker, Exif capture time, resumable chunks. Known limitations: a never-hashed photo whose file was already missing is deleted without a tombstone; an unhashed server frame of a photo deleted on a PC stays *missing here* until the server verifies it; `jobState` carries no kind, so panel pages refresh after any job. Phase 4a done and released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): Reorganize after import (R7) on the desktop (Archive manager, Library, the toast after Settings › Archive templates change; it replaces Rename… and Move…) and the admin panel (Library, the *Saved* toast of Archive) — folder, file and title templates applied to filed sequences behind a dry run that lists every change, the photos that keep their names and why (in place, never verified, missing) and the sequences that stay whole (unreadable sidecar), applied by the `move` job of exactly the confirmed plan (fingerprint, `POST /api/v1/archive/reorganize`, plans kept a few minutes on the server), which holds the rest when paused, cancelled or failed (also while the archive is offline), lets a sequence still receiving photos keep its file names and takes along a sequence left as it was inside a folder that moves; files renamed in two phases under `.chronos/rename-files.json`, completed after a crash by the next writer; the index, frames and exports follow a moved folder in one transaction, here and at another index's next scan, and writers never create a folder a Reorganize left nor write into one another sequence took; import, upload and Reorganize name photos by one rule (the sequence's camera and lens), and templates follow one set of rules everywhere (no folder scans skip, the extension kept, names that tell photos apart), held only to templates given anew. Known limitations: a reader without the sequence's lease can miss a file while its files are renamed; a change made on disk alone after a server dry run is found by the job, which fails changing nothing; a photo restored from the trash after a Reorganize keeps its old name; a render of another program whose folder moves while it runs is not stopped. | | 9 Monetization | Not started: requires explicit approval (§22). | ## Verification (2026-10-12) @@ -87,6 +87,10 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot before*, whose *Upload again* files it on the next *Upload*. Esc does nothing while photos are sent. - Desktop trash: Archive › Maintenance › *Trash…* lists photo entries beside deleted sequences; *Restore* says why a photo stayed; *Empty…* measures the trash and asks for the number of entries before the *Empty trash* job. +- Reorganize: desktop Archive › select a year › *Reorganize…* › Folders `{year}/{date} {title}`: the dry run lists every + change, and *Apply* queues the *Reorganize* job (pause and resume it in Jobs). + Admin panel: Library › select sequences › *Reorganize…* › *Apply…* › *Reorganize* › *Open job*; or Archive › change + the file template › *Save* › *Reorganize…* in the toast. - Project files: Export › *Save project file* writes a `.chronos` file; opening it (double-click or `Chronos.exe `) opens the sequence with those settings in the running Chronos. - Notifications: minimise Chronos and insert a card or finish a job: a Windows notification appears; Ctrl+1…6 and @@ -100,28 +104,27 @@ src/Chronos.App/bin/Release/net10.0-windows/Chronos.exe --capture out/screenshot Owner reviews, in the owner's order (owner review 2 first, then the rest of owner review 1); each phase ends with a release (owner review 2, R12): -1. Owner review 2, phase 4a: R7 Reorganize after import. -2. Owner review 2, phase 4b: R7 mass conversion. -3. Owner review 2, phase 5a: R8 workspace and projects with a local home (migration 0009). -4. Owner review 2, phase 5b: R8 server home. -5. Owner review 2, phase 5c: R8 originals, local render, clean-up, Workspace settings. -6. Owner review 1, phase 4: R5 visual crop locked to the output's proportions, R6 mirroring, 90° rotations, +1. Owner review 2, phase 4b: R7 mass conversion. +2. Owner review 2, phase 5a: R8 workspace and projects with a local home (migration 0009). +3. Owner review 2, phase 5b: R8 server home. +4. Owner review 2, phase 5c: R8 originals, local render, clean-up, Workspace settings. +5. Owner review 1, phase 4: R5 visual crop locked to the output's proportions, R6 mirroring, 90° rotations, straightening and colour filters (project settings in the workspace). -7. Owner review 1, phase 5: R3 export panel and Render menu, R8 export options, R9 videos library. -8. Owner review 1, phase 6: Docker, Unraid and deploy docs, BRIEF §24 amendments, full verification. +6. Owner review 1, phase 5: R3 export panel and Render menu, R8 export options, R9 videos library. +7. Owner review 1, phase 6: Docker, Unraid and deploy docs, BRIEF §24 amendments, full verification. Phase 8 gate: -9. Visibility: make the `BalboSoft` organisation (and its packages) public, or publish to a public `RELEASES_REPO`, so +8. Visibility: make the `BalboSoft` organisation (and its packages) public, or publish to a public `RELEASES_REPO`, so that people without an account can download releases, get update notices and pull the image. -10. Windows runner: register an act_runner in host mode on a Windows PC (.NET SDK, Git for Windows, PowerShell 7) and +9. Windows runner: register an act_runner in host mode on a Windows PC (.NET SDK, Git for Windows, PowerShell 7) and set the repository variable `WINDOWS_RUNNER` to its label. Then arm the screenshot diff: from the `ci-screenshots` commit of the first green `windows` job of a pull request, run `dotnet run --project src/Chronos.Tools -- screenshots accept ` and commit the PNGs to `tests/visual/baselines` (its README says how). From then on a visual change, or a screen without a baseline, fails the `windows` job. -11. On Windows: install the latest pre-release's setup, upgrade over the previous version, uninstall (with and without +10. On Windows: install the latest pre-release's setup, upgrade over the previous version, uninstall (with and without user data), silent mode. -12. Unraid: install the template as a user template (README › Server image, Compose and Unraid) with the official +11. Unraid: install the template as a user template (README › Server image, Compose and Unraid) with the official PostgreSQL template, check that its icon (the SVG of `branding/`) shows, reach the WebUI, and that the Dashboard shows the array's free space through *Array view*. -13. Native-speaker review of the machine translations where users report wording (`i18n export` per language). +12. Native-speaker review of the machine translations where users report wording (`i18n export` per language). diff --git a/docs/requests/2026-10-26-owner-review-2.md b/docs/requests/2026-10-26-owner-review-2.md index 3b7ae901..0bce2155 100644 --- a/docs/requests/2026-10-26-owner-review-2.md +++ b/docs/requests/2026-10-26-owner-review-2.md @@ -71,8 +71,8 @@ |---|---|---|---| | 1 | R1 `:latest`, R2 array space, R4 gear and Settings at the bottom, R5 About inside Settings, R9 whole-folder import | done 2026-10-26, released as `v0.1.0-rc.3`: BRIEF §12.1, §12.4, §12.8, §12.9, §13, §14.4, §14.8, §14.9, §19.3, §19.5, §19.6, §24; 12 DECISIONS rows dated 2026-10-26 (R1 `:latest` and `release-channels`; R2 space path, mountinfo file system, fall-back warning, write volume, 507 at completion, `VolumeSpace`; R4/R5 admin menu and About group; R4 gear icon and `icons.py` generating `icons.js`; R5 desktop About page; R9 whole-folder grouping and its session key); CHANGELOG [Unreleased]; STATUS 8.3. `:latest` appears with the next pre-release: re-publishing `v0.1.0-rc.2` builds the tag's `Chronos.Tools`, which lacks `release-channels` | `1f089888` | | 2 | R11 log settings, R10 scheduled jobs (migration 0007) | done 2026-10-27, released as `v0.1.0-rc.4` (one adversarial review round, 35 findings fixed; strings in all 38 languages): BRIEF §5, §6.2, §7, §12.5, §12.6, §12.8, §14.1, §14.3, §14.6, §14.8, §14.9, §19.6, §24; 30 DECISIONS rows dated 2026-10-26 (R10 text recurrence form instead of cron, compare-and-set claim, system schedules seeded once, the timers they replace, catch-up, live services that are not schedules, the trash only reported, history and audit purges in clean-ups, one audit retention, scan at start, deep analysis read at run time, 6-hour upload sweep, Scheduled as a Jobs tab, Backup and Cleanup job kinds, 500 sequences per job, index backups and one backup retention, the archive.json timer, schedule API and audit, `scheduleChanged`, time zone, cache trim, desktop toasts, texts and archive reopening; R11 log defaults, rotation and pruning, the Debug/Trace fix, `CHRONOS_LOG_LEVEL` locking both levels, the log settings DTO and desktop rows, logging that never fails a job), six earlier rows marked superseded; CHANGELOG [Unreleased] with the `CHRONOS_LOG_LEVEL` and migration 0007 upgrade notes; STATUS 8.3 | `af9eeaab` | -| 3 | R6 library on the panel, photo delete and trash (migration 0008), R3 web upload | done 2026-10-27, released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; tried by hand in a browser) (two adversarial review rounds, findings fixed; new strings in `en` and `it` only so far): BRIEF §5, §7, §12.2, §12.5, §14.3, §14.4, §14.5, §14.8, §24; 24 DECISIONS rows dated 2026-10-26 (R6 photo trash layout, deletion journal and hidden pending record, restore journal and `.restoring` staging under the entry lease, restore rules and kept reasons, tombstones in sidecar and index, never-hashed photos hashed at deletion with the missing ones left without a tombstone as a known limitation, positions and follow-ups, Empty only as an explicit job with a fingerprint and never scheduled, trash API and audit, photo-delete permission and body limit, bulk limits of 1,000 a request and the verify fix, the upload tombstone checks and the explicit restore flag, sync tombstones and aliases, hidden dot files refused, Library navigation and the on-demand upload module, facets and covers, panel confirmations, CSV and grids, live refresh without job kinds, static files `no-cache` with ETag; R3 in-house SHA-256 worker, fail-closed self-test, no folder upload and `server/info` extensions, upload pacing and capture time, Cancel deletes and Close keeps); CHANGELOG [Unreleased] with the migration 0008 upgrade note and the known limitations; STATUS 8.3 | | -| 4a | R7 Reorganize after import | in progress | | +| 3 | R6 library on the panel, photo delete and trash (migration 0008), R3 web upload | done 2026-10-27, released as `v0.1.0-rc.5` (one adversarial review round and two fix rounds, 40 findings fixed; strings in all 38 languages; tried by hand in a browser): BRIEF §5, §7, §12.2, §12.5, §14.3, §14.4, §14.5, §14.8, §24; 24 DECISIONS rows dated 2026-10-26 (R6 photo trash layout, deletion journal and hidden pending record, restore journal and `.restoring` staging under the entry lease, restore rules and kept reasons, tombstones in sidecar and index, never-hashed photos hashed at deletion with the missing ones left without a tombstone as a known limitation, positions and follow-ups, Empty only as an explicit job with a fingerprint and never scheduled, trash API and audit, photo-delete permission and body limit, bulk limits of 1,000 a request and the verify fix, the upload tombstone checks and the explicit restore flag, sync tombstones and aliases, hidden dot files refused, Library navigation and the on-demand upload module, facets and covers, panel confirmations, CSV and grids, live refresh without job kinds, static files `no-cache` with ETag; R3 in-house SHA-256 worker, fail-closed self-test, no folder upload and `server/info` extensions, upload pacing and capture time, Cancel deletes and Close keeps); CHANGELOG [Unreleased] with the migration 0008 upgrade note and the known limitations; STATUS 8.3 | `9aa818ed` | +| 4a | R7 Reorganize after import | done 2026-10-27, released as `v0.1.0-rc.6` (one adversarial review round and six fix rounds; strings in all 38 languages): BRIEF §5, §7, §7.1, §12.2, §12.5, §12.8, §13, §14.3, §14.5, §14.8, §24; 25 DECISIONS rows dated 2026-10-26 (R7 one naming rule `FrameNaming` for import, upload and Reorganize; what Reorganize renames and what stays whole; unique names in index order and XMP companions; the two-phase file journal; step order and checks under the leases; the fingerprint pinning file renames by digest; sequences still receiving photos; a sequence left inside a moving folder taken along; Reorganize as the `move` job with held plans; the whole-plan tally and errors; `sequenceChanged` `reorganized` and the editor reload; exports rebased with their folder; the rows of a sequence that took the old folder never follow; writers under the lease and render filing's 503; a folder another sequence holds refused by every writer; proxy lease batches; case-only and stable folders; template rules; rules held only to templates given anew; the server's plan cache; the reorganize API; panel selection and dialog; the desktop dialog and the Settings toast; render leftovers removed only where the sequence is; originals restored only where the sequence is), three earlier rows marked superseded; CHANGELOG [0.1.0-rc.6] with the template upgrade note and the known limitations; STATUS 8.3 | | | 4b | R7 mass conversion | todo | | | 5a | R8 workspace and projects with a local home (migration 0009) | todo | | | 5b | R8 server home | todo | | diff --git a/i18n/ar/Admin.ar.resx b/i18n/ar/Admin.ar.resx index a32910e2..f6f01c2a 100644 --- a/i18n/ar/Admin.ar.resx +++ b/i18n/ar/Admin.ar.resx @@ -9,6 +9,7 @@ خادم Chronos مدة التشغيل الإصدار + أعاد {0} تنظيم الأرشيف · {1} غيّر {0} تنظيم الأرشيف حذف {0} {1} بدأ {0} المهمة {1} @@ -156,7 +157,7 @@ استيراد تحليل سريع صيانة - نقل + إعادة التنظيم ملفات يتيمة نسخ وكيلة إعادة البناء @@ -391,6 +392,7 @@ تسجيل الدخول لإدارة هذا الخادم المستخدم اسم المستخدم الخاص بك على هذا الخادم + إعادة تنظيم الأرشيف تنظيم الأرشيف حذف صور بدء مهمة @@ -478,6 +480,68 @@ تغيير كلمة المرور استبدال كلمة المرور والمتابعة إلى اللوحة اختر كلمة مرور جديدة + إعادة التنظيم… + تطبيق قوالب المجلدات والملفات والعناوين على التسلسلات المحددة؛ وتعرض المعاينة كل تغيير أولًا + بعد: + تطبيق… + إعادة التنظيم كما تعرض المعاينة؛ ويُطلب التأكيد أولًا + قبل: + اكتب قالبًا، أو أوقف هذا الجزء. + الإغلاق دون تغيير أي شيء + منقول ضمنًا + يُنقل فقط لأن مجلدًا يحتويه يُنقل + الملفات المُعاد تسميتها + المجلد + التسلسل + إعادة التنظيم + إضافة المهمة التي تنقل الملفات الأصلية وتعيد تسميتها إلى قائمة الانتظار؛ لا يُستبدل أي شيء ولا يُحذف + تحصل {0} صور على أسماء جديدة. + تحصل {0} صورة على أسماء جديدة. + تحصل صورة واحدة على اسم جديد. + تحصل {0} صورة على أسماء جديدة. + يُنقل {0} مجلدات. + يُنقل {0} مجلدًا. + يُنقل مجلد واحد. + يُنقل {0} مجلد. + يتغيّر {0} تسلسلات. + يتغيّر {0} تسلسلًا. + يتغيّر تسلسل واحد. + يتغيّر {0} تسلسل. + إعادة التنظيم الآن؟ + اسم كل صورة كما يحدده الاستيراد، مثل {date}_{time}_{n:0000}؛ وتتبعها الملفات المجاورة لها + الملفات + إعادة تسمية صور كل تسلسل؛ وعند الإيقاف تبقى أسماء الملفات كلها كما هي + أُعيدت تسمية {0} ملفات + أُعيدت تسمية {0} ملفًا + أُعيدت تسمية ملف واحد + أُعيدت تسمية {0} ملف + مجلد كل تسلسل في الأرشيف، مثل {year}/{date} {camera}؛ و{title} هو العنوان الجديد + المجلدات + نقل كل تسلسل إلى المجلد الذي يحدده قالبه؛ وعند الإيقاف يبقى كل مجلد في مكانه + لم يعد أحد التسلسلات المحددة موجودًا في الأرشيف؛ أغلق وحدّد مجددًا. + {0}: {1} + شغّل جزءًا واحدًا على الأقل لتغييره. + لا شيء للتغيير: هذه التسلسلات تتبع القوالب بالفعل. + إعادة التنظيم… + تطبيق القوالب الجديدة على التسلسلات الموجودة بالفعل في الأرشيف؛ وتعرض المعاينة كل تغيير أولًا + فتح المهمة + إظهار المهمة وسجلها في صفحة «المهام» + تغيّر الأرشيف أثناء التأكيد؛ راجع المعاينة الجديدة وطبّق مجددًا. + جارٍ إعداد الخطة… + معاينة + ما سيصبح عليه كل تسلسل، بترتيب تطبيق التغييرات؛ لم يتغير شيء بعد + أُضيفت إعادة التنظيم إلى قائمة الانتظار. + يبقى هذا المجلد في مكانه + إعادة تنظيم {0} تسلسلات + إعادة تنظيم {0} تسلسلًا + إعادة تنظيم تسلسل واحد + إعادة تنظيم {0} تسلسل + إعادة تنظيم كل التسلسلات + العنوان الجديد لكل تسلسل، مثل {date} {camera}؛ و{title} هو العنوان الحالي + العناوين + منح كل تسلسل العنوان الذي يصنعه قالبه؛ وعند الإيقاف تبقى العناوين كلها كما هي + تعمل إعادة التنظيم على {0} من التسلسلات كحد أقصى في المرة الواحدة، أو على كل التسلسلات: امسح عوامل التصفية وحدد الكل. + التسلسلات المتغيرة: {0} · الملفات المُعاد تسميتها: {1} · الأسماء المحتفظ بها: {2} مسؤول محرر رافع diff --git a/i18n/ar/Archive.ar.resx b/i18n/ar/Archive.ar.resx index 267409ad..c77cf217 100644 --- a/i18n/ar/Archive.ar.resx +++ b/i18n/ar/Archive.ar.resx @@ -17,6 +17,7 @@ انتظر حتى تُطبَّق التغييرات. المجموعة فارغة: غيّر التحديد أو عامل التصفية. لن يتغير شيء. + شغّل قالبًا واحدًا على الأقل. يجب أن يكون الأرشيف متصلًا وقابلًا للكتابة. انتظر انتهاء التشغيل التجريبي. انتظر حتى تتم قراءة الأرشيف. @@ -101,6 +102,18 @@ كُتب {0} بإصدار أحدث من Chronos (التنسيق {1}). الأرشيف {0} غير متصل. الأرشيف {0} للقراءة فقط. + احتفظ {0:N0} تسلسلات بأسماء ملفاتها: كانت إحدى الصور قيد الاستخدام أو كان اسمها الجديد مستخدمًا بالفعل. + احتفظ {0:N0} تسلسلًا بأسماء ملفاتها: كانت إحدى الصور قيد الاستخدام أو كان اسمها الجديد مستخدمًا بالفعل. + احتفظ تسلسل واحد بأسماء ملفاته: كانت إحدى الصور قيد الاستخدام أو كان اسمها الجديد مستخدمًا بالفعل. + احتفظ {0:N0} تسلسل بأسماء ملفاتها: كانت إحدى الصور قيد الاستخدام أو كان اسمها الجديد مستخدمًا بالفعل. + لم يُعَد تنظيم {0:N0} تسلسلات كما هو مخطط: فقد تغيّرت بعد إعداد الخطة. + لم يُعَد تنظيم {0:N0} تسلسلًا كما هو مخطط: فقد تغيّرت بعد إعداد الخطة. + لم يُعَد تنظيم تسلسل واحد كما هو مخطط: فقد تغيّر بعد إعداد الخطة. + لم يُعَد تنظيم {0:N0} تسلسل كما هو مخطط: فقد تغيّرت بعد إعداد الخطة. + احتفظ {0:N0} تسلسلات بعناوينها وأسماء ملفاتها: ملفات هذه التسلسلات من إصدار أحدث من Chronos. + احتفظ {0:N0} تسلسلًا بعناوينها وأسماء ملفاتها: ملفات هذه التسلسلات من إصدار أحدث من Chronos. + احتفظ تسلسل واحد بعنوانه وأسماء ملفاته: ملف التسلسل من إصدار أحدث من Chronos. + احتفظ {0:N0} تسلسل بعناوينها وأسماء ملفاتها: ملفات هذه التسلسلات من إصدار أحدث من Chronos. تغيّر {0} بعد إعداد الخطة. البطاقة أو المجلد {0} لم يعد متاحًا. تغيّر الأرشيف بعد إعداد هذه الخطة. @@ -178,6 +191,14 @@ صور غير مفهرسة: {0}، صور مفقودة: {1} {0}: أُنشئ {1}، وأُعيد استخدام {2}، وتعذّرت قراءة {3}، و{4} في الانتظار النسخ الوكيلة للخادم: أُرسل {0}، ولم يُرسل {1} + تُرك كما كان، إذ بقي المجلد الذي يحتويه في مكانه: {0} + تُرك كما كان، إذ تغيّر بعد إعداد الخطة: {0} + احتُفظ بأسماء الملفات، إذ كانت إحدى الصور قيد الاستخدام أو كان اسمها الجديد مستخدمًا بالفعل: {0} + احتُفظ بأسماء الملفات، إذ تغيّرت الصور بعد إعداد الخطة: {0} + احتُفظ بالعنوان وأسماء الملفات، إذ إن ملف التسلسل من إصدار أحدث من Chronos: {0} + احتُفظ بالعنوان وأسماء الملفات، إذ تغيّر التسلسل بعد إعداد الخطة: {0} + التسلسلات المتغيرة: {0}، الملفات المُعاد تسميتها: {1} + اكتملت إعادة التنظيم عند فتح الأرشيف تقرير فقط: لم يُغيَّر شيء. المجلدات: {0}، المفهرسة: {1}، المضمومة: {2}، المُزالة: {3} لم يُعثر على التسلسل: {0} @@ -238,20 +259,38 @@ مجلد الأرشيف المنقول تطبيق {0} من {1} - إعادة تسمية {0:N0} تسلسلات - إعادة تسمية {0:N0} تسلسلًا - إعادة تسمية تسلسل واحد - إعادة تسمية {0:N0} تسلسل - نقل {0:N0} تسلسلات - نقل {0:N0} تسلسلًا - نقل تسلسل واحد - نقل {0:N0} تسلسل التغييرات يتغير {0:N0} من {1:N0} يتغير {0:N0} من {1:N0} يتغير {0:N0} من {1:N0} يتغير {0:N0} من {1:N0} - القالب + تحتفظ الصور المتروكة في مكانها خارج originals بأسمائها. + تحتفظ الصور المفقودة بأسمائها. + تحتفظ الصور التي لم يُتحقق منها قط بأسمائها؛ تحقق من التسلسل أولًا. + تتعذر قراءة ملف التسلسل؛ يبقى التسلسل كما هو، وكذلك أي مجلد يحتويه. + يتبع مجلده + {0}: من {1} إلى {2} + الملف + أسماء الملفات + المجلد + المجلدات + إعادة تنظيم {0:N0} تسلسلات + إعادة تنظيم {0:N0} تسلسلًا + إعادة تنظيم تسلسل واحد + إعادة تنظيم {0:N0} تسلسل + إعادة تنظيم {0} + احتُفظ بـ {0:N0} أسماء + احتُفظ بـ {0:N0} اسمًا + احتُفظ باسم واحد + احتُفظ بـ {0:N0} اسم + تشغيل تجريبي… + أُعيدت تسمية {0:N0} ملفات + أُعيدت تسمية {0:N0} ملفًا + أُعيدت تسمية ملف واحد + أُعيدت تسمية {0:N0} ملف + العنوان + العناوين + ستُفتح «إعادة التنظيم» عند إغلاق مربع الحوار المفتوح إضافة وسوم تطبيق وسوم {0:N0} تسلسلات @@ -270,9 +309,8 @@ تصدير CSV تصفية المجموعة المجموعة المصفّاة - نقل… النسخ الوكيلة - إعادة تسمية… + إعادة التنظيم… تعديل الوسوم… الصور المصغرة تحقق diff --git a/i18n/ar/Errors.ar.resx b/i18n/ar/Errors.ar.resx index 71a65ca0..361747ba 100644 --- a/i18n/ar/Errors.ar.resx +++ b/i18n/ar/Errors.ar.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 تسلسلات لم تُحلَّل: {0} من {1}؛ راجع سجل المهمة. + مجلد هذا التسلسل ليس في الموضع المسجل في الفهرس؛ حاول مرة أخرى بعد الفحص التالي. تعذّر فتح الأرشيف. تعذّر نسخ الفهرس الحالي احتياطيًا أو استبداله؛ ستُعاد محاولة الاستعادة عند البدء التالي. لا يمكن استعادة هذه النسخة الاحتياطية؛ اختر نسخة أخرى. @@ -41,9 +42,11 @@ {0} من الملفات الأصلية مفقودة أو تغيّرت منذ أرشفتها؛ تحقق من الأرشيف. القالب فارغ. رمز فارغ في الموضع {1}: اكتب اسمًا بين القوسين المعقوفين. + ستفقد الصور امتدادها: اكتب نقطة قبل {ext}، أو احذف {ext}. لا يمكن أن تحتوي أسماء الملفات على شرطة مائلة؛ ضع المجلدات في قالب المجلدات. التنسيق بعد النقطتين لا يناسب رمزه. ستتكرر الأسماء: أضف رقم الإطار أو الوقت أو الاسم الأصلي. + يتخطى الفحص المجلدات التي يبدأ اسمها بنقطة أو التي اسمها originals أو proxies أو exports. القوس المعقوف المفتوح في الموضع {1} لا يُغلق أبدًا. رمز غير معروف «{0}» في الموضع {1}. قوس الإغلاق المعقوف في الموضع {1} ليس له قوس فتح؛ كرّره لكتابة قوس حرفي. diff --git a/i18n/ar/Jobs.ar.resx b/i18n/ar/Jobs.ar.resx index 31a41df1..6a045298 100644 --- a/i18n/ar/Jobs.ar.resx +++ b/i18n/ar/Jobs.ar.resx @@ -78,7 +78,7 @@ استيراد تحليل سريع صيانة - نقل الأرشيف + إعادة التنظيم ملفات يتيمة نسخ وكيلة إعادة بناء الفهرس diff --git a/i18n/ar/Library.ar.resx b/i18n/ar/Library.ar.resx index d33c554a..40326b07 100644 --- a/i18n/ar/Library.ar.resx +++ b/i18n/ar/Library.ar.resx @@ -10,17 +10,16 @@ تنزيل تصدير القائمة المجلد - نقل… فتح النسخ الوكيلة التقييم تصيير + إعادة التنظيم… مزامنة الوسوم… رفع تحقق ضم مجلد - يعمل النقل على تسلسلات أرشيف واحد في كل مرة. متطابق على هذا الكمبيوتر وعلى الخادم: لا شيء للمزامنة. لا توجد طريقة عرض محفوظة قيد الاستخدام؛ اختر واحدة أولًا. لا يملك حسابك على الخادم صلاحية تنزيل الملفات الأصلية. @@ -32,6 +31,7 @@ سجّل الدخول إلى خادم Chronos أولًا، من شاشة «الخادم». لا يوجد ما يُجلب من الخادم للتسلسلات المحددة. لدى الخادم بالفعل كل ما تحتويه التسلسلات المحددة. + تعمل إعادة التنظيم على تسلسلات أرشيف واحد في كل مرة. للتسلسلات الموجودة على هذا الكمبيوتر فقط؛ والتسلسلات المحددة موجودة على الخادم فقط. تجري بالفعل عملية نقل لهذا التسلسل. مسح عوامل التصفية diff --git a/i18n/ar/Server.ar.resx b/i18n/ar/Server.ar.resx index 7a026c2e..f3b3cf66 100644 --- a/i18n/ar/Server.ar.resx +++ b/i18n/ar/Server.ar.resx @@ -40,6 +40,7 @@ فشل الاتصال؛ التفاصيل في السجل. أحد ملفات التسلسل مفتوح في برنامج آخر؛ أغلقه وحاول مرة أخرى. لم يعد مجلده موجودًا على القرص؛ فلم يبقَ شيء لنقله إلى سلة المحذوفات. + مجلد هذا التسلسل ليس في الموضع المسجل في فهرس الخادم؛ حاول مرة أخرى بعد الفحص التالي للخادم. لا يملك حسابك صلاحية القيام بذلك. تغيّرت صور التسلسل على الخادم؛ أعد تحميله وطبّق تعديلك مجددًا. وصل الملف تالفًا؛ ارفعه مرة أخرى. @@ -68,11 +69,14 @@ لا يستطيع هذا الخادم تشغيل هذا النوع من المهام. لا يمكن إزالة آخر مسؤول أو تعطيله. هذا الأسلوب غير مسموح به هنا. + سيقع مجلد جديد داخل مجلد تسلسل آخر. هذا العنوان ليس خادم Chronos. غير موجود. غيّر كلمة المرور أولًا. حُذفت الصورة من التسلسل أثناء رفعها، لذا لم تُضَف. تتعذر قراءة {0}، ودون تجزئته لن تعرف النسخ الأخرى أنه حُذف؛ أغلق البرنامج الذي يستخدمه أو تحقق من أذوناته، ثم حاول مرة أخرى. + تغيّر الأرشيف بعد التشغيل التجريبي؛ راجع الخطة مجددًا. + توقف الخادم عن إعداد هذه الخطة: فقد استغرقت وقتًا طويلًا جدًا، أو طُلبت خطط كثيرة جدًا في وقت واحد؛ حاول مرة أخرى بعد قليل. لا يُنشئ هذا الأرشيف نسخًا وكيلة. أُنشئت النسخة الوكيلة من صورة أخرى. لا يحتاج الخادم إلى نسخة وكيلة من هذه الصورة. diff --git a/i18n/ar/Settings.ar.resx b/i18n/ar/Settings.ar.resx index b22f473e..5e802570 100644 --- a/i18n/ar/Settings.ar.resx +++ b/i18n/ar/Settings.ar.resx @@ -67,6 +67,7 @@ نجوم لكل ميغابكسل عرض التحليل بكسل للضلع الطويل + تحتفظ المجلدات والملفات الموجودة بالفعل في الأرشيف بأسمائها. أسماء الملفات المجلدات {0} متاحة @@ -76,10 +77,12 @@ اختيار مجلد الأرشيف معاينة حجم النسخ الوكيلة + إعادة التنظيم… إعادة تعيين الأرشيف تعود قوالب التسمية وحجم النسخ الوكيلة وحجم الصور المصغرة فيه إلى قيمها الافتراضية لكل كمبيوتر وخادم يستخدمه. وتحتفظ المجلدات والملفات الموجودة بالفعل في الأرشيف بأسمائها. إعادة تعيين إعدادات {0}؟ مجلد الأرشيف + حُفظت قوالب الأرشيف حجم الصور المصغرة العودة إلى «تلقائي» اختيار مجلد diff --git a/i18n/ar/Tooltips.ar.resx b/i18n/ar/Tooltips.ar.resx index 9d65cfe5..4068b5cd 100644 --- a/i18n/ar/Tooltips.ar.resx +++ b/i18n/ar/Tooltips.ar.resx @@ -38,6 +38,7 @@ فتح تسلسل النسخة الأولى في «التحرير» البحث عن الصور المتطابقة عبر التسلسلات بواسطة التجزئة · يقرأ الفهرس فقط إظهار تسلسلات هذه السنة + اسم ملف كل صورة، كما تسميها عمليات الاستيراد · يُتحقق منه أثناء الكتابة الإبقاء على تسلسلات كاميرا واحدة فقط اختيار هذه القيمة؛ اخترها مجددًا لمسحها الإبقاء على التسلسلات التي في حالة واحدة فقط @@ -73,7 +74,10 @@ إعادة بناء الفهرس من الملفات المرافقة، مع اللجوء إلى فحص كامل للبيانات الوصفية عند الحاجة؛ ولا تُحذف الملفات الأصلية أبدًا إضافة إعادة البناء إلى قائمة الانتظار · يبقى الأرشيف قابلًا للاستخدام في أثناء ذلك اختيار المجلد الجديد لأرشيف نقلته؛ وتتبعه تسلسلاته - إجراء هذه التغييرات بالضبط على المجلدات والملفات المرافقة والفهرس · يُستأنف بعد أي تعطل مفاجئ + إضافة مهمة تُجري هذه التغييرات بالضبط إلى قائمة الانتظار · يمكنك إيقافها مؤقتًا واستئنافها في «المهام» + إعادة تسمية الصور بهذا القالب · عند الإيقاف تحتفظ بأسمائها + نقل مجلدات التسلسلات إلى هذا التنظيم · عند الإيقاف تبقى في مكانها + تغيير العناوين بهذا القالب · عند الإيقاف تبقى كما هي اختيار نسخة احتياطية من الفهرس في «الإعدادات › متقدم»؛ وتحل محل الفهرس عند البدء التالي تغيير وسوم هذه التسلسلات في الملفات المرافقة والفهرس تشغيل الإجراء نفسه مجددًا @@ -82,9 +86,8 @@ تشغيل التحليل المعمّق على كل تسلسل في المجموعة نقل المجموعة إلى سلة محذوفات الأرشيف · يعرض التشغيل التجريبي، ثم يطلب منك الكتابة للتأكيد تصدير المجموعة كملف CSV: صف واحد لكل تسلسل - نقل المجموعة إلى بنية مجلدات جديدة · بتشغيل تجريبي أولًا إنشاء النسخ الوكيلة أو تحديثها - إعادة تسمية عناوين المجموعة باستخدام قالب · بتشغيل تجريبي أولًا + تطبيق قوالب المجلدات والملفات والعناوين على المجموعة · بتشغيل تجريبي أولًا، ثم عبر مهمة إضافة وسوم إلى المجموعة كلها أو إزالتها منها إنشاء الصور المصغرة أو تحديثها إعادة حساب تجزئة الملفات الأصلية للمجموعة @@ -485,10 +488,6 @@ حفظ {0:N0} صفًا كملف CSV في مجلد تختاره حفظ صف واحد كملف CSV في مجلد تختاره حفظ {0:N0} صف كملف CSV في مجلد تختاره - نقل {0:N0} تسلسلات إلى بنية مجلدات جديدة في أرشيفها · يعرض التشغيل التجريبي أولًا - نقل {0:N0} تسلسلًا إلى بنية مجلدات جديدة في أرشيفها · يعرض التشغيل التجريبي أولًا - نقل تسلسل واحد إلى بنية مجلدات جديدة في أرشيفه · يعرض التشغيل التجريبي أولًا - نقل {0:N0} تسلسل إلى بنية مجلدات جديدة في أرشيفها · يعرض التشغيل التجريبي أولًا إنشاء نسخ وكيلة بتنسيق JPEG لـ {0:N0} تسلسلات · يعمل كمهمة واحدة إنشاء نسخ وكيلة بتنسيق JPEG لـ {0:N0} تسلسلًا · يعمل كمهمة واحدة إنشاء نسخ وكيلة بتنسيق JPEG لتسلسل واحد · يعمل كمهمة واحدة @@ -497,6 +496,10 @@ تعيين تقييم {0:N0} تسلسلًا في ملفاتها المرافقة وفي الفهرس تعيين تقييم تسلسل واحد في ملفه المرافق وفي الفهرس تعيين تقييم {0:N0} تسلسل في ملفاتها المرافقة وفي الفهرس + تطبيق قوالب المجلدات والملفات والعناوين على {0:N0} تسلسلات في أرشيفها · بتشغيل تجريبي أولًا، ثم عبر مهمة + تطبيق قوالب المجلدات والملفات والعناوين على {0:N0} تسلسلًا في أرشيفها · بتشغيل تجريبي أولًا، ثم عبر مهمة + تطبيق قوالب المجلدات والملفات والعناوين على تسلسل واحد في أرشيفه · بتشغيل تجريبي أولًا، ثم عبر مهمة + تطبيق قوالب المجلدات والملفات والعناوين على {0:N0} تسلسل في أرشيفها · بتشغيل تجريبي أولًا، ثم عبر مهمة إضافة وسوم إلى {0:N0} تسلسلات أو إزالتها منها إضافة وسوم إلى {0:N0} تسلسلًا أو إزالتها منها إضافة وسوم إلى تسلسل واحد أو إزالتها منه @@ -730,6 +733,7 @@ «متوازن» يناسب معظم الأعمال؛ «الأفضل» يقيس بضعف الدقة ويقرأ مسبقًا لمسافة أبعد؛ «سريع» يقيس بنصف الدقة مع حركة تقريبية سرد المرمّزات مجددًا بعد تثبيت برنامج تشغيل أو برنامج ترميز البحث عن ملحقات برامج الترميز مجددًا بعد تثبيت أحدها؛ وتستخدمها المهام التالية + تطبيق قوالب الأرشيف على التسلسلات الموجودة فيه بالفعل · بتشغيل تجريبي أولًا إعادة كل إعدادات هذا الكمبيوتر إلى قيمها الافتراضية؛ مع طلب التأكيد أولًا كتابة القوالب والأحجام الافتراضية في ملف archive.json الخاص بهذا الأرشيف الآن إعادة تعيين كل الإعدادات الآن diff --git a/i18n/bg/Admin.bg.resx b/i18n/bg/Admin.bg.resx index b39e9939..2e697e7a 100644 --- a/i18n/bg/Admin.bg.resx +++ b/i18n/bg/Admin.bg.resx @@ -9,6 +9,7 @@ Chronos Server Време на работа Версия + {0} реорганизира архива · {1} {0} промени структурата на архива {0} изтри {1} {0} стартира {1} @@ -138,7 +139,7 @@ Импортиране Бърз анализ Поддръжка - Преместване + Реорганизиране Осиротели файлове Прокси Преизграждане @@ -343,6 +344,7 @@ Влизане за администриране на този сървър Потребител Вашето потребителско име на този сървър + Реорганизиран архив Структура на архива Изтрити снимки Стартирана задача @@ -426,6 +428,58 @@ Смяна на паролата Заменя паролата и продължава към панела Изберете нова парола + Реорганизиране… + Прилага шаблоните за папки, файлове и заглавия към избраните серии; визуализацията първо показва всяка промяна + След: + Прилагане… + Реорганизира според визуализацията; първо се иска потвърждение + Преди: + Напишете шаблон или изключете тази част. + Затваря, без да променя нищо + С родителската папка + Премества се само защото се премества папка, в която се намира + Преименувани файлове + Папка + Серия + Реорганизиране + Поставя на опашка задачата, която премества и преименува оригиналите; нищо не се презаписва и не се изтрива + {0} снимка получава ново име. + {0} снимки получават нови имена. + {0} папка се премества. + {0} папки се преместват. + {0} серия се променя. + {0} серии се променят. + Да се реорганизира ли сега? + Име на всяка снимка, каквото ѝ дава импортирането, например {date}_{time}_{n:0000}; файловете до снимката я следват + Файлове + Преименува снимките на всяка серия; ако е изключено, всички имена на файлове се запазват + {0} преименуван файл + {0} преименувани файла + Папка на всяка серия в архива, например {year}/{date} {camera}; {title} е новото заглавие + Папки + Премества всяка серия в папката, която дава шаблонът ѝ; ако е изключено, всяка папка остава на мястото си + Една от избраните серии вече не е в архива; затворете и изберете отново. + {0}: {1} + Включете поне една част, която да се промени. + Няма какво да се промени: тези серии вече следват шаблоните. + Реорганизиране… + Прилага новите шаблони към сериите, които вече са в архива; визуализацията първо показва всяка промяна + Отваряне на задачата + Показва задачата и журнала ѝ на страницата „Задачи“ + Архивът се промени по време на потвърждението; проверете новата визуализация и приложете отново. + Планиране… + Визуализация + Какво ще стане с всяка серия, в реда на прилагане на промените; още нищо не е променено + Реорганизирането е на опашка. + Тази папка остава на мястото си + Реорганизиране на {0} серия + Реорганизиране на {0} серии + Реорганизиране на всички серии + Ново заглавие на всяка серия, например {date} {camera}; {title} е текущото заглавие + Заглавия + Дава на всяка серия заглавието, което създава шаблонът ѝ; ако е изключено, всички заглавия се запазват + Реорганизирането обработва най-много {0} серии наведнъж или всички серии: изчистете филтрите и изберете всички. + Променени серии: {0} · преименувани файлове: {1} · запазени имена: {2} Администратор Редактор Качващ diff --git a/i18n/bg/Archive.bg.resx b/i18n/bg/Archive.bg.resx index 22e2bdc2..13e12905 100644 --- a/i18n/bg/Archive.bg.resx +++ b/i18n/bg/Archive.bg.resx @@ -15,6 +15,7 @@ Изчакайте промените да бъдат приложени. Наборът е празен: променете избора или филтъра. Нищо няма да се промени. + Включете поне един шаблон. Архивът трябва да е онлайн и да позволява запис. Изчакайте пробното изпълнение. Изчакайте архивът да бъде прочетен. @@ -81,6 +82,12 @@ {0} е записан от по-нова версия на Chronos (формат {1}). Архивът {0} е офлайн. Архивът {0} е само за четене. + {0:N0} серия запази имената на файловете си: снимка се използваше или новото ѝ име вече беше заето. + {0:N0} серии запазиха имената на файловете си: снимка се използваше или новото ѝ име вече беше заето. + {0:N0} серия не беше реорганизирана според плана: промени се след създаването му. + {0:N0} серии не бяха реорганизирани според плана: промениха се след създаването му. + {0:N0} серия запази заглавието и имената на файловете си: файлът на серията е от по-нова версия на Chronos. + {0:N0} серии запазиха заглавията и имената на файловете си: файловете на сериите са от по-нова версия на Chronos. {0} се промени след създаването на плана. Картата или папката {0} вече не е достъпна. Архивът се промени след създаването на този план. @@ -146,6 +153,14 @@ Неиндексирани снимки: {0}, липсващи снимки: {1} {0}: създадени {1}, използвани повторно {2}, нечетими {3}, изчакващи {4} Прокси за сървъра – изпратени: {0}, неизпратени: {1} + Оставена както беше, папката, в която се намира, остана на мястото си: {0} + Оставена както беше, променена след създаването на плана: {0} + Имената на файловете са запазени, снимка се използваше или новото ѝ име вече беше заето: {0} + Имената на файловете са запазени, снимките са променени след създаването на плана: {0} + Заглавието и имената на файловете са запазени, файлът на серията е от по-нова версия на Chronos: {0} + Заглавието и имената на файловете са запазени, серията е променена след създаването на плана: {0} + Променени серии: {0}, преименувани файлове: {1} + Реорганизирането беше завършено при отварянето на архива Само отчет: нищо не е променено. Папки: {0}, индексирани: {1}, присъединени: {2}, премахнати: {3} Серията не е намерена: {0} @@ -200,14 +215,30 @@ Папка на преместения архив Прилагане {0} от {1} - Преименуване на {0:N0} серия - Преименуване на {0:N0} серии - Преместване на {0:N0} серия - Преместване на {0:N0} серии Промени {0:N0} от {1:N0} се променя {0:N0} от {1:N0} се променят - Шаблон + Снимките, оставени на място извън originals, запазват имената си. + Липсващите снимки запазват имената си. + Снимките, които никога не са проверявани, запазват имената си; първо проверете серията. + Файлът на серията не може да бъде прочетен; серията остава както е, както и всяка папка, в която се намира. + Следва папката си + {0}: от {1} на {2} + Файл + Имена на файлове + Папка + Папки + Реорганизиране на {0:N0} серия + Реорганизиране на {0:N0} серии + Реорганизиране на {0} + {0:N0} запазено име + {0:N0} запазени имена + Пробно изпълнение… + {0:N0} преименуван файл + {0:N0} преименувани файла + Заглавие + Заглавия + „Реорганизиране“ ще се отвори, когато отвореният диалогов прозорец се затвори Добавяне на етикети Прилагане Етикети на {0:N0} серия @@ -222,9 +253,8 @@ Експортиране в CSV Филтър на набора Филтриран набор - Преместване… Прокси - Преименуване… + Реорганизиране… Етикети… Миниатюри Проверка diff --git a/i18n/bg/Errors.bg.resx b/i18n/bg/Errors.bg.resx index 8c45acf9..82a333de 100644 --- a/i18n/bg/Errors.bg.resx +++ b/i18n/bg/Errors.bg.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Неанализирани серии: {0} от {1}; вижте журнала на задачата. + Папката на тази серия не е там, където я сочи индексът; опитайте отново след следващото сканиране. Архивът не можа да бъде отворен. Не можа да се създаде резервно копие на текущия индекс или той не можа да бъде заменен; възстановяването ще се изпълни отново при следващото стартиране. Това резервно копие не може да бъде възстановено; изберете друго. @@ -37,9 +38,11 @@ {0} оригинала липсват или са променени, откакто са добавени в архива; проверете архива. Шаблонът е празен. Празно поле на позиция {1}: напишете име между фигурните скоби. + Снимките ще загубят разширението си: напишете точка преди {ext} или премахнете {ext}. Имената на файлове не могат да съдържат наклонена черта; поставете папките в шаблона за папки. Форматът след двоеточието не подхожда на полето си. Имената биха се повтаряли: добавете номера на кадъра, часа или оригиналното име. + Сканирането пропуска папките, които започват с точка или се казват originals, proxies или exports. Скобата, отворена на позиция {1}, не е затворена. Непознато поле „{0}“ на позиция {1}. Затварящата скоба на позиция {1} няма отваряща; удвоете я за буквална скоба. diff --git a/i18n/bg/Jobs.bg.resx b/i18n/bg/Jobs.bg.resx index 68525fae..e38fe5a4 100644 --- a/i18n/bg/Jobs.bg.resx +++ b/i18n/bg/Jobs.bg.resx @@ -76,7 +76,7 @@ Импортиране Бърз анализ Поддръжка - Преместване на архива + Реорганизиране Осиротели файлове Прокси Преизграждане на индекса diff --git a/i18n/bg/Library.bg.resx b/i18n/bg/Library.bg.resx index 670a6cb5..b7c5e5ea 100644 --- a/i18n/bg/Library.bg.resx +++ b/i18n/bg/Library.bg.resx @@ -10,17 +10,16 @@ Изтегляне Експортиране на списъка Папка - Преместване… Отваряне Прокси Оценка Рендериране + Реорганизиране… Синхронизиране Етикети… Качване Проверка Присъединяване на папка - Преместването работи със серии само от един архив наведнъж. Еднаква на този компютър и на сървъра: няма какво да се синхронизира. Няма активен записан изглед; първо изберете такъв. Вашият акаунт на сървъра не може да изтегля оригинали. @@ -32,6 +31,7 @@ Първо влезте в Chronos Server от екрана „Сървър“. Избраните серии нямат какво да изтеглят от сървъра. Сървърът вече има всичко, което съдържат избраните серии. + Реорганизирането работи със сериите на един архив наведнъж. Само за серии на този компютър; избраното се намира на сървъра. Вече тече трансфер на тази серия. Изчистване на филтрите diff --git a/i18n/bg/Server.bg.resx b/i18n/bg/Server.bg.resx index 6e2692da..b119b515 100644 --- a/i18n/bg/Server.bg.resx +++ b/i18n/bg/Server.bg.resx @@ -40,6 +40,7 @@ Връзката е неуспешна; подробностите са в журнала. Файл от серията е отворен в друга програма; затворете го и опитайте отново. Папката на серията вече не е на диска; няма какво да се премести в кошчето. + Папката на тази серия не е там, където я сочи индексът на сървъра; опитайте отново след следващото му сканиране. Вашият акаунт няма право да прави това. Снимките на серията се промениха на сървъра; презаредете я и приложете редакцията си отново. Файлът е пристигнал повреден; качете го отново. @@ -68,11 +69,14 @@ Този сървър не може да изпълнява такъв тип задачи. Последният администратор не може да бъде премахнат или деактивиран. Този метод не е разрешен тук. + Нова папка ще се окаже в папката на друга серия. Този адрес не е на Chronos Server. Не е намерено. Първо сменете паролата си. Снимката е изтрита от серията, докато се е качвала, затова не е добавена. Файлът {0} не може да бъде прочетен, а без хеша му другите копия няма да разберат, че е изтрит; затворете програмата, която го използва, или проверете разрешенията му, след което опитайте отново. + Архивът се промени след пробното изпълнение; прегледайте плана отново. + Сървърът спря да подготвя този план: отне твърде много време или бяха поискани твърде много наведнъж; опитайте отново след малко. Този архив не създава прокси. Прокси файлът е създаден от друга снимка. Сървърът няма нужда от прокси на тази снимка. diff --git a/i18n/bg/Settings.bg.resx b/i18n/bg/Settings.bg.resx index ea470756..6fb252ef 100644 --- a/i18n/bg/Settings.bg.resx +++ b/i18n/bg/Settings.bg.resx @@ -65,6 +65,7 @@ звезди на мегапиксел Ширина за анализ пикс. по дългата страна + Папките и файловете, които вече са в архива, запазват имената си. Имена на файлове Папки {0} свободни @@ -74,10 +75,12 @@ Изберете папката на архива Визуализация Размер на прокси + Реорганизиране… Нулиране на архива Шаблоните за имена, размерът на прокси и размерът на миниатюрите се връщат към стойностите по подразбиране за всеки компютър и сървър, който използва архива. Папките и файловете, които вече са в архива, запазват имената си. Нулиране на настройките на {0}? Папка на архива + Шаблоните на архива са записани Размер на миниатюрите Връщане към „Авто“ Избор на папка diff --git a/i18n/bg/Tooltips.bg.resx b/i18n/bg/Tooltips.bg.resx index 568b033d..dbc2f05e 100644 --- a/i18n/bg/Tooltips.bg.resx +++ b/i18n/bg/Tooltips.bg.resx @@ -36,6 +36,7 @@ Отваря серията на първото копие в екрана „Редактиране“ Намира еднакви снимки в различни серии по хеш · чете само индекса Показва сериите от тази година + Име на файла на всяка снимка, както го задава импортирането · проверява се, докато пишете Оставя само сериите от един фотоапарат Избира тази стойност; изберете я отново, за да я изчистите Оставя само сериите в едно състояние @@ -71,7 +72,10 @@ Преизгражда индекса от sidecar файловете; при липса прави пълно сканиране на метаданните; никога не изтрива оригинали Поставя преизграждането на опашка · междувременно архивът остава използваем Избира новата папка на архив, който сте преместили; сериите му го следват - Прилага точно тези промени към папките, sidecar файловете и индекса · продължава след срив + Поставя на опашка задача, която прави точно тези промени · можете да я поставите на пауза и да я възобновите в „Задачи“ + Преименува снимките с този шаблон · ако е изключено, те запазват имената си + Премества папките на сериите в тази структура · ако е изключено, остават на мястото си + Променя заглавията с този шаблон · ако е изключено, остават такива, каквито са Изберете резервно копие на индекса в Настройки › Разширени; то заменя индекса при следващото стартиране Променя етикетите на тези серии в sidecar файловете и индекса Изпълнява същото действие отново @@ -80,9 +84,8 @@ Изпълнява задълбочения анализ за всяка серия в набора Премества набора в кошчето на архива · показва пробното изпълнение, след което ви моли да потвърдите чрез въвеждане Експортира набора като CSV: по един ред на серия - Премества набора в нова структура на папките · първо пробно изпълнение Създава или обновява прокси - Преименува заглавията в набора по шаблон · първо пробно изпълнение + Прилага шаблоните за папки, файлове и заглавия към набора · първо пробно изпълнение, след това задача Добавя или премахва етикети в целия набор Създава или обновява миниатюрите Хешира отново оригиналите в набора @@ -471,12 +474,12 @@ Изтегля от сървъра това, което липсва тук на {0:N0} серии (оригинали или рендери) · изпълнява се като задачи за трансфер Записва {0:N0} ред като CSV в избрана от вас папка Записва {0:N0} реда като CSV в избрана от вас папка - Премества {0:N0} серия в нова структура на папките на нейния архив · първо показва пробното изпълнение - Премества {0:N0} серии в нова структура на папките на техния архив · първо показва пробното изпълнение Създава JPEG прокси за {0:N0} серия · изпълнява се като една задача Създава JPEG прокси за {0:N0} серии · изпълнява се като една задача Задава оценката на {0:N0} серия в нейния sidecar файл и в индекса Задава оценката на {0:N0} серии в техните sidecar файлове и в индекса + Прилага шаблоните за папки, файлове и заглавия към {0:N0} серия от нейния архив · първо пробно изпълнение, след това задача + Прилага шаблоните за папки, файлове и заглавия към {0:N0} серии от техния архив · първо пробно изпълнение, след това задача Добавя или премахва етикети на {0:N0} серия Добавя или премахва етикети на {0:N0} серии Изпраща към сървъра това, което му липсва от {0:N0} серия (оригинали и настройки или само рендери) · изпълнява се като задача за трансфер @@ -692,6 +695,7 @@ „Балансиран“ е подходящ в повечето случаи; „Най-добър“ измерва при двойна резолюция и чете повече кадри напред; „Бърз“ измерва при половин резолюция с чернова на движението Изброява кодерите отново след инсталиране на драйвер или кодек Търси отново разширения за кодеци след инсталиране на такова; следващите задачи ги използват + Прилага шаблоните на архива към сериите, които вече са в него · първо пробно изпълнение Връща всички настройки на този компютър към стойностите по подразбиране; първо пита Записва сега шаблоните и размерите по подразбиране в archive.json на този архив Нулира всички настройки сега diff --git a/i18n/cs/Admin.cs.resx b/i18n/cs/Admin.cs.resx index 976d4380..aa0d2d03 100644 --- a/i18n/cs/Admin.cs.resx +++ b/i18n/cs/Admin.cs.resx @@ -9,6 +9,7 @@ Chronos Server Doba provozu Verze + Uživatel {0} reorganizoval archiv · {1} Uživatel {0} změnil uspořádání archivu Uživatel {0} odstranil {1} Uživatel {0} spustil úlohu {1} @@ -147,7 +148,7 @@ Import Rychlá analýza Údržba - Přesun + Reorganizace Osiřelé soubory Proxy Sestavení indexu @@ -367,6 +368,7 @@ Přihlásí vás ke správě tohoto serveru Uživatel Vaše uživatelské jméno na tomto serveru + Reorganizace archivu Uspořádání archivu Odstranění fotografií Spuštění úlohy @@ -452,6 +454,63 @@ Změnit heslo Nahradí heslo a pokračuje do panelu Zvolte nové heslo + Reorganizovat… + Použije šablony složek, souborů a názvů na vybrané sekvence; náhled nejprve zobrazí každou změnu + Po: + Použít… + Reorganizuje podle náhledu; nejprve požádá o potvrzení + Před: + Napište šablonu, nebo tuto část vypněte. + Zavře dialog beze změn + S nadřazenou složkou + Přesune se jen proto, že se přesouvá složka, ve které leží + Přejmenované soubory + Složka + Sekvence + Reorganizovat + Zařadí do fronty úlohu, která přesune a přejmenuje originály; nic se nepřepíše ani neodstraní + {0} fotografie dostanou nové názvy. + {0} fotografie dostane nový název. + {0} fotografií dostane nové názvy. + Přesunou se {0} složky. + Přesune se {0} složka. + Přesune se {0} složek. + Změní se {0} sekvence. + Změní se {0} sekvence. + Změní se {0} sekvencí. + Reorganizovat nyní? + Název každé fotografie, jaký jí dá import, např. {date}_{time}_{n:0000}; soubory vedle fotografie ji následují + Soubory + Přejmenuje fotografie každé sekvence; když je vypnuto, všechny názvy souborů zůstanou + {0} soubory přejmenovány + {0} soubor přejmenován + {0} souborů přejmenováno + Složka každé sekvence v archivu, např. {year}/{date} {camera}; {title} je nový název + Složky + Přesune každou sekvenci do složky podle její šablony; když je vypnuto, každá složka zůstane na místě + Vybraná sekvence už v archivu není; zavřete dialog a vyberte znovu. + {0}: {1} + Zapněte alespoň jednu část, kterou chcete změnit. + Není co měnit: tyto sekvence už šablonám odpovídají. + Reorganizovat… + Použije nové šablony na sekvence, které už jsou v archivu; náhled nejprve zobrazí každou změnu + Otevřít úlohu + Zobrazí úlohu a její protokol na stránce Úlohy + Archiv se během potvrzování změnil; zkontrolujte nový náhled a použijte změny znovu. + Plánování… + Náhled + Jak bude každá sekvence vypadat, v pořadí, v jakém se změny použijí; zatím se nic nezměnilo + Reorganizace je ve frontě. + Tato složka zůstane na místě + Reorganizovat {0} sekvence + Reorganizovat {0} sekvenci + Reorganizovat {0} sekvencí + Reorganizovat všechny sekvence + Nový název každé sekvence, např. {date} {camera}; {title} je aktuální název + Názvy + Dá každé sekvenci název vytvořený její šablonou; když je vypnuto, všechny názvy zůstanou + Reorganizace zpracuje najednou nejvýše {0} sekvencí, nebo všechny sekvence: zrušte filtry a vyberte vše. + Změněné sekvence: {0} · přejmenované soubory: {1} · ponechané názvy: {2} Správce Editor Nahrávač diff --git a/i18n/cs/Archive.cs.resx b/i18n/cs/Archive.cs.resx index 5d54cfcc..a014c703 100644 --- a/i18n/cs/Archive.cs.resx +++ b/i18n/cs/Archive.cs.resx @@ -16,6 +16,7 @@ Počkejte, až se změny použijí. Sada je prázdná: změňte výběr nebo filtr. Nic by se nezměnilo. + Zapněte alespoň jednu šablonu. Archiv musí být online a zapisovatelný. Počkejte na zkušební běh. Počkejte, až se archiv načte. @@ -91,6 +92,15 @@ Soubor {0} zapsala novější verze Chronos (formát {1}). Archiv {0} je offline. Archiv {0} je jen pro čtení. + {0:N0} sekvence si ponechaly názvy souborů: některá fotografie se používala nebo byl její nový název obsazený. + {0:N0} sekvence si ponechala názvy souborů: některá fotografie se používala nebo byl její nový název obsazený. + {0:N0} sekvencí si ponechalo názvy souborů: některá fotografie se používala nebo byl její nový název obsazený. + {0:N0} sekvence nebyly reorganizovány podle plánu: po vytvoření plánu se změnily. + {0:N0} sekvence nebyla reorganizována podle plánu: po vytvoření plánu se změnila. + {0:N0} sekvencí nebylo reorganizováno podle plánu: po vytvoření plánu se změnily. + {0:N0} sekvence si ponechaly své názvy i názvy souborů: jejich soubory sekvencí pocházejí z novější verze Chronos. + {0:N0} sekvence si ponechala svůj název i názvy souborů: její soubor sekvence pochází z novější verze Chronos. + {0:N0} sekvencí si ponechalo své názvy i názvy souborů: jejich soubory sekvencí pocházejí z novější verze Chronos. Zdroj {0} se po vytvoření plánu změnil. Karta nebo složka {0} už není k dispozici. Archiv se po vytvoření tohoto plánu změnil. @@ -162,6 +172,14 @@ Neindexované fotografie: {0}, chybějící fotografie: {1} {0} — vytvořeno: {1}, znovu použito: {2}, nečitelné: {3}, čekající: {4} Proxy pro server — odesláno: {0}, neodesláno: {1} + Ponecháno, jak bylo, složka, ve které leží, zůstala na místě: {0} + Ponecháno, jak bylo, po vytvoření plánu se změnilo: {0} + Názvy souborů ponechány, některá fotografie se používala nebo byl její nový název obsazený: {0} + Názvy souborů ponechány, fotografie se po vytvoření plánu změnily: {0} + Název a názvy souborů ponechány, soubor sekvence pochází z novější verze Chronos: {0} + Název a názvy souborů ponechány, sekvence se po vytvoření plánu změnila: {0} + Změněné sekvence: {0}, přejmenované soubory: {1} + Reorganizace byla dokončena při otevření archivu Jen přehled: nic nebylo změněno. Složky: {0}, indexováno: {1}, převzato: {2}, odebráno: {3} Sekvence nenalezena: {0} @@ -219,17 +237,34 @@ Složka přesunutého archivu Použít {0} z {1} - Přejmenovat {0:N0} sekvence - Přejmenovat {0:N0} sekvenci - Přejmenovat {0:N0} sekvencí - Přesunout {0:N0} sekvence - Přesunout {0:N0} sekvenci - Přesunout {0:N0} sekvencí Změny Změní se {0:N0} z {1:N0} Změní se {0:N0} z {1:N0} Změní se {0:N0} z {1:N0} - Šablona + Fotografie ponechané na místě mimo složku originals si ponechají své názvy. + Chybějící fotografie si ponechají své názvy. + Fotografie, které nikdy nebyly ověřeny, si ponechají své názvy; nejprve sekvenci ověřte. + Soubor sekvence nelze přečíst; sekvence zůstane, jak je, stejně jako každá složka, ve které leží. + Následuje svou složku + {0}: z {1} na {2} + Soubor + Názvy souborů + Složka + Složky + Reorganizovat {0:N0} sekvence + Reorganizovat {0:N0} sekvenci + Reorganizovat {0:N0} sekvencí + Reorganizovat archiv {0} + {0:N0} názvy ponechány + {0:N0} název ponechán + {0:N0} názvů ponecháno + Zkušební běh… + {0:N0} soubory přejmenovány + {0:N0} soubor přejmenován + {0:N0} souborů přejmenováno + Název + Názvy + Reorganizace se otevře, až se zavře otevřený dialog Přidat značky Použít Značky {0:N0} sekvencí @@ -246,9 +281,8 @@ Exportovat CSV Filtr sady Filtrovaná sada - Přesunout… Proxy - Přejmenovat… + Reorganizovat… Změnit značky… Miniatury Ověřit diff --git a/i18n/cs/Errors.cs.resx b/i18n/cs/Errors.cs.resx index e9fe0b8e..6e21556e 100644 --- a/i18n/cs/Errors.cs.resx +++ b/i18n/cs/Errors.cs.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Neanalyzované sekvence: {0} z {1}; podrobnosti najdete v protokolu úlohy. + Složka této sekvence není tam, kde ji uvádí index; zkuste to znovu po příštím prohledání. Archiv nelze otevřít. Aktuální index nebylo možné zálohovat ani nahradit; obnovení proběhne znovu při příštím spuštění. Tuto zálohu nelze obnovit; vyberte jinou. @@ -39,9 +40,11 @@ {0} originálů chybí nebo se od archivace změnilo; ověřte archiv. Šablona je prázdná. Prázdný zástupný symbol na pozici {1}: mezi složené závorky napište název. + Fotografie by přišly o příponu: před {ext} napište tečku, nebo {ext} vynechte. Názvy souborů nesmí obsahovat lomítko; složky uveďte v šabloně složek. Formát za dvojtečkou neodpovídá svému zástupnému symbolu. Názvy by se opakovaly: přidejte číslo snímku, čas nebo původní název. + Prohledávání vynechává složky, jejichž název začíná tečkou nebo zní originals, proxies či exports. Závorka otevřená na pozici {1} není nikdy uzavřena. Neznámý zástupný symbol „{0}“ na pozici {1}. Uzavírací závorka na pozici {1} nemá otevírací; pro doslovnou závorku ji zdvojte. diff --git a/i18n/cs/Jobs.cs.resx b/i18n/cs/Jobs.cs.resx index 6f47873e..bff4ecb3 100644 --- a/i18n/cs/Jobs.cs.resx +++ b/i18n/cs/Jobs.cs.resx @@ -77,7 +77,7 @@ Import Rychlá analýza Údržba - Přesun archivu + Reorganizace Osiřelé soubory Proxy Sestavení indexu diff --git a/i18n/cs/Library.cs.resx b/i18n/cs/Library.cs.resx index 24c2c550..3b2b1263 100644 --- a/i18n/cs/Library.cs.resx +++ b/i18n/cs/Library.cs.resx @@ -10,17 +10,16 @@ Stáhnout Exportovat seznam Složka - Přesunout… Otevřít Proxy Hodnocení Renderovat + Reorganizovat… Synchronizovat Značky… Nahrát Ověřit Převzít složku - Přesun funguje vždy jen se sekvencemi jednoho archivu. V tomto počítači i na serveru je vše stejné: není co synchronizovat. Nepoužívá se žádný uložený pohled; nejprve nějaký vyberte. Váš účet na serveru nemůže stahovat originály. @@ -32,6 +31,7 @@ Nejprve se přihlaste k serveru Chronos Server na obrazovce Server. Vybrané sekvence nemají ze serveru co stáhnout. Server už má vše, co vybrané sekvence obsahují. + Reorganizace pracuje vždy jen se sekvencemi jednoho archivu. Jen pro sekvence v tomto počítači; vybrané sekvence jsou na serveru. Přenos této sekvence už probíhá. Vymazat filtry diff --git a/i18n/cs/Server.cs.resx b/i18n/cs/Server.cs.resx index 70bae418..93e59014 100644 --- a/i18n/cs/Server.cs.resx +++ b/i18n/cs/Server.cs.resx @@ -40,6 +40,7 @@ Připojení selhalo; podrobnosti najdete v protokolu. Soubor sekvence je otevřený v jiném programu; zavřete ho a zkuste to znovu. Její složka už na disku není; do koše není co přesunout. + Složka této sekvence není tam, kde ji uvádí index serveru; zkuste to znovu po jeho příštím prohledání. Váš účet toto nemůže provést. Fotografie sekvence se na serveru změnily; načtěte ji znovu a proveďte úpravu ještě jednou. Soubor dorazil poškozený; nahrajte ho znovu. @@ -68,11 +69,14 @@ Tento server nemůže spustit tento typ úlohy. Posledního správce nelze odebrat ani zakázat. Tato metoda zde není povolena. + Nová složka by ležela uvnitř složky jiné sekvence. Na této adrese není Chronos Server. Nenalezeno. Nejprve si změňte heslo. Fotografie byla během nahrávání odstraněna ze sekvence, proto nebyla přidána. Soubor {0} nelze přečíst a bez jeho hashe by se ostatní kopie nedozvěděly, že byl odstraněn; zavřete program, který ho používá, nebo zkontrolujte jeho oprávnění a zkuste to znovu. + Archiv se po zkušebním běhu změnil; zkontrolujte plán znovu. + Server přestal tento plán připravovat: trvalo to příliš dlouho, nebo jich bylo najednou požadováno příliš mnoho; zkuste to za chvíli znovu. Tento archiv nevytváří proxy. Proxy pochází z jiné fotografie. Server nepotřebuje proxy této fotografie. diff --git a/i18n/cs/Settings.cs.resx b/i18n/cs/Settings.cs.resx index 45d32243..52090df3 100644 --- a/i18n/cs/Settings.cs.resx +++ b/i18n/cs/Settings.cs.resx @@ -66,6 +66,7 @@ hvězd na megapixel Šířka analýzy px delší strany + Složky a soubory, které už v archivu jsou, si ponechají své názvy. Názvy souborů Složky {0} volných @@ -75,10 +76,12 @@ Vyberte složku archivu Náhled Velikost proxy + Reorganizovat… Resetovat archiv Šablony pojmenování, velikost proxy a velikost miniatur se vrátí na výchozí hodnoty pro každý počítač a server, který archiv používá. Složky a soubory, které už v archivu jsou, si ponechají své názvy. Resetovat nastavení archivu {0}? Složka archivu + Šablony archivu uloženy Velikost miniatur Zpět na Auto Vybrat složku diff --git a/i18n/cs/Tooltips.cs.resx b/i18n/cs/Tooltips.cs.resx index b0168404..2d2bf695 100644 --- a/i18n/cs/Tooltips.cs.resx +++ b/i18n/cs/Tooltips.cs.resx @@ -37,6 +37,7 @@ Otevře sekvenci první kopie v části Úpravy Najde shodné fotografie napříč sekvencemi podle hashe · čte jen index Zobrazí sekvence tohoto roku + Název souboru každé fotografie, jak ho pojmenuje import · kontroluje se během psaní Ponechá jen sekvence jednoho fotoaparátu Vybere tuto hodnotu; dalším výběrem ji zrušíte Ponechá jen sekvence v jednom stavu @@ -72,7 +73,10 @@ Znovu sestaví index z doprovodných souborů; jinak použije úplné prohledání metadat; originály nikdy neodstraní Zařadí sestavení indexu do fronty · archiv zůstane mezitím použitelný Vybere novou složku přesunutého archivu; cesty k jeho sekvencím se aktualizují - Provede přesně tyto změny ve složkách, doprovodných souborech a indexu · po pádu aplikace pokračuje + Zařadí do fronty úlohu, která provede přesně tyto změny · pozastavíte a obnovíte ji v části Úlohy + Přejmenuje fotografie podle této šablony · když je vypnuto, ponechají si své názvy + Přesune složky sekvencí do tohoto uspořádání · když je vypnuto, zůstanou na místě + Změní názvy podle této šablony · když je vypnuto, zůstanou, jak jsou Zálohu indexu vyberte v Nastavení › Pokročilé; při příštím spuštění nahradí index Změní značky těchto sekvencí v doprovodných souborech a v indexu Spustí stejnou akci znovu @@ -81,9 +85,8 @@ Spustí hloubkovou analýzu všech sekvencí v sadě Přesune sadu do koše archivu · zobrazí zkušební běh a pak požádá o potvrzení zadáním počtu Exportuje sadu jako CSV: jeden řádek na sekvenci - Přesune sadu do nové struktury složek · nejprve zkušební běh Vytvoří nebo aktualizuje proxy - Přejmenuje názvy sekvencí v sadě podle šablony · nejprve zkušební běh + Použije šablony složek, souborů a názvů na sadu · nejprve zkušební běh, pak úloha Přidá nebo odebere značky v celé sadě Vytvoří nebo aktualizuje miniatury Znovu vypočte hash originálů v sadě @@ -478,15 +481,15 @@ Uloží {0:N0} řádky jako CSV do zvolené složky Uloží {0:N0} řádek jako CSV do zvolené složky Uloží {0:N0} řádků jako CSV do zvolené složky - Přesune {0:N0} sekvence do nové struktury složek jejich archivu · nejprve zkušební běh - Přesune {0:N0} sekvenci do nové struktury složek jejího archivu · nejprve zkušební běh - Přesune {0:N0} sekvencí do nové struktury složek jejich archivu · nejprve zkušební běh Vytvoří JPEG proxy pro {0:N0} sekvence · běží jako jedna úloha Vytvoří JPEG proxy pro {0:N0} sekvenci · běží jako jedna úloha Vytvoří JPEG proxy pro {0:N0} sekvencí · běží jako jedna úloha Nastaví hodnocení {0:N0} sekvencí v jejich doprovodných souborech a v indexu Nastaví hodnocení {0:N0} sekvence v jejím doprovodném souboru a v indexu Nastaví hodnocení {0:N0} sekvencí v jejich doprovodných souborech a v indexu + Použije šablony složek, souborů a názvů na {0:N0} sekvence jejich archivu · nejprve zkušební běh, pak úloha + Použije šablony složek, souborů a názvů na {0:N0} sekvenci jejího archivu · nejprve zkušební běh, pak úloha + Použije šablony složek, souborů a názvů na {0:N0} sekvencí jejich archivu · nejprve zkušební běh, pak úloha Přidá nebo odebere značky u {0:N0} sekvencí Přidá nebo odebere značky u {0:N0} sekvence Přidá nebo odebere značky u {0:N0} sekvencí @@ -711,6 +714,7 @@ Vyvážený vyhovuje většině práce; Nejlepší měří ve dvojnásobném rozlišení a načítá více snímků dopředu; Rychlý měří v polovičním rozlišení s hrubým odhadem pohybu Znovu vypíše kodéry po instalaci ovladače nebo kodeku Znovu vyhledá rozšíření kodeků po instalaci některého z nich; další úlohy je použijí + Použije šablony archivu na sekvence, které už v něm jsou · nejprve zkušební běh Vrátí všechna nastavení tohoto počítače na výchozí hodnoty; nejprve se zeptá Ihned zapíše výchozí šablony a velikosti do souboru archive.json tohoto archivu Ihned resetuje všechna nastavení diff --git a/i18n/da/Admin.da.resx b/i18n/da/Admin.da.resx index ea253303..c9f1b68d 100644 --- a/i18n/da/Admin.da.resx +++ b/i18n/da/Admin.da.resx @@ -9,6 +9,7 @@ Chronos Server Oppetid Version + {0} omorganiserede arkivet · {1} {0} ændrede arkivets struktur {0} slettede {1} {0} startede {1} @@ -138,7 +139,7 @@ Import Hurtig analyse Vedligeholdelse - Flytning + Omorganisering Forældreløse filer Proxyer Genopbygning @@ -343,6 +344,7 @@ Log på for at administrere denne server Bruger Dit brugernavn på denne server + Arkiv omorganiseret Arkivstruktur Fotos slettet Job startet @@ -426,6 +428,58 @@ Skift adgangskode Erstat adgangskoden, og fortsæt til panelet Vælg en ny adgangskode + Omorganiser… + Anvend mappe-, fil- og titelskabeloner på de valgte sekvenser; en forhåndsvisning viser først alle ændringer + Efter: + Anvend… + Omorganiser som vist i forhåndsvisningen; først kommer en bekræftelse + Før: + Skriv en skabelon, eller slå denne del fra. + Luk uden at ændre noget + Følger med + Flyttes kun, fordi en mappe, den ligger i, flyttes + Omdøbte filer + Mappe + Sekvens + Omorganiser + Sæt det job i kø, der flytter og omdøber originalerne; intet overskrives eller slettes + {0} foto får et nyt navn. + {0} fotos får nye navne. + {0} mappe flyttes. + {0} mapper flyttes. + {0} sekvens ændres. + {0} sekvenser ændres. + Omorganiser nu? + Navn på hvert foto, som en import giver det, f.eks. {date}_{time}_{n:0000}; filerne ved siden af et foto følger med + Filer + Omdøb fotoene i hver sekvens; når funktionen er slået fra, bevares alle filnavne + {0} fil omdøbt + {0} filer omdøbt + Mappe til hver sekvens i arkivet, f.eks. {year}/{date} {camera}; {title} er den nye titel + Mapper + Flyt hver sekvens til den mappe, dens skabelon angiver; når funktionen er slået fra, bliver alle mapper, hvor de er + En valgt sekvens er ikke længere i arkivet; luk og vælg igen. + {0}: {1} + Slå mindst én del til, som skal ændres. + Intet at ændre: disse sekvenser følger allerede skabelonerne. + Omorganiser… + Anvend de nye skabeloner på de sekvenser, der allerede er i arkivet; en forhåndsvisning viser først alle ændringer + Åbn job + Vis jobbet og dets log på siden Job + Arkivet blev ændret under bekræftelsen; kontrollér den nye forhåndsvisning, og anvend igen. + Planlægger… + Forhåndsvisning + Hvad hver sekvens bliver til, i den rækkefølge ændringerne anvendes i; intet er ændret endnu + Omorganisering sat i kø. + Denne mappe bliver, hvor den er + Omorganiser {0} sekvens + Omorganiser {0} sekvenser + Omorganiser alle sekvenser + Ny titel for hver sekvens, f.eks. {date} {camera}; {title} er den nuværende titel + Titler + Giv hver sekvens den titel, dens skabelon laver; når funktionen er slået fra, bevares alle titler + Omorganisering tager højst {0} sekvenser ad gangen eller alle sekvenser: ryd filtrene, og vælg alle. + Sekvenser ændret: {0} · filer omdøbt: {1} · navne bevaret: {2} Administrator Redaktør Uploader diff --git a/i18n/da/Archive.da.resx b/i18n/da/Archive.da.resx index 6f1d1c02..f6739b0d 100644 --- a/i18n/da/Archive.da.resx +++ b/i18n/da/Archive.da.resx @@ -15,6 +15,7 @@ Vent, til ændringerne er anvendt. Udvalget er tomt: skift markeringen eller filteret. Intet ville blive ændret. + Slå mindst én skabelon til. Arkivet skal være online og skrivbart. Vent på prøvekørslen. Vent, til arkivet er læst. @@ -81,6 +82,12 @@ {0} blev skrevet af en nyere Chronos (format {1}). Arkivet {0} er offline. Arkivet {0} er skrivebeskyttet. + {0:N0} sekvens beholdt sine filnavne: et foto var i brug, eller dets nye navn var optaget. + {0:N0} sekvenser beholdt deres filnavne: et foto var i brug, eller dets nye navn var optaget. + {0:N0} sekvens blev ikke omorganiseret som planlagt: den er ændret, efter at planen blev lavet. + {0:N0} sekvenser blev ikke omorganiseret som planlagt: de er ændret, efter at planen blev lavet. + {0:N0} sekvens beholdt sin titel og sine filnavne: dens sekvensfil er fra en nyere Chronos. + {0:N0} sekvenser beholdt deres titler og filnavne: deres sekvensfiler er fra en nyere Chronos. {0} er ændret, efter at planen blev lavet. Kortet eller mappen {0} er ikke længere tilgængelig. Arkivet er ændret, efter at denne plan blev lavet. @@ -146,6 +153,14 @@ Ikke-indekserede fotos: {0}, manglende fotos: {1} {0}: lavet {1}, genbrugt {2}, ulæselige {3}, venter {4} Proxyer til serveren: {0} sendt, {1} ikke sendt + Ladt urørt, mappen, den ligger i, blev på plads: {0} + Ladt urørt, ændret efter planen: {0} + Filnavne bevaret, et foto var i brug, eller dets nye navn var optaget: {0} + Filnavne bevaret, fotos ændret efter planen: {0} + Titel og filnavne bevaret, sekvensfilen er fra en nyere Chronos: {0} + Titel og filnavne bevaret, ændret efter planen: {0} + Sekvenser ændret: {0}, filer omdøbt: {1} + Omorganiseringen blev fuldført, da arkivet blev åbnet Kun rapport: intet blev ændret. Mapper: {0}, indekseret: {1}, overtaget: {2}, fjernet: {3} Sekvens ikke fundet: {0} @@ -200,14 +215,30 @@ Mappen med det flyttede arkiv Anvend {0} af {1} - Omdøb {0:N0} sekvens - Omdøb {0:N0} sekvenser - Flyt {0:N0} sekvens - Flyt {0:N0} sekvenser Ændringer {0:N0} af {1:N0} ændres {0:N0} af {1:N0} ændres - Skabelon + Fotos, der ligger på deres plads uden for originals, beholder deres navne. + Manglende fotos beholder deres navne. + Fotos, der aldrig er verificeret, beholder deres navne; verificer sekvensen først. + Sekvensfilen kan ikke læses; sekvensen forbliver, som den er, og det gør enhver mappe, den ligger i, også. + Følger sin mappe + {0}: fra {1} til {2} + Fil + Filnavne + Mappe + Mapper + Omorganiser {0:N0} sekvens + Omorganiser {0:N0} sekvenser + Omorganiser {0} + {0:N0} navn bevaret + {0:N0} navne bevaret + Prøvekørsel… + {0:N0} fil omdøbt + {0:N0} filer omdøbt + Titel + Titler + Omorganisering åbner, når den åbne dialogboks lukkes Tilføj tags Anvend Tags for {0:N0} sekvens @@ -222,9 +253,8 @@ Eksporter CSV Udvalgsfilter Filtreret udvalg - Flyt… Proxyer - Omdøb… + Omorganiser… Rediger tags… Miniaturer Verificer diff --git a/i18n/da/Errors.da.resx b/i18n/da/Errors.da.resx index 5cab3246..b1902e40 100644 --- a/i18n/da/Errors.da.resx +++ b/i18n/da/Errors.da.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Sekvenser, der ikke blev analyseret: {0} af {1}; se jobloggen. + Mappen for denne sekvens er ikke der, hvor indekset har den; prøv igen efter næste scanning. Arkivet kunne ikke åbnes. Det aktuelle indeks kunne ikke sikkerhedskopieres eller erstattes; gendannelsen køres igen ved næste start. Denne sikkerhedskopi kan ikke gendannes; vælg en anden. @@ -37,9 +38,11 @@ {0} originaler mangler eller er ændret, siden de blev arkiveret; verificer arkivet. Skabelonen er tom. Tomt token ved position {1}: skriv et navn mellem tuborgklammerne. + Fotoene ville miste deres filtypenavn: skriv et punktum før {ext}, eller udelad {ext}. Filnavne må ikke indeholde en skråstreg; angiv mapper i mappeskabelonen. Formatet efter kolonet passer ikke til dets token. Navne ville gentage sig: tilføj billednummeret, klokkeslættet eller det oprindelige navn. + Scanninger springer mapper over, der starter med et punktum eller hedder originals, proxies eller exports. Tuborgklammen, der åbnes ved position {1}, lukkes aldrig. Ukendt token »{0}« ved position {1}. Den lukkende tuborgklamme ved position {1} har ingen åbnende; skriv den to gange for at få en bogstavelig klamme. diff --git a/i18n/da/Jobs.da.resx b/i18n/da/Jobs.da.resx index 6e002293..8f302e5a 100644 --- a/i18n/da/Jobs.da.resx +++ b/i18n/da/Jobs.da.resx @@ -76,7 +76,7 @@ Import Hurtig analyse Vedligeholdelse - Arkivflytning + Omorganisering Forældreløse filer Proxyer Indeksgenopbygning diff --git a/i18n/da/Library.da.resx b/i18n/da/Library.da.resx index 2940602a..95918eef 100644 --- a/i18n/da/Library.da.resx +++ b/i18n/da/Library.da.resx @@ -10,17 +10,16 @@ Download Eksporter liste Mappe - Flyt… Åbn Proxyer Bedømmelse Render + Omorganiser… Synkroniser Tags… Upload Verificer Overtag en mappe - Flytning virker kun på sekvenserne i ét arkiv ad gangen. Sekvensen er ens på denne pc og på serveren: der er intet at synkronisere. Ingen gemt visning er i brug; vælg én først. Din serverkonto kan ikke downloade originaler. @@ -32,6 +31,7 @@ Log først på en Chronos Server på skærmen Server. De valgte sekvenser har intet at hente fra serveren. Serveren har allerede det, som de valgte sekvenser indeholder. + Omorganisering arbejder med sekvenserne i ét arkiv ad gangen. Kun for sekvenser på denne pc; markeringen ligger på serveren. En overførsel af denne sekvens er allerede i gang. Ryd filtre diff --git a/i18n/da/Server.da.resx b/i18n/da/Server.da.resx index 7db48d96..b2f8d370 100644 --- a/i18n/da/Server.da.resx +++ b/i18n/da/Server.da.resx @@ -40,6 +40,7 @@ Forbindelsen mislykkedes; loggen indeholder detaljerne. En fil i sekvensen er åben i et andet program; luk den, og prøv igen. Dens mappe findes ikke længere på disken; der er intet tilbage at flytte til papirkurven. + Mappen for denne sekvens er ikke der, hvor serverens indeks har den; prøv igen efter dens næste scanning. Din konto har ikke tilladelse til dette. Sekvensens fotos er ændret på serveren; genindlæs den, og udfør din redigering igen. Filen kom frem beskadiget; upload den igen. @@ -68,11 +69,14 @@ Denne server kan ikke køre den type job. Den sidste administrator kan ikke fjernes eller deaktiveres. Denne metode er ikke tilladt her. + En ny mappe ville ligge inde i mappen for en anden sekvens. Den adresse er ikke en Chronos Server. Ikke fundet. Skift din adgangskode først. Fotoet blev slettet fra sekvensen, mens det blev uploadet, så det blev ikke tilføjet. {0} kan ikke læses, og uden dens hash ville andre kopier ikke få at vide, at den blev slettet; luk det program, der bruger den, eller kontrollér dens tilladelser, og prøv derefter igen. + Arkivet er ændret efter prøvekørslen; gennemgå planen igen. + Serveren holdt op med at lave denne plan: det tog for lang tid, eller der blev bedt om for mange på én gang; prøv igen om lidt. Dette arkiv laver ingen proxyer. Proxyen blev lavet ud fra et andet foto. Serveren har ikke brug for en proxy af dette foto. diff --git a/i18n/da/Settings.da.resx b/i18n/da/Settings.da.resx index fc30608c..5ea72b39 100644 --- a/i18n/da/Settings.da.resx +++ b/i18n/da/Settings.da.resx @@ -65,6 +65,7 @@ stjerner pr. megapixel Analysebredde px på den lange side + Mapper og filer, der allerede er i arkivet, beholder deres navne. Filnavne Mapper {0} ledig @@ -74,10 +75,12 @@ Vælg arkivmappen Forhåndsvisning Proxystørrelse + Omorganiser… Nulstil arkiv Navneskabeloner, proxystørrelse og miniaturestørrelse vender tilbage til standard for alle pc'er og servere, der bruger arkivet. Mapper og filer, der allerede er i arkivet, beholder deres navne. Nulstil indstillingerne for {0}? Arkivmappe + Arkivskabeloner gemt Miniaturestørrelse Tilbage til Auto Vælg mappe diff --git a/i18n/da/Tooltips.da.resx b/i18n/da/Tooltips.da.resx index fc315d42..33c659dd 100644 --- a/i18n/da/Tooltips.da.resx +++ b/i18n/da/Tooltips.da.resx @@ -36,6 +36,7 @@ Åbn sekvensen med den første kopi i Redigering Find identiske fotos på tværs af sekvenser via hash · læser kun indekset Vis sekvenserne fra dette år + Filnavn for hvert foto, som det navngives ved import · kontrolleres, mens du skriver Behold kun sekvenserne fra ét kamera Vælg denne værdi; vælg den igen for at rydde den Behold kun sekvenserne i én tilstand @@ -71,7 +72,10 @@ Genopbyg indekset ud fra sidecar-filerne; bruger ellers en fuld metadatascanning; sletter aldrig originaler Sæt genopbygningen i kø · arkivet kan bruges imens Vælg den nye mappe for et arkiv, du har flyttet; dets sekvenser følger med - Foretag præcis disse ændringer i mapper, sidecar-filer og indeks · genoptages efter et nedbrud + Sæt et job i kø, der foretager præcis disse ændringer · sæt det på pause, og genoptag det under Job + Omdøb fotoene med denne skabelon · når funktionen er slået fra, beholder de deres navne + Flyt sekvensmapperne ind i denne struktur · når funktionen er slået fra, bliver de, hvor de er + Skift titlerne med denne skabelon · når funktionen er slået fra, forbliver de, som de er Vælg en sikkerhedskopi af indekset under Indstillinger › Avanceret; den erstatter indekset ved næste start Skift tags for disse sekvenser i sidecar-filer og indeks Kør den samme handling igen @@ -80,9 +84,8 @@ Kør dybdeanalysen på alle sekvenser i udvalget Flyt udvalget til arkivets papirkurv · viser prøvekørslen og beder dig derefter skrive for at bekræfte Eksporter udvalget som CSV: én række pr. sekvens - Flyt udvalget til en ny mappestruktur · prøvekørsel først Generér eller opdater proxyer - Omdøb titlerne i udvalget med en skabelon · prøvekørsel først + Anvend mappe-, fil- og titelskabeloner på udvalget · først en prøvekørsel, derefter et job Tilføj eller fjern tags på hele udvalget Generér eller opdater miniaturer Beregn hash for originalerne i udvalget igen @@ -471,12 +474,12 @@ Hent det, som {0:N0} sekvenser mangler her (originaler eller renderinger), fra serveren · kører som overførselsjob Gem {0:N0} række som CSV i en mappe, du vælger Gem {0:N0} rækker som CSV i en mappe, du vælger - Flyt {0:N0} sekvens til en ny mappestruktur i dens arkiv · viser prøvekørslen først - Flyt {0:N0} sekvenser til en ny mappestruktur i deres arkiv · viser prøvekørslen først Byg JPEG-proxyer til {0:N0} sekvens · kører som ét job Byg JPEG-proxyer til {0:N0} sekvenser · kører som ét job Angiv bedømmelsen af {0:N0} sekvens i dens sidecar-fil og i indekset Angiv bedømmelsen af {0:N0} sekvenser i deres sidecar-filer og i indekset + Anvend mappe-, fil- og titelskabeloner på {0:N0} sekvens i dens arkiv · først en prøvekørsel, derefter et job + Anvend mappe-, fil- og titelskabeloner på {0:N0} sekvenser i deres arkiv · først en prøvekørsel, derefter et job Tilføj eller fjern tags på {0:N0} sekvens Tilføj eller fjern tags på {0:N0} sekvenser Send det, som serveren mangler af {0:N0} sekvens (originaler og indstillinger eller renderinger) · kører som et overførselsjob @@ -692,6 +695,7 @@ Afbalanceret passer til det meste; Bedst måler i dobbelt opløsning og læser længere frem; Hurtig måler i halv opløsning med flowkvaliteten Kladde Find encoderne igen efter installation af en driver eller et codec Søg efter codec-udvidelser igen efter installation af en; de næste job bruger dem + Anvend arkivets skabeloner på de sekvenser, der allerede er i det · først en prøvekørsel Nulstil alle indstillinger på denne pc til standard; spørger først Skriv standardskabelonerne og -størrelserne i dette arkivs archive.json nu Nulstil alle indstillinger nu diff --git a/i18n/de/Admin.de.resx b/i18n/de/Admin.de.resx index 7823a225..f4fc2938 100644 --- a/i18n/de/Admin.de.resx +++ b/i18n/de/Admin.de.resx @@ -9,6 +9,7 @@ Chronos Server Läuft seit Version + {0} hat das Archiv neu geordnet · {1} {0} hat die Archivstruktur geändert {0} hat {1} gelöscht {0} hat {1} gestartet @@ -138,7 +139,7 @@ Import Schnellanalyse Wartung - Verschieben + Neuordnung Verwaiste Dateien Proxys Neuaufbau @@ -343,6 +344,7 @@ Anmelden, um diesen Server zu verwalten Benutzer Ihr Benutzername auf diesem Server + Archiv neu geordnet Archivstruktur Fotos gelöscht Auftrag gestartet @@ -426,6 +428,58 @@ Kennwort ändern Kennwort ersetzen und zum Admin-Bereich wechseln Neues Kennwort wählen + Neu ordnen… + Ordner-, Dateinamen- und Titelvorlagen auf die ausgewählten Sequenzen anwenden; eine Vorschau zeigt zuerst jede Änderung + Nachher: + Übernehmen… + Wie in der Vorschau gezeigt neu ordnen; vorher wird um Bestätigung gebeten + Vorher: + Geben Sie eine Vorlage ein oder schalten Sie diesen Teil aus. + Schließen, ohne etwas zu ändern + Mitverschoben + Wird nur verschoben, weil ein Ordner verschoben wird, in dem sie liegt + Umbenannte Dateien + Ordner + Sequenz + Neu ordnen + Den Auftrag einreihen, der die Originale verschiebt und umbenennt; nichts wird überschrieben oder gelöscht + {0} Foto erhält einen neuen Namen. + {0} Fotos erhalten neue Namen. + {0} Ordner wird verschoben. + {0} Ordner werden verschoben. + {0} Sequenz wird geändert. + {0} Sequenzen werden geändert. + Jetzt neu ordnen? + Name jedes Fotos, wie ein Import ihn vergibt, z. B. {date}_{time}_{n:0000}; die Dateien neben einem Foto folgen ihm + Dateien + Die Fotos jeder Sequenz umbenennen; ausgeschaltet bleiben alle Dateinamen erhalten + {0} Datei umbenannt + {0} Dateien umbenannt + Ordner jeder Sequenz im Archiv, z. B. {year}/{date} {camera}; {title} ist der neue Titel + Ordner + Jede Sequenz in den Ordner verschieben, den ihre Vorlage ergibt; ausgeschaltet bleibt jeder Ordner, wo er ist + Eine ausgewählte Sequenz ist nicht mehr im Archiv; schließen Sie das Fenster und wählen Sie erneut aus. + {0}: {1} + Schalten Sie mindestens einen Teil ein, der geändert werden soll. + Nichts zu ändern: Diese Sequenzen folgen bereits den Vorlagen. + Neu ordnen… + Die neuen Vorlagen auf die Sequenzen anwenden, die bereits im Archiv sind; eine Vorschau zeigt zuerst jede Änderung + Auftrag öffnen + Den Auftrag und sein Protokoll auf der Seite „Aufträge“ anzeigen + Das Archiv hat sich während der Bestätigung geändert; prüfen Sie die neue Vorschau und wenden Sie sie erneut an. + Wird geplant… + Vorschau + Was aus jeder Sequenz wird, in der Reihenfolge, in der die Änderungen angewendet werden; noch hat sich nichts geändert + Neuordnung eingereiht. + Dieser Ordner bleibt, wo er ist + {0} Sequenz neu ordnen + {0} Sequenzen neu ordnen + Alle Sequenzen neu ordnen + Neuer Titel jeder Sequenz, z. B. {date} {camera}; {title} ist der aktuelle Titel + Titel + Jeder Sequenz den Titel geben, den ihre Vorlage ergibt; ausgeschaltet bleiben alle Titel erhalten + „Neu ordnen“ verarbeitet höchstens {0} Sequenzen auf einmal oder alle Sequenzen: Setzen Sie die Filter zurück und wählen Sie alle aus. + Geänderte Sequenzen: {0} · umbenannte Dateien: {1} · beibehaltene Namen: {2} Administrator Bearbeiter Uploader diff --git a/i18n/de/Archive.de.resx b/i18n/de/Archive.de.resx index 0f11cdda..3a05b4db 100644 --- a/i18n/de/Archive.de.resx +++ b/i18n/de/Archive.de.resx @@ -15,6 +15,7 @@ Warten Sie, bis die Änderungen übernommen sind. Die gefilterte Auswahl ist leer: Ändern Sie die Auswahl im Baum oder den Filter. Es würde sich nichts ändern. + Aktivieren Sie mindestens eine Vorlage. Das Archiv muss online und beschreibbar sein. Warten Sie auf den Probelauf. Warten Sie, bis das Archiv gelesen ist. @@ -81,6 +82,12 @@ {0} wurde von einer neueren Chronos-Version geschrieben (Format {1}). Das Archiv {0} ist offline. Das Archiv {0} ist schreibgeschützt. + {0:N0} Sequenz hat ihre Dateinamen behalten: Ein Foto war in Verwendung oder sein neuer Name war bereits vergeben. + {0:N0} Sequenzen haben ihre Dateinamen behalten: Ein Foto war in Verwendung oder sein neuer Name war bereits vergeben. + {0:N0} Sequenz wurde nicht wie geplant neu geordnet: Sie hat sich nach dem Plan geändert. + {0:N0} Sequenzen wurden nicht wie geplant neu geordnet: Sie haben sich nach dem Plan geändert. + {0:N0} Sequenz hat ihren Titel und ihre Dateinamen behalten: Ihre Sequenzdatei stammt von einer neueren Chronos-Version. + {0:N0} Sequenzen haben ihre Titel und Dateinamen behalten: Ihre Sequenzdateien stammen von einer neueren Chronos-Version. {0} hat sich geändert, nachdem der Plan erstellt wurde. Die Karte oder der Ordner {0} ist nicht mehr verfügbar. Das Archiv hat sich geändert, nachdem dieser Plan erstellt wurde. @@ -146,6 +153,14 @@ Nicht indizierte Fotos: {0}, fehlende Fotos: {1} {0}: erstellt {1}, wiederverwendet {2}, unlesbar {3}, ausstehend {4} Proxys für den Server: gesendet {0}, nicht gesendet {1} + Unverändert gelassen, der Ordner, in dem sie liegt, ist geblieben: {0} + Unverändert gelassen, nach dem Plan geändert: {0} + Dateinamen behalten, ein Foto war in Verwendung oder sein neuer Name war bereits vergeben: {0} + Dateinamen behalten, Fotos nach dem Plan geändert: {0} + Titel und Dateinamen behalten, ihre Sequenzdatei stammt von einer neueren Chronos-Version: {0} + Titel und Dateinamen behalten, nach dem Plan geändert: {0} + Geänderte Sequenzen: {0}, umbenannte Dateien: {1} + Die Neuordnung wurde beim Öffnen des Archivs abgeschlossen Nur Bericht: Es wurde nichts geändert. Ordner: {0}, indiziert: {1}, eingebunden: {2}, entfernt: {3} Sequenz nicht gefunden: {0} @@ -200,14 +215,30 @@ Ordner des verschobenen Archivs Übernehmen {0} von {1} - {0:N0} Sequenz umbenennen - {0:N0} Sequenzen umbenennen - {0:N0} Sequenz verschieben - {0:N0} Sequenzen verschieben Änderungen {0:N0} von {1:N0} wird geändert {0:N0} von {1:N0} werden geändert - Vorlage + Fotos, die außerhalb von originals an ihrem Ort belassen wurden, behalten ihre Namen. + Fehlende Fotos behalten ihre Namen. + Nie geprüfte Fotos behalten ihre Namen; prüfen Sie zuerst die Sequenz. + Die Sequenzdatei kann nicht gelesen werden; die Sequenz bleibt unverändert, ebenso jeder Ordner, in dem sie liegt. + Folgt ihrem Ordner + {0}: von {1} zu {2} + Datei + Dateinamen + Ordner + Ordner + {0:N0} Sequenz neu ordnen + {0:N0} Sequenzen neu ordnen + {0} neu ordnen + {0:N0} Name beibehalten + {0:N0} Namen beibehalten + Probelauf… + {0:N0} Datei umbenannt + {0:N0} Dateien umbenannt + Titel + Titel + „Neu ordnen“ wird geöffnet, sobald das offene Dialogfeld geschlossen ist Tags hinzufügen Übernehmen Tags von {0:N0} Sequenz @@ -222,9 +253,8 @@ CSV exportieren Filter der Auswahl Gefilterte Auswahl - Verschieben… Proxys - Umbenennen… + Neu ordnen… Tags ändern… Miniaturansichten Prüfen diff --git a/i18n/de/Errors.de.resx b/i18n/de/Errors.de.resx index 4abcb73c..864953a0 100644 --- a/i18n/de/Errors.de.resx +++ b/i18n/de/Errors.de.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Nicht analysierte Sequenzen: {0} von {1}; siehe Auftragsprotokoll. + Der Ordner dieser Sequenz liegt nicht dort, wo der Index ihn verzeichnet; versuchen Sie es nach dem nächsten Scan erneut. Das Archiv konnte nicht geöffnet werden. Der aktuelle Index konnte nicht gesichert oder ersetzt werden; die Wiederherstellung wird beim nächsten Start erneut ausgeführt. Diese Sicherung kann nicht wiederhergestellt werden; wählen Sie eine andere aus. @@ -37,9 +38,11 @@ {0} Originale fehlen oder wurden seit der Archivierung geändert; prüfen Sie das Archiv. Die Vorlage ist leer. Leerer Platzhalter an Position {1}: Schreiben Sie einen Namen zwischen die geschweiften Klammern. + Die Fotos würden ihre Erweiterung verlieren: Schreiben Sie einen Punkt vor {ext} oder lassen Sie {ext} weg. Dateinamen dürfen keinen Schrägstrich enthalten; Ordner gehören in die Ordnervorlage. Das Format nach dem Doppelpunkt passt nicht zu seinem Platzhalter. Namen würden sich wiederholen: Fügen Sie die Frame-Nummer, die Uhrzeit oder den Originalnamen hinzu. + Scans überspringen Ordner, die mit einem Punkt beginnen oder originals, proxies oder exports heißen. Die an Position {1} geöffnete geschweifte Klammer wird nie geschlossen. Unbekannter Platzhalter „{0}“ an Position {1}. Die schließende geschweifte Klammer an Position {1} hat keine öffnende; verdoppeln Sie sie für eine literale Klammer. diff --git a/i18n/de/Jobs.de.resx b/i18n/de/Jobs.de.resx index 2de5a7fa..447d5715 100644 --- a/i18n/de/Jobs.de.resx +++ b/i18n/de/Jobs.de.resx @@ -76,7 +76,7 @@ Import Schnellanalyse Wartung - Archiv verschieben + Neuordnung Verwaiste Dateien Proxys Index neu aufbauen diff --git a/i18n/de/Library.de.resx b/i18n/de/Library.de.resx index 02603fe1..4192180f 100644 --- a/i18n/de/Library.de.resx +++ b/i18n/de/Library.de.resx @@ -10,17 +10,16 @@ Herunterladen Liste exportieren Ordner - Verschieben… Öffnen Proxys Bewertung Rendern + Neu ordnen… Synchronisieren Tags… Hochladen Prüfen Ordner einbinden - „Verschieben“ funktioniert nur mit Sequenzen aus jeweils einem Archiv. Auf diesem PC und auf dem Server identisch: Es gibt nichts zu synchronisieren. Es ist keine gespeicherte Ansicht aktiv; wählen Sie zuerst eine aus. Ihr Serverkonto darf keine Originale herunterladen. @@ -32,6 +31,7 @@ Melden Sie sich zuerst im Bereich „Server“ bei einem Chronos Server an. Für die ausgewählten Sequenzen gibt es nichts vom Server abzurufen. Der Server hat bereits alles, was die ausgewählten Sequenzen enthalten. + „Neu ordnen“ wirkt jeweils nur auf die Sequenzen eines einzigen Archivs. Nur für Sequenzen auf diesem PC; die Auswahl liegt auf dem Server. Für diese Sequenz läuft bereits eine Übertragung. Filter zurücksetzen diff --git a/i18n/de/Server.de.resx b/i18n/de/Server.de.resx index 3b5e3a8e..c645d1f2 100644 --- a/i18n/de/Server.de.resx +++ b/i18n/de/Server.de.resx @@ -40,6 +40,7 @@ Die Verbindung ist fehlgeschlagen; Details stehen im Protokoll. Eine Datei der Sequenz ist in einem anderen Programm geöffnet; schließen Sie sie und versuchen Sie es erneut. Der Ordner der Sequenz ist nicht mehr auf dem Datenträger; es gibt nichts mehr, das in den Papierkorb verschoben werden kann. + Der Ordner dieser Sequenz liegt nicht dort, wo der Index des Servers ihn verzeichnet; versuchen Sie es nach dem nächsten Scan des Servers erneut. Ihr Konto darf das nicht. Die Fotos der Sequenz wurden auf dem Server geändert; laden Sie die Sequenz neu und wenden Sie Ihre Änderung erneut an. Die Datei ist beschädigt angekommen; laden Sie sie erneut hoch. @@ -68,11 +69,14 @@ Dieser Server kann diese Art von Auftrag nicht ausführen. Der letzte Administrator kann nicht entfernt oder deaktiviert werden. Diese Methode ist hier nicht zulässig. + Ein neuer Ordner läge im Ordner einer anderen Sequenz. Diese Adresse ist kein Chronos Server. Nicht gefunden. Ändern Sie zuerst Ihr Kennwort. Das Foto wurde während des Hochladens aus der Sequenz gelöscht und daher nicht hinzugefügt. {0} kann nicht gelesen werden; ohne ihre Prüfsumme würden andere Kopien nicht erfahren, dass die Datei gelöscht wurde. Schließen Sie das Programm, das sie verwendet, oder prüfen Sie ihre Berechtigungen, und versuchen Sie es dann erneut. + Das Archiv hat sich nach dem Probelauf geändert; prüfen Sie den Plan erneut. + Der Server hat die Erstellung dieses Plans abgebrochen: Sie dauerte zu lange, oder es wurden zu viele auf einmal angefordert; versuchen Sie es gleich noch einmal. Dieses Archiv erstellt keine Proxys. Der Proxy wurde aus einem anderen Foto erstellt. Der Server benötigt keinen Proxy dieses Fotos. diff --git a/i18n/de/Settings.de.resx b/i18n/de/Settings.de.resx index c34e6f94..a863d1a3 100644 --- a/i18n/de/Settings.de.resx +++ b/i18n/de/Settings.de.resx @@ -65,6 +65,7 @@ Sterne pro Megapixel Analysebreite px an der langen Kante + Ordner und Dateien, die bereits im Archiv liegen, behalten ihre Namen. Dateinamen Ordner {0} frei @@ -74,10 +75,12 @@ Archivordner auswählen Vorschau Proxygröße + Neu ordnen… Archiv zurücksetzen Seine Namensvorlagen, Proxygröße und Miniaturgröße kehren für jeden PC und Server, der es verwendet, zu ihren Standardwerten zurück. Ordner und Dateien, die bereits im Archiv liegen, behalten ihre Namen. Einstellungen von {0} zurücksetzen? Archivordner + Archivvorlagen gespeichert Miniaturgröße Zurück zu Auto Ordner auswählen diff --git a/i18n/de/Tooltips.de.resx b/i18n/de/Tooltips.de.resx index 915d0af4..5380581f 100644 --- a/i18n/de/Tooltips.de.resx +++ b/i18n/de/Tooltips.de.resx @@ -36,6 +36,7 @@ Sequenz der ersten Kopie im Bereich „Bearbeiten“ öffnen Identische Fotos sequenzübergreifend per Prüfsumme finden · liest nur den Index Sequenzen dieses Jahres anzeigen + Dateiname jedes Fotos, wie Importe ihn vergeben · wird beim Tippen geprüft Nur die Sequenzen einer Kamera behalten Diesen Wert wählen; erneutes Wählen hebt ihn auf Nur die Sequenzen mit einem bestimmten Status behalten @@ -71,7 +72,10 @@ Index aus den Sidecar-Dateien neu aufbauen; greift notfalls auf einen vollständigen Metadatenscan zurück; löscht nie Originale Neuaufbau einreihen · das Archiv bleibt währenddessen nutzbar Neuen Ordner eines verschobenen Archivs auswählen; seine Sequenzen folgen - Genau diese Änderungen an Ordnern, Sidecar-Dateien und Index vornehmen · wird nach einem Absturz fortgesetzt + Einen Auftrag einreihen, der genau diese Änderungen vornimmt · unter „Aufträge“ anhalten und fortsetzen + Die Fotos mit dieser Vorlage umbenennen · ausgeschaltet behalten sie ihre Namen + Die Sequenzordner in diese Struktur verschieben · ausgeschaltet bleiben sie, wo sie sind + Die Titel mit dieser Vorlage ändern · ausgeschaltet bleiben sie unverändert Unter Einstellungen › Erweitert eine Sicherung des Index auswählen; sie ersetzt den Index beim nächsten Start Tags dieser Sequenzen in Sidecar-Dateien und Index ändern Dieselbe Aktion erneut ausführen @@ -80,9 +84,8 @@ Tiefenanalyse für jede Sequenz der Auswahl ausführen Die Auswahl in den Papierkorb des Archivs verschieben · zeigt zuerst den Probelauf und verlangt dann eine Bestätigung per Eingabe Auswahl als CSV exportieren: eine Zeile pro Sequenz - Auswahl in eine neue Ordnerstruktur verschieben · zuerst ein Probelauf Proxys erstellen oder aktualisieren - Titel der Auswahl mit einer Vorlage umbenennen · zuerst ein Probelauf + Ordner-, Dateinamen- und Titelvorlagen auf die Auswahl anwenden · zuerst ein Probelauf, dann ein Auftrag Tags für die gesamte Auswahl hinzufügen oder entfernen Miniaturansichten erstellen oder aktualisieren Prüfsummen der Originale der Auswahl neu berechnen @@ -471,12 +474,12 @@ Für {0:N0} Sequenzen vom Server holen, was hier fehlt (Originale oder Renderings) · läuft in Übertragungsaufträgen {0:N0} Zeile als CSV in einem Ordner Ihrer Wahl speichern {0:N0} Zeilen als CSV in einem Ordner Ihrer Wahl speichern - {0:N0} Sequenz in eine neue Ordnerstruktur ihres Archivs verschieben · zeigt zuerst den Probelauf - {0:N0} Sequenzen in eine neue Ordnerstruktur ihres Archivs verschieben · zeigt zuerst den Probelauf JPEG-Proxys für {0:N0} Sequenz erstellen · läuft als ein Auftrag JPEG-Proxys für {0:N0} Sequenzen erstellen · läuft als ein Auftrag Bewertung von {0:N0} Sequenz festlegen, in ihrer Sidecar-Datei und im Index Bewertung von {0:N0} Sequenzen festlegen, in ihren Sidecar-Dateien und im Index + Ordner-, Dateinamen- und Titelvorlagen auf {0:N0} Sequenz ihres Archivs anwenden · zuerst ein Probelauf, dann ein Auftrag + Ordner-, Dateinamen- und Titelvorlagen auf {0:N0} Sequenzen ihres Archivs anwenden · zuerst ein Probelauf, dann ein Auftrag Tags bei {0:N0} Sequenz hinzufügen oder entfernen Tags bei {0:N0} Sequenzen hinzufügen oder entfernen Für {0:N0} Sequenz an den Server senden, was ihm fehlt (Originale und Einstellungen oder Renderings) · läuft als Übertragungsauftrag @@ -692,6 +695,7 @@ „Ausgewogen“ passt für die meisten Arbeiten; „Beste“ misst mit doppelter Auflösung und liest weiter voraus; „Schnell“ misst mit halber Auflösung und Bewegung in Entwurfsqualität Encoder nach einer Treiber- oder Codec-Installation erneut auflisten Nach der Installation einer Codec-Erweiterung erneut nach Erweiterungen suchen; die nächsten Aufträge verwenden sie + Die Vorlagen des Archivs auf die Sequenzen anwenden, die bereits darin liegen · zuerst ein Probelauf Alle Einstellungen dieses PCs auf den Standard zurücksetzen; fragt vorher nach Die Standardvorlagen und -größen jetzt in die archive.json dieses Archivs schreiben Alle Einstellungen jetzt zurücksetzen diff --git a/i18n/el/Admin.el.resx b/i18n/el/Admin.el.resx index f2b6faa6..e7d680b7 100644 --- a/i18n/el/Admin.el.resx +++ b/i18n/el/Admin.el.resx @@ -9,6 +9,7 @@ Chronos Server Χρόνος λειτουργίας Έκδοση + {0} αναδιοργάνωσε την αρχειοθήκη · {1} {0} άλλαξε τη διάταξη της αρχειοθήκης {0} διέγραψε {1} {0} ξεκίνησε εργασία: {1} @@ -138,7 +139,7 @@ Εισαγωγή Γρήγορη ανάλυση Συντήρηση - Μετακίνηση + Αναδιοργάνωση Ορφανά αρχεία Proxy Αναδόμηση @@ -343,6 +344,7 @@ Είσοδος για τη διαχείριση αυτού του διακομιστή Χρήστης Το όνομα χρήστη σας σε αυτόν τον διακομιστή + Αναδιοργάνωση αρχειοθήκης Διάταξη αρχειοθήκης Διαγραφή φωτογραφιών Έναρξη εργασίας @@ -426,6 +428,58 @@ Αλλαγή κωδικού πρόσβασης Αντικατάσταση του κωδικού πρόσβασης και συνέχεια στον πίνακα διαχείρισης Επιλέξτε νέο κωδικό πρόσβασης + Αναδιοργάνωση… + Εφαρμογή προτύπων φακέλου, αρχείου και τίτλου στις επιλεγμένες ακολουθίες. Μια προεπισκόπηση δείχνει πρώτα κάθε αλλαγή + Μετά: + Εφαρμογή… + Αναδιοργάνωση όπως δείχνει η προεπισκόπηση. Πρώτα ζητείται επιβεβαίωση + Πριν: + Γράψτε ένα πρότυπο ή απενεργοποιήστε αυτό το τμήμα. + Κλείσιμο χωρίς καμία αλλαγή + Μεταφέρεται μαζί + Μετακινείται μόνο επειδή μετακινείται ένας φάκελος που την περιέχει + Μετονομασμένα αρχεία + Φάκελος + Ακολουθία + Αναδιοργάνωση + Τοποθέτηση στην ουρά της εργασίας που μετακινεί και μετονομάζει τα πρωτότυπα. Τίποτα δεν αντικαθίσταται ούτε διαγράφεται + {0} φωτογραφία παίρνει νέο όνομα. + {0} φωτογραφίες παίρνουν νέα ονόματα. + Μετακινείται {0} φάκελος. + Μετακινούνται {0} φάκελοι. + Αλλάζει {0} ακολουθία. + Αλλάζουν {0} ακολουθίες. + Αναδιοργάνωση τώρα; + Όνομα κάθε φωτογραφίας όπως το δίνει μια εισαγωγή, π.χ. {date}_{time}_{n:0000}. Τα αρχεία δίπλα σε μια φωτογραφία την ακολουθούν + Αρχεία + Μετονομασία των φωτογραφιών κάθε ακολουθίας. Όταν είναι ανενεργό, διατηρούνται όλα τα ονόματα αρχείων + {0} αρχείο μετονομάστηκε + {0} αρχεία μετονομάστηκαν + Φάκελος κάθε ακολουθίας στην αρχειοθήκη, π.χ. {year}/{date} {camera}. Το {title} είναι ο νέος τίτλος + Φάκελοι + Μετακίνηση κάθε ακολουθίας στον φάκελο που δίνει το πρότυπό της. Όταν είναι ανενεργό, κάθε φάκελος μένει στη θέση του + Μια επιλεγμένη ακολουθία δεν βρίσκεται πλέον στην αρχειοθήκη. Κλείστε και επιλέξτε ξανά. + {0}: {1} + Ενεργοποιήστε τουλάχιστον ένα τμήμα για αλλαγή. + Τίποτα για αλλαγή: αυτές οι ακολουθίες ακολουθούν ήδη τα πρότυπα. + Αναδιοργάνωση… + Εφαρμογή των νέων προτύπων στις ακολουθίες που υπάρχουν ήδη στην αρχειοθήκη. Μια προεπισκόπηση δείχνει πρώτα κάθε αλλαγή + Άνοιγμα εργασίας + Εμφάνιση της εργασίας και της καταγραφής της στη σελίδα Εργασίες + Η αρχειοθήκη άλλαξε κατά την επιβεβαίωση. Ελέγξτε τη νέα προεπισκόπηση και εφαρμόστε ξανά. + Σχεδιασμός… + Προεπισκόπηση + Τι γίνεται κάθε ακολουθία, με τη σειρά που εφαρμόζονται οι αλλαγές. Δεν έχει αλλάξει τίποτα ακόμη + Η αναδιοργάνωση μπήκε στην ουρά. + Αυτός ο φάκελος μένει στη θέση του + Αναδιοργάνωση {0} ακολουθίας + Αναδιοργάνωση {0} ακολουθιών + Αναδιοργάνωση όλων των ακολουθιών + Νέος τίτλος κάθε ακολουθίας, π.χ. {date} {camera}. Το {title} είναι ο τρέχων τίτλος + Τίτλοι + Κάθε ακολουθία παίρνει τον τίτλο που δημιουργεί το πρότυπό της. Όταν είναι ανενεργό, διατηρούνται όλοι οι τίτλοι + Η αναδιοργάνωση δέχεται έως {0} ακολουθίες τη φορά ή όλες τις ακολουθίες: απαλείψτε τα φίλτρα και επιλέξτε όλες. + Ακολουθίες που άλλαξαν: {0} · αρχεία που μετονομάστηκαν: {1} · ονόματα που διατηρήθηκαν: {2} Διαχειριστής Επεξεργαστής Αποστολέας diff --git a/i18n/el/Archive.el.resx b/i18n/el/Archive.el.resx index 8becac18..11d8dbe6 100644 --- a/i18n/el/Archive.el.resx +++ b/i18n/el/Archive.el.resx @@ -15,6 +15,7 @@ Περιμένετε να εφαρμοστούν οι αλλαγές. Το σύνολο είναι κενό: αλλάξτε την επιλογή ή το φίλτρο. Δεν θα άλλαζε τίποτα. + Ενεργοποιήστε τουλάχιστον ένα πρότυπο. Η αρχειοθήκη πρέπει να είναι σε σύνδεση και εγγράψιμη. Περιμένετε τη δοκιμαστική εκτέλεση. Περιμένετε να διαβαστεί η αρχειοθήκη. @@ -81,6 +82,12 @@ Το {0} γράφτηκε από νεότερη έκδοση του Chronos (μορφή {1}). Η αρχειοθήκη {0} είναι εκτός σύνδεσης. Η αρχειοθήκη {0} είναι μόνο για ανάγνωση. + {0:N0} ακολουθία διατήρησε τα ονόματα αρχείων της: μια φωτογραφία ήταν σε χρήση ή το νέο της όνομα υπήρχε ήδη. + {0:N0} ακολουθίες διατήρησαν τα ονόματα αρχείων τους: μια φωτογραφία ήταν σε χρήση ή το νέο της όνομα υπήρχε ήδη. + {0:N0} ακολουθία δεν αναδιοργανώθηκε όπως είχε σχεδιαστεί: άλλαξε μετά το σχέδιο. + {0:N0} ακολουθίες δεν αναδιοργανώθηκαν όπως είχε σχεδιαστεί: άλλαξαν μετά το σχέδιο. + {0:N0} ακολουθία διατήρησε τον τίτλο και τα ονόματα αρχείων της: το αρχείο της ακολουθίας προέρχεται από νεότερη έκδοση του Chronos. + {0:N0} ακολουθίες διατήρησαν τους τίτλους και τα ονόματα αρχείων τους: τα αρχεία των ακολουθιών προέρχονται από νεότερη έκδοση του Chronos. Το {0} άλλαξε μετά τη δημιουργία του σχεδίου. Η κάρτα ή ο φάκελος {0} δεν είναι πλέον διαθέσιμος. Η αρχειοθήκη άλλαξε μετά τη δημιουργία αυτού του σχεδίου. @@ -146,6 +153,14 @@ Φωτογραφίες εκτός ευρετηρίου: {0}, φωτογραφίες που λείπουν: {1} {0}: δημιουργήθηκαν {1}, επαναχρησιμοποιήθηκαν {2}, μη αναγνώσιμα {3}, σε αναμονή {4} Proxy για τον διακομιστή: {0} στάλθηκαν, {1} δεν στάλθηκαν + Έμεινε ως είχε, ο φάκελος που την περιέχει δεν μετακινήθηκε: {0} + Έμεινε ως είχε, άλλαξε μετά το σχέδιο: {0} + Τα ονόματα αρχείων διατηρήθηκαν, μια φωτογραφία ήταν σε χρήση ή το νέο της όνομα υπήρχε ήδη: {0} + Τα ονόματα αρχείων διατηρήθηκαν, οι φωτογραφίες άλλαξαν μετά το σχέδιο: {0} + Ο τίτλος και τα ονόματα αρχείων διατηρήθηκαν, το αρχείο της ακολουθίας προέρχεται από νεότερη έκδοση του Chronos: {0} + Ο τίτλος και τα ονόματα αρχείων διατηρήθηκαν, άλλαξε μετά το σχέδιο: {0} + Ακολουθίες που άλλαξαν: {0}, αρχεία που μετονομάστηκαν: {1} + Η αναδιοργάνωση ολοκληρώθηκε κατά το άνοιγμα της αρχειοθήκης Μόνο αναφορά: δεν άλλαξε τίποτα. Φάκελοι: {0}, καταχωρίστηκαν: {1}, ενσωματώθηκαν: {2}, αφαιρέθηκαν: {3} Η ακολουθία δεν βρέθηκε: {0} @@ -200,14 +215,30 @@ Φάκελος της μετακινημένης αρχειοθήκης Εφαρμογή {0} από {1} - Μετονομασία {0:N0} ακολουθίας - Μετονομασία {0:N0} ακολουθιών - Μετακίνηση {0:N0} ακολουθίας - Μετακίνηση {0:N0} ακολουθιών Αλλαγές {0:N0} από {1:N0} αλλάζει {0:N0} από {1:N0} αλλάζουν - Πρότυπο + Οι φωτογραφίες που παραμένουν στη θέση τους εκτός του φακέλου originals διατηρούν τα ονόματά τους. + Οι φωτογραφίες που λείπουν διατηρούν τα ονόματά τους. + Οι φωτογραφίες που δεν έχουν επαληθευτεί ποτέ διατηρούν τα ονόματά τους. Επαληθεύστε πρώτα την ακολουθία. + Το αρχείο της ακολουθίας δεν είναι αναγνώσιμο. Η ακολουθία μένει ως έχει, όπως και κάθε φάκελος που την περιέχει. + Ακολουθεί τον φάκελό της + {0}: από {1} σε {2} + Αρχείο + Ονόματα αρχείων + Φάκελος + Φάκελοι + Αναδιοργάνωση {0:N0} ακολουθίας + Αναδιοργάνωση {0:N0} ακολουθιών + Αναδιοργάνωση της αρχειοθήκης {0} + {0:N0} όνομα διατηρήθηκε + {0:N0} ονόματα διατηρήθηκαν + Δοκιμαστική εκτέλεση… + {0:N0} αρχείο μετονομάστηκε + {0:N0} αρχεία μετονομάστηκαν + Τίτλος + Τίτλοι + Η αναδιοργάνωση ανοίγει μόλις κλείσει το ανοιχτό παράθυρο διαλόγου Προσθήκη ετικετών Εφαρμογή Ετικέτες {0:N0} ακολουθίας @@ -222,9 +253,8 @@ Εξαγωγή CSV Φίλτρο συνόλου Φιλτραρισμένο σύνολο - Μετακίνηση… Proxy - Μετονομασία… + Αναδιοργάνωση… Ετικέτες… Μικρογραφίες Επαλήθευση diff --git a/i18n/el/Errors.el.resx b/i18n/el/Errors.el.resx index e9ccad19..4cbaa09f 100644 --- a/i18n/el/Errors.el.resx +++ b/i18n/el/Errors.el.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Ακολουθίες που δεν αναλύθηκαν: {0} από {1}. Δείτε την καταγραφή της εργασίας. + Ο φάκελος αυτής της ακολουθίας δεν βρίσκεται εκεί που τον δείχνει το ευρετήριο. Δοκιμάστε ξανά μετά την επόμενη σάρωση. Δεν ήταν δυνατό το άνοιγμα της αρχειοθήκης. Δεν ήταν δυνατή η δημιουργία αντιγράφου ασφαλείας ή η αντικατάσταση του τρέχοντος ευρετηρίου. Η επαναφορά θα εκτελεστεί ξανά στην επόμενη εκκίνηση. Αυτό το αντίγραφο ασφαλείας δεν μπορεί να επαναφερθεί. Επιλέξτε άλλο. @@ -37,9 +38,11 @@ {0} πρωτότυπα λείπουν ή άλλαξαν μετά την αρχειοθέτησή τους. Επαληθεύστε την αρχειοθήκη. Το πρότυπο είναι κενό. Κενό πεδίο στη θέση {1}: γράψτε ένα όνομα μέσα στα άγκιστρα. + Οι φωτογραφίες θα έχαναν την επέκτασή τους: γράψτε μια τελεία πριν από το {ext} ή αφαιρέστε το {ext}. Τα ονόματα αρχείων δεν μπορούν να περιέχουν κάθετο. Βάλτε τους φακέλους στο πρότυπο φακέλου. Η μορφή μετά την άνω και κάτω τελεία δεν ταιριάζει στο πεδίο της. Τα ονόματα θα επαναλαμβάνονταν: προσθέστε τον αριθμό καρέ, την ώρα ή το αρχικό όνομα. + Οι σαρώσεις παραλείπουν τους φακέλους που ξεκινούν με τελεία ή ονομάζονται originals, proxies ή exports. Το άγκιστρο που ανοίγει στη θέση {1} δεν κλείνει ποτέ. Άγνωστο πεδίο «{0}» στη θέση {1}. Το άγκιστρο κλεισίματος στη θέση {1} δεν έχει αντίστοιχο άνοιγμα. Γράψτε το δύο φορές για να εμφανιστεί ως χαρακτήρας. diff --git a/i18n/el/Jobs.el.resx b/i18n/el/Jobs.el.resx index 241ad001..3693c2ca 100644 --- a/i18n/el/Jobs.el.resx +++ b/i18n/el/Jobs.el.resx @@ -76,7 +76,7 @@ Εισαγωγή Γρήγορη ανάλυση Συντήρηση - Μετακίνηση αρχειοθήκης + Αναδιοργάνωση Ορφανά αρχεία Proxy Αναδόμηση ευρετηρίου diff --git a/i18n/el/Library.el.resx b/i18n/el/Library.el.resx index 777f9484..9e35509f 100644 --- a/i18n/el/Library.el.resx +++ b/i18n/el/Library.el.resx @@ -10,17 +10,16 @@ Λήψη Εξαγωγή λίστας Φάκελος - Μετακίνηση… Άνοιγμα Proxy Βαθμολογία Απόδοση + Αναδιοργάνωση… Συγχρονισμός Ετικέτες… Αποστολή Επαλήθευση Ενσωμάτωση φακέλου - Η μετακίνηση γίνεται για τις ακολουθίες μίας αρχειοθήκης κάθε φορά. Ίδια σε αυτόν τον υπολογιστή και στον διακομιστή: τίποτα για συγχρονισμό. Δεν χρησιμοποιείται καμία αποθηκευμένη προβολή. Επιλέξτε πρώτα μία. Ο λογαριασμός σας στον διακομιστή δεν μπορεί να κάνει λήψη πρωτοτύπων. @@ -32,6 +31,7 @@ Συνδεθείτε πρώτα σε έναν Chronos Server, στην οθόνη «Διακομιστής». Οι επιλεγμένες ακολουθίες δεν έχουν τίποτα για λήψη από τον διακομιστή. Ο διακομιστής έχει ήδη όσα περιέχουν οι επιλεγμένες ακολουθίες. + Η αναδιοργάνωση αφορά τις ακολουθίες μίας μόνο αρχειοθήκης κάθε φορά. Μόνο για ακολουθίες σε αυτόν τον υπολογιστή. Η επιλογή βρίσκεται στον διακομιστή. Μια μεταφορά αυτής της ακολουθίας βρίσκεται ήδη σε εξέλιξη. Απαλοιφή φίλτρων diff --git a/i18n/el/Server.el.resx b/i18n/el/Server.el.resx index 83552c70..be8e23ed 100644 --- a/i18n/el/Server.el.resx +++ b/i18n/el/Server.el.resx @@ -40,6 +40,7 @@ Η σύνδεση απέτυχε. Οι λεπτομέρειες υπάρχουν στο αρχείο καταγραφής. Ένα αρχείο της ακολουθίας είναι ανοιχτό σε άλλο πρόγραμμα. Κλείστε το και δοκιμάστε ξανά. Ο φάκελος της ακολουθίας δεν υπάρχει πλέον στον δίσκο. Δεν έμεινε τίποτα για μετακίνηση στον κάδο. + Ο φάκελος αυτής της ακολουθίας δεν βρίσκεται εκεί που τον δείχνει το ευρετήριο του διακομιστή. Δοκιμάστε ξανά μετά την επόμενη σάρωσή του. Ο λογαριασμός σας δεν έχει δικαίωμα για αυτήν την ενέργεια. Οι φωτογραφίες της ακολουθίας άλλαξαν στον διακομιστή. Φορτώστε ξανά την ακολουθία και εφαρμόστε ξανά την αλλαγή σας. Το αρχείο έφτασε κατεστραμμένο. Στείλτε το ξανά. @@ -68,11 +69,14 @@ Αυτός ο διακομιστής δεν μπορεί να εκτελέσει αυτό το είδος εργασίας. Ο τελευταίος διαχειριστής δεν μπορεί να καταργηθεί ή να απενεργοποιηθεί. Αυτή η μέθοδος δεν επιτρέπεται εδώ. + Ένας νέος φάκελος θα βρισκόταν μέσα στον φάκελο άλλης ακολουθίας. Αυτή η διεύθυνση δεν είναι Chronos Server. Δεν βρέθηκε. Αλλάξτε πρώτα τον κωδικό πρόσβασής σας. Η φωτογραφία διαγράφηκε από την ακολουθία ενώ γινόταν η αποστολή της, οπότε δεν προστέθηκε. Δεν είναι δυνατή η ανάγνωση του αρχείου {0} και, χωρίς το hash του, τα άλλα αντίγραφα δεν θα μάθαιναν ότι διαγράφηκε. Κλείστε το πρόγραμμα που το χρησιμοποιεί ή ελέγξτε τα δικαιώματά του και δοκιμάστε ξανά. + Η αρχειοθήκη άλλαξε μετά τη δοκιμαστική εκτέλεση. Ελέγξτε ξανά το σχέδιο. + Ο διακομιστής σταμάτησε να καταρτίζει αυτό το σχέδιο: χρειαζόταν πολύ χρόνο ή ζητήθηκαν πάρα πολλά ταυτόχρονα. Δοκιμάστε ξανά σε λίγο. Αυτή η αρχειοθήκη δεν δημιουργεί proxy. Το proxy δημιουργήθηκε από άλλη φωτογραφία. Ο διακομιστής δεν χρειάζεται proxy αυτής της φωτογραφίας. diff --git a/i18n/el/Settings.el.resx b/i18n/el/Settings.el.resx index e3a302b2..4247dfdd 100644 --- a/i18n/el/Settings.el.resx +++ b/i18n/el/Settings.el.resx @@ -65,6 +65,7 @@ αστέρια ανά megapixel Πλάτος ανάλυσης px στη μεγάλη πλευρά + Οι φάκελοι και τα αρχεία που υπάρχουν ήδη στην αρχειοθήκη διατηρούν τα ονόματά τους. Ονόματα αρχείων Φάκελοι {0} ελεύθερα @@ -74,10 +75,12 @@ Επιλέξτε τον φάκελο της αρχειοθήκης Προεπισκόπηση Μέγεθος proxy + Αναδιοργάνωση… Επαναφορά ρυθμίσεων Τα πρότυπα ονοματοδοσίας, το μέγεθος των proxy και το μέγεθος των μικρογραφιών της επιστρέφουν στις προεπιλογές για κάθε υπολογιστή και διακομιστή που τη χρησιμοποιεί. Οι φάκελοι και τα αρχεία που υπάρχουν ήδη στην αρχειοθήκη διατηρούν τα ονόματά τους. Επαναφορά των ρυθμίσεων της αρχειοθήκης {0}; Φάκελος αρχειοθήκης + Τα πρότυπα της αρχειοθήκης αποθηκεύτηκαν Μέγεθος μικρογραφιών Επαναφορά σε Αυτόματο Επιλογή φακέλου diff --git a/i18n/el/Tooltips.el.resx b/i18n/el/Tooltips.el.resx index dd97961a..0a446d7f 100644 --- a/i18n/el/Tooltips.el.resx +++ b/i18n/el/Tooltips.el.resx @@ -36,6 +36,7 @@ Άνοιγμα της ακολουθίας του πρώτου αντιγράφου στην οθόνη «Επεξεργασία» Εύρεση πανομοιότυπων φωτογραφιών σε όλες τις ακολουθίες μέσω hash · διαβάζει μόνο το ευρετήριο Εμφάνιση των ακολουθιών αυτού του έτους + Όνομα αρχείου κάθε φωτογραφίας, όπως το δίνουν οι εισαγωγές · ελέγχεται καθώς πληκτρολογείτε Διατήρηση μόνο των ακολουθιών μίας κάμερας Επιλογή αυτής της τιμής. Επιλέξτε την ξανά για απαλοιφή Διατήρηση μόνο των ακολουθιών σε μία κατάσταση @@ -71,7 +72,10 @@ Αναδόμηση του ευρετηρίου από τα αρχεία sidecar, με πλήρη σάρωση μεταδεδομένων όπου λείπουν. Τα πρωτότυπα δεν διαγράφονται ποτέ Προσθήκη της αναδόμησης στην ουρά · η αρχειοθήκη παραμένει διαθέσιμη στο μεταξύ Επιλογή του νέου φακέλου μιας αρχειοθήκης που μετακινήσατε. Οι ακολουθίες της ενημερώνονται αναλόγως - Εφαρμογή ακριβώς αυτών των αλλαγών σε φακέλους, αρχεία sidecar και ευρετήριο · συνεχίζει μετά από κατάρρευση + Τοποθέτηση στην ουρά μιας εργασίας που κάνει ακριβώς αυτές τις αλλαγές · παύση και συνέχισή της από τις Εργασίες + Μετονομασία των φωτογραφιών με αυτό το πρότυπο · όταν είναι ανενεργό, διατηρούν τα ονόματά τους + Μετακίνηση των φακέλων των ακολουθιών σε αυτή τη διάταξη · όταν είναι ανενεργό, μένουν στη θέση τους + Αλλαγή των τίτλων με αυτό το πρότυπο · όταν είναι ανενεργό, μένουν ως έχουν Επιλογή αντιγράφου ασφαλείας του ευρετηρίου στις Ρυθμίσεις › Για προχωρημένους. Αντικαθιστά το ευρετήριο στην επόμενη εκκίνηση Αλλαγή των ετικετών αυτών των ακολουθιών στα αρχεία sidecar και στο ευρετήριο Νέα εκτέλεση της ίδιας ενέργειας @@ -80,9 +84,8 @@ Εκτέλεση της ανάλυσης σε βάθος σε κάθε ακολουθία του συνόλου Μετακίνηση του συνόλου στον κάδο της αρχειοθήκης · εμφανίζει τη δοκιμαστική εκτέλεση και ζητά πληκτρολόγηση για επιβεβαίωση Εξαγωγή του συνόλου ως CSV: μία γραμμή ανά ακολουθία - Μετακίνηση του συνόλου σε νέα διάταξη φακέλων · πρώτα δοκιμαστική εκτέλεση Δημιουργία ή ανανέωση των proxy - Μετονομασία των τίτλων του συνόλου με πρότυπο · πρώτα δοκιμαστική εκτέλεση + Εφαρμογή προτύπων φακέλου, αρχείου και τίτλου στο σύνολο · πρώτα δοκιμαστική εκτέλεση, μετά εργασία Προσθήκη ή κατάργηση ετικετών σε ολόκληρο το σύνολο Δημιουργία ή ανανέωση των μικρογραφιών Νέος υπολογισμός του hash των πρωτοτύπων του συνόλου @@ -471,12 +474,12 @@ Λήψη από τον διακομιστή όσων λείπουν εδώ από {0:N0} ακολουθίες (πρωτότυπα ή αποδόσεις) · εκτελείται ως εργασίες μεταφοράς Αποθήκευση {0:N0} γραμμής ως CSV σε φάκελο της επιλογής σας Αποθήκευση {0:N0} γραμμών ως CSV σε φάκελο της επιλογής σας - Μετακίνηση {0:N0} ακολουθίας σε νέα διάταξη φακέλων της αρχειοθήκης της · πρώτα εμφανίζει τη δοκιμαστική εκτέλεση - Μετακίνηση {0:N0} ακολουθιών σε νέα διάταξη φακέλων της αρχειοθήκης τους · πρώτα εμφανίζει τη δοκιμαστική εκτέλεση Δημιουργία proxy JPEG για {0:N0} ακολουθία · εκτελείται ως μία εργασία Δημιουργία proxy JPEG για {0:N0} ακολουθίες · εκτελείται ως μία εργασία Ορισμός της βαθμολογίας {0:N0} ακολουθίας στο αρχείο sidecar της και στο ευρετήριο Ορισμός της βαθμολογίας {0:N0} ακολουθιών στα αρχεία sidecar τους και στο ευρετήριο + Εφαρμογή προτύπων φακέλου, αρχείου και τίτλου σε {0:N0} ακολουθία της αρχειοθήκης της · πρώτα δοκιμαστική εκτέλεση, μετά εργασία + Εφαρμογή προτύπων φακέλου, αρχείου και τίτλου σε {0:N0} ακολουθίες της αρχειοθήκης τους · πρώτα δοκιμαστική εκτέλεση, μετά εργασία Προσθήκη ή κατάργηση ετικετών σε {0:N0} ακολουθία Προσθήκη ή κατάργηση ετικετών σε {0:N0} ακολουθίες Αποστολή όσων λείπουν από τον διακομιστή για {0:N0} ακολουθία (πρωτότυπα και ρυθμίσεις ή αποδόσεις) · εκτελείται ως εργασία μεταφοράς @@ -692,6 +695,7 @@ Το «Ισορροπημένο» ταιριάζει στις περισσότερες εργασίες. Το «Βέλτιστο» μετρά σε διπλή ανάλυση και διαβάζει πιο μπροστά. Το «Γρήγορο» μετρά στη μισή ανάλυση με πρόχειρη εκτίμηση κίνησης Νέα καταγραφή των κωδικοποιητών μετά από εγκατάσταση προγράμματος οδήγησης ή codec Νέα αναζήτηση επεκτάσεων codec μετά την εγκατάσταση μιας επέκτασης. Οι επόμενες εργασίες τις χρησιμοποιούν + Εφαρμογή των προτύπων της αρχειοθήκης στις ακολουθίες που περιέχει ήδη · πρώτα δοκιμαστική εκτέλεση Επαναφορά όλων των ρυθμίσεων αυτού του υπολογιστή στις προεπιλογές τους. Ζητείται πρώτα επιβεβαίωση Εγγραφή των προεπιλεγμένων προτύπων και μεγεθών στο archive.json αυτής της αρχειοθήκης τώρα Επαναφορά όλων των ρυθμίσεων τώρα diff --git a/i18n/en/Admin.resx b/i18n/en/Admin.resx index 2a20d805..49d1a133 100644 --- a/i18n/en/Admin.resx +++ b/i18n/en/Admin.resx @@ -9,6 +9,7 @@ Chronos Server Running for Version + {0} reorganized the archive · {1}long {0} changed the archive layoutlong {0} deleted {1}long {0} started {1}long @@ -138,7 +139,7 @@ Import Light analysis Maintenance - Move + Reorganize Orphans Proxies Rebuild @@ -343,6 +344,7 @@ Sign in to administer this server User Your user name on this server + Archive reorganized Archive layout Photos deleted Job started @@ -427,6 +429,58 @@ Change password Replace the password and continue to the panel Choose a new password + Reorganize… + Apply folder, file and title templates to the selected sequences; a preview shows every change first + After: + Apply… + Reorganize as the preview shows; a confirmation comes first + Before: + Write a template, or switch this part off.long + Close without changing anything + Carried + Moves only because a folder it is inside moves + Renamed files + Folder + Sequence + Reorganize + Queue the job that moves and renames the originals; nothing is overwritten or deleted + {0} photo gets a new name.long + {0} photos get new names.long + {0} folder moves.long + {0} folders move.long + {0} sequence changes.long + {0} sequences change.long + Reorganize now? + Name of each photo as an import gives it, e.g. {date}_{time}_{n:0000}; the files beside a photo follow it + Files + Rename the photos of each sequence; off keeps every file name + {0} file renamedlong + {0} files renamedlong + Folder of each sequence in the archive, e.g. {year}/{date} {camera}; {title} is the new title + Folders + Move each sequence to the folder its template gives; off keeps every folder where it is + A selected sequence is no longer in the archive; close and select again.long + {0}: {1}long: a photo count, then why those photos keep their names + Switch on at least one part to change.long + Nothing to change: these sequences already follow the templates.long + Reorganize… + Apply the new templates to the sequences already in the archive; a preview shows every change first + Open job + Show the job and its log on the Jobs page + The archive changed during the confirmation; check the new preview and apply again.long + Planning… + Preview + What each sequence becomes, in the order the changes apply; nothing has changed yet + Reorganize queued. + This folder stays where it is + Reorganize {0} sequence + Reorganize {0} sequences + Reorganize all sequences + New title of each sequence, e.g. {date} {camera}; {title} is the current title + Titles + Give each sequence the title its template makes; off keeps every title + Reorganize takes at most {0} sequences at once, or every sequence: clear the filters and select all.long + Sequences changed: {0} · files renamed: {1} · names kept: {2}long Administrator Editor Uploader diff --git a/i18n/en/Archive.resx b/i18n/en/Archive.resx index 5b747fd9..4eb785a4 100644 --- a/i18n/en/Archive.resx +++ b/i18n/en/Archive.resx @@ -15,6 +15,7 @@ Wait until the changes are applied.long The set is empty: change the selection or the filter.long Nothing would change.long + Turn on at least one template.long The archive must be online and writable.long Wait for the dry run.long Wait until the archive is read.long @@ -86,6 +87,12 @@ {0} was written by a newer Chronos (format {1}).long: error sentence The archive {0} is offline.long: error sentence The archive {0} is read-only.long: error sentence + {0:N0} sequence kept its file names: a photo was in use or its new name was taken.long: error sentence of a Reorganize job + {0:N0} sequences kept their file names: a photo was in use or its new name was taken.long: error sentence of a Reorganize job + {0:N0} sequence was not reorganized as planned: it changed after the plan.long: error sentence of a Reorganize job + {0:N0} sequences were not reorganized as planned: they changed after the plan.long: error sentence of a Reorganize job + {0:N0} sequence kept its title and file names: its sequence file is from a newer Chronos.long: error sentence of a Reorganize job + {0:N0} sequences kept their titles and file names: their sequence files are from a newer Chronos.long: error sentence of a Reorganize job {0} changed after the plan was made.long: error sentence The card or folder {0} is no longer available.long: error sentence The archive changed after this plan was made.long: error sentence @@ -151,6 +158,14 @@ Unindexed photos: {0}, missing photos: {1}long: job log line {0}: made {1}, reused {2}, unreadable {3}, waiting {4}long: job log line; {4} frames whose proxy this host waits for from a client or render node Proxies for the server: {0} sent, {1} not sentlong: job log line; {0} proxies sent; {1} proxies this PC could not make or the server refused + Left as it was, the folder it is in stayed: {0}long: job log line; {0} sequence title or folder + Left as it was, changed after the plan: {0}long: job log line; {0} sequence title or folder + File names kept, a photo was in use or its new name was taken: {0}long: job log line; {0} sequence title or folder + File names kept, photos changed after the plan: {0}long: job log line; {0} sequence title or folder + Title and file names kept, its sequence file is from a newer Chronos: {0}long: job log line; {0} sequence title or folder + Title and file names kept, changed after the plan: {0}long: job log line; {0} sequence title or folder + Sequences changed: {0}, files renamed: {1}long: job log line of a Reorganize; {0} sequences, {1} photos + The reorganization was completed when the archive was openedlong: job log line Report only: nothing was changed.long: job log line Folders: {0}, indexed: {1}, adopted: {2}, removed: {3}long: job log line Sequence not found: {0}long: job log line @@ -206,14 +221,30 @@ Folder of the moved archive Apply {0} of {1} - Rename {0:N0} sequence - Rename {0:N0} sequences - Move {0:N0} sequence - Move {0:N0} sequences Changes {0:N0} of {1:N0} changes {0:N0} of {1:N0} change - Template + Photos kept in place outside originals keep their names.long: why photos keep their names in a Reorganize dry run + Missing photos keep their names.long: why photos keep their names in a Reorganize dry run + Photos never verified keep their names; verify the sequence first.long: why photos keep their names in a Reorganize dry run + The sequence file cannot be read; the sequence stays as it is, and so does any folder it is in.long: why a sequence keeps its folder, title and photo names in a Reorganize dry run + Follows its folder + {0}: {1} to {2}long: what a screen reader says for one line of the Reorganize dry run; {0} Folder, Title or File, {1} before, {2} after + File + File names + Folder + Folders + Reorganize {0:N0} sequence + Reorganize {0:N0} sequences + Reorganize {0}long: dialog heading; {0} archive name + {0:N0} name kept + {0:N0} names kept + Dry run… + {0:N0} file renamed + {0:N0} files renamed + Title + Titles + Reorganize opens when the open dialog closeslong: toast when the Settings toast's Reorganize… finds another Archive dialog open Add tags Apply Tags of {0:N0} sequence @@ -228,9 +259,8 @@ Export CSV Set filter Filtered set - Move… Proxies - Rename… + Reorganize… Retag… Thumbnails Verify diff --git a/i18n/en/Errors.resx b/i18n/en/Errors.resx index 13ec9fad..47e8adbe 100644 --- a/i18n/en/Errors.resx +++ b/i18n/en/Errors.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Sequences not analysed: {0} of {1}; see the job log.long; {0} failed count (2 or more); {1} total count + The folder of this sequence is not where the index has it; try again after the next scan. The archive could not be opened.long The current index could not be backed up or replaced; the restore runs again at the next start.long This backup cannot be restored; choose another one.long @@ -38,8 +39,10 @@ The template is empty. Empty token at position {1}: write a name between the braces. File names cannot contain a slash; put folders in the folder template. + The photos would lose their extension: write a dot before {ext}, or leave {ext} out. The format after the colon does not suit its token. Names would repeat: add the frame number, the time or the original name. + Scans skip folders that start with a dot or are named originals, proxies or exports. The brace opened at position {1} is never closed. Unknown token “{0}” at position {1}. The closing brace at position {1} has no opening one; double it for a literal brace. diff --git a/i18n/en/Jobs.resx b/i18n/en/Jobs.resx index 767a399a..d60462c4 100644 --- a/i18n/en/Jobs.resx +++ b/i18n/en/Jobs.resx @@ -76,7 +76,7 @@ Import Light analysis Maintenance - Move archive + Reorganize Orphans Proxies Rebuild index diff --git a/i18n/en/Library.resx b/i18n/en/Library.resx index 43a16d4b..6bc44f48 100644 --- a/i18n/en/Library.resx +++ b/i18n/en/Library.resx @@ -10,17 +10,16 @@ Download Export list Folder - Move… Open Proxies Rating Render + Reorganize… Sync Tags… Upload Verify Adopt a folder - Move works on the sequences of one archive at a time.long The same on this PC and on the server: nothing to sync.long No saved view is in use; choose one first.long Your server account cannot download originals.long @@ -32,6 +31,7 @@ Sign in to a Chronos Server first, on the Server screen.long The selected sequences have nothing to fetch from the server.long The server already has what the selected sequences hold.long + Reorganize works on the sequences of one archive at a time.long Only for sequences on this PC; the selection lives on the server.long A transfer of this sequence is already under way.long Clear filters diff --git a/i18n/en/Server.resx b/i18n/en/Server.resx index 48a6e115..5e7a8059 100644 --- a/i18n/en/Server.resx +++ b/i18n/en/Server.resx @@ -42,6 +42,7 @@ The connection failed; the log has the details.long A file of the sequence is open in another program; close it and try again.long Its folder is no longer on disk; nothing is left to move to the trash.long + The folder of this sequence is not where the server's index has it; try again after its next scan.long Your account cannot do this.long The photos of the sequence changed on the server; reload it and apply your edit again.long The file arrived damaged; upload it again.long @@ -70,11 +71,14 @@ This server cannot run that kind of job.long The last administrator cannot be removed or disabled.long This method is not allowed here.long + A new folder would lie inside the folder of another sequence.long Not found.long That address is not a Chronos Server.long Change your password first.long The photo was deleted from the sequence while it was being uploaded, so it was not added.long {0} cannot be read, and without its hash other copies would not learn it was deleted; close the program using it or check its permissions, then try again.long + The archive changed after the dry run; review the plan again.long + The server stopped making this plan: it took too long, or too many were asked at once; try again shortly.long This page did not come through a trusted proxy over HTTPS. Open it through your proxy, or add the proxy's address to CHRONOS_TRUSTED_PROXIES.long This archive makes no proxies.long The proxy was made from another photo.long diff --git a/i18n/en/Settings.resx b/i18n/en/Settings.resx index 0e6e5694..dc162458 100644 --- a/i18n/en/Settings.resx +++ b/i18n/en/Settings.resx @@ -65,6 +65,7 @@ stars per megapixel Analysis width px long edge + Folders and files already in the archive keep their names.long File names Folders {0} free @@ -74,10 +75,12 @@ Choose the archive folder Preview Proxy size + Reorganize… Reset archive Its naming templates, proxy size and thumbnail size return to their defaults for every PC and server that uses it. Folders and files already in the archive keep their names.long Reset the settings of {0}?long; {0} archive name Archive folder + Archive templates saved Thumbnail size Back to Auto Choose folder diff --git a/i18n/en/Tooltips.resx b/i18n/en/Tooltips.resx index f2da9002..63103f3b 100644 --- a/i18n/en/Tooltips.resx +++ b/i18n/en/Tooltips.resx @@ -36,6 +36,7 @@ Open the sequence of the first copy in Edit Find identical photos across sequences by hash · reads the index only Show the sequences of this year + File name of each photo, as imports name them · checked as you type Keep only the sequences of one camera Choose this value; choose it again to clear it Keep only the sequences in one state @@ -71,7 +72,10 @@ Rebuild the index from the sidecars; falls back to a full metadata scan; never deletes originals Queue the rebuild · the archive stays usable meanwhile Choose the new folder of an archive you moved; its sequences follow - Make exactly these changes to folders, sidecars and index · resumes after a crash + Queue a job that makes exactly these changes · pause and resume it in Jobs + Rename the photos with this template · off, they keep their names + Move the sequence folders into this layout · off, they stay where they are + Change the titles with this template · off, they stay as they are Choose a backup of the index in Settings › Advanced; it replaces the index at the next start Change the tags of these sequences in sidecars and index Run the same action again @@ -80,9 +84,8 @@ Run the deep analysis on every sequence in the set Move the set to the archive's trash · shows the dry run, then asks you to type to confirm Export the set as CSV: one row per sequence - Move the set into a new folder layout · dry run first Generate or refresh proxies - Rename the titles of the set with a template · dry run first + Apply folder, file and title templates to the set · dry run first, then a job Add or remove tags on the whole set Generate or refresh thumbnails Re-hash the originals of the set @@ -472,12 +475,12 @@ Fetch what {0:N0} sequences lack here (originals or renders) from the server · runs as transfer jobs Save {0:N0} row as CSV in a folder you choose Save {0:N0} rows as CSV in a folder you choose - Move {0:N0} sequence into a new folder layout of its archive · shows the dry run first - Move {0:N0} sequences into a new folder layout of their archive · shows the dry run first Build JPEG proxies of {0:N0} sequence · runs as one job Build JPEG proxies of {0:N0} sequences · runs as one job Set the rating of {0:N0} sequence, in its sidecar and the index Set the rating of {0:N0} sequences, in their sidecars and the index + Apply folder, file and title templates to {0:N0} sequence of its archive · dry run first, then a job + Apply folder, file and title templates to {0:N0} sequences of their archive · dry run first, then a job Add or remove tags on {0:N0} sequence Add or remove tags on {0:N0} sequences Send what the server lacks of {0:N0} sequence (originals and settings, or renders) · runs as a transfer job @@ -694,6 +697,7 @@ Balanced suits most work; Best measures at double resolution and reads further ahead; Fast measures at half resolution with draft motion List the encoders again after a driver or codec install Look for codec extensions again after installing one; the next jobs use them + Apply the archive's templates to the sequences already in it · dry run first Return every setting of this PC to its default; asks first Write the default templates and sizes into this archive's archive.json now Reset every setting now diff --git a/i18n/es/Admin.es.resx b/i18n/es/Admin.es.resx index cc11b5c7..8a109fc3 100644 --- a/i18n/es/Admin.es.resx +++ b/i18n/es/Admin.es.resx @@ -9,6 +9,7 @@ Chronos Server Tiempo activo Versión + {0} reorganizó la fototeca · {1} {0} cambió la organización de la fototeca {0} eliminó {1} {0} inició {1} @@ -138,7 +139,7 @@ Importación Análisis rápido Mantenimiento - Traslado + Reorganización Huérfanos Proxies Reconstrucción @@ -343,6 +344,7 @@ Inicia sesión para administrar este servidor Usuario Tu nombre de usuario en este servidor + Fototeca reorganizada Organización de la fototeca Fotos eliminadas Tarea iniciada @@ -426,6 +428,58 @@ Cambiar contraseña Sustituye la contraseña y continúa al panel Elige una nueva contraseña + Reorganizar… + Aplica las plantillas de carpeta, archivo y título a las secuencias seleccionadas; una vista previa muestra antes cada cambio + Después: + Aplicar… + Reorganiza según muestra la vista previa; antes pide confirmación + Antes: + Escribe una plantilla o desactiva esta parte. + Cierra sin cambiar nada + Arrastrada + Se mueve solo porque se mueve una carpeta que la contiene + Archivos renombrados + Carpeta + Secuencia + Reorganizar + Pone en cola la tarea que mueve y renombra los originales; no se sobrescribe ni se elimina nada + {0} foto recibe un nombre nuevo. + {0} fotos reciben nombres nuevos. + Se mueve {0} carpeta. + Se mueven {0} carpetas. + Cambia {0} secuencia. + Cambian {0} secuencias. + ¿Reorganizar ahora? + Nombre de cada foto tal como lo asigna una importación, p. ej. {date}_{time}_{n:0000}; los archivos que acompañan a una foto la siguen + Archivos + Renombra las fotos de cada secuencia; desactivado conserva todos los nombres de archivo + {0} archivo renombrado + {0} archivos renombrados + Carpeta de cada secuencia en la fototeca, p. ej. {year}/{date} {camera}; {title} es el título nuevo + Carpetas + Mueve cada secuencia a la carpeta que da su plantilla; desactivado deja cada carpeta donde está + Una secuencia seleccionada ya no está en la fototeca; cierra y vuelve a seleccionar. + {0}: {1} + Activa al menos una parte que cambiar. + Nada que cambiar: estas secuencias ya siguen las plantillas. + Reorganizar… + Aplica las plantillas nuevas a las secuencias que ya están en la fototeca; una vista previa muestra antes cada cambio + Abrir tarea + Muestra la tarea y su registro en la página Tareas + La fototeca cambió durante la confirmación; revisa la nueva vista previa y vuelve a aplicar. + Planificando… + Vista previa + En qué se convierte cada secuencia, en el orden en que se aplican los cambios; todavía no ha cambiado nada + Reorganización en cola. + Esta carpeta se queda donde está + Reorganizar {0} secuencia + Reorganizar {0} secuencias + Reorganizar todas las secuencias + Título nuevo de cada secuencia, p. ej. {date} {camera}; {title} es el título actual + Títulos + Da a cada secuencia el título que genera su plantilla; desactivado conserva todos los títulos + Reorganizar admite como máximo {0} secuencias a la vez, o todas: quita los filtros y selecciona todo. + Secuencias cambiadas: {0} · archivos renombrados: {1} · nombres conservados: {2} Administrador Editor Colaborador diff --git a/i18n/es/Archive.es.resx b/i18n/es/Archive.es.resx index 2eadd957..756c6080 100644 --- a/i18n/es/Archive.es.resx +++ b/i18n/es/Archive.es.resx @@ -15,6 +15,7 @@ Espera a que se apliquen los cambios. El conjunto está vacío: cambia la selección o el filtro. No cambiaría nada. + Activa al menos una plantilla. La fototeca debe estar en línea y admitir escritura. Espera a que termine la simulación. Espera a que se lea la fototeca. @@ -81,6 +82,12 @@ {0} se escribió con una versión más reciente de Chronos (formato {1}). La fototeca {0} está sin conexión. La fototeca {0} es de solo lectura. + {0:N0} secuencia conservó sus nombres de archivo: una foto estaba en uso o su nombre nuevo ya existía. + {0:N0} secuencias conservaron sus nombres de archivo: una foto estaba en uso o su nombre nuevo ya existía. + {0:N0} secuencia no se reorganizó según lo previsto: cambió después del plan. + {0:N0} secuencias no se reorganizaron según lo previsto: cambiaron después del plan. + {0:N0} secuencia conservó su título y sus nombres de archivo: su archivo de secuencia es de una versión más reciente de Chronos. + {0:N0} secuencias conservaron sus títulos y nombres de archivo: sus archivos de secuencia son de una versión más reciente de Chronos. {0} cambió después de crear el plan. La tarjeta o carpeta {0} ya no está disponible. La fototeca cambió después de crear este plan. @@ -146,6 +153,14 @@ Fotos sin indexar: {0}, fotos que faltan: {1} {0}: generados {1}, reutilizados {2}, ilegibles {3}, en espera {4} Proxies para el servidor: enviados {0}, sin enviar {1} + Se dejó como estaba, la carpeta que la contiene no se movió: {0} + Se dejó como estaba, cambió después del plan: {0} + Nombres de archivo conservados, una foto estaba en uso o su nombre nuevo ya existía: {0} + Nombres de archivo conservados, las fotos cambiaron después del plan: {0} + Título y nombres de archivo conservados, su archivo de secuencia es de una versión más reciente de Chronos: {0} + Título y nombres de archivo conservados, cambió después del plan: {0} + Secuencias cambiadas: {0}, archivos renombrados: {1} + La reorganización se completó al abrir la fototeca Solo informe: no se ha cambiado nada. Carpetas: {0}, indexadas: {1}, incorporadas: {2}, eliminadas: {3} Secuencia no encontrada: {0} @@ -200,14 +215,30 @@ Carpeta de la fototeca movida Aplicar {0} de {1} - Cambiar nombre de {0:N0} secuencia - Cambiar nombre de {0:N0} secuencias - Mover {0:N0} secuencia - Mover {0:N0} secuencias Cambios {0:N0} de {1:N0} cambia {0:N0} de {1:N0} cambian - Plantilla + Las fotos que se mantienen en su sitio fuera de originals conservan sus nombres. + Las fotos que faltan conservan sus nombres. + Las fotos nunca verificadas conservan sus nombres; verifica primero la secuencia. + No se puede leer el archivo de la secuencia; la secuencia se queda como está, igual que cualquier carpeta que la contenga. + Sigue a su carpeta + {0}: de {1} a {2} + Archivo + Nombres de archivo + Carpeta + Carpetas + Reorganizar {0:N0} secuencia + Reorganizar {0:N0} secuencias + Reorganizar {0} + {0:N0} nombre conservado + {0:N0} nombres conservados + Simulación… + {0:N0} archivo renombrado + {0:N0} archivos renombrados + Título + Títulos + Reorganizar se abrirá cuando se cierre el cuadro de diálogo abierto Añadir etiquetas Aplicar Etiquetas de {0:N0} secuencia @@ -222,9 +253,8 @@ Exportar CSV Filtro del conjunto Conjunto filtrado - Mover… Proxies - Cambiar nombre… + Reorganizar… Etiquetar… Miniaturas Verificar diff --git a/i18n/es/Errors.es.resx b/i18n/es/Errors.es.resx index 38576cde..f26460d9 100644 --- a/i18n/es/Errors.es.resx +++ b/i18n/es/Errors.es.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Secuencias sin analizar: {0} de {1}; consulta el registro de la tarea. + La carpeta de esta secuencia no está donde la indica el índice; inténtalo de nuevo después del próximo escaneo. No se pudo abrir la fototeca. No se pudo hacer una copia de seguridad del índice actual ni sustituirlo; la restauración se volverá a ejecutar en el próximo inicio. Esta copia de seguridad no se puede restaurar; elige otra. @@ -37,9 +38,11 @@ {0} originales faltan o han cambiado desde que se archivaron; verifica la fototeca. La plantilla está vacía. Marcador vacío en la posición {1}: escribe un nombre entre las llaves. + Las fotos perderían su extensión: escribe un punto antes de {ext} o quita {ext}. Los nombres de archivo no pueden contener una barra; pon las carpetas en la plantilla de carpeta. El formato que sigue a los dos puntos no es adecuado para su marcador. Los nombres se repetirían: añade el número de fotograma, la hora o el nombre original. + Los escaneos omiten las carpetas que empiezan por un punto o se llaman originals, proxies o exports. La llave abierta en la posición {1} nunca se cierra. Marcador desconocido «{0}» en la posición {1}. La llave de cierre de la posición {1} no tiene llave de apertura; duplícala para obtener una llave literal. diff --git a/i18n/es/Jobs.es.resx b/i18n/es/Jobs.es.resx index f4b83936..a77d2646 100644 --- a/i18n/es/Jobs.es.resx +++ b/i18n/es/Jobs.es.resx @@ -76,7 +76,7 @@ Importación Análisis rápido Mantenimiento - Traslado de fototeca + Reorganización Huérfanos Proxies Reconstrucción del índice diff --git a/i18n/es/Library.es.resx b/i18n/es/Library.es.resx index fa22c22d..cbe63abe 100644 --- a/i18n/es/Library.es.resx +++ b/i18n/es/Library.es.resx @@ -10,17 +10,16 @@ Descargar Exportar lista Carpeta - Mover… Abrir Proxies Valoración Renderizar + Reorganizar… Sincronizar Etiquetas… Subir Verificar Incorporar una carpeta - Mover actúa sobre las secuencias de una sola fototeca a la vez. Igual en este equipo y en el servidor: no hay nada que sincronizar. No hay ninguna vista guardada en uso; elige una primero. Tu cuenta del servidor no puede descargar originales. @@ -32,6 +31,7 @@ Inicia sesión primero en un Chronos Server, en la pantalla Servidor. Las secuencias seleccionadas no tienen nada que obtener del servidor. El servidor ya tiene lo que contienen las secuencias seleccionadas. + Reorganizar actúa sobre las secuencias de una sola fototeca a la vez. Solo para secuencias de este equipo; la selección está en el servidor. Ya hay una transferencia de esta secuencia en curso. Quitar filtros diff --git a/i18n/es/Server.es.resx b/i18n/es/Server.es.resx index fa62e6c9..6bd77bdc 100644 --- a/i18n/es/Server.es.resx +++ b/i18n/es/Server.es.resx @@ -40,6 +40,7 @@ La conexión falló; consulta el registro para ver los detalles. Un archivo de la secuencia está abierto en otro programa; ciérralo e inténtalo de nuevo. Su carpeta ya no está en el disco; no queda nada que mover a la papelera. + La carpeta de esta secuencia no está donde la indica el índice del servidor; inténtalo de nuevo después de su próximo escaneo. Tu cuenta no puede hacer esto. Las fotos de la secuencia cambiaron en el servidor; vuelve a cargarla y aplica de nuevo tu cambio. El archivo llegó dañado; vuelve a subirlo. @@ -68,11 +69,14 @@ Este servidor no puede ejecutar ese tipo de tarea. No se puede quitar ni deshabilitar al último administrador. Este método no está permitido aquí. + Una carpeta nueva quedaría dentro de la carpeta de otra secuencia. Esa dirección no es un Chronos Server. No encontrado. Primero cambia tu contraseña. La foto se eliminó de la secuencia mientras se subía, así que no se añadió. No se puede leer {0} y, sin su hash, las demás copias no sabrían que se eliminó; cierra el programa que lo usa o revisa sus permisos y vuelve a intentarlo. + La fototeca cambió después de la simulación; vuelve a revisar el plan. + El servidor dejó de preparar este plan: tardaba demasiado o se pidieron demasiados a la vez; inténtalo de nuevo en breve. Esta fototeca no genera proxies. El proxy se generó a partir de otra foto. El servidor no necesita un proxy de esta foto. diff --git a/i18n/es/Settings.es.resx b/i18n/es/Settings.es.resx index 81e39629..4d6da3a4 100644 --- a/i18n/es/Settings.es.resx +++ b/i18n/es/Settings.es.resx @@ -65,6 +65,7 @@ estrellas por megapíxel Ancho de análisis px en el lado largo + Las carpetas y los archivos que ya están en la fototeca conservan sus nombres. Nombres de archivo Carpetas {0} libres @@ -74,10 +75,12 @@ Elegir la carpeta de la fototeca Vista previa Tamaño de proxy + Reorganizar… Restablecer fototeca Sus plantillas de nombres, el tamaño de proxy y el tamaño de miniatura vuelven a sus valores predeterminados en todos los equipos y servidores que la usan. Las carpetas y los archivos que ya están en la fototeca conservan sus nombres. ¿Restablecer la configuración de {0}? Carpeta de la fototeca + Plantillas de la fototeca guardadas Tamaño de miniatura Volver a Auto Elegir carpeta diff --git a/i18n/es/Tooltips.es.resx b/i18n/es/Tooltips.es.resx index a29328e4..6a5824a9 100644 --- a/i18n/es/Tooltips.es.resx +++ b/i18n/es/Tooltips.es.resx @@ -36,6 +36,7 @@ Abre la secuencia de la primera copia en la pantalla Edición Busca fotos idénticas entre secuencias por su hash · solo lee el índice Muestra las secuencias de este año + Nombre de archivo de cada foto, tal como lo asignan las importaciones · se comprueba mientras escribes Deja solo las secuencias de una cámara Elige este valor; vuelve a elegirlo para quitarlo Deja solo las secuencias en un estado @@ -71,7 +72,10 @@ Reconstruye el índice a partir de los archivos sidecar; si no, recurre a un escaneo completo de metadatos; nunca elimina originales Pone en cola la reconstrucción · mientras tanto la fototeca sigue disponible Elige la nueva carpeta de una fototeca que has movido; sus secuencias la siguen - Aplica exactamente estos cambios en carpetas, archivos sidecar e índice · se reanuda tras un cierre inesperado + Pone en cola una tarea que hace exactamente estos cambios · puedes pausarla y reanudarla en Tareas + Renombra las fotos con esta plantilla · desactivado, conservan sus nombres + Mueve las carpetas de las secuencias a esta organización · desactivado, se quedan donde están + Cambia los títulos con esta plantilla · desactivado, se quedan como están Elige una copia de seguridad del índice en Configuración › Avanzado; sustituye al índice en el próximo inicio Cambia las etiquetas de estas secuencias en los archivos sidecar y en el índice Vuelve a ejecutar la misma acción @@ -80,9 +84,8 @@ Ejecuta el análisis profundo en todas las secuencias del conjunto Mueve el conjunto a la papelera de la fototeca · muestra la simulación y luego te pide que escribas para confirmar Exporta el conjunto como CSV: una fila por secuencia - Mueve el conjunto a una nueva estructura de carpetas · primero hace una simulación Genera o actualiza los proxies - Cambia los títulos del conjunto con una plantilla · primero hace una simulación + Aplica plantillas de carpeta, archivo y título al conjunto · primero una simulación, luego una tarea Añade o quita etiquetas en todo el conjunto Genera o actualiza las miniaturas Vuelve a calcular el hash de los originales del conjunto @@ -471,12 +474,12 @@ Obtiene del servidor lo que les falta aquí a {0:N0} secuencias (originales o renderizados) · se ejecuta en tareas de transferencia Guarda {0:N0} fila como CSV en una carpeta que elijas Guarda {0:N0} filas como CSV en una carpeta que elijas - Mueve {0:N0} secuencia a una nueva estructura de carpetas de su fototeca · primero hace una simulación - Mueve {0:N0} secuencias a una nueva estructura de carpetas de su fototeca · primero hace una simulación Genera proxies JPEG de {0:N0} secuencia · se ejecuta como una sola tarea Genera proxies JPEG de {0:N0} secuencias · se ejecuta como una sola tarea Establece la valoración de {0:N0} secuencia, en su archivo sidecar y en el índice Establece la valoración de {0:N0} secuencias, en sus archivos sidecar y en el índice + Aplica plantillas de carpeta, archivo y título a {0:N0} secuencia de su fototeca · primero una simulación, luego una tarea + Aplica plantillas de carpeta, archivo y título a {0:N0} secuencias de su fototeca · primero una simulación, luego una tarea Añade o quita etiquetas en {0:N0} secuencia Añade o quita etiquetas en {0:N0} secuencias Envía al servidor lo que le falta de {0:N0} secuencia (originales y configuración, o renderizados) · se ejecuta como tarea de transferencia @@ -692,6 +695,7 @@ Equilibrado sirve para casi todo; Óptimo mide a doble resolución y lee más fotogramas por adelantado; Rápido mide a media resolución con movimiento en borrador Vuelve a listar los codificadores tras instalar un controlador o un códec Vuelve a buscar extensiones de códec después de instalar una; las próximas tareas las usan + Aplica las plantillas de la fototeca a las secuencias que ya contiene · primero una simulación Devuelve todos los ajustes de este equipo a su valor predeterminado; pide confirmación antes Escribe ahora las plantillas y los tamaños predeterminados en el archivo archive.json de esta fototeca Restablece ahora todos los ajustes diff --git a/i18n/et/Admin.et.resx b/i18n/et/Admin.et.resx index 8314fe6c..6ec89ff7 100644 --- a/i18n/et/Admin.et.resx +++ b/i18n/et/Admin.et.resx @@ -9,6 +9,7 @@ Chronos Server Tööaeg Versioon + {0} korraldas arhiivi ümber · {1} {0} muutis arhiivi paigutust {0} kustutas {1} {0} käivitas töö {1} @@ -138,7 +139,7 @@ Importimine Kiiranalüüs Hooldus - Teisaldamine + Ümberkorraldamine Orbfailid Proksid Taasloomine @@ -343,6 +344,7 @@ Logige sisse, et seda serverit hallata Kasutaja Teie kasutajanimi selles serveris + Arhiiv ümber korraldatud Arhiivi paigutus Fotod kustutatud Töö käivitatud @@ -426,6 +428,58 @@ Muuda parooli Asendage parool ja liikuge edasi paneelile Valige uus parool + Korralda ümber… + Rakendage valitud jadadele kausta-, failinime- ja pealkirjamallid; eelvaade näitab enne iga muudatust + Pärast: + Rakenda… + Korraldage ümber nii, nagu eelvaade näitab; enne küsitakse kinnitust + Enne: + Kirjutage mall või lülitage see osa välja. + Sulgege midagi muutmata + Liigub kaasa + Liigub ainult seetõttu, et teisaldatakse kaust, milles see asub + Ümber nimetatud failid + Kaust + Jada + Korralda ümber + Lisage järjekorda töö, mis teisaldab originaalid ja nimetab need ümber; midagi ei kirjutata üle ega kustutata + {0} foto saab uue nime. + {0} fotot saavad uue nime. + Teisaldatakse {0} kaust. + Teisaldatakse {0} kausta. + Muutub {0} jada. + Muutub {0} jada. + Kas korraldada kohe ümber? + Iga foto nimi, nagu import selle annab, nt {date}_{time}_{n:0000}; foto kõrval olevad failid järgivad seda + Failid + Nimetab iga jada fotod ümber; väljalülitatuna jäävad kõik failinimed alles + {0} fail nimetati ümber + {0} faili nimetati ümber + Iga jada kaust arhiivis, nt {year}/{date} {camera}; {title} on uus pealkiri + Kaustad + Teisaldab iga jada kausta, mille selle mall annab; väljalülitatuna jääb iga kaust oma kohale + Üks valitud jada pole enam arhiivis; sulgege aken ja valige uuesti. + {0}: {1} + Lülitage sisse vähemalt üks muudetav osa. + Pole midagi muuta: need jadad järgivad juba malle. + Korralda ümber… + Rakendage uued mallid arhiivis juba olevatele jadadele; eelvaade näitab enne iga muudatust + Ava töö + Kuvage töö ja selle logi tööde lehel + Arhiiv muutus kinnitamise ajal; vaadake uus eelvaade üle ja rakendage uuesti. + Plaani koostamine… + Eelvaade + Milliseks iga jada muutub, muudatuste rakendamise järjekorras; veel pole midagi muudetud + Ümberkorraldamine on järjekorras. + See kaust jääb oma kohale + Korralda {0} jada ümber + Korralda {0} jada ümber + Korralda kõik jadad ümber + Iga jada uus pealkiri, nt {date} {camera}; {title} on praegune pealkiri + Pealkirjad + Annab igale jadale pealkirja, mille selle mall loob; väljalülitatuna jäävad kõik pealkirjad alles + Ümberkorraldamine võtab korraga kuni {0} jada või kõik jadad: tühjendage filtrid ja valige kõik. + Muudetud jadasid: {0} · ümber nimetatud faile: {1} · säilitatud nimesid: {2} Administraator Toimetaja Üleslaadija diff --git a/i18n/et/Archive.et.resx b/i18n/et/Archive.et.resx index 10780949..76755bd8 100644 --- a/i18n/et/Archive.et.resx +++ b/i18n/et/Archive.et.resx @@ -15,6 +15,7 @@ Oodake, kuni muudatused on rakendatud. Valik on tühi: muutke valikut või filtrit. Midagi ei muutuks. + Lülitage sisse vähemalt üks mall. Arhiiv peab olema saadaval ja kirjutatav. Oodake proovikäivituse lõppu. Oodake, kuni arhiiv on loetud. @@ -81,6 +82,12 @@ {0} on kirjutatud uuema Chronosega (vorming {1}). Arhiiv {0} ei ole saadaval. Arhiiv {0} on kirjutuskaitstud. + {0:N0} jada säilitas oma failinimed: mõni foto oli kasutusel või selle uus nimi oli juba võetud. + {0:N0} jada säilitasid oma failinimed: mõni foto oli kasutusel või selle uus nimi oli juba võetud. + {0:N0} jada ei korraldatud ümber kavandatud viisil: see muutus pärast plaani koostamist. + {0:N0} jada ei korraldatud ümber kavandatud viisil: need muutusid pärast plaani koostamist. + {0:N0} jada säilitas oma pealkirja ja failinimed: selle jadafail pärineb uuemast Chronosest. + {0:N0} jada säilitasid oma pealkirjad ja failinimed: nende jadafailid pärinevad uuemast Chronosest. {0} muutus pärast plaani koostamist. Kaart või kaust {0} ei ole enam saadaval. Arhiiv muutus pärast selle plaani koostamist. @@ -146,6 +153,14 @@ Indekseerimata fotosid: {0}, puuduvaid fotosid: {1} {0}: loodud {1}, taaskasutatud {2}, loetamatuid {3}, ootel {4} Proksid serverile: saadetud {0}, saatmata {1} + Jäeti endiseks, kaust, milles see asub, jäi paigale: {0} + Jäeti endiseks, muutus pärast plaani koostamist: {0} + Failinimed säilitati, mõni foto oli kasutusel või selle uus nimi oli juba võetud: {0} + Failinimed säilitati, fotod muutusid pärast plaani koostamist: {0} + Pealkiri ja failinimed säilitati, selle jadafail pärineb uuemast Chronosest: {0} + Pealkiri ja failinimed säilitati, muutus pärast plaani koostamist: {0} + Muudetud jadasid: {0}, ümber nimetatud faile: {1} + Ümberkorraldamine viidi lõpule arhiivi avamisel Ainult aruanne: midagi ei muudetud. Kaustu: {0}, indekseeritud: {1}, üle võetud: {2}, eemaldatud: {3} Jada ei leitud: {0} @@ -200,14 +215,30 @@ Teisaldatud arhiivi kaust Rakenda {0} / {1} - Nimeta ümber {0:N0} jada - Nimeta ümber {0:N0} jada - Teisalda {0:N0} jada - Teisalda {0:N0} jada Muudatused {1:N0}-st muutub {0:N0} {1:N0}-st muutub {0:N0} - Mall + Väljaspool kausta originals oma kohale jäetud fotod säilitavad oma nimed. + Puuduvad fotod säilitavad oma nimed. + Kunagi kontrollimata fotod säilitavad oma nimed; kontrollige esmalt jada. + Jadafaili ei saa lugeda; jada jääb samaks, nagu ka iga kaust, milles see asub. + Järgib oma kausta + {0}: enne {1}, pärast {2} + Fail + Failinimed + Kaust + Kaustad + Korralda {0:N0} jada ümber + Korralda {0:N0} jada ümber + Korralda arhiiv {0} ümber + {0:N0} nimi säilitati + {0:N0} nime säilitati + Proovikäivitus… + {0:N0} fail nimetati ümber + {0:N0} faili nimetati ümber + Pealkiri + Pealkirjad + Ümberkorraldamine avaneb, kui avatud dialoog suletakse Lisa sildid Rakenda {0:N0} jada sildid @@ -222,9 +253,8 @@ Ekspordi CSV Valiku filter Filtreeritud valik - Teisalda… Proksid - Nimeta ümber… + Korralda ümber… Muuda silte… Pisipildid Kontrolli diff --git a/i18n/et/Errors.et.resx b/i18n/et/Errors.et.resx index 668ac973..b9750f70 100644 --- a/i18n/et/Errors.et.resx +++ b/i18n/et/Errors.et.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Analüüsimata jadad: {0} / {1}; vaadake töö logi. + Selle jada kaust pole seal, kus indeks seda näitab; proovige uuesti pärast järgmist skannimist. Arhiivi ei saanud avada. Praegust indeksit ei saanud varundada ega asendada; taastamist proovitakse uuesti järgmisel käivitamisel. Seda varukoopiat ei saa taastada; valige mõni teine. @@ -37,9 +38,11 @@ {0} originaali puudub või on pärast arhiveerimist muutunud; kontrollige arhiivi. Mall on tühi. Tühi märgend kohal {1}: kirjutage nimi looksulgude vahele. + Fotod kaotaksid oma laiendi: kirjutage {ext} ette punkt või jätke {ext} välja. Failinimedes ei tohi olla kaldkriipsu; lisage kaustad kaustamalli. Koolonijärgne vorming ei sobi oma märgendiga. Nimed korduksid: lisage kaadri number, kellaaeg või algne nimi. + Skannimine jätab vahele kaustad, mille nimi algab punktiga või on originals, proxies või exports. Kohal {1} avatud looksulg jääb sulgemata. Tundmatu märgend „{0}“ kohal {1}. Kohal {1} oleval sulgeval looksulul pole avavat paari; sõnasõnalise looksulu jaoks kirjutage see topelt. diff --git a/i18n/et/Jobs.et.resx b/i18n/et/Jobs.et.resx index a111169d..d5cc6575 100644 --- a/i18n/et/Jobs.et.resx +++ b/i18n/et/Jobs.et.resx @@ -76,7 +76,7 @@ Importimine Kiiranalüüs Hooldus - Arhiivi teisaldamine + Ümberkorraldamine Orbfailid Proksid Indeksi taasloomine diff --git a/i18n/et/Library.et.resx b/i18n/et/Library.et.resx index 26c7338c..3671df69 100644 --- a/i18n/et/Library.et.resx +++ b/i18n/et/Library.et.resx @@ -10,17 +10,16 @@ Laadi alla Ekspordi loend Kaust - Teisalda… Ava Proksid Hinnang Renderda + Korralda ümber… Sünkrooni Sildid… Laadi üles Kontrolli Võta kaust üle - Teisaldamine töötab korraga ainult ühe arhiivi jadadega. Selles arvutis ja serveris ühesugune: pole midagi sünkroonida. Ükski salvestatud vaade pole kasutusel; valige esmalt üks. Teie serverikonto ei saa originaale alla laadida. @@ -32,6 +31,7 @@ Logige esmalt kuval „Server“ Chronos Serverisse sisse. Valitud jadadel pole serverist midagi tuua. Serveris on juba olemas kõik, mis valitud jadades on. + Ümberkorraldamine toimib korraga ainult ühe arhiivi jadadel. Ainult selles arvutis olevatele jadadele; valik asub serveris. Selle jada edastus on juba käimas. Tühjenda filtrid diff --git a/i18n/et/Server.et.resx b/i18n/et/Server.et.resx index 840bfe7d..eb0a7c7e 100644 --- a/i18n/et/Server.et.resx +++ b/i18n/et/Server.et.resx @@ -40,6 +40,7 @@ Ühendus nurjus; üksikasjad on logis. Üks jada failidest on avatud teises programmis; sulgege see ja proovige uuesti. Selle kausta pole enam kettal; prügikasti pole midagi teisaldada. + Selle jada kaust pole seal, kus serveri indeks seda näitab; proovige uuesti pärast serveri järgmist skannimist. Teie kontol pole selleks õigust. Jada fotod muutusid serveris; laadige jada uuesti ja rakendage oma muudatus uuesti. Fail saabus kahjustatuna; laadige see uuesti üles. @@ -68,11 +69,14 @@ See server ei saa seda liiki tööd käitada. Viimast administraatorit ei saa eemaldada ega keelata. See meetod pole siin lubatud. + Uus kaust jääks teise jada kausta sisse. Sellel aadressil pole Chronos Serverit. Ei leitud. Muutke esmalt oma parooli. Foto kustutati jadast üleslaadimise ajal, seega seda ei lisatud. Faili {0} ei saa lugeda ja ilma selle räsita ei saaks teised koopiad teada, et see on kustutatud; sulgege seda kasutav programm või kontrollige selle õigusi ja proovige siis uuesti. + Arhiiv muutus pärast proovikäivitust; vaadake plaan uuesti üle. + Server lõpetas selle plaani koostamise: see võttis liiga kaua aega või küsiti korraga liiga palju plaane; proovige varsti uuesti. See arhiiv ei loo prokse. Proksi on tehtud teisest fotost. Server ei vaja selle foto proksit. diff --git a/i18n/et/Settings.et.resx b/i18n/et/Settings.et.resx index 71a7befa..c418793b 100644 --- a/i18n/et/Settings.et.resx +++ b/i18n/et/Settings.et.resx @@ -65,6 +65,7 @@ tähte megapiksli kohta Analüüsi laius px pikemal küljel + Arhiivis juba olevad kaustad ja failid säilitavad oma nimed. Failinimed Kaustad {0} vaba @@ -74,10 +75,12 @@ Vali arhiivikaust Eelvaade Proksi suurus + Korralda ümber… Lähtesta arhiivi sätted Selle nimemallid, proksi suurus ja pisipiltide suurus lähtestatakse vaikeväärtustele kõigis seda kasutavates arvutites ja serverites. Arhiivis juba olevad kaustad ja failid säilitavad oma nimed. Kas lähtestada arhiivi {0} sätted? Arhiivikaust + Arhiivi mallid salvestatud Pisipildi suurus Tagasi režiimile Auto Vali kaust diff --git a/i18n/et/Tooltips.et.resx b/i18n/et/Tooltips.et.resx index 2ec5cd5b..84209c36 100644 --- a/i18n/et/Tooltips.et.resx +++ b/i18n/et/Tooltips.et.resx @@ -36,6 +36,7 @@ Avage esimese koopia jada kuval „Redigeerimine“ Leidke räsi järgi jadade vahel identsed fotod · loeb ainult indeksit Kuvage selle aasta jadad + Iga foto failinimi, nagu impordid selle panevad · kontrollitakse tippimise ajal Jätke alles ainult ühe kaamera jadad Valige see väärtus; uuesti valimine tühjendab selle Jätke alles ainult ühes olekus jadad @@ -71,7 +72,10 @@ Looge indeks kaasfailidest uuesti; nende puudumisel loetakse kõik metaandmed; originaale ei kustutata kunagi Lisage taasloomine järjekorda · arhiiv jääb seni kasutatavaks Valige teisaldatud arhiivi uus kaust; selle jadad liiguvad kaasa - Tehke kaustades, kaasfailides ja indeksis täpselt need muudatused · jätkub pärast krahhi + Lisage järjekorda töö, mis teeb täpselt need muudatused · saate selle jaotises „Tööd“ peatada ja jätkata + Nimetab fotod selle malli järgi ümber · väljalülitatuna säilitavad need oma nimed + Teisaldab jadade kaustad sellesse paigutusse · väljalülitatuna jäävad need oma kohale + Muudab pealkirjad selle malli järgi · väljalülitatuna jäävad need samaks Valige indeksi varukoopia jaotises Sätted › Täpsemalt; see asendab indeksi järgmisel käivitamisel Muutke nende jadade silte kaasfailides ja indeksis Käivitage sama toiming uuesti @@ -80,9 +84,8 @@ Käivitage valiku iga jada süvaanalüüs Teisaldage valik arhiivi prügikasti · näitab proovikäivitust ja palub seejärel kinnitamiseks tippida Eksportige valik CSV-failina: üks rida jada kohta - Teisaldage valik uude kaustapaigutusse · esmalt proovikäivitus Looge või värskendage proksid - Nimetage valiku pealkirjad malli abil ümber · esmalt proovikäivitus + Rakendage valikule kausta-, failinime- ja pealkirjamallid · esmalt proovikäivitus, siis töö Lisage kogu valikule silte või eemaldage neid Looge või värskendage pisipildid Räsige valiku originaalid uuesti @@ -471,12 +474,12 @@ Tooge serverist see, mis {0:N0} jadal siin puudub (originaalid või renderdused) · käib edastustöödena Salvestage {0:N0} rida CSV-failina teie valitud kausta Salvestage {0:N0} rida CSV-failina teie valitud kausta - Teisaldage {0:N0} jada arhiivi uude kaustapaigutusse · näitab esmalt proovikäivitust - Teisaldage {0:N0} jada nende arhiivi uude kaustapaigutusse · näitab esmalt proovikäivitust Looge {0:N0} jadale JPEG-proksid · käib ühe tööna Looge {0:N0} jadale JPEG-proksid · käib ühe tööna Määrake {0:N0} jadale hinnang; see salvestatakse kaasfaili ja indeksisse Määrake {0:N0} jadale hinnang; see salvestatakse kaasfailidesse ja indeksisse + Rakendage {0:N0} jadale selle arhiivi kausta-, failinime- ja pealkirjamallid · esmalt proovikäivitus, siis töö + Rakendage {0:N0} jadale nende arhiivi kausta-, failinime- ja pealkirjamallid · esmalt proovikäivitus, siis töö Lisage {0:N0} jadale silte või eemaldage neid Lisage {0:N0} jadale silte või eemaldage neid Saatke serverisse see, mis seal {0:N0} jadast puudub (originaalid ja sätted või renderdused) · käib edastustööna @@ -692,6 +695,7 @@ Tasakaalustatud sobib enamikul juhtudel; Parim mõõdab kahekordse eraldusvõimega ja loeb kaugemale ette; Kiire mõõdab poole eraldusvõimega ja liikumise ligikaudse hinnanguga Loetlege kodeerijad uuesti pärast draiveri või koodeki installimist Otsige koodekilaiendeid uuesti pärast mõne installimist; järgmised tööd kasutavad neid + Rakendage arhiivi mallid selles juba olevatele jadadele · esmalt proovikäivitus Lähtestage kõik selle arvuti sätted vaikeväärtustele; küsitakse eelnevalt kinnitust Kirjutage vaikemallid ja -suurused kohe selle arhiivi faili archive.json Lähtestage kõik sätted kohe diff --git a/i18n/fi/Admin.fi.resx b/i18n/fi/Admin.fi.resx index 124399cf..334aec2a 100644 --- a/i18n/fi/Admin.fi.resx +++ b/i18n/fi/Admin.fi.resx @@ -9,6 +9,7 @@ Chronos-palvelin Käynnissä Versio + {0} järjesti arkiston uudelleen · {1} {0} muutti arkiston rakennetta {0} poisti {1} {0} aloitti työn: {1} @@ -138,7 +139,7 @@ Tuonti Pika-analyysi Ylläpito - Siirto + Uudelleenjärjestely Orvot tiedostot Proxyt Uudelleenluonti @@ -343,6 +344,7 @@ Kirjaudu sisään hallitaksesi tätä palvelinta Käyttäjä Käyttäjänimesi tällä palvelimella + Arkisto järjestetty uudelleen Arkiston rakenne Kuvia poistettu Työ aloitettu @@ -426,6 +428,58 @@ Vaihda salasana Vaihda salasana ja jatka paneeliin Valitse uusi salasana + Järjestä uudelleen… + Käytä kansio-, tiedosto- ja nimimalleja valittuihin sarjoihin; esikatselu näyttää ensin jokaisen muutoksen + Jälkeen: + Käytä… + Järjestä uudelleen esikatselun mukaisesti; ensin pyydetään vahvistus + Ennen: + Kirjoita malli tai poista tämä osa käytöstä. + Sulje muuttamatta mitään + Siirtyy mukana + Siirtyy vain, koska kansio, jonka sisällä se on, siirtyy + Uudelleennimetyt tiedostot + Kansio + Sarja + Järjestä uudelleen + Lisää jonoon työ, joka siirtää alkuperäiset tiedostot ja nimeää ne uudelleen; mitään ei korvata eikä poisteta + {0} kuva saa uuden nimen. + {0} kuvaa saa uuden nimen. + {0} kansio siirtyy. + {0} kansiota siirtyy. + {0} sarja muuttuu. + {0} sarjaa muuttuu. + Järjestetäänkö uudelleen nyt? + Kunkin kuvan nimi sellaisena kuin tuonti sen antaa, esim. {date}_{time}_{n:0000}; kuvan vieressä olevat tiedostot seuraavat sitä + Tiedostot + Nimeä kunkin sarjan kuvat uudelleen; pois päältä jokainen tiedostonimi säilyy + {0} tiedosto nimetty uudelleen + {0} tiedostoa nimetty uudelleen + Kunkin sarjan kansio arkistossa, esim. {year}/{date} {camera}; {title} on uusi nimi + Kansiot + Siirrä kukin sarja kansioon, jonka sen malli antaa; pois päältä jokainen kansio pysyy paikallaan + Valittu sarja ei ole enää arkistossa; sulje ja valitse uudelleen. + {0}: {1} + Ota käyttöön vähintään yksi muutettava osa. + Ei muutettavaa: nämä sarjat noudattavat jo malleja. + Järjestä uudelleen… + Käytä uusia malleja arkistossa jo oleviin sarjoihin; esikatselu näyttää ensin jokaisen muutoksen + Avaa työ + Näytä työ ja sen loki Työt-sivulla + Arkisto muuttui vahvistuksen aikana; tarkista uusi esikatselu ja ota muutokset käyttöön uudelleen. + Suunnitellaan… + Esikatselu + Mitä kustakin sarjasta tulee, siinä järjestyksessä kuin muutokset tehdään; mitään ei ole vielä muutettu + Uudelleenjärjestely lisätty jonoon. + Tämä kansio pysyy paikallaan + Järjestä {0} sarja uudelleen + Järjestä {0} sarjaa uudelleen + Järjestä kaikki sarjat uudelleen + Kunkin sarjan uusi nimi, esim. {date} {camera}; {title} on nykyinen nimi + Sarjojen nimet + Anna kullekin sarjalle sen mallin muodostama nimi; pois päältä jokainen nimi säilyy + Uudelleenjärjestelyyn voi ottaa kerralla enintään {0} sarjaa tai kaikki sarjat: tyhjennä suodattimet ja valitse kaikki. + Muuttuneita sarjoja: {0} · uudelleennimettyjä tiedostoja: {1} · säilytettyjä nimiä: {2} Ylläpitäjä Muokkaaja Lähettäjä diff --git a/i18n/fi/Archive.fi.resx b/i18n/fi/Archive.fi.resx index 5deccc0d..1492c47f 100644 --- a/i18n/fi/Archive.fi.resx +++ b/i18n/fi/Archive.fi.resx @@ -15,6 +15,7 @@ Odota, kunnes muutokset on tehty. Joukko on tyhjä: muuta valintaa tai suodatinta. Mikään ei muuttuisi. + Ota käyttöön vähintään yksi malli. Arkiston on oltava käytettävissä ja kirjoitettavissa. Odota testiajon valmistumista. Odota, kunnes arkisto on luettu. @@ -81,6 +82,12 @@ Tiedoston {0} on kirjoittanut uudempi Chronos (muoto {1}). Arkisto {0} ei ole käytettävissä. Arkisto {0} on vain luku -tilassa. + {0:N0} sarja säilytti tiedostonimensä: kuva oli käytössä tai sen uusi nimi oli jo varattu. + {0:N0} sarjaa säilytti tiedostonimensä: kuva oli käytössä tai sen uusi nimi oli jo varattu. + {0:N0} sarjan uudelleenjärjestely ei toteutunut suunnitellusti: sarja muuttui suunnitelman laatimisen jälkeen. + {0:N0} sarjan uudelleenjärjestely ei toteutunut suunnitellusti: sarjat muuttuivat suunnitelman laatimisen jälkeen. + {0:N0} sarja säilytti nimensä ja tiedostonimensä: sen sarjatiedoston on kirjoittanut uudempi Chronos. + {0:N0} sarjaa säilytti nimensä ja tiedostonimensä: niiden sarjatiedostot on kirjoittanut uudempi Chronos. Kohde {0} muuttui suunnitelman laatimisen jälkeen. Korttia tai kansiota {0} ei ole enää saatavilla. Arkisto muuttui tämän suunnitelman laatimisen jälkeen. @@ -146,6 +153,14 @@ Indeksoimattomia kuvia: {0}, puuttuvia kuvia: {1} {0}: luotu {1}, käytetty uudelleen {2}, lukukelvottomia {3}, odottavia {4} Proxyt palvelimelle: lähetetty {0}, lähettämättä {1} + Jätetty ennalleen, sen sisältävä kansio pysyi paikallaan: {0} + Jätetty ennalleen, muuttui suunnitelman jälkeen: {0} + Tiedostonimet säilytetty, kuva oli käytössä tai sen uusi nimi oli varattu: {0} + Tiedostonimet säilytetty, kuvat muuttuivat suunnitelman jälkeen: {0} + Nimi ja tiedostonimet säilytetty, sarjatiedoston on kirjoittanut uudempi Chronos: {0} + Nimi ja tiedostonimet säilytetty, sarja muuttui suunnitelman jälkeen: {0} + Muuttuneita sarjoja: {0}, uudelleennimettyjä tiedostoja: {1} + Uudelleenjärjestely saatiin valmiiksi, kun arkisto avattiin Vain raportti: mitään ei muutettu. Kansioita: {0}, indeksoitu: {1}, sisällytetty: {2}, poistettu: {3} Sarjaa ei löydy: {0} @@ -200,14 +215,30 @@ Siirretyn arkiston kansio Käytä {0} / {1} - Nimeä {0:N0} sarja uudelleen - Nimeä {0:N0} sarjaa uudelleen - Siirrä {0:N0} sarja - Siirrä {0:N0} sarjaa Muutokset {0:N0} / {1:N0} muuttuu {0:N0} / {1:N0} muuttuu - Malli + Paikallaan pidettävät kuvat originals-kansion ulkopuolella säilyttävät nimensä. + Puuttuvat kuvat säilyttävät nimensä. + Koskaan tarkistamattomat kuvat säilyttävät nimensä; tarkista sarja ensin. + Sarjatiedostoa ei voi lukea; sarja pysyy ennallaan, samoin jokainen kansio, jonka sisällä se on. + Seuraa kansiotaan + {0}: ennen {1}, jälkeen {2} + Tiedosto + Tiedostonimet + Kansio + Kansiot + Järjestä {0:N0} sarja uudelleen + Järjestä {0:N0} sarjaa uudelleen + Järjestä arkisto {0} uudelleen + {0:N0} nimi säilytetty + {0:N0} nimeä säilytetty + Testiajo… + {0:N0} tiedosto nimetty uudelleen + {0:N0} tiedostoa nimetty uudelleen + Nimi + Sarjojen nimet + Uudelleenjärjestely avautuu, kun avoinna oleva valintaikkuna suljetaan Lisää tunnisteita Käytä {0:N0} sarjan tunnisteet @@ -222,9 +253,8 @@ Vie CSV Joukon suodatin Suodatettu joukko - Siirrä… Luo proxyt - Nimeä uudelleen… + Järjestä uudelleen… Muuta tunnisteita… Luo pikkukuvat Tarkista diff --git a/i18n/fi/Errors.fi.resx b/i18n/fi/Errors.fi.resx index 7dc1b827..06865e55 100644 --- a/i18n/fi/Errors.fi.resx +++ b/i18n/fi/Errors.fi.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Analysoimattomia sarjoja: {0} / {1}; katso työn loki. + Tämän sarjan kansio ei ole siellä, missä sen indeksin mukaan pitäisi olla; yritä uudelleen seuraavan skannauksen jälkeen. Arkistoa ei voitu avata. Nykyistä indeksiä ei voitu varmuuskopioida tai korvata; palautusta yritetään uudelleen seuraavassa käynnistyksessä. Tätä varmuuskopiota ei voi palauttaa; valitse toinen. @@ -37,9 +38,11 @@ {0} alkuperäistä tiedostoa puuttuu tai on muuttunut arkistoinnin jälkeen; tarkista arkisto. Malli on tyhjä. Tyhjä paikkamerkki kohdassa {1}: kirjoita nimi aaltosulkeiden väliin. + Kuvat menettäisivät tiedostotunnisteensa: kirjoita piste ennen paikkamerkkiä {ext} tai jätä {ext} pois. Tiedostonimissä ei voi olla kauttaviivaa; määritä kansiot kansiomallissa. Kaksoispisteen jälkeinen muoto ei sovi paikkamerkkiinsä. Nimet toistuisivat: lisää kuvan numero, aika tai alkuperäinen nimi. + Skannaukset ohittavat kansiot, joiden nimi alkaa pisteellä tai on originals, proxies tai exports. Kohdassa {1} avattua aaltosuljetta ei suljeta koskaan. Tuntematon paikkamerkki ”{0}” kohdassa {1}. Kohdan {1} sulkevalla aaltosulkeella ei ole avaavaa paria; kirjoita se kahdesti, jos haluat kirjaimellisen aaltosulkeen. diff --git a/i18n/fi/Jobs.fi.resx b/i18n/fi/Jobs.fi.resx index 907f9d46..fa9feb48 100644 --- a/i18n/fi/Jobs.fi.resx +++ b/i18n/fi/Jobs.fi.resx @@ -76,7 +76,7 @@ Tuonti Pika-analyysi Ylläpito - Arkiston siirto + Uudelleenjärjestely Orvot tiedostot Proxyt Indeksin uudelleenluonti diff --git a/i18n/fi/Library.fi.resx b/i18n/fi/Library.fi.resx index b592f0f9..cd733d89 100644 --- a/i18n/fi/Library.fi.resx +++ b/i18n/fi/Library.fi.resx @@ -10,17 +10,16 @@ Lataa Vie luettelo Kansio - Siirrä… Avaa Luo proxyt Luokitus Renderöi + Järjestä uudelleen… Synkronoi Tunnisteet… Lähetä Tarkista Sisällytä kansio - Siirto koskee vain yhden arkiston sarjoja kerrallaan. Sarja on sama tällä tietokoneella ja palvelimella, joten synkronoitavaa ei ole. Mikään tallennettu näkymä ei ole käytössä; valitse ensin näkymä. Palvelintililläsi ei voi ladata alkuperäisiä tiedostoja. @@ -32,6 +31,7 @@ Kirjaudu ensin sisään Chronos-palvelimelle Palvelin-näkymässä. Valituilla sarjoilla ei ole palvelimelta haettavaa. Palvelimella on jo kaikki, mitä valitut sarjat sisältävät. + Uudelleenjärjestely käsittelee kerrallaan vain yhden arkiston sarjoja. Vain tällä tietokoneella oleville sarjoille; valitut sarjat ovat palvelimella. Tämän sarjan siirto on jo käynnissä. Tyhjennä suodattimet diff --git a/i18n/fi/Server.fi.resx b/i18n/fi/Server.fi.resx index 35c33019..b151807a 100644 --- a/i18n/fi/Server.fi.resx +++ b/i18n/fi/Server.fi.resx @@ -40,6 +40,7 @@ Yhteys epäonnistui; lokissa on lisätietoja. Jokin sarjan tiedosto on auki toisessa ohjelmassa; sulje se ja yritä uudelleen. Sen kansiota ei ole enää levyllä; roskakoriin ei ole siirrettävää. + Tämän sarjan kansio ei ole siellä, missä sen palvelimen indeksin mukaan pitäisi olla; yritä uudelleen palvelimen seuraavan skannauksen jälkeen. Tililläsi ei voi tehdä tätä. Sarjan kuvat muuttuivat palvelimella; lataa sarja uudelleen ja tee muutoksesi uudelleen. Tiedosto vaurioitui siirrossa; lähetä se uudelleen. @@ -68,11 +69,14 @@ Tämä palvelin ei voi suorittaa sen tyyppistä työtä. Viimeistä ylläpitäjää ei voi poistaa eikä poistaa käytöstä. Tätä metodia ei sallita täällä. + Uusi kansio tulisi toisen sarjan kansion sisään. Osoitteessa ei ole Chronos-palvelinta. Ei löytynyt. Vaihda ensin salasanasi. Kuva poistettiin sarjasta sen lähetyksen aikana, joten sitä ei lisätty. Tiedostoa {0} ei voi lukea, eivätkä muut kopiot saisi ilman sen tiivistettä tietää sen poistamisesta; sulje sitä käyttävä ohjelma tai tarkista sen käyttöoikeudet ja yritä sitten uudelleen. + Arkisto muuttui testiajon jälkeen; tarkista suunnitelma uudelleen. + Palvelin lopetti tämän suunnitelman laatimisen: se kesti liian kauan tai suunnitelmia pyydettiin liian monta kerralla; yritä hetken kuluttua uudelleen. Tämä arkisto ei luo proxyja. Proxy on tehty toisesta kuvasta. Palvelin ei tarvitse tämän kuvan proxya. diff --git a/i18n/fi/Settings.fi.resx b/i18n/fi/Settings.fi.resx index 537b330a..34e0afe7 100644 --- a/i18n/fi/Settings.fi.resx +++ b/i18n/fi/Settings.fi.resx @@ -65,6 +65,7 @@ tähteä megapikseliä kohden Analyysin leveys px pitkällä sivulla + Arkistossa jo olevat kansiot ja tiedostot säilyttävät nimensä. Tiedostonimet Kansiot {0} vapaana @@ -74,10 +75,12 @@ Valitse arkistokansio Esikatselu Proxyn koko + Järjestä uudelleen… Palauta arkiston oletukset Sen nimeämismallit, proxyjen koko ja pikkukuvien koko palautetaan oletusarvoihin kaikilla sitä käyttävillä tietokoneilla ja palvelimilla. Arkistossa jo olevat kansiot ja tiedostot säilyttävät nimensä. Palautetaanko arkiston {0} asetukset oletuksiin? Arkistokansio + Arkiston mallit tallennettu Pikkukuvan koko Palauta automaattinen Valitse kansio diff --git a/i18n/fi/Tooltips.fi.resx b/i18n/fi/Tooltips.fi.resx index 1144a204..1a3a87e2 100644 --- a/i18n/fi/Tooltips.fi.resx +++ b/i18n/fi/Tooltips.fi.resx @@ -36,6 +36,7 @@ Avaa ensimmäisen kopion sarja Muokkaus-näkymässä Etsi identtiset kuvat eri sarjoista tiivisteen perusteella · lukee vain indeksiä Näytä tämän vuoden sarjat + Kunkin kuvan tiedostonimi sellaisena kuin tuonnit sen antavat · tarkistetaan kirjoittaessasi Näytä vain yhden kameran sarjat Valitse tämä arvo; poista se valitsemalla se uudelleen Näytä vain sarjat, joilla on tietty tila @@ -71,7 +72,10 @@ Luo indeksi uudelleen sivutiedostoista; tarvittaessa luetaan kaikki metatiedot; alkuperäisiä tiedostoja ei koskaan poisteta Lisää uudelleenluonti jonoon · arkisto pysyy sillä välin käytettävissä Valitse siirtämäsi arkiston uusi kansio; sen sarjat seuraavat mukana - Tee täsmälleen nämä muutokset kansioihin, sivutiedostoihin ja indeksiin · jatkuu kaatumisen jälkeen + Lisää jonoon työ, joka tekee täsmälleen nämä muutokset · keskeytä ja jatka sitä Työt-näkymässä + Nimeä kuvat uudelleen tällä mallilla · pois päältä ne säilyttävät nimensä + Siirrä sarjojen kansiot tähän rakenteeseen · pois päältä ne pysyvät paikallaan + Muuta sarjojen nimet tällä mallilla · pois päältä ne pysyvät ennallaan Valitse indeksin varmuuskopio kohdassa Asetukset › Lisäasetukset; se korvaa indeksin seuraavassa käynnistyksessä Muuta näiden sarjojen tunnisteet sivutiedostoissa ja indeksissä Suorita sama toiminto uudelleen @@ -80,9 +84,8 @@ Suorita syväanalyysi joukon kaikille sarjoille Siirrä joukko arkiston roskakoriin · näyttää ensin testiajon ja pyytää sitten vahvistamaan kirjoittamalla Vie joukko CSV-tiedostona: yksi rivi sarjaa kohden - Siirrä joukko uuteen kansiorakenteeseen · ensin testiajo Luo tai päivitä proxyt - Nimeä joukon sarjat uudelleen mallin avulla · ensin testiajo + Käytä kansio-, tiedosto- ja nimimalleja joukkoon · ensin testiajo, sitten työ Lisää tai poista tunnisteita koko joukosta Luo tai päivitä pikkukuvat Laske joukon alkuperäisten tiedostojen tiivisteet uudelleen @@ -471,12 +474,12 @@ Hae palvelimelta, mitä {0:N0} sarjalta puuttuu täältä (alkuperäiset tiedostot tai renderöinnit) · suoritetaan siirtotöinä Tallenna {0:N0} rivi CSV-tiedostona valitsemaasi kansioon Tallenna {0:N0} riviä CSV-tiedostona valitsemaasi kansioon - Siirrä {0:N0} sarja arkistonsa uuteen kansiorakenteeseen · näyttää ensin testiajon - Siirrä {0:N0} sarjaa arkistonsa uuteen kansiorakenteeseen · näyttää ensin testiajon Luo {0:N0} sarjan JPEG-proxyt · suoritetaan yhtenä työnä Luo {0:N0} sarjan JPEG-proxyt · suoritetaan yhtenä työnä Aseta {0:N0} sarjan luokitus sen sivutiedostoon ja indeksiin Aseta {0:N0} sarjan luokitus niiden sivutiedostoihin ja indeksiin + Käytä kansio-, tiedosto- ja nimimalleja {0:N0} sarjaan sen arkistossa · ensin testiajo, sitten työ + Käytä kansio-, tiedosto- ja nimimalleja {0:N0} sarjaan niiden arkistossa · ensin testiajo, sitten työ Lisää tai poista {0:N0} sarjan tunnisteita Lisää tai poista {0:N0} sarjan tunnisteita Lähetä palvelimelle, mitä siltä puuttuu {0:N0} sarjasta (alkuperäiset tiedostot ja asetukset tai renderöinnit) · suoritetaan siirtotyönä @@ -692,6 +695,7 @@ Tasapainoinen sopii useimpiin tarkoituksiin; Paras mittaa kaksinkertaisella tarkkuudella ja lukee pidemmälle eteenpäin; Nopea mittaa puolella tarkkuudella ja karkealla liikearviolla Luettele kooderit uudelleen ohjaimen tai koodekin asennuksen jälkeen Etsi koodekkilaajennuksia uudelleen, kun olet asentanut sellaisen; seuraavat työt käyttävät niitä + Käytä arkiston malleja siinä jo oleviin sarjoihin · ensin testiajo Palauta kaikki tämän tietokoneen asetukset oletusarvoihin; kysyy ensin Kirjoita oletusmallit ja -koot tämän arkiston archive.json-tiedostoon nyt Palauta kaikki asetukset oletusarvoihin nyt diff --git a/i18n/fr/Admin.fr.resx b/i18n/fr/Admin.fr.resx index 274ae27e..e9448cb4 100644 --- a/i18n/fr/Admin.fr.resx +++ b/i18n/fr/Admin.fr.resx @@ -9,6 +9,7 @@ Chronos Server Actif depuis Version + {0} a réorganisé l'archive · {1} {0} a modifié l'organisation de l'archive {0} a supprimé {1} {0} a lancé {1} @@ -138,7 +139,7 @@ Importation Analyse rapide Maintenance - Déplacement + Réorganisation Orphelins Proxys Reconstruction @@ -343,6 +344,7 @@ Ouvrir une session pour administrer ce serveur Utilisateur Votre nom d'utilisateur sur ce serveur + Archive réorganisée Organisation de l'archive Photos supprimées Tâche lancée @@ -426,6 +428,58 @@ Changer le mot de passe Remplacer le mot de passe et accéder au panneau Choisissez un nouveau mot de passe + Réorganiser… + Appliquer les modèles de dossier, de fichier et de titre aux séquences sélectionnées ; un aperçu montre d'abord chaque modification + Après : + Appliquer… + Réorganiser comme le montre l'aperçu ; une confirmation est demandée d'abord + Avant : + Écrivez un modèle, ou désactivez cette partie. + Fermer sans rien modifier + Entraînée + Ne se déplace que parce qu'un dossier qui la contient se déplace + Fichiers renommés + Dossier + Séquence + Réorganiser + Mettre en file d'attente la tâche qui déplace et renomme les originaux ; rien n'est écrasé ni supprimé + {0} photo reçoit un nouveau nom. + {0} photos reçoivent un nouveau nom. + {0} dossier est déplacé. + {0} dossiers sont déplacés. + {0} séquence est modifiée. + {0} séquences sont modifiées. + Réorganiser maintenant ? + Nom de chaque photo tel qu'une importation le lui donne, p. ex. {date}_{time}_{n:0000} ; les fichiers à côté d'une photo la suivent + Fichiers + Renommer les photos de chaque séquence ; désactivé, chaque nom de fichier est conservé + {0} fichier renommé + {0} fichiers renommés + Dossier de chaque séquence dans l'archive, p. ex. {year}/{date} {camera} ; {title} est le nouveau titre + Dossiers + Déplacer chaque séquence dans le dossier donné par son modèle ; désactivé, chaque dossier reste à sa place + Une séquence sélectionnée n'est plus dans l'archive ; fermez et sélectionnez de nouveau. + {0} : {1} + Activez au moins une partie à modifier. + Rien à modifier : ces séquences suivent déjà les modèles. + Réorganiser… + Appliquer les nouveaux modèles aux séquences déjà présentes dans l'archive ; un aperçu montre d'abord chaque modification + Ouvrir la tâche + Afficher la tâche et son journal dans la page Tâches + L'archive a changé pendant la confirmation ; vérifiez le nouvel aperçu et appliquez de nouveau. + Planification… + Aperçu + Ce que devient chaque séquence, dans l'ordre où les modifications s'appliquent ; rien n'a encore changé + Réorganisation mise en file d'attente. + Ce dossier reste à sa place + Réorganiser {0} séquence + Réorganiser {0} séquences + Réorganiser toutes les séquences + Nouveau titre de chaque séquence, p. ex. {date} {camera} ; {title} est le titre actuel + Titres + Donner à chaque séquence le titre produit par son modèle ; désactivé, chaque titre est conservé + La réorganisation porte sur {0} séquences au plus à la fois, ou sur toutes : effacez les filtres et sélectionnez tout. + Séquences modifiées : {0} · fichiers renommés : {1} · noms conservés : {2} Administrateur Éditeur Contributeur diff --git a/i18n/fr/Archive.fr.resx b/i18n/fr/Archive.fr.resx index 41ded57b..df8f501c 100644 --- a/i18n/fr/Archive.fr.resx +++ b/i18n/fr/Archive.fr.resx @@ -15,6 +15,7 @@ Attendez que les modifications soient appliquées. L'ensemble est vide : modifiez la sélection ou le filtre. Rien ne changerait. + Activez au moins un modèle. L'archive doit être en ligne et accessible en écriture. Attendez la fin de la simulation. Attendez la fin de la lecture de l'archive. @@ -81,6 +82,12 @@ {0} a été écrit par une version plus récente de Chronos (format {1}). L'archive {0} est hors ligne. L'archive {0} est en lecture seule. + {0:N0} séquence a conservé ses noms de fichiers : une photo était en cours d'utilisation ou son nouveau nom était déjà pris. + {0:N0} séquences ont conservé leurs noms de fichiers : une photo était en cours d'utilisation ou son nouveau nom était déjà pris. + {0:N0} séquence n'a pas été réorganisée comme prévu : elle a changé après le plan. + {0:N0} séquences n'ont pas été réorganisées comme prévu : elles ont changé après le plan. + {0:N0} séquence a conservé son titre et ses noms de fichiers : son fichier de séquence provient d'une version plus récente de Chronos. + {0:N0} séquences ont conservé leurs titres et noms de fichiers : leurs fichiers de séquence proviennent d'une version plus récente de Chronos. {0} a changé après l'établissement du plan. La carte ou le dossier {0} n'est plus disponible. L'archive a changé après l'établissement de ce plan. @@ -146,6 +153,14 @@ Photos non indexées : {0}, photos manquantes : {1} {0} : créés {1}, réutilisés {2}, illisibles {3}, en attente {4} Proxys pour le serveur : envoyés {0}, non envoyés {1} + Laissée telle quelle, le dossier qui la contient n'a pas bougé : {0} + Laissée telle quelle, modifiée après le plan : {0} + Noms de fichiers conservés, une photo était en cours d'utilisation ou son nouveau nom était pris : {0} + Noms de fichiers conservés, photos modifiées après le plan : {0} + Titre et noms de fichiers conservés, son fichier de séquence provient d'une version plus récente de Chronos : {0} + Titre et noms de fichiers conservés, modifiée après le plan : {0} + Séquences modifiées : {0}, fichiers renommés : {1} + La réorganisation a été terminée à l'ouverture de l'archive Rapport uniquement : rien n'a été modifié. Dossiers : {0}, indexés : {1}, adoptés : {2}, retirés : {3} Séquence introuvable : {0} @@ -200,14 +215,30 @@ Dossier de l'archive déplacée Appliquer {0} sur {1} - Renommer {0:N0} séquence - Renommer {0:N0} séquences - Déplacer {0:N0} séquence - Déplacer {0:N0} séquences Modifications {0:N0} sur {1:N0} modifiée {0:N0} sur {1:N0} modifiées - Modèle + Les photos conservées sur place hors du dossier originals gardent leur nom. + Les photos manquantes gardent leur nom. + Les photos jamais vérifiées gardent leur nom ; vérifiez d'abord la séquence. + Le fichier de séquence est illisible ; la séquence reste telle quelle, de même que tout dossier qui la contient. + Suit son dossier + {0} : de {1} à {2} + Fichier + Noms de fichiers + Dossier + Dossiers + Réorganiser {0:N0} séquence + Réorganiser {0:N0} séquences + Réorganiser {0} + {0:N0} nom conservé + {0:N0} noms conservés + Simulation… + {0:N0} fichier renommé + {0:N0} fichiers renommés + Titre + Titres + La réorganisation s'ouvrira à la fermeture de la boîte de dialogue ouverte Ajouter des étiquettes Appliquer Étiquettes de {0:N0} séquence @@ -222,9 +253,8 @@ Exporter en CSV Filtre de l'ensemble Ensemble filtré - Déplacer… Proxys - Renommer… + Réorganiser… Étiqueter… Miniatures Vérifier diff --git a/i18n/fr/Errors.fr.resx b/i18n/fr/Errors.fr.resx index 3a61afe9..8d16ca66 100644 --- a/i18n/fr/Errors.fr.resx +++ b/i18n/fr/Errors.fr.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Séquences non analysées : {0} sur {1} ; consultez le journal de la tâche. + Le dossier de cette séquence n'est pas là où l'index l'indique ; réessayez après le prochain scan. L'archive n'a pas pu être ouverte. L'index actuel n'a pas pu être sauvegardé ni remplacé ; la restauration sera relancée au prochain démarrage. Cette sauvegarde ne peut pas être restaurée ; choisissez-en une autre. @@ -37,9 +38,11 @@ {0} originaux manquent ou ont changé depuis leur archivage ; vérifiez l'archive. Le modèle est vide. Balise vide à la position {1} : écrivez un nom entre les accolades. + Les photos perdraient leur extension : écrivez un point avant {ext}, ou retirez {ext}. Les noms de fichiers ne peuvent pas contenir de barre oblique ; placez les dossiers dans le modèle de dossier. Le format après les deux-points ne convient pas à sa balise. Des noms se répéteraient : ajoutez le numéro d'image, l'heure ou le nom d'origine. + Les scans ignorent les dossiers dont le nom commence par un point ou qui s'appellent originals, proxies ou exports. L'accolade ouverte à la position {1} n'est jamais fermée. Balise « {0} » inconnue à la position {1}. L'accolade fermante à la position {1} n'a pas d'accolade ouvrante ; doublez-la pour obtenir une accolade littérale. diff --git a/i18n/fr/Jobs.fr.resx b/i18n/fr/Jobs.fr.resx index a1bda681..4530f8ee 100644 --- a/i18n/fr/Jobs.fr.resx +++ b/i18n/fr/Jobs.fr.resx @@ -76,7 +76,7 @@ Importation Analyse rapide Maintenance - Déplacement d'archive + Réorganisation Orphelins Proxys Reconstruction d'index diff --git a/i18n/fr/Library.fr.resx b/i18n/fr/Library.fr.resx index 1ef1b274..02f52728 100644 --- a/i18n/fr/Library.fr.resx +++ b/i18n/fr/Library.fr.resx @@ -10,17 +10,16 @@ Télécharger Exporter la liste Dossier - Déplacer… Ouvrir Proxys Note Lancer le rendu + Réorganiser… Synchroniser Étiquettes… Envoyer Vérifier Adopter un dossier - Le déplacement agit sur les séquences d'une seule archive à la fois. Identique sur ce PC et sur le serveur : rien à synchroniser. Aucune vue enregistrée n'est en cours d'utilisation ; choisissez-en d'abord une. Votre compte sur le serveur ne peut pas télécharger les originaux. @@ -32,6 +31,7 @@ Ouvrez d'abord une session sur un Chronos Server, dans l'écran Serveur. Les séquences sélectionnées n'ont rien à récupérer du serveur. Le serveur possède déjà tout ce que contiennent les séquences sélectionnées. + La réorganisation porte sur les séquences d'une seule archive à la fois. Uniquement pour les séquences de ce PC ; la sélection se trouve sur le serveur. Un transfert de cette séquence est déjà en cours. Effacer les filtres diff --git a/i18n/fr/Server.fr.resx b/i18n/fr/Server.fr.resx index 9f440e7e..a59c3fe6 100644 --- a/i18n/fr/Server.fr.resx +++ b/i18n/fr/Server.fr.resx @@ -40,6 +40,7 @@ La connexion a échoué ; le journal contient les détails. Un fichier de la séquence est ouvert dans un autre programme ; fermez-le et réessayez. Son dossier n'est plus sur le disque ; il n'y a plus rien à mettre à la corbeille. + Le dossier de cette séquence n'est pas là où l'index du serveur l'indique ; réessayez après son prochain scan. Votre compte ne permet pas cette opération. Les photos de la séquence ont changé sur le serveur ; rechargez-la et appliquez de nouveau votre modification. Le fichier est arrivé endommagé ; envoyez-le de nouveau. @@ -68,11 +69,14 @@ Ce serveur ne peut pas exécuter ce type de tâche. Le dernier administrateur ne peut être ni supprimé ni désactivé. Cette méthode n'est pas autorisée ici. + Un nouveau dossier se trouverait dans le dossier d'une autre séquence. Cette adresse n'est pas un Chronos Server. Introuvable. Changez d'abord votre mot de passe. La photo a été supprimée de la séquence pendant son envoi ; elle n'a donc pas été ajoutée. Impossible de lire {0} : sans son hachage, les autres copies ne sauraient pas que ce fichier a été supprimé ; fermez le programme qui l'utilise ou vérifiez ses autorisations, puis réessayez. + L'archive a changé après la simulation ; vérifiez de nouveau le plan. + Le serveur a cessé de préparer ce plan : cela prenait trop de temps, ou trop de plans étaient demandés à la fois ; réessayez dans un instant. Cette archive ne crée pas de proxys. Le proxy a été créé à partir d'une autre photo. Le serveur n'a pas besoin d'un proxy de cette photo. diff --git a/i18n/fr/Settings.fr.resx b/i18n/fr/Settings.fr.resx index cd361eb7..2096cd12 100644 --- a/i18n/fr/Settings.fr.resx +++ b/i18n/fr/Settings.fr.resx @@ -65,6 +65,7 @@ étoiles par mégapixel Largeur d'analyse px sur le grand côté + Les dossiers et fichiers déjà présents dans l'archive conservent leurs noms. Noms de fichiers Dossiers {0} libres @@ -74,10 +75,12 @@ Choisir le dossier de l'archive Aperçu Taille des proxys + Réorganiser… Réinitialiser l'archive Ses modèles de nommage, la taille des proxys et celle des miniatures reviennent à leurs valeurs par défaut pour chaque PC et serveur qui l'utilise. Les dossiers et fichiers déjà présents dans l'archive conservent leurs noms. Réinitialiser les paramètres de {0} ? Dossier de l'archive + Modèles de l'archive enregistrés Taille des miniatures Revenir à Auto Choisir un dossier diff --git a/i18n/fr/Tooltips.fr.resx b/i18n/fr/Tooltips.fr.resx index 62f1cd24..961ebbd5 100644 --- a/i18n/fr/Tooltips.fr.resx +++ b/i18n/fr/Tooltips.fr.resx @@ -36,6 +36,7 @@ Ouvrir la séquence de la première copie dans l'écran Édition Trouver les photos identiques entre les séquences d'après leur hachage · lit uniquement l'index Afficher les séquences de cette année + Nom de fichier de chaque photo, tel que les importations le donnent · vérifié pendant la saisie Conserver uniquement les séquences d'un seul appareil Choisir cette valeur ; la choisir de nouveau l'efface Conserver uniquement les séquences dans un état donné @@ -71,7 +72,10 @@ Reconstruire l'index à partir des fichiers annexes ; à défaut, scan complet des métadonnées ; ne supprime jamais les originaux Mettre la reconstruction en file d'attente · l'archive reste utilisable pendant ce temps Choisir le nouveau dossier d'une archive que vous avez déplacée ; ses séquences suivent - Appliquer exactement ces modifications aux dossiers, aux fichiers annexes et à l'index · reprend après un plantage + Mettre en file d'attente une tâche qui effectue exactement ces modifications · vous pouvez la suspendre et la reprendre dans Tâches + Renommer les photos avec ce modèle · désactivé, elles gardent leur nom + Déplacer les dossiers des séquences dans cette organisation · désactivé, ils restent à leur place + Modifier les titres avec ce modèle · désactivé, ils restent tels quels Choisir une sauvegarde de l'index dans Paramètres › Avancé ; elle remplace l'index au prochain démarrage Modifier les étiquettes de ces séquences dans les fichiers annexes et l'index Relancer la même action @@ -80,9 +84,8 @@ Lancer l'analyse approfondie de chaque séquence de l'ensemble Mettre l'ensemble à la corbeille de l'archive · affiche la simulation, puis vous demande de saisir une confirmation Exporter l'ensemble en CSV : une ligne par séquence - Déplacer l'ensemble vers une nouvelle organisation de dossiers · simulation d'abord Créer ou actualiser les proxys - Renommer les titres de l'ensemble avec un modèle · simulation d'abord + Appliquer les modèles de dossier, de fichier et de titre à l'ensemble · simulation d'abord, puis une tâche Ajouter ou retirer des étiquettes sur tout l'ensemble Créer ou actualiser les miniatures Hacher de nouveau les originaux de l'ensemble @@ -471,12 +474,12 @@ Récupérer depuis le serveur ce qui manque ici à {0:N0} séquences (originaux ou rendus) · s'exécute sous forme de tâches de transfert Enregistrer {0:N0} ligne au format CSV dans un dossier de votre choix Enregistrer {0:N0} lignes au format CSV dans un dossier de votre choix - Déplacer {0:N0} séquence vers une nouvelle organisation de dossiers de son archive · affiche d'abord la simulation - Déplacer {0:N0} séquences vers une nouvelle organisation de dossiers de leur archive · affiche d'abord la simulation Créer les proxys JPEG de {0:N0} séquence · s'exécute comme une seule tâche Créer les proxys JPEG de {0:N0} séquences · s'exécute comme une seule tâche Définir la note de {0:N0} séquence, dans son fichier annexe et dans l'index Définir la note de {0:N0} séquences, dans leurs fichiers annexes et dans l'index + Appliquer les modèles de dossier, de fichier et de titre à {0:N0} séquence de son archive · simulation d'abord, puis une tâche + Appliquer les modèles de dossier, de fichier et de titre à {0:N0} séquences de leur archive · simulation d'abord, puis une tâche Ajouter ou retirer des étiquettes sur {0:N0} séquence Ajouter ou retirer des étiquettes sur {0:N0} séquences Envoyer au serveur ce qui lui manque de {0:N0} séquence (originaux et paramètres, ou rendus) · s'exécute comme tâche de transfert @@ -692,6 +695,7 @@ Équilibré convient à la plupart des travaux ; Optimal mesure à double résolution et lit davantage à l'avance ; Rapide mesure à demi-résolution avec un mouvement en qualité brouillon Lister de nouveau les encodeurs après l'installation d'un pilote ou d'un codec Rechercher de nouveau les extensions de codec après en avoir installé une ; les prochaines tâches les utilisent + Appliquer les modèles de l'archive aux séquences qu'elle contient déjà · simulation d'abord Rétablir la valeur par défaut de chaque paramètre de ce PC ; demande confirmation Écrire maintenant les modèles et tailles par défaut dans le fichier archive.json de cette archive Réinitialiser tous les paramètres maintenant diff --git a/i18n/he/Admin.he.resx b/i18n/he/Admin.he.resx index a5d0359f..96536168 100644 --- a/i18n/he/Admin.he.resx +++ b/i18n/he/Admin.he.resx @@ -9,6 +9,7 @@ שרת Chronos זמן פעולה גרסה + ארגון מחדש של הארכיון על ידי {0} · {1} שינוי מבנה הארכיון על ידי {0} מחיקת {1} על ידי {0} הפעלת {1} על ידי {0} @@ -147,7 +148,7 @@ ייבוא ניתוח מהיר תחזוקה - העברה + ארגון מחדש קבצים יתומים פרוקסי בנייה מחדש @@ -367,6 +368,7 @@ כניסה לניהול השרת הזה משתמש שם המשתמש שלך בשרת הזה + הארכיון אורגן מחדש מבנה הארכיון תמונות נמחקו משימה הופעלה @@ -452,6 +454,63 @@ שנה סיסמה החלפת הסיסמה והמשך לממשק הניהול בחירת סיסמה חדשה + ארגן מחדש… + החלת תבניות של תיקיות, קבצים וכותרות על הרצפים שנבחרו; תצוגה מקדימה מציגה קודם כל שינוי + אחרי: + החל… + ארגון מחדש כפי שמוצג בתצוגה המקדימה; לפני כן מוצגת בקשת אישור + לפני: + יש לכתוב תבנית, או לכבות את החלק הזה. + סגירה בלי לשנות דבר + מועבר עם התיקייה + מועבר רק מפני שתיקייה שמכילה אותו מועברת + קבצים ששמם שונה + תיקייה + רצף + ארגן מחדש + הוספה לתור של המשימה שמעבירה את הקבצים המקוריים ומשנה את שמותיהם; דבר אינו נדרס או נמחק + {0} תמונות יקבלו שמות חדשים. + תמונה אחת תקבל שם חדש. + {0} תמונות יקבלו שמות חדשים. + {0} תיקיות יועברו. + תיקייה אחת תועבר. + {0} תיקיות יועברו. + {0} רצפים ישתנו. + רצף אחד ישתנה. + {0} רצפים ישתנו. + לארגן מחדש עכשיו? + השם של כל תמונה כפי שייבוא נותן אותו, לדוגמה {date}_{time}_{n:0000}; הקבצים שלצד תמונה עוברים איתה + קבצים + שינוי השמות של התמונות בכל רצף; במצב כבוי נשמר כל שם קובץ + {0} קבצים ששמם שונה + קובץ אחד ששמו שונה + {0} קבצים ששמם שונה + התיקייה של כל רצף בארכיון, לדוגמה {year}/{date} {camera}; השדה {title} הוא הכותרת החדשה + תיקיות + העברת כל רצף לתיקייה שהתבנית שלו קובעת; במצב כבוי כל תיקייה נשארת במקומה + רצף שנבחר כבר אינו בארכיון; יש לסגור ולבחור שוב. + {0}: {1} + יש להפעיל לפחות חלק אחד לשינוי. + אין מה לשנות: הרצפים האלה כבר תואמים לתבניות. + ארגן מחדש… + החלת התבניות החדשות על הרצפים שכבר נמצאים בארכיון; תצוגה מקדימה מציגה קודם כל שינוי + פתח משימה + הצגת המשימה והיומן שלה בדף המשימות + הארכיון השתנה במהלך האישור; יש לבדוק את התצוגה המקדימה החדשה ולהחיל שוב. + תכנון… + תצוגה מקדימה + מה יהיה כל רצף, לפי הסדר שבו השינויים מוחלים; עדיין לא שונה דבר + הארגון מחדש נוסף לתור. + התיקייה הזו נשארת במקומה + ארגון מחדש של {0} רצפים + ארגון מחדש של רצף אחד + ארגון מחדש של {0} רצפים + ארגון מחדש של כל הרצפים + הכותרת החדשה של כל רצף, לדוגמה {date} {camera}; השדה {title} הוא הכותרת הנוכחית + כותרות + מתן הכותרת שהתבנית יוצרת לכל רצף; במצב כבוי נשמרת כל כותרת + ארגון מחדש פועל על {0} רצפים לכל היותר בכל פעם, או על כל הרצפים: יש לנקות את הסינון ולבחור הכול. + רצפים שהשתנו: {0} · קבצים ששמם שונה: {1} · שמות שנשמרו: {2} מנהל מערכת עורך מעלה קבצים diff --git a/i18n/he/Archive.he.resx b/i18n/he/Archive.he.resx index 3dde7cb2..5b591460 100644 --- a/i18n/he/Archive.he.resx +++ b/i18n/he/Archive.he.resx @@ -16,6 +16,7 @@ יש להמתין עד שהשינויים יוחלו. האוסף ריק: יש לשנות את הבחירה או את הסינון. שום דבר לא ישתנה. + יש להפעיל לפחות תבנית אחת. הארכיון חייב להיות מקוון וניתן לכתיבה. יש להמתין להרצת הניסיון. יש להמתין עד שהארכיון ייקרא. @@ -91,6 +92,15 @@ {0} נכתב על ידי גרסה חדשה יותר של Chronos (פורמט {1}). הארכיון {0} אינו מקוון. הארכיון {0} מוגדר לקריאה בלבד. + {0:N0} רצפים שמרו על שמות הקבצים שלהם: תמונה הייתה בשימוש, או שהשם החדש שלה כבר היה תפוס. + רצף אחד שמר על שמות הקבצים שלו: תמונה הייתה בשימוש, או שהשם החדש שלה כבר היה תפוס. + {0:N0} רצפים שמרו על שמות הקבצים שלהם: תמונה הייתה בשימוש, או שהשם החדש שלה כבר היה תפוס. + {0:N0} רצפים לא אורגנו מחדש כמתוכנן: הם השתנו אחרי התוכנית. + רצף אחד לא אורגן מחדש כמתוכנן: הוא השתנה אחרי התוכנית. + {0:N0} רצפים לא אורגנו מחדש כמתוכנן: הם השתנו אחרי התוכנית. + {0:N0} רצפים שמרו על הכותרות ועל שמות הקבצים שלהם: קובצי הרצף שלהם נוצרו בגרסה חדשה יותר של Chronos. + רצף אחד שמר על הכותרת ועל שמות הקבצים שלו: קובץ הרצף שלו נוצר בגרסה חדשה יותר של Chronos. + {0:N0} רצפים שמרו על הכותרות ועל שמות הקבצים שלהם: קובצי הרצף שלהם נוצרו בגרסה חדשה יותר של Chronos. {0} השתנה לאחר שהתוכנית נוצרה. הכרטיס או התיקייה {0} אינם זמינים עוד. הארכיון השתנה לאחר שהתוכנית הזו נוצרה. @@ -162,6 +172,14 @@ תמונות שלא נוספו לאינדקס: {0}, תמונות חסרות: {1} {0}: נוצרו {1}, שומשו מחדש {2}, בלתי קריאים {3}, ממתינים {4} קובצי פרוקסי לשרת: נשלחו {0}, לא נשלחו {1} + נשאר כפי שהיה, התיקייה שמכילה אותו לא הועברה: {0} + נשאר כפי שהיה, השתנה אחרי התוכנית: {0} + שמות הקבצים נשמרו, תמונה הייתה בשימוש או שהשם החדש שלה היה תפוס: {0} + שמות הקבצים נשמרו, תמונות השתנו אחרי התוכנית: {0} + הכותרת ושמות הקבצים נשמרו, קובץ הרצף נוצר בגרסה חדשה יותר של Chronos: {0} + הכותרת ושמות הקבצים נשמרו, הרצף השתנה אחרי התוכנית: {0} + רצפים שהשתנו: {0}, קבצים ששמם שונה: {1} + הארגון מחדש הושלם בעת פתיחת הארכיון דוח בלבד: לא שונה דבר. תיקיות: {0}, נוספו לאינדקס: {1}, אומצו: {2}, הוסרו: {3} הרצף לא נמצא: {0} @@ -219,17 +237,34 @@ תיקיית הארכיון שהועבר החל {0} מתוך {1} - שינוי שם של {0:N0} רצפים - שינוי שם של רצף אחד - שינוי שם של {0:N0} רצפים - העברת {0:N0} רצפים - העברת רצף אחד - העברת {0:N0} רצפים שינויים {0:N0} מתוך {1:N0} ישתנו {0:N0} מתוך {1:N0} ישתנה {0:N0} מתוך {1:N0} ישתנו - תבנית + תמונות שנשארות במקומן מחוץ לתיקייה originals שומרות על שמותיהן. + תמונות חסרות שומרות על שמותיהן. + תמונות שמעולם לא אומתו שומרות על שמותיהן; יש לאמת קודם את הרצף. + לא ניתן לקרוא את קובץ הרצף; הרצף נשאר כפי שהוא, וכך גם כל תיקייה שמכילה אותו. + עובר עם התיקייה שלו + {0}: מ-{1} ל-{2} + קובץ + שמות קבצים + תיקייה + תיקיות + ארגון מחדש של {0:N0} רצפים + ארגון מחדש של רצף אחד + ארגון מחדש של {0:N0} רצפים + ארגון מחדש של {0} + {0:N0} שמות שנשמרו + שם אחד שנשמר + {0:N0} שמות שנשמרו + הרצת ניסיון… + {0:N0} קבצים ששמם שונה + קובץ אחד ששמו שונה + {0:N0} קבצים ששמם שונה + כותרת + כותרות + חלון הארגון מחדש ייפתח כשהחלון הפתוח ייסגר הוסף תגיות החל תגיות של {0:N0} רצפים @@ -246,9 +281,8 @@ ייצא CSV סינון האוסף אוסף מסונן - העבר… פרוקסי - שנה שם… + ארגן מחדש… ערוך תגיות… תמונות ממוזערות אמת diff --git a/i18n/he/Errors.he.resx b/i18n/he/Errors.he.resx index 81dd0449..18a0b456 100644 --- a/i18n/he/Errors.he.resx +++ b/i18n/he/Errors.he.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 רצפים שלא נותחו: {0} מתוך {1}; הפרטים ביומן המשימה. + התיקייה של הרצף הזה אינה במקום שבו האינדקס מציין אותה; יש לנסות שוב אחרי הסריקה הבאה. לא ניתן היה לפתוח את הארכיון. לא ניתן היה לגבות או להחליף את האינדקס הנוכחי; השחזור יתבצע שוב בהפעלה הבאה. לא ניתן לשחזר את הגיבוי הזה; יש לבחור גיבוי אחר. @@ -39,9 +40,11 @@ {0} קבצים מקוריים חסרים או השתנו מאז שנשמרו בארכיון; יש לאמת את הארכיון. התבנית ריקה. שדה ריק במיקום {1}: יש לכתוב שם בין הסוגריים המסולסלים. + התמונות יאבדו את הסיומת שלהן: יש לכתוב נקודה לפני {ext}, או להשמיט את {ext}. שמות קבצים אינם יכולים להכיל לוכסן; יש להגדיר תיקיות בתבנית התיקיות. הפורמט שאחרי הנקודתיים אינו מתאים לשדה שלו. השמות יחזרו על עצמם: יש להוסיף את מספר הפריים, את השעה או את השם המקורי. + סריקות מדלגות על תיקיות ששמן מתחיל בנקודה או ששמן originals, proxies או exports. הסוגר המסולסל שנפתח במיקום {1} אינו נסגר. שדה לא מוכר "{0}" במיקום {1}. לסוגר המסולסל במיקום {1} אין סוגר פותח; כדי לקבל סוגר מסולסל כפשוטו יש להכפיל אותו. diff --git a/i18n/he/Jobs.he.resx b/i18n/he/Jobs.he.resx index ca733805..fb81c282 100644 --- a/i18n/he/Jobs.he.resx +++ b/i18n/he/Jobs.he.resx @@ -77,7 +77,7 @@ ייבוא ניתוח מהיר תחזוקה - העברת ארכיון + ארגון מחדש קבצים יתומים פרוקסי בנייה מחדש של האינדקס diff --git a/i18n/he/Library.he.resx b/i18n/he/Library.he.resx index 5e2676d9..c50ad30d 100644 --- a/i18n/he/Library.he.resx +++ b/i18n/he/Library.he.resx @@ -10,17 +10,16 @@ הורד ייצא רשימה תיקייה - העבר… פתח פרוקסי דירוג רנדר + ארגן מחדש… סנכרן תגיות… העלה אמת אימוץ תיקייה - העברה פועלת על הרצפים של ארכיון אחד בכל פעם. זהה במחשב הזה ובשרת: אין מה לסנכרן. אין תצוגה שמורה בשימוש; יש לבחור אחת קודם. לחשבון שלך בשרת אין הרשאה להוריד קבצים מקוריים. @@ -32,6 +31,7 @@ יש להיכנס קודם לשרת Chronos, במסך "שרת". לרצפים שנבחרו אין מה להוריד מהשרת. לשרת כבר יש את כל מה שהרצפים שנבחרו מכילים. + ארגון מחדש פועל על הרצפים של ארכיון אחד בכל פעם. רק עבור רצפים במחשב הזה; הרצפים שנבחרו נמצאים בשרת בלבד. העברה של הרצף הזה כבר מתבצעת. נקה מסננים diff --git a/i18n/he/Server.he.resx b/i18n/he/Server.he.resx index 5155e5e7..27af715d 100644 --- a/i18n/he/Server.he.resx +++ b/i18n/he/Server.he.resx @@ -40,6 +40,7 @@ החיבור נכשל; הפרטים מופיעים ביומן. קובץ של הרצף פתוח בתוכנית אחרת; יש לסגור אותו ולנסות שוב. התיקייה שלו כבר אינה בדיסק; לא נשאר דבר להעביר לאשפה. + התיקייה של הרצף הזה אינה במקום שבו האינדקס של השרת מציין אותה; יש לנסות שוב אחרי הסריקה הבאה שלו. לחשבון שלך אין הרשאה לבצע פעולה זו. התמונות של הרצף השתנו בשרת; יש לטעון אותו מחדש ולהחיל שוב את העריכה. הקובץ הגיע פגום; יש להעלות אותו שוב. @@ -68,11 +69,14 @@ השרת הזה אינו יכול להריץ משימה מסוג זה. לא ניתן להסיר או להשבית את מנהל המערכת האחרון. השיטה הזו אינה מותרת כאן. + תיקייה חדשה תהיה בתוך התיקייה של רצף אחר. הכתובת הזו אינה של שרת Chronos. לא נמצא. יש להחליף קודם את הסיסמה. התמונה נמחקה מהרצף בזמן שהועלתה, ולכן לא נוספה. לא ניתן לקרוא את {0}, ובלי הגיבוב שלו עותקים אחרים לא יידעו שהוא נמחק; יש לסגור את התוכנית שמשתמשת בו או לבדוק את ההרשאות שלו, ולנסות שוב. + הארכיון השתנה אחרי הרצת הניסיון; יש לבדוק שוב את התוכנית. + השרת הפסיק להכין את התוכנית הזו: ההכנה נמשכה זמן רב מדי, או שהתבקשו יותר מדי תוכניות בבת אחת; יש לנסות שוב בעוד רגע. הארכיון הזה אינו יוצר קובצי פרוקסי. קובץ הפרוקסי נוצר מתמונה אחרת. השרת אינו צריך קובץ פרוקסי של התמונה הזו. diff --git a/i18n/he/Settings.he.resx b/i18n/he/Settings.he.resx index f6d5d85d..9456b8cb 100644 --- a/i18n/he/Settings.he.resx +++ b/i18n/he/Settings.he.resx @@ -66,6 +66,7 @@ כוכבים למגה-פיקסל רוחב ניתוח פיקסלים בצד הארוך + תיקיות וקבצים שכבר נמצאים בארכיון שומרים על שמותיהם. שמות קבצים תיקיות {0} פנויים @@ -75,10 +76,12 @@ בחירת תיקיית הארכיון תצוגה מקדימה גודל פרוקסי + ארגן מחדש… אפס ארכיון תבניות השמות, גודל הפרוקסי וגודל התמונות הממוזערות שלו יחזרו לברירות המחדל בכל מחשב ושרת שמשתמשים בו. תיקיות וקבצים שכבר נמצאים בארכיון ישמרו על שמותיהם. לאפס את ההגדרות של {0}? תיקיית הארכיון + תבניות הארכיון נשמרו גודל תמונות ממוזערות חזרה לאוטומטי בחר תיקייה diff --git a/i18n/he/Tooltips.he.resx b/i18n/he/Tooltips.he.resx index 5148cf3d..8281c1ab 100644 --- a/i18n/he/Tooltips.he.resx +++ b/i18n/he/Tooltips.he.resx @@ -37,6 +37,7 @@ פתיחת הרצף של העותק הראשון במסך העריכה חיפוש תמונות זהות בין רצפים לפי גיבוב · קורא את האינדקס בלבד הצגת הרצפים של השנה הזו + שם הקובץ של כל תמונה, כפי שייבואים נותנים אותו · נבדק תוך כדי הקלדה הצגת הרצפים של מצלמה אחת בלבד בחירת הערך הזה; בחירה חוזרת מנקה אותו הצגת הרצפים במצב אחד בלבד @@ -72,7 +73,10 @@ בנייה מחדש של האינדקס מהקבצים הנלווים; בהיעדרם, סריקה מלאה של המטא-נתונים; קבצים מקוריים לעולם אינם נמחקים הוספת הבנייה מחדש לתור · אפשר להמשיך להשתמש בארכיון בינתיים בחירת התיקייה החדשה של ארכיון שהועבר; הרצפים שלו עוברים איתו - ביצוע השינויים האלה בדיוק בתיקיות, בקבצים הנלווים ובאינדקס · ממשיך לאחר קריסה + הוספה לתור של משימה שמבצעת בדיוק את השינויים האלה · ניתן להשהות ולהמשיך אותה במסך "משימות" + שינוי שמות התמונות לפי התבנית הזו · במצב כבוי הן שומרות על שמותיהן + העברת תיקיות הרצפים למבנה הזה · במצב כבוי הן נשארות במקומן + שינוי הכותרות לפי התבנית הזו · במצב כבוי הן נשארות כפי שהן בחירת גיבוי של האינדקס בהגדרות › מתקדם; הוא יחליף את האינדקס בהפעלה הבאה שינוי התגיות של הרצפים האלה בקבצים הנלווים ובאינדקס הרצה חוזרת של אותה פעולה @@ -81,9 +85,8 @@ הרצת ניתוח מעמיק על כל רצף באוסף העברת האוסף לאשפה של הארכיון · מציג את הרצת הניסיון, ואז מבקש להקליד לאישור ייצוא האוסף כ-CSV: שורה אחת לכל רצף - העברת האוסף למבנה תיקיות חדש · קודם הרצת ניסיון יצירה או רענון של קובצי פרוקסי - שינוי הכותרות באוסף לפי תבנית · קודם הרצת ניסיון + החלת תבניות של תיקיות, קבצים וכותרות על האוסף · קודם הרצת ניסיון, ואז משימה הוספה או הסרה של תגיות בכל האוסף יצירה או רענון של תמונות ממוזערות חישוב מחדש של הגיבוב של הקבצים המקוריים באוסף @@ -478,15 +481,15 @@ שמירת {0:N0} שורות כקובץ CSV בתיקייה לבחירתך שמירת שורה אחת כקובץ CSV בתיקייה לבחירתך שמירת {0:N0} שורות כקובץ CSV בתיקייה לבחירתך - העברת {0:N0} רצפים למבנה תיקיות חדש בארכיון שלהם · קודם מוצגת הרצת ניסיון - העברת רצף אחד למבנה תיקיות חדש בארכיון שלו · קודם מוצגת הרצת ניסיון - העברת {0:N0} רצפים למבנה תיקיות חדש בארכיון שלהם · קודם מוצגת הרצת ניסיון בניית קובצי פרוקסי JPEG ל-{0:N0} רצפים · פועל כמשימה אחת בניית קובצי פרוקסי JPEG לרצף אחד · פועל כמשימה אחת בניית קובצי פרוקסי JPEG ל-{0:N0} רצפים · פועל כמשימה אחת קביעת הדירוג של {0:N0} רצפים, בקבצים הנלווים שלהם ובאינדקס קביעת הדירוג של רצף אחד, בקובץ הנלווה שלו ובאינדקס קביעת הדירוג של {0:N0} רצפים, בקבצים הנלווים שלהם ובאינדקס + החלת תבניות של תיקיות, קבצים וכותרות על {0:N0} רצפים בארכיון שלהם · קודם הרצת ניסיון, ואז משימה + החלת תבניות של תיקיות, קבצים וכותרות על רצף אחד בארכיון שלו · קודם הרצת ניסיון, ואז משימה + החלת תבניות של תיקיות, קבצים וכותרות על {0:N0} רצפים בארכיון שלהם · קודם הרצת ניסיון, ואז משימה הוספה או הסרה של תגיות ב-{0:N0} רצפים הוספה או הסרה של תגיות ברצף אחד הוספה או הסרה של תגיות ב-{0:N0} רצפים @@ -711,6 +714,7 @@ "מאוזן" מתאים לרוב העבודה; "הטוב ביותר" מודד ברזולוציה כפולה וקורא רחוק יותר קדימה; "מהיר" מודד בחצי רזולוציה עם תנועה באיכות טיוטה רישום המקודדים מחדש לאחר התקנת מנהל התקן או קודק חיפוש חוזר של הרחבות קודק לאחר התקנת אחת מהן; המשימות הבאות ישתמשו בהן + החלת תבניות הארכיון על הרצפים שכבר נמצאים בו · קודם הרצת ניסיון החזרת כל ההגדרות של המחשב הזה לברירת המחדל; מבקש אישור תחילה כתיבת התבניות והגדלים של ברירת המחדל לקובץ archive.json של הארכיון הזה עכשיו איפוס כל ההגדרות עכשיו diff --git a/i18n/hi/Admin.hi.resx b/i18n/hi/Admin.hi.resx index d066b731..a402f4f8 100644 --- a/i18n/hi/Admin.hi.resx +++ b/i18n/hi/Admin.hi.resx @@ -9,6 +9,7 @@ Chronos Server चालू अवधि संस्करण + {0} ने संग्रह को पुनर्व्यवस्थित किया · {1} {0} ने संग्रह का लेआउट बदला {0} ने {1} हटाया {0} ने {1} शुरू किया @@ -138,7 +139,7 @@ आयात त्वरित विश्लेषण रखरखाव - स्थानांतरण + पुनर्व्यवस्थापन अनाथ फ़ाइलें प्रॉक्सी पुनर्निर्माण @@ -343,6 +344,7 @@ इस सर्वर का प्रबंधन करने के लिए साइन इन करें उपयोगकर्ता इस सर्वर पर आपका उपयोगकर्ता नाम + संग्रह पुनर्व्यवस्थित किया गया संग्रह लेआउट फ़ोटो हटाई गईं कार्य शुरू हुआ @@ -426,6 +428,58 @@ पासवर्ड बदलें पासवर्ड बदलें और पैनल पर जारी रखें नया पासवर्ड चुनें + पुनर्व्यवस्थित करें… + चयनित सीक्वेंस पर फ़ोल्डर, फ़ाइल और शीर्षक टेम्पलेट लागू करें; पूर्वावलोकन पहले हर बदलाव दिखाता है + बाद में: + लागू करें… + पूर्वावलोकन के अनुसार पुनर्व्यवस्थित करें; पहले पुष्टि माँगी जाती है + पहले: + कोई टेम्पलेट लिखें, या इस भाग को बंद करें। + कुछ भी बदले बिना बंद करें + साथ में स्थानांतरित + केवल इसलिए स्थानांतरित होता है क्योंकि इसे रखने वाला फ़ोल्डर स्थानांतरित होता है + नाम बदली गई फ़ाइलें + फ़ोल्डर + सीक्वेंस + पुनर्व्यवस्थित करें + वह कार्य कतार में रखें जो मूल फ़ाइलों को स्थानांतरित करता है और उनके नाम बदलता है; कुछ भी अधिलेखित या हटाया नहीं जाता + {0} फ़ोटो को नया नाम मिलेगा। + {0} फ़ोटो को नए नाम मिलेंगे। + {0} फ़ोल्डर स्थानांतरित होगा। + {0} फ़ोल्डर स्थानांतरित होंगे। + {0} सीक्वेंस बदलेगा। + {0} सीक्वेंस बदलेंगे। + अभी पुनर्व्यवस्थित करें? + हर फ़ोटो का नाम, जैसा आयात उसे देता है, जैसे {date}_{time}_{n:0000}; किसी फ़ोटो के साथ की फ़ाइलें उसी के साथ चलती हैं + फ़ाइलें + हर सीक्वेंस की फ़ोटो के नाम बदलें; बंद होने पर हर फ़ाइल नाम बना रहता है + {0} फ़ाइल का नाम बदला गया + {0} फ़ाइलों के नाम बदले गए + संग्रह में हर सीक्वेंस का फ़ोल्डर, जैसे {year}/{date} {camera}; {title} नया शीर्षक है + फ़ोल्डर + हर सीक्वेंस को उसके टेम्पलेट से बने फ़ोल्डर में ले जाएँ; बंद होने पर हर फ़ोल्डर अपनी जगह रहता है + चयनित कोई सीक्वेंस अब संग्रह में नहीं है; बंद करें और फिर से चुनें। + {0}: {1} + बदलने के लिए कम से कम एक भाग चालू करें। + बदलने को कुछ नहीं: ये सीक्वेंस पहले से टेम्पलेट का पालन करते हैं। + पुनर्व्यवस्थित करें… + संग्रह में पहले से मौजूद सीक्वेंस पर नए टेम्पलेट लागू करें; पूर्वावलोकन पहले हर बदलाव दिखाता है + कार्य खोलें + यह कार्य और इसका लॉग “कार्य” पेज पर दिखाएँ + पुष्टि के दौरान संग्रह बदल गया; नया पूर्वावलोकन जाँचें और फिर से लागू करें। + योजना बन रही है… + पूर्वावलोकन + हर सीक्वेंस क्या बनेगा, उसी क्रम में जिसमें बदलाव लागू होते हैं; अभी तक कुछ नहीं बदला है + पुनर्व्यवस्थापन कतार में। + यह फ़ोल्डर अपनी जगह रहता है + {0} सीक्वेंस पुनर्व्यवस्थित करें + {0} सीक्वेंस पुनर्व्यवस्थित करें + सभी सीक्वेंस पुनर्व्यवस्थित करें + हर सीक्वेंस का नया शीर्षक, जैसे {date} {camera}; {title} वर्तमान शीर्षक है + शीर्षक + हर सीक्वेंस को उसके टेम्पलेट से बना शीर्षक दें; बंद होने पर हर शीर्षक बना रहता है + पुनर्व्यवस्थापन एक बार में अधिकतम {0} सीक्वेंस या सभी सीक्वेंस पर काम करता है: फ़िल्टर साफ़ करें और सभी चुनें। + बदले गए सीक्वेंस: {0} · नाम बदली गई फ़ाइलें: {1} · बनाए रखे गए नाम: {2} व्यवस्थापक संपादक अपलोडर diff --git a/i18n/hi/Archive.hi.resx b/i18n/hi/Archive.hi.resx index 37da4059..397eebaa 100644 --- a/i18n/hi/Archive.hi.resx +++ b/i18n/hi/Archive.hi.resx @@ -15,6 +15,7 @@ बदलाव लागू होने तक प्रतीक्षा करें। सेट खाली है: चयन या फ़िल्टर बदलें। कुछ भी नहीं बदलेगा। + कम से कम एक टेम्पलेट चालू करें। संग्रह ऑनलाइन और लिखने योग्य होना चाहिए। परीक्षण रन की प्रतीक्षा करें। संग्रह पढ़े जाने तक प्रतीक्षा करें। @@ -81,6 +82,12 @@ {0} को Chronos के नए संस्करण ने लिखा था (फ़ॉर्मेट {1})। संग्रह {0} ऑफ़लाइन है। संग्रह {0} केवल-पढ़ने योग्य है। + {0:N0} सीक्वेंस ने अपने फ़ाइल नाम बनाए रखे: कोई फ़ोटो उपयोग में थी या उसका नया नाम पहले से लिया गया था। + {0:N0} सीक्वेंस ने अपने फ़ाइल नाम बनाए रखे: कोई फ़ोटो उपयोग में थी या उसका नया नाम पहले से लिया गया था। + {0:N0} सीक्वेंस योजना के अनुसार पुनर्व्यवस्थित नहीं हुआ: वह योजना के बाद बदल गया। + {0:N0} सीक्वेंस योजना के अनुसार पुनर्व्यवस्थित नहीं हुए: वे योजना के बाद बदल गए। + {0:N0} सीक्वेंस ने अपना शीर्षक और फ़ाइल नाम बनाए रखे: उसकी सीक्वेंस फ़ाइल Chronos के नए संस्करण की है। + {0:N0} सीक्वेंस ने अपने शीर्षक और फ़ाइल नाम बनाए रखे: उनकी सीक्वेंस फ़ाइलें Chronos के नए संस्करण की हैं। योजना बनने के बाद {0} बदल गया। कार्ड या फ़ोल्डर {0} अब उपलब्ध नहीं है। यह योजना बनने के बाद संग्रह बदल गया। @@ -146,6 +153,14 @@ इंडेक्स न की गई फ़ोटो: {0}, गुम फ़ोटो: {1} {0}: बनाए गए {1}, दोबारा उपयोग किए गए {2}, अपठनीय {3}, प्रतीक्षा में {4} सर्वर के लिए प्रॉक्सी: भेजे गए {0}, नहीं भेजे गए {1} + जैसा था वैसा छोड़ा गया, इसे रखने वाला फ़ोल्डर अपनी जगह रहा: {0} + जैसा था वैसा छोड़ा गया, योजना के बाद बदल गया: {0} + फ़ाइल नाम बनाए रखे गए, कोई फ़ोटो उपयोग में थी या उसका नया नाम पहले से लिया गया था: {0} + फ़ाइल नाम बनाए रखे गए, योजना के बाद फ़ोटो बदल गईं: {0} + शीर्षक और फ़ाइल नाम बनाए रखे गए, इसकी सीक्वेंस फ़ाइल Chronos के नए संस्करण की है: {0} + शीर्षक और फ़ाइल नाम बनाए रखे गए, योजना के बाद बदल गया: {0} + बदले गए सीक्वेंस: {0}, नाम बदली गई फ़ाइलें: {1} + संग्रह खोलते समय पुनर्व्यवस्थापन पूरा किया गया केवल रिपोर्ट: कुछ नहीं बदला गया। फ़ोल्डर: {0}, इंडेक्स किए गए: {1}, अपनाए गए: {2}, निकाले गए: {3} सीक्वेंस नहीं मिला: {0} @@ -200,14 +215,30 @@ स्थानांतरित संग्रह का फ़ोल्डर लागू करें {1} में से {0} - {0:N0} सीक्वेंस का नाम बदलें - {0:N0} सीक्वेंस के नाम बदलें - {0:N0} सीक्वेंस स्थानांतरित करें - {0:N0} सीक्वेंस स्थानांतरित करें बदलाव {1:N0} में से {0:N0} बदलाव {1:N0} में से {0:N0} बदलाव - टेम्पलेट + originals फ़ोल्डर के बाहर उसी जगह रखी गई फ़ोटो अपने नाम बनाए रखती हैं। + गुम फ़ोटो अपने नाम बनाए रखती हैं। + कभी सत्यापित न की गई फ़ोटो अपने नाम बनाए रखती हैं; पहले सीक्वेंस सत्यापित करें। + सीक्वेंस फ़ाइल पढ़ी नहीं जा सकती; सीक्वेंस जैसा है वैसा रहता है, और उसे रखने वाला हर फ़ोल्डर भी। + अपने फ़ोल्डर के साथ + {0}: {1} से {2} + फ़ाइल + फ़ाइल नाम + फ़ोल्डर + फ़ोल्डर + {0:N0} सीक्वेंस पुनर्व्यवस्थित करें + {0:N0} सीक्वेंस पुनर्व्यवस्थित करें + {0} पुनर्व्यवस्थित करें + {0:N0} नाम बनाए रखा गया + {0:N0} नाम बनाए रखे गए + परीक्षण रन… + {0:N0} फ़ाइल का नाम बदला गया + {0:N0} फ़ाइलों के नाम बदले गए + शीर्षक + शीर्षक + खुला संवाद बॉक्स बंद होने पर पुनर्व्यवस्थापन खुलेगा टैग जोड़ें लागू करें {0:N0} सीक्वेंस के टैग @@ -222,9 +253,8 @@ CSV निर्यात करें सेट का फ़िल्टर फ़िल्टर किया गया सेट - स्थानांतरित करें… प्रॉक्सी - नाम बदलें… + पुनर्व्यवस्थित करें… टैग बदलें… थंबनेल सत्यापित करें diff --git a/i18n/hi/Errors.hi.resx b/i18n/hi/Errors.hi.resx index 51fd18bd..24e130e6 100644 --- a/i18n/hi/Errors.hi.resx +++ b/i18n/hi/Errors.hi.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 जिन सीक्वेंस का विश्लेषण नहीं हुआ: {1} में से {0}; कार्य लॉग देखें। + इस सीक्वेंस का फ़ोल्डर वहाँ नहीं है जहाँ इंडेक्स उसे बताता है; अगले स्कैन के बाद फिर से प्रयास करें। संग्रह नहीं खोला जा सका। वर्तमान इंडेक्स का बैकअप नहीं लिया जा सका या उसे बदला नहीं जा सका; अगली बार शुरू होने पर पुनर्स्थापना फिर से चलेगी। यह बैकअप पुनर्स्थापित नहीं किया जा सकता; कोई दूसरा चुनें। @@ -37,9 +38,11 @@ {0} मूल फ़ाइलें गुम हैं या संग्रहीत होने के बाद बदल गई हैं; संग्रह सत्यापित करें। टेम्पलेट खाली है। स्थिति {1} पर खाली टोकन: कोष्ठकों के बीच कोई नाम लिखें। + फ़ोटो अपना एक्सटेंशन खो देंगी: {ext} से पहले एक बिंदु लिखें, या {ext} हटा दें। फ़ाइल नामों में स्लैश नहीं हो सकता; फ़ोल्डर, फ़ोल्डर टेम्पलेट में रखें। कोलन के बाद का फ़ॉर्मेट उसके टोकन के अनुकूल नहीं है। नाम दोहराए जाएँगे: फ़्रेम संख्या, समय या मूल नाम जोड़ें। + स्कैन उन फ़ोल्डरों को छोड़ देते हैं जिनका नाम बिंदु से शुरू होता है या जिनका नाम originals, proxies या exports है। स्थिति {1} पर खोला गया कोष्ठक कभी बंद नहीं होता। स्थिति {1} पर अज्ञात टोकन “{0}”। स्थिति {1} पर बंद करने वाले कोष्ठक का कोई खुलने वाला कोष्ठक नहीं है; कोष्ठक को अक्षरशः लिखने के लिए इसे दो बार लिखें। diff --git a/i18n/hi/Jobs.hi.resx b/i18n/hi/Jobs.hi.resx index 2d58033a..462925dd 100644 --- a/i18n/hi/Jobs.hi.resx +++ b/i18n/hi/Jobs.hi.resx @@ -76,7 +76,7 @@ आयात त्वरित विश्लेषण रखरखाव - संग्रह स्थानांतरण + पुनर्व्यवस्थापन अनाथ फ़ाइलें प्रॉक्सी इंडेक्स पुनर्निर्माण diff --git a/i18n/hi/Library.hi.resx b/i18n/hi/Library.hi.resx index becb1d72..8b675599 100644 --- a/i18n/hi/Library.hi.resx +++ b/i18n/hi/Library.hi.resx @@ -10,17 +10,16 @@ डाउनलोड करें सूची निर्यात करें फ़ोल्डर - स्थानांतरित करें… खोलें प्रॉक्सी रेटिंग रेंडर करें + पुनर्व्यवस्थित करें… सिंक करें टैग… अपलोड करें सत्यापित करें फ़ोल्डर अपनाएँ - स्थानांतरण एक समय में केवल एक संग्रह के सीक्वेंस पर काम करता है। इस PC पर और सर्वर पर एक जैसा: सिंक करने के लिए कुछ नहीं। कोई सहेजा गया दृश्य उपयोग में नहीं है; पहले एक चुनें। आपका सर्वर खाता मूल फ़ाइलें डाउनलोड नहीं कर सकता। @@ -32,6 +31,7 @@ पहले सर्वर स्क्रीन पर किसी Chronos Server में साइन इन करें। चयनित सीक्वेंस के लिए सर्वर से लाने को कुछ नहीं है। चयनित सीक्वेंस में जो कुछ है, वह सर्वर पर पहले से है। + पुनर्व्यवस्थापन एक बार में एक ही संग्रह के सीक्वेंस पर काम करता है। केवल इस PC पर मौजूद सीक्वेंस के लिए; चयन सर्वर पर है। इस सीक्वेंस का एक ट्रांसफ़र पहले से चल रहा है। फ़िल्टर साफ़ करें diff --git a/i18n/hi/Server.hi.resx b/i18n/hi/Server.hi.resx index 14f3e9f8..c42c414c 100644 --- a/i18n/hi/Server.hi.resx +++ b/i18n/hi/Server.hi.resx @@ -40,6 +40,7 @@ कनेक्शन विफल रहा; विवरण लॉग में है। सीक्वेंस की एक फ़ाइल किसी अन्य प्रोग्राम में खुली है; उसे बंद करें और फिर से प्रयास करें। इसका फ़ोल्डर अब डिस्क पर नहीं है; ट्रैश में ले जाने के लिए कुछ नहीं बचा। + इस सीक्वेंस का फ़ोल्डर वहाँ नहीं है जहाँ सर्वर का इंडेक्स उसे बताता है; सर्वर के अगले स्कैन के बाद फिर से प्रयास करें। आपका खाता यह नहीं कर सकता। सर्वर पर सीक्वेंस की फ़ोटो बदल गई हैं; इसे फिर से लोड करें और अपना संपादन दोबारा लागू करें। फ़ाइल क्षतिग्रस्त पहुँची; इसे फिर से अपलोड करें। @@ -68,11 +69,14 @@ यह सर्वर उस प्रकार का कार्य नहीं चला सकता। अंतिम व्यवस्थापक को निकाला या अक्षम नहीं किया जा सकता। यहाँ इस विधि की अनुमति नहीं है। + एक नया फ़ोल्डर किसी दूसरे सीक्वेंस के फ़ोल्डर के अंदर होगा। यह पता किसी Chronos Server का नहीं है। नहीं मिला। पहले अपना पासवर्ड बदलें। अपलोड होते समय फ़ोटो सीक्वेंस से हटा दी गई, इसलिए उसे जोड़ा नहीं गया। {0} को पढ़ा नहीं जा सकता, और उसके हैश के बिना अन्य कॉपियों को पता नहीं चलेगा कि उसे हटाया गया था; उसका उपयोग कर रहा प्रोग्राम बंद करें या उसकी अनुमतियाँ जाँचें, फिर से प्रयास करें। + परीक्षण रन के बाद संग्रह बदल गया; योजना की फिर से समीक्षा करें। + सर्वर ने यह योजना बनाना बंद कर दिया: इसमें बहुत समय लग रहा था, या एक साथ बहुत सारी योजनाएँ माँगी गईं; थोड़ी देर में फिर से प्रयास करें। यह संग्रह कोई प्रॉक्सी नहीं बनाता। प्रॉक्सी किसी दूसरी फ़ोटो से बनाया गया था। सर्वर को इस फ़ोटो के प्रॉक्सी की ज़रूरत नहीं है। diff --git a/i18n/hi/Settings.hi.resx b/i18n/hi/Settings.hi.resx index dd209440..31363cc7 100644 --- a/i18n/hi/Settings.hi.resx +++ b/i18n/hi/Settings.hi.resx @@ -65,6 +65,7 @@ प्रति मेगापिक्सेल तारे विश्लेषण चौड़ाई पिक्सेल (लंबा किनारा) + संग्रह में पहले से मौजूद फ़ोल्डर और फ़ाइलें अपने नाम बनाए रखती हैं। फ़ाइल नाम फ़ोल्डर {0} खाली @@ -74,10 +75,12 @@ संग्रह फ़ोल्डर चुनें पूर्वावलोकन प्रॉक्सी आकार + पुनर्व्यवस्थित करें… संग्रह रीसेट करें इसके नामकरण टेम्पलेट, प्रॉक्सी आकार और थंबनेल आकार इसका उपयोग करने वाले हर PC और सर्वर के लिए अपने डिफ़ॉल्ट पर लौट आते हैं। संग्रह में पहले से मौजूद फ़ोल्डर और फ़ाइलें अपने नाम बनाए रखती हैं। {0} की सेटिंग्स रीसेट करें? संग्रह फ़ोल्डर + संग्रह टेम्पलेट सहेजे गए थंबनेल आकार ऑटो पर लौटें फ़ोल्डर चुनें diff --git a/i18n/hi/Tooltips.hi.resx b/i18n/hi/Tooltips.hi.resx index 3450af8e..29d7b120 100644 --- a/i18n/hi/Tooltips.hi.resx +++ b/i18n/hi/Tooltips.hi.resx @@ -36,6 +36,7 @@ पहली कॉपी का सीक्वेंस संपादन में खोलें हैश के आधार पर सभी सीक्वेंस में एक जैसी फ़ोटो खोजें · केवल इंडेक्स पढ़ता है इस वर्ष के सीक्वेंस दिखाएँ + हर फ़ोटो का फ़ाइल नाम, जैसा आयात उसे देते हैं · टाइप करते ही जाँचा जाता है केवल एक कैमरे के सीक्वेंस रखें यह मान चुनें; साफ़ करने के लिए इसे फिर से चुनें केवल एक स्थिति वाले सीक्वेंस रखें @@ -71,7 +72,10 @@ साइडकार फ़ाइलों से इंडेक्स फिर से बनाएँ; ज़रूरत पड़ने पर पूरा मेटाडेटा स्कैन करता है; मूल फ़ाइलें कभी नहीं हटाता पुनर्निर्माण कतार में रखें · इस दौरान संग्रह उपयोग योग्य रहता है आपके द्वारा स्थानांतरित किए गए संग्रह का नया फ़ोल्डर चुनें; उसके सीक्वेंस साथ आ जाते हैं - फ़ोल्डर, साइडकार फ़ाइलों और इंडेक्स में ठीक यही बदलाव करें · क्रैश के बाद फिर से शुरू होता है + एक कार्य कतार में रखें जो ठीक यही बदलाव करता है · उसे “कार्य” में विराम दें और फिर से शुरू करें + इस टेम्पलेट से फ़ोटो के नाम बदलें · बंद होने पर वे अपने नाम बनाए रखती हैं + सीक्वेंस फ़ोल्डरों को इस लेआउट में ले जाएँ · बंद होने पर वे अपनी जगह रहते हैं + इस टेम्पलेट से शीर्षक बदलें · बंद होने पर वे जैसे हैं वैसे रहते हैं सेटिंग्स › उन्नत में इंडेक्स का कोई बैकअप चुनें; यह अगली बार शुरू होने पर इंडेक्स की जगह लेता है इन सीक्वेंस के टैग साइडकार फ़ाइलों और इंडेक्स में बदलें वही क्रिया फिर से चलाएँ @@ -80,9 +84,8 @@ सेट के हर सीक्वेंस पर गहन विश्लेषण चलाएँ सेट को संग्रह के ट्रैश में ले जाएँ · परीक्षण रन दिखाता है, फिर पुष्टि के लिए टाइप करने को कहता है सेट को CSV के रूप में निर्यात करें: प्रति सीक्वेंस एक पंक्ति - सेट को नए फ़ोल्डर लेआउट में स्थानांतरित करें · पहले परीक्षण रन प्रॉक्सी बनाएँ या रीफ़्रेश करें - टेम्पलेट से सेट के शीर्षक बदलें · पहले परीक्षण रन + सेट पर फ़ोल्डर, फ़ाइल और शीर्षक टेम्पलेट लागू करें · पहले परीक्षण रन, फिर एक कार्य पूरे सेट पर टैग जोड़ें या निकालें थंबनेल बनाएँ या रीफ़्रेश करें सेट की मूल फ़ाइलें फिर से हैश करें @@ -471,12 +474,12 @@ {0:N0} सीक्वेंस का जो हिस्सा यहाँ नहीं है (मूल फ़ाइलें या रेंडर), उसे सर्वर से लाएँ · ट्रांसफ़र कार्यों के रूप में चलता है {0:N0} पंक्ति को आपके चुने फ़ोल्डर में CSV के रूप में सहेजें {0:N0} पंक्तियों को आपके चुने फ़ोल्डर में CSV के रूप में सहेजें - {0:N0} सीक्वेंस को उसके संग्रह के नए फ़ोल्डर लेआउट में स्थानांतरित करें · पहले परीक्षण रन दिखाता है - {0:N0} सीक्वेंस को उनके संग्रह के नए फ़ोल्डर लेआउट में स्थानांतरित करें · पहले परीक्षण रन दिखाता है {0:N0} सीक्वेंस के JPEG प्रॉक्सी बनाएँ · एक कार्य के रूप में चलता है {0:N0} सीक्वेंस के JPEG प्रॉक्सी बनाएँ · एक कार्य के रूप में चलता है {0:N0} सीक्वेंस की रेटिंग उसकी साइडकार फ़ाइल और इंडेक्स में सेट करें {0:N0} सीक्वेंस की रेटिंग उनकी साइडकार फ़ाइलों और इंडेक्स में सेट करें + उसके संग्रह के {0:N0} सीक्वेंस पर फ़ोल्डर, फ़ाइल और शीर्षक टेम्पलेट लागू करें · पहले परीक्षण रन, फिर एक कार्य + उनके संग्रह के {0:N0} सीक्वेंस पर फ़ोल्डर, फ़ाइल और शीर्षक टेम्पलेट लागू करें · पहले परीक्षण रन, फिर एक कार्य {0:N0} सीक्वेंस पर टैग जोड़ें या निकालें {0:N0} सीक्वेंस पर टैग जोड़ें या निकालें {0:N0} सीक्वेंस का जो हिस्सा सर्वर पर नहीं है (मूल फ़ाइलें और सेटिंग्स, या रेंडर), उसे भेजें · ट्रांसफ़र कार्य के रूप में चलता है @@ -692,6 +695,7 @@ “संतुलित” ज़्यादातर काम के लिए उपयुक्त है; “सर्वोत्तम” दोगुने रिज़ॉल्यूशन पर मापता है और आगे तक पढ़ता है; “तेज़” आधे रिज़ॉल्यूशन पर ड्राफ़्ट मोशन के साथ मापता है ड्राइवर या कोडेक इंस्टॉल करने के बाद एनकोडर फिर से सूचीबद्ध करें कोई कोडेक एक्सटेंशन इंस्टॉल करने के बाद उन्हें फिर से खोजें; अगले कार्य उनका उपयोग करते हैं + संग्रह के टेम्पलेट उसमें पहले से मौजूद सीक्वेंस पर लागू करें · पहले परीक्षण रन इस PC की हर सेटिंग को उसके डिफ़ॉल्ट पर लौटाएँ; पहले पूछता है डिफ़ॉल्ट टेम्पलेट और आकार अभी इस संग्रह की archive.json में लिखें हर सेटिंग अभी रीसेट करें diff --git a/i18n/hr/Admin.hr.resx b/i18n/hr/Admin.hr.resx index 3fc9b1bb..a92ec561 100644 --- a/i18n/hr/Admin.hr.resx +++ b/i18n/hr/Admin.hr.resx @@ -9,6 +9,7 @@ Chronos Server Vrijeme rada Verzija + Korisnik {0} reorganizirao je arhivu · {1} Korisnik {0} promijenio je strukturu arhive Korisnik {0} izbrisao je {1} Korisnik {0} pokrenuo je zadatak: {1} @@ -147,7 +148,7 @@ Uvoz Brza analiza Održavanje - Premještanje + Reorganizacija Nepovezane datoteke Proxy kopije Ponovna izgradnja @@ -367,6 +368,7 @@ Prijava radi administriranja ovog poslužitelja Korisnik Vaše korisničko ime na ovom poslužitelju + Arhiva reorganizirana Struktura arhive Fotografije izbrisane Zadatak pokrenut @@ -452,6 +454,63 @@ Promijeni lozinku Zamjenjuje lozinku i nastavlja na ploču Odaberite novu lozinku + Reorganiziraj… + Primjenjuje predloške mapa, datoteka i naslova na odabrane sekvence; pretpregled najprije prikazuje svaku promjenu + Poslije: + Primijeni… + Reorganizira kako je prikazano u pretpregledu; najprije traži potvrdu + Prije: + Upišite predložak ili isključite ovaj dio. + Zatvara bez ikakvih promjena + Premještena s mapom + Premješta se samo zato što se premješta mapa u kojoj se nalazi + Preimenovane datoteke + Mapa + Sekvenca + Reorganiziraj + Stavlja u red čekanja zadatak koji premješta i preimenuje izvornike; ništa se ne prepisuje niti briše + {0} fotografije dobivaju nove nazive. + {0} fotografija dobiva novi naziv. + {0} fotografija dobiva nove nazive. + Premještaju se {0} mape. + Premješta se {0} mapa. + Premješta se {0} mapa. + Mijenjaju se {0} sekvence. + Mijenja se {0} sekvenca. + Mijenja se {0} sekvenci. + Reorganizirati sada? + Naziv svake fotografije kakav joj daje uvoz, npr. {date}_{time}_{n:0000}; datoteke uz fotografiju slijede njezin naziv + Datoteke + Preimenuje fotografije svake sekvence; kada je isključeno, svi nazivi datoteka ostaju isti + {0} datoteke preimenovane + {0} datoteka preimenovana + {0} datoteka preimenovano + Mapa svake sekvence u arhivi, npr. {year}/{date} {camera}; {title} je novi naslov + Mape + Premješta svaku sekvencu u mapu koju određuje njezin predložak; kada je isključeno, svaka mapa ostaje gdje jest + Odabrana sekvenca više nije u arhivi; zatvorite prozor i ponovno odaberite. + {0}: {1} + Uključite barem jedan dio koji želite promijeniti. + Nema se što promijeniti: ove sekvence već slijede predloške. + Reorganiziraj… + Primjenjuje nove predloške na sekvence koje su već u arhivi; pretpregled najprije prikazuje svaku promjenu + Otvori zadatak + Prikazuje zadatak i njegov zapisnik na stranici „Zadaci” + Arhiva se promijenila tijekom potvrde; provjerite novi pretpregled i ponovno primijenite. + Planiranje… + Pretpregled + Kako će izgledati svaka sekvenca, redoslijedom kojim se promjene primjenjuju; još ništa nije promijenjeno + Reorganizacija je u redu čekanja. + Ova mapa ostaje gdje jest + Reorganizacija {0} sekvence + Reorganizacija {0} sekvence + Reorganizacija {0} sekvenci + Reorganizacija svih sekvenci + Novi naslov svake sekvence, npr. {date} {camera}; {title} je trenutačni naslov + Naslovi + Daje svakoj sekvenci naslov koji stvara njezin predložak; kada je isključeno, svi naslovi ostaju isti + Reorganizacija obuhvaća najviše {0} sekvenci odjednom ili sve sekvence: očistite filtre i odaberite sve. + Promijenjene sekvence: {0} · preimenovane datoteke: {1} · zadržani nazivi: {2} Administrator Urednik Pošiljatelj diff --git a/i18n/hr/Archive.hr.resx b/i18n/hr/Archive.hr.resx index 55dba142..37daf15f 100644 --- a/i18n/hr/Archive.hr.resx +++ b/i18n/hr/Archive.hr.resx @@ -16,6 +16,7 @@ Pričekajte da se promjene primijene. Skup je prazan: promijenite odabir ili filtar. Ništa se ne bi promijenilo. + Uključite barem jedan predložak. Arhiva mora biti dostupna i omogućavati zapisivanje. Pričekajte probni rad. Pričekajte da se arhiva pročita. @@ -91,6 +92,15 @@ Datoteku {0} zapisala je novija verzija programa Chronos (format {1}). Arhiva {0} nije dostupna. Arhiva {0} je samo za čitanje. + {0:N0} sekvence zadržale su nazive datoteka: fotografija je bila u upotrebi ili je njezin novi naziv bio zauzet. + {0:N0} sekvenca zadržala je nazive datoteka: fotografija je bila u upotrebi ili je njezin novi naziv bio zauzet. + {0:N0} sekvenci zadržalo je nazive datoteka: fotografija je bila u upotrebi ili je njezin novi naziv bio zauzet. + {0:N0} sekvence nisu reorganizirane prema planu: promijenile su se nakon izrade plana. + {0:N0} sekvenca nije reorganizirana prema planu: promijenila se nakon izrade plana. + {0:N0} sekvenci nije reorganizirano prema planu: promijenile su se nakon izrade plana. + {0:N0} sekvence zadržale su naslove i nazive datoteka: njihove datoteke sekvence potječu iz novije verzije programa Chronos. + {0:N0} sekvenca zadržala je naslov i nazive datoteka: njezina datoteka sekvence potječe iz novije verzije programa Chronos. + {0:N0} sekvenci zadržalo je naslove i nazive datoteka: njihove datoteke sekvence potječu iz novije verzije programa Chronos. Izvor {0} promijenio se nakon izrade plana. Kartica ili mapa {0} više nije dostupna. Arhiva se promijenila nakon izrade ovog plana. @@ -162,6 +172,14 @@ Neindeksirane fotografije: {0}, fotografije koje nedostaju: {1} {0}: izrađeno {1}, ponovno upotrijebljeno {2}, nečitljivo {3}, čeka {4} Proxy kopije za poslužitelj: poslano {0}, nije poslano {1} + Ostavljeno kako je bilo, mapa u kojoj se nalazi ostala je na mjestu: {0} + Ostavljeno kako je bilo, promijenjeno nakon izrade plana: {0} + Nazivi datoteka zadržani, fotografija je bila u upotrebi ili je njezin novi naziv bio zauzet: {0} + Nazivi datoteka zadržani, fotografije su se promijenile nakon izrade plana: {0} + Naslov i nazivi datoteka zadržani, datoteka sekvence potječe iz novije verzije programa Chronos: {0} + Naslov i nazivi datoteka zadržani, promijenjeno nakon izrade plana: {0} + Promijenjene sekvence: {0}, preimenovane datoteke: {1} + Reorganizacija je dovršena pri otvaranju arhive Samo izvješće: ništa nije promijenjeno. Mape: {0}, indeksirano: {1}, usvojeno: {2}, uklonjeno: {3} Sekvenca nije pronađena: {0} @@ -219,17 +237,34 @@ Mapa premještene arhive Primijeni {0} od {1} - Preimenuj {0:N0} sekvence - Preimenuj {0:N0} sekvencu - Preimenuj {0:N0} sekvenci - Premjesti {0:N0} sekvence - Premjesti {0:N0} sekvencu - Premjesti {0:N0} sekvenci Promjene Mijenjaju se {0:N0} od {1:N0} Mijenja se {0:N0} od {1:N0} Mijenja se {0:N0} od {1:N0} - Predložak + Fotografije koje su ostale na svojem mjestu izvan mape originals zadržavaju svoje nazive. + Fotografije koje nedostaju zadržavaju svoje nazive. + Fotografije koje nikad nisu provjerene zadržavaju svoje nazive; najprije provjerite sekvencu. + Datoteka sekvence ne može se pročitati; sekvenca ostaje kakva jest, kao i svaka mapa u kojoj se nalazi. + Prati svoju mapu + {0}: {1} postaje {2} + Datoteka + Nazivi datoteka + Mapa + Mape + Reorganizacija {0:N0} sekvence + Reorganizacija {0:N0} sekvence + Reorganizacija {0:N0} sekvenci + Reorganizacija arhive {0} + {0:N0} naziva zadržana + {0:N0} naziv zadržan + {0:N0} naziva zadržano + Probni rad… + {0:N0} datoteke preimenovane + {0:N0} datoteka preimenovana + {0:N0} datoteka preimenovano + Naslov + Naslovi + Reorganizacija će se otvoriti kada se zatvori otvoreni dijaloški okvir Dodaj oznake Primijeni Oznake {0:N0} sekvence @@ -246,9 +281,8 @@ Izvezi CSV Filtar skupa Filtrirani skup - Premjesti… Proxy kopije - Preimenuj… + Reorganiziraj… Promijeni oznake… Minijature Provjeri diff --git a/i18n/hr/Errors.hr.resx b/i18n/hr/Errors.hr.resx index 810eeb65..35af635e 100644 --- a/i18n/hr/Errors.hr.resx +++ b/i18n/hr/Errors.hr.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Neanalizirane sekvence: {0} od {1}; pogledajte zapisnik zadatka. + Mapa ove sekvence nije ondje gdje je navodi indeks; pokušajte ponovno nakon sljedećeg skeniranja. Arhiva se ne može otvoriti. Za trenutačni indeks nije bilo moguće izraditi sigurnosnu kopiju niti ga zamijeniti; vraćanje će se ponovno pokušati pri sljedećem pokretanju. Ova se sigurnosna kopija ne može vratiti; odaberite drugu. @@ -39,9 +40,11 @@ {0} izvornika nedostaje ili se promijenilo nakon arhiviranja; provjerite arhivu. Predložak je prazan. Prazno rezervirano mjesto na položaju {1}: upišite naziv između vitičastih zagrada. + Fotografije bi izgubile nastavak: upišite točku ispred {ext} ili izostavite {ext}. Nazivi datoteka ne smiju sadržavati kosu crtu; mape navedite u predlošku mape. Format iza dvotočke ne odgovara svojem rezerviranom mjestu. Nazivi bi se ponavljali: dodajte broj kadra, vrijeme ili izvorni naziv. + Skeniranje preskače mape koje počinju točkom ili se zovu originals, proxies ili exports. Vitičasta zagrada otvorena na položaju {1} nikad se ne zatvara. Nepoznato rezervirano mjesto „{0}” na položaju {1}. Zatvorena vitičasta zagrada na položaju {1} nema otvorenu; udvostručite je za doslovnu zagradu. diff --git a/i18n/hr/Jobs.hr.resx b/i18n/hr/Jobs.hr.resx index 194e45fd..8f2a11f8 100644 --- a/i18n/hr/Jobs.hr.resx +++ b/i18n/hr/Jobs.hr.resx @@ -77,7 +77,7 @@ Uvoz Brza analiza Održavanje - Premještanje arhive + Reorganizacija Nepovezane datoteke Proxy kopije Ponovna izgradnja indeksa diff --git a/i18n/hr/Library.hr.resx b/i18n/hr/Library.hr.resx index 3456e0d5..535979d8 100644 --- a/i18n/hr/Library.hr.resx +++ b/i18n/hr/Library.hr.resx @@ -10,17 +10,16 @@ Preuzmi Izvezi popis Mapa - Premjesti… Otvori Proxy kopije Ocjena Renderiraj + Reorganiziraj… Sinkroniziraj Oznake… Prenesi Provjeri Usvoji mapu - Premještanje radi sa sekvencama samo jedne arhive odjednom. Isto na ovom računalu i na poslužitelju: nema se što sinkronizirati. Nijedan spremljeni prikaz nije u upotrebi; najprije odaberite jedan. Vaš račun na poslužitelju ne može preuzimati izvornike. @@ -32,6 +31,7 @@ Najprije se prijavite na Chronos Server, na zaslonu Poslužitelj. Odabrane sekvence nemaju ništa za preuzimanje s poslužitelja. Poslužitelj već ima sve što sadrže odabrane sekvence. + Reorganizacija radi sa sekvencama samo jedne arhive odjednom. Samo za sekvence na ovom računalu; odabir se nalazi na poslužitelju. Prijenos ove sekvence već je u tijeku. Očisti filtre diff --git a/i18n/hr/Server.hr.resx b/i18n/hr/Server.hr.resx index a1541162..afb74173 100644 --- a/i18n/hr/Server.hr.resx +++ b/i18n/hr/Server.hr.resx @@ -40,6 +40,7 @@ Povezivanje nije uspjelo; pojedinosti su u zapisniku. Datoteka sekvence otvorena je u drugom programu; zatvorite je i pokušajte ponovno. Njezina mapa više nije na disku; u koš za smeće nema se što premjestiti. + Mapa ove sekvence nije ondje gdje je navodi indeks poslužitelja; pokušajte ponovno nakon njegova sljedećeg skeniranja. Vaš račun to ne smije učiniti. Fotografije sekvence promijenile su se na poslužitelju; ponovno je učitajte i ponovno primijenite svoju izmjenu. Datoteka je stigla oštećena; ponovno je prenesite. @@ -68,11 +69,14 @@ Ovaj poslužitelj ne može izvoditi tu vrstu zadatka. Posljednji administrator ne može se ukloniti ni onemogućiti. Ova metoda ovdje nije dopuštena. + Nova mapa nalazila bi se unutar mape druge sekvence. Ta adresa nije Chronos Server. Nije pronađeno. Najprije promijenite lozinku. Fotografija je izbrisana iz sekvence dok se prenosila pa nije dodana. Datoteka {0} ne može se pročitati, a bez njezina hasha ostale kopije ne bi saznale da je izbrisana; zatvorite program koji je upotrebljava ili provjerite njezina dopuštenja, a zatim pokušajte ponovno. + Arhiva se promijenila nakon probnog rada; ponovno pregledajte plan. + Poslužitelj je prestao izrađivati ovaj plan: trajalo je predugo ili je odjednom zatraženo previše planova; pokušajte ponovno malo poslije. Ova arhiva ne izrađuje proxy kopije. Proxy kopija izrađena je od druge fotografije. Poslužitelju nije potrebna proxy kopija ove fotografije. diff --git a/i18n/hr/Settings.hr.resx b/i18n/hr/Settings.hr.resx index b0a6bb64..96136551 100644 --- a/i18n/hr/Settings.hr.resx +++ b/i18n/hr/Settings.hr.resx @@ -66,6 +66,7 @@ zvijezda po megapikselu Širina analize px na duljoj stranici + Mape i datoteke koje su već u arhivi zadržavaju svoje nazive. Nazivi datoteka Mape Slobodno: {0} @@ -75,10 +76,12 @@ Odaberite mapu arhive Pretpregled Veličina proxy kopija + Reorganiziraj… Vrati zadano Njezini predlošci naziva, veličina proxy kopija i veličina minijatura vraćaju se na zadane vrijednosti za svako računalo i poslužitelj koji je upotrebljavaju. Mape i datoteke koje su već u arhivi zadržavaju svoje nazive. Vratiti postavke arhive {0} na zadano? Mapa arhive + Predlošci arhive spremljeni Veličina minijatura Vrati na Auto Odaberi mapu diff --git a/i18n/hr/Tooltips.hr.resx b/i18n/hr/Tooltips.hr.resx index 04c2bbf3..1e695dc9 100644 --- a/i18n/hr/Tooltips.hr.resx +++ b/i18n/hr/Tooltips.hr.resx @@ -37,6 +37,7 @@ Otvara sekvencu prve kopije u odjeljku Uređivanje Pronalazi identične fotografije u svim sekvencama prema hashu · čita samo indeks Prikazuje sekvence ove godine + Naziv datoteke svake fotografije, kako ih imenuje uvoz · provjerava se tijekom upisivanja Zadržava samo sekvence jednog fotoaparata Odabire ovu vrijednost; ponovni odabir je poništava Zadržava samo sekvence u jednom stanju @@ -72,7 +73,10 @@ Ponovno izgrađuje indeks iz pratećih datoteka; ako treba, skenira sve metapodatke; nikad ne briše izvornike Stavlja ponovnu izgradnju u red čekanja · arhiva se u međuvremenu može upotrebljavati Odabir nove mape premještene arhive; njezine sekvence je slijede - Primjenjuje točno ove promjene na mape, prateće datoteke i indeks · nastavlja se nakon rušenja programa + Stavlja u red čekanja zadatak koji izvodi točno ove promjene · može se pauzirati i nastaviti u Zadacima + Preimenuje fotografije prema ovom predlošku · kada je isključeno, zadržavaju svoje nazive + Premješta mape sekvenci u ovu strukturu · kada je isključeno, ostaju gdje jesu + Mijenja naslove prema ovom predlošku · kada je isključeno, ostaju kakvi jesu Odaberite sigurnosnu kopiju indeksa u Postavke › Napredno; ona zamjenjuje indeks pri sljedećem pokretanju Mijenja oznake ovih sekvenci u pratećim datotekama i indeksu Ponovno pokreće istu radnju @@ -81,9 +85,8 @@ Pokreće dubinsku analizu svake sekvence u skupu Premješta skup u koš za smeće arhive · prikazuje probni rad, a zatim traži da upišete potvrdu Izvozi skup kao CSV: jedan redak po sekvenci - Premješta skup u novu strukturu mapa · najprije probni rad Izrađuje ili osvježava proxy kopije - Preimenuje naslove skupa prema predlošku · najprije probni rad + Primjenjuje predloške mapa, datoteka i naslova na skup · najprije probni rad, zatim zadatak Dodaje ili uklanja oznake na cijelom skupu Izrađuje ili osvježava minijature Ponovno izračunava hash izvornika skupa @@ -478,15 +481,15 @@ Sprema {0:N0} retka kao CSV u mapu po vašem izboru Sprema {0:N0} redak kao CSV u mapu po vašem izboru Sprema {0:N0} redaka kao CSV u mapu po vašem izboru - Premješta {0:N0} sekvence u novu strukturu mapa unutar arhive · najprije prikazuje probni rad - Premješta {0:N0} sekvencu u novu strukturu mapa unutar arhive · najprije prikazuje probni rad - Premješta {0:N0} sekvenci u novu strukturu mapa unutar arhive · najprije prikazuje probni rad Izrađuje JPEG proxy kopije {0:N0} sekvence · izvodi se kao jedan zadatak Izrađuje JPEG proxy kopije {0:N0} sekvence · izvodi se kao jedan zadatak Izrađuje JPEG proxy kopije {0:N0} sekvenci · izvodi se kao jedan zadatak Postavlja ocjenu {0:N0} sekvence u njihovim pratećim datotekama i indeksu Postavlja ocjenu {0:N0} sekvence u njezinoj pratećoj datoteci i indeksu Postavlja ocjenu {0:N0} sekvenci u njihovim pratećim datotekama i indeksu + Primjenjuje predloške mapa, datoteka i naslova na {0:N0} sekvence iz njihove arhive · najprije probni rad, zatim zadatak + Primjenjuje predloške mapa, datoteka i naslova na {0:N0} sekvencu iz njezine arhive · najprije probni rad, zatim zadatak + Primjenjuje predloške mapa, datoteka i naslova na {0:N0} sekvenci iz njihove arhive · najprije probni rad, zatim zadatak Dodaje ili uklanja oznake {0:N0} sekvence Dodaje ili uklanja oznake {0:N0} sekvence Dodaje ili uklanja oznake {0:N0} sekvenci @@ -711,6 +714,7 @@ Uravnoteženo odgovara većini poslova; Najbolje mjeri u dvostrukoj razlučivosti i čita dalje unaprijed; Brzo mjeri u upola manjoj razlučivosti s optičkim tokom u kvaliteti Nacrt Ponovno navodi kodere nakon instalacije upravljačkog programa ili kodeka Ponovno traži proširenja kodeka nakon instalacije nekog od njih; sljedeći ih zadaci upotrebljavaju + Primjenjuje predloške arhive na sekvence koje su već u njoj · najprije probni rad Vraća sve postavke ovog računala na zadane vrijednosti; najprije traži potvrdu Odmah zapisuje zadane predloške i veličine u datoteku archive.json ove arhive Odmah vraća sve postavke na zadano diff --git a/i18n/hu/Admin.hu.resx b/i18n/hu/Admin.hu.resx index d4a20d25..7e2e7d59 100644 --- a/i18n/hu/Admin.hu.resx +++ b/i18n/hu/Admin.hu.resx @@ -9,6 +9,7 @@ Chronos Server Üzemidő Verzió + {0} átrendezte az archívumot · {1} {0} módosította az archívum szerkezetét {0} törölte: {1} {0} elindította: {1} @@ -138,7 +139,7 @@ Importálás Gyorselemzés Karbantartás - Áthelyezés + Átrendezés Árva fájlok Proxyk Újraépítés @@ -343,6 +344,7 @@ Bejelentkezés a szerver felügyeletéhez Felhasználó A felhasználóneve ezen a szerveren + Archívum átrendezve Archívum szerkezete Fotók törölve Feladat elindítva @@ -426,6 +428,58 @@ Jelszó módosítása Lecseréli a jelszót, és továbblép a panelre Új jelszó megadása + Átrendezés… + Mappa-, fájlnév- és címsablonokat alkalmaz a kijelölt sorozatokra; előbb előnézet mutat meg minden módosítást + Utána: + Alkalmazás… + Az előnézet szerint rendez át; előbb megerősítést kér + Előtte: + Írjon be egy sablont, vagy kapcsolja ki ezt a részt. + Bezárja anélkül, hogy bármit módosítana + Mappájával együtt + Csak azért helyeződik át, mert egy mappa, amelyben található, áthelyeződik + Átnevezett fájlok + Mappa + Sorozat + Átrendezés + Várólistára teszi a feladatot, amely áthelyezi és átnevezi az eredeti fájlokat; semmit sem ír felül és semmit sem töröl + {0} fotó új nevet kap. + {0} fotó új nevet kap. + {0} mappa áthelyeződik. + {0} mappa áthelyeződik. + {0} sorozat módosul. + {0} sorozat módosul. + Átrendezi most? + Az egyes fotók neve, ahogy az importálás adja, pl. {date}_{time}_{n:0000}; a fotó melletti fájlok követik a nevét + Fájlok + Átnevezi az egyes sorozatok fotóit; kikapcsolva minden fájlnév megmarad + {0} fájl átnevezve + {0} fájl átnevezve + Az egyes sorozatok mappája az archívumban, pl. {year}/{date} {camera}; a {title} az új cím + Mappák + Minden sorozatot a sablonja szerinti mappába helyez át; kikapcsolva minden mappa a helyén marad + Az egyik kijelölt sorozat már nincs az archívumban; zárja be az ablakot, és jelöljön ki újra. + {0}: {1} + Kapcsoljon be legalább egy módosítandó részt. + Nincs mit módosítani: ezek a sorozatok már követik a sablonokat. + Átrendezés… + Az új sablonokat alkalmazza az archívumban már meglévő sorozatokra; előbb előnézet mutat meg minden módosítást + Feladat megnyitása + Megjeleníti a feladatot és a naplóját a Feladatok oldalon + Az archívum megváltozott a megerősítés közben; ellenőrizze az új előnézetet, és alkalmazza újra. + Tervezés… + Előnézet + Mi lesz az egyes sorozatokból, a módosítások alkalmazásának sorrendjében; még semmi sem változott + Átrendezés várólistára téve. + Ez a mappa a helyén marad + {0} sorozat átrendezése + {0} sorozat átrendezése + Az összes sorozat átrendezése + Az egyes sorozatok új címe, pl. {date} {camera}; a {title} a jelenlegi cím + Címek + Minden sorozatnak a sablonja szerinti címet adja; kikapcsolva minden cím megmarad + Az átrendezés egyszerre legfeljebb {0} sorozatot kezel, vagy az összeset: törölje a szűrőket, és jelöljön ki mindent. + Módosult sorozatok: {0} · átnevezett fájlok: {1} · megtartott nevek: {2} Rendszergazda Szerkesztő Feltöltő diff --git a/i18n/hu/Archive.hu.resx b/i18n/hu/Archive.hu.resx index 0aa7a433..3790bbde 100644 --- a/i18n/hu/Archive.hu.resx +++ b/i18n/hu/Archive.hu.resx @@ -15,6 +15,7 @@ Várja meg, amíg a módosítások érvénybe lépnek. A halmaz üres: módosítsa a kijelölést vagy a szűrőt. Semmi sem változna. + Kapcsoljon be legalább egy sablont. Az archívumnak elérhetőnek és írhatónak kell lennie. Várja meg a próbafuttatást. Várja meg, amíg az archívum beolvasása befejeződik. @@ -81,6 +82,12 @@ {0}: egy újabb Chronos-verzió írta (formátum: {1}). A(z) {0} archívum nem érhető el. A(z) {0} archívum csak olvasható. + {0:N0} sorozat megtartotta a fájlneveit: egy fotó használatban volt, vagy az új neve már foglalt volt. + {0:N0} sorozat megtartotta a fájlneveit: egy fotó használatban volt, vagy az új neve már foglalt volt. + {0:N0} sorozat átrendezése elmaradt: a terv elkészülte után megváltozott. + {0:N0} sorozat átrendezése elmaradt: a terv elkészülte után megváltoztak. + {0:N0} sorozat megtartotta a címét és a fájlneveit: a sorozatfájlja egy újabb Chronos-verzióból származik. + {0:N0} sorozat megtartotta a címét és a fájlneveit: a sorozatfájljaik egy újabb Chronos-verzióból származnak. {0}: a terv elkészülte után megváltozott. A(z) {0} kártya vagy mappa már nem érhető el. Az archívum megváltozott a terv elkészülte óta. @@ -146,6 +153,14 @@ Nem indexelt fotók: {0}, hiányzó fotók: {1} {0}: elkészítve {1}, újrafelhasználva {2}, olvashatatlan {3}, várakozó {4} Proxyk a szervernek – elküldve: {0}, nem elküldve: {1} + Változatlanul hagyva, mert a mappa, amelyben található, a helyén maradt: {0} + Változatlanul hagyva, a terv elkészülte után megváltozott: {0} + Fájlnevek megtartva, egy fotó használatban volt, vagy az új neve már foglalt volt: {0} + Fájlnevek megtartva, a fotók a terv elkészülte után megváltoztak: {0} + Cím és fájlnevek megtartva, a sorozatfájl egy újabb Chronos-verzióból származik: {0} + Cím és fájlnevek megtartva, a terv elkészülte után megváltozott: {0} + Módosult sorozatok: {0}, átnevezett fájlok: {1} + Az átrendezés az archívum megnyitásakor fejeződött be Csak jelentés: semmi sem változott. Mappák: {0}, indexelve: {1}, átvéve: {2}, eltávolítva: {3} A sorozat nem található: {0} @@ -200,14 +215,30 @@ Az áthelyezett archívum mappája Alkalmazás {0} / {1} - {0:N0} sorozat átnevezése - {0:N0} sorozat átnevezése - {0:N0} sorozat áthelyezése - {0:N0} sorozat áthelyezése Módosítások {1:N0} közül {0:N0} módosul {1:N0} közül {0:N0} módosul - Sablon + Az originals mappán kívül, a helyükön tartott fotók megtartják a nevüket. + A hiányzó fotók megtartják a nevüket. + A soha nem ellenőrzött fotók megtartják a nevüket; előbb ellenőrizze a sorozatot. + A sorozatfájl nem olvasható; a sorozat változatlan marad, és minden mappa is, amelyben található. + Követi a mappáját + {0}: {1} helyett {2} + Fájl + Fájlnevek + Mappa + Mappák + {0:N0} sorozat átrendezése + {0:N0} sorozat átrendezése + A(z) {0} archívum átrendezése + {0:N0} név megtartva + {0:N0} név megtartva + Próbafuttatás… + {0:N0} fájl átnevezve + {0:N0} fájl átnevezve + Cím + Címek + Az átrendezés akkor nyílik meg, amikor a megnyitott párbeszédpanel bezárul Címkék hozzáadása Alkalmazás {0:N0} sorozat címkéi @@ -222,9 +253,8 @@ CSV exportálása Halmazszűrő Szűrt halmaz - Áthelyezés… Proxyk - Átnevezés… + Átrendezés… Címkézés… Miniatűrök Ellenőrzés diff --git a/i18n/hu/Errors.hu.resx b/i18n/hu/Errors.hu.resx index eab960a8..393b9b18 100644 --- a/i18n/hu/Errors.hu.resx +++ b/i18n/hu/Errors.hu.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Nem elemzett sorozatok: {0} / {1}; a részletek a feladat naplójában találhatók. + Ennek a sorozatnak a mappája nem ott van, ahol az index szerint lennie kellene; próbálja újra a következő átvizsgálás után. Az archívumot nem sikerült megnyitni. A jelenlegi indexről nem sikerült biztonsági mentést készíteni, vagy nem sikerült lecserélni; a visszaállítás a következő indításkor újra lefut. Ez a biztonsági mentés nem állítható vissza; válasszon másikat. @@ -37,9 +38,11 @@ {0} eredeti fájl hiányzik, vagy az archiválás óta megváltozott; ellenőrizze az archívumot. A sablon üres. Üres helyőrző a(z) {1}. pozícióban: írjon nevet a kapcsos zárójelek közé. + A fotók elveszítenék a kiterjesztésüket: írjon egy pontot az {ext} elé, vagy hagyja el az {ext} helyőrzőt. A fájlnevek nem tartalmazhatnak perjelet; a mappákat a mappasablonba írja. A kettőspont utáni formátum nem illik a helyőrzőhöz. A nevek ismétlődnének: adja hozzá a képkocka sorszámát, az időt vagy az eredeti nevet. + Az átvizsgálás kihagyja a ponttal kezdődő, valamint az originals, proxies vagy exports nevű mappákat. A(z) {1}. pozícióban nyitott kapcsos zárójel nincs lezárva. Ismeretlen helyőrző: „{0}” ({1}. pozíció). A(z) {1}. pozícióban lévő záró kapcsos zárójelnek nincs nyitó párja; szó szerinti zárójelhez írja kétszer. diff --git a/i18n/hu/Jobs.hu.resx b/i18n/hu/Jobs.hu.resx index 64dbb21d..8e8c90a3 100644 --- a/i18n/hu/Jobs.hu.resx +++ b/i18n/hu/Jobs.hu.resx @@ -76,7 +76,7 @@ Importálás Gyorselemzés Karbantartás - Archívum áthelyezése + Átrendezés Árva fájlok Proxyk Index újraépítése diff --git a/i18n/hu/Library.hu.resx b/i18n/hu/Library.hu.resx index 5a90da4b..a8070d93 100644 --- a/i18n/hu/Library.hu.resx +++ b/i18n/hu/Library.hu.resx @@ -10,17 +10,16 @@ Letöltés Lista exportálása Mappa - Áthelyezés… Megnyitás Proxyk Értékelés Renderelés + Átrendezés… Szinkronizálás Címkék… Feltöltés Ellenőrzés Mappa átvétele - Az áthelyezés egyszerre csak egy archívum sorozataival működik. Azonos ezen a számítógépen és a szerveren: nincs mit szinkronizálni. Nincs használatban mentett nézet; előbb válasszon egyet. A szerveres fiókja nem tölthet le eredeti fájlokat. @@ -32,6 +31,7 @@ Előbb jelentkezzen be egy Chronos Serverre a Szerver képernyőn. A kijelölt sorozatokhoz nincs mit letölteni a szerverről. A szerveren már megvan minden, ami a kijelölt sorozatokban található. + Az átrendezés egyszerre csak egy archívum sorozataival működik. Csak az ezen a számítógépen lévő sorozatokhoz; a kijelölés a szerveren található. Ennek a sorozatnak az átvitele már folyamatban van. Szűrők törlése diff --git a/i18n/hu/Server.hu.resx b/i18n/hu/Server.hu.resx index 738e5e92..ceda0746 100644 --- a/i18n/hu/Server.hu.resx +++ b/i18n/hu/Server.hu.resx @@ -40,6 +40,7 @@ A kapcsolat sikertelen; a részletek a naplóban találhatók. A sorozat egyik fájlja meg van nyitva egy másik programban; zárja be, és próbálja újra. A mappája már nincs a lemezen; nincs mit a lomtárba helyezni. + Ennek a sorozatnak a mappája nem ott van, ahol a szerver indexe szerint lennie kellene; próbálja újra a szerver következő átvizsgálása után. Ehhez a fiókjának nincs jogosultsága. A sorozat fotói megváltoztak a szerveren; töltse be újra, és alkalmazza ismét a módosítást. A fájl sérülten érkezett meg; töltse fel újra. @@ -68,11 +69,14 @@ Ez a szerver nem tud ilyen típusú feladatot futtatni. Az utolsó rendszergazda nem távolítható el és nem tiltható le. Ez a metódus itt nem engedélyezett. + Egy új mappa egy másik sorozat mappáján belülre kerülne. Ez a cím nem Chronos Server. Nem található. Előbb változtassa meg a jelszavát. A fotót feltöltés közben törölték a sorozatból, ezért nem lett hozzáadva. A(z) {0} nem olvasható, és a hash-értéke nélkül a többi másolat nem értesülne a törléséről; zárja be az azt használó programot, vagy ellenőrizze a jogosultságait, majd próbálja újra. + Az archívum megváltozott a próbafuttatás óta; tekintse át újra a tervet. + A szerver abbahagyta ennek a tervnek a készítését: túl sokáig tartott, vagy egyszerre túl sok tervet kértek; próbálja újra hamarosan. Ez az archívum nem készít proxykat. A proxy egy másik fotóból készült. A szervernek nincs szüksége ennek a fotónak a proxyjára. diff --git a/i18n/hu/Settings.hu.resx b/i18n/hu/Settings.hu.resx index 2de59d11..efc52a7c 100644 --- a/i18n/hu/Settings.hu.resx +++ b/i18n/hu/Settings.hu.resx @@ -65,6 +65,7 @@ csillag megapixelenként Elemzési szélesség px a hosszabbik oldalon + Az archívumban már meglévő mappák és fájlok megtartják a nevüket. Fájlnevek Mappák {0} szabad @@ -74,10 +75,12 @@ Archívummappa kiválasztása Előnézet Proxyméret + Átrendezés… Archívum alaphelyzetbe állítása Az elnevezési sablonok, a proxyméret és a miniatűrméret visszaáll az alapértékre minden számítógépen és szerveren, amely az archívumot használja. Az archívumban már meglévő mappák és fájlok megtartják a nevüket. Alaphelyzetbe állítja a(z) {0} archívum beállításait? Archívummappa + Archívumsablonok mentve Miniatűrméret Vissza Auto értékre Mappa kiválasztása diff --git a/i18n/hu/Tooltips.hu.resx b/i18n/hu/Tooltips.hu.resx index 4d03f4ca..b279388d 100644 --- a/i18n/hu/Tooltips.hu.resx +++ b/i18n/hu/Tooltips.hu.resx @@ -36,6 +36,7 @@ Megnyitja az első másolat sorozatát a Szerkesztés képernyőn Azonos fotókat keres a sorozatok között hash-érték alapján · csak az indexet olvassa Megjeleníti ennek az évnek a sorozatait + Az egyes fotók fájlneve, ahogy az importálás elnevezi őket · gépelés közben ellenőrizve Csak egy fényképezőgép sorozatait tartja meg Kiválasztja ezt az értéket; újbóli választással törli Csak az adott állapotú sorozatokat tartja meg @@ -71,7 +72,10 @@ A kísérőfájlokból újraépíti az indexet; ha kell, teljes metaadat-átvizsgálásra vált; eredeti fájlt sosem töröl Várólistára teszi az újraépítést · közben az archívum használható marad Egy áthelyezett archívum új mappájának kiválasztása; a sorozatai is követik - Pontosan ezeket a módosításokat hajtja végre a mappákon, a kísérőfájlokon és az indexen · összeomlás után folytatódik + Várólistára tesz egy feladatot, amely pontosan ezeket a módosításokat végzi el · a Feladatok között szüneteltethető és folytatható + Ezzel a sablonnal nevezi át a fotókat · kikapcsolva megtartják a nevüket + Ebbe a szerkezetbe helyezi át a sorozatmappákat · kikapcsolva a helyükön maradnak + Ezzel a sablonnal módosítja a címeket · kikapcsolva változatlanok maradnak Válassza ki az index egyik biztonsági mentését a Beállítások › Speciális oldalon; a következő indításkor felváltja az indexet Módosítja ezen sorozatok címkéit a kísérőfájlokban és az indexben Újra lefuttatja ugyanazt a műveletet @@ -80,9 +84,8 @@ Részletes elemzést futtat a halmaz minden sorozatán A halmazt az archívum lomtárába helyezi · előbb próbafuttatást mutat, majd begépelt megerősítést kér CSV-be exportálja a halmazt: soronként egy sorozat - Új mappaszerkezetbe helyezi át a halmazt · előbb próbafuttatás Proxykat készít vagy frissít - Sablonnal átnevezi a halmaz címeit · előbb próbafuttatás + Mappa-, fájlnév- és címsablonokat alkalmaz a halmazra · előbb próbafuttatás, aztán feladat Címkéket ad a halmaz összes sorozatához, vagy címkéket távolít el róluk Miniatűröket készít vagy frissít Újraszámolja a halmaz eredeti fájljainak hash-értékét @@ -471,12 +474,12 @@ Letölti a szerverről, ami {0:N0} sorozatból itt hiányzik (eredeti vagy renderelt fájlok) · átviteli feladatokként fut {0:N0} sort CSV-fájlba ment egy választott mappába {0:N0} sort CSV-fájlba ment egy választott mappába - {0:N0} sorozatot áthelyez az archívuma új mappaszerkezetébe · előbb próbafuttatást mutat - {0:N0} sorozatot áthelyez az archívumuk új mappaszerkezetébe · előbb próbafuttatást mutat JPEG-proxykat készít {0:N0} sorozathoz · egyetlen feladatként fut JPEG-proxykat készít {0:N0} sorozathoz · egyetlen feladatként fut Beállítja {0:N0} sorozat értékelését a kísérőfájljában és az indexben Beállítja {0:N0} sorozat értékelését a kísérőfájljaikban és az indexben + Mappa-, fájlnév- és címsablonokat alkalmaz {0:N0} sorozatra a saját archívumában · előbb próbafuttatás, aztán feladat + Mappa-, fájlnév- és címsablonokat alkalmaz {0:N0} sorozatra a saját archívumukban · előbb próbafuttatás, aztán feladat Címkéket ad {0:N0} sorozathoz, vagy címkéket távolít el róla Címkéket ad {0:N0} sorozathoz, vagy címkéket távolít el róluk Elküldi, ami {0:N0} sorozatból a szerveren hiányzik (eredeti fájlok és beállítások, vagy renderelt fájlok) · átviteli feladatként fut @@ -692,6 +695,7 @@ A Kiegyensúlyozott a legtöbb munkához megfelel; a Legjobb kétszeres felbontáson mér, és több képkockát olvas előre; a Gyors fél felbontáson mér, vázlatos mozgásbecsléssel Újra listázza a kódolókat illesztőprogram vagy kodek telepítése után Egy kodekbővítmény telepítése után újra megkeresi a kodekbővítményeket; a következő feladatok már használják őket + Az archívum sablonjait alkalmazza a benne már meglévő sorozatokra · előbb próbafuttatás Ennek a számítógépnek minden beállítását visszaállítja az alapértékre; előbb megerősítést kér Most beírja az alapértelmezett sablonokat és méreteket az archívum archive.json fájljába Most alaphelyzetbe állít minden beállítást diff --git a/i18n/id/Admin.id.resx b/i18n/id/Admin.id.resx index 5b2e24d0..5eba05c5 100644 --- a/i18n/id/Admin.id.resx +++ b/i18n/id/Admin.id.resx @@ -9,6 +9,7 @@ Chronos Server Berjalan selama Versi + {0} menata ulang arsip · {1} {0} mengubah tata letak arsip {0} menghapus {1} {0} memulai {1} @@ -138,7 +139,7 @@ Impor Analisis cepat Pemeliharaan - Pemindahan + Penataan ulang File yatim Proksi Bangun ulang @@ -343,6 +344,7 @@ Masuk untuk mengelola server ini Pengguna Nama pengguna Anda di server ini + Arsip ditata ulang Tata letak arsip Foto dihapus Tugas dimulai @@ -426,6 +428,58 @@ Ubah kata sandi Ganti kata sandi lalu lanjutkan ke panel Pilih kata sandi baru + Tata ulang… + Terapkan templat folder, file, dan judul ke sekuens yang dipilih; pratinjau menampilkan setiap perubahan terlebih dahulu + Sesudah: + Terapkan… + Tata ulang seperti yang ditampilkan pratinjau; konfirmasi diminta terlebih dahulu + Sebelum: + Tulis templat, atau nonaktifkan bagian ini. + Tutup tanpa mengubah apa pun + Ikut terbawa + Berpindah hanya karena folder yang memuatnya dipindahkan + File diganti nama + Folder + Sekuens + Tata ulang + Antrekan tugas yang memindahkan dan mengganti nama file asli; tidak ada yang ditimpa atau dihapus + {0} foto mendapat nama baru. + {0} foto mendapat nama baru. + {0} folder dipindahkan. + {0} folder dipindahkan. + {0} sekuens berubah. + {0} sekuens berubah. + Tata ulang sekarang? + Nama setiap foto seperti yang diberikan impor, mis. {date}_{time}_{n:0000}; file di samping foto mengikuti namanya + File + Ganti nama foto setiap sekuens; jika nonaktif, semua nama file dipertahankan + {0} file diganti nama + {0} file diganti nama + Folder setiap sekuens di arsip, mis. {year}/{date} {camera}; {title} adalah judul baru + Folder + Pindahkan setiap sekuens ke folder yang dihasilkan templatnya; jika nonaktif, setiap folder tetap di tempatnya + Sekuens yang dipilih sudah tidak ada di arsip; tutup lalu pilih lagi. + {0}: {1} + Aktifkan setidaknya satu bagian yang akan diubah. + Tidak ada yang perlu diubah: sekuens ini sudah mengikuti templat. + Tata ulang… + Terapkan templat baru ke sekuens yang sudah ada di arsip; pratinjau menampilkan setiap perubahan terlebih dahulu + Buka tugas + Tampilkan tugas dan log-nya di halaman Tugas + Arsip berubah selama konfirmasi; periksa pratinjau baru lalu terapkan lagi. + Merencanakan… + Pratinjau + Hasil setiap sekuens, sesuai urutan penerapan perubahan; belum ada yang berubah + Penataan ulang diantrekan. + Folder ini tetap di tempatnya + Tata ulang {0} sekuens + Tata ulang {0} sekuens + Tata ulang semua sekuens + Judul baru setiap sekuens, mis. {date} {camera}; {title} adalah judul saat ini + Judul + Beri setiap sekuens judul yang dibuat templatnya; jika nonaktif, semua judul dipertahankan + Penataan ulang menangani paling banyak {0} sekuens sekaligus, atau semua sekuens: bersihkan filter lalu pilih semua. + Sekuens diubah: {0} · file diganti nama: {1} · nama dipertahankan: {2} Administrator Editor Pengunggah diff --git a/i18n/id/Archive.id.resx b/i18n/id/Archive.id.resx index cf3a5d90..c4e61159 100644 --- a/i18n/id/Archive.id.resx +++ b/i18n/id/Archive.id.resx @@ -15,6 +15,7 @@ Tunggu hingga perubahan selesai diterapkan. Kumpulan ini kosong: ubah pilihan atau filternya. Tidak ada yang akan berubah. + Aktifkan setidaknya satu templat. Arsip harus online dan dapat ditulis. Tunggu hingga uji coba selesai. Tunggu hingga arsip selesai dibaca. @@ -81,6 +82,12 @@ {0} ditulis oleh Chronos yang lebih baru (format {1}). Arsip {0} sedang offline. Arsip {0} hanya-baca. + {0:N0} sekuens mempertahankan nama file-nya: sebuah foto sedang digunakan atau nama barunya sudah terpakai. + {0:N0} sekuens mempertahankan nama file-nya: sebuah foto sedang digunakan atau nama barunya sudah terpakai. + {0:N0} sekuens tidak ditata ulang sesuai rencana: sekuens itu berubah setelah rencana dibuat. + {0:N0} sekuens tidak ditata ulang sesuai rencana: sekuens tersebut berubah setelah rencana dibuat. + {0:N0} sekuens mempertahankan judul dan nama file-nya: file sekuensnya berasal dari Chronos yang lebih baru. + {0:N0} sekuens mempertahankan judul dan nama file-nya: file sekuensnya berasal dari Chronos yang lebih baru. {0} berubah setelah rencana dibuat. Kartu atau folder {0} tidak lagi tersedia. Arsip berubah setelah rencana ini dibuat. @@ -146,6 +153,14 @@ Foto belum diindeks: {0}, foto hilang: {1} {0}: dibuat {1}, dipakai ulang {2}, tidak terbaca {3}, menunggu {4} Proksi untuk server: terkirim {0}, tidak terkirim {1} + Dibiarkan seperti semula, folder yang memuatnya tidak dipindahkan: {0} + Dibiarkan seperti semula, berubah setelah rencana dibuat: {0} + Nama file dipertahankan, sebuah foto sedang digunakan atau nama barunya sudah terpakai: {0} + Nama file dipertahankan, foto berubah setelah rencana dibuat: {0} + Judul dan nama file dipertahankan, file sekuensnya berasal dari Chronos yang lebih baru: {0} + Judul dan nama file dipertahankan, berubah setelah rencana dibuat: {0} + Sekuens diubah: {0}, file diganti nama: {1} + Penataan ulang diselesaikan saat arsip dibuka Hanya laporan: tidak ada yang diubah. Folder: {0}, diindeks: {1}, diadopsi: {2}, dihapus: {3} Sekuens tidak ditemukan: {0} @@ -200,14 +215,30 @@ Folder arsip yang dipindahkan Terapkan {0} dari {1} - Ganti nama {0:N0} sekuens - Ganti nama {0:N0} sekuens - Pindahkan {0:N0} sekuens - Pindahkan {0:N0} sekuens Perubahan {0:N0} dari {1:N0} berubah {0:N0} dari {1:N0} berubah - Templat + Foto yang dibiarkan di tempatnya di luar originals mempertahankan namanya. + Foto yang hilang mempertahankan namanya. + Foto yang belum pernah diverifikasi mempertahankan namanya; verifikasi sekuens terlebih dahulu. + File sekuens tidak dapat dibaca; sekuens tetap seperti semula, begitu pula setiap folder yang memuatnya. + Mengikuti foldernya + {0}: {1} menjadi {2} + File + Nama file + Folder + Folder + Tata ulang {0:N0} sekuens + Tata ulang {0:N0} sekuens + Tata ulang {0} + {0:N0} nama dipertahankan + {0:N0} nama dipertahankan + Uji coba… + {0:N0} file diganti nama + {0:N0} file diganti nama + Judul + Judul + Tata ulang akan terbuka setelah dialog yang sedang terbuka ditutup Tambah tag Terapkan Tag {0:N0} sekuens @@ -222,9 +253,8 @@ Ekspor CSV Filter kumpulan Kumpulan terfilter - Pindahkan… Proksi - Ganti nama… + Tata ulang… Ubah tag… Gambar mini Verifikasi diff --git a/i18n/id/Errors.id.resx b/i18n/id/Errors.id.resx index d6b2dfc6..b1bcc797 100644 --- a/i18n/id/Errors.id.resx +++ b/i18n/id/Errors.id.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Sekuens yang tidak dianalisis: {0} dari {1}; lihat log tugas. + Folder sekuens ini tidak berada di lokasi yang tercatat di indeks; coba lagi setelah pemindaian berikutnya. Arsip tidak dapat dibuka. Indeks saat ini tidak dapat dicadangkan atau diganti; pemulihan akan dijalankan lagi saat Chronos dimulai berikutnya. Cadangan ini tidak dapat dipulihkan; pilih cadangan lain. @@ -37,9 +38,11 @@ {0} file asli hilang atau berubah sejak diarsipkan; verifikasi arsip. Templat kosong. Token kosong di posisi {1}: tulis nama di antara kurung kurawal. + Foto akan kehilangan ekstensinya: tulis titik sebelum {ext}, atau hapus {ext}. Nama file tidak boleh berisi garis miring; letakkan folder di templat folder. Format setelah titik dua tidak sesuai dengan tokennya. Nama akan berulang: tambahkan nomor bingkai, waktu, atau nama asli. + Pemindaian melewati folder yang diawali titik atau bernama originals, proxies, atau exports. Kurung kurawal yang dibuka di posisi {1} tidak pernah ditutup. Token “{0}” tidak dikenal di posisi {1}. Kurung kurawal tutup di posisi {1} tidak memiliki pasangan pembuka; gandakan untuk menulis kurung kurawal literal. diff --git a/i18n/id/Jobs.id.resx b/i18n/id/Jobs.id.resx index 6be754c3..0c14fd96 100644 --- a/i18n/id/Jobs.id.resx +++ b/i18n/id/Jobs.id.resx @@ -76,7 +76,7 @@ Impor Analisis cepat Pemeliharaan - Pindahkan arsip + Penataan ulang File yatim Proksi Bangun ulang indeks diff --git a/i18n/id/Library.id.resx b/i18n/id/Library.id.resx index 82e6b4c6..e96ab2c9 100644 --- a/i18n/id/Library.id.resx +++ b/i18n/id/Library.id.resx @@ -10,17 +10,16 @@ Unduh Ekspor daftar Folder - Pindahkan… Buka Proksi Peringkat Render + Tata ulang… Sinkronkan Tag… Unggah Verifikasi Adopsi folder - Pemindahan hanya berlaku untuk sekuens dari satu arsip dalam satu waktu. Sama di PC ini dan di server: tidak ada yang perlu disinkronkan. Tidak ada tampilan tersimpan yang sedang digunakan; pilih salah satu terlebih dahulu. Akun server Anda tidak dapat mengunduh file asli. @@ -32,6 +31,7 @@ Masuk ke Chronos Server terlebih dahulu, di layar Server. Tidak ada yang perlu diambil dari server untuk sekuens yang dipilih. Server sudah memiliki semua isi sekuens yang dipilih. + Penataan ulang hanya dapat dilakukan pada sekuens dari satu arsip dalam satu waktu. Hanya untuk sekuens di PC ini; pilihan ini berada di server. Transfer sekuens ini sudah berlangsung. Bersihkan filter diff --git a/i18n/id/Server.id.resx b/i18n/id/Server.id.resx index d4700c8d..47a97478 100644 --- a/i18n/id/Server.id.resx +++ b/i18n/id/Server.id.resx @@ -40,6 +40,7 @@ Koneksi gagal; detailnya ada di log. Sebuah file sekuens sedang terbuka di program lain; tutup file tersebut lalu coba lagi. Foldernya sudah tidak ada di disk; tidak ada yang tersisa untuk dipindahkan ke sampah. + Folder sekuens ini tidak berada di lokasi yang tercatat di indeks server; coba lagi setelah pemindaian server berikutnya. Akun Anda tidak dapat melakukan ini. Foto sekuens berubah di server; muat ulang lalu terapkan lagi perubahan Anda. File diterima dalam keadaan rusak; unggah lagi. @@ -68,11 +69,14 @@ Server ini tidak dapat menjalankan jenis tugas tersebut. Administrator terakhir tidak dapat dihapus atau dinonaktifkan. Metode ini tidak diizinkan di sini. + Folder baru akan berada di dalam folder sekuens lain. Alamat itu bukan Chronos Server. Tidak ditemukan. Ubah kata sandi Anda terlebih dahulu. Foto dihapus dari sekuens saat sedang diunggah, jadi tidak ditambahkan. {0} tidak dapat dibaca, dan tanpa hash-nya salinan lain tidak akan tahu bahwa file itu telah dihapus; tutup program yang menggunakannya atau periksa izinnya, lalu coba lagi. + Arsip berubah setelah uji coba; tinjau kembali rencananya. + Server berhenti menyusun rencana ini: prosesnya terlalu lama, atau terlalu banyak rencana diminta sekaligus; coba lagi sebentar lagi. Arsip ini tidak membuat proksi. Proksi dibuat dari foto lain. Server tidak memerlukan proksi untuk foto ini. diff --git a/i18n/id/Settings.id.resx b/i18n/id/Settings.id.resx index 31fde67d..a29d9053 100644 --- a/i18n/id/Settings.id.resx +++ b/i18n/id/Settings.id.resx @@ -65,6 +65,7 @@ bintang per megapiksel Lebar analisis px sisi panjang + Folder dan file yang sudah ada di arsip tetap mempertahankan namanya. Nama file Folder {0} kosong @@ -74,10 +75,12 @@ Pilih folder arsip Pratinjau Ukuran proksi + Tata ulang… Reset arsip Templat penamaan, ukuran proksi, dan ukuran gambar mininya kembali ke default untuk setiap PC dan server yang menggunakannya. Folder dan file yang sudah ada di arsip tetap mempertahankan namanya. Reset pengaturan {0}? Folder arsip + Templat arsip disimpan Ukuran gambar mini Kembali ke Otomatis Pilih folder diff --git a/i18n/id/Tooltips.id.resx b/i18n/id/Tooltips.id.resx index 779a060c..92d779f4 100644 --- a/i18n/id/Tooltips.id.resx +++ b/i18n/id/Tooltips.id.resx @@ -36,6 +36,7 @@ Buka sekuens salinan pertama di layar Edit Temukan foto identik di seluruh sekuens berdasarkan hash · hanya membaca indeks Tampilkan sekuens tahun ini + Nama file setiap foto, seperti yang diberikan impor · diperiksa saat Anda mengetik Tampilkan hanya sekuens dari kamera tertentu Pilih nilai ini; pilih lagi untuk membatalkannya Tampilkan hanya sekuens dengan status tertentu @@ -71,7 +72,10 @@ Bangun ulang indeks dari sidecar; jika tidak ada, beralih ke pemindaian metadata penuh; file asli tidak pernah dihapus Antrekan pembangunan ulang · arsip tetap dapat digunakan selama proses Pilih folder baru dari arsip yang Anda pindahkan; sekuensnya ikut berpindah - Terapkan tepat perubahan ini pada folder, sidecar, dan indeks · dilanjutkan jika aplikasi berhenti mendadak + Antrekan tugas yang membuat persis perubahan ini · jeda dan lanjutkan tugas itu di Tugas + Ganti nama foto dengan templat ini · jika nonaktif, foto mempertahankan namanya + Pindahkan folder sekuens ke tata letak ini · jika nonaktif, folder tetap di tempatnya + Ubah judul dengan templat ini · jika nonaktif, judul tetap seperti semula Pilih cadangan indeks di Pengaturan › Lanjutan; cadangan itu menggantikan indeks saat Chronos dimulai berikutnya Ubah tag sekuens ini di sidecar dan indeks Jalankan tindakan yang sama lagi @@ -80,9 +84,8 @@ Jalankan analisis mendalam pada setiap sekuens dalam kumpulan Pindahkan kumpulan ke sampah arsip · uji coba ditampilkan, lalu Anda diminta mengetik untuk mengonfirmasi Ekspor kumpulan sebagai CSV: satu baris per sekuens - Pindahkan kumpulan ke tata letak folder baru · uji coba terlebih dahulu Buat atau perbarui proksi - Ganti judul dalam kumpulan dengan templat · uji coba terlebih dahulu + Terapkan templat folder, file, dan judul ke kumpulan · uji coba dulu, lalu tugas Tambah atau hapus tag pada seluruh kumpulan Buat atau perbarui gambar mini Hitung ulang hash file asli dalam kumpulan @@ -471,12 +474,12 @@ Ambil dari server apa yang belum dimiliki {0:N0} sekuens di sini (file asli atau hasil render) · berjalan sebagai tugas transfer Simpan {0:N0} baris sebagai CSV di folder pilihan Anda Simpan {0:N0} baris sebagai CSV di folder pilihan Anda - Pindahkan {0:N0} sekuens ke tata letak folder baru di arsipnya · uji coba ditampilkan terlebih dahulu - Pindahkan {0:N0} sekuens ke tata letak folder baru di arsipnya · uji coba ditampilkan terlebih dahulu Buat proksi JPEG untuk {0:N0} sekuens · berjalan sebagai satu tugas Buat proksi JPEG untuk {0:N0} sekuens · berjalan sebagai satu tugas Tetapkan peringkat {0:N0} sekuens, di sidecar-nya dan di indeks Tetapkan peringkat {0:N0} sekuens, di sidecar-nya dan di indeks + Terapkan templat folder, file, dan judul ke {0:N0} sekuens dari arsipnya · uji coba dulu, lalu tugas + Terapkan templat folder, file, dan judul ke {0:N0} sekuens dari arsipnya · uji coba dulu, lalu tugas Tambah atau hapus tag pada {0:N0} sekuens Tambah atau hapus tag pada {0:N0} sekuens Kirim apa yang belum dimiliki server dari {0:N0} sekuens (file asli dan pengaturan, atau hasil render) · berjalan sebagai tugas transfer @@ -692,6 +695,7 @@ Seimbang cocok untuk sebagian besar pekerjaan; Terbaik mengukur pada resolusi ganda dan membaca lebih jauh ke depan; Cepat mengukur pada setengah resolusi dengan gerakan draf Daftar ulang encoder setelah menginstal driver atau codec Cari lagi ekstensi codec setelah menginstalnya; tugas berikutnya akan menggunakannya + Terapkan templat arsip ke sekuens yang sudah ada di dalamnya · uji coba dulu Kembalikan semua pengaturan PC ini ke default; meminta konfirmasi terlebih dahulu Tulis templat dan ukuran default ke archive.json arsip ini sekarang Reset semua pengaturan sekarang diff --git a/i18n/it/Admin.it.resx b/i18n/it/Admin.it.resx index 9e799f85..e7c21981 100644 --- a/i18n/it/Admin.it.resx +++ b/i18n/it/Admin.it.resx @@ -9,6 +9,7 @@ Chronos Server In esecuzione da Versione + {0} ha riorganizzato l'archivio · {1} {0} ha modificato l'organizzazione dell'archivio {0} ha eliminato {1}long {0} ha avviato {1} @@ -138,7 +139,7 @@ Importazione Analisi rapida Manutenzione - Spostamento + Riorganizzazione Orfani Proxy Ricostruzione @@ -343,6 +344,7 @@ Accedi per amministrare questo server Utente Il tuo nome utente su questo server + Archivio riorganizzato Organizzazione archivio Foto eliminate Job avviato @@ -426,6 +428,58 @@ Cambia password Sostituisci la password e continua nel pannello Scegli una nuova password + Riorganizza… + Applica modelli di cartelle, file e titoli alle sequenze selezionate; un'anteprima mostra prima ogni modifica + Dopo: + Applica… + Riorganizza come mostra l'anteprima; prima chiede conferma + Prima: + Scrivi un modello, o disattiva questa parte. + Chiudi senza cambiare niente + Trasportata + Si sposta solo perché si sposta una cartella che la contiene + File rinominati + Cartella + Sequenza + Riorganizza + Metti in coda il job che sposta e rinomina gli originali; niente viene sovrascritto o eliminato + {0} foto riceve un nuovo nome. + {0} foto ricevono un nuovo nome. + Si sposta {0} cartella. + Si spostano {0} cartelle. + Cambia {0} sequenza. + Cambiano {0} sequenze. + Riorganizzare ora? + Nome di ogni foto come lo dà un'importazione, es. {date}_{time}_{n:0000}; i file accanto a una foto la seguono + File + Rinomina le foto di ogni sequenza; spento mantiene ogni nome di file + {0} file rinominato + {0} file rinominati + Cartella di ogni sequenza nell'archivio, es. {year}/{date} {camera}; {title} è il nuovo titolo + Cartelle + Sposta ogni sequenza nella cartella data dal modello; spento lascia ogni cartella dov'è + Una sequenza selezionata non è più nell'archivio; chiudi e seleziona di nuovo. + {0}: {1} + Attiva almeno una parte da cambiare. + Niente da cambiare: queste sequenze seguono già i modelli. + Riorganizza… + Applica i nuovi modelli alle sequenze già nell'archivio; un'anteprima mostra prima ogni modifica + Apri job + Mostra il job e il suo log nella pagina Job + L'archivio è cambiato durante la conferma; controlla la nuova anteprima e applica di nuovo. + Pianificazione… + Anteprima + Cosa diventa ogni sequenza, nell'ordine in cui si applicano le modifiche; ancora non è cambiato niente + Riorganizzazione in coda. + Questa cartella resta dov'è + Riorganizza {0} sequenza + Riorganizza {0} sequenze + Riorganizza tutte le sequenze + Nuovo titolo di ogni sequenza, es. {date} {camera}; {title} è il titolo attuale + Titoli + Dai a ogni sequenza il titolo fatto dal modello; spento mantiene ogni titolo + Riorganizza al massimo {0} sequenze alla volta, o tutte: togli i filtri e seleziona tutto. + Sequenze cambiate: {0} · file rinominati: {1} · nomi mantenuti: {2} Amministratore Editor Caricamento diff --git a/i18n/it/Archive.it.resx b/i18n/it/Archive.it.resx index e8c71356..53783f24 100644 --- a/i18n/it/Archive.it.resx +++ b/i18n/it/Archive.it.resx @@ -15,6 +15,7 @@ Attendi che le modifiche siano applicate. La selezione è vuota: cambia la selezione o il filtro. Non cambierebbe nulla. + Attiva almeno un modello. L'archivio deve essere raggiungibile e scrivibile. Attendi la simulazione. Attendi la lettura dell'archivio. @@ -81,6 +82,12 @@ {0} è stato scritto da un Chronos più recente (formato {1}). L'archivio {0} non è raggiungibile. L'archivio {0} è di sola lettura. + {0:N0} sequenza ha mantenuto i nomi dei file: una foto era in uso o il suo nuovo nome era occupato. + {0:N0} sequenze hanno mantenuto i nomi dei file: una foto era in uso o il suo nuovo nome era occupato. + {0:N0} sequenza non è stata riorganizzata come previsto: è cambiata dopo il piano. + {0:N0} sequenze non sono state riorganizzate come previsto: sono cambiate dopo il piano. + {0:N0} sequenza ha mantenuto titolo e nomi dei file: il file della sequenza è di un Chronos più recente. + {0:N0} sequenze hanno mantenuto titoli e nomi dei file: i file delle sequenze sono di un Chronos più recente. {0} è cambiato dopo la creazione del piano. La scheda o cartella {0} non è più disponibile. L'archivio è cambiato dopo la creazione del piano. @@ -146,6 +153,14 @@ Foto non indicizzate: {0}, foto mancanti: {1} {0}: create {1}, riusate {2}, illeggibili {3}, in attesa {4} Proxy per il server: {0} inviati, {1} non inviati + Lasciata com'era, la cartella che la contiene è rimasta: {0} + Lasciata com'era, cambiata dopo il piano: {0} + Nomi dei file mantenuti, una foto era in uso o il suo nuovo nome era occupato: {0} + Nomi dei file mantenuti, foto cambiate dopo il piano: {0} + Titolo e nomi dei file mantenuti, il file della sequenza è di un Chronos più recente: {0} + Titolo e nomi dei file mantenuti, cambiata dopo il piano: {0} + Sequenze cambiate: {0}, file rinominati: {1} + La riorganizzazione è stata completata all'apertura dell'archivio Solo resoconto: nulla è stato modificato. Cartelle: {0}, indicizzate: {1}, adottate: {2}, rimosse: {3} Sequenza non trovata: {0} @@ -200,14 +215,30 @@ Nuova cartella dell'archivio Applica {0} di {1} - Rinomina {0:N0} sequenza - Rinomina {0:N0} sequenze - Sposta {0:N0} sequenza - Sposta {0:N0} sequenze Modifiche {0:N0} di {1:N0} cambia {0:N0} di {1:N0} cambiano - Modello + Le foto tenute sul posto fuori da originals mantengono il loro nome. + Le foto mancanti mantengono il loro nome. + Le foto mai verificate mantengono il loro nome; verifica prima la sequenza. + Il file della sequenza non è leggibile; la sequenza resta com'è, e così ogni cartella che la contiene. + Segue la sua cartella + {0}: da {1} a {2} + File + Nomi dei file + Cartella + Cartelle + Riorganizza {0:N0} sequenza + Riorganizza {0:N0} sequenze + Riorganizza {0} + {0:N0} nome mantenuto + {0:N0} nomi mantenuti + Simulazione… + {0:N0} file rinominato + {0:N0} file rinominati + Titolo + Titoli + Riorganizza si apre quando si chiude la finestra aperta Aggiungi tag Applica Tag di {0:N0} sequenza @@ -222,9 +253,8 @@ Esporta CSV Filtro selezione Selezione - Sposta… Proxy - Rinomina… + Riorganizza… Tag… Miniature Verifica diff --git a/i18n/it/Errors.it.resx b/i18n/it/Errors.it.resx index 4d36a221..0574bc79 100644 --- a/i18n/it/Errors.it.resx +++ b/i18n/it/Errors.it.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Sequenze non analizzate: {0} su {1}; vedi il registro del job. + La cartella di questa sequenza non è dove la indica l'indice; riprova dopo la prossima scansione. Impossibile aprire l'archivio. Non è stato possibile copiare o sostituire l'indice attuale; il ripristino riparte al prossimo avvio. Questa copia non si può ripristinare; scegline un'altra. @@ -38,8 +39,10 @@ Il modello è vuoto. Segnaposto vuoto alla posizione {1}: scrivi un nome tra le parentesi graffe. I nomi dei file non possono contenere la barra; metti le cartelle nel modello delle cartelle. + Le foto perderebbero l'estensione: scrivi un punto prima di {ext}, oppure togli {ext}. Il formato dopo i due punti non è adatto al suo segnaposto. I nomi si ripeterebbero: aggiungi il numero del fotogramma, l'ora o il nome originale. + Le scansioni saltano le cartelle che iniziano con un punto o si chiamano originals, proxies o exports. La parentesi graffa aperta alla posizione {1} non viene mai chiusa. Segnaposto sconosciuto «{0}» alla posizione {1}. La parentesi graffa chiusa alla posizione {1} non ha un'apertura; raddoppiala per una graffa letterale. diff --git a/i18n/it/Jobs.it.resx b/i18n/it/Jobs.it.resx index 7021dc93..643ae63f 100644 --- a/i18n/it/Jobs.it.resx +++ b/i18n/it/Jobs.it.resx @@ -76,7 +76,7 @@ Importazione Analisi rapida Manutenzione - Spostamento archivio + Riorganizzazione File orfani Proxy Ricostruzione indice diff --git a/i18n/it/Library.it.resx b/i18n/it/Library.it.resx index 13807a39..503df244 100644 --- a/i18n/it/Library.it.resx +++ b/i18n/it/Library.it.resx @@ -10,17 +10,16 @@ Scarica Esporta elenco Cartella - Sposta… Apri Proxy Voto Renderizza + Riorganizza… Sincronizza Tag… Carica Verifica Adotta una cartella - Lo spostamento agisce sulle sequenze di un solo archivio alla volta. Uguale su questo PC e sul server: niente da sincronizzare. Nessuna vista salvata in uso; prima scegline una. Il tuo account sul server non può scaricare gli originali. @@ -32,6 +31,7 @@ Prima accedi a un Chronos Server, nella schermata Server. Le sequenze selezionate non hanno nulla da ricevere dal server. Il server ha già tutto ciò che contengono le sequenze selezionate. + La riorganizzazione agisce sulle sequenze di un solo archivio alla volta. Solo per sequenze su questo PC; la selezione si trova sul server. Un trasferimento di questa sequenza è già in corso. Azzera i filtri diff --git a/i18n/it/Server.it.resx b/i18n/it/Server.it.resx index a3102434..e76fc6b9 100644 --- a/i18n/it/Server.it.resx +++ b/i18n/it/Server.it.resx @@ -40,6 +40,7 @@ La connessione non è riuscita; i dettagli sono nel log. Un file della sequenza è aperto in un altro programma; chiudilo e riprova. La sua cartella non è più sul disco; non resta nulla da spostare nel cestino. + La cartella di questa sequenza non è dove la indica l'indice del server; riprova dopo la sua prossima scansione. Il tuo account non può farlo. Le foto della sequenza sono cambiate sul server; ricaricala e riapplica la modifica. Il file è arrivato danneggiato; caricalo di nuovo. @@ -68,11 +69,14 @@ Questo server non può eseguire quel tipo di job. L'ultimo amministratore non può essere rimosso o disattivato. Metodo non consentito qui. + Una nuova cartella finirebbe dentro la cartella di un'altra sequenza. Non trovato. Questo indirizzo non è un Chronos Server. Cambia prima la password. La foto è stata eliminata dalla sequenza mentre veniva caricata, quindi non è stata aggiunta.long Impossibile leggere {0}: senza il suo hash le altre copie non saprebbero che è stato eliminato. Chiudi il programma che lo usa o controlla i permessi, poi riprova. + L'archivio è cambiato dopo la simulazione; rivedi di nuovo il piano. + Il server ha smesso di preparare questo piano: richiedeva troppo tempo, o ne sono stati chiesti troppi insieme; riprova tra poco. Questa pagina non è arrivata da un proxy attendibile in HTTPS. Aprila tramite il proxy o aggiungi l'indirizzo del proxy a CHRONOS_TRUSTED_PROXIES. Questo archivio non crea proxy. Il proxy è stato creato da un'altra foto. diff --git a/i18n/it/Settings.it.resx b/i18n/it/Settings.it.resx index 6d65f2a1..58db5333 100644 --- a/i18n/it/Settings.it.resx +++ b/i18n/it/Settings.it.resx @@ -65,6 +65,7 @@ stelle per megapixel Larghezza di analisi px sul lato lungo + Le cartelle e i file già nell'archivio mantengono i loro nomi. Nomi dei file Cartelle {0} liberi @@ -74,10 +75,12 @@ Scegli la cartella dell'archivio Anteprima Dimensione proxy + Riorganizza… Reimposta archivio I modelli di nome, la dimensione dei proxy e quella delle miniature tornano ai valori predefiniti per ogni PC e server che lo usa. Le cartelle e i file già nell'archivio mantengono i loro nomi. Reimpostare le impostazioni di {0}? Cartella archivio + Modelli dell'archivio salvati Dimensione miniature Torna ad Auto Scegli cartella diff --git a/i18n/it/Tooltips.it.resx b/i18n/it/Tooltips.it.resx index 5719b7a7..c5ee663e 100644 --- a/i18n/it/Tooltips.it.resx +++ b/i18n/it/Tooltips.it.resx @@ -36,6 +36,7 @@ Apri in Modifica la sequenza della prima copia Trova foto identiche tra le sequenze tramite hash · legge solo l'indice Mostra le sequenze di quest'anno + Nome del file di ogni foto, come lo danno le importazioni · controllato mentre scrivi Tieni solo le sequenze di una fotocamera Scegli questo valore; sceglilo di nuovo per toglierlo Tieni solo le sequenze in uno stato @@ -71,7 +72,10 @@ Ricostruisce l'indice dai sidecar; se mancano legge i metadati; non elimina mai gli originali Metti in coda la ricostruzione · l'archivio resta utilizzabile Scegli la nuova cartella di un archivio spostato; le sequenze lo seguono - Applica esattamente queste modifiche a cartelle, sidecar e indice · riprende dopo un arresto + Metti in coda un'attività che fa esattamente queste modifiche · mettila in pausa e riprendila in Attività + Rinomina le foto con questo modello · se spento, mantengono il loro nome + Sposta le cartelle delle sequenze in questa struttura · se spento, restano dove sono + Cambia i titoli con questo modello · se spento, restano come sono Scegli una copia dell'indice in Impostazioni › Avanzate; sostituisce l'indice al prossimo avvio Cambia i tag di queste sequenze in sidecar e indice Esegui di nuovo la stessa azione @@ -80,9 +84,8 @@ Esegui l'analisi profonda su ogni sequenza della selezione Sposta la selezione nel cestino dell'archivio · mostra prima la simulazione, poi chiede di digitare per confermare Esporta la selezione in CSV: una riga per sequenza - Sposta la selezione in una nuova struttura di cartelle · prima la simulazione Crea o aggiorna i proxy - Rinomina i titoli della selezione con un modello · prima la simulazione + Applica modelli di cartella, file e titolo alla selezione · prima la simulazione, poi un'attività Aggiungi o rimuovi tag su tutta la selezione Crea o aggiorna le miniature Ricalcola l'hash degli originali della selezione @@ -471,12 +474,12 @@ Ricevi dal server ciò che manca qui a {0:N0} sequenze (originali o render) · come attività di trasferimento Salva {0:N0} riga come CSV in una cartella a tua scelta Salva {0:N0} righe come CSV in una cartella a tua scelta - Sposta {0:N0} sequenza in una nuova struttura di cartelle del suo archivio · prima la simulazione - Sposta {0:N0} sequenze in una nuova struttura di cartelle del loro archivio · prima la simulazione Crea i proxy JPEG di {0:N0} sequenza · un'unica attività Crea i proxy JPEG di {0:N0} sequenze · un'unica attività Imposta il voto di {0:N0} sequenza, nel sidecar e nell'indice Imposta il voto di {0:N0} sequenze, nei sidecar e nell'indice + Applica modelli di cartella, file e titolo a {0:N0} sequenza del suo archivio · prima la simulazione, poi un'attività + Applica modelli di cartella, file e titolo a {0:N0} sequenze del loro archivio · prima la simulazione, poi un'attività Aggiungi o rimuovi tag su {0:N0} sequenza Aggiungi o rimuovi tag su {0:N0} sequenze Invia al server ciò che gli manca di {0:N0} sequenza (originali e impostazioni, o render) · come attività di trasferimento @@ -692,6 +695,7 @@ Bilanciato va bene quasi sempre; Massima qualità misura a risoluzione doppia e legge più avanti; Veloce misura a metà risoluzione con movimento in bozza Elenca di nuovo gli encoder dopo l'installazione di un driver o di un codec Cerca di nuovo le estensioni codec dopo averne installata una; le prossime attività le usano + Applica i modelli dell'archivio alle sequenze che contiene già · prima la simulazione Riporta ogni impostazione di questo PC al valore predefinito; chiede prima Scrivi ora i modelli e le dimensioni predefiniti nel file archive.json dell'archivio Reimposta ora ogni impostazione diff --git a/i18n/ja/Admin.ja.resx b/i18n/ja/Admin.ja.resx index 461aac69..3bd85be2 100644 --- a/i18n/ja/Admin.ja.resx +++ b/i18n/ja/Admin.ja.resx @@ -9,6 +9,7 @@ Chronos Server 稼働時間 バージョン + {0} がアーカイブを再編成しました · {1} {0} がアーカイブの構成を変更しました {0} が {1} を削除しました {0} が {1} を開始しました @@ -138,7 +139,7 @@ インポート 簡易分析 メンテナンス - 移動 + 再編成 孤立ファイル プロキシ 再構築 @@ -343,6 +344,7 @@ サインインしてこのサーバーを管理します。 ユーザー このサーバーでのユーザー名です。 + アーカイブ再編成 アーカイブの構成 写真削除 ジョブ開始 @@ -426,6 +428,58 @@ パスワードを変更 パスワードを置き換えて、パネルに進みます。 新しいパスワードを設定 + 再編成… + 選択したシーケンスに、フォルダー、ファイル名、タイトルのテンプレートを適用します。先にプレビューですべての変更を確認できます。 + 変更後: + 適用… + プレビューに表示されたとおりに再編成します。実行前に確認を求めます。 + 変更前: + テンプレートを入力するか、この項目をオフにしてください。 + 何も変更せずに閉じます。 + フォルダーごと移動 + 含まれているフォルダーが移動するため、一緒に移動するだけです。 + 名前を変更するファイル + フォルダー + シーケンス + 再編成 + オリジナルを移動して名前を変更するジョブをキューに追加します。上書きや削除は一切行われません。 + 写真 {0} 枚の名前が変わります。 + 写真 {0} 枚の名前が変わります。 + フォルダー {0} 個が移動します。 + フォルダー {0} 個が移動します。 + シーケンス {0} 個が変更されます。 + シーケンス {0} 個が変更されます。 + 今すぐ再編成しますか? + インポート時と同じ規則で付ける各写真の名前です。例: {date}_{time}_{n:0000}。写真と並んでいるファイルも写真に合わせて名前が変わります。 + ファイル + 各シーケンスの写真の名前を変更します。オフにすると、すべてのファイル名がそのまま残ります。 + ファイル {0} 個の名前を変更 + ファイル {0} 個の名前を変更 + アーカイブ内の各シーケンスのフォルダーです。例: {year}/{date} {camera}。{title} は新しいタイトルです。 + フォルダー + 各シーケンスを、テンプレートで決まるフォルダーに移動します。オフにすると、すべてのフォルダーが今の場所に残ります。 + 選択したシーケンスの 1 つがアーカイブにありません。閉じてから、もう一度選択してください。 + {0}: {1} + 変更する項目を少なくとも 1 つオンにしてください。 + 変更するものはありません。これらのシーケンスは既にテンプレートに沿っています。 + 再編成… + 新しいテンプレートを、既にアーカイブにあるシーケンスに適用します。先にプレビューですべての変更を確認できます。 + ジョブを開く + 「ジョブ」ページに、ジョブとそのログを表示します。 + 確認中にアーカイブが変更されました。新しいプレビューを確認してから、もう一度適用してください。 + プランを作成中… + プレビュー + 変更が適用される順に、各シーケンスがどうなるかを示します。まだ何も変更されていません。 + 再編成をキューに追加しました。 + このフォルダーは今の場所に残ります。 + シーケンス {0} 個を再編成 + シーケンス {0} 個を再編成 + すべてのシーケンスを再編成 + 各シーケンスの新しいタイトルです。例: {date} {camera}。{title} は現在のタイトルです。 + タイトル + 各シーケンスに、テンプレートで作るタイトルを付けます。オフにすると、すべてのタイトルがそのまま残ります。 + 再編成できるのは、一度に {0} 個までのシーケンスか、すべてのシーケンスです。フィルターをクリアして、すべて選択してください。 + 変更されたシーケンス: {0} · 名前を変更したファイル: {1} · 保持した名前: {2} 管理者 編集者 アップローダー diff --git a/i18n/ja/Archive.ja.resx b/i18n/ja/Archive.ja.resx index e7e606da..d77b6ecb 100644 --- a/i18n/ja/Archive.ja.resx +++ b/i18n/ja/Archive.ja.resx @@ -15,6 +15,7 @@ 変更が適用されるまでお待ちください。 セットが空です。選択またはフィルターを変更してください。 変更される項目はありません。 + 少なくとも 1 つのテンプレートをオンにしてください。 アーカイブがオンラインで、書き込み可能である必要があります。 ドライランが終わるまでお待ちください。 アーカイブの読み込みが終わるまでお待ちください。 @@ -81,6 +82,12 @@ {0} は新しいバージョンの Chronos で書き込まれています (形式 {1})。 アーカイブ {0} はオフラインです。 アーカイブ {0} は読み取り専用です。 + シーケンス {0:N0} 個のファイル名は変更されませんでした。写真が使用中だったか、新しい名前が既に使われていました。 + シーケンス {0:N0} 個のファイル名は変更されませんでした。写真が使用中だったか、新しい名前が既に使われていました。 + シーケンス {0:N0} 個はプランどおりに再編成されませんでした。プランの作成後に変更されています。 + シーケンス {0:N0} 個はプランどおりに再編成されませんでした。プランの作成後に変更されています。 + シーケンス {0:N0} 個のタイトルとファイル名は変更されませんでした。シーケンスファイルが新しいバージョンの Chronos のものです。 + シーケンス {0:N0} 個のタイトルとファイル名は変更されませんでした。シーケンスファイルが新しいバージョンの Chronos のものです。 {0} はプランの作成後に変更されました。 カードまたはフォルダー {0} は使用できなくなりました。 このプランの作成後にアーカイブが変更されました。 @@ -146,6 +153,14 @@ インデックス化されていない写真: {0}、欠落した写真: {1} {0}: 作成 {1}、再利用 {2}、読み取り不能 {3}、待機中 {4} サーバー向けのプロキシ: 送信 {0}、未送信 {1} + そのまま残しました (含まれているフォルダーが移動しなかったため): {0} + そのまま残しました (プランの作成後に変更されたため): {0} + ファイル名を保持しました (写真が使用中だったか、新しい名前が既に使われていたため): {0} + ファイル名を保持しました (プランの作成後に写真が変更されたため): {0} + タイトルとファイル名を保持しました (シーケンスファイルが新しいバージョンの Chronos のものであるため): {0} + タイトルとファイル名を保持しました (プランの作成後に変更されたため): {0} + 変更したシーケンス: {0}、名前を変更したファイル: {1} + 再編成はアーカイブを開いたときに完了しました レポートのみ: 何も変更されていません。 フォルダー: {0}、インデックス化: {1}、登録: {2}、削除: {3} シーケンスが見つかりません: {0} @@ -200,14 +215,30 @@ 移動したアーカイブのフォルダー 適用 {0} / {1} - シーケンス {0:N0} 個の名前を変更 - シーケンス {0:N0} 個の名前を変更 - シーケンス {0:N0} 個を移動 - シーケンス {0:N0} 個を移動 変更内容 {1:N0} 個中 {0:N0} 個を変更 {1:N0} 個中 {0:N0} 個を変更 - テンプレート + originals の外にあり、元の場所に置かれたままの写真は、名前が変わりません。 + 見つからない写真は、名前が変わりません。 + 一度も検証されていない写真は、名前が変わりません。先にシーケンスを検証してください。 + シーケンスファイルを読み取れません。シーケンスはそのまま残り、それを含むフォルダーも変更されません。 + フォルダーと一緒に移動 + {0}: {1} から {2} へ + ファイル + ファイル名 + フォルダー + フォルダー + シーケンス {0:N0} 個を再編成 + シーケンス {0:N0} 個を再編成 + {0} を再編成 + 名前 {0:N0} 個を保持 + 名前 {0:N0} 個を保持 + ドライラン中… + ファイル {0:N0} 個の名前を変更 + ファイル {0:N0} 個の名前を変更 + タイトル + タイトル + 開いているダイアログを閉じると、再編成が開きます 追加するタグ 適用 シーケンス {0:N0} 個のタグ @@ -222,9 +253,8 @@ CSV をエクスポート セットのフィルター 絞り込んだセット - 移動… プロキシを作成 - 名前の変更… + 再編成… タグの変更… サムネイルを作成 検証 diff --git a/i18n/ja/Errors.ja.resx b/i18n/ja/Errors.ja.resx index 0284b9e8..ba736fbd 100644 --- a/i18n/ja/Errors.ja.resx +++ b/i18n/ja/Errors.ja.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 分析されなかったシーケンス: {1} 個中 {0} 個。ジョブのログを確認してください。 + このシーケンスのフォルダーが、インデックスに記録された場所にありません。次のスキャンの後で、もう一度お試しください。 アーカイブを開けませんでした。 現在のインデックスをバックアップまたは置き換えできませんでした。次回の起動時に復元をもう一度実行します。 このバックアップは復元できません。別のバックアップを選択してください。 @@ -37,9 +38,11 @@ {0} 個のオリジナルが、アーカイブされた後に欠落したか変更されています。アーカイブを検証してください。 テンプレートが空です。 位置 {1} のトークンが空です。中かっこの間に名前を入力してください。 + 写真の拡張子がなくなります。{ext} の前にドットを入力するか、{ext} を削除してください。 ファイル名にスラッシュは使えません。フォルダーはフォルダーテンプレートで指定してください。 コロンの後の形式がトークンに合っていません。 名前が重複します。フレーム番号、時刻、または元のファイル名を追加してください。 + ドットで始まるフォルダーや、originals、proxies、exports という名前のフォルダーは、スキャンでスキップされます。 位置 {1} で開いた中かっこが閉じられていません。 位置 {1} に不明なトークン「{0}」があります。 位置 {1} の閉じ中かっこに対応する開き中かっこがありません。中かっこそのものを使うには 2 つ重ねてください。 diff --git a/i18n/ja/Jobs.ja.resx b/i18n/ja/Jobs.ja.resx index 903c7e51..52e8d5d7 100644 --- a/i18n/ja/Jobs.ja.resx +++ b/i18n/ja/Jobs.ja.resx @@ -76,7 +76,7 @@ インポート 簡易分析 メンテナンス - アーカイブの移動 + 再編成 孤立ファイル プロキシ インデックスの再構築 diff --git a/i18n/ja/Library.ja.resx b/i18n/ja/Library.ja.resx index 78fc8f92..25e6c4a4 100644 --- a/i18n/ja/Library.ja.resx +++ b/i18n/ja/Library.ja.resx @@ -10,17 +10,16 @@ ダウンロード リストをエクスポート フォルダー - 移動… 開く プロキシを作成 評価 レンダリング + 再編成… 同期 タグ… アップロード 検証 フォルダーを登録 - 移動は一度に 1 つのアーカイブのシーケンスに対してのみ行えます。 この PC とサーバーで同じ内容のため、同期するものはありません。 使用中の保存済みビューはありません。先にビューを選択してください。 サーバーのアカウントでは、オリジナルをダウンロードできません。 @@ -32,6 +31,7 @@ 先に「サーバー」画面で Chronos Server にサインインしてください。 選択したシーケンスには、サーバーから取得するものはありません。 選択したシーケンスの内容は既にサーバーにあります。 + 再編成は、一度に 1 つのアーカイブのシーケンスにしか使用できません。 この PC にあるシーケンス専用です。選択したシーケンスはサーバー上にあります。 このシーケンスの転送は既に実行中です。 フィルターをクリア diff --git a/i18n/ja/Server.ja.resx b/i18n/ja/Server.ja.resx index 5b9d2d65..5fd8dec7 100644 --- a/i18n/ja/Server.ja.resx +++ b/i18n/ja/Server.ja.resx @@ -40,6 +40,7 @@ 接続に失敗しました。詳細はログを確認してください。 シーケンスのファイルが別のプログラムで開かれています。ファイルを閉じてから、もう一度お試しください。 このシーケンスのフォルダーはディスク上にありません。ごみ箱に移動するものは残っていません。 + このシーケンスのフォルダーが、サーバーのインデックスに記録された場所にありません。サーバーの次のスキャンの後で、もう一度お試しください。 このアカウントではこの操作を実行できません。 サーバー上でシーケンスの写真が変更されました。再読み込みしてから、編集をもう一度適用してください。 ファイルが破損した状態で届きました。もう一度アップロードしてください。 @@ -68,11 +69,14 @@ このサーバーではその種類のジョブを実行できません。 最後の管理者は削除することも無効にすることもできません。 このメソッドはここでは使用できません。 + 新しいフォルダーが、別のシーケンスのフォルダーの中に入ってしまいます。 このアドレスは Chronos Server ではありません。 見つかりません。 先にパスワードを変更してください。 アップロード中に写真がシーケンスから削除されたため、追加されませんでした。 {0} を読み取れません。ハッシュがないと、削除されたことがほかのコピーに伝わりません。このファイルを使用しているプログラムを閉じるか、アクセス許可を確認してから、もう一度お試しください。 + ドライランの後にアーカイブが変更されました。もう一度プランを確認してください。 + サーバーがこのプランの作成を中止しました。時間がかかりすぎたか、一度に要求されたプランが多すぎます。しばらくしてからもう一度お試しください。 このアーカイブではプロキシを作成しません。 プロキシは別の写真から作成されています。 サーバーはこの写真のプロキシを必要としていません。 diff --git a/i18n/ja/Settings.ja.resx b/i18n/ja/Settings.ja.resx index 42e904bb..c5b075fb 100644 --- a/i18n/ja/Settings.ja.resx +++ b/i18n/ja/Settings.ja.resx @@ -65,6 +65,7 @@ 個/メガピクセル 分析の幅 px (長辺) + 既にアーカイブにあるフォルダーとファイルの名前は変わりません。 ファイル名 フォルダー {0} 空き @@ -74,10 +75,12 @@ アーカイブフォルダーの選択 プレビュー プロキシのサイズ + 再編成… アーカイブをリセット 名前のテンプレート、プロキシのサイズ、サムネイルのサイズが、このアーカイブを使用するすべての PC とサーバーで既定値に戻ります。既にアーカイブにあるフォルダーとファイルの名前は変わりません。 {0} の設定をリセットしますか? アーカイブフォルダー + アーカイブのテンプレートを保存しました サムネイルのサイズ 自動に戻す フォルダーを選択 diff --git a/i18n/ja/Tooltips.ja.resx b/i18n/ja/Tooltips.ja.resx index f97d1915..7f3e52b2 100644 --- a/i18n/ja/Tooltips.ja.resx +++ b/i18n/ja/Tooltips.ja.resx @@ -36,6 +36,7 @@ 最初のコピーのシーケンスを「編集」画面で開きます。 ハッシュを使って、シーケンス間で同一の写真を探します · インデックスのみ読み取り この年のシーケンスを表示します。 + 各写真のファイル名です (インポート時と同じ付け方) · 入力中にチェックされます 1 台のカメラのシーケンスだけを残します。 この値を選択します。もう一度選択すると解除されます。 特定の状態のシーケンスだけを残します。 @@ -71,7 +72,10 @@ サイドカーからインデックスを再構築します。サイドカーがない場合はメタデータを完全にスキャンします。オリジナルが削除されることはありません。 再構築をキューに追加します · その間もアーカイブは使用できます 移動したアーカイブの新しいフォルダーを選択します。シーケンスの場所も合わせて更新されます。 - フォルダー、サイドカー、インデックスにこの変更内容をそのまま適用します · クラッシュ後も再開できます + これらの変更だけを行うジョブをキューに追加します · 「ジョブ」で一時停止と再開ができます + このテンプレートで写真の名前を変更します · オフにすると名前はそのままです + シーケンスのフォルダーをこの構成に移動します · オフにすると今の場所に残ります + このテンプレートでタイトルを変更します · オフにするとタイトルはそのままです 「設定 › 詳細設定」でインデックスのバックアップを選択します。次回の起動時にインデックスが置き換えられます。 これらのシーケンスのタグを、サイドカーとインデックスで変更します。 同じ操作をもう一度実行します。 @@ -80,9 +84,8 @@ セット内のすべてのシーケンスで詳細分析を実行します。 セットをアーカイブのごみ箱に移動します · ドライランを表示してから、確認の入力を求めます セットを CSV としてエクスポートします。1 シーケンスにつき 1 行です。 - セットを新しいフォルダー構成に移動します · 先にドライラン プロキシを作成または更新します。 - テンプレートを使ってセットのタイトルを変更します · 先にドライラン + フォルダー、ファイル名、タイトルのテンプレートをセットに適用します · 先にドライラン、次にジョブ セット全体にタグを追加するか、セット全体からタグを削除します。 サムネイルを作成または更新します。 セットのオリジナルのハッシュを再計算します。 @@ -471,12 +474,12 @@ シーケンス {0:N0} 個について、この PC にないもの (オリジナルまたはレンダリング結果) をサーバーから取得します · 転送ジョブとして実行 {0:N0} 行を CSV として、選択したフォルダーに保存します。 {0:N0} 行を CSV として、選択したフォルダーに保存します。 - シーケンス {0:N0} 個をアーカイブ内の新しいフォルダー構成に移動します · 先にドライランを表示 - シーケンス {0:N0} 個をアーカイブ内の新しいフォルダー構成に移動します · 先にドライランを表示 シーケンス {0:N0} 個の JPEG プロキシを作成します · 1 つのジョブとして実行 シーケンス {0:N0} 個の JPEG プロキシを作成します · 1 つのジョブとして実行 シーケンス {0:N0} 個の評価を、サイドカーとインデックスに設定します。 シーケンス {0:N0} 個の評価を、サイドカーとインデックスに設定します。 + フォルダー、ファイル名、タイトルのテンプレートを、同じアーカイブのシーケンス {0:N0} 個に適用します · 先にドライラン、次にジョブ + フォルダー、ファイル名、タイトルのテンプレートを、同じアーカイブのシーケンス {0:N0} 個に適用します · 先にドライラン、次にジョブ シーケンス {0:N0} 個のタグを追加または削除します。 シーケンス {0:N0} 個のタグを追加または削除します。 シーケンス {0:N0} 個について、サーバーにないもの (オリジナルと設定、またはレンダリング結果) を送信します · 転送ジョブとして実行 @@ -692,6 +695,7 @@ 「バランス」はほとんどの作業に適しています。「最高品質」は 2 倍の解像度で測定し、より先まで読み込みます。「高速」は半分の解像度で測定し、動きはドラフト品質になります。 ドライバーやコーデックをインストールした後に、エンコーダーを再度一覧表示します。 拡張機能をインストールした後に、コーデック拡張機能を再度検索します。次のジョブから使用されます。 + アーカイブのテンプレートを、既にアーカイブにあるシーケンスに適用します · 先にドライラン この PC のすべての設定を既定値に戻します。実行前に確認します。 既定のテンプレートとサイズを、今すぐこのアーカイブの archive.json に書き込みます。 今すぐすべての設定をリセットします。 diff --git a/i18n/ko/Admin.ko.resx b/i18n/ko/Admin.ko.resx index 3b2d7ec8..c82bbe4d 100644 --- a/i18n/ko/Admin.ko.resx +++ b/i18n/ko/Admin.ko.resx @@ -9,6 +9,7 @@ Chronos Server 가동 시간 버전 + {0} 님이 아카이브를 재정리했습니다 · {1} {0} 님이 아카이브 구조를 변경했습니다 {0} 님이 사진을 삭제했습니다 · {1} {0} 님이 작업을 시작했습니다 · {1} @@ -138,7 +139,7 @@ 가져오기 빠른 분석 유지 관리 - 이동 + 재정리 고아 파일 프록시 재구성 @@ -343,6 +344,7 @@ 로그인하여 이 서버를 관리합니다. 사용자 이 서버의 사용자 이름 + 아카이브 재정리 아카이브 구조 사진 삭제 작업 시작 @@ -426,6 +428,58 @@ 암호 변경 암호를 바꾸고 패널로 이동합니다. 새 암호 설정 + 재정리… + 선택한 시퀀스에 폴더, 파일, 제목 템플릿을 적용합니다. 먼저 미리 보기에서 모든 변경 내용을 보여 줍니다. + 변경 후: + 적용… + 미리 보기에 표시된 대로 재정리합니다. 먼저 확인을 요청합니다. + 변경 전: + 템플릿을 입력하거나 이 부분을 끄십시오. + 아무것도 변경하지 않고 닫습니다. + 함께 이동 + 자체 변경은 없고, 들어 있는 폴더가 이동하므로 함께 이동합니다. + 이름을 바꾼 파일 + 폴더 + 시퀀스 + 재정리 + 원본을 이동하고 이름을 바꾸는 작업을 대기열에 추가합니다. 덮어쓰거나 삭제되는 항목은 없습니다. + 사진 {0}장의 이름이 바뀝니다. + 사진 {0}장의 이름이 바뀝니다. + 폴더 {0}개가 이동합니다. + 폴더 {0}개가 이동합니다. + 시퀀스 {0}개가 변경됩니다. + 시퀀스 {0}개가 변경됩니다. + 지금 재정리하시겠습니까? + 가져오기에서 지정하는 각 사진의 이름입니다. 예: {date}_{time}_{n:0000}. 사진 옆에 있는 파일도 함께 바뀝니다. + 파일 + 각 시퀀스의 사진 이름을 바꿉니다. 끄면 모든 파일 이름이 유지됩니다. + 이름을 바꾼 파일 {0}개 + 이름을 바꾼 파일 {0}개 + 아카이브에서 각 시퀀스의 폴더입니다. 예: {year}/{date} {camera}. {title} 토큰은 새 제목입니다. + 폴더 + 각 시퀀스를 템플릿이 지정하는 폴더로 이동합니다. 끄면 모든 폴더가 현재 위치에 유지됩니다. + 선택한 시퀀스 중 하나가 더 이상 아카이브에 없습니다. 닫고 다시 선택하십시오. + {0}: {1} + 변경할 부분을 하나 이상 켜십시오. + 변경할 항목이 없습니다. 이 시퀀스는 이미 템플릿을 따르고 있습니다. + 재정리… + 아카이브에 이미 있는 시퀀스에 새 템플릿을 적용합니다. 먼저 미리 보기에서 모든 변경 내용을 보여 줍니다. + 작업 열기 + 작업 페이지에서 작업과 해당 로그를 표시합니다. + 확인하는 동안 아카이브가 변경되었습니다. 새 미리 보기를 확인하고 다시 적용하십시오. + 계획 중… + 미리 보기 + 변경이 적용되는 순서대로 각 시퀀스가 어떻게 바뀌는지 보여 줍니다. 아직 아무것도 변경되지 않았습니다. + 재정리가 대기열에 추가되었습니다. + 이 폴더는 현재 위치에 그대로 있습니다. + 시퀀스 {0}개 재정리 + 시퀀스 {0}개 재정리 + 모든 시퀀스 재정리 + 각 시퀀스의 새 제목입니다. 예: {date} {camera}. {title} 토큰은 현재 제목입니다. + 제목 + 각 시퀀스에 템플릿으로 만든 제목을 지정합니다. 끄면 모든 제목이 유지됩니다. + 재정리는 한 번에 최대 시퀀스 {0}개 또는 모든 시퀀스를 처리할 수 있습니다. 필터를 지우고 모두 선택하십시오. + 변경된 시퀀스: {0} · 이름을 바꾼 파일: {1} · 유지된 이름: {2} 관리자 편집자 업로더 diff --git a/i18n/ko/Archive.ko.resx b/i18n/ko/Archive.ko.resx index 238f4ce5..c285a769 100644 --- a/i18n/ko/Archive.ko.resx +++ b/i18n/ko/Archive.ko.resx @@ -15,6 +15,7 @@ 변경 내용이 적용될 때까지 기다리십시오. 작업 대상이 비어 있습니다. 선택이나 필터를 변경하십시오. 변경될 항목이 없습니다. + 템플릿을 하나 이상 켜십시오. 아카이브가 온라인 상태이고 쓰기 가능해야 합니다. 시험 실행이 끝날 때까지 기다리십시오. 아카이브를 다 읽을 때까지 기다리십시오. @@ -81,6 +82,12 @@ {0}: 더 새로운 버전의 Chronos(형식 {1})에서 작성되었습니다. {0} 아카이브가 오프라인입니다. {0} 아카이브는 읽기 전용입니다. + 시퀀스 {0:N0}개의 파일 이름이 유지되었습니다. 사진이 사용 중이었거나 새 이름이 이미 사용되고 있었습니다. + 시퀀스 {0:N0}개의 파일 이름이 유지되었습니다. 사진이 사용 중이었거나 새 이름이 이미 사용되고 있었습니다. + 시퀀스 {0:N0}개가 계획대로 재정리되지 않았습니다. 계획을 만든 후 변경되었습니다. + 시퀀스 {0:N0}개가 계획대로 재정리되지 않았습니다. 계획을 만든 후 변경되었습니다. + 시퀀스 {0:N0}개의 제목과 파일 이름이 유지되었습니다. 시퀀스 파일이 더 새로운 버전의 Chronos에서 작성되었습니다. + 시퀀스 {0:N0}개의 제목과 파일 이름이 유지되었습니다. 시퀀스 파일이 더 새로운 버전의 Chronos에서 작성되었습니다. 계획을 만든 후 {0} 항목이 변경되었습니다. 카드 또는 폴더 {0}에 더 이상 액세스할 수 없습니다. 이 계획을 만든 후 아카이브가 변경되었습니다. @@ -146,6 +153,14 @@ 인덱싱 안 된 사진: {0}, 누락된 사진: {1} {0}: 생성 {1}, 재사용 {2}, 읽을 수 없음 {3}, 대기 중 {4} 서버용 프록시: 보냄 {0}, 보내지 못함 {1} + 그대로 둠, 들어 있는 폴더가 이동하지 않음: {0} + 그대로 둠, 계획 후 변경됨: {0} + 파일 이름 유지됨, 사진이 사용 중이었거나 새 이름이 이미 사용 중임: {0} + 파일 이름 유지됨, 계획 후 사진이 변경됨: {0} + 제목과 파일 이름 유지됨, 시퀀스 파일이 더 새로운 Chronos에서 작성됨: {0} + 제목과 파일 이름 유지됨, 계획 후 변경됨: {0} + 변경된 시퀀스: {0}, 이름을 바꾼 파일: {1} + 아카이브를 열 때 재정리가 완료되었습니다 보고서만: 아무것도 변경하지 않았습니다. 폴더: {0}, 인덱싱됨: {1}, 등록됨: {2}, 제거됨: {3} 시퀀스를 찾을 수 없음: {0} @@ -200,14 +215,30 @@ 이동한 아카이브의 폴더 선택 적용 {0} / {1} - 시퀀스 {0:N0}개 이름 바꾸기 - 시퀀스 {0:N0}개 이름 바꾸기 - 시퀀스 {0:N0}개 이동 - 시퀀스 {0:N0}개 이동 변경 내용 {1:N0}개 중 {0:N0}개 변경 {1:N0}개 중 {0:N0}개 변경 - 템플릿 + originals 폴더 밖에서 제자리에 보관된 사진은 이름이 유지됩니다. + 누락된 사진은 이름이 유지됩니다. + 검증된 적 없는 사진은 이름이 유지됩니다. 먼저 시퀀스를 검증하십시오. + 시퀀스 파일을 읽을 수 없습니다. 시퀀스와 이 시퀀스가 들어 있는 폴더는 모두 그대로 유지됩니다. + 상위 폴더와 함께 이동 + {0}: 변경 전 {1}, 변경 후 {2} + 파일 + 파일 이름 + 폴더 + 폴더 + 시퀀스 {0:N0}개 재정리 + 시퀀스 {0:N0}개 재정리 + {0} 아카이브 재정리 + 유지된 이름 {0:N0}개 + 유지된 이름 {0:N0}개 + 시험 실행 중… + 이름을 바꾼 파일 {0:N0}개 + 이름을 바꾼 파일 {0:N0}개 + 제목 + 제목 + 열려 있는 대화 상자를 닫으면 재정리 창이 열립니다 태그 추가 적용 시퀀스 {0:N0}개의 태그 @@ -222,9 +253,8 @@ CSV 내보내기 작업 대상 필터 작업 대상 - 이동… 프록시 - 이름 바꾸기… + 재정리… 태그 변경… 썸네일 검증 diff --git a/i18n/ko/Errors.ko.resx b/i18n/ko/Errors.ko.resx index 6555ddfd..b4123423 100644 --- a/i18n/ko/Errors.ko.resx +++ b/i18n/ko/Errors.ko.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 분석하지 못한 시퀀스: {1}개 중 {0}개. 작업 로그를 확인하십시오. + 이 시퀀스의 폴더가 인덱스에 기록된 위치에 없습니다. 다음 스캔 후 다시 시도하십시오. 아카이브를 열 수 없습니다. 현재 인덱스를 백업하거나 교체할 수 없습니다. 다음에 시작할 때 복원을 다시 실행합니다. 이 백업은 복원할 수 없습니다. 다른 백업을 선택하십시오. @@ -37,9 +38,11 @@ 원본 {0}개가 없거나 보관된 후 변경되었습니다. 아카이브를 검증하십시오. 템플릿이 비어 있습니다. 위치 {1}에 빈 토큰이 있습니다. 중괄호 안에 이름을 쓰십시오. + 사진의 확장자가 없어집니다. {ext} 앞에 점을 쓰거나 {ext} 토큰을 빼십시오. 파일 이름에는 슬래시를 쓸 수 없습니다. 폴더는 폴더 템플릿에 넣으십시오. 콜론 뒤의 형식이 해당 토큰에 맞지 않습니다. 이름이 중복됩니다. 프레임 번호, 시각 또는 원래 이름을 추가하십시오. + 스캔은 점으로 시작하거나 이름이 originals, proxies, exports인 폴더를 건너뜁니다. 위치 {1}에서 연 중괄호가 닫히지 않았습니다. 위치 {1}: 알 수 없는 토큰 “{0}”. 위치 {1}의 닫는 중괄호에 짝이 되는 여는 중괄호가 없습니다. 중괄호 문자를 쓰려면 두 번 입력하십시오. diff --git a/i18n/ko/Jobs.ko.resx b/i18n/ko/Jobs.ko.resx index d53e25eb..bfc5ff83 100644 --- a/i18n/ko/Jobs.ko.resx +++ b/i18n/ko/Jobs.ko.resx @@ -76,7 +76,7 @@ 가져오기 빠른 분석 유지 관리 - 아카이브 이동 + 재정리 고아 파일 프록시 인덱스 재구성 diff --git a/i18n/ko/Library.ko.resx b/i18n/ko/Library.ko.resx index d9613a0b..90540c4e 100644 --- a/i18n/ko/Library.ko.resx +++ b/i18n/ko/Library.ko.resx @@ -10,17 +10,16 @@ 다운로드 목록 내보내기 폴더 - 이동… 열기 프록시 등급 렌더링 + 재정리… 동기화 태그… 업로드 검증 폴더 등록 - ‘이동’은 한 번에 한 아카이브의 시퀀스에만 적용됩니다. 이 PC와 서버의 내용이 같습니다. 동기화할 항목이 없습니다. 사용 중인 저장된 보기가 없습니다. 먼저 보기를 하나 선택하십시오. 서버 계정으로는 원본을 다운로드할 수 없습니다. @@ -32,6 +31,7 @@ 먼저 서버 화면에서 Chronos Server에 로그인하십시오. 선택한 시퀀스에는 서버에서 받을 항목이 없습니다. 선택한 시퀀스의 내용이 이미 서버에 모두 있습니다. + 재정리는 한 번에 한 아카이브의 시퀀스에만 적용할 수 있습니다. 이 PC에 있는 시퀀스에만 사용할 수 있습니다. 선택한 시퀀스는 서버에 있습니다. 이 시퀀스의 전송이 이미 진행 중입니다. 필터 지우기 diff --git a/i18n/ko/Server.ko.resx b/i18n/ko/Server.ko.resx index e1fcbff4..5b7094e5 100644 --- a/i18n/ko/Server.ko.resx +++ b/i18n/ko/Server.ko.resx @@ -40,6 +40,7 @@ 연결하지 못했습니다. 자세한 내용은 로그를 확인하십시오. 시퀀스의 파일이 다른 프로그램에서 열려 있습니다. 파일을 닫고 다시 시도하십시오. 시퀀스 폴더가 더 이상 디스크에 없습니다. 휴지통으로 이동할 항목이 남아 있지 않습니다. + 이 시퀀스의 폴더가 서버 인덱스에 기록된 위치에 없습니다. 서버의 다음 스캔 후 다시 시도하십시오. 이 계정으로는 이 작업을 할 수 없습니다. 서버에서 시퀀스의 사진이 변경되었습니다. 다시 불러온 후 편집 내용을 다시 적용하십시오. 파일이 손상된 채로 도착했습니다. 다시 업로드하십시오. @@ -68,11 +69,14 @@ 이 서버는 해당 종류의 작업을 실행할 수 없습니다. 마지막 관리자는 제거하거나 비활성화할 수 없습니다. 여기에서는 이 메서드를 사용할 수 없습니다. + 새 폴더가 다른 시퀀스의 폴더 안에 놓이게 됩니다. 해당 주소는 Chronos Server가 아닙니다. 찾을 수 없습니다. 먼저 암호를 변경하십시오. 업로드하는 동안 사진이 시퀀스에서 삭제되어 추가하지 않았습니다. {0} 파일을 읽을 수 없습니다. 해시가 없으면 다른 복사본에 이 파일이 삭제되었음을 알릴 수 없습니다. 이 파일을 사용하는 프로그램을 닫거나 권한을 확인한 후 다시 시도하십시오. + 시험 실행 후 아카이브가 변경되었습니다. 계획을 다시 검토하십시오. + 서버가 이 계획 작성을 중단했습니다. 시간이 너무 오래 걸렸거나 한 번에 너무 많은 계획이 요청되었습니다. 잠시 후 다시 시도하십시오. 이 아카이브는 프록시를 만들지 않습니다. 프록시가 다른 사진으로 만들어졌습니다. 서버에는 이 사진의 프록시가 필요하지 않습니다. diff --git a/i18n/ko/Settings.ko.resx b/i18n/ko/Settings.ko.resx index 75ab33ea..4b9b51d4 100644 --- a/i18n/ko/Settings.ko.resx +++ b/i18n/ko/Settings.ko.resx @@ -65,6 +65,7 @@ 개(메가픽셀당 별) 분석 너비 px(긴 변) + 아카이브에 이미 있는 폴더와 파일은 이름이 그대로 유지됩니다. 파일 이름 폴더 {0} 사용 가능 @@ -74,10 +75,12 @@ 아카이브 폴더 선택 미리 보기 프록시 크기 + 재정리… 아카이브 설정 초기화 이 아카이브를 사용하는 모든 PC와 서버에서 이름 지정 템플릿, 프록시 크기, 썸네일 크기가 기본값으로 돌아갑니다. 아카이브에 이미 있는 폴더와 파일은 이름이 그대로 유지됩니다. {0} 아카이브의 설정을 초기화하시겠습니까? 아카이브 폴더 + 아카이브 템플릿을 저장했습니다 썸네일 크기 자동으로 되돌리기 폴더 선택 diff --git a/i18n/ko/Tooltips.ko.resx b/i18n/ko/Tooltips.ko.resx index 96c86edb..62d7cff2 100644 --- a/i18n/ko/Tooltips.ko.resx +++ b/i18n/ko/Tooltips.ko.resx @@ -36,6 +36,7 @@ 첫 번째 복사본의 시퀀스를 편집 화면에서 엽니다. 해시로 시퀀스 간에 동일한 사진을 찾습니다 · 인덱스만 읽음 이 연도의 시퀀스를 표시합니다. + 가져오기에서 지정하는 각 사진의 파일 이름입니다 · 입력하는 동안 확인 한 카메라의 시퀀스만 남깁니다. 이 값을 선택합니다. 다시 선택하면 해제됩니다. 한 상태의 시퀀스만 남깁니다. @@ -71,7 +72,10 @@ 사이드카에서 인덱스를 재구성합니다. 사이드카가 없으면 메타데이터를 전부 스캔하며, 원본은 절대 삭제하지 않습니다. 재구성을 대기열에 추가합니다 · 그동안에도 아카이브를 사용할 수 있음 이동한 아카이브의 새 폴더를 선택합니다. 해당 시퀀스도 새 위치로 연결됩니다. - 폴더, 사이드카, 인덱스에 정확히 이 변경 내용을 적용합니다 · 중단되어도 이어서 진행 + 정확히 이 변경 내용을 적용하는 작업을 대기열에 추가합니다 · 작업에서 일시 중지 및 재개 가능 + 이 템플릿으로 사진 이름을 바꿉니다 · 끄면 이름이 유지됨 + 시퀀스 폴더를 이 구조로 이동합니다 · 끄면 현재 위치에 유지됨 + 이 템플릿으로 제목을 변경합니다 · 끄면 그대로 유지됨 설정 › 고급에서 인덱스 백업을 선택합니다. 선택한 백업은 다음에 시작할 때 인덱스를 대체합니다. 사이드카와 인덱스에서 이 시퀀스들의 태그를 변경합니다. 같은 동작을 다시 실행합니다. @@ -80,9 +84,8 @@ 작업 대상의 모든 시퀀스를 정밀 분석합니다. 작업 대상을 아카이브의 휴지통으로 이동합니다 · 시험 실행 후 입력하여 확인 작업 대상을 CSV로 내보냅니다. 시퀀스마다 한 행입니다. - 작업 대상을 새 폴더 구조로 이동합니다 · 시험 실행 먼저 프록시를 만들거나 새로 고칩니다. - 템플릿으로 작업 대상의 제목을 바꿉니다 · 시험 실행 먼저 + 작업 대상에 폴더, 파일, 제목 템플릿을 적용합니다 · 먼저 시험 실행 후 작업으로 실행 작업 대상 전체에 태그를 추가하거나 제거합니다. 썸네일을 만들거나 새로 고칩니다. 작업 대상의 원본 해시를 다시 계산합니다. @@ -471,12 +474,12 @@ 시퀀스 {0:N0}개에 대해 이 PC에 없는 항목(원본 또는 렌더링 결과)을 서버에서 받습니다 · 전송 작업으로 실행 행 {0:N0}개를 원하는 폴더에 CSV로 저장합니다. 행 {0:N0}개를 원하는 폴더에 CSV로 저장합니다. - 시퀀스 {0:N0}개를 해당 아카이브의 새 폴더 구조로 이동합니다 · 시험 실행 먼저 - 시퀀스 {0:N0}개를 해당 아카이브의 새 폴더 구조로 이동합니다 · 시험 실행 먼저 시퀀스 {0:N0}개의 JPEG 프록시를 만듭니다 · 하나의 작업으로 실행 시퀀스 {0:N0}개의 JPEG 프록시를 만듭니다 · 하나의 작업으로 실행 시퀀스 {0:N0}개의 등급을 사이드카와 인덱스에 설정합니다. 시퀀스 {0:N0}개의 등급을 사이드카와 인덱스에 설정합니다. + 아카이브의 시퀀스 {0:N0}개에 폴더, 파일, 제목 템플릿을 적용합니다 · 먼저 시험 실행 후 작업으로 실행 + 아카이브의 시퀀스 {0:N0}개에 폴더, 파일, 제목 템플릿을 적용합니다 · 먼저 시험 실행 후 작업으로 실행 시퀀스 {0:N0}개에 태그를 추가하거나 제거합니다. 시퀀스 {0:N0}개에 태그를 추가하거나 제거합니다. 시퀀스 {0:N0}개에서 서버에 없는 항목(원본과 설정, 또는 렌더링 결과)을 보냅니다 · 전송 작업으로 실행 @@ -692,6 +695,7 @@ ‘균형’은 대부분의 작업에 적합합니다. ‘최고’는 두 배 해상도로 측정하고 더 멀리 미리 읽으며, ‘빠름’은 절반 해상도로 측정하고 초안 수준의 움직임을 사용합니다. 드라이버나 코덱을 설치한 후 인코더 목록을 다시 만듭니다. 코덱 확장을 설치한 후 다시 찾습니다. 다음 작업부터 사용됩니다. + 아카이브에 이미 있는 시퀀스에 아카이브의 템플릿을 적용합니다 · 먼저 시험 실행 이 PC의 모든 설정을 기본값으로 되돌립니다. 먼저 확인을 요청합니다. 지금 이 아카이브의 archive.json에 기본 템플릿과 크기를 씁니다. 지금 모든 설정을 초기화합니다. diff --git a/i18n/lt/Admin.lt.resx b/i18n/lt/Admin.lt.resx index a6905a09..443511e7 100644 --- a/i18n/lt/Admin.lt.resx +++ b/i18n/lt/Admin.lt.resx @@ -9,6 +9,7 @@ Chronos serveris Veikia Versija + {0} pertvarkė archyvą · {1} {0} pakeitė archyvo struktūrą {0} panaikino {1} {0} pradėjo {1} @@ -147,7 +148,7 @@ Importavimas Greitoji analizė Priežiūra - Perkėlimas + Pertvarkymas Našlaičiai Tarpinės kopijos Perkūrimas @@ -367,6 +368,7 @@ Prisijungti ir administruoti šį serverį Naudotojas Jūsų naudotojo vardas šiame serveryje + Archyvas pertvarkytas Archyvo struktūra Nuotraukos panaikintos Užduotis pradėta @@ -452,6 +454,63 @@ Keisti slaptažodį Pakeisti slaptažodį ir pereiti į skydelį Pasirinkite naują slaptažodį + Pertvarkyti… + Taikyti aplankų, failų ir pavadinimų šablonus pažymėtoms sekoms; pirmiausia peržiūroje parodomas kiekvienas pakeitimas + Po: + Taikyti… + Pertvarkyti, kaip rodo peržiūra; pirmiausia prašoma patvirtinti + Prieš: + Įrašykite šabloną arba išjunkite šią dalį. + Uždaryti nieko nekeičiant + Perkeliama kartu + Perkeliama tik todėl, kad perkeliamas aplankas, kuriame ji yra + Pervardyti failai + Aplankas + Seka + Pertvarkyti + Įtraukti į eilę užduotį, kuri perkelia ir pervardija originalus; niekas neperrašoma ir nepanaikinama + {0} nuotraukos bus pervardytos. + {0} nuotrauka bus pervardyta. + {0} nuotraukų bus pervardyta. + {0} aplankai bus perkelti. + {0} aplankas bus perkeltas. + {0} aplankų bus perkelta. + {0} sekos bus pakeistos. + {0} seka bus pakeista. + {0} sekų bus pakeista. + Pertvarkyti dabar? + Kiekvienos nuotraukos pavadinimas, kokį suteikia importavimas, pvz., {date}_{time}_{n:0000}; šalia nuotraukos esantys failai pervardijami kartu + Failai + Pervardyti kiekvienos sekos nuotraukas; išjungus paliekami visi failų pavadinimai + {0} failai pervardyti + {0} failas pervardytas + {0} failų pervardyta + Kiekvienos sekos aplankas archyve, pvz., {year}/{date} {camera}; {title} – naujasis pavadinimas + Aplankai + Perkelti kiekvieną seką į jos šablono nurodytą aplanką; išjungus visi aplankai lieka savo vietose + Vienos iš pažymėtų sekų archyve nebėra; uždarykite ir pažymėkite iš naujo. + {0}: {1} + Įjunkite bent vieną keistiną dalį. + Nėra ko keisti: šios sekos jau atitinka šablonus. + Pertvarkyti… + Taikyti naujus šablonus archyve jau esančioms sekoms; pirmiausia peržiūroje parodomas kiekvienas pakeitimas + Atidaryti užduotį + Rodyti užduotį ir jos žurnalą užduočių puslapyje + Tvirtinant archyvas pasikeitė; patikrinkite naują peržiūrą ir taikykite dar kartą. + Planuojama… + Peržiūra + Kuo taps kiekviena seka, pakeitimų taikymo tvarka; kol kas niekas nepakeista + Pertvarkymas įtrauktas į eilę. + Šis aplankas lieka savo vietoje + Pertvarkyti {0} sekas + Pertvarkyti {0} seką + Pertvarkyti {0} sekų + Pertvarkyti visas sekas + Naujas kiekvienos sekos pavadinimas, pvz., {date} {camera}; {title} – dabartinis pavadinimas + Pavadinimai + Suteikti kiekvienai sekai jos šablono sudarytą pavadinimą; išjungus paliekami visi pavadinimai + Vienu kartu pertvarkomų sekų skaičius ribojamas iki {0}, nebent pertvarkomos visos sekos: išvalykite filtrus ir pažymėkite viską. + Pakeista sekų: {0} · pervardyta failų: {1} · palikta pavadinimų: {2} Administratorius Redaktorius Įkėlėjas diff --git a/i18n/lt/Archive.lt.resx b/i18n/lt/Archive.lt.resx index 54edc744..f5b720aa 100644 --- a/i18n/lt/Archive.lt.resx +++ b/i18n/lt/Archive.lt.resx @@ -16,6 +16,7 @@ Palaukite, kol bus pritaikyti pakeitimai. Rinkinys tuščias: pakeiskite žymėjimą arba filtrą. Niekas nepasikeistų. + Įjunkite bent vieną šabloną. Archyvas turi būti pasiekiamas ir jame turi būti galima rašyti. Palaukite, kol baigsis bandomasis vykdymas. Palaukite, kol archyvas bus perskaitytas. @@ -91,6 +92,15 @@ {0} įrašė naujesnė Chronos versija (formatas {1}). Archyvas {0} nepasiekiamas. Archyvas {0} tik skaitomas. + {0:N0} sekos išlaikė failų pavadinimus: kuri nors nuotrauka buvo naudojama arba jos naujas pavadinimas jau buvo užimtas. + {0:N0} seka išlaikė failų pavadinimus: kuri nors nuotrauka buvo naudojama arba jos naujas pavadinimas jau buvo užimtas. + {0:N0} sekų išlaikė failų pavadinimus: kuri nors nuotrauka buvo naudojama arba jos naujas pavadinimas jau buvo užimtas. + {0:N0} sekos nepertvarkytos pagal planą: jos pasikeitė po plano sudarymo. + {0:N0} seka nepertvarkyta pagal planą: ji pasikeitė po plano sudarymo. + {0:N0} sekų nepertvarkyta pagal planą: jos pasikeitė po plano sudarymo. + {0:N0} sekos išlaikė pavadinimus ir failų pavadinimus: jų sekų failus įrašė naujesnė Chronos versija. + {0:N0} seka išlaikė pavadinimą ir failų pavadinimus: jos sekos failą įrašė naujesnė Chronos versija. + {0:N0} sekų išlaikė pavadinimus ir failų pavadinimus: jų sekų failus įrašė naujesnė Chronos versija. {0} pasikeitė po to, kai buvo sudarytas planas. Kortelė arba aplankas {0} nebepasiekiami. Archyvas pasikeitė po to, kai buvo sudarytas šis planas. @@ -162,6 +172,14 @@ Neindeksuotų nuotraukų: {0}, trūkstamų nuotraukų: {1} {0}: sukurta {1}, panaudota pakartotinai {2}, neperskaitoma {3}, laukiama {4} Tarpinės kopijos serveriui: išsiųsta {0}, neišsiųsta {1} + Palikta kaip buvo, aplankas, kuriame ji yra, liko vietoje: {0} + Palikta kaip buvo, pasikeitė po plano sudarymo: {0} + Failų pavadinimai palikti, nuotrauka buvo naudojama arba jos naujas pavadinimas užimtas: {0} + Failų pavadinimai palikti, nuotraukos pasikeitė po plano sudarymo: {0} + Pavadinimas ir failų pavadinimai palikti, sekos failą įrašė naujesnė Chronos versija: {0} + Pavadinimas ir failų pavadinimai palikti, pasikeitė po plano sudarymo: {0} + Pakeista sekų: {0}, pervardyta failų: {1} + Pertvarkymas užbaigtas atidarant archyvą Tik ataskaita: niekas nepakeista. Aplankų: {0}, indeksuota: {1}, perimta: {2}, pašalinta: {3} Seka nerasta: {0} @@ -219,17 +237,34 @@ Perkelto archyvo aplankas Taikyti {0} iš {1} - Pervardyti {0:N0} sekas - Pervardyti {0:N0} seką - Pervardyti {0:N0} sekų - Perkelti {0:N0} sekas - Perkelti {0:N0} seką - Perkelti {0:N0} sekų Pakeitimai Pasikeis {0:N0} iš {1:N0} Pasikeis {0:N0} iš {1:N0} Pasikeis {0:N0} iš {1:N0} - Šablonas + Nuotraukos, laikomos vietoje už aplanko originals ribų, išlaiko savo pavadinimus. + Trūkstamos nuotraukos išlaiko savo pavadinimus. + Niekada nepatikrintos nuotraukos išlaiko savo pavadinimus; pirmiausia patikrinkite seką. + Sekos failo nepavyksta perskaityti; seka lieka tokia, kokia yra, kaip ir bet kuris aplankas, kuriame ji yra. + Perkeliama su aplanku + {0}: iš {1} į {2} + Failas + Failų pavadinimai + Aplankas + Aplankai + Pertvarkyti {0:N0} sekas + Pertvarkyti {0:N0} seką + Pertvarkyti {0:N0} sekų + Pertvarkyti archyvą {0} + {0:N0} pavadinimai palikti + {0:N0} pavadinimas paliktas + {0:N0} pavadinimų palikta + Bandomasis vykdymas… + {0:N0} failai pervardyti + {0:N0} failas pervardytas + {0:N0} failų pervardyta + Pavadinimas + Pavadinimai + Pertvarkymo langas atsidarys, kai bus uždarytas atidarytas dialogo langas Pridėti žymes Taikyti {0:N0} sekų žymės @@ -246,9 +281,8 @@ Eksportuoti CSV Rinkinio filtras Filtruotas rinkinys - Perkelti… Tarpinės kopijos - Pervardyti… + Pertvarkyti… Keisti žymes… Miniatiūros Patikrinti diff --git a/i18n/lt/Errors.lt.resx b/i18n/lt/Errors.lt.resx index 94ae25b2..2f6097ed 100644 --- a/i18n/lt/Errors.lt.resx +++ b/i18n/lt/Errors.lt.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Neišanalizuotų sekų: {0} iš {1}; žr. užduoties žurnalą. + Šios sekos aplankas ne ten, kur nurodo indeksas; bandykite dar kartą po kito nuskaitymo. Nepavyko atidaryti archyvo. Nepavyko sukurti dabartinio indekso atsarginės kopijos arba jo pakeisti; atkurti bus vėl bandoma kitą kartą paleidus programą. Šios atsarginės kopijos atkurti negalima; pasirinkite kitą. @@ -39,9 +40,11 @@ {0} originalų trūksta arba jie pasikeitė po archyvavimo; patikrinkite archyvą. Šablonas tuščias. Tuščias žymuo {1} pozicijoje: tarp riestinių skliaustų įrašykite pavadinimą. + Nuotraukos netektų plėtinio: prieš {ext} parašykite tašką arba pašalinkite {ext}. Failų pavadinimuose negali būti pasvirojo brūkšnio; aplankus nurodykite aplankų šablone. Formatas po dvitaškio netinka jo žymeniui. Pavadinimai kartotųsi: pridėkite kadro numerį, laiką arba originalų pavadinimą. + Nuskaitant praleidžiami aplankai, kurių pavadinimas prasideda tašku arba yra originals, proxies ar exports. {1} pozicijoje atidarytas riestinis skliaustas neuždarytas. Nežinomas žymuo „{0}“ {1} pozicijoje. Uždarantis riestinis skliaustas {1} pozicijoje neturi atidarančiojo; norėdami įrašyti patį skliaustą, parašykite jį du kartus. diff --git a/i18n/lt/Jobs.lt.resx b/i18n/lt/Jobs.lt.resx index cd30e119..94511168 100644 --- a/i18n/lt/Jobs.lt.resx +++ b/i18n/lt/Jobs.lt.resx @@ -77,7 +77,7 @@ Importavimas Greitoji analizė Priežiūra - Archyvo perkėlimas + Pertvarkymas Našlaičiai Tarpinės kopijos Indekso perkūrimas diff --git a/i18n/lt/Library.lt.resx b/i18n/lt/Library.lt.resx index 3fd70c4f..a83c36a6 100644 --- a/i18n/lt/Library.lt.resx +++ b/i18n/lt/Library.lt.resx @@ -10,17 +10,16 @@ Atsisiųsti Eksportuoti sąrašą Aplankas - Perkelti… Atidaryti Tarpinės kopijos Įvertinimas Atvaizduoti + Pertvarkyti… Sinchronizuoti Žymės… Įkelti Patikrinti Perimti aplanką - Vienu metu galima perkelti tik vieno archyvo sekas. Šiame kompiuteryje ir serveryje viskas vienoda: nėra ko sinchronizuoti. Nenaudojamas joks įrašytas rodinys; pirmiausia pasirinkite rodinį. Jūsų serverio paskyra negali atsisiųsti originalų. @@ -32,6 +31,7 @@ Pirmiausia serverio ekrane prisijunkite prie Chronos serverio. Pažymėtoms sekoms nėra ko atsisiųsti iš serverio. Serveris jau turi viską, ką turi pažymėtos sekos. + Vienu metu galima pertvarkyti tik vieno archyvo sekas. Tik šiame kompiuteryje esančioms sekoms; pažymėtos sekos saugomos serveryje. Šios sekos perdavimas jau vyksta. Valyti filtrus diff --git a/i18n/lt/Server.lt.resx b/i18n/lt/Server.lt.resx index 78b161e8..d07bb347 100644 --- a/i18n/lt/Server.lt.resx +++ b/i18n/lt/Server.lt.resx @@ -40,6 +40,7 @@ Ryšys nepavyko; išsami informacija – žurnale. Sekos failas atidarytas kitoje programoje; uždarykite jį ir bandykite dar kartą. Jos aplanko diske nebėra; nėra ko perkelti į šiukšlinę. + Šios sekos aplankas ne ten, kur nurodo serverio indeksas; bandykite dar kartą po kito serverio nuskaitymo. Jūsų paskyra negali to atlikti. Sekos nuotraukos serveryje pasikeitė; įkelkite seką iš naujo ir vėl pritaikykite savo pakeitimą. Failas atkeliavo sugadintas; įkelkite jį dar kartą. @@ -68,11 +69,14 @@ Šis serveris negali vykdyti tokio tipo užduočių. Paskutinio administratoriaus negalima pašalinti ar išjungti. Šis metodas čia neleidžiamas. + Naujas aplankas atsidurtų kitos sekos aplanke. Šiuo adresu nėra Chronos serverio. Nerasta. Pirmiausia pakeiskite slaptažodį. Nuotrauka buvo panaikinta iš sekos jos įkėlimo metu, todėl ji nepridėta. Failo {0} nepavyksta perskaityti, o be jo maišos kitos kopijos nesužinotų, kad jis panaikintas; uždarykite jį naudojančią programą arba patikrinkite jo teises ir bandykite dar kartą. + Archyvas pasikeitė po bandomojo vykdymo; dar kartą peržiūrėkite planą. + Serveris nustojo sudarinėti šį planą: tai užtruko per ilgai arba vienu metu paprašyta per daug planų; netrukus bandykite dar kartą. Šis archyvas nekuria tarpinių kopijų. Tarpinė kopija sukurta iš kitos nuotraukos. Serveriui nereikia šios nuotraukos tarpinės kopijos. diff --git a/i18n/lt/Settings.lt.resx b/i18n/lt/Settings.lt.resx index 6ad2f7fc..3f2f87fa 100644 --- a/i18n/lt/Settings.lt.resx +++ b/i18n/lt/Settings.lt.resx @@ -66,6 +66,7 @@ žvaigždžių megapikselyje Analizės plotis px ilgojoje kraštinėje + Archyve jau esantys aplankai ir failai išlaiko savo pavadinimus. Failų pavadinimai Aplankai {0} laisva @@ -75,10 +76,12 @@ Pasirinkite archyvo aplanką Peržiūra Tarpinių kopijų dydis + Pertvarkyti… Atkurti archyvo parametrus Jo pavadinimų šablonai, tarpinių kopijų dydis ir miniatiūrų dydis grąžinami į numatytąsias reikšmes visuose jį naudojančiuose kompiuteriuose ir serveriuose. Archyve jau esantys aplankai ir failai išlaiko savo pavadinimus. Atkurti archyvo {0} parametrus? Archyvo aplankas + Archyvo šablonai įrašyti Miniatiūrų dydis Grįžti į Auto Pasirinkti aplanką diff --git a/i18n/lt/Tooltips.lt.resx b/i18n/lt/Tooltips.lt.resx index f49d9caf..728b52bf 100644 --- a/i18n/lt/Tooltips.lt.resx +++ b/i18n/lt/Tooltips.lt.resx @@ -37,6 +37,7 @@ Atidaryti pirmosios kopijos seką skiltyje „Redagavimas“ Rasti vienodas nuotraukas skirtingose sekose pagal maišą · skaitomas tik indeksas Rodyti šių metų sekas + Kiekvienos nuotraukos failo pavadinimas, kokį suteikia importavimas · tikrinama rašant Palikti tik vieno fotoaparato sekas Pasirinkti šią reikšmę; pasirinkus dar kartą ji išvaloma Palikti tik vienos būsenos sekas @@ -72,7 +73,10 @@ Perkurti indeksą iš šalutinių failų; jei jų nėra, nuskaitomi visi metaduomenys; originalai niekada nenaikinami Įtraukti perkūrimą į eilę · archyvu galima naudotis ir tuo metu Pasirinkti naują perkelto archyvo aplanką; jo sekos perkeliamos kartu - Atlikti būtent šiuos aplankų, šalutinių failų ir indekso pakeitimus · po strigties tęsiama + Įtraukti į eilę užduotį, kuri atliks būtent šiuos pakeitimus · ją pristabdyti ir tęsti galima skiltyje Užduotys + Pervardyti nuotraukas pagal šį šabloną · išjungus jos išlaiko savo pavadinimus + Perkelti sekų aplankus į šią struktūrą · išjungus jie lieka savo vietose + Keisti pavadinimus pagal šį šabloną · išjungus jie lieka tokie, kokie yra Pasirinkite indekso atsarginę kopiją skiltyje Parametrai › Išplėstiniai; ji pakeičia indeksą kitą kartą paleidus programą Pakeisti šių sekų žymes šalutiniuose failuose ir indekse Dar kartą atlikti tą patį veiksmą @@ -81,9 +85,8 @@ Atlikti išsamią kiekvienos rinkinio sekos analizę Perkelti rinkinį į archyvo šiukšlinę · parodomas bandomasis vykdymas, tada prašoma patvirtinti įvedant skaičių Eksportuoti rinkinį kaip CSV: po eilutę kiekvienai sekai - Perkelti rinkinį į naują aplankų struktūrą · pirmiausia bandomasis vykdymas Kurti arba atnaujinti tarpines kopijas - Pervardyti rinkinio pavadinimus pagal šabloną · pirmiausia bandomasis vykdymas + Taikyti aplankų, failų ir pavadinimų šablonus rinkiniui · pirmiausia bandomasis vykdymas, tada užduotis Pridėti žymių visam rinkiniui arba jas pašalinti Kurti arba atnaujinti miniatiūras Iš naujo apskaičiuoti rinkinio originalų maišas @@ -478,15 +481,15 @@ Įrašyti {0:N0} eilutes kaip CSV pasirinktame aplanke Įrašyti {0:N0} eilutę kaip CSV pasirinktame aplanke Įrašyti {0:N0} eilučių kaip CSV pasirinktame aplanke - Perkelti {0:N0} sekas į naują jų archyvo aplankų struktūrą · pirmiausia bandomasis vykdymas - Perkelti {0:N0} seką į naują jos archyvo aplankų struktūrą · pirmiausia bandomasis vykdymas - Perkelti {0:N0} sekų į naują jų archyvo aplankų struktūrą · pirmiausia bandomasis vykdymas Kurti {0:N0} sekų JPEG tarpines kopijas · vykdoma kaip viena užduotis Kurti {0:N0} sekos JPEG tarpines kopijas · vykdoma kaip viena užduotis Kurti {0:N0} sekų JPEG tarpines kopijas · vykdoma kaip viena užduotis Nustatyti {0:N0} sekų įvertinimą jų šalutiniuose failuose ir indekse Nustatyti {0:N0} sekos įvertinimą jos šalutiniame faile ir indekse Nustatyti {0:N0} sekų įvertinimą jų šalutiniuose failuose ir indekse + Taikyti archyvo aplankų, failų ir pavadinimų šablonus {0:N0} sekoms · pirmiausia bandomasis vykdymas, tada užduotis + Taikyti archyvo aplankų, failų ir pavadinimų šablonus {0:N0} sekai · pirmiausia bandomasis vykdymas, tada užduotis + Taikyti archyvo aplankų, failų ir pavadinimų šablonus {0:N0} sekų · pirmiausia bandomasis vykdymas, tada užduotis Pridėti arba šalinti {0:N0} sekų žymes Pridėti arba šalinti {0:N0} sekos žymes Pridėti arba šalinti {0:N0} sekų žymes @@ -711,6 +714,7 @@ „Subalansuotas“ tinka daugumai darbų; „Geriausias“ matuoja dviguba skyra ir skaito toliau į priekį; „Greitas“ matuoja perpus mažesne skyra su juodraštiniu judesiu Iš naujo išvardyti koduotuvus įdiegus tvarkyklę ar kodeką Iš naujo ieškoti kodekų plėtinių įdiegus kurį nors iš jų; kitos užduotys juos naudos + Taikyti archyvo šablonus jame jau esančioms sekoms · pirmiausia bandomasis vykdymas Grąžinti visus šio kompiuterio parametrus į numatytąsias reikšmes; prieš tai paklausiama Dabar įrašyti numatytuosius šablonus ir dydžius į šio archyvo failą archive.json Dabar grąžinti visų parametrų numatytąsias reikšmes diff --git a/i18n/lv/Admin.lv.resx b/i18n/lv/Admin.lv.resx index 7e0adeb5..b043a206 100644 --- a/i18n/lv/Admin.lv.resx +++ b/i18n/lv/Admin.lv.resx @@ -9,6 +9,7 @@ Chronos Server Darbības laiks Versija + {0} pārkārtoja arhīvu · {1} {0} mainīja arhīva struktūru {0} izdzēsa: {1} {0} sāka darbu: {1} @@ -147,7 +148,7 @@ Importēšana Ātrā analīze Apkope - Pārvietošana + Pārkārtošana Bāreņfaili Proxy attēli Pārbūve @@ -367,6 +368,7 @@ Pierakstīties, lai administrētu šo serveri Lietotājs Jūsu lietotājvārds šajā serverī + Arhīvs pārkārtots Arhīva struktūra Fotoattēli izdzēsti Darbs sākts @@ -452,6 +454,63 @@ Mainīt paroli Aizstāt paroli un turpināt uz paneli Izvēlieties jaunu paroli + Pārkārtot… + Piemērot mapju, failu un nosaukumu veidnes atlasītajām secībām; vispirms priekšskatījumā redzamas visas izmaiņas + Pēc: + Piemērot… + Pārkārtot, kā redzams priekšskatījumā; vispirms tiek lūgts apstiprinājums + Pirms: + Ierakstiet veidni vai izslēdziet šo daļu. + Aizvērt, neko nemainot + Pārvietojas līdzi + Pārvietojas tikai tāpēc, ka tiek pārvietota mape, kurā tā atrodas + Pārdēvētie faili + Mape + Secība + Pārkārtot + Ievietot rindā darbu, kas pārvieto un pārdēvē oriģinālus; nekas netiek pārrakstīts vai dzēsts + {0} fotoattēlu tiks pārdēvēts. + {0} fotoattēls tiks pārdēvēts. + {0} fotoattēli tiks pārdēvēti. + {0} mapju tiks pārvietots. + {0} mape tiks pārvietota. + {0} mapes tiks pārvietotas. + {0} secību tiks mainīts. + {0} secība tiks mainīta. + {0} secības tiks mainītas. + Pārkārtot tagad? + Katra fotoattēla nosaukums, kādu piešķir importēšana, piemēram, {date}_{time}_{n:0000}; faili blakus fotoattēlam tiek pārdēvēti līdzi + Faili + Pārdēvēt katras secības fotoattēlus; ja izslēgts, visi failu nosaukumi paliek + Pārdēvēts {0} failu + Pārdēvēts {0} fails + Pārdēvēti {0} faili + Katras secības mape arhīvā, piemēram, {year}/{date} {camera}; {title} ir jaunais nosaukums + Mapes + Pārvietot katru secību uz mapi, ko nosaka tās veidne; ja izslēgts, visas mapes paliek savās vietās + Kāda no atlasītajām secībām vairs nav arhīvā; aizveriet un atlasiet vēlreiz. + {0}: {1} + Ieslēdziet vismaz vienu maināmo daļu. + Nav ko mainīt: šīs secības jau atbilst veidnēm. + Pārkārtot… + Piemērot jaunās veidnes secībām, kas jau ir arhīvā; vispirms priekšskatījumā redzamas visas izmaiņas + Atvērt darbu + Rādīt darbu un tā žurnālu lapā Darbi + Apstiprināšanas laikā arhīvs mainījās; pārbaudiet jauno priekšskatījumu un piemērojiet vēlreiz. + Plāno… + Priekšskatījums + Par ko kļūs katra secība, izmaiņu piemērošanas kārtībā; pagaidām nekas nav mainīts + Pārkārtošana ievietota rindā. + Šī mape paliek savā vietā + Pārkārtot {0} secību + Pārkārtot {0} secību + Pārkārtot {0} secības + Pārkārtot visas secības + Katras secības jaunais nosaukums, piemēram, {date} {camera}; {title} ir pašreizējais nosaukums + Nosaukumi + Piešķirt katrai secībai nosaukumu, ko veido tās veidne; ja izslēgts, visi nosaukumi paliek + Vienā reizē pārkārtojamo secību skaits ir ierobežots līdz {0}, ja vien netiek pārkārtotas visas secības: notīriet filtrus un atlasiet visu. + Mainītas secības: {0} · pārdēvēti faili: {1} · saglabāti nosaukumi: {2} Administrators Redaktors Augšupielādētājs diff --git a/i18n/lv/Archive.lv.resx b/i18n/lv/Archive.lv.resx index 4f468e57..b950b3e3 100644 --- a/i18n/lv/Archive.lv.resx +++ b/i18n/lv/Archive.lv.resx @@ -16,6 +16,7 @@ Uzgaidiet, līdz izmaiņas ir piemērotas. Kopa ir tukša: mainiet atlasi vai filtru. Nekas nemainītos. + Ieslēdziet vismaz vienu veidni. Arhīvam jābūt tiešsaistē un rakstāmam. Uzgaidiet, līdz izmēģinājums beidzas. Uzgaidiet, līdz arhīvs ir nolasīts. @@ -91,6 +92,15 @@ {0} ir ierakstījusi jaunāka Chronos versija (formāts {1}). Arhīvs {0} ir bezsaistē. Arhīvs {0} ir tikai lasāms. + {0:N0} secību saglabāja failu nosaukumus: kāds fotoattēls tika izmantots vai tā jaunais nosaukums jau bija aizņemts. + {0:N0} secība saglabāja failu nosaukumus: kāds fotoattēls tika izmantots vai tā jaunais nosaukums jau bija aizņemts. + {0:N0} secības saglabāja failu nosaukumus: kāds fotoattēls tika izmantots vai tā jaunais nosaukums jau bija aizņemts. + {0:N0} secību netika pārkārtots, kā plānots: tās mainījās pēc plāna izveides. + {0:N0} secība netika pārkārtota, kā plānots: tā mainījās pēc plāna izveides. + {0:N0} secības netika pārkārtotas, kā plānots: tās mainījās pēc plāna izveides. + {0:N0} secību saglabāja nosaukumus un failu nosaukumus: to secību faili ir no jaunākas Chronos versijas. + {0:N0} secība saglabāja nosaukumu un failu nosaukumus: tās secības fails ir no jaunākas Chronos versijas. + {0:N0} secības saglabāja nosaukumus un failu nosaukumus: to secību faili ir no jaunākas Chronos versijas. {0} mainījās pēc plāna izveides. Karte vai mape {0} vairs nav pieejama. Arhīvs mainījās pēc šī plāna izveides. @@ -162,6 +172,14 @@ Neindeksēti fotoattēli: {0}, trūkstoši fotoattēli: {1} {0}: izveidoti {1}, atkārtoti izmantoti {2}, nenolasāmi {3}, gaida {4} Proxy attēli serverim: nosūtīti {0}, nenosūtīti {1} + Atstāta kā bija, mape, kurā tā atrodas, palika vietā: {0} + Atstāta kā bija, mainījās pēc plāna izveides: {0} + Failu nosaukumi saglabāti, kāds fotoattēls tika izmantots vai tā jaunais nosaukums bija aizņemts: {0} + Failu nosaukumi saglabāti, fotoattēli mainījās pēc plāna izveides: {0} + Nosaukums un failu nosaukumi saglabāti, secības fails ir no jaunākas Chronos versijas: {0} + Nosaukums un failu nosaukumi saglabāti, mainījās pēc plāna izveides: {0} + Mainītas secības: {0}, pārdēvēti faili: {1} + Pārkārtošana tika pabeigta, atverot arhīvu Tikai pārskats: nekas netika mainīts. Mapes: {0}, indeksētas: {1}, pārņemtas: {2}, noņemtas: {3} Secība nav atrasta: {0} @@ -219,17 +237,34 @@ Pārvietotā arhīva mape Piemērot {0} no {1} - Pārdēvēt {0:N0} secību - Pārdēvēt {0:N0} secību - Pārdēvēt {0:N0} secības - Pārvietot {0:N0} secību - Pārvietot {0:N0} secību - Pārvietot {0:N0} secības Izmaiņas Mainās {0:N0} no {1:N0} Mainās {0:N0} no {1:N0} Mainās {0:N0} no {1:N0} - Veidne + Fotoattēli, kas atstāti savā vietā ārpus mapes originals, saglabā savus nosaukumus. + Trūkstošie fotoattēli saglabā savus nosaukumus. + Nekad neverificēti fotoattēli saglabā savus nosaukumus; vispirms verificējiet secību. + Secības failu nevar nolasīt; secība paliek, kāda ir, tāpat arī jebkura mape, kurā tā atrodas. + Seko savai mapei + {0}: no {1} uz {2} + Fails + Failu nosaukumi + Mape + Mapes + Pārkārtot {0:N0} secību + Pārkārtot {0:N0} secību + Pārkārtot {0:N0} secības + Pārkārtot arhīvu {0} + Saglabāts {0:N0} nosaukumu + Saglabāts {0:N0} nosaukums + Saglabāti {0:N0} nosaukumi + Izmēģinājums… + Pārdēvēts {0:N0} failu + Pārdēvēts {0:N0} fails + Pārdēvēti {0:N0} faili + Nosaukums + Nosaukumi + Pārkārtošana atvērsies, kad tiks aizvērts atvērtais dialogs Pievienot atzīmes Piemērot {0:N0} secību atzīmes @@ -246,9 +281,8 @@ Eksportēt CSV Kopas filtrs Filtrētā kopa - Pārvietot… Veidot proxy - Pārdēvēt… + Pārkārtot… Mainīt atzīmes… Veidot sīktēlus Verificēt diff --git a/i18n/lv/Errors.lv.resx b/i18n/lv/Errors.lv.resx index a14208a0..f80b97b0 100644 --- a/i18n/lv/Errors.lv.resx +++ b/i18n/lv/Errors.lv.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Neanalizētas secības: {0} no {1}; skatiet darba žurnālu. + Šīs secības mape neatrodas tur, kur norāda indekss; mēģiniet vēlreiz pēc nākamās skenēšanas. Arhīvu nevarēja atvērt. Pašreizējo indeksu nevarēja dublēt vai aizstāt; atjaunošana tiks mēģināta vēlreiz nākamajā startēšanas reizē. Šo dublējumu nevar atjaunot; izvēlieties citu. @@ -39,9 +40,11 @@ {0} oriģināli trūkst vai ir mainījušies kopš arhivēšanas; verificējiet arhīvu. Veidne ir tukša. Tukšs vietturis pozīcijā {1}: ierakstiet nosaukumu starp figūriekavām. + Fotoattēli zaudētu paplašinājumu: ierakstiet punktu pirms {ext} vai izlaidiet {ext}. Failu nosaukumos nedrīkst būt slīpsvītra; mapes norādiet mapes veidnē. Formāts pēc kola neatbilst savam vietturim. Nosaukumi atkārtotos: pievienojiet kadra numuru, laiku vai sākotnējo nosaukumu. + Skenēšana izlaiž mapes, kuru nosaukums sākas ar punktu vai ir originals, proxies vai exports. Pozīcijā {1} atvērtā figūriekava netiek aizvērta. Nezināms vietturis „{0}” pozīcijā {1}. Aizverošajai figūriekavai pozīcijā {1} nav atverošās; burtiskai figūriekavai ierakstiet to divreiz. diff --git a/i18n/lv/Jobs.lv.resx b/i18n/lv/Jobs.lv.resx index 3ce0bbc7..5cd4633b 100644 --- a/i18n/lv/Jobs.lv.resx +++ b/i18n/lv/Jobs.lv.resx @@ -77,7 +77,7 @@ Importēšana Ātrā analīze Apkope - Arhīva pārvietošana + Pārkārtošana Bāreņfaili Proxy attēli Indeksa pārbūve diff --git a/i18n/lv/Library.lv.resx b/i18n/lv/Library.lv.resx index 6352d1dd..b24aa079 100644 --- a/i18n/lv/Library.lv.resx +++ b/i18n/lv/Library.lv.resx @@ -10,17 +10,16 @@ Lejupielādēt Eksportēt sarakstu Mape - Pārvietot… Atvērt Veidot proxy Vērtējums Renderēt + Pārkārtot… Sinhronizēt Atzīmes… Augšupielādēt Verificēt Pārņemt mapi - Pārvietošana vienā reizē darbojas tikai ar viena arhīva secībām. Vienāda šajā datorā un serverī: nav ko sinhronizēt. Netiek izmantots neviens saglabātais skats; vispirms izvēlieties kādu. Jūsu servera konts nevar lejupielādēt oriģinālus. @@ -32,6 +31,7 @@ Vispirms servera ekrānā pierakstieties serverī Chronos Server. Atlasītajām secībām no servera nav ko saņemt. Serverī jau ir viss, kas ir atlasītajās secībās. + Pārkārtošana vienlaikus darbojas tikai ar viena arhīva secībām. Tikai secībām šajā datorā; atlase atrodas serverī. Šīs secības pārsūtīšana jau notiek. Notīrīt filtrus diff --git a/i18n/lv/Server.lv.resx b/i18n/lv/Server.lv.resx index 5856ee19..3696e2e4 100644 --- a/i18n/lv/Server.lv.resx +++ b/i18n/lv/Server.lv.resx @@ -40,6 +40,7 @@ Savienojums neizdevās; detalizēta informācija ir žurnālā. Kāds secības fails ir atvērts citā programmā; aizveriet to un mēģiniet vēlreiz. Tās mapes diskā vairs nav; uz atkritni nav ko pārvietot. + Šīs secības mape neatrodas tur, kur norāda servera indekss; mēģiniet vēlreiz pēc nākamās servera skenēšanas. Jūsu konts to nevar darīt. Secības fotoattēli serverī ir mainījušies; ielādējiet secību no jauna un vēlreiz veiciet savas izmaiņas. Fails pienāca bojāts; augšupielādējiet to vēlreiz. @@ -68,11 +69,14 @@ Šis serveris nevar izpildīt šāda veida darbu. Pēdējo administratoru nevar noņemt vai atspējot. Šī metode šeit nav atļauta. + Jaunā mape nonāktu citas secības mapē. Šī adrese nav Chronos Server. Nav atrasts. Vispirms nomainiet paroli. Fotoattēls augšupielādes laikā tika izdzēsts no secības, tāpēc tas netika pievienots. {0} nevar nolasīt, un bez tā jaucējkoda citas kopijas neuzzinātu, ka tas ir izdzēsts; aizveriet programmu, kas to izmanto, vai pārbaudiet tā piekļuves tiesības, pēc tam mēģiniet vēlreiz. + Arhīvs mainījās pēc izmēģinājuma; vēlreiz pārskatiet plānu. + Serveris pārtrauca šī plāna veidošanu: tā aizņēma pārāk ilgu laiku vai vienlaikus tika pieprasīts pārāk daudz plānu; mēģiniet vēlreiz pēc brīža. Šis arhīvs neveido proxy attēlus. Proxy attēls ir izveidots no cita fotoattēla. Serverim nav vajadzīgs šī fotoattēla proxy attēls. diff --git a/i18n/lv/Settings.lv.resx b/i18n/lv/Settings.lv.resx index f3619334..be1c2552 100644 --- a/i18n/lv/Settings.lv.resx +++ b/i18n/lv/Settings.lv.resx @@ -66,6 +66,7 @@ zvaigznes uz megapikseli Analīzes platums px garākajā malā + Mapes un faili, kas jau ir arhīvā, saglabā savus nosaukumus. Failu nosaukumi Mapes brīvi {0} @@ -75,10 +76,12 @@ Izvēlieties arhīva mapi Priekšskatījums Proxy izmērs + Pārkārtot… Atiestatīt arhīva iestatījumus Tā nosaukumu veidnes, proxy attēlu izmērs un sīktēlu izmērs atgriežas pie noklusējuma vērtībām visiem datoriem un serveriem, kas to izmanto. Mapes un faili, kas jau ir arhīvā, saglabā savus nosaukumus. Atiestatīt arhīva {0} iestatījumus? Arhīva mape + Arhīva veidnes saglabātas Sīktēlu izmērs Atpakaļ uz Auto Izvēlēties mapi diff --git a/i18n/lv/Tooltips.lv.resx b/i18n/lv/Tooltips.lv.resx index f4a44443..cc5437ef 100644 --- a/i18n/lv/Tooltips.lv.resx +++ b/i18n/lv/Tooltips.lv.resx @@ -37,6 +37,7 @@ Atvērt pirmās kopijas secību rediģēšanas ekrānā Atrast identiskus fotoattēlus dažādās secībās pēc jaucējkoda · nolasa tikai indeksu Rādīt šī gada secības + Katra fotoattēla faila nosaukums, kādu piešķir importēšana · tiek pārbaudīts rakstot Atstāt tikai vienas kameras secības Izvēlēties šo vērtību; izvēlieties to vēlreiz, lai to notīrītu Atstāt tikai secības vienā stāvoklī @@ -72,7 +73,10 @@ Pārbūvēt indeksu no blakusfailiem; ja to nav, tiek veikta pilna metadatu skenēšana; oriģināli nekad netiek dzēsti Ievietot pārbūvi rindā · arhīvs tikmēr paliek lietojams Izvēlēties pārvietota arhīva jauno mapi; tā secības seko līdzi - Veikt tieši šīs izmaiņas mapēs, blakusfailos un indeksā · pēc avārijas turpinās + Ievietot rindā darbu, kas veiks tieši šīs izmaiņas · to var pauzēt un atsākt sadaļā Darbi + Pārdēvēt fotoattēlus pēc šīs veidnes · ja izslēgts, tie saglabā savus nosaukumus + Pārvietot secību mapes šajā struktūrā · ja izslēgts, tās paliek savās vietās + Mainīt nosaukumus pēc šīs veidnes · ja izslēgts, tie paliek nemainīti Izvēlēties indeksa dublējumu sadaļā Iestatījumi › Papildu; tas aizstāj indeksu nākamajā startēšanas reizē Mainīt šo secību atzīmes blakusfailos un indeksā Vēlreiz izpildīt to pašu darbību @@ -81,9 +85,8 @@ Veikt padziļināto analīzi katrai kopas secībai Pārvietot kopu uz arhīva atkritni · parāda izmēģinājumu, pēc tam lūdz ierakstīt apstiprinājumu Eksportēt kopu kā CSV: viena rinda katrai secībai - Pārvietot kopu jaunā mapju struktūrā · vispirms izmēģinājums Izveidot vai atjaunot proxy attēlus - Pārdēvēt kopas nosaukumus ar veidni · vispirms izmēģinājums + Piemērot mapju, failu un nosaukumu veidnes kopai · vispirms izmēģinājums, tad darbs Pievienot vai noņemt atzīmes visai kopai Izveidot vai atjaunot sīktēlus Atkārtoti aprēķināt kopas oriģinālu jaucējkodus @@ -478,15 +481,15 @@ Saglabāt {0:N0} rindu CSV formātā jūsu izvēlētā mapē Saglabāt {0:N0} rindu CSV formātā jūsu izvēlētā mapē Saglabāt {0:N0} rindas CSV formātā jūsu izvēlētā mapē - Pārvietot {0:N0} secību attiecīgā arhīva jaunā mapju struktūrā · vispirms parāda izmēģinājumu - Pārvietot {0:N0} secību tās arhīva jaunā mapju struktūrā · vispirms parāda izmēģinājumu - Pārvietot {0:N0} secības attiecīgā arhīva jaunā mapju struktūrā · vispirms parāda izmēģinājumu Veidot {0:N0} secību JPEG proxy attēlus · darbojas kā viens darbs Veidot {0:N0} secības JPEG proxy attēlus · darbojas kā viens darbs Veidot {0:N0} secību JPEG proxy attēlus · darbojas kā viens darbs Iestatīt {0:N0} secību vērtējumu to blakusfailos un indeksā Iestatīt {0:N0} secības vērtējumu tās blakusfailā un indeksā Iestatīt {0:N0} secību vērtējumu to blakusfailos un indeksā + Piemērot arhīva mapju, failu un nosaukumu veidnes {0:N0} secībām · vispirms izmēģinājums, tad darbs + Piemērot arhīva mapju, failu un nosaukumu veidnes {0:N0} secībai · vispirms izmēģinājums, tad darbs + Piemērot arhīva mapju, failu un nosaukumu veidnes {0:N0} secībām · vispirms izmēģinājums, tad darbs Pievienot vai noņemt atzīmes {0:N0} secībām Pievienot vai noņemt atzīmes {0:N0} secībai Pievienot vai noņemt atzīmes {0:N0} secībām @@ -711,6 +714,7 @@ „Līdzsvarots” der lielākajai daļai darbu; „Labākais” mēra divkāršā izšķirtspējā un nolasa tālāk uz priekšu; „Ātrs” mēra uz pusi mazākā izšķirtspējā ar aptuvenu kustību Vēlreiz uzskaitīt kodētājus pēc draivera vai kodeka instalēšanas Vēlreiz meklēt kodeku paplašinājumus pēc kāda instalēšanas; nākamie darbi tos izmantos + Piemērot arhīva veidnes secībām, kas jau ir tajā · vispirms izmēģinājums Atiestatīt visus šī datora iestatījumus uz noklusējuma vērtībām; vispirms jautā Tūlīt ierakstīt noklusējuma veidnes un izmērus šī arhīva failā archive.json Tūlīt atiestatīt visus iestatījumus diff --git a/i18n/ms/Admin.ms.resx b/i18n/ms/Admin.ms.resx index 2d375a23..6e64a086 100644 --- a/i18n/ms/Admin.ms.resx +++ b/i18n/ms/Admin.ms.resx @@ -9,6 +9,7 @@ Chronos Server Berjalan selama Versi + {0} menyusun semula arkib · {1} {0} menukar susun atur arkib {0} memadam {1} {0} memulakan {1} @@ -138,7 +139,7 @@ Import Analisis pantas Penyelenggaraan - Pindah + Susun semula Fail yatim Proksi Bina semula @@ -343,6 +344,7 @@ Daftar masuk untuk mentadbir pelayan ini Pengguna Nama pengguna anda pada pelayan ini + Arkib disusun semula Susun atur arkib Foto dipadam Tugas dimulakan @@ -426,6 +428,58 @@ Tukar kata laluan Gantikan kata laluan dan teruskan ke panel Pilih kata laluan baharu + Susun semula… + Gunakan templat folder, fail dan tajuk pada jujukan yang dipilih; pratonton menunjukkan setiap perubahan dahulu + Selepas: + Guna… + Susun semula seperti yang ditunjukkan oleh pratonton; pengesahan diminta dahulu + Sebelum: + Tulis templat, atau matikan bahagian ini. + Tutup tanpa mengubah apa-apa + Turut dipindahkan + Dipindahkan hanya kerana folder yang mengandunginya dipindahkan + Fail dinamakan semula + Folder + Jujukan + Susun semula + Masukkan ke baris gilir tugas yang memindahkan dan menamakan semula fail asal; tiada apa-apa ditulis ganti atau dipadam + {0} foto akan dinamakan semula. + {0} foto akan dinamakan semula. + {0} folder akan dipindahkan. + {0} folder akan dipindahkan. + {0} jujukan akan berubah. + {0} jujukan akan berubah. + Susun semula sekarang? + Nama setiap foto seperti yang diberikan oleh import, cth. {date}_{time}_{n:0000}; fail di sebelah foto turut mengikutnya + Fail + Namakan semula foto setiap jujukan; jika dimatikan, setiap nama fail dikekalkan + {0} fail dinamakan semula + {0} fail dinamakan semula + Folder setiap jujukan dalam arkib, cth. {year}/{date} {camera}; {title} ialah tajuk baharu + Folder + Pindahkan setiap jujukan ke folder yang diberikan oleh templatnya; jika dimatikan, setiap folder kekal di tempatnya + Satu jujukan yang dipilih tiada lagi dalam arkib; tutup dan pilih semula. + {0}: {1} + Hidupkan sekurang-kurangnya satu bahagian untuk diubah. + Tiada apa-apa untuk diubah: jujukan ini sudah mengikut templat. + Susun semula… + Gunakan templat baharu pada jujukan yang sudah ada dalam arkib; pratonton menunjukkan setiap perubahan dahulu + Buka tugas + Tunjukkan tugas dan lognya pada halaman Tugas + Arkib berubah semasa pengesahan; semak pratonton baharu dan gunakan sekali lagi. + Merancang… + Pratonton + Rupa setiap jujukan selepas perubahan, mengikut urutan perubahan digunakan; belum ada apa-apa yang berubah + Susun semula dalam baris gilir. + Folder ini kekal di tempatnya + Susun semula {0} jujukan + Susun semula {0} jujukan + Susun semula semua jujukan + Tajuk baharu setiap jujukan, cth. {date} {camera}; {title} ialah tajuk semasa + Tajuk + Berikan setiap jujukan tajuk yang dibuat oleh templatnya; jika dimatikan, setiap tajuk dikekalkan + Susun semula mengambil paling banyak {0} jujukan sekali gus, atau setiap jujukan: kosongkan penapis dan pilih semua. + Jujukan diubah: {0} · fail dinamakan semula: {1} · nama dikekalkan: {2} Pentadbir Penyunting Pemuat naik diff --git a/i18n/ms/Archive.ms.resx b/i18n/ms/Archive.ms.resx index d6a181b1..47fdaf24 100644 --- a/i18n/ms/Archive.ms.resx +++ b/i18n/ms/Archive.ms.resx @@ -15,6 +15,7 @@ Tunggu sehingga perubahan digunakan. Set ini kosong: ubah pilihan atau penapis. Tiada apa-apa yang akan berubah. + Hidupkan sekurang-kurangnya satu templat. Arkib mesti berada dalam talian dan boleh ditulis. Tunggu larian percubaan selesai. Tunggu sehingga arkib selesai dibaca. @@ -81,6 +82,12 @@ {0} ditulis oleh Chronos yang lebih baharu (format {1}). Arkib {0} berada di luar talian. Arkib {0} hanya boleh dibaca. + {0:N0} jujukan mengekalkan nama failnya: satu foto sedang digunakan atau nama baharunya telah diambil. + {0:N0} jujukan mengekalkan nama failnya: satu foto sedang digunakan atau nama baharunya telah diambil. + {0:N0} jujukan tidak disusun semula seperti yang dirancang: jujukan itu berubah selepas pelan dibuat. + {0:N0} jujukan tidak disusun semula seperti yang dirancang: jujukan itu berubah selepas pelan dibuat. + {0:N0} jujukan mengekalkan tajuk dan nama failnya: fail jujukannya daripada Chronos yang lebih baharu. + {0:N0} jujukan mengekalkan tajuk dan nama failnya: fail jujukannya daripada Chronos yang lebih baharu. {0} berubah selepas pelan dibuat. Kad atau folder {0} tidak lagi tersedia. Arkib berubah selepas pelan ini dibuat. @@ -146,6 +153,14 @@ Foto tidak diindeks: {0}, foto hilang: {1} {0}: dibuat {1}, diguna semula {2}, tidak boleh dibaca {3}, menunggu {4} Proksi untuk pelayan: {0} dihantar, {1} tidak dihantar + Dibiarkan seperti asal, folder yang mengandunginya kekal: {0} + Dibiarkan seperti asal, berubah selepas pelan dibuat: {0} + Nama fail dikekalkan, satu foto sedang digunakan atau nama baharunya telah diambil: {0} + Nama fail dikekalkan, foto berubah selepas pelan dibuat: {0} + Tajuk dan nama fail dikekalkan, fail jujukannya daripada Chronos yang lebih baharu: {0} + Tajuk dan nama fail dikekalkan, berubah selepas pelan dibuat: {0} + Jujukan diubah: {0}, fail dinamakan semula: {1} + Penyusunan semula diselesaikan semasa arkib dibuka Laporan sahaja: tiada apa-apa diubah. Folder: {0}, diindeks: {1}, diterima pakai: {2}, dialih keluar: {3} Jujukan tidak ditemui: {0} @@ -200,14 +215,30 @@ Folder arkib yang dipindahkan Guna {0} daripada {1} - Namakan semula {0:N0} jujukan - Namakan semula {0:N0} jujukan - Pindah {0:N0} jujukan - Pindah {0:N0} jujukan Perubahan {0:N0} daripada {1:N0} berubah {0:N0} daripada {1:N0} berubah - Templat + Foto yang disimpan di tempatnya di luar folder originals mengekalkan namanya. + Foto yang hilang mengekalkan namanya. + Foto yang tidak pernah disahkan mengekalkan namanya; sahkan jujukan dahulu. + Fail jujukan tidak dapat dibaca; jujukan kekal seperti sedia ada, begitu juga mana-mana folder yang mengandunginya. + Mengikut foldernya + {0}: daripada {1} kepada {2} + Fail + Nama fail + Folder + Folder + Susun semula {0:N0} jujukan + Susun semula {0:N0} jujukan + Susun semula {0} + {0:N0} nama dikekalkan + {0:N0} nama dikekalkan + Larian percubaan… + {0:N0} fail dinamakan semula + {0:N0} fail dinamakan semula + Tajuk + Tajuk + Susun semula dibuka apabila dialog yang terbuka ditutup Tambah teg Guna Teg bagi {0:N0} jujukan @@ -222,9 +253,8 @@ Eksport CSV Penapis set Set ditapis - Pindah… Proksi - Namakan semula… + Susun semula… Teg semula… Lakaran kecil Sahkan diff --git a/i18n/ms/Errors.ms.resx b/i18n/ms/Errors.ms.resx index b38f7b74..a6220d76 100644 --- a/i18n/ms/Errors.ms.resx +++ b/i18n/ms/Errors.ms.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Jujukan tidak dianalisis: {0} daripada {1}; lihat log tugas. + Folder jujukan ini tiada di lokasi yang dicatat oleh indeks; cuba semula selepas imbasan seterusnya. Arkib tidak dapat dibuka. Indeks semasa tidak dapat disandarkan atau digantikan; pemulihan akan dijalankan semula pada permulaan seterusnya. Sandaran ini tidak dapat dipulihkan; pilih sandaran lain. @@ -37,9 +38,11 @@ {0} fail asal hilang atau telah berubah sejak diarkibkan; sahkan arkib. Templat kosong. Token kosong pada kedudukan {1}: tulis nama di antara kurungan kerinting. + Foto akan kehilangan sambungan failnya: tulis titik sebelum {ext}, atau buang {ext}. Nama fail tidak boleh mengandungi garis condong; letakkan folder dalam templat folder. Format selepas titik bertindih tidak sesuai dengan tokennya. Nama akan berulang: tambahkan nombor bingkai, masa atau nama asal. + Imbasan melangkau folder yang bermula dengan titik atau bernama originals, proxies atau exports. Kurungan kerinting yang dibuka pada kedudukan {1} tidak pernah ditutup. Token “{0}” tidak diketahui pada kedudukan {1}. Kurungan kerinting penutup pada kedudukan {1} tiada pembukanya; gandakannya untuk kurungan literal. diff --git a/i18n/ms/Jobs.ms.resx b/i18n/ms/Jobs.ms.resx index ab710aeb..35cebbc6 100644 --- a/i18n/ms/Jobs.ms.resx +++ b/i18n/ms/Jobs.ms.resx @@ -76,7 +76,7 @@ Import Analisis pantas Penyelenggaraan - Pindah arkib + Susun semula Fail yatim Proksi Bina semula indeks diff --git a/i18n/ms/Library.ms.resx b/i18n/ms/Library.ms.resx index 95f68c8a..5322e119 100644 --- a/i18n/ms/Library.ms.resx +++ b/i18n/ms/Library.ms.resx @@ -10,17 +10,16 @@ Muat turun Eksport senarai Folder - Pindah… Buka Proksi Penarafan Render + Susun semula… Segerakkan Teg… Muat naik Sahkan Terima pakai folder - Pindah hanya berfungsi pada jujukan daripada satu arkib pada satu masa. Sama pada PC ini dan pada pelayan: tiada apa-apa untuk disegerakkan. Tiada paparan tersimpan yang sedang digunakan; pilih satu dahulu. Akaun pelayan anda tidak boleh memuat turun fail asal. @@ -32,6 +31,7 @@ Daftar masuk ke Chronos Server dahulu, pada skrin Pelayan. Jujukan yang dipilih tiada apa-apa untuk diambil daripada pelayan. Pelayan sudah mempunyai semua kandungan jujukan yang dipilih. + Susun semula berfungsi pada jujukan satu arkib pada satu masa. Hanya untuk jujukan pada PC ini; pilihan ini berada pada pelayan. Pemindahan jujukan ini sudah pun berjalan. Kosongkan penapis diff --git a/i18n/ms/Server.ms.resx b/i18n/ms/Server.ms.resx index 3741b394..466e08c5 100644 --- a/i18n/ms/Server.ms.resx +++ b/i18n/ms/Server.ms.resx @@ -40,6 +40,7 @@ Sambungan gagal; log mengandungi butirannya. Satu fail jujukan ini sedang dibuka dalam program lain; tutup fail itu dan cuba semula. Folder jujukan ini tidak lagi berada pada cakera; tiada apa-apa lagi untuk dipindahkan ke tong sampah. + Folder jujukan ini tiada di lokasi yang dicatat oleh indeks pelayan; cuba semula selepas imbasan seterusnya pada pelayan. Akaun anda tidak boleh melakukan ini. Foto jujukan telah berubah pada pelayan; muat semula jujukan itu dan gunakan semula perubahan anda. Fail tiba dalam keadaan rosak; muat naik semula. @@ -68,11 +69,14 @@ Pelayan ini tidak dapat menjalankan jenis tugas tersebut. Pentadbir terakhir tidak boleh dialih keluar atau dinyahdayakan. Kaedah ini tidak dibenarkan di sini. + Folder baharu akan berada di dalam folder jujukan lain. Alamat itu bukan Chronos Server. Tidak ditemui. Tukar kata laluan anda dahulu. Foto itu dipadam daripada jujukan semasa sedang dimuat naik, jadi ia tidak ditambah. {0} tidak dapat dibaca, dan tanpa cincangannya salinan lain tidak akan mengetahui bahawa ia telah dipadam; tutup program yang menggunakannya atau semak kebenarannya, kemudian cuba semula. + Arkib berubah selepas larian percubaan; semak pelan sekali lagi. + Pelayan berhenti membuat pelan ini: prosesnya terlalu lama, atau terlalu banyak pelan diminta serentak; cuba semula sebentar lagi. Arkib ini tidak membuat proksi. Proksi ini dibuat daripada foto lain. Pelayan tidak memerlukan proksi foto ini. diff --git a/i18n/ms/Settings.ms.resx b/i18n/ms/Settings.ms.resx index c2f72a51..0c830ec0 100644 --- a/i18n/ms/Settings.ms.resx +++ b/i18n/ms/Settings.ms.resx @@ -65,6 +65,7 @@ bintang setiap megapiksel Lebar analisis px sisi panjang + Folder dan fail yang sudah ada dalam arkib mengekalkan namanya. Nama fail Folder {0} kosong @@ -74,10 +75,12 @@ Pilih folder arkib Pratonton Saiz proksi + Susun semula… Tetapkan semula arkib Templat penamaan, saiz proksi dan saiz lakaran kecilnya kembali kepada nilai lalai untuk setiap PC dan pelayan yang menggunakannya. Folder dan fail yang sudah ada dalam arkib mengekalkan namanya. Tetapkan semula tetapan {0}? Folder arkib + Templat arkib disimpan Saiz lakaran kecil Kembali ke Auto Pilih folder diff --git a/i18n/ms/Tooltips.ms.resx b/i18n/ms/Tooltips.ms.resx index 28727db9..5ff15aaf 100644 --- a/i18n/ms/Tooltips.ms.resx +++ b/i18n/ms/Tooltips.ms.resx @@ -36,6 +36,7 @@ Buka jujukan salinan pertama pada skrin Edit Cari foto yang identik merentasi jujukan melalui cincangan · membaca indeks sahaja Tunjukkan jujukan tahun ini + Nama fail setiap foto, seperti yang diberikan oleh import · disemak semasa anda menaip Kekalkan hanya jujukan daripada satu kamera Pilih nilai ini; pilih sekali lagi untuk mengosongkannya Kekalkan hanya jujukan dalam satu keadaan @@ -71,7 +72,10 @@ Bina semula indeks daripada fail sidecar; beralih kepada imbasan metadata penuh jika perlu; tidak pernah memadam fail asal Masukkan pembinaan semula ke baris gilir · arkib kekal boleh digunakan sementara itu Pilih folder baharu bagi arkib yang anda pindahkan; jujukannya turut dipaut semula - Buat perubahan ini dengan tepat pada folder, fail sidecar dan indeks · disambung semula selepas ranap + Masukkan ke baris gilir tugas yang membuat tepat perubahan ini · jeda dan sambung semula tugas itu dalam Tugas + Namakan semula foto dengan templat ini · jika dimatikan, foto mengekalkan namanya + Pindahkan folder jujukan ke dalam susun atur ini · jika dimatikan, folder kekal di tempatnya + Tukar tajuk dengan templat ini · jika dimatikan, tajuk kekal seperti sedia ada Pilih sandaran indeks dalam Tetapan › Lanjutan; sandaran itu menggantikan indeks pada permulaan seterusnya Tukar teg jujukan ini dalam fail sidecar dan indeks Jalankan tindakan yang sama sekali lagi @@ -80,9 +84,8 @@ Jalankan analisis mendalam pada setiap jujukan dalam set Pindahkan set ke tong sampah arkib · menunjukkan larian percubaan, kemudian meminta anda menaip untuk mengesahkan Eksport set sebagai CSV: satu baris bagi setiap jujukan - Pindahkan set ke susun atur folder baharu · larian percubaan dahulu Jana atau segar semula proksi - Namakan semula tajuk dalam set dengan templat · larian percubaan dahulu + Gunakan templat folder, fail dan tajuk pada set · larian percubaan dahulu, kemudian satu tugas Tambah atau alih keluar teg pada keseluruhan set Jana atau segar semula lakaran kecil Cincang semula fail asal dalam set @@ -471,12 +474,12 @@ Ambil daripada pelayan apa yang tiada di sini bagi {0:N0} jujukan (fail asal atau hasil render) · berjalan sebagai tugas pemindahan Simpan {0:N0} baris sebagai CSV dalam folder pilihan anda Simpan {0:N0} baris sebagai CSV dalam folder pilihan anda - Pindahkan {0:N0} jujukan ke susun atur folder baharu dalam arkibnya · larian percubaan dahulu - Pindahkan {0:N0} jujukan ke susun atur folder baharu dalam arkibnya · larian percubaan dahulu Bina proksi JPEG bagi {0:N0} jujukan · berjalan sebagai satu tugas Bina proksi JPEG bagi {0:N0} jujukan · berjalan sebagai satu tugas Tetapkan penarafan {0:N0} jujukan, dalam fail sidecar dan indeks Tetapkan penarafan {0:N0} jujukan, dalam fail sidecar dan indeks + Gunakan templat folder, fail dan tajuk arkibnya pada {0:N0} jujukan · larian percubaan dahulu, kemudian satu tugas + Gunakan templat folder, fail dan tajuk arkibnya pada {0:N0} jujukan · larian percubaan dahulu, kemudian satu tugas Tambah atau alih keluar teg pada {0:N0} jujukan Tambah atau alih keluar teg pada {0:N0} jujukan Hantar apa yang tiada pada pelayan bagi {0:N0} jujukan (fail asal dan tetapan, atau hasil render) · berjalan sebagai tugas pemindahan @@ -692,6 +695,7 @@ Seimbang sesuai untuk kebanyakan kerja; Terbaik mengukur pada resolusi berganda dan membaca lebih jauh ke hadapan; Pantas mengukur pada separuh resolusi dengan gerakan draf Senaraikan pengekod sekali lagi selepas pemacu atau kodek dipasang Cari sambungan kodek sekali lagi selepas memasangnya; tugas seterusnya akan menggunakannya + Gunakan templat arkib pada jujukan yang sudah ada di dalamnya · larian percubaan dahulu Kembalikan setiap tetapan PC ini kepada nilai lalainya; bertanya dahulu Tulis templat dan saiz lalai ke dalam archive.json arkib ini sekarang Tetapkan semula setiap tetapan sekarang diff --git a/i18n/nb/Admin.nb.resx b/i18n/nb/Admin.nb.resx index e1781ed2..6f12f551 100644 --- a/i18n/nb/Admin.nb.resx +++ b/i18n/nb/Admin.nb.resx @@ -9,6 +9,7 @@ Chronos Server Oppetid Versjon + {0} omorganiserte arkivet · {1} {0} endret arkivoppsettet {0} slettet {1} {0} startet {1} @@ -138,7 +139,7 @@ Import Hurtiganalyse Vedlikehold - Flytting + Omorganisering Foreldreløse filer Proxyer Gjenoppbygging @@ -343,6 +344,7 @@ Logg på for å administrere denne serveren Bruker Brukernavnet ditt på denne serveren + Arkiv omorganisert Arkivoppsett Bilder slettet Jobb startet @@ -426,6 +428,58 @@ Endre passord Bytt ut passordet og gå videre til panelet Velg et nytt passord + Omorganiser… + Bruk mappe-, filnavn- og tittelmaler på de valgte sekvensene; en forhåndsvisning viser alle endringene først + Etter: + Bruk… + Omorganiser slik forhåndsvisningen viser; du blir bedt om å bekrefte først + Før: + Skriv en mal, eller slå av denne delen. + Lukk uten å endre noe + Følger med + Flyttes bare fordi en mappe den ligger i, flyttes + Nye filnavn + Mappe + Sekvens + Omorganiser + Legg jobben som flytter originalene og gir dem nye navn, i kø; ingenting blir overskrevet eller slettet + {0} bilde får nytt navn. + {0} bilder får nye navn. + {0} mappe flyttes. + {0} mapper flyttes. + {0} sekvens endres. + {0} sekvenser endres. + Omorganisere nå? + Navnet på hvert bilde slik en import gir det, f.eks. {date}_{time}_{n:0000}; filene ved siden av et bilde følger med + Filer + Gi bildene i hver sekvens nye navn; når delen er slått av, beholder alle filer navnet sitt + {0} fil har fått nytt navn + {0} filer har fått nytt navn + Mappen til hver sekvens i arkivet, f.eks. {year}/{date} {camera}; {title} er den nye tittelen + Mapper + Flytt hver sekvens til mappen malen angir; når delen er slått av, blir alle mapper der de er + En valgt sekvens er ikke lenger i arkivet; lukk og velg på nytt. + {0}: {1} + Slå på minst én del som skal endres. + Ingenting å endre: disse sekvensene følger allerede malene. + Omorganiser… + Bruk de nye malene på sekvensene som allerede ligger i arkivet; en forhåndsvisning viser alle endringene først + Åpne jobb + Vis jobben og loggen på Jobber-siden + Arkivet ble endret under bekreftelsen; kontroller den nye forhåndsvisningen og bruk endringene på nytt. + Planlegger… + Forhåndsvisning + Hva hver sekvens blir, i den rekkefølgen endringene tas i bruk; ingenting er endret ennå + Omorganiseringen er satt i kø. + Denne mappen blir der den er + Omorganiser {0} sekvens + Omorganiser {0} sekvenser + Omorganiser alle sekvenser + Ny tittel for hver sekvens, f.eks. {date} {camera}; {title} er den nåværende tittelen + Titler + Gi hver sekvens tittelen malen lager; når delen er slått av, beholdes alle titler + Omorganisering tar høyst {0} sekvenser om gangen, eller alle sekvensene: fjern filtrene og velg alle. + Sekvenser endret: {0} · filer med nytt navn: {1} · navn beholdt: {2} Administrator Redaktør Opplaster diff --git a/i18n/nb/Archive.nb.resx b/i18n/nb/Archive.nb.resx index 8e179dee..0d8c0ff5 100644 --- a/i18n/nb/Archive.nb.resx +++ b/i18n/nb/Archive.nb.resx @@ -15,6 +15,7 @@ Vent til endringene er tatt i bruk. Settet er tomt: endre utvalget eller filteret. Ingenting ville blitt endret. + Slå på minst én mal. Arkivet må være tilkoblet og skrivbart. Vent på prøvekjøringen. Vent til arkivet er lest. @@ -81,6 +82,12 @@ {0} ble skrevet av en nyere Chronos (format {1}). Arkivet {0} er frakoblet. Arkivet {0} er skrivebeskyttet. + {0:N0} sekvens beholdt filnavnene sine: et bilde var i bruk, eller det nye navnet var opptatt. + {0:N0} sekvenser beholdt filnavnene sine: et bilde var i bruk, eller det nye navnet var opptatt. + {0:N0} sekvens ble ikke omorganisert som planlagt: den ble endret etter at planen ble laget. + {0:N0} sekvenser ble ikke omorganisert som planlagt: de ble endret etter at planen ble laget. + {0:N0} sekvens beholdt tittelen og filnavnene: sekvensfilen er fra en nyere Chronos. + {0:N0} sekvenser beholdt titlene og filnavnene: sekvensfilene er fra en nyere Chronos. {0} ble endret etter at planen ble laget. Kortet eller mappen {0} er ikke lenger tilgjengelig. Arkivet ble endret etter at denne planen ble laget. @@ -146,6 +153,14 @@ Uindekserte bilder: {0}, manglende bilder: {1} {0}: laget {1}, gjenbrukt {2}, uleselige {3}, venter {4} Proxyer til serveren: {0} sendt, {1} ikke sendt + Latt urørt, mappen den ligger i, ble ikke flyttet: {0} + Latt urørt, endret etter at planen ble laget: {0} + Filnavn beholdt, et bilde var i bruk, eller det nye navnet var opptatt: {0} + Filnavn beholdt, bilder ble endret etter at planen ble laget: {0} + Tittel og filnavn beholdt, sekvensfilen er fra en nyere Chronos: {0} + Tittel og filnavn beholdt, endret etter at planen ble laget: {0} + Sekvenser endret: {0}, filer med nytt navn: {1} + Omorganiseringen ble fullført da arkivet ble åpnet Bare rapport: ingenting ble endret. Mapper: {0}, indeksert: {1}, overtatt: {2}, fjernet: {3} Fant ikke sekvensen: {0} @@ -200,14 +215,30 @@ Mappen til det flyttede arkivet Bruk {0} av {1} - Gi nytt navn til {0:N0} sekvens - Gi nytt navn til {0:N0} sekvenser - Flytt {0:N0} sekvens - Flytt {0:N0} sekvenser Endringer {0:N0} av {1:N0} endres {0:N0} av {1:N0} endres - Mal + Bilder som ligger på stedet utenfor originals, beholder navnene sine. + Manglende bilder beholder navnene sine. + Bilder som aldri er verifisert, beholder navnene sine; verifiser sekvensen først. + Sekvensfilen kan ikke leses; sekvensen blir som den er, og det samme gjør alle mapper den ligger i. + Følger mappen sin + {0}: fra {1} til {2} + Fil + Filnavn + Mappe + Mapper + Omorganiser {0:N0} sekvens + Omorganiser {0:N0} sekvenser + Omorganiser {0} + {0:N0} navn beholdt + {0:N0} navn beholdt + Prøvekjøring… + {0:N0} fil har fått nytt navn + {0:N0} filer har fått nytt navn + Tittel + Titler + Omorganisering åpnes når dialogboksen som er åpen, lukkes Legg til etiketter Bruk Etiketter for {0:N0} sekvens @@ -222,9 +253,8 @@ Eksporter CSV Filter for settet Filtrert sett - Flytt… Proxyer - Gi nytt navn… + Omorganiser… Endre etiketter… Miniatyrbilder Verifiser diff --git a/i18n/nb/Errors.nb.resx b/i18n/nb/Errors.nb.resx index f5ed634a..e64f609f 100644 --- a/i18n/nb/Errors.nb.resx +++ b/i18n/nb/Errors.nb.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Sekvenser som ikke ble analysert: {0} av {1}; se jobbloggen. + Mappen til denne sekvensen ligger ikke der indeksen sier; prøv på nytt etter neste skanning. Arkivet kunne ikke åpnes. Den gjeldende indeksen kunne ikke sikkerhetskopieres eller erstattes; gjenopprettingen kjøres på nytt ved neste oppstart. Denne sikkerhetskopien kan ikke gjenopprettes; velg en annen. @@ -37,9 +38,11 @@ {0} originaler mangler eller er endret siden de ble arkivert; verifiser arkivet. Malen er tom. Tom plassholder på posisjon {1}: skriv et navn mellom klammeparentesene. + Bildene ville mistet filtypen: skriv et punktum foran {ext}, eller utelat {ext}. Filnavn kan ikke inneholde skråstrek; legg mapper i mappemalen. Formatet etter kolonet passer ikke til plassholderen. Navnene ville gjentatt seg: legg til bildenummeret, klokkeslettet eller originalnavnet. + Skanninger hopper over mapper som starter med punktum eller heter originals, proxies eller exports. Klammeparentesen som åpnes på posisjon {1}, lukkes aldri. Ukjent plassholder «{0}» på posisjon {1}. Den avsluttende klammeparentesen på posisjon {1} har ingen åpnende; skriv den to ganger for å få en vanlig klammeparentes. diff --git a/i18n/nb/Jobs.nb.resx b/i18n/nb/Jobs.nb.resx index 328b839d..8e475b71 100644 --- a/i18n/nb/Jobs.nb.resx +++ b/i18n/nb/Jobs.nb.resx @@ -76,7 +76,7 @@ Import Hurtiganalyse Vedlikehold - Flytting av arkiv + Omorganisering Foreldreløse filer Proxyer Gjenoppbygging av indeks diff --git a/i18n/nb/Library.nb.resx b/i18n/nb/Library.nb.resx index e63c8537..5d8a8446 100644 --- a/i18n/nb/Library.nb.resx +++ b/i18n/nb/Library.nb.resx @@ -10,17 +10,16 @@ Last ned Eksporter liste Mappe - Flytt… Åpne Proxyer Vurdering Rendre + Omorganiser… Synkroniser Etiketter… Last opp Verifiser Overta en mappe - Du kan bare flytte sekvenser fra ett arkiv om gangen. Identisk på denne PC-en og på serveren: ingenting å synkronisere. Ingen lagret visning er i bruk; velg en først. Serverkontoen din kan ikke laste ned originaler. @@ -32,6 +31,7 @@ Logg på en Chronos Server først, på Server-skjermen. De valgte sekvensene har ingenting å hente fra serveren. Serveren har allerede det de valgte sekvensene inneholder. + Omorganisering virker på sekvensene i ett arkiv om gangen. Bare for sekvenser på denne PC-en; utvalget ligger på serveren. En overføring av denne sekvensen pågår allerede. Fjern filtre diff --git a/i18n/nb/Server.nb.resx b/i18n/nb/Server.nb.resx index c21a45a0..88efcc73 100644 --- a/i18n/nb/Server.nb.resx +++ b/i18n/nb/Server.nb.resx @@ -40,6 +40,7 @@ Tilkoblingen mislyktes; loggen har detaljene. En fil i sekvensen er åpen i et annet program; lukk den og prøv på nytt. Mappen finnes ikke lenger på disken; det er ingenting igjen å flytte til papirkurven. + Mappen til denne sekvensen ligger ikke der serverens indeks sier; prøv på nytt etter serverens neste skanning. Kontoen din kan ikke gjøre dette. Bildene i sekvensen ble endret på serveren; last den inn på nytt og gjør endringen din igjen. Filen kom frem skadet; last den opp på nytt. @@ -68,11 +69,14 @@ Denne serveren kan ikke kjøre den typen jobb. Den siste administratoren kan ikke fjernes eller deaktiveres. Denne metoden er ikke tillatt her. + En ny mappe ville ligget inne i mappen til en annen sekvens. Den adressen er ikke en Chronos Server. Ikke funnet. Endre passordet ditt først. Bildet ble slettet fra sekvensen mens det ble lastet opp, så det ble ikke lagt til. {0} kan ikke leses, og uten hashen ville ikke andre kopier få vite at den ble slettet; lukk programmet som bruker den, eller kontroller rettighetene til den, og prøv deretter på nytt. + Arkivet ble endret etter prøvekjøringen; se gjennom planen på nytt. + Serveren sluttet å lage denne planen: det tok for lang tid, eller det ble bedt om for mange samtidig; prøv på nytt om litt. Dette arkivet lager ingen proxyer. Proxyen ble laget fra et annet bilde. Serveren trenger ikke en proxy av dette bildet. diff --git a/i18n/nb/Settings.nb.resx b/i18n/nb/Settings.nb.resx index a91cf84c..28829fb9 100644 --- a/i18n/nb/Settings.nb.resx +++ b/i18n/nb/Settings.nb.resx @@ -65,6 +65,7 @@ stjerner per megapiksel Analysebredde px på langsiden + Mapper og filer som allerede ligger i arkivet, beholder navnene sine. Filnavn Mapper {0} ledig @@ -74,10 +75,12 @@ Velg arkivmappen Forhåndsvisning Proxystørrelse + Omorganiser… Tilbakestill arkivet Navnemaler, proxystørrelse og størrelse på miniatyrbilder går tilbake til standardverdiene for alle PC-er og servere som bruker arkivet. Mapper og filer som allerede ligger i arkivet, beholder navnene sine. Tilbakestille innstillingene for {0}? Arkivmappe + Arkivmalene er lagret Miniatyrbildestørrelse Tilbake til Auto Velg mappe diff --git a/i18n/nb/Tooltips.nb.resx b/i18n/nb/Tooltips.nb.resx index c3f8dba2..bb2ead5e 100644 --- a/i18n/nb/Tooltips.nb.resx +++ b/i18n/nb/Tooltips.nb.resx @@ -36,6 +36,7 @@ Åpne sekvensen til den første kopien i Redigering Finn identiske bilder på tvers av sekvenser etter hash · leser bare indeksen Vis sekvensene fra dette året + Filnavnet på hvert bilde, slik importer navngir dem · kontrolleres mens du skriver Behold bare sekvensene fra ett kamera Velg denne verdien; velg den igjen for å fjerne den Behold bare sekvensene i én tilstand @@ -71,7 +72,10 @@ Gjenoppbygg indeksen fra sidecar-filene; faller tilbake på en full metadataskanning; sletter aldri originaler Legg gjenoppbyggingen i kø · arkivet kan brukes i mellomtiden Velg den nye mappen til et arkiv du har flyttet; sekvensene følger med - Gjør nøyaktig disse endringene i mapper, sidecar-filer og indeks · fortsetter etter et krasj + Legg i kø en jobb som gjør nøyaktig disse endringene · sett den på pause og gjenoppta den i Jobber + Gi bildene nye navn med denne malen · slått av: de beholder navnene sine + Flytt sekvensmappene inn i denne strukturen · slått av: de blir der de er + Endre titlene med denne malen · slått av: de forblir som de er Velg en sikkerhetskopi av indeksen i Innstillinger › Avansert; den erstatter indeksen ved neste oppstart Endre etikettene til disse sekvensene i sidecar-filer og indeks Kjør den samme handlingen på nytt @@ -80,9 +84,8 @@ Kjør dybdeanalysen på alle sekvensene i settet Flytt settet til arkivets papirkurv · viser prøvekjøringen og ber deg deretter skrive inn en bekreftelse Eksporter settet som CSV: én rad per sekvens - Flytt settet inn i en ny mappestruktur · prøvekjøring først Lag eller oppdater proxyer - Endre titlene i settet med en mal · prøvekjøring først + Bruk mappe-, filnavn- og tittelmaler på settet · prøvekjøring først, deretter en jobb Legg til eller fjern etiketter på hele settet Lag eller oppdater miniatyrbilder Beregn hashen for originalene i settet på nytt @@ -471,12 +474,12 @@ Hent fra serveren det som mangler her av {0:N0} sekvenser (originaler eller renderinger) · kjører som overføringsjobber Lagre {0:N0} rad som CSV i en mappe du velger Lagre {0:N0} rader som CSV i en mappe du velger - Flytt {0:N0} sekvens inn i en ny mappestruktur i arkivet · viser prøvekjøringen først - Flytt {0:N0} sekvenser inn i en ny mappestruktur i arkivet · viser prøvekjøringen først Lag JPEG-proxyer for {0:N0} sekvens · kjører som én jobb Lag JPEG-proxyer for {0:N0} sekvenser · kjører som én jobb Angi vurderingen for {0:N0} sekvens, i sidecar-filen og i indeksen Angi vurderingen for {0:N0} sekvenser, i sidecar-filene og i indeksen + Bruk mappe-, filnavn- og tittelmaler på {0:N0} sekvens i arkivet · prøvekjøring først, deretter en jobb + Bruk mappe-, filnavn- og tittelmaler på {0:N0} sekvenser i arkivet · prøvekjøring først, deretter en jobb Legg til eller fjern etiketter på {0:N0} sekvens Legg til eller fjern etiketter på {0:N0} sekvenser Send det serveren mangler av {0:N0} sekvens (originaler og innstillinger, eller renderinger) · kjører som en overføringsjobb @@ -692,6 +695,7 @@ Balansert passer til det meste; Beste måler med dobbel oppløsning og leser lenger frem; Rask måler med halv oppløsning og flytkvaliteten Utkast List opp koderne på nytt etter installasjon av en driver eller kodek Se etter kodekutvidelser på nytt etter at du har installert en; de neste jobbene bruker dem + Bruk arkivets maler på sekvensene som allerede ligger i det · prøvekjøring først Tilbakestill alle innstillinger på denne PC-en til standardverdiene; spør først Skriv standardmalene og -størrelsene til archive.json i dette arkivet nå Tilbakestill alle innstillinger nå diff --git a/i18n/nl/Admin.nl.resx b/i18n/nl/Admin.nl.resx index c885b048..ca4bb25d 100644 --- a/i18n/nl/Admin.nl.resx +++ b/i18n/nl/Admin.nl.resx @@ -9,6 +9,7 @@ Chronos Server Bedrijfstijd Versie + {0} heeft het archief gereorganiseerd · {1} {0} heeft de archiefindeling gewijzigd {0} heeft {1} verwijderd {0} heeft {1} gestart @@ -138,7 +139,7 @@ Import Snelle analyse Onderhoud - Verplaatsen + Reorganisatie Verweesde bestanden Proxy's Opnieuw opbouwen @@ -343,6 +344,7 @@ Meld je aan om deze server te beheren Gebruiker Je gebruikersnaam op deze server + Archief gereorganiseerd Archiefindeling Foto's verwijderd Taak gestart @@ -426,6 +428,58 @@ Wachtwoord wijzigen Vervang het wachtwoord en ga verder naar het paneel Kies een nieuw wachtwoord + Reorganiseren… + Pas map-, bestands- en titelsjablonen toe op de geselecteerde reeksen; een voorbeeld toont eerst elke wijziging + Na: + Toepassen… + Reorganiseer zoals het voorbeeld toont; eerst wordt om bevestiging gevraagd + Voor: + Schrijf een sjabloon, of schakel dit onderdeel uit. + Sluit zonder iets te wijzigen + Gaat mee + Wordt alleen verplaatst omdat een map waarin de reeks staat, wordt verplaatst + Hernoemde bestanden + Map + Reeks + Reorganiseren + Plaats de taak die de originelen verplaatst en hernoemt in de wachtrij; er wordt niets overschreven of verwijderd + {0} foto krijgt een nieuwe naam. + {0} foto's krijgen een nieuwe naam. + {0} map wordt verplaatst. + {0} mappen worden verplaatst. + {0} reeks wordt gewijzigd. + {0} reeksen worden gewijzigd. + Nu reorganiseren? + Naam van elke foto zoals een import die geeft, bijvoorbeeld {date}_{time}_{n:0000}; de bestanden naast een foto worden mee hernoemd + Bestanden + Hernoem de foto's van elke reeks; als dit uit staat, behoudt elk bestand zijn naam + {0} bestand hernoemd + {0} bestanden hernoemd + Map van elke reeks in het archief, bijvoorbeeld {year}/{date} {camera}; {title} is de nieuwe titel + Mappen + Verplaats elke reeks naar de map die het sjabloon aangeeft; als dit uit staat, blijft elke map waar die is + Een geselecteerde reeks staat niet meer in het archief; sluit en selecteer opnieuw. + {0}: {1} + Schakel ten minste één onderdeel in om te wijzigen. + Niets te wijzigen: deze reeksen volgen de sjablonen al. + Reorganiseren… + Pas de nieuwe sjablonen toe op de reeksen die al in het archief staan; een voorbeeld toont eerst elke wijziging + Taak openen + Toon de taak en het logboek ervan op de pagina Taken + Het archief is tijdens de bevestiging gewijzigd; controleer het nieuwe voorbeeld en pas opnieuw toe. + Plan wordt gemaakt… + Voorbeeld + Wat elke reeks wordt, in de volgorde waarin de wijzigingen worden toegepast; er is nog niets gewijzigd + Reorganisatie in wachtrij geplaatst. + Deze map blijft waar die is + {0} reeks reorganiseren + {0} reeksen reorganiseren + Alle reeksen reorganiseren + Nieuwe titel van elke reeks, bijvoorbeeld {date} {camera}; {title} is de huidige titel + Titels + Geef elke reeks de titel die het sjabloon maakt; als dit uit staat, blijft elke titel behouden + Reorganiseren verwerkt maximaal {0} reeksen tegelijk, of alle reeksen: wis de filters en selecteer alles. + Gewijzigde reeksen: {0} · hernoemde bestanden: {1} · behouden namen: {2} Beheerder Bewerker Uploader diff --git a/i18n/nl/Archive.nl.resx b/i18n/nl/Archive.nl.resx index 7235941a..786f63ba 100644 --- a/i18n/nl/Archive.nl.resx +++ b/i18n/nl/Archive.nl.resx @@ -15,6 +15,7 @@ Wacht tot de wijzigingen zijn toegepast. De set is leeg: wijzig de selectie of het filter. Er zou niets veranderen. + Schakel ten minste één sjabloon in. Het archief moet online en beschrijfbaar zijn. Wacht op de proefrun. Wacht tot het archief is gelezen. @@ -81,6 +82,12 @@ {0} is geschreven door een nieuwere Chronos (indeling {1}). Het archief {0} is offline. Het archief {0} is alleen-lezen. + {0:N0} reeks heeft de bestandsnamen behouden: een foto was in gebruik of de nieuwe naam ervan was al bezet. + {0:N0} reeksen hebben hun bestandsnamen behouden: een foto was in gebruik of de nieuwe naam ervan was al bezet. + {0:N0} reeks is niet volgens plan gereorganiseerd: die is gewijzigd nadat het plan is gemaakt. + {0:N0} reeksen zijn niet volgens plan gereorganiseerd: ze zijn gewijzigd nadat het plan is gemaakt. + {0:N0} reeks heeft de titel en bestandsnamen behouden: het reeksbestand is van een nieuwere Chronos. + {0:N0} reeksen hebben hun titels en bestandsnamen behouden: de reeksbestanden zijn van een nieuwere Chronos. {0} is gewijzigd nadat het plan is gemaakt. De kaart of map {0} is niet meer beschikbaar. Het archief is gewijzigd nadat dit plan is gemaakt. @@ -146,6 +153,14 @@ Niet-geïndexeerde foto's: {0}, ontbrekende foto's: {1} {0}: gemaakt {1}, hergebruikt {2}, onleesbaar {3}, wachtend {4} Proxy's voor de server: {0} verzonden, {1} niet verzonden + Ongemoeid gelaten, de bovenliggende map is niet verplaatst: {0} + Ongemoeid gelaten, gewijzigd na het plan: {0} + Bestandsnamen behouden, een foto was in gebruik of de nieuwe naam was al bezet: {0} + Bestandsnamen behouden, foto's gewijzigd na het plan: {0} + Titel en bestandsnamen behouden, het reeksbestand is van een nieuwere Chronos: {0} + Titel en bestandsnamen behouden, gewijzigd na het plan: {0} + Gewijzigde reeksen: {0}, hernoemde bestanden: {1} + De reorganisatie is voltooid toen het archief werd geopend Alleen rapport: er is niets gewijzigd. Mappen: {0}, geïndexeerd: {1}, opgenomen: {2}, verwijderd: {3} Reeks niet gevonden: {0} @@ -200,14 +215,30 @@ Map van het verplaatste archief Toepassen {0} van {1} - Naam van {0:N0} reeks wijzigen - Namen van {0:N0} reeksen wijzigen - {0:N0} reeks verplaatsen - {0:N0} reeksen verplaatsen Wijzigingen {0:N0} van {1:N0} verandert {0:N0} van {1:N0} veranderen - Sjabloon + Foto's die ter plaatse buiten originals worden bewaard, behouden hun naam. + Ontbrekende foto's behouden hun naam. + Foto's die nooit zijn geverifieerd, behouden hun naam; verifieer eerst de reeks. + Het reeksbestand kan niet worden gelezen; de reeks blijft zoals die is, en dat geldt ook voor elke map waarin die staat. + Volgt de map + {0}: van {1} naar {2} + Bestand + Bestandsnamen + Map + Mappen + {0:N0} reeks reorganiseren + {0:N0} reeksen reorganiseren + {0} reorganiseren + {0:N0} naam behouden + {0:N0} namen behouden + Proefrun… + {0:N0} bestand hernoemd + {0:N0} bestanden hernoemd + Titel + Titels + Reorganiseren wordt geopend zodra het geopende dialoogvenster is gesloten Tags toevoegen Toepassen Tags van {0:N0} reeks @@ -222,9 +253,8 @@ CSV exporteren Filter van de set Gefilterde set - Verplaatsen… Proxy's - Naam wijzigen… + Reorganiseren… Tags wijzigen… Miniaturen Verifiëren diff --git a/i18n/nl/Errors.nl.resx b/i18n/nl/Errors.nl.resx index a07e5caf..8faa0543 100644 --- a/i18n/nl/Errors.nl.resx +++ b/i18n/nl/Errors.nl.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Niet-geanalyseerde reeksen: {0} van {1}; zie het taaklogboek. + De map van deze reeks staat niet waar de index die aangeeft; probeer het opnieuw na de volgende scan. Het archief kan niet worden geopend. Er kon geen back-up van de huidige index worden gemaakt of de index kon niet worden vervangen; het terugzetten wordt bij de volgende start opnieuw uitgevoerd. Deze back-up kan niet worden teruggezet; kies een andere. @@ -37,9 +38,11 @@ {0} originelen ontbreken of zijn gewijzigd sinds ze zijn gearchiveerd; verifieer het archief. Het sjabloon is leeg. Lege variabele op positie {1}: schrijf een naam tussen de accolades. + De foto's zouden hun extensie kwijtraken: typ een punt vóór {ext}, of laat {ext} weg. Bestandsnamen mogen geen slash bevatten; zet mappen in het mapsjabloon. De indeling na de dubbele punt past niet bij de variabele. Namen zouden dubbel voorkomen: voeg het framenummer, de tijd of de oorspronkelijke naam toe. + Scans slaan mappen over die met een punt beginnen of originals, proxies of exports heten. De accolade die op positie {1} wordt geopend, wordt nooit gesloten. Onbekende variabele “{0}” op positie {1}. De sluitende accolade op positie {1} heeft geen openingsaccolade; typ hem dubbel voor een letterlijke accolade. diff --git a/i18n/nl/Jobs.nl.resx b/i18n/nl/Jobs.nl.resx index f2fb6f6b..3971045e 100644 --- a/i18n/nl/Jobs.nl.resx +++ b/i18n/nl/Jobs.nl.resx @@ -76,7 +76,7 @@ Import Snelle analyse Onderhoud - Archief verplaatsen + Reorganisatie Verweesde bestanden Proxy's Index opnieuw opbouwen diff --git a/i18n/nl/Library.nl.resx b/i18n/nl/Library.nl.resx index 5d3a7b44..08489ebd 100644 --- a/i18n/nl/Library.nl.resx +++ b/i18n/nl/Library.nl.resx @@ -10,17 +10,16 @@ Downloaden Lijst exporteren Map - Verplaatsen… Openen Proxy's Beoordeling Renderen + Reorganiseren… Synchroniseren Tags… Uploaden Verifiëren Een map opnemen - Verplaatsen werkt met de reeksen van één archief tegelijk. Hetzelfde op deze pc en op de server: niets te synchroniseren. Er is geen opgeslagen weergave in gebruik; kies er eerst een. Je serveraccount kan geen originelen downloaden. @@ -32,6 +31,7 @@ Meld je eerst aan bij een Chronos Server, op het scherm Server. Er valt voor de geselecteerde reeksen niets van de server op te halen. De server heeft al wat de geselecteerde reeksen bevatten. + Reorganiseren werkt steeds op de reeksen van één archief. Alleen voor reeksen op deze pc; de selectie staat op de server. Er loopt al een overdracht van deze reeks. Filters wissen diff --git a/i18n/nl/Server.nl.resx b/i18n/nl/Server.nl.resx index 96b257cf..2bd2cdc2 100644 --- a/i18n/nl/Server.nl.resx +++ b/i18n/nl/Server.nl.resx @@ -40,6 +40,7 @@ De verbinding is mislukt; het logboek bevat de details. Een bestand van de reeks is geopend in een ander programma; sluit het en probeer het opnieuw. De map van de reeks staat niet meer op schijf; er is niets meer om naar de prullenbak te verplaatsen. + De map van deze reeks staat niet waar de index van de server die aangeeft; probeer het opnieuw na de volgende scan van de server. Je account mag dit niet doen. De foto's van de reeks zijn op de server gewijzigd; laad de reeks opnieuw en pas je bewerking nogmaals toe. Het bestand is beschadigd aangekomen; upload het opnieuw. @@ -68,11 +69,14 @@ Deze server kan dat type taak niet uitvoeren. De laatste beheerder kan niet worden verwijderd of uitgeschakeld. Deze methode is hier niet toegestaan. + Een nieuwe map zou in de map van een andere reeks terechtkomen. Dat adres is geen Chronos Server. Niet gevonden. Wijzig eerst je wachtwoord. De foto is uit de reeks verwijderd terwijl die werd geüpload, dus is die niet toegevoegd. {0} kan niet worden gelezen, en zonder de hash ervan zouden andere kopieën niet te weten komen dat het is verwijderd; sluit het programma dat het gebruikt of controleer de rechten ervan, en probeer het dan opnieuw. + Het archief is na de proefrun gewijzigd; bekijk het plan opnieuw. + De server is gestopt met het maken van dit plan: het duurde te lang, of er werden er te veel tegelijk aangevraagd; probeer het straks opnieuw. Dit archief maakt geen proxy's. De proxy is van een andere foto gemaakt. De server heeft geen proxy van deze foto nodig. diff --git a/i18n/nl/Settings.nl.resx b/i18n/nl/Settings.nl.resx index 9521764a..124869b4 100644 --- a/i18n/nl/Settings.nl.resx +++ b/i18n/nl/Settings.nl.resx @@ -65,6 +65,7 @@ sterren per megapixel Analysebreedte px lange zijde + Mappen en bestanden die al in het archief staan, behouden hun naam. Bestandsnamen Mappen {0} vrij @@ -74,10 +75,12 @@ Kies de archiefmap Voorbeeld Proxygrootte + Reorganiseren… Archief herstellen De naamsjablonen, de proxygrootte en de miniatuurgrootte krijgen weer hun standaardwaarden voor elke pc en server die het archief gebruikt. Mappen en bestanden die al in het archief staan, behouden hun naam. Instellingen van {0} herstellen? Archiefmap + Archiefsjablonen opgeslagen Miniatuurgrootte Terug naar Auto Map kiezen diff --git a/i18n/nl/Tooltips.nl.resx b/i18n/nl/Tooltips.nl.resx index 9b9f2cfc..8ec5c503 100644 --- a/i18n/nl/Tooltips.nl.resx +++ b/i18n/nl/Tooltips.nl.resx @@ -36,6 +36,7 @@ Open de reeks van de eerste kopie op het scherm Bewerken Zoek identieke foto's in alle reeksen op hash · leest alleen de index Toon de reeksen van dit jaar + Bestandsnaam van elke foto, zoals imports die benoemen · gecontroleerd terwijl je typt Behoud alleen de reeksen van één camera Kies deze waarde; kies nogmaals om de keuze te wissen Behoud alleen de reeksen met één status @@ -71,7 +72,10 @@ Bouw de index opnieuw op vanuit de sidecarbestanden; valt terug op een volledige metadatascan; verwijdert nooit originelen Zet het opnieuw opbouwen in de wachtrij · het archief blijft intussen bruikbaar Kies de nieuwe map van een archief dat je hebt verplaatst; de reeksen ervan volgen - Voer precies deze wijzigingen door in mappen, sidecarbestanden en index · wordt na een crash hervat + Plaats een taak in de wachtrij die precies deze wijzigingen aanbrengt · onderbreek en hervat die in Taken + Hernoem de foto's met dit sjabloon · uit: ze behouden hun naam + Verplaats de reeksmappen naar deze indeling · uit: ze blijven waar ze zijn + Wijzig de titels met dit sjabloon · uit: ze blijven zoals ze zijn Kies een back-up van de index in Instellingen › Geavanceerd; die vervangt de index bij de volgende start Wijzig de tags van deze reeksen in sidecarbestanden en index Voer dezelfde actie opnieuw uit @@ -80,9 +84,8 @@ Voer de diepgaande analyse uit op alle reeksen in de set Verplaats de set naar de prullenbak van het archief · toont eerst de proefrun en vraagt je dan om ter bevestiging te typen Exporteer de set als CSV: één rij per reeks - Verplaats de set naar een nieuwe mapindeling · eerst een proefrun Maak of vernieuw proxy's - Wijzig de titels van de set met een sjabloon · eerst een proefrun + Pas map-, bestands- en titelsjablonen toe op de set · eerst een proefrun, dan een taak Voeg tags toe aan of verwijder tags uit de hele set Maak of vernieuw miniaturen Hash de originelen van de set opnieuw @@ -471,12 +474,12 @@ Haal van de server op wat {0:N0} reeksen hier missen (originelen of renders) · wordt als overdrachtstaken uitgevoerd Sla {0:N0} rij op als CSV in een map naar keuze Sla {0:N0} rijen op als CSV in een map naar keuze - Verplaats {0:N0} reeks naar een nieuwe mapindeling van het archief ervan · toont eerst de proefrun - Verplaats {0:N0} reeksen naar een nieuwe mapindeling van hun archief · toont eerst de proefrun Maak JPEG-proxy's van {0:N0} reeks · wordt als één taak uitgevoerd Maak JPEG-proxy's van {0:N0} reeksen · wordt als één taak uitgevoerd Stel de beoordeling van {0:N0} reeks in, in het sidecarbestand ervan en de index Stel de beoordeling van {0:N0} reeksen in, in hun sidecarbestanden en de index + Pas map-, bestands- en titelsjablonen toe op {0:N0} reeks van het archief ervan · eerst een proefrun, dan een taak + Pas map-, bestands- en titelsjablonen toe op {0:N0} reeksen van hun archief · eerst een proefrun, dan een taak Voeg tags toe aan of verwijder tags uit {0:N0} reeks Voeg tags toe aan of verwijder tags uit {0:N0} reeksen Verzend wat de server mist van {0:N0} reeks (originelen en instellingen, of renders) · wordt als overdrachtstaak uitgevoerd @@ -692,6 +695,7 @@ Gebalanceerd is geschikt voor het meeste werk; Beste meet op dubbele resolutie en leest verder vooruit; Snel meet op halve resolutie met conceptbeweging Toon de encoders opnieuw na installatie van een stuurprogramma of codec Zoek opnieuw naar codecextensies nadat je er een hebt geïnstalleerd; de volgende taken gebruiken ze + Pas de sjablonen van het archief toe op de reeksen die er al in staan · eerst een proefrun Zet elke instelling van deze pc terug op de standaardwaarde; vraagt eerst om bevestiging Schrijf nu de standaardsjablonen en -groottes naar het archive.json van dit archief Herstel nu alle instellingen diff --git a/i18n/pl/Admin.pl.resx b/i18n/pl/Admin.pl.resx index 8d4686c2..f882efd7 100644 --- a/i18n/pl/Admin.pl.resx +++ b/i18n/pl/Admin.pl.resx @@ -9,6 +9,7 @@ Chronos Server Czas działania Wersja + Użytkownik {0} zreorganizował archiwum · {1} Użytkownik {0} zmienił układ archiwum Użytkownik {0} usunął {1} Użytkownik {0} uruchomił zadanie {1} @@ -156,7 +157,7 @@ Import Szybka analiza Konserwacja - Przenoszenie + Reorganizacja Pliki osierocone Proxy Odbudowa @@ -391,6 +392,7 @@ Zaloguj się, aby administrować tym serwerem Użytkownik Twoja nazwa użytkownika na tym serwerze + Zreorganizowano archiwum Układ archiwum Usunięto zdjęcia Uruchomiono zadanie @@ -478,6 +480,68 @@ Zmień hasło Zastąp hasło i przejdź do panelu Wybierz nowe hasło + Reorganizuj… + Zastosuj szablony folderów, plików i tytułów do zaznaczonych sekwencji; podgląd najpierw pokaże każdą zmianę + Po: + Zastosuj… + Zreorganizuj zgodnie z podglądem; najpierw pojawi się prośba o potwierdzenie + Przed: + Wpisz szablon lub wyłącz tę część. + Zamknij bez wprowadzania zmian + Razem z folderem + Zostanie przeniesiona tylko dlatego, że przenoszony jest folder, w którym się znajduje + Zmienione nazwy plików + Folder + Sekwencja + Reorganizuj + Dodaj do kolejki zadanie, które przeniesie oryginały i zmieni ich nazwy; nic nie zostanie nadpisane ani usunięte + {0} zdjęcia otrzymają nowe nazwy. + {0} zdjęć otrzyma nowe nazwy. + {0} zdjęcie otrzyma nową nazwę. + {0} zdjęć otrzyma nowe nazwy. + {0} foldery zostaną przeniesione. + {0} folderów zostanie przeniesionych. + {0} folder zostanie przeniesiony. + {0} folderów zostanie przeniesionych. + {0} sekwencje zostaną zmienione. + {0} sekwencji zostanie zmienionych. + {0} sekwencja zostanie zmieniona. + {0} sekwencji zostanie zmienionych. + Zreorganizować teraz? + Nazwa każdego zdjęcia nadawana jak przy imporcie, np. {date}_{time}_{n:0000}; pliki leżące obok zdjęcia zmieniają nazwę razem z nim + Pliki + Zmień nazwy zdjęć w każdej sekwencji; po wyłączeniu wszystkie pliki zachowują swoje nazwy + {0} pliki ze zmienioną nazwą + {0} plików ze zmienioną nazwą + {0} plik ze zmienioną nazwą + {0} plików ze zmienioną nazwą + Folder każdej sekwencji w archiwum, np. {year}/{date} {camera}; {title} oznacza nowy tytuł + Foldery + Przenieś każdą sekwencję do folderu wskazanego przez szablon; po wyłączeniu każdy folder zostaje na swoim miejscu + Jednej z zaznaczonych sekwencji nie ma już w archiwum; zamknij i zaznacz ponownie. + {0}: {1} + Włącz co najmniej jedną część do zmiany. + Nie ma nic do zmiany: te sekwencje są już zgodne z szablonami. + Reorganizuj… + Zastosuj nowe szablony do sekwencji, które już są w archiwum; podgląd najpierw pokaże każdą zmianę + Otwórz zadanie + Pokaż zadanie i jego dziennik na stronie Zadania + Archiwum zmieniło się podczas potwierdzania; sprawdź nowy podgląd i zastosuj ponownie. + Planowanie… + Podgląd + Czym stanie się każda sekwencja, w kolejności stosowania zmian; jeszcze nic nie zmieniono + Dodano reorganizację do kolejki. + Ten folder zostaje na swoim miejscu + Reorganizuj {0} sekwencje + Reorganizuj {0} sekwencji + Reorganizuj {0} sekwencję + Reorganizuj {0} sekwencji + Reorganizuj wszystkie sekwencje + Nowy tytuł każdej sekwencji, np. {date} {camera}; {title} oznacza bieżący tytuł + Tytuły + Nadaj każdej sekwencji tytuł utworzony przez szablon; po wyłączeniu wszystkie tytuły pozostają bez zmian + Reorganizacja obejmuje naraz najwyżej {0} sekwencji albo wszystkie sekwencje: wyczyść filtry i zaznacz wszystko. + Zmienione sekwencje: {0} · pliki ze zmienioną nazwą: {1} · zachowane nazwy: {2} Administrator Edytor Przesyłający diff --git a/i18n/pl/Archive.pl.resx b/i18n/pl/Archive.pl.resx index 92f7b66b..86f2b281 100644 --- a/i18n/pl/Archive.pl.resx +++ b/i18n/pl/Archive.pl.resx @@ -17,6 +17,7 @@ Poczekaj, aż zmiany zostaną zastosowane. Zestaw jest pusty: zmień zaznaczenie lub filtr. Nic by się nie zmieniło. + Włącz co najmniej jeden szablon. Archiwum musi być online i dostępne do zapisu. Poczekaj na wynik symulacji. Poczekaj, aż archiwum zostanie odczytane. @@ -101,6 +102,18 @@ Element {0} został zapisany przez nowszą wersję programu Chronos (format {1}). Archiwum {0} jest offline. Archiwum {0} jest tylko do odczytu. + {0:N0} sekwencje zachowały nazwy plików: zdjęcie było w użyciu lub jego nowa nazwa była zajęta. + {0:N0} sekwencji zachowało nazwy plików: zdjęcie było w użyciu lub jego nowa nazwa była zajęta. + {0:N0} sekwencja zachowała nazwy plików: zdjęcie było w użyciu lub jego nowa nazwa była zajęta. + {0:N0} sekwencji zachowało nazwy plików: zdjęcie było w użyciu lub jego nowa nazwa była zajęta. + {0:N0} sekwencje nie zostały zreorganizowane zgodnie z planem: zmieniły się po utworzeniu planu. + {0:N0} sekwencji nie zostało zreorganizowanych zgodnie z planem: zmieniły się po utworzeniu planu. + {0:N0} sekwencja nie została zreorganizowana zgodnie z planem: zmieniła się po utworzeniu planu. + {0:N0} sekwencji nie zostało zreorganizowanych zgodnie z planem: zmieniły się po utworzeniu planu. + {0:N0} sekwencje zachowały tytuły i nazwy plików: ich pliki sekwencji pochodzą z nowszej wersji programu Chronos. + {0:N0} sekwencji zachowało tytuły i nazwy plików: ich pliki sekwencji pochodzą z nowszej wersji programu Chronos. + {0:N0} sekwencja zachowała tytuł i nazwy plików: jej plik sekwencji pochodzi z nowszej wersji programu Chronos. + {0:N0} sekwencji zachowało tytuły i nazwy plików: ich pliki sekwencji pochodzą z nowszej wersji programu Chronos. Element {0} zmienił się po utworzeniu planu. Karta lub folder {0} nie jest już dostępny. Archiwum zmieniło się po utworzeniu tego planu. @@ -178,6 +191,14 @@ Niezaindeksowane zdjęcia: {0}, brakujące zdjęcia: {1} {0} — utworzone: {1}, użyte ponownie: {2}, nieczytelne: {3}, oczekujące: {4} Pliki proxy dla serwera — wysłane: {0}, niewysłane: {1} + Pozostawiono bez zmian, folder nadrzędny nie został przeniesiony: {0} + Pozostawiono bez zmian, sekwencja zmieniła się po utworzeniu planu: {0} + Zachowano nazwy plików, zdjęcie było w użyciu lub jego nowa nazwa była zajęta: {0} + Zachowano nazwy plików, zdjęcia zmieniły się po utworzeniu planu: {0} + Zachowano tytuł i nazwy plików, plik sekwencji pochodzi z nowszej wersji programu Chronos: {0} + Zachowano tytuł i nazwy plików, sekwencja zmieniła się po utworzeniu planu: {0} + Zmienione sekwencje: {0}, pliki ze zmienioną nazwą: {1} + Reorganizację dokończono podczas otwierania archiwum Tylko raport: niczego nie zmieniono. Foldery: {0}, zaindeksowane: {1}, dołączone: {2}, usunięte: {3} Nie znaleziono sekwencji: {0} @@ -238,20 +259,38 @@ Folder przeniesionego archiwum Zastosuj {0} z {1} - Zmień nazwy {0:N0} sekwencji - Zmień nazwy {0:N0} sekwencji - Zmień nazwę {0:N0} sekwencji - Zmień nazwy {0:N0} sekwencji - Przenieś {0:N0} sekwencje - Przenieś {0:N0} sekwencji - Przenieś {0:N0} sekwencję - Przenieś {0:N0} sekwencji Zmiany Do zmiany: {0:N0} z {1:N0} Do zmiany: {0:N0} z {1:N0} Do zmiany: {0:N0} z {1:N0} Do zmiany: {0:N0} z {1:N0} - Szablon + Zdjęcia przechowywane na miejscu poza folderem originals zachowują swoje nazwy. + Brakujące zdjęcia zachowują swoje nazwy. + Zdjęcia, których nigdy nie zweryfikowano, zachowują swoje nazwy; najpierw zweryfikuj sekwencję. + Nie można odczytać pliku sekwencji; sekwencja pozostaje bez zmian, podobnie jak każdy folder, w którym się znajduje. + Podąża za folderem + {0}: z {1} na {2} + Plik + Nazwy plików + Folder + Foldery + Reorganizuj {0:N0} sekwencje + Reorganizuj {0:N0} sekwencji + Reorganizuj {0:N0} sekwencję + Reorganizuj {0:N0} sekwencji + Reorganizuj archiwum {0} + {0:N0} zachowane nazwy + {0:N0} zachowanych nazw + {0:N0} zachowana nazwa + {0:N0} zachowanych nazw + Symulacja… + {0:N0} pliki ze zmienioną nazwą + {0:N0} plików ze zmienioną nazwą + {0:N0} plik ze zmienioną nazwą + {0:N0} plików ze zmienioną nazwą + Tytuł + Tytuły + Okno reorganizacji otworzy się po zamknięciu bieżącego okna dialogowego Dodaj tagi Zastosuj Tagi {0:N0} sekwencji @@ -270,9 +309,8 @@ Eksportuj CSV Filtr zestawu Filtrowany zestaw - Przenieś… Proxy - Zmień nazwy… + Reorganizuj… Zmień tagi… Miniatury Weryfikuj diff --git a/i18n/pl/Errors.pl.resx b/i18n/pl/Errors.pl.resx index 55f43e17..89f0623c 100644 --- a/i18n/pl/Errors.pl.resx +++ b/i18n/pl/Errors.pl.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Nieprzeanalizowane sekwencje: {0} z {1}; szczegóły znajdziesz w dzienniku zadania. + Folder tej sekwencji nie znajduje się tam, gdzie wskazuje indeks; spróbuj ponownie po następnym skanowaniu. Nie można otworzyć archiwum. Nie udało się utworzyć kopii zapasowej bieżącego indeksu ani go zastąpić; przywracanie zostanie ponowione przy następnym uruchomieniu. Nie można przywrócić tej kopii zapasowej; wybierz inną. @@ -41,9 +42,11 @@ {0} oryginałów zniknęło lub zmieniło się od czasu archiwizacji; zweryfikuj archiwum. Szablon jest pusty. Pusty znacznik na pozycji {1}: wpisz nazwę między nawiasami klamrowymi. + Zdjęcia straciłyby rozszerzenie: wpisz kropkę przed {ext} albo usuń {ext}. Nazwy plików nie mogą zawierać ukośnika; foldery umieść w szablonie folderu. Format po dwukropku nie pasuje do znacznika. Nazwy by się powtarzały: dodaj numer klatki, godzinę lub oryginalną nazwę. + Skanowanie pomija foldery, których nazwa zaczyna się od kropki lub brzmi originals, proxies albo exports. Nawias klamrowy otwarty na pozycji {1} nie został zamknięty. Nieznany znacznik „{0}” na pozycji {1}. Zamykający nawias klamrowy na pozycji {1} nie ma pary; aby wstawić sam nawias, wpisz go podwójnie. diff --git a/i18n/pl/Jobs.pl.resx b/i18n/pl/Jobs.pl.resx index 5d4a2c78..2e0cd1c3 100644 --- a/i18n/pl/Jobs.pl.resx +++ b/i18n/pl/Jobs.pl.resx @@ -78,7 +78,7 @@ Import Szybka analiza Konserwacja - Przenoszenie archiwum + Reorganizacja Pliki osierocone Proxy Odbudowa indeksu diff --git a/i18n/pl/Library.pl.resx b/i18n/pl/Library.pl.resx index 6ea71eee..1f3ee8df 100644 --- a/i18n/pl/Library.pl.resx +++ b/i18n/pl/Library.pl.resx @@ -10,17 +10,16 @@ Pobierz Eksportuj listę Folder - Przenieś… Otwórz Utwórz proxy Ocena Renderuj + Reorganizuj… Synchronizuj Tagi… Prześlij Weryfikuj Dołącz folder - Przenoszenie obejmuje sekwencje tylko jednego archiwum naraz. Sekwencja jest taka sama na tym komputerze i na serwerze: nie ma czego synchronizować. Żaden zapisany widok nie jest używany; najpierw wybierz jeden. Twoje konto na serwerze nie może pobierać oryginałów. @@ -32,6 +31,7 @@ Najpierw zaloguj się do Chronos Server na ekranie Serwer. Dla zaznaczonych sekwencji nie ma nic do pobrania z serwera. Serwer ma już całą zawartość zaznaczonych sekwencji. + Reorganizacja obejmuje naraz sekwencje tylko jednego archiwum. Tylko dla sekwencji na tym komputerze; zaznaczone sekwencje są na serwerze. Transfer tej sekwencji już trwa. Wyczyść filtry diff --git a/i18n/pl/Server.pl.resx b/i18n/pl/Server.pl.resx index c53feaa1..4bcece02 100644 --- a/i18n/pl/Server.pl.resx +++ b/i18n/pl/Server.pl.resx @@ -40,6 +40,7 @@ Połączenie nie powiodło się; szczegóły znajdziesz w dzienniku. Plik tej sekwencji jest otwarty w innym programie; zamknij go i spróbuj ponownie. Folderu sekwencji nie ma już na dysku; nie ma czego przenieść do kosza. + Folder tej sekwencji nie znajduje się tam, gdzie wskazuje indeks serwera; spróbuj ponownie po następnym skanowaniu na serwerze. Twoje konto nie ma uprawnień do tej operacji. Zdjęcia sekwencji zmieniły się na serwerze; wczytaj ją ponownie i jeszcze raz wprowadź swoją zmianę. Plik dotarł uszkodzony; prześlij go ponownie. @@ -68,11 +69,14 @@ Ten serwer nie może uruchamiać zadań tego rodzaju. Nie można usunąć ani wyłączyć ostatniego administratora. Ta metoda jest tutaj niedozwolona. + Nowy folder znalazłby się wewnątrz folderu innej sekwencji. Pod tym adresem nie działa Chronos Server. Nie znaleziono. Najpierw zmień hasło. Zdjęcie zostało usunięte z sekwencji w trakcie przesyłania, więc nie zostało dodane. Nie można odczytać pliku {0}, a bez jego sumy kontrolnej inne kopie nie dowiedzą się, że został usunięty; zamknij program, który go używa, lub sprawdź uprawnienia, a następnie spróbuj ponownie. + Archiwum zmieniło się po symulacji; przejrzyj plan ponownie. + Serwer przerwał tworzenie tego planu: trwało to zbyt długo lub zażądano zbyt wielu planów naraz; spróbuj ponownie za chwilę. To archiwum nie tworzy plików proxy. Plik proxy utworzono z innego zdjęcia. Serwer nie potrzebuje pliku proxy tego zdjęcia. diff --git a/i18n/pl/Settings.pl.resx b/i18n/pl/Settings.pl.resx index 35816111..4c35218a 100644 --- a/i18n/pl/Settings.pl.resx +++ b/i18n/pl/Settings.pl.resx @@ -67,6 +67,7 @@ gwiazd na megapiksel Szerokość analizy px dłuższej krawędzi + Foldery i pliki, które już są w archiwum, zachowują swoje nazwy. Nazwy plików Foldery {0} wolnego @@ -76,10 +77,12 @@ Wybierz folder archiwum Podgląd Rozmiar proxy + Reorganizuj… Resetuj archiwum Szablony nazw, rozmiar proxy i rozmiar miniatur wrócą do wartości domyślnych na każdym komputerze i serwerze, który korzysta z tego archiwum. Foldery i pliki, które już są w archiwum, zachowają swoje nazwy. Zresetować ustawienia archiwum {0}? Folder archiwum + Zapisano szablony archiwum Rozmiar miniatur Przywróć Auto Wybierz folder diff --git a/i18n/pl/Tooltips.pl.resx b/i18n/pl/Tooltips.pl.resx index 01fc20f5..612fac62 100644 --- a/i18n/pl/Tooltips.pl.resx +++ b/i18n/pl/Tooltips.pl.resx @@ -38,6 +38,7 @@ Otwórz sekwencję pierwszej kopii w sekcji Edycja Znajdź identyczne zdjęcia w różnych sekwencjach na podstawie sumy kontrolnej · odczytuje tylko indeks Pokaż sekwencje z tego roku + Nazwa pliku każdego zdjęcia, nadawana jak przy imporcie · sprawdzana podczas pisania Pozostaw tylko sekwencje z jednego aparatu Wybierz tę wartość; wybierz ją ponownie, aby ją wyczyścić Pozostaw tylko sekwencje w jednym stanie @@ -73,7 +74,10 @@ Odbuduj indeks z plików sidecar; w razie potrzeby wykonuje pełne skanowanie metadanych; nigdy nie usuwa oryginałów Dodaj odbudowę do kolejki · archiwum pozostaje w tym czasie dostępne Wybierz nowy folder przeniesionego archiwum; ścieżki jego sekwencji zostaną zaktualizowane - Wprowadź dokładnie te zmiany w folderach, plikach sidecar i indeksie · wznawia się po awarii + Dodaj do kolejki zadanie, które wprowadzi dokładnie te zmiany · można je wstrzymać i wznowić w widoku Zadania + Zmień nazwy zdjęć według tego szablonu · po wyłączeniu zdjęcia zachowują swoje nazwy + Przenieś foldery sekwencji do tego układu · po wyłączeniu foldery zostają na swoim miejscu + Zmień tytuły według tego szablonu · po wyłączeniu tytuły pozostają bez zmian Wybierz kopię zapasową indeksu (Ustawienia › Zaawansowane); zastąpi ona indeks przy następnym uruchomieniu Zmień tagi tych sekwencji w plikach sidecar i indeksie Wykonaj tę samą akcję ponownie @@ -82,9 +86,8 @@ Uruchom dogłębną analizę każdej sekwencji z zestawu Przenieś zestaw do kosza archiwum · najpierw pokazuje symulację, potem prosi o potwierdzenie przez wpisanie Eksportuj zestaw jako CSV: jeden wiersz na sekwencję - Przenieś zestaw do nowej struktury folderów · najpierw symulacja Utwórz lub odśwież pliki proxy - Zmień tytuły zestawu według szablonu · najpierw symulacja + Zastosuj szablony folderów, plików i tytułów do zestawu · najpierw symulacja, potem zadanie Dodaj lub usuń tagi w całym zestawie Utwórz lub odśwież miniatury Ponownie oblicz sumy kontrolne oryginałów z zestawu @@ -485,10 +488,6 @@ Zapisz {0:N0} wierszy jako CSV w wybranym folderze Zapisz {0:N0} wiersz jako CSV w wybranym folderze Zapisz {0:N0} wierszy jako CSV w wybranym folderze - Przenieś {0:N0} sekwencje do nowej struktury folderów ich archiwum · najpierw symulacja - Przenieś {0:N0} sekwencji do nowej struktury folderów ich archiwum · najpierw symulacja - Przenieś {0:N0} sekwencję do nowej struktury folderów jej archiwum · najpierw symulacja - Przenieś {0:N0} sekwencji do nowej struktury folderów ich archiwum · najpierw symulacja Utwórz pliki proxy JPEG dla {0:N0} sekwencji · działa jako jedno zadanie Utwórz pliki proxy JPEG dla {0:N0} sekwencji · działa jako jedno zadanie Utwórz pliki proxy JPEG dla {0:N0} sekwencji · działa jako jedno zadanie @@ -497,6 +496,10 @@ Ustaw ocenę {0:N0} sekwencji w ich plikach sidecar i w indeksie Ustaw ocenę {0:N0} sekwencji w jej pliku sidecar i w indeksie Ustaw ocenę {0:N0} sekwencji w ich plikach sidecar i w indeksie + Zastosuj szablony folderów, plików i tytułów do {0:N0} sekwencji w ich archiwum · najpierw symulacja, potem zadanie + Zastosuj szablony folderów, plików i tytułów do {0:N0} sekwencji w ich archiwum · najpierw symulacja, potem zadanie + Zastosuj szablony folderów, plików i tytułów do {0:N0} sekwencji w jej archiwum · najpierw symulacja, potem zadanie + Zastosuj szablony folderów, plików i tytułów do {0:N0} sekwencji w ich archiwum · najpierw symulacja, potem zadanie Dodaj lub usuń tagi {0:N0} sekwencji Dodaj lub usuń tagi {0:N0} sekwencji Dodaj lub usuń tagi {0:N0} sekwencji @@ -730,6 +733,7 @@ Zrównoważony sprawdza się w większości zastosowań; Najlepszy mierzy w podwójnej rozdzielczości i wczytuje klatki z większym wyprzedzeniem; Szybki mierzy w połowie rozdzielczości z roboczym wyznaczaniem ruchu Ponownie wyświetl listę enkoderów po instalacji sterownika lub kodeka Ponownie wyszukaj rozszerzenia kodeków po zainstalowaniu jednego z nich; kolejne zadania będą z nich korzystać + Zastosuj szablony archiwum do sekwencji, które już się w nim znajdują · najpierw symulacja Przywróć wartości domyślne wszystkich ustawień tego komputera; najpierw pyta o potwierdzenie Zapisz teraz domyślne szablony i rozmiary w pliku archive.json tego archiwum Zresetuj teraz wszystkie ustawienia diff --git a/i18n/pt-BR/Admin.pt-BR.resx b/i18n/pt-BR/Admin.pt-BR.resx index 30f758ed..33c16c00 100644 --- a/i18n/pt-BR/Admin.pt-BR.resx +++ b/i18n/pt-BR/Admin.pt-BR.resx @@ -9,6 +9,7 @@ Chronos Server Em execução há Versão + {0} reorganizou o acervo · {1} {0} alterou a organização do acervo {0} excluiu {1} {0} iniciou {1} @@ -138,7 +139,7 @@ Importação Análise rápida Manutenção - Movimentação + Reorganização Órfãos Proxies Reconstrução @@ -343,6 +344,7 @@ Entra na conta para administrar este servidor Usuário Seu nome de usuário neste servidor + Acervo reorganizado Organização do acervo Fotos excluídas Tarefa iniciada @@ -426,6 +428,58 @@ Alterar senha Substitui a senha e continua para o painel Escolha uma nova senha + Reorganizar… + Aplica os modelos de pasta, arquivo e título às sequências selecionadas; antes, uma prévia mostra cada alteração + Depois: + Aplicar… + Reorganiza conforme mostra a prévia; antes, pede uma confirmação + Antes: + Escreva um modelo ou desative esta parte. + Fecha sem alterar nada + Levada junto + Só muda de lugar porque uma pasta que a contém é movida + Arquivos renomeados + Pasta + Sequência + Reorganizar + Coloca na fila a tarefa que move e renomeia os originais; nada é sobrescrito nem excluído + {0} foto recebe um novo nome. + {0} fotos recebem novos nomes. + {0} pasta é movida. + {0} pastas são movidas. + {0} sequência é alterada. + {0} sequências são alteradas. + Reorganizar agora? + Nome de cada foto como uma importação o daria, por exemplo {date}_{time}_{n:0000}; os arquivos ao lado de uma foto a acompanham + Arquivos + Renomeia as fotos de cada sequência; se desativado, mantém todos os nomes de arquivo + {0} arquivo renomeado + {0} arquivos renomeados + Pasta de cada sequência no acervo, por exemplo {year}/{date} {camera}; {title} é o novo título + Pastas + Move cada sequência para a pasta que o modelo indica; se desativado, deixa cada pasta onde está + Uma sequência selecionada não está mais no acervo; feche e selecione de novo. + {0}: {1} + Ative pelo menos uma parte para alterar. + Nada a alterar: estas sequências já seguem os modelos. + Reorganizar… + Aplica os novos modelos às sequências que já estão no acervo; antes, uma prévia mostra cada alteração + Abrir tarefa + Mostra a tarefa e o log dela na página Tarefas + O acervo mudou durante a confirmação; confira a nova prévia e aplique de novo. + Planejando… + Prévia + O que cada sequência se torna, na ordem em que as alterações são aplicadas; nada mudou ainda + Reorganização na fila. + Esta pasta fica onde está + Reorganizar {0} sequência + Reorganizar {0} sequências + Reorganizar todas as sequências + Novo título de cada sequência, por exemplo {date} {camera}; {title} é o título atual + Títulos + Dá a cada sequência o título que o modelo cria; se desativado, mantém todos os títulos + A reorganização aceita no máximo {0} sequências por vez, ou todas: limpe os filtros e selecione tudo. + Sequências alteradas: {0} · arquivos renomeados: {1} · nomes mantidos: {2} Administrador Editor Uploader diff --git a/i18n/pt-BR/Archive.pt-BR.resx b/i18n/pt-BR/Archive.pt-BR.resx index 28b2b66f..150a1328 100644 --- a/i18n/pt-BR/Archive.pt-BR.resx +++ b/i18n/pt-BR/Archive.pt-BR.resx @@ -15,6 +15,7 @@ Aguarde até que as alterações sejam aplicadas. O conjunto está vazio: altere a seleção ou o filtro. Nada mudaria. + Ative pelo menos um modelo. O acervo precisa estar online e gravável. Aguarde a simulação. Aguarde a leitura do acervo. @@ -81,6 +82,12 @@ {0} foi gravado por um Chronos mais recente (formato {1}). O acervo {0} está offline. O acervo {0} é somente leitura. + {0:N0} sequência manteve os nomes de arquivo: uma foto estava em uso ou o novo nome dela já estava ocupado. + {0:N0} sequências mantiveram os nomes de arquivo: uma foto estava em uso ou o novo nome dela já estava ocupado. + {0:N0} sequência não foi reorganizada como planejado: ela mudou depois que o plano foi criado. + {0:N0} sequências não foram reorganizadas como planejado: elas mudaram depois que o plano foi criado. + {0:N0} sequência manteve o título e os nomes de arquivo: o arquivo da sequência é de um Chronos mais recente. + {0:N0} sequências mantiveram os títulos e os nomes de arquivo: os arquivos das sequências são de um Chronos mais recente. {0} mudou depois que o plano foi criado. O cartão ou a pasta {0} não está mais disponível. O acervo mudou depois que este plano foi criado. @@ -146,6 +153,14 @@ Fotos não indexadas: {0}, fotos ausentes: {1} {0}: criados {1}, reutilizados {2}, ilegíveis {3}, aguardando {4} Proxies para o servidor: enviados {0}, não enviados {1} + Mantida como estava, a pasta que a contém não foi movida: {0} + Mantida como estava, mudou depois do plano: {0} + Nomes de arquivo mantidos, uma foto estava em uso ou o novo nome dela já estava ocupado: {0} + Nomes de arquivo mantidos, fotos alteradas depois do plano: {0} + Título e nomes de arquivo mantidos, o arquivo da sequência é de um Chronos mais recente: {0} + Título e nomes de arquivo mantidos, a sequência mudou depois do plano: {0} + Sequências alteradas: {0}, arquivos renomeados: {1} + A reorganização foi concluída quando o acervo foi aberto Somente relatório: nada foi alterado. Pastas: {0}, indexadas: {1}, adotadas: {2}, removidas: {3} Sequência não encontrada: {0} @@ -200,14 +215,30 @@ Pasta do acervo movido Aplicar {0} de {1} - Renomear {0:N0} sequência - Renomear {0:N0} sequências - Mover {0:N0} sequência - Mover {0:N0} sequências Alterações {0:N0} de {1:N0} muda {0:N0} de {1:N0} mudam - Modelo + Fotos guardadas no local, fora de originals, mantêm seus nomes. + Fotos ausentes mantêm seus nomes. + Fotos nunca verificadas mantêm seus nomes; verifique a sequência primeiro. + O arquivo da sequência não pode ser lido; a sequência fica como está, assim como qualquer pasta que a contenha. + Segue a pasta + {0}: de {1} para {2} + Arquivo + Nomes de arquivo + Pasta + Pastas + Reorganizar {0:N0} sequência + Reorganizar {0:N0} sequências + Reorganizar {0} + {0:N0} nome mantido + {0:N0} nomes mantidos + Simulação… + {0:N0} arquivo renomeado + {0:N0} arquivos renomeados + Título + Títulos + Reorganizar abre quando a caixa de diálogo aberta for fechada Adicionar tags Aplicar Tags de {0:N0} sequência @@ -222,9 +253,8 @@ Exportar CSV Filtro do conjunto Conjunto filtrado - Mover… Proxies - Renomear… + Reorganizar… Alterar tags… Miniaturas Verificar diff --git a/i18n/pt-BR/Errors.pt-BR.resx b/i18n/pt-BR/Errors.pt-BR.resx index 463ab1b7..69c6e200 100644 --- a/i18n/pt-BR/Errors.pt-BR.resx +++ b/i18n/pt-BR/Errors.pt-BR.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Sequências não analisadas: {0} de {1}; consulte o log da tarefa. + A pasta desta sequência não está onde o índice indica; tente novamente após a próxima varredura. Não foi possível abrir o acervo. Não foi possível fazer backup do índice atual ou substituí-lo; a restauração será executada de novo na próxima inicialização. Este backup não pode ser restaurado; escolha outro. @@ -37,9 +38,11 @@ {0} originais estão ausentes ou mudaram desde que entraram no acervo; verifique o acervo. O modelo está vazio. Marcador vazio na posição {1}: escreva um nome entre as chaves. + As fotos perderiam a extensão: escreva um ponto antes de {ext} ou remova {ext}. Nomes de arquivo não podem conter barra; coloque as pastas no modelo de pasta. O formato após os dois-pontos não é adequado ao marcador. Os nomes se repetiriam: adicione o número do quadro, a hora ou o nome original. + As varreduras ignoram pastas que começam com ponto ou se chamam originals, proxies ou exports. A chave aberta na posição {1} nunca é fechada. Marcador desconhecido “{0}” na posição {1}. A chave de fechamento na posição {1} não tem uma de abertura; duplique-a para obter uma chave literal. diff --git a/i18n/pt-BR/Jobs.pt-BR.resx b/i18n/pt-BR/Jobs.pt-BR.resx index b3337387..f54d912f 100644 --- a/i18n/pt-BR/Jobs.pt-BR.resx +++ b/i18n/pt-BR/Jobs.pt-BR.resx @@ -76,7 +76,7 @@ Importação Análise rápida Manutenção - Movimentação do acervo + Reorganização Arquivos órfãos Proxies Reconstrução do índice diff --git a/i18n/pt-BR/Library.pt-BR.resx b/i18n/pt-BR/Library.pt-BR.resx index 28cfd97f..531d150f 100644 --- a/i18n/pt-BR/Library.pt-BR.resx +++ b/i18n/pt-BR/Library.pt-BR.resx @@ -10,17 +10,16 @@ Baixar Exportar lista Pasta - Mover… Abrir Proxies Classificação Renderizar + Reorganizar… Sincronizar Tags… Enviar Verificar Adotar uma pasta - Mover só funciona com as sequências de um acervo por vez. Igual neste PC e no servidor: nada a sincronizar. Nenhuma exibição salva está em uso; escolha uma primeiro. Sua conta no servidor não pode baixar originais. @@ -32,6 +31,7 @@ Entre em um Chronos Server primeiro, na tela Servidor. As sequências selecionadas não têm nada a baixar do servidor. O servidor já tem o que as sequências selecionadas contêm. + A reorganização age nas sequências de um acervo por vez. Só para sequências neste PC; a seleção está no servidor. Uma transferência desta sequência já está em andamento. Limpar filtros diff --git a/i18n/pt-BR/Server.pt-BR.resx b/i18n/pt-BR/Server.pt-BR.resx index 4dbe375c..527501b0 100644 --- a/i18n/pt-BR/Server.pt-BR.resx +++ b/i18n/pt-BR/Server.pt-BR.resx @@ -40,6 +40,7 @@ A conexão falhou; os detalhes estão no log. Um arquivo da sequência está aberto em outro programa; feche-o e tente novamente. A pasta da sequência não está mais no disco; não há nada a mover para a lixeira. + A pasta desta sequência não está onde o índice do servidor indica; tente novamente após a próxima varredura do servidor. Sua conta não pode fazer isso. As fotos da sequência mudaram no servidor; recarregue-a e aplique sua edição de novo. O arquivo chegou danificado; envie-o novamente. @@ -68,11 +69,14 @@ Este servidor não pode executar esse tipo de tarefa. O último administrador não pode ser removido nem desativado. Este método não é permitido aqui. + Uma nova pasta ficaria dentro da pasta de outra sequência. Esse endereço não é um Chronos Server. Não encontrado. Altere sua senha primeiro. A foto foi excluída da sequência enquanto era enviada, então não foi adicionada. Não é possível ler {0}, e sem o hash dele as outras cópias não saberiam que ele foi excluído; feche o programa que o está usando ou confira as permissões dele e tente novamente. + O acervo mudou depois da simulação; revise o plano de novo. + O servidor parou de preparar este plano: demorou demais, ou foram pedidos muitos ao mesmo tempo; tente novamente daqui a pouco. Este acervo não cria proxies. O proxy foi criado a partir de outra foto. O servidor não precisa de um proxy desta foto. diff --git a/i18n/pt-BR/Settings.pt-BR.resx b/i18n/pt-BR/Settings.pt-BR.resx index bd72de71..337e34c2 100644 --- a/i18n/pt-BR/Settings.pt-BR.resx +++ b/i18n/pt-BR/Settings.pt-BR.resx @@ -65,6 +65,7 @@ estrelas por megapixel Largura da análise px no lado maior + As pastas e os arquivos que já estão no acervo mantêm seus nomes. Nomes de arquivo Pastas {0} livres @@ -74,10 +75,12 @@ Escolha a pasta do acervo Prévia Tamanho do proxy + Reorganizar… Redefinir acervo Os modelos de nomes, o tamanho do proxy e o tamanho das miniaturas voltam ao padrão em todos os PCs e servidores que usam este acervo. As pastas e os arquivos que já estão no acervo mantêm seus nomes. Redefinir as configurações de {0}? Pasta do acervo + Modelos do acervo salvos Tamanho da miniatura Voltar para Auto Escolher pasta diff --git a/i18n/pt-BR/Tooltips.pt-BR.resx b/i18n/pt-BR/Tooltips.pt-BR.resx index c5fe27eb..caffc495 100644 --- a/i18n/pt-BR/Tooltips.pt-BR.resx +++ b/i18n/pt-BR/Tooltips.pt-BR.resx @@ -36,6 +36,7 @@ Abre a sequência da primeira cópia na tela Edição Localiza fotos idênticas entre sequências pelo hash · lê só o índice Mostra as sequências deste ano + Nome do arquivo de cada foto, como as importações o definem · validado enquanto você digita Mantém só as sequências de uma câmera Escolhe este valor; escolha-o de novo para limpá-lo Mantém só as sequências em um estado @@ -71,7 +72,10 @@ Reconstrói o índice a partir dos arquivos sidecar; na falta deles, faz uma varredura completa dos metadados; nunca exclui originais Coloca a reconstrução na fila · o acervo continua utilizável enquanto isso Escolhe a nova pasta de um acervo que você moveu; as sequências dele acompanham - Faz exatamente estas alterações em pastas, arquivos sidecar e índice · retoma após uma falha + Coloca na fila uma tarefa que faz exatamente estas alterações · ela pode ser pausada e retomada em Tarefas + Renomeia as fotos com este modelo · se desativado, elas mantêm seus nomes + Move as pastas das sequências para esta estrutura · se desativado, elas ficam onde estão + Altera os títulos com este modelo · se desativado, eles ficam como estão Escolha um backup do índice em Configurações › Avançado; ele substitui o índice na próxima inicialização Altera as tags destas sequências nos arquivos sidecar e no índice Executa a mesma ação de novo @@ -80,9 +84,8 @@ Executa a análise aprofundada em todas as sequências do conjunto Move o conjunto para a lixeira do acervo · mostra a simulação e depois pede que você digite para confirmar Exporta o conjunto como CSV: uma linha por sequência - Move o conjunto para uma nova estrutura de pastas · com simulação antes Gera ou atualiza os proxies - Renomeia os títulos do conjunto com um modelo · com simulação antes + Aplica modelos de pasta, arquivo e título ao conjunto · primeiro a simulação, depois uma tarefa Adiciona ou remove tags em todo o conjunto Gera ou atualiza as miniaturas Recalcula o hash dos originais do conjunto @@ -471,12 +474,12 @@ Baixa do servidor o que falta aqui de {0:N0} sequências (originais ou renderizações) · em tarefas de transferência Salva {0:N0} linha como CSV em uma pasta de sua escolha Salva {0:N0} linhas como CSV em uma pasta de sua escolha - Move {0:N0} sequência para uma nova estrutura de pastas do acervo dela · com simulação antes - Move {0:N0} sequências para uma nova estrutura de pastas do acervo delas · com simulação antes Cria proxies JPEG de {0:N0} sequência · em uma única tarefa Cria proxies JPEG de {0:N0} sequências · em uma única tarefa Define a classificação de {0:N0} sequência, no arquivo sidecar dela e no índice Define a classificação de {0:N0} sequências, nos arquivos sidecar delas e no índice + Aplica modelos de pasta, arquivo e título a {0:N0} sequência do acervo dela · primeiro a simulação, depois uma tarefa + Aplica modelos de pasta, arquivo e título a {0:N0} sequências do acervo delas · primeiro a simulação, depois uma tarefa Adiciona ou remove tags em {0:N0} sequência Adiciona ou remove tags em {0:N0} sequências Envia o que falta no servidor de {0:N0} sequência (originais e configurações, ou renderizações) · em uma tarefa de transferência @@ -692,6 +695,7 @@ Equilibrado serve para quase tudo; Melhor mede em resolução dupla e lê mais à frente; Rápido mede em meia resolução com movimento em rascunho Lista os codificadores de novo após instalar um driver ou codec Procura extensões de codec de novo depois de instalar uma; as próximas tarefas as usam + Aplica os modelos do acervo às sequências que já estão nele · primeiro a simulação Restaura o padrão de todas as configurações deste PC; pede confirmação antes Grava agora os modelos e tamanhos padrão no archive.json deste acervo Redefine todas as configurações agora diff --git a/i18n/pt-PT/Admin.pt-PT.resx b/i18n/pt-PT/Admin.pt-PT.resx index 4b6aaf3f..87761b2d 100644 --- a/i18n/pt-PT/Admin.pt-PT.resx +++ b/i18n/pt-PT/Admin.pt-PT.resx @@ -9,6 +9,7 @@ Chronos Server Em execução há Versão + {0} reorganizou o arquivo · {1} {0} alterou a estrutura do arquivo {0} eliminou {1} {0} iniciou {1} @@ -138,7 +139,7 @@ Importação Análise rápida Manutenção - Mover + Reorganização Órfãos Proxies Reconstrução @@ -343,6 +344,7 @@ Iniciar sessão para administrar este servidor Utilizador O seu nome de utilizador neste servidor + Arquivo reorganizado Estrutura do arquivo Fotografias eliminadas Tarefa iniciada @@ -426,6 +428,58 @@ Alterar palavra-passe Substituir a palavra-passe e continuar para o painel Definir nova palavra-passe + Reorganizar… + Aplicar modelos de pasta, ficheiro e título às sequências selecionadas; primeiro, uma pré-visualização mostra cada alteração + Depois: + Aplicar… + Reorganizar como mostra a pré-visualização; primeiro é pedida uma confirmação + Antes: + Escreva um modelo ou desative esta parte. + Fechar sem alterar nada + Arrastada + Move-se apenas porque se move uma pasta que a contém + Ficheiros com novo nome + Pasta + Sequência + Reorganizar + Colocar em fila a tarefa que move os originais e lhes muda o nome; nada é substituído nem eliminado + {0} fotografia recebe um novo nome. + {0} fotografias recebem novos nomes. + {0} pasta é movida. + {0} pastas são movidas. + {0} sequência é alterada. + {0} sequências são alteradas. + Reorganizar agora? + Nome de cada fotografia tal como uma importação o atribui, por exemplo {date}_{time}_{n:0000}; os ficheiros junto a uma fotografia acompanham-na + Ficheiros + Mudar o nome das fotografias de cada sequência; desativado, mantém todos os nomes de ficheiro + {0} ficheiro com novo nome + {0} ficheiros com novo nome + Pasta de cada sequência no arquivo, por exemplo {year}/{date} {camera}; {title} é o novo título + Pastas + Mover cada sequência para a pasta indicada pelo respetivo modelo; desativado, deixa cada pasta onde está + Uma sequência selecionada já não está no arquivo; feche e selecione novamente. + {0}: {1} + Ative pelo menos uma parte a alterar. + Nada a alterar: estas sequências já seguem os modelos. + Reorganizar… + Aplicar os novos modelos às sequências que já estão no arquivo; primeiro, uma pré-visualização mostra cada alteração + Abrir tarefa + Mostrar a tarefa e o respetivo registo na página Tarefas + O arquivo foi alterado durante a confirmação; verifique a nova pré-visualização e aplique novamente. + A planear… + Pré-visualização + O que cada sequência passa a ser, pela ordem em que as alterações são aplicadas; ainda nada foi alterado + Reorganização em fila. + Esta pasta fica onde está + Reorganizar {0} sequência + Reorganizar {0} sequências + Reorganizar todas as sequências + Novo título de cada sequência, por exemplo {date} {camera}; {title} é o título atual + Títulos + Dar a cada sequência o título criado pelo respetivo modelo; desativado, mantém todos os títulos + A reorganização abrange no máximo {0} sequências de cada vez, ou todas as sequências: limpe os filtros e selecione tudo. + Sequências alteradas: {0} · ficheiros com novo nome: {1} · nomes mantidos: {2} Administrador Editor Uploader diff --git a/i18n/pt-PT/Archive.pt-PT.resx b/i18n/pt-PT/Archive.pt-PT.resx index 0d126443..2f00719b 100644 --- a/i18n/pt-PT/Archive.pt-PT.resx +++ b/i18n/pt-PT/Archive.pt-PT.resx @@ -15,6 +15,7 @@ Aguarde até as alterações serem aplicadas. O conjunto está vazio: altere a seleção ou o filtro. Nada seria alterado. + Ative pelo menos um modelo. O arquivo tem de estar online e com permissão de escrita. Aguarde pela simulação. Aguarde até o arquivo ser lido. @@ -81,6 +82,12 @@ {0} foi escrito por uma versão mais recente do Chronos (formato {1}). O arquivo {0} está offline. O arquivo {0} é só de leitura. + {0:N0} sequência manteve os nomes de ficheiro: uma fotografia estava em utilização ou o seu novo nome já estava ocupado. + {0:N0} sequências mantiveram os nomes de ficheiro: uma fotografia estava em utilização ou o seu novo nome já estava ocupado. + {0:N0} sequência não foi reorganizada conforme planeado: foi alterada depois do plano. + {0:N0} sequências não foram reorganizadas conforme planeado: foram alteradas depois do plano. + {0:N0} sequência manteve o título e os nomes de ficheiro: o respetivo ficheiro de sequência é de uma versão mais recente do Chronos. + {0:N0} sequências mantiveram os títulos e os nomes de ficheiro: os respetivos ficheiros de sequência são de uma versão mais recente do Chronos. {0} foi alterado depois de o plano ter sido criado. O cartão ou a pasta {0} já não está disponível. O arquivo foi alterado depois de este plano ter sido criado. @@ -146,6 +153,14 @@ Fotografias não indexadas: {0}, fotografias em falta: {1} {0}: criados {1}, reutilizados {2}, ilegíveis {3}, em espera {4} Proxies para o servidor: enviados {0}, não enviados {1} + Deixada como estava, a pasta que a contém ficou no lugar: {0} + Deixada como estava, alterada depois do plano: {0} + Nomes de ficheiro mantidos, uma fotografia estava em utilização ou o seu novo nome já estava ocupado: {0} + Nomes de ficheiro mantidos, fotografias alteradas depois do plano: {0} + Título e nomes de ficheiro mantidos, o ficheiro da sequência é de uma versão mais recente do Chronos: {0} + Título e nomes de ficheiro mantidos, alterada depois do plano: {0} + Sequências alteradas: {0}, ficheiros com novo nome: {1} + A reorganização foi concluída ao abrir o arquivo Apenas relatório: nada foi alterado. Pastas: {0}, indexadas: {1}, adotadas: {2}, removidas: {3} Sequência não encontrada: {0} @@ -200,14 +215,30 @@ Pasta do arquivo movido Aplicar {0} de {1} - Mudar o nome de {0:N0} sequência - Mudar o nome de {0:N0} sequências - Mover {0:N0} sequência - Mover {0:N0} sequências Alterações {0:N0} de {1:N0} muda {0:N0} de {1:N0} mudam - Modelo + As fotografias mantidas no local fora de originals mantêm os nomes. + As fotografias em falta mantêm os nomes. + As fotografias nunca verificadas mantêm os nomes; verifique primeiro a sequência. + Não é possível ler o ficheiro da sequência; a sequência fica como está, tal como qualquer pasta que a contenha. + Segue a sua pasta + {0}: de {1} para {2} + Ficheiro + Nomes de ficheiro + Pasta + Pastas + Reorganizar {0:N0} sequência + Reorganizar {0:N0} sequências + Reorganizar {0} + {0:N0} nome mantido + {0:N0} nomes mantidos + Simulação… + {0:N0} ficheiro com novo nome + {0:N0} ficheiros com novo nome + Título + Títulos + A janela Reorganizar abre-se quando a caixa de diálogo aberta for fechada Adicionar etiquetas Aplicar Etiquetas de {0:N0} sequência @@ -222,9 +253,8 @@ Exportar CSV Filtro do conjunto Conjunto filtrado - Mover… Proxies - Mudar o nome… + Reorganizar… Etiquetar… Miniaturas Verificar diff --git a/i18n/pt-PT/Errors.pt-PT.resx b/i18n/pt-PT/Errors.pt-PT.resx index c8f6463d..6a4aa446 100644 --- a/i18n/pt-PT/Errors.pt-PT.resx +++ b/i18n/pt-PT/Errors.pt-PT.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Sequências não analisadas: {0} de {1}; consulte o registo da tarefa. + A pasta desta sequência não está onde o índice a indica; tente novamente após o próximo exame. Não foi possível abrir o arquivo. Não foi possível fazer uma cópia de segurança do índice atual nem substituí-lo; o restauro será executado novamente no próximo arranque. Não é possível restaurar esta cópia de segurança; escolha outra. @@ -37,9 +38,11 @@ {0} originais estão em falta ou foram alterados desde que foram arquivados; verifique o arquivo. O modelo está vazio. Marcador vazio na posição {1}: escreva um nome entre as chavetas. + As fotografias perderiam a extensão: escreva um ponto antes de {ext} ou retire {ext}. Os nomes de ficheiro não podem conter barras; coloque as pastas no modelo de pasta. O formato após os dois pontos não se adequa ao respetivo marcador. Os nomes iriam repetir-se: adicione o número do fotograma, a hora ou o nome original. + Os exames ignoram as pastas que começam por um ponto ou se chamam originals, proxies ou exports. A chaveta aberta na posição {1} nunca é fechada. Marcador desconhecido «{0}» na posição {1}. A chaveta de fecho na posição {1} não tem chaveta de abertura; duplique-a para obter uma chaveta literal. diff --git a/i18n/pt-PT/Jobs.pt-PT.resx b/i18n/pt-PT/Jobs.pt-PT.resx index f99f0396..1c673a6a 100644 --- a/i18n/pt-PT/Jobs.pt-PT.resx +++ b/i18n/pt-PT/Jobs.pt-PT.resx @@ -76,7 +76,7 @@ Importação Análise rápida Manutenção - Mover arquivo + Reorganização Órfãos Proxies Reconstrução do índice diff --git a/i18n/pt-PT/Library.pt-PT.resx b/i18n/pt-PT/Library.pt-PT.resx index f039dc51..6274b659 100644 --- a/i18n/pt-PT/Library.pt-PT.resx +++ b/i18n/pt-PT/Library.pt-PT.resx @@ -10,17 +10,16 @@ Transferir Exportar lista Pasta - Mover… Abrir Proxies Classificação Renderizar + Reorganizar… Sincronizar Etiquetas… Carregar Verificar Adotar uma pasta - «Mover» funciona com as sequências de um arquivo de cada vez. Igual neste PC e no servidor: nada a sincronizar. Nenhuma vista guardada está em uso; escolha uma primeiro. A sua conta no servidor não pode transferir originais. @@ -32,6 +31,7 @@ Inicie primeiro sessão num Chronos Server, no ecrã Servidor. As sequências selecionadas não têm nada a transferir do servidor. O servidor já tem o que as sequências selecionadas contêm. + A reorganização atua sobre as sequências de um arquivo de cada vez. Apenas para sequências neste PC; a seleção está no servidor. Já está em curso uma transferência desta sequência. Limpar filtros diff --git a/i18n/pt-PT/Server.pt-PT.resx b/i18n/pt-PT/Server.pt-PT.resx index 66260e8e..7741ca08 100644 --- a/i18n/pt-PT/Server.pt-PT.resx +++ b/i18n/pt-PT/Server.pt-PT.resx @@ -40,6 +40,7 @@ A ligação falhou; o registo contém os detalhes. Um ficheiro da sequência está aberto noutro programa; feche-o e tente novamente. A pasta da sequência já não está no disco; não resta nada para mover para o lixo. + A pasta desta sequência não está onde o índice do servidor a indica; tente novamente após o próximo exame do servidor. A sua conta não pode fazer isto. As fotografias da sequência foram alteradas no servidor; recarregue-a e aplique novamente a sua edição. O ficheiro chegou danificado; carregue-o novamente. @@ -68,11 +69,14 @@ Este servidor não pode executar esse tipo de tarefa. O último administrador não pode ser removido nem desativado. Este método não é permitido aqui. + Uma nova pasta ficaria dentro da pasta de outra sequência. Esse endereço não é um Chronos Server. Não encontrado. Altere primeiro a sua palavra-passe. A fotografia foi eliminada da sequência enquanto estava a ser carregada, por isso não foi adicionada. Não é possível ler {0} e, sem o respetivo hash, as outras cópias não saberiam que foi eliminado; feche o programa que o está a utilizar ou verifique as respetivas permissões e tente novamente. + O arquivo foi alterado depois da simulação; reveja novamente o plano. + O servidor deixou de preparar este plano: demorava demasiado ou foram pedidos demasiados planos em simultâneo; tente novamente daqui a pouco. Este arquivo não cria proxies. O proxy foi criado a partir de outra fotografia. O servidor não precisa de um proxy desta fotografia. diff --git a/i18n/pt-PT/Settings.pt-PT.resx b/i18n/pt-PT/Settings.pt-PT.resx index c1af2229..5d653d21 100644 --- a/i18n/pt-PT/Settings.pt-PT.resx +++ b/i18n/pt-PT/Settings.pt-PT.resx @@ -65,6 +65,7 @@ estrelas por megapíxel Largura de análise px no lado maior + As pastas e os ficheiros que já estão no arquivo mantêm os nomes. Nomes de ficheiro Pastas {0} livres @@ -74,10 +75,12 @@ Escolher a pasta do arquivo Pré-visualização Tamanho do proxy + Reorganizar… Repor arquivo Os modelos de nomes, o tamanho dos proxies e o tamanho das miniaturas voltam aos valores predefinidos em todos os PCs e servidores que o utilizam. As pastas e os ficheiros que já estão no arquivo mantêm os nomes. Repor as definições de {0}? Pasta do arquivo + Modelos do arquivo guardados Tamanho da miniatura Voltar a Auto Escolher pasta diff --git a/i18n/pt-PT/Tooltips.pt-PT.resx b/i18n/pt-PT/Tooltips.pt-PT.resx index 100b61d5..252db491 100644 --- a/i18n/pt-PT/Tooltips.pt-PT.resx +++ b/i18n/pt-PT/Tooltips.pt-PT.resx @@ -36,6 +36,7 @@ Abrir a sequência da primeira cópia no ecrã Edição Encontrar fotografias idênticas entre sequências pelo hash · lê apenas o índice Mostrar as sequências deste ano + Nome de ficheiro de cada fotografia, tal como as importações o atribuem · verificado enquanto escreve Manter apenas as sequências de uma câmara Escolher este valor; escolha-o novamente para o limpar Manter apenas as sequências num estado @@ -71,7 +72,10 @@ Reconstruir o índice a partir dos sidecars; recorre a um exame completo dos metadados; nunca elimina originais Colocar a reconstrução em fila · entretanto, o arquivo continua utilizável Escolher a nova pasta de um arquivo que moveu; as respetivas sequências acompanham-no - Fazer exatamente estas alterações nas pastas, nos sidecars e no índice · retoma após uma falha + Colocar em fila uma tarefa que faz exatamente estas alterações · pode pausá-la e retomá-la em Tarefas + Mudar o nome das fotografias com este modelo · se desativado, mantêm os nomes + Mover as pastas das sequências para esta estrutura · se desativado, ficam onde estão + Alterar os títulos com este modelo · se desativado, ficam como estão Escolher uma cópia de segurança do índice em Definições › Avançado; substitui o índice no próximo arranque Alterar as etiquetas destas sequências nos sidecars e no índice Executar novamente a mesma ação @@ -80,9 +84,8 @@ Executar a análise aprofundada em todas as sequências do conjunto Mover o conjunto para o lixo do arquivo · mostra a simulação e, depois, pede-lhe que escreva para confirmar Exportar o conjunto como CSV: uma linha por sequência - Mover o conjunto para uma nova estrutura de pastas · simulação primeiro Criar ou atualizar proxies - Mudar os títulos do conjunto com um modelo · simulação primeiro + Aplicar modelos de pasta, ficheiro e título ao conjunto · simulação primeiro, depois uma tarefa Adicionar ou remover etiquetas em todo o conjunto Criar ou atualizar miniaturas Recalcular o hash dos originais do conjunto @@ -471,12 +474,12 @@ Transferir do servidor o que falta aqui a {0:N0} sequências (originais ou renderizações) · executado como tarefas de transferência Guardar {0:N0} linha como CSV numa pasta à sua escolha Guardar {0:N0} linhas como CSV numa pasta à sua escolha - Mover {0:N0} sequência para uma nova estrutura de pastas do respetivo arquivo · mostra primeiro a simulação - Mover {0:N0} sequências para uma nova estrutura de pastas do respetivo arquivo · mostra primeiro a simulação Criar proxies JPEG de {0:N0} sequência · executado como uma única tarefa Criar proxies JPEG de {0:N0} sequências · executado como uma única tarefa Definir a classificação de {0:N0} sequência, no respetivo sidecar e no índice Definir a classificação de {0:N0} sequências, nos respetivos sidecars e no índice + Aplicar modelos de pasta, ficheiro e título a {0:N0} sequência do respetivo arquivo · simulação primeiro, depois uma tarefa + Aplicar modelos de pasta, ficheiro e título a {0:N0} sequências do respetivo arquivo · simulação primeiro, depois uma tarefa Adicionar ou remover etiquetas em {0:N0} sequência Adicionar ou remover etiquetas em {0:N0} sequências Enviar para o servidor o que lhe falta de {0:N0} sequência (originais e definições, ou renderizações) · executado como tarefa de transferência @@ -692,6 +695,7 @@ Equilibrado serve para a maioria dos trabalhos; Melhor mede com o dobro da resolução e lê mais à frente; Rápido mede com metade da resolução e movimento de rascunho Listar novamente os codificadores após instalar um controlador ou codec Procurar novamente extensões de codec depois de instalar uma; as próximas tarefas utilizam-nas + Aplicar os modelos do arquivo às sequências que já contém · simulação primeiro Repor o valor predefinido de todas as definições deste PC; pede confirmação primeiro Escrever já os modelos e tamanhos predefinidos no archive.json deste arquivo Repor já todas as definições diff --git a/i18n/ro/Admin.ro.resx b/i18n/ro/Admin.ro.resx index 6c60a0d7..49ccf6b0 100644 --- a/i18n/ro/Admin.ro.resx +++ b/i18n/ro/Admin.ro.resx @@ -9,6 +9,7 @@ Chronos Server Rulează de Versiune + {0} a reorganizat arhiva · {1} {0} a modificat structura arhivei {0} a șters {1} {0} a pornit {1} @@ -147,7 +148,7 @@ Import Analiză rapidă Întreținere - Mutare + Reorganizare Fișiere orfane Proxy-uri Reconstruire @@ -367,6 +368,7 @@ Autentificați-vă pentru a administra acest server Utilizator Numele dumneavoastră de utilizator pe acest server + Arhivă reorganizată Structură arhivă Fotografii șterse Lucrare pornită @@ -452,6 +454,63 @@ Schimbare parolă Înlocuiți parola și continuați la panou Alegeți o parolă nouă + Reorganizare… + Aplicați șabloanele de folder, fișier și titlu secvențelor selectate; mai întâi o previzualizare arată fiecare modificare + După: + Aplicare… + Reorganizați așa cum arată previzualizarea; mai întâi se cere o confirmare + Înainte: + Scrieți un șablon sau dezactivați această parte. + Închideți fără a modifica nimic + Mutată indirect + Se mută doar pentru că se mută un folder care o conține + Fișiere redenumite + Folder + Secvență + Reorganizare + Puneți în coadă lucrarea care mută și redenumește originalele; nimic nu este suprascris sau șters + {0} fotografii primesc nume noi. + {0} fotografie primește un nume nou. + {0} de fotografii primesc nume noi. + Se mută {0} foldere. + Se mută {0} folder. + Se mută {0} de foldere. + Se modifică {0} secvențe. + Se modifică {0} secvență. + Se modifică {0} de secvențe. + Reorganizați acum? + Numele fiecărei fotografii așa cum îl dă un import, de ex. {date}_{time}_{n:0000}; fișierele de lângă o fotografie o urmează + Fișiere + Redenumiți fotografiile fiecărei secvențe; dezactivat, se păstrează toate numele de fișiere + {0} fișiere redenumite + {0} fișier redenumit + {0} de fișiere redenumite + Folderul fiecărei secvențe în arhivă, de ex. {year}/{date} {camera}; {title} este noul titlu + Foldere + Mutați fiecare secvență în folderul dat de șablonul ei; dezactivat, fiecare folder rămâne unde este + O secvență selectată nu mai este în arhivă; închideți și selectați din nou. + {0}: {1} + Activați cel puțin o parte de modificat. + Nimic de modificat: aceste secvențe urmează deja șabloanele. + Reorganizare… + Aplicați noile șabloane secvențelor aflate deja în arhivă; mai întâi o previzualizare arată fiecare modificare + Deschidere lucrare + Afișați lucrarea și jurnalul ei în pagina Lucrări + Arhiva s-a modificat în timpul confirmării; verificați noua previzualizare și aplicați din nou. + Planificare… + Previzualizare + Ce devine fiecare secvență, în ordinea în care se aplică modificările; încă nu s-a modificat nimic + Reorganizare pusă în coadă. + Acest folder rămâne unde este + Reorganizare pentru {0} secvențe + Reorganizare pentru {0} secvență + Reorganizare pentru {0} de secvențe + Reorganizare pentru toate secvențele + Noul titlu al fiecărei secvențe, de ex. {date} {camera}; {title} este titlul curent + Titluri + Dați fiecărei secvențe titlul creat de șablonul ei; dezactivat, se păstrează toate titlurile + Reorganizarea acceptă cel mult {0} de secvențe odată sau toate secvențele: resetați filtrele și selectați tot. + Secvențe modificate: {0} · fișiere redenumite: {1} · nume păstrate: {2} Administrator Editor Contribuitor diff --git a/i18n/ro/Archive.ro.resx b/i18n/ro/Archive.ro.resx index eb38956b..9c022da3 100644 --- a/i18n/ro/Archive.ro.resx +++ b/i18n/ro/Archive.ro.resx @@ -16,6 +16,7 @@ Așteptați aplicarea modificărilor. Setul este gol: modificați selecția sau filtrul. Nu s-ar modifica nimic. + Activați cel puțin un șablon. Arhiva trebuie să fie online și să permită scrierea. Așteptați simularea. Așteptați citirea arhivei. @@ -91,6 +92,15 @@ {0} a fost scris de o versiune mai nouă de Chronos (formatul {1}). Arhiva {0} este offline. Arhiva {0} este doar în citire. + {0:N0} secvențe și-au păstrat numele fișierelor: o fotografie era în uz sau noul ei nume era deja folosit. + {0:N0} secvență și-a păstrat numele fișierelor: o fotografie era în uz sau noul ei nume era deja folosit. + {0:N0} de secvențe și-au păstrat numele fișierelor: o fotografie era în uz sau noul ei nume era deja folosit. + {0:N0} secvențe nu au fost reorganizate conform planului: s-au modificat după crearea planului. + {0:N0} secvență nu a fost reorganizată conform planului: s-a modificat după crearea planului. + {0:N0} de secvențe nu au fost reorganizate conform planului: s-au modificat după crearea planului. + {0:N0} secvențe și-au păstrat titlurile și numele fișierelor: fișierele lor de secvență provin dintr-o versiune mai nouă de Chronos. + {0:N0} secvență și-a păstrat titlul și numele fișierelor: fișierul ei de secvență provine dintr-o versiune mai nouă de Chronos. + {0:N0} de secvențe și-au păstrat titlurile și numele fișierelor: fișierele lor de secvență provin dintr-o versiune mai nouă de Chronos. {0} s-a modificat după crearea planului. Cardul sau folderul {0} nu mai este disponibil. Arhiva s-a modificat după crearea acestui plan. @@ -162,6 +172,14 @@ Fotografii neindexate: {0}, fotografii lipsă: {1} {0}: create {1}, reutilizate {2}, ilizibile {3}, în așteptare {4} Proxy-uri pentru server: trimise {0}, netrimise {1} + Lăsată așa cum era, folderul care o conține a rămas pe loc: {0} + Lăsată așa cum era, modificată după crearea planului: {0} + Nume de fișiere păstrate, o fotografie era în uz sau noul ei nume era deja folosit: {0} + Nume de fișiere păstrate, fotografii modificate după crearea planului: {0} + Titlu și nume de fișiere păstrate, fișierul secvenței provine dintr-o versiune mai nouă de Chronos: {0} + Titlu și nume de fișiere păstrate, modificată după crearea planului: {0} + Secvențe modificate: {0}, fișiere redenumite: {1} + Reorganizarea a fost finalizată la deschiderea arhivei Doar raport: nu s-a modificat nimic. Foldere: {0}, indexate: {1}, adoptate: {2}, eliminate: {3} Secvența nu a fost găsită: {0} @@ -219,17 +237,34 @@ Folderul arhivei mutate Aplicare {0} din {1} - Redenumirea a {0:N0} secvențe - Redenumirea unei secvențe - Redenumirea a {0:N0} de secvențe - Mutarea a {0:N0} secvențe - Mutarea unei secvențe - Mutarea a {0:N0} de secvențe Modificări {0:N0} din {1:N0} se modifică {0:N0} din {1:N0} se modifică {0:N0} din {1:N0} se modifică - Șablon + Fotografiile păstrate pe loc în afara folderului originals își păstrează numele. + Fotografiile lipsă își păstrează numele. + Fotografiile care nu au fost verificate niciodată își păstrează numele; verificați mai întâi secvența. + Fișierul secvenței nu poate fi citit; secvența rămâne așa cum este, la fel ca orice folder care o conține. + Urmează folderul său + {0}: din {1} în {2} + Fișier + Nume de fișiere + Folder + Foldere + Reorganizare pentru {0:N0} secvențe + Reorganizare pentru {0:N0} secvență + Reorganizare pentru {0:N0} de secvențe + Reorganizarea arhivei {0} + {0:N0} nume păstrate + {0:N0} nume păstrat + {0:N0} de nume păstrate + Simulare… + {0:N0} fișiere redenumite + {0:N0} fișier redenumit + {0:N0} de fișiere redenumite + Titlu + Titluri + Reorganizarea se deschide după ce se închide fereastra de dialog deschisă Adăugare etichete Aplicare Etichetele a {0:N0} secvențe @@ -246,9 +281,8 @@ Exportare CSV Filtru set Set filtrat - Mutare… Proxy-uri - Redenumire… + Reorganizare… Etichete… Miniaturi Verificare diff --git a/i18n/ro/Errors.ro.resx b/i18n/ro/Errors.ro.resx index 9bd82561..25d9f4e6 100644 --- a/i18n/ro/Errors.ro.resx +++ b/i18n/ro/Errors.ro.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Secvențe neanalizate: {0} din {1}; consultați jurnalul lucrării. + Folderul acestei secvențe nu este acolo unde îl indică indexul; încercați din nou după următoarea scanare. Arhiva nu a putut fi deschisă. Indexul curent nu a putut fi salvat ca copie de rezervă sau înlocuit; restaurarea va rula din nou la următoarea pornire. Această copie de rezervă nu poate fi restaurată; alegeți alta. @@ -39,9 +40,11 @@ {0} de originale lipsesc sau s-au modificat de la arhivare; verificați arhiva. Șablonul este gol. Substituent gol la poziția {1}: scrieți un nume între acolade. + Fotografiile și-ar pierde extensia: scrieți un punct înainte de {ext} sau eliminați {ext}. Numele de fișiere nu pot conține bară oblică; puneți folderele în șablonul de folder. Formatul de după două puncte nu se potrivește cu substituentul său. Numele s-ar repeta: adăugați numărul cadrului, ora sau numele original. + Scanările omit folderele care încep cu un punct sau se numesc originals, proxies sau exports. Acolada deschisă la poziția {1} nu este închisă niciodată. Substituent necunoscut „{0}” la poziția {1}. Acolada de închidere de la poziția {1} nu are o acoladă de deschidere; dublați-o pentru o acoladă literală. diff --git a/i18n/ro/Jobs.ro.resx b/i18n/ro/Jobs.ro.resx index 7f0fb816..33a89e73 100644 --- a/i18n/ro/Jobs.ro.resx +++ b/i18n/ro/Jobs.ro.resx @@ -77,7 +77,7 @@ Import Analiză rapidă Întreținere - Mutare arhivă + Reorganizare Fișiere orfane Proxy-uri Reconstruire index diff --git a/i18n/ro/Library.ro.resx b/i18n/ro/Library.ro.resx index b1c7b608..ede1a8af 100644 --- a/i18n/ro/Library.ro.resx +++ b/i18n/ro/Library.ro.resx @@ -10,17 +10,16 @@ Descărcare Exportare listă Folder - Mutare… Deschidere Proxy-uri Evaluare Randare + Reorganizare… Sincronizare Etichete… Încărcare Verificare Adoptare folder - Mutarea poate cuprinde doar secvențele unei singure arhive. Identică pe acest PC și pe server: nimic de sincronizat. Nicio vizualizare salvată nu este activă; alegeți mai întâi una. Contul dumneavoastră de pe server nu poate descărca originale. @@ -32,6 +31,7 @@ Autentificați-vă mai întâi la un Chronos Server, în ecranul Server. Secvențele selectate nu au nimic de adus de pe server. Serverul are deja tot ce conțin secvențele selectate. + Reorganizarea se aplică secvențelor unei singure arhive odată. Doar pentru secvențele de pe acest PC; selecția se află pe server. Un transfer al acestei secvențe este deja în curs. Resetare filtre diff --git a/i18n/ro/Server.ro.resx b/i18n/ro/Server.ro.resx index 0bcf1ab4..0f723084 100644 --- a/i18n/ro/Server.ro.resx +++ b/i18n/ro/Server.ro.resx @@ -40,6 +40,7 @@ Conexiunea a eșuat; detaliile se află în jurnal. Un fișier al secvenței este deschis în alt program; închideți-l și încercați din nou. Folderul ei nu mai există pe disc; nu a rămas nimic de mutat în coșul de gunoi. + Folderul acestei secvențe nu este acolo unde îl indică indexul serverului; încercați din nou după următoarea lui scanare. Contul dumneavoastră nu poate face acest lucru. Fotografiile secvenței s-au modificat pe server; reîncărcați-o și aplicați din nou modificarea. Fișierul a ajuns deteriorat; încărcați-l din nou. @@ -68,11 +69,14 @@ Acest server nu poate rula acest tip de lucrare. Ultimul administrator nu poate fi eliminat sau dezactivat. Această metodă nu este permisă aici. + Un folder nou ar ajunge în interiorul folderului altei secvențe. Această adresă nu este un Chronos Server. Nu a fost găsit. Mai întâi schimbați-vă parola. Fotografia a fost ștearsă din secvență în timp ce era încărcată, așa că nu a fost adăugată. Fișierul {0} nu poate fi citit, iar fără hash-ul lui celelalte copii nu ar afla că a fost șters; închideți programul care îl folosește sau verificați-i permisiunile, apoi încercați din nou. + Arhiva s-a modificat după simulare; revedeți planul. + Serverul a încetat să pregătească acest plan: dura prea mult sau s-au cerut prea multe planuri simultan; încercați din nou în scurt timp. Această arhivă nu creează proxy-uri. Proxy-ul a fost creat dintr-o altă fotografie. Serverul nu are nevoie de un proxy al acestei fotografii. diff --git a/i18n/ro/Settings.ro.resx b/i18n/ro/Settings.ro.resx index 2ef73067..dff2dbbc 100644 --- a/i18n/ro/Settings.ro.resx +++ b/i18n/ro/Settings.ro.resx @@ -66,6 +66,7 @@ stele pe megapixel Lățime de analiză px pe latura lungă + Folderele și fișierele aflate deja în arhivă își păstrează numele. Nume de fișiere Foldere {0} liberi @@ -75,10 +76,12 @@ Alegeți folderul arhivei Previzualizare Dimensiune proxy + Reorganizare… Resetare arhivă Șabloanele de denumire, dimensiunea proxy-urilor și dimensiunea miniaturilor revin la valorile implicite pentru fiecare PC și server care folosește această arhivă. Folderele și fișierele aflate deja în arhivă își păstrează numele. Resetați setările arhivei {0}? Folder arhivă + Șabloanele arhivei au fost salvate Dimensiune miniaturi Revenire la Auto Alegere folder diff --git a/i18n/ro/Tooltips.ro.resx b/i18n/ro/Tooltips.ro.resx index e82fc2f4..36802171 100644 --- a/i18n/ro/Tooltips.ro.resx +++ b/i18n/ro/Tooltips.ro.resx @@ -37,6 +37,7 @@ Deschideți secvența primei copii în ecranul Editare Găsiți fotografii identice între secvențe după hash · citește doar indexul Afișați secvențele acestui an + Numele de fișier al fiecărei fotografii, așa cum îl dau importurile · verificat în timp ce tastați Păstrați doar secvențele unui singur aparat foto Alegeți această valoare; alegeți-o din nou pentru a renunța la ea Păstrați doar secvențele aflate într-o anumită stare @@ -72,7 +73,10 @@ Reconstruiți indexul din fișierele sidecar; la nevoie se face o scanare completă a metadatelor; originalele nu sunt șterse niciodată Puneți în coadă reconstruirea · între timp arhiva rămâne utilizabilă Alegeți noul folder al unei arhive pe care ați mutat-o; secvențele ei o urmează - Aplicați exact aceste modificări folderelor, fișierelor sidecar și indexului · se reia după un blocaj + Puneți în coadă o lucrare care face exact aceste modificări · o puteți pune pe pauză și relua în Lucrări + Redenumiți fotografiile cu acest șablon · dezactivat, își păstrează numele + Mutați folderele secvențelor în această structură · dezactivat, rămân unde sunt + Modificați titlurile cu acest șablon · dezactivat, rămân așa cum sunt Alegeți o copie de rezervă a indexului în Setări › Avansat; aceasta înlocuiește indexul la următoarea pornire Modificați etichetele acestor secvențe în fișierele sidecar și în index Rulați din nou aceeași acțiune @@ -81,9 +85,8 @@ Rulați analiza aprofundată pe fiecare secvență din set Mutați setul în coșul de gunoi al arhivei · afișează simularea, apoi vă cere să tastați pentru a confirma Exportați setul ca CSV: câte un rând pentru fiecare secvență - Mutați setul într-o nouă structură de foldere · mai întâi o simulare Generați sau reîmprospătați proxy-urile - Redenumiți titlurile setului cu un șablon · mai întâi o simulare + Aplicați șabloanele de folder, fișier și titlu setului · mai întâi o simulare, apoi o lucrare Adăugați sau eliminați etichete pe întregul set Generați sau reîmprospătați miniaturile Recalculați hash-ul originalelor setului @@ -478,15 +481,15 @@ Salvați {0:N0} rânduri ca CSV într-un folder ales de dumneavoastră Salvați {0:N0} rând ca CSV într-un folder ales de dumneavoastră Salvați {0:N0} de rânduri ca CSV într-un folder ales de dumneavoastră - Mutați {0:N0} secvențe într-o nouă structură de foldere a arhivei lor · afișează mai întâi simularea - Mutați {0:N0} secvență într-o nouă structură de foldere a arhivei ei · afișează mai întâi simularea - Mutați {0:N0} de secvențe într-o nouă structură de foldere a arhivei lor · afișează mai întâi simularea Creați proxy-uri JPEG pentru {0:N0} secvențe · rulează ca o singură lucrare Creați proxy-uri JPEG pentru {0:N0} secvență · rulează ca o singură lucrare Creați proxy-uri JPEG pentru {0:N0} de secvențe · rulează ca o singură lucrare Setați evaluarea pentru {0:N0} secvențe, în fișierele lor sidecar și în index Setați evaluarea pentru {0:N0} secvență, în fișierul ei sidecar și în index Setați evaluarea pentru {0:N0} de secvențe, în fișierele lor sidecar și în index + Aplicați șabloanele de folder, fișier și titlu pentru {0:N0} secvențe din arhiva lor · mai întâi o simulare, apoi o lucrare + Aplicați șabloanele de folder, fișier și titlu pentru {0:N0} secvență din arhiva ei · mai întâi o simulare, apoi o lucrare + Aplicați șabloanele de folder, fișier și titlu pentru {0:N0} de secvențe din arhiva lor · mai întâi o simulare, apoi o lucrare Adăugați sau eliminați etichete pentru {0:N0} secvențe Adăugați sau eliminați etichete pentru {0:N0} secvență Adăugați sau eliminați etichete pentru {0:N0} de secvențe @@ -711,6 +714,7 @@ Echilibrat se potrivește în majoritatea cazurilor; Calitate maximă măsoară la rezoluție dublă și citește mai mult în avans; Rapid măsoară la jumătate de rezoluție, cu flux optic de calitate Schiță Listați din nou codificatoarele după instalarea unui driver sau a unui codec Căutați din nou extensiile de codec după instalarea uneia; următoarele lucrări le folosesc + Aplicați șabloanele arhivei secvențelor pe care le conține deja · mai întâi o simulare Readuceți fiecare setare a acestui PC la valoarea implicită; se cere mai întâi confirmarea Scrieți acum șabloanele și dimensiunile implicite în fișierul archive.json al acestei arhive Resetați acum toate setările diff --git a/i18n/ru/Admin.ru.resx b/i18n/ru/Admin.ru.resx index 0c8da9d2..663aff5f 100644 --- a/i18n/ru/Admin.ru.resx +++ b/i18n/ru/Admin.ru.resx @@ -9,6 +9,7 @@ Chronos Server Время работы Версия + {0}: архив реорганизован · {1} {0}: изменена структура архива {0}: удалено {1} {0}: запущено задание {1} @@ -156,7 +157,7 @@ Импорт Быстрый анализ Обслуживание - Перемещение + Реорганизация Неучтённые файлы Прокси Перестроение @@ -391,6 +392,7 @@ Войти, чтобы администрировать этот сервер Пользователь Ваше имя пользователя на этом сервере + Реорганизация архива Структура архива Удаление фото Запуск задания @@ -478,6 +480,68 @@ Сменить пароль Заменить пароль и перейти к панели Задайте новый пароль + Реорганизовать… + Применить шаблоны папок, имён файлов и названий к выбранным сериям; сначала предпросмотр покажет каждое изменение + После: + Применить… + Реорганизовать, как показано в предпросмотре; сначала будет запрошено подтверждение + До: + Введите шаблон или отключите эту часть. + Закрыть, ничего не меняя + Вместе с папкой + Перемещается только потому, что перемещается содержащая её папка + Переименованные файлы + Папка + Серия + Реорганизовать + Поставить в очередь задание, которое переместит и переименует оригиналы; ничего не перезаписывается и не удаляется + {0} фото получат новые имена. + {0} фото получат новые имена. + {0} фото получит новое имя. + {0} фото получат новые имена. + Будут перемещены {0} папки. + Будет перемещено {0} папок. + Будет перемещена {0} папка. + Будут перемещены {0} папки. + Изменятся {0} серии. + Изменится {0} серий. + Изменится {0} серия. + Изменятся {0} серии. + Реорганизовать сейчас? + Имя каждого фото, как его задаёт импорт, например {date}_{time}_{n:0000}; файлы рядом с фото следуют за ним + Файлы + Переименовать фото каждой серии; если выключено, все имена файлов сохраняются + {0} файла переименованы + {0} файлов переименовано + {0} файл переименован + {0} файла переименованы + Папка каждой серии в архиве, например {year}/{date} {camera}; {title} — новое название + Папки + Переместить каждую серию в папку, заданную её шаблоном; если выключено, все папки остаются на месте + Выбранной серии больше нет в архиве; закройте окно и выберите серии снова. + {0}: {1} + Включите хотя бы одну часть, которую нужно изменить. + Менять нечего: эти серии уже соответствуют шаблонам. + Реорганизовать… + Применить новые шаблоны к сериям, которые уже есть в архиве; сначала предпросмотр покажет каждое изменение + Открыть задание + Показать задание и его журнал на странице «Задания» + Архив изменился во время подтверждения; проверьте новый предпросмотр и примените снова. + Планирование… + Предпросмотр + Чем станет каждая серия, в порядке применения изменений; пока ничего не изменено + Реорганизация поставлена в очередь. + Эта папка остаётся на месте + Реорганизовать {0} серии + Реорганизовать {0} серий + Реорганизовать {0} серию + Реорганизовать {0} серии + Реорганизовать все серии + Новое название каждой серии, например {date} {camera}; {title} — текущее название + Названия + Дать каждой серии название, созданное её шаблоном; если выключено, все названия сохраняются + За один раз можно реорганизовать не более {0} серий или все серии сразу: сбросьте фильтры и выберите всё. + Изменено серий: {0} · переименовано файлов: {1} · сохранено имён: {2} Администратор Редактор Загрузчик diff --git a/i18n/ru/Archive.ru.resx b/i18n/ru/Archive.ru.resx index 8e6b3ab1..4ac10d22 100644 --- a/i18n/ru/Archive.ru.resx +++ b/i18n/ru/Archive.ru.resx @@ -17,6 +17,7 @@ Дождитесь применения изменений. Выборка пуста: измените выделение или фильтр. Ничего не изменится. + Включите хотя бы один шаблон. Архив должен быть в сети и доступен для записи. Дождитесь окончания пробного запуска. Дождитесь окончания чтения архива. @@ -101,6 +102,18 @@ {0}: записано более новой версией Chronos (формат {1}). Архив {0} недоступен. Архив {0} доступен только для чтения. + {0:N0} серии сохранили имена файлов: фото использовалось или его новое имя было занято. + {0:N0} серий сохранили имена файлов: фото использовалось или его новое имя было занято. + {0:N0} серия сохранила имена файлов: фото использовалось или его новое имя было занято. + {0:N0} серии сохранили имена файлов: фото использовалось или его новое имя было занято. + {0:N0} серии не реорганизованы по плану: они изменились после составления плана. + {0:N0} серий не реорганизовано по плану: они изменились после составления плана. + {0:N0} серия не реорганизована по плану: она изменилась после составления плана. + {0:N0} серии не реорганизованы по плану: они изменились после составления плана. + {0:N0} серии сохранили названия и имена файлов: их файлы серий созданы более новой версией Chronos. + {0:N0} серий сохранили названия и имена файлов: их файлы серий созданы более новой версией Chronos. + {0:N0} серия сохранила название и имена файлов: её файл серии создан более новой версией Chronos. + {0:N0} серии сохранили названия и имена файлов: их файлы серий созданы более новой версией Chronos. После составления плана изменилось: {0}. Карта или папка {0} больше недоступна. Архив изменился после составления этого плана. @@ -178,6 +191,14 @@ Фото вне индекса: {0}, отсутствующих фото: {1} {0}: создано {1}, использовано повторно {2}, не читается {3}, в ожидании {4} Прокси для сервера: отправлено {0}, не отправлено {1} + Оставлена как была, содержащая её папка осталась на месте: {0} + Оставлена как была, изменилась после составления плана: {0} + Имена файлов сохранены, фото использовалось или его новое имя было занято: {0} + Имена файлов сохранены, фото изменились после составления плана: {0} + Название и имена файлов сохранены, файл серии создан более новой версией Chronos: {0} + Название и имена файлов сохранены, серия изменилась после составления плана: {0} + Изменено серий: {0}, переименовано файлов: {1} + Реорганизация завершена при открытии архива Только отчёт: ничего не изменено. Папок: {0}, проиндексировано: {1}, присоединено: {2}, убрано: {3} Серия не найдена: {0} @@ -238,20 +259,38 @@ Папка перемещённого архива Применить {0} из {1} - Переименовать {0:N0} серии - Переименовать {0:N0} серий - Переименовать {0:N0} серию - Переименовать {0:N0} серии - Переместить {0:N0} серии - Переместить {0:N0} серий - Переместить {0:N0} серию - Переместить {0:N0} серии Изменения Изменятся {0:N0} из {1:N0} Изменится {0:N0} из {1:N0} Изменится {0:N0} из {1:N0} Изменится {0:N0} из {1:N0} - Шаблон + Фото, оставленные на месте вне папки originals, сохраняют свои имена. + Отсутствующие фото сохраняют свои имена. + Ни разу не проверенные фото сохраняют свои имена; сначала проверьте серию. + Не удаётся прочитать файл серии; серия остаётся как есть, как и любая содержащая её папка. + Следует за папкой + {0}: было {1}, станет {2} + Файл + Имена файлов + Папка + Папки + Реорганизовать {0:N0} серии + Реорганизовать {0:N0} серий + Реорганизовать {0:N0} серию + Реорганизовать {0:N0} серии + Реорганизовать архив {0} + {0:N0} имени сохранены + {0:N0} имён сохранено + {0:N0} имя сохранено + {0:N0} имени сохранены + Пробный запуск… + {0:N0} файла переименованы + {0:N0} файлов переименовано + {0:N0} файл переименован + {0:N0} файла переименованы + Название + Названия + Окно реорганизации откроется, когда будет закрыто открытое сейчас окно Добавить теги Применить Теги {0:N0} серий @@ -270,9 +309,8 @@ Экспортировать в CSV Фильтр выборки Выборка - Переместить… Прокси - Переименовать… + Реорганизовать… Изменить теги… Эскизы Проверить diff --git a/i18n/ru/Errors.ru.resx b/i18n/ru/Errors.ru.resx index 882dba01..184bfeb2 100644 --- a/i18n/ru/Errors.ru.resx +++ b/i18n/ru/Errors.ru.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Не проанализировано серий: {0} из {1}; подробности — в журнале задания. + Папка этой серии находится не там, где указано в индексе; повторите попытку после следующего сканирования. Не удалось открыть архив. Не удалось создать резервную копию текущего индекса или заменить его; восстановление повторится при следующем запуске. Эту резервную копию нельзя восстановить; выберите другую. @@ -41,9 +42,11 @@ {0} оригинала отсутствуют или изменились после архивации; проверьте архив. Шаблон пуст. Пустая метка в позиции {1}: впишите имя между фигурными скобками. + Фото потеряют расширение: поставьте точку перед {ext} или уберите {ext}. Имена файлов не могут содержать косую черту; папки задаются в шаблоне папок. Формат после двоеточия не подходит для этой метки. Имена будут повторяться: добавьте номер кадра, время или исходное имя. + При сканировании пропускаются папки, имена которых начинаются с точки или совпадают с originals, proxies или exports. Фигурная скобка, открытая в позиции {1}, не закрыта. Неизвестная метка «{0}» в позиции {1}. У закрывающей фигурной скобки в позиции {1} нет открывающей; чтобы вставить скобку как текст, удвойте её. diff --git a/i18n/ru/Jobs.ru.resx b/i18n/ru/Jobs.ru.resx index 360c70bd..33263986 100644 --- a/i18n/ru/Jobs.ru.resx +++ b/i18n/ru/Jobs.ru.resx @@ -78,7 +78,7 @@ Импорт Быстрый анализ Обслуживание - Перемещение архива + Реорганизация Неучтённые файлы Прокси Перестроение индекса diff --git a/i18n/ru/Library.ru.resx b/i18n/ru/Library.ru.resx index 3fcbc5f7..e4042aee 100644 --- a/i18n/ru/Library.ru.resx +++ b/i18n/ru/Library.ru.resx @@ -10,17 +10,16 @@ Скачать Экспорт списка Папка - Переместить… Открыть Прокси Оценка Отрендерить + Реорганизовать… Синхронизировать Теги… Загрузить Проверить Присоединить папку - За один раз можно перемещать серии только одного архива. Серия одинакова на этом ПК и на сервере: синхронизировать нечего. Сохранённое представление не выбрано; сначала выберите его. Вашей учётной записи на сервере не разрешено скачивать оригиналы. @@ -32,6 +31,7 @@ Сначала откройте страницу «Сервер» и войдите на Chronos Server. Для выбранных серий на сервере нечего скачивать. На сервере уже есть всё, что содержат выбранные серии. + Реорганизация работает с сериями только одного архива за раз. Только для серий на этом ПК; выбранные серии хранятся на сервере. Передача этой серии уже выполняется. Сбросить фильтры diff --git a/i18n/ru/Server.ru.resx b/i18n/ru/Server.ru.resx index f6315e33..2944f06c 100644 --- a/i18n/ru/Server.ru.resx +++ b/i18n/ru/Server.ru.resx @@ -40,6 +40,7 @@ Сбой подключения; подробности — в журнале. Файл этой серии открыт в другой программе; закройте его и повторите попытку. Папки этой серии больше нет на диске; перемещать в корзину нечего. + Папка этой серии находится не там, где указано в индексе сервера; повторите попытку после его следующего сканирования. Вашей учётной записи это не разрешено. Фото серии изменились на сервере; обновите её и повторите правку. Файл пришёл повреждённым; загрузите его снова. @@ -68,11 +69,14 @@ Этот сервер не может выполнять задания такого типа. Нельзя удалить или отключить последнего администратора. Этот метод здесь не разрешён. + Новая папка оказалась бы внутри папки другой серии. По этому адресу находится не Chronos Server. Не найдено. Сначала смените пароль. Фото было удалено из серии во время загрузки, поэтому оно не добавлено. Не удаётся прочитать файл {0}, а без его хеша другие копии не узнают о его удалении; закройте программу, которая его использует, или проверьте права доступа и повторите попытку. + Архив изменился после пробного запуска; просмотрите план ещё раз. + Сервер прекратил составление этого плана: оно заняло слишком много времени или одновременно было запрошено слишком много планов; повторите попытку чуть позже. Этот архив не создаёт прокси. Прокси создан из другого фото. Серверу не нужен прокси этого фото. diff --git a/i18n/ru/Settings.ru.resx b/i18n/ru/Settings.ru.resx index 235f46ff..9ea220d0 100644 --- a/i18n/ru/Settings.ru.resx +++ b/i18n/ru/Settings.ru.resx @@ -67,6 +67,7 @@ звёзд на мегапиксель Ширина анализа пикс. по длинной стороне + Папки и файлы, уже находящиеся в архиве, сохраняют свои имена. Имена файлов Папки Свободно {0} @@ -76,10 +77,12 @@ Выберите папку архива Предпросмотр Размер прокси + Реорганизовать… Сбросить параметры Его шаблоны имён, размер прокси и размер эскизов вернутся к значениям по умолчанию для всех ПК и серверов, которые его используют. Папки и файлы, уже находящиеся в архиве, сохранят свои имена. Сбросить параметры архива {0}? Папка архива + Шаблоны архива сохранены Размер эскизов Вернуть «Авто» Выбрать папку diff --git a/i18n/ru/Tooltips.ru.resx b/i18n/ru/Tooltips.ru.resx index 7ff0fda9..7f8fcf26 100644 --- a/i18n/ru/Tooltips.ru.resx +++ b/i18n/ru/Tooltips.ru.resx @@ -38,6 +38,7 @@ Открыть серию первой копии на странице «Редактирование» Найти одинаковые фото в разных сериях по хешу · читается только индекс Показать серии этого года + Имя файла каждого фото, как его задаёт импорт · проверяется по мере ввода Оставить только серии одной камеры Выбрать это значение; повторный выбор снимает его Оставить только серии в одном состоянии @@ -73,7 +74,10 @@ Перестроить индекс по sidecar-файлам, а без них — полным сканированием метаданных; оригиналы никогда не удаляются Поставить перестроение в очередь · архивом можно пользоваться и в это время Выбрать новую папку перемещённого архива; пути его серий обновятся - Внести именно эти изменения в папки, sidecar-файлы и индекс · после сбоя работа продолжится + Поставить в очередь задание, которое внесёт ровно эти изменения · его можно приостановить и возобновить на странице «Задания» + Переименовать фото по этому шаблону · если выключено, имена сохраняются + Переместить папки серий в эту структуру · если выключено, они остаются на месте + Изменить названия по этому шаблону · если выключено, они остаются прежними Выберите резервную копию индекса в разделе «Параметры › Дополнительно»; она заменит индекс при следующем запуске Изменить теги этих серий в sidecar-файлах и индексе Выполнить то же действие ещё раз @@ -82,9 +86,8 @@ Выполнить глубокий анализ каждой серии выборки Переместить выборку в корзину архива · сначала пробный запуск, затем подтверждение вводом Экспортировать выборку в CSV: одна строка на серию - Переместить выборку в новую структуру папок · сначала пробный запуск Создать или обновить прокси - Переименовать серии выборки по шаблону · сначала пробный запуск + Применить шаблоны папок, имён файлов и названий к выборке · сначала пробный запуск, затем задание Добавить или убрать теги у всей выборки Создать или обновить эскизы Заново вычислить хеши оригиналов выборки @@ -485,10 +488,6 @@ Сохранить {0:N0} строк как CSV в выбранной папке Сохранить {0:N0} строку как CSV в выбранной папке Сохранить {0:N0} строки как CSV в выбранной папке - Переместить {0:N0} серии в новую структуру папок их архива · сначала пробный запуск - Переместить {0:N0} серий в новую структуру папок их архива · сначала пробный запуск - Переместить {0:N0} серию в новую структуру папок её архива · сначала пробный запуск - Переместить {0:N0} серии в новую структуру папок их архива · сначала пробный запуск Создать JPEG-прокси для {0:N0} серий · выполняется одним заданием Создать JPEG-прокси для {0:N0} серий · выполняется одним заданием Создать JPEG-прокси для {0:N0} серии · выполняется одним заданием @@ -497,6 +496,10 @@ Задать оценку {0:N0} серий в их sidecar-файлах и индексе Задать оценку {0:N0} серии в её sidecar-файле и индексе Задать оценку {0:N0} серии в их sidecar-файлах и индексе + Применить шаблоны папок, имён файлов и названий к {0:N0} сериям их архива · сначала пробный запуск, затем задание + Применить шаблоны папок, имён файлов и названий к {0:N0} сериям их архива · сначала пробный запуск, затем задание + Применить шаблоны папок, имён файлов и названий к {0:N0} серии её архива · сначала пробный запуск, затем задание + Применить шаблоны папок, имён файлов и названий к {0:N0} сериям их архива · сначала пробный запуск, затем задание Добавить или убрать теги у {0:N0} серий Добавить или убрать теги у {0:N0} серий Добавить или убрать теги у {0:N0} серии @@ -730,6 +733,7 @@ «Сбалансированный» подходит для большинства задач; «Наилучший» измеряет в двойном разрешении и читает дальше вперёд; «Быстрый» измеряет в половинном разрешении с черновой оценкой движения Заново составить список кодировщиков после установки драйвера или кодека Снова найти расширения кодеков после установки одного из них; следующие задания будут их использовать + Применить шаблоны архива к сериям, которые уже в нём есть · сначала пробный запуск Вернуть все параметры этого ПК к значениям по умолчанию; сначала будет запрошено подтверждение Записать шаблоны и размеры по умолчанию в archive.json этого архива сейчас Сбросить все параметры сейчас diff --git a/i18n/sk/Admin.sk.resx b/i18n/sk/Admin.sk.resx index e3428f73..e3eaf3c3 100644 --- a/i18n/sk/Admin.sk.resx +++ b/i18n/sk/Admin.sk.resx @@ -9,6 +9,7 @@ Chronos Server Doba prevádzky Verzia + Používateľ {0} reorganizoval archív · {1} Používateľ {0} zmenil usporiadanie archívu Používateľ {0} odstránil {1} Používateľ {0} spustil {1} @@ -147,7 +148,7 @@ Import Rýchla analýza Údržba - Presun + Reorganizácia Osirotené súbory Proxy Zostavenie indexu @@ -367,6 +368,7 @@ Prihlási vás na správu tohto servera Používateľ Vaše používateľské meno na tomto serveri + Reorganizovaný archív Usporiadanie archívu Odstránené fotografie Spustená úloha @@ -452,6 +454,63 @@ Zmeniť heslo Nahradí heslo a pokračuje do panela Zvoľte nové heslo + Reorganizovať… + Použije šablóny priečinkov, súborov a názvov na vybraté sekvencie; najprv sa v náhľade zobrazí každá zmena + Po: + Použiť… + Reorganizuje podľa náhľadu; najprv si vyžiada potvrdenie + Pred: + Napíšte šablónu alebo túto časť vypnite. + Zavrie okno bez akejkoľvek zmeny + Presunutá s priečinkom + Presúva sa iba preto, že sa presúva priečinok, v ktorom sa nachádza + Premenované súbory + Priečinok + Sekvencia + Reorganizovať + Zaradí do frontu úlohu, ktorá presunie a premenuje originály; nič sa neprepíše ani neodstráni + {0} fotografie dostanú nové názvy. + {0} fotografia dostane nový názov. + {0} fotografií dostane nové názvy. + Presunú sa {0} priečinky. + Presunie sa {0} priečinok. + Presunie sa {0} priečinkov. + Zmenia sa {0} sekvencie. + Zmení sa {0} sekvencia. + Zmení sa {0} sekvencií. + Reorganizovať teraz? + Názov každej fotografie, ako ho dáva import, napríklad {date}_{time}_{n:0000}; súbory vedľa fotografie ju nasledujú + Súbory + Premenuje fotografie každej sekvencie; pri vypnutí sa ponechajú všetky názvy súborov + {0} premenované súbory + {0} premenovaný súbor + {0} premenovaných súborov + Priečinok každej sekvencie v archíve, napríklad {year}/{date} {camera}; {title} je nový názov + Priečinky + Presunie každú sekvenciu do priečinka podľa jej šablóny; pri vypnutí zostane každý priečinok na mieste + Vybratá sekvencia už nie je v archíve; zavrite okno a vyberte znova. + {0}: {1} + Zapnite aspoň jednu časť, ktorá sa má zmeniť. + Nie je čo meniť: tieto sekvencie už zodpovedajú šablónam. + Reorganizovať… + Použije nové šablóny na sekvencie, ktoré už sú v archíve; najprv sa v náhľade zobrazí každá zmena + Otvoriť úlohu + Zobrazí úlohu a jej denník na stránke Úlohy + Archív sa počas potvrdzovania zmenil; skontrolujte nový náhľad a použite zmeny znova. + Plánovanie… + Náhľad + Čím sa stane každá sekvencia, v poradí, v akom sa zmeny použijú; zatiaľ sa nič nezmenilo + Reorganizácia zaradená do frontu. + Tento priečinok zostane na mieste + Reorganizovať {0} sekvencie + Reorganizovať {0} sekvenciu + Reorganizovať {0} sekvencií + Reorganizovať všetky sekvencie + Nový názov každej sekvencie, napríklad {date} {camera}; {title} je aktuálny názov + Názvy + Dá každej sekvencii názov podľa jej šablóny; pri vypnutí sa ponechajú všetky názvy + Reorganizácia naraz spracuje najviac {0} sekvencií alebo všetky sekvencie: vymažte filtre a vyberte všetko. + Zmenené sekvencie: {0} · premenované súbory: {1} · ponechané názvy: {2} Správca Editor Odosielateľ diff --git a/i18n/sk/Archive.sk.resx b/i18n/sk/Archive.sk.resx index d4bc1425..b74f93c4 100644 --- a/i18n/sk/Archive.sk.resx +++ b/i18n/sk/Archive.sk.resx @@ -16,6 +16,7 @@ Počkajte, kým sa zmeny použijú. Filtrovaný výber je prázdny: zmeňte výber alebo filter. Nič by sa nezmenilo. + Zapnite aspoň jednu šablónu. Archív musí byť online a zapisovateľný. Počkajte na skúšobný beh. Počkajte, kým sa archív načíta. @@ -91,6 +92,15 @@ Položku {0} zapísala novšia verzia Chronos (formát {1}). Archív {0} je offline. Archív {0} je iba na čítanie. + {0:N0} sekvencie si ponechali názvy súborov: fotografia sa používala alebo jej nový názov bol obsadený. + {0:N0} sekvencia si ponechala názvy súborov: fotografia sa používala alebo jej nový názov bol obsadený. + {0:N0} sekvencií si ponechalo názvy súborov: fotografia sa používala alebo jej nový názov bol obsadený. + {0:N0} sekvencie sa nereorganizovali podľa plánu: zmenili sa po vytvorení plánu. + {0:N0} sekvencia sa nereorganizovala podľa plánu: zmenila sa po vytvorení plánu. + {0:N0} sekvencií sa nereorganizovalo podľa plánu: zmenili sa po vytvorení plánu. + {0:N0} sekvencie si ponechali názvy a názvy súborov: ich súbory sekvencií pochádzajú z novšej verzie Chronos. + {0:N0} sekvencia si ponechala názov a názvy súborov: jej súbor sekvencie pochádza z novšej verzie Chronos. + {0:N0} sekvencií si ponechalo názvy a názvy súborov: ich súbory sekvencií pochádzajú z novšej verzie Chronos. Položka {0} sa zmenila po vytvorení plánu. Karta alebo priečinok {0} už nie je k dispozícii. Archív sa zmenil po vytvorení tohto plánu. @@ -162,6 +172,14 @@ Neindexované fotografie: {0}, chýbajúce fotografie: {1} {0} – vytvorené: {1}, znova použité: {2}, nečitateľné: {3}, čakajúce: {4} Proxy pre server – odoslané: {0}, neodoslané: {1} + Ponechaná bez zmeny, priečinok, v ktorom sa nachádza, zostal na mieste: {0} + Ponechaná bez zmeny, zmenila sa po vytvorení plánu: {0} + Názvy súborov ponechané, fotografia sa používala alebo jej nový názov bol obsadený: {0} + Názvy súborov ponechané, fotografie sa zmenili po vytvorení plánu: {0} + Názov a názvy súborov ponechané, jej súbor sekvencie pochádza z novšej verzie Chronos: {0} + Názov a názvy súborov ponechané, zmenila sa po vytvorení plánu: {0} + Zmenené sekvencie: {0}, premenované súbory: {1} + Reorganizácia sa dokončila pri otvorení archívu Iba prehľad: nič sa nezmenilo. Priečinky: {0}, indexované: {1}, prevzaté: {2}, odobraté: {3} Sekvencia sa nenašla: {0} @@ -219,17 +237,34 @@ Priečinok presunutého archívu Použiť {0} z {1} - Premenovať {0:N0} sekvencie - Premenovať {0:N0} sekvenciu - Premenovať {0:N0} sekvencií - Presunúť {0:N0} sekvencie - Presunúť {0:N0} sekvenciu - Presunúť {0:N0} sekvencií Zmeny Zmenia sa {0:N0} z {1:N0} Zmení sa {0:N0} z {1:N0} Zmení sa {0:N0} z {1:N0} - Šablóna + Fotografie ponechané na mieste mimo priečinka originals si ponechajú svoje názvy. + Chýbajúce fotografie si ponechajú svoje názvy. + Fotografie, ktoré sa nikdy neoverili, si ponechajú svoje názvy; najprv overte sekvenciu. + Súbor sekvencie sa nedá prečítať; sekvencia zostane tak, ako je, a rovnako aj každý priečinok, v ktorom sa nachádza. + Nasleduje svoj priečinok + {0}: z {1} na {2} + Súbor + Názvy súborov + Priečinok + Priečinky + Reorganizovať {0:N0} sekvencie + Reorganizovať {0:N0} sekvenciu + Reorganizovať {0:N0} sekvencií + Reorganizovať archív {0} + {0:N0} ponechané názvy + {0:N0} ponechaný názov + {0:N0} ponechaných názvov + Skúšobný beh… + {0:N0} premenované súbory + {0:N0} premenovaný súbor + {0:N0} premenovaných súborov + Názov + Názvy + Reorganizácia sa otvorí po zatvorení otvoreného dialógového okna Pridať značky Použiť Značky {0:N0} sekvencií @@ -246,9 +281,8 @@ Exportovať CSV Filter výberu Filtrovaný výber - Presunúť… Proxy - Premenovať… + Reorganizovať… Značky… Miniatúry Overiť diff --git a/i18n/sk/Errors.sk.resx b/i18n/sk/Errors.sk.resx index 189be408..c8b2da6b 100644 --- a/i18n/sk/Errors.sk.resx +++ b/i18n/sk/Errors.sk.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Neanalyzované sekvencie: {0} z {1}; pozrite si denník úlohy. + Priečinok tejto sekvencie nie je tam, kde ho uvádza index; skúste to znova po ďalšom skenovaní. Archív sa nepodarilo otvoriť. Aktuálny index sa nepodarilo zálohovať ani nahradiť; obnovenie sa zopakuje pri ďalšom spustení. Túto zálohu nemožno obnoviť; vyberte inú. @@ -39,9 +40,11 @@ {0} originálov chýba alebo sa od archivácie zmenilo; overte archív. Šablóna je prázdna. Prázdny zástupný symbol na pozícii {1}: medzi zložené zátvorky napíšte názov. + Fotografie by stratili príponu: pred {ext} napíšte bodku alebo {ext} vynechajte. Názvy súborov nemôžu obsahovať lomku; priečinky zadajte v šablóne priečinkov. Formát za dvojbodkou nezodpovedá svojmu zástupnému symbolu. Názvy by sa opakovali: pridajte číslo snímky, čas alebo pôvodný názov. + Skenovanie vynecháva priečinky, ktorých názov sa začína bodkou alebo znie originals, proxies či exports. Zložená zátvorka otvorená na pozícii {1} sa nikde neuzatvára. Neznámy zástupný symbol „{0}“ na pozícii {1}. Uzatváracia zložená zátvorka na pozícii {1} nemá otváraciu; ak ju chcete zapísať ako znak, zdvojte ju. diff --git a/i18n/sk/Jobs.sk.resx b/i18n/sk/Jobs.sk.resx index bd62c5a6..001dd314 100644 --- a/i18n/sk/Jobs.sk.resx +++ b/i18n/sk/Jobs.sk.resx @@ -77,7 +77,7 @@ Import Rýchla analýza Údržba - Presun archívu + Reorganizácia Osirotené súbory Proxy Zostavenie indexu diff --git a/i18n/sk/Library.sk.resx b/i18n/sk/Library.sk.resx index 231968af..c5106ca2 100644 --- a/i18n/sk/Library.sk.resx +++ b/i18n/sk/Library.sk.resx @@ -10,17 +10,16 @@ Stiahnuť Exportovať zoznam Priečinok - Presunúť… Otvoriť Proxy Hodnotenie Renderovať + Reorganizovať… Synchronizovať Značky… Nahrať Overiť Prevziať priečinok - Presun funguje naraz iba so sekvenciami jedného archívu. Sekvencia je rovnaká na tomto počítači aj na serveri: nie je čo synchronizovať. Nepoužíva sa žiadne uložené zobrazenie; najprv nejaké vyberte. Váš účet na serveri nemôže sťahovať originály. @@ -32,6 +31,7 @@ Najprv sa na obrazovke Server prihláste k serveru Chronos Server. Pre vybraté sekvencie nie je zo servera čo stiahnuť. Server už má všetko, čo obsahujú vybraté sekvencie. + Reorganizácia pracuje vždy so sekvenciami iba jedného archívu. Iba pre sekvencie na tomto počítači; výber je uložený na serveri. Prenos tejto sekvencie už prebieha. Vymazať filtre diff --git a/i18n/sk/Server.sk.resx b/i18n/sk/Server.sk.resx index 914f8ea8..822b20e7 100644 --- a/i18n/sk/Server.sk.resx +++ b/i18n/sk/Server.sk.resx @@ -40,6 +40,7 @@ Pripojenie zlyhalo; podrobnosti sú v denníku. Súbor sekvencie je otvorený v inom programe; zavrite ho a skúste to znova. Jej priečinok už nie je na disku; do koša nie je čo presunúť. + Priečinok tejto sekvencie nie je tam, kde ho uvádza index servera; skúste to znova po jeho ďalšom skenovaní. Váš účet to nemôže urobiť. Fotografie sekvencie sa na serveri zmenili; znova ju načítajte a zopakujte úpravu. Súbor dorazil poškodený; nahrajte ho znova. @@ -68,11 +69,14 @@ Tento server nedokáže spustiť taký druh úlohy. Posledného správcu nemožno odstrániť ani zakázať. Táto metóda tu nie je povolená. + Nový priečinok by sa ocitol v priečinku inej sekvencie. Na tejto adrese nie je Chronos Server. Nenašlo sa. Najprv si zmeňte heslo. Fotografia bola počas nahrávania odstránená zo sekvencie, preto sa nepridala. Súbor {0} nemožno prečítať a bez jeho hashu by sa ostatné kópie nedozvedeli, že bol odstránený; zatvorte program, ktorý ho používa, alebo skontrolujte jeho oprávnenia a skúste to znova. + Archív sa po skúšobnom behu zmenil; znova si prezrite plán. + Server prestal pripravovať tento plán: trvalo to príliš dlho alebo sa naraz vyžiadalo príliš veľa plánov; skúste to o chvíľu znova. Tento archív nevytvára proxy. Proxy pochádza z inej fotografie. Server nepotrebuje proxy tejto fotografie. diff --git a/i18n/sk/Settings.sk.resx b/i18n/sk/Settings.sk.resx index 0d65559f..56c2e507 100644 --- a/i18n/sk/Settings.sk.resx +++ b/i18n/sk/Settings.sk.resx @@ -66,6 +66,7 @@ hviezd na megapixel Šírka analýzy px dlhšej strany + Priečinky a súbory, ktoré už sú v archíve, si ponechajú svoje názvy. Názvy súborov Priečinky {0} voľných @@ -75,10 +76,12 @@ Vyberte priečinok archívu Ukážka Veľkosť proxy + Reorganizovať… Resetovať nastavenia Jeho šablóny názvov, veľkosť proxy a veľkosť miniatúr sa vrátia na predvolené hodnoty pre všetky počítače a servery, ktoré ho používajú. Priečinky a súbory, ktoré už sú v archíve, si ponechajú svoje názvy. Resetovať nastavenia archívu {0}? Priečinok archívu + Šablóny archívu sa uložili Veľkosť miniatúr Späť na Auto Vybrať priečinok diff --git a/i18n/sk/Tooltips.sk.resx b/i18n/sk/Tooltips.sk.resx index 1a8b5b9e..3eb37757 100644 --- a/i18n/sk/Tooltips.sk.resx +++ b/i18n/sk/Tooltips.sk.resx @@ -37,6 +37,7 @@ Otvorí sekvenciu prvej kópie v časti Úpravy Vyhľadá rovnaké fotografie naprieč sekvenciami podľa hashu · číta iba index Zobrazí sekvencie tohto roka + Názov súboru každej fotografie, ako ho dávajú importy · kontroluje sa počas písania Ponechá iba sekvencie jedného fotoaparátu Vyberie túto hodnotu; opätovným výberom ju zrušíte Ponechá iba sekvencie v jednom stave @@ -72,7 +73,10 @@ Znova zostaví index zo súborov sidecar; ak to nejde, úplne preskenuje metadáta; originály nikdy neodstraňuje Zaradí zostavenie indexu do frontu · archív sa medzitým dá používať Vyberie nový priečinok presunutého archívu; jeho sekvencie sa prepoja spolu s ním - Vykoná presne tieto zmeny v priečinkoch, súboroch sidecar a indexe · po páde pokračuje + Zaradí do frontu úlohu, ktorá vykoná presne tieto zmeny · pozastaviť ju a pokračovať v nej môžete na obrazovke Úlohy + Premenuje fotografie podľa tejto šablóny · pri vypnutí si ponechajú svoje názvy + Presunie priečinky sekvencií do tohto usporiadania · pri vypnutí zostanú na mieste + Zmení názvy podľa tejto šablóny · pri vypnutí zostanú tak, ako sú Zálohu indexu vyberte v časti Nastavenia › Rozšírené; pri ďalšom spustení nahradí index Zmení značky týchto sekvencií v súboroch sidecar a v indexe Znova spustí rovnakú akciu @@ -81,9 +85,8 @@ Spustí hĺbkovú analýzu všetkých sekvencií vo výbere Presunie výber do koša archívu · zobrazí skúšobný beh a potom vás požiada o potvrdenie zadaním Exportuje výber ako CSV: jeden riadok na sekvenciu - Presunie výber do nového usporiadania priečinkov · najprv skúšobný beh Vytvorí alebo obnoví proxy - Premenuje názvy sekvencií vo výbere podľa šablóny · najprv skúšobný beh + Použije šablóny priečinkov, súborov a názvov na výber · najprv skúšobný beh, potom úloha Pridá alebo odoberie značky v celom výbere Vytvorí alebo obnoví miniatúry Znova vypočíta hash originálov vo výbere @@ -478,15 +481,15 @@ Uloží {0:N0} riadky ako CSV do priečinka, ktorý vyberiete Uloží {0:N0} riadok ako CSV do priečinka, ktorý vyberiete Uloží {0:N0} riadkov ako CSV do priečinka, ktorý vyberiete - Presunie {0:N0} sekvencie do nového usporiadania priečinkov ich archívu · najprv zobrazí skúšobný beh - Presunie {0:N0} sekvenciu do nového usporiadania priečinkov jej archívu · najprv zobrazí skúšobný beh - Presunie {0:N0} sekvencií do nového usporiadania priečinkov ich archívu · najprv zobrazí skúšobný beh Vytvorí proxy JPEG pre {0:N0} sekvencie · beží ako jedna úloha Vytvorí proxy JPEG pre {0:N0} sekvenciu · beží ako jedna úloha Vytvorí proxy JPEG pre {0:N0} sekvencií · beží ako jedna úloha Nastaví hodnotenie {0:N0} sekvencií v ich súboroch sidecar a v indexe Nastaví hodnotenie {0:N0} sekvencie v jej súbore sidecar a v indexe Nastaví hodnotenie {0:N0} sekvencií v ich súboroch sidecar a v indexe + Použije šablóny priečinkov, súborov a názvov na {0:N0} sekvencie ich archívu · najprv skúšobný beh, potom úloha + Použije šablóny priečinkov, súborov a názvov na {0:N0} sekvenciu jej archívu · najprv skúšobný beh, potom úloha + Použije šablóny priečinkov, súborov a názvov na {0:N0} sekvencií ich archívu · najprv skúšobný beh, potom úloha Pridá alebo odoberie značky {0:N0} sekvencií Pridá alebo odoberie značky {0:N0} sekvencie Pridá alebo odoberie značky {0:N0} sekvencií @@ -711,6 +714,7 @@ Vyvážený sa hodí na väčšinu práce; Najlepší meria v dvojnásobnom rozlíšení a číta viac dopredu; Rýchly meria v polovičnom rozlíšení s hrubým odhadom pohybu Znova zistí kodéry po inštalácii ovládača alebo kodeku Znova vyhľadá rozšírenia kodekov po inštalácii niektorého z nich; ďalšie úlohy ich použijú + Použije šablóny archívu na sekvencie, ktoré už obsahuje · najprv skúšobný beh Vráti všetky nastavenia tohto počítača na predvolené hodnoty; najprv sa opýta Ihneď zapíše predvolené šablóny a veľkosti do súboru archive.json tohto archívu Ihneď resetuje všetky nastavenia diff --git a/i18n/sl/Admin.sl.resx b/i18n/sl/Admin.sl.resx index 0178d64f..43305d84 100644 --- a/i18n/sl/Admin.sl.resx +++ b/i18n/sl/Admin.sl.resx @@ -9,6 +9,7 @@ Chronos Server Deluje že Različica + {0}: reorganiziran arhiv · {1} {0}: spremenjena postavitev arhiva {0}: izbrisano {1} {0}: zagnano opravilo {1} @@ -147,7 +148,7 @@ Uvoz Hitra analiza Vzdrževanje - Premik + Reorganizacija Osirotele datoteke Proxyji Ponovna izgradnja @@ -367,6 +368,7 @@ Vpišite se, da upravljate ta strežnik Uporabnik Vaše uporabniško ime na tem strežniku + Reorganiziran arhiv Postavitev arhiva Izbrisane fotografije Zagnano opravilo @@ -452,6 +454,63 @@ Spremeni geslo Zamenjaj geslo in nadaljuj na ploščo Izberite novo geslo + Reorganiziraj … + Uveljavi predloge map, datotek in naslovov za izbrane sekvence; predogled najprej pokaže vse spremembe + Potem: + Uveljavi … + Reorganiziraj, kot kaže predogled; najprej je treba potrditi + Prej: + Vpišite predlogo ali izklopite ta del. + Zapri brez sprememb + Sledi mapi + Premakne se samo zato, ker se premakne mapa, v kateri je + Preimenovane datoteke + Mapa + Sekvenca + Reorganiziraj + Dodaj v čakalno vrsto opravilo, ki premakne in preimenuje izvirnike; nič se ne prepiše ali izbriše + {0} fotografije dobijo nova imena. + {0} fotografija dobi novo ime. + {0} fotografij dobi nova imena. + {0} mape se premaknejo. + {0} mapa se premakne. + {0} map se premakne. + {0} sekvence se spremenijo. + {0} sekvenca se spremeni. + {0} sekvenc se spremeni. + Želite reorganizirati zdaj? + Ime vsake fotografije, kot ga določi uvoz, npr. {date}_{time}_{n:0000}; datoteke ob fotografiji ji sledijo + Datoteke + Preimenuj fotografije vsake sekvence; izklopljeno ohrani vsa imena datotek + {0} preimenovane datoteke + {0} preimenovana datoteka + {0} preimenovanih datotek + Mapa vsake sekvence v arhivu, npr. {year}/{date} {camera}; {title} je novi naslov + Mape + Premakni vsako sekvenco v mapo, ki jo določa njena predloga; izklopljeno pusti vse mape, kjer so + Ena od izbranih sekvenc ni več v arhivu; zaprite in znova izberite. + {0}: {1} + Vklopite vsaj en del, ki ga želite spremeniti. + Ničesar ni treba spremeniti: te sekvence že sledijo predlogam. + Reorganiziraj … + Uveljavi nove predloge za sekvence, ki so že v arhivu; predogled najprej pokaže vse spremembe + Odpri opravilo + Pokaži opravilo in njegov dnevnik na strani Opravila + Arhiv se je med potrjevanjem spremenil; preverite novi predogled in znova uveljavite. + Načrtovanje … + Predogled + Kaj postane vsaka sekvenca, v vrstnem redu, v katerem se spremembe uveljavijo; nič se še ni spremenilo + Reorganizacija je v čakalni vrsti. + Ta mapa ostane, kjer je + Reorganiziraj {0} sekvence + Reorganiziraj {0} sekvenco + Reorganiziraj {0} sekvenc + Reorganiziraj vse sekvence + Novi naslov vsake sekvence, npr. {date} {camera}; {title} je trenutni naslov + Naslovi + Daj vsaki sekvenci naslov, ki ga ustvari njena predloga; izklopljeno ohrani vse naslove + Reorganizacija hkrati obdela največ {0} sekvenc ali vse sekvence: počistite filtre in izberite vse. + Spremenjene sekvence: {0} · preimenovane datoteke: {1} · ohranjena imena: {2} Skrbnik Urednik Nalagalec diff --git a/i18n/sl/Archive.sl.resx b/i18n/sl/Archive.sl.resx index d30b5733..ebc57152 100644 --- a/i18n/sl/Archive.sl.resx +++ b/i18n/sl/Archive.sl.resx @@ -16,6 +16,7 @@ Počakajte, da se spremembe uveljavijo. Nabor je prazen: spremenite izbor ali filter. Nič se ne bi spremenilo. + Vklopite vsaj eno predlogo. Arhiv mora biti dosegljiv in zapisljiv. Počakajte na poskusni zagon. Počakajte, da se arhiv prebere. @@ -91,6 +92,15 @@ Datoteko {0} je zapisal novejši Chronos (oblika {1}). Arhiv {0} ni dosegljiv. Arhiv {0} je samo za branje. + {0:N0} sekvence so obdržale imena datotek: fotografija je bila v uporabi ali pa je bilo njeno novo ime že zasedeno. + {0:N0} sekvenca je obdržala imena datotek: fotografija je bila v uporabi ali pa je bilo njeno novo ime že zasedeno. + {0:N0} sekvenc je obdržalo imena datotek: fotografija je bila v uporabi ali pa je bilo njeno novo ime že zasedeno. + {0:N0} sekvence niso bile reorganizirane po načrtu: po izdelavi načrta so se spremenile. + {0:N0} sekvenca ni bila reorganizirana po načrtu: po izdelavi načrta se je spremenila. + {0:N0} sekvenc ni bilo reorganiziranih po načrtu: po izdelavi načrta so se spremenile. + {0:N0} sekvence so obdržale naslove in imena datotek: njihove datoteke sekvenc je zapisal novejši Chronos. + {0:N0} sekvenca je obdržala naslov in imena datotek: njeno datoteko sekvence je zapisal novejši Chronos. + {0:N0} sekvenc je obdržalo naslove in imena datotek: njihove datoteke sekvenc je zapisal novejši Chronos. Vir {0} se je spremenil po izdelavi načrta. Kartica ali mapa {0} ni več na voljo. Arhiv se je spremenil po izdelavi tega načrta. @@ -162,6 +172,14 @@ Neindeksirane fotografije: {0}, manjkajoče fotografije: {1} {0} – ustvarjeno: {1}, znova uporabljeno: {2}, neberljivo: {3}, čaka: {4} Proxyji za strežnik – poslano: {0}, ni poslano: {1} + Ostalo, kot je bilo, ker je nadrejena mapa ostala na mestu: {0} + Ostalo, kot je bilo, ker se je po izdelavi načrta spremenilo: {0} + Imena datotek ohranjena, ker je bila fotografija v uporabi ali pa je bilo njeno novo ime že zasedeno: {0} + Imena datotek ohranjena, ker so se fotografije po izdelavi načrta spremenile: {0} + Naslov in imena datotek ohranjeni, ker je datoteko sekvence zapisal novejši Chronos: {0} + Naslov in imena datotek ohranjeni, ker se je sekvenca po izdelavi načrta spremenila: {0} + Spremenjene sekvence: {0}, preimenovane datoteke: {1} + Reorganizacija je bila dokončana ob odprtju arhiva Samo poročilo: nič ni bilo spremenjeno. Mape: {0}, indeksirano: {1}, prevzeto: {2}, odstranjeno: {3} Sekvence ni mogoče najti: {0} @@ -219,17 +237,34 @@ Mapa premaknjenega arhiva Uveljavi {0} od {1} - Preimenuj {0:N0} sekvence - Preimenuj {0:N0} sekvenco - Preimenuj {0:N0} sekvenc - Premakni {0:N0} sekvence - Premakni {0:N0} sekvenco - Premakni {0:N0} sekvenc Spremembe {0:N0} od {1:N0} se spremenijo {0:N0} od {1:N0} se spremeni {0:N0} od {1:N0} se spremeni - Predloga + Fotografije, ohranjene na mestu zunaj mape originals, obdržijo svoja imena. + Manjkajoče fotografije obdržijo svoja imena. + Fotografije, ki niso bile nikoli preverjene, obdržijo svoja imena; najprej preverite sekvenco. + Datoteke sekvence ni mogoče prebrati; sekvenca ostane, kot je, prav tako pa tudi vse mape, v katerih je. + Sledi svoji mapi + {0}: iz {1} v {2} + Datoteka + Imena datotek + Mapa + Mape + Reorganiziraj {0:N0} sekvence + Reorganiziraj {0:N0} sekvenco + Reorganiziraj {0:N0} sekvenc + Reorganiziraj arhiv {0} + {0:N0} ohranjena imena + {0:N0} ohranjeno ime + {0:N0} ohranjenih imen + Poskusni zagon … + {0:N0} preimenovane datoteke + {0:N0} preimenovana datoteka + {0:N0} preimenovanih datotek + Naslov + Naslovi + Reorganizacija se odpre, ko se zapre odprto pogovorno okno Dodaj oznake Uveljavi Oznake {0:N0} sekvenc @@ -246,9 +281,8 @@ Izvozi CSV Filter nabora Filtriran nabor - Premakni … Proxyji - Preimenuj … + Reorganiziraj … Spremeni oznake … Miniature Preveri diff --git a/i18n/sl/Errors.sl.resx b/i18n/sl/Errors.sl.resx index 049d4b69..6c688889 100644 --- a/i18n/sl/Errors.sl.resx +++ b/i18n/sl/Errors.sl.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Neanalizirane sekvence: {0} od {1}; oglejte si dnevnik opravila. + Mapa te sekvence ni tam, kjer jo navaja indeks; poskusite znova po naslednjem pregledu. Arhiva ni bilo mogoče odpreti. Trenutnega indeksa ni bilo mogoče varnostno kopirati ali zamenjati; obnovitev se znova izvede ob naslednjem zagonu. Te varnostne kopije ni mogoče obnoviti; izberite drugo. @@ -39,9 +40,11 @@ {0} izvirnikov manjka ali se je spremenilo od arhiviranja; preverite arhiv. Predloga je prazna. Prazno polje na mestu {1}: med zavita oklepaja vpišite ime. + Fotografije bi izgubile končnico: pred {ext} vpišite piko ali pa {ext} izpustite. Imena datotek ne smejo vsebovati poševnice; mape vpišite v predlogo map. Oblika za dvopičjem ne ustreza svojemu polju. Imena bi se ponavljala: dodajte številko sličice, čas ali izvirno ime. + Pregledi preskočijo mape, ki se začnejo s piko ali se imenujejo originals, proxies ali exports. Zaviti oklepaj, odprt na mestu {1}, ni nikoli zaprt. Neznano polje »{0}« na mestu {1}. Zaklepaj na mestu {1} nima uklepaja; za dobesedni zaviti oklepaj ga podvojite. diff --git a/i18n/sl/Jobs.sl.resx b/i18n/sl/Jobs.sl.resx index f7268584..e76240fb 100644 --- a/i18n/sl/Jobs.sl.resx +++ b/i18n/sl/Jobs.sl.resx @@ -77,7 +77,7 @@ Uvoz Hitra analiza Vzdrževanje - Premik arhiva + Reorganizacija Osirotele datoteke Proxyji Ponovna izgradnja indeksa diff --git a/i18n/sl/Library.sl.resx b/i18n/sl/Library.sl.resx index 36649ed4..d9c9421d 100644 --- a/i18n/sl/Library.sl.resx +++ b/i18n/sl/Library.sl.resx @@ -10,17 +10,16 @@ Prenesi Izvozi seznam Mapa - Premakni … Odpri Proxyji Ocena Upodobi + Reorganiziraj … Sinhroniziraj Oznake … Naloži Preveri Prevzemi mapo - Premikate lahko samo sekvence enega arhiva naenkrat. Enako v tem računalniku in na strežniku: ničesar ni treba sinhronizirati. Noben shranjeni pogled ni v uporabi; najprej ga izberite. Vaš račun na strežniku ne more prenašati izvirnikov. @@ -32,6 +31,7 @@ Najprej se vpišite v strežnik Chronos Server na zaslonu Strežnik. Za izbrane sekvence s strežnika ni ničesar za prenos. Strežnik že ima vse, kar vsebujejo izbrane sekvence. + Reorganizacija deluje na sekvencah samo enega arhiva naenkrat. Samo za sekvence v tem računalniku; izbor je na strežniku. Prenos te sekvence že poteka. Počisti filtre diff --git a/i18n/sl/Server.sl.resx b/i18n/sl/Server.sl.resx index 82229f17..0fc0c15c 100644 --- a/i18n/sl/Server.sl.resx +++ b/i18n/sl/Server.sl.resx @@ -40,6 +40,7 @@ Povezava ni uspela; podrobnosti so v dnevniku. Datoteka sekvence je odprta v drugem programu; zaprite jo in poskusite znova. Mape te sekvence ni več na disku; v koš ni ničesar za premik. + Mapa te sekvence ni tam, kjer jo navaja indeks strežnika; poskusite znova po njegovem naslednjem pregledu. Vaš račun tega ne more storiti. Fotografije sekvence so se na strežniku spremenile; znova jo naložite in ponovno uveljavite svojo spremembo. Datoteka je prispela poškodovana; znova jo naložite. @@ -68,11 +69,14 @@ Ta strežnik ne more izvajati te vrste opravila. Zadnjega skrbnika ni mogoče odstraniti ali onemogočiti. Ta metoda tukaj ni dovoljena. + Nova mapa bi bila znotraj mape druge sekvence. Na tem naslovu ni strežnika Chronos Server. Ni najdeno. Najprej spremenite geslo. Fotografija je bila med nalaganjem izbrisana iz sekvence, zato ni bila dodana. Datoteke {0} ni mogoče prebrati, brez njene zgoščene vrednosti pa druge kopije ne bi izvedele, da je bila izbrisana; zaprite program, ki jo uporablja, ali preverite njena dovoljenja in poskusite znova. + Arhiv se je po poskusnem zagonu spremenil; znova si oglejte načrt. + Strežnik je prenehal pripravljati ta načrt: trajalo je predolgo ali pa je bilo hkrati zahtevanih preveč načrtov; poskusite znova čez nekaj trenutkov. Ta arhiv ne ustvarja proxyjev. Proxy je bil ustvarjen iz druge fotografije. Strežnik ne potrebuje proxyja te fotografije. diff --git a/i18n/sl/Settings.sl.resx b/i18n/sl/Settings.sl.resx index 832b1ffd..c499d9b3 100644 --- a/i18n/sl/Settings.sl.resx +++ b/i18n/sl/Settings.sl.resx @@ -66,6 +66,7 @@ zvezd na megapiksel Širina analize px daljše stranice + Mape in datoteke, ki so že v arhivu, obdržijo svoja imena. Imena datotek Mape {0} prosto @@ -75,10 +76,12 @@ Izberite mapo arhiva Predogled Velikost proxyjev + Reorganiziraj … Ponastavi nastavitve Njegove predloge za poimenovanje, velikost proxyjev in velikost miniatur se vrnejo na privzete vrednosti za vse računalnike in strežnike, ki ga uporabljajo. Mape in datoteke, ki so že v arhivu, obdržijo svoja imena. Želite ponastaviti nastavitve arhiva {0}? Mapa arhiva + Predloge arhiva so shranjene Velikost miniatur Nazaj na samodejno Izberi mapo diff --git a/i18n/sl/Tooltips.sl.resx b/i18n/sl/Tooltips.sl.resx index b464f1e4..3d21693c 100644 --- a/i18n/sl/Tooltips.sl.resx +++ b/i18n/sl/Tooltips.sl.resx @@ -37,6 +37,7 @@ Odpri sekvenco prve kopije v razdelku Urejanje Poišči enake fotografije v različnih sekvencah po zgoščeni vrednosti · bere samo indeks Pokaži sekvence tega leta + Ime datoteke vsake fotografije, kot jo poimenujejo uvozi · preveri se med tipkanjem Ohrani samo sekvence enega fotoaparata Izberi to vrednost; ponovna izbira jo počisti Ohrani samo sekvence v enem stanju @@ -72,7 +73,10 @@ Znova zgradi indeks iz datotek sidecar; po potrebi izvede celoten pregled metapodatkov; izvirnikov nikoli ne izbriše Dodaj ponovno izgradnjo v čakalno vrsto · arhiv ostane medtem uporaben Izberi novo mapo arhiva, ki ste ga premaknili; njegove sekvence mu sledijo - Izvedi natanko te spremembe v mapah, datotekah sidecar in indeksu · po zrušitvi se nadaljuje + Dodaj v čakalno vrsto opravilo, ki naredi natanko te spremembe · v razdelku Opravila ga lahko začasno ustavite in nadaljujete + Preimenuj fotografije s to predlogo · če je izklopljeno, obdržijo svoja imena + Premakni mape sekvenc v to postavitev · če je izklopljeno, ostanejo, kjer so + Spremeni naslove s to predlogo · če je izklopljeno, ostanejo, kot so Izberi varnostno kopijo indeksa v Nastavitve › Dodatno; ob naslednjem zagonu zamenja indeks Spremeni oznake teh sekvenc v datotekah sidecar in indeksu Znova zaženi isto dejanje @@ -81,9 +85,8 @@ Zaženi poglobljeno analizo vsake sekvence v naboru Premakni nabor v koš arhiva · pokaže poskusni zagon, nato zahteva vnos za potrditev Izvozi nabor kot CSV: ena vrstica na sekvenco - Premakni nabor v novo postavitev map · najprej poskusni zagon Ustvari ali osveži proxyje - Preimenuj naslove nabora s predlogo · najprej poskusni zagon + Uveljavi predloge map, datotek in naslovov za nabor · najprej poskusni zagon, nato opravilo Dodaj ali odstrani oznake celotnega nabora Ustvari ali osveži miniature Znova izračunaj zgoščene vrednosti izvirnikov nabora @@ -478,15 +481,15 @@ Shrani {0:N0} vrstice kot CSV v mapo po vaši izbiri Shrani {0:N0} vrstico kot CSV v mapo po vaši izbiri Shrani {0:N0} vrstic kot CSV v mapo po vaši izbiri - Premakni {0:N0} sekvence v novo postavitev map njihovega arhiva · najprej pokaže poskusni zagon - Premakni {0:N0} sekvenco v novo postavitev map njenega arhiva · najprej pokaže poskusni zagon - Premakni {0:N0} sekvenc v novo postavitev map njihovega arhiva · najprej pokaže poskusni zagon Ustvari proxyje JPEG za {0:N0} sekvence · izvede se kot eno opravilo Ustvari proxyje JPEG za {0:N0} sekvenco · izvede se kot eno opravilo Ustvari proxyje JPEG za {0:N0} sekvenc · izvede se kot eno opravilo Nastavi oceno {0:N0} sekvenc v njihovih datotekah sidecar in v indeksu Nastavi oceno {0:N0} sekvence v njeni datoteki sidecar in v indeksu Nastavi oceno {0:N0} sekvenc v njihovih datotekah sidecar in v indeksu + Uveljavi predloge map, datotek in naslovov za {0:N0} sekvence njihovega arhiva · najprej poskusni zagon, nato opravilo + Uveljavi predloge map, datotek in naslovov za {0:N0} sekvenco njenega arhiva · najprej poskusni zagon, nato opravilo + Uveljavi predloge map, datotek in naslovov za {0:N0} sekvenc njihovega arhiva · najprej poskusni zagon, nato opravilo Dodaj ali odstrani oznake {0:N0} sekvenc Dodaj ali odstrani oznake {0:N0} sekvence Dodaj ali odstrani oznake {0:N0} sekvenc @@ -711,6 +714,7 @@ Uravnoteženo ustreza večini dela; Najboljše meri pri dvojni ločljivosti in bere dlje vnaprej; Hitro meri pri polovični ločljivosti z gibanjem v kakovosti osnutka Znova poišči kodirnike po namestitvi gonilnika ali kodeka Znova poišči razširitve kodekov po namestitvi katere od njih; naslednja opravila jih uporabijo + Uveljavi predloge arhiva za sekvence, ki so že v njem · najprej poskusni zagon Vrni vse nastavitve tega računalnika na privzete vrednosti; prej vpraša Takoj zapiši privzete predloge in velikosti v datoteko archive.json tega arhiva Takoj ponastavi vse nastavitve diff --git a/i18n/sv/Admin.sv.resx b/i18n/sv/Admin.sv.resx index e3bd81d6..2998913a 100644 --- a/i18n/sv/Admin.sv.resx +++ b/i18n/sv/Admin.sv.resx @@ -9,6 +9,7 @@ Chronos Server Drifttid Version + {0} omorganiserade arkivet · {1} {0} ändrade arkivets struktur {0} raderade {1} {0} startade {1} @@ -138,7 +139,7 @@ Import Snabbanalys Underhåll - Flytt + Omorganisering Överblivna filer Proxyer Återskapande @@ -343,6 +344,7 @@ Logga in för att administrera den här servern Användare Ditt användarnamn på den här servern + Arkiv omorganiserat Arkivstruktur Foton raderade Jobb startat @@ -426,6 +428,58 @@ Byt lösenord Ersätt lösenordet och fortsätt till panelen Välj ett nytt lösenord + Omorganisera… + Tillämpa mapp-, fil- och titelmallar på de markerade sekvenserna; en förhandsvisning visar först varje ändring + Efter: + Tillämpa… + Omorganisera som förhandsvisningen visar; en bekräftelse kommer först + Före: + Skriv en mall eller stäng av den här delen. + Stäng utan att ändra något + Följer med + Flyttas bara för att en mapp som den ligger i flyttas + Omdöpta filer + Mapp + Sekvens + Omorganisera + Lägg jobbet som flyttar och byter namn på originalen i kö; inget skrivs över eller raderas + {0} foto får ett nytt namn. + {0} foton får nya namn. + {0} mapp flyttas. + {0} mappar flyttas. + {0} sekvens ändras. + {0} sekvenser ändras. + Omorganisera nu? + Namnet på varje foto som en import ger det, t.ex. {date}_{time}_{n:0000}; filerna bredvid ett foto följer med det + Filer + Byt namn på fotona i varje sekvens; när det är av behålls alla filnamn + {0} fil omdöpt + {0} filer omdöpta + Mappen för varje sekvens i arkivet, t.ex. {year}/{date} {camera}; {title} är den nya titeln + Mappar + Flytta varje sekvens till mappen som dess mall anger; när det är av ligger alla mappar kvar där de är + En markerad sekvens finns inte längre i arkivet; stäng och markera igen. + {0}: {1} + Slå på minst en del att ändra. + Inget att ändra: de här sekvenserna följer redan mallarna. + Omorganisera… + Tillämpa de nya mallarna på sekvenserna som redan finns i arkivet; en förhandsvisning visar först varje ändring + Öppna jobb + Visa jobbet och dess logg på sidan Jobb + Arkivet ändrades under bekräftelsen; kontrollera den nya förhandsvisningen och tillämpa igen. + Planerar… + Förhandsvisning + Vad varje sekvens blir, i den ordning ändringarna tillämpas; inget har ändrats ännu + Omorganiseringen har lagts i kö. + Den här mappen ligger kvar där den är + Omorganisera {0} sekvens + Omorganisera {0} sekvenser + Omorganisera alla sekvenser + Ny titel för varje sekvens, t.ex. {date} {camera}; {title} är den aktuella titeln + Titlar + Ge varje sekvens titeln som dess mall skapar; när det är av behålls alla titlar + Omorganisering hanterar högst {0} sekvenser åt gången, eller alla sekvenser: rensa filtren och markera alla. + Ändrade sekvenser: {0} · omdöpta filer: {1} · behållna namn: {2} Administratör Redaktör Uppladdare diff --git a/i18n/sv/Archive.sv.resx b/i18n/sv/Archive.sv.resx index 7f44c175..c9dab901 100644 --- a/i18n/sv/Archive.sv.resx +++ b/i18n/sv/Archive.sv.resx @@ -15,6 +15,7 @@ Vänta tills ändringarna har tillämpats. Urvalet är tomt: ändra markeringen eller filtret. Inget skulle ändras. + Slå på minst en mall. Arkivet måste vara online och skrivbart. Vänta på testkörningen. Vänta tills arkivet har lästs in. @@ -81,6 +82,12 @@ {0} skrevs av en nyare Chronos (format {1}). Arkivet {0} är offline. Arkivet {0} är skrivskyddat. + {0:N0} sekvens behöll sina filnamn: ett foto användes eller dess nya namn var upptaget. + {0:N0} sekvenser behöll sina filnamn: ett foto användes eller dess nya namn var upptaget. + {0:N0} sekvens omorganiserades inte enligt planen: den ändrades efter planen. + {0:N0} sekvenser omorganiserades inte enligt planen: de ändrades efter planen. + {0:N0} sekvens behöll sin titel och sina filnamn: dess sekvensfil kommer från en nyare Chronos. + {0:N0} sekvenser behöll sina titlar och filnamn: deras sekvensfiler kommer från en nyare Chronos. {0} ändrades efter att planen skapades. Kortet eller mappen {0} är inte längre tillgänglig. Arkivet ändrades efter att den här planen skapades. @@ -146,6 +153,14 @@ Oindexerade foton: {0}, saknade foton: {1} {0}: skapade {1}, återanvända {2}, oläsbara {3}, väntande {4} Proxyer för servern: skickade {0}, inte skickade {1} + Lämnad som den var, mappen den ligger i låg kvar: {0} + Lämnad som den var, ändrad efter planen: {0} + Filnamnen behölls, ett foto användes eller dess nya namn var upptaget: {0} + Filnamnen behölls, fotona ändrades efter planen: {0} + Titel och filnamn behölls, dess sekvensfil kommer från en nyare Chronos: {0} + Titel och filnamn behölls, ändrad efter planen: {0} + Ändrade sekvenser: {0}, omdöpta filer: {1} + Omorganiseringen slutfördes när arkivet öppnades Endast rapport: inget ändrades. Mappar: {0}, indexerade: {1}, införlivade: {2}, borttagna: {3} Sekvensen hittades inte: {0} @@ -200,14 +215,30 @@ Mapp för det flyttade arkivet Tillämpa {0} av {1} - Byt namn på {0:N0} sekvens - Byt namn på {0:N0} sekvenser - Flytta {0:N0} sekvens - Flytta {0:N0} sekvenser Ändringar {0:N0} av {1:N0} ändras {0:N0} av {1:N0} ändras - Mall + Foton som hålls kvar på plats utanför mappen originals behåller sina namn. + Saknade foton behåller sina namn. + Foton som aldrig verifierats behåller sina namn; verifiera sekvensen först. + Sekvensfilen kan inte läsas; sekvensen förblir som den är, och det gör även varje mapp som den ligger i. + Följer sin mapp + {0}: från {1} till {2} + Fil + Filnamn + Mapp + Mappar + Omorganisera {0:N0} sekvens + Omorganisera {0:N0} sekvenser + Omorganisera {0} + {0:N0} namn behållet + {0:N0} namn behållna + Testkörning… + {0:N0} fil omdöpt + {0:N0} filer omdöpta + Titel + Titlar + Omorganisera öppnas när den öppna dialogrutan stängs Lägg till taggar Tillämpa Taggar för {0:N0} sekvens @@ -222,9 +253,8 @@ Exportera CSV Urvalsfilter Filtrerat urval - Flytta… Proxyer - Byt namn… + Omorganisera… Ändra taggar… Miniatyrer Verifiera diff --git a/i18n/sv/Errors.sv.resx b/i18n/sv/Errors.sv.resx index 4fa9409c..5f97aeec 100644 --- a/i18n/sv/Errors.sv.resx +++ b/i18n/sv/Errors.sv.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Sekvenser som inte analyserades: {0} av {1}; se jobbloggen. + Sekvensens mapp finns inte där indexet anger; försök igen efter nästa genomsökning. Arkivet kunde inte öppnas. Det aktuella indexet kunde inte säkerhetskopieras eller ersättas; återställningen körs igen vid nästa start. Den här säkerhetskopian kan inte återställas; välj en annan. @@ -37,9 +38,11 @@ {0} original saknas eller har ändrats sedan de arkiverades; verifiera arkivet. Mallen är tom. Tom platshållare på position {1}: skriv ett namn mellan klammerparenteserna. + Fotona skulle förlora sin filändelse: skriv en punkt före {ext}, eller utelämna {ext}. Filnamn kan inte innehålla snedstreck; lägg mappar i mappmallen. Formatet efter kolonet passar inte platshållaren. Namnen skulle upprepas: lägg till bildrutenumret, tiden eller originalnamnet. + Genomsökningar hoppar över mappar som börjar med en punkt eller heter originals, proxies eller exports. Klammerparentesen som öppnas på position {1} stängs aldrig. Okänd platshållare ”{0}” på position {1}. Den avslutande klammerparentesen på position {1} har ingen inledande; dubblera den för att skriva en klammerparentes som text. diff --git a/i18n/sv/Jobs.sv.resx b/i18n/sv/Jobs.sv.resx index b9a2f523..f33d146e 100644 --- a/i18n/sv/Jobs.sv.resx +++ b/i18n/sv/Jobs.sv.resx @@ -76,7 +76,7 @@ Import Snabbanalys Underhåll - Arkivflytt + Omorganisering Överblivna filer Proxyer Återskapande av index diff --git a/i18n/sv/Library.sv.resx b/i18n/sv/Library.sv.resx index 55cf255f..0e4cd043 100644 --- a/i18n/sv/Library.sv.resx +++ b/i18n/sv/Library.sv.resx @@ -10,17 +10,16 @@ Ladda ned Exportera lista Mapp - Flytta… Öppna Proxyer Betyg Rendera + Omorganisera… Synka Taggar… Ladda upp Verifiera Införliva en mapp - ”Flytta” fungerar bara för sekvenser från ett arkiv åt gången. Likadan på den här datorn och på servern: inget att synka. Ingen sparad vy används; välj en först. Ditt serverkonto kan inte ladda ned original. @@ -32,6 +31,7 @@ Logga in på en Chronos Server först, på skärmen Server. De markerade sekvenserna har inget att hämta från servern. Servern har redan det som de markerade sekvenserna innehåller. + Omorganisering fungerar på sekvenserna i ett arkiv i taget. Endast för sekvenser på den här datorn; markeringen finns på servern. En överföring av den här sekvensen pågår redan. Rensa filter diff --git a/i18n/sv/Server.sv.resx b/i18n/sv/Server.sv.resx index 84aa1352..8ee54e31 100644 --- a/i18n/sv/Server.sv.resx +++ b/i18n/sv/Server.sv.resx @@ -40,6 +40,7 @@ Anslutningen misslyckades; se loggen för detaljer. En fil i sekvensen är öppen i ett annat program; stäng den och försök igen. Dess mapp finns inte längre på disken; det finns inget kvar att flytta till papperskorgen. + Sekvensens mapp finns inte där serverns index anger; försök igen efter dess nästa genomsökning. Ditt konto får inte göra detta. Sekvensens foton ändrades på servern; läs in den igen och gör om din ändring. Filen kom fram skadad; ladda upp den igen. @@ -68,11 +69,14 @@ Den här servern kan inte köra den typen av jobb. Den sista administratören kan inte tas bort eller inaktiveras. Den här metoden är inte tillåten här. + En ny mapp skulle hamna inuti mappen för en annan sekvens. Den adressen är inte en Chronos Server. Hittades inte. Byt ditt lösenord först. Fotot raderades från sekvensen medan det laddades upp, så det lades inte till. {0} kan inte läsas, och utan dess hash skulle andra kopior inte få veta att den raderades; stäng programmet som använder den eller kontrollera dess behörigheter och försök sedan igen. + Arkivet ändrades efter testkörningen; granska planen igen. + Servern slutade ta fram den här planen: det tog för lång tid, eller för många begärdes samtidigt; försök igen om en stund. Det här arkivet skapar inga proxyer. Proxyn skapades från ett annat foto. Servern behöver ingen proxy för det här fotot. diff --git a/i18n/sv/Settings.sv.resx b/i18n/sv/Settings.sv.resx index 209aa56d..6d9c3c90 100644 --- a/i18n/sv/Settings.sv.resx +++ b/i18n/sv/Settings.sv.resx @@ -65,6 +65,7 @@ stjärnor per megapixel Analysbredd px på långsidan + Mappar och filer som redan finns i arkivet behåller sina namn. Filnamn Mappar {0} ledigt @@ -74,10 +75,12 @@ Välj arkivmappen Förhandsvisning Proxystorlek + Omorganisera… Återställ arkiv Dess namngivningsmallar, proxystorlek och miniatyrstorlek återgår till standardvärdena för alla datorer och servrar som använder det. Mappar och filer som redan finns i arkivet behåller sina namn. Återställa inställningarna för {0}? Arkivmapp + Arkivmallarna har sparats Miniatyrstorlek Tillbaka till Auto Välj mapp diff --git a/i18n/sv/Tooltips.sv.resx b/i18n/sv/Tooltips.sv.resx index 1699cf02..524cc0d2 100644 --- a/i18n/sv/Tooltips.sv.resx +++ b/i18n/sv/Tooltips.sv.resx @@ -36,6 +36,7 @@ Öppna den första kopians sekvens i Redigering Hitta identiska foton i olika sekvenser via hash · läser endast indexet Visa sekvenserna för det här året + Filnamnet för varje foto, som importer namnger dem · kontrolleras medan du skriver Behåll endast sekvenserna från en kamera Välj det här värdet; välj det igen för att rensa det Behåll endast sekvenserna med en viss status @@ -71,7 +72,10 @@ Återskapa indexet från sidecar-filerna, annars via en fullständig genomsökning av metadata; raderar aldrig original Lägg återskapandet i kö · arkivet kan användas under tiden Välj den nya mappen för ett arkiv du har flyttat; dess sekvenser följer med - Gör exakt de här ändringarna i mappar, sidecar-filer och index · återupptas efter en krasch + Lägg ett jobb i kö som gör exakt de här ändringarna · pausa och återuppta det i Jobb + Byt namn på fotona med den här mallen · när det är av behåller de sina namn + Flytta sekvensmapparna till den här strukturen · när det är av ligger de kvar där de är + Ändra titlarna med den här mallen · när det är av förblir de som de är Välj en säkerhetskopia av indexet i Inställningar › Avancerat; den ersätter indexet vid nästa start Ändra taggarna för de här sekvenserna i sidecar-filer och index Kör samma åtgärd igen @@ -80,9 +84,8 @@ Kör djupanalysen på varje sekvens i urvalet Flytta urvalet till arkivets papperskorg · visar testkörningen och ber dig sedan skriva för att bekräfta Exportera urvalet som CSV: en rad per sekvens - Flytta urvalet till en ny mappstruktur · testkörning först Skapa eller uppdatera proxyer - Byt namn på urvalets titlar med en mall · testkörning först + Tillämpa mapp-, fil- och titelmallar på urvalet · testkörning först, sedan ett jobb Lägg till eller ta bort taggar i hela urvalet Skapa eller uppdatera miniatyrer Beräkna om hasharna för urvalets original @@ -471,12 +474,12 @@ Hämta det som {0:N0} sekvenser saknar här (original eller renderingar) från servern · körs som överföringsjobb Spara {0:N0} rad som CSV i en mapp du väljer Spara {0:N0} rader som CSV i en mapp du väljer - Flytta {0:N0} sekvens till en ny mappstruktur i arkivet · visar testkörningen först - Flytta {0:N0} sekvenser till en ny mappstruktur i arkivet · visar testkörningen först Skapa JPEG-proxyer för {0:N0} sekvens · körs som ett jobb Skapa JPEG-proxyer för {0:N0} sekvenser · körs som ett jobb Ange betyget för {0:N0} sekvens, i dess sidecar-fil och i indexet Ange betyget för {0:N0} sekvenser, i deras sidecar-filer och i indexet + Tillämpa mapp-, fil- och titelmallar på {0:N0} sekvens i dess arkiv · testkörning först, sedan ett jobb + Tillämpa mapp-, fil- och titelmallar på {0:N0} sekvenser i deras arkiv · testkörning först, sedan ett jobb Lägg till eller ta bort taggar på {0:N0} sekvens Lägg till eller ta bort taggar på {0:N0} sekvenser Skicka det som servern saknar av {0:N0} sekvens (original och inställningar, eller renderingar) · körs som ett överföringsjobb @@ -692,6 +695,7 @@ ”Balanserad” passar i de flesta fall; ”Bästa” mäter i dubbel upplösning och läser längre fram; ”Snabb” mäter i halv upplösning med rörelse i utkastkvalitet Lista kodarna igen efter installation av en drivrutin eller codec Sök efter codec-tillägg igen efter att du har installerat ett; nästa jobb använder dem + Tillämpa arkivets mallar på sekvenserna som redan finns i det · testkörning först Återställ alla inställningar på den här datorn till standardvärdena; frågar först Skriv standardmallarna och standardstorlekarna till arkivets archive.json nu Återställ alla inställningar nu diff --git a/i18n/th/Admin.th.resx b/i18n/th/Admin.th.resx index 33ece3ba..d07e3bd0 100644 --- a/i18n/th/Admin.th.resx +++ b/i18n/th/Admin.th.resx @@ -9,6 +9,7 @@ Chronos Server ทำงานมาแล้ว เวอร์ชัน + {0} จัดระเบียบคลังภาพใหม่ · {1} {0} เปลี่ยนโครงสร้างคลังภาพ {0} ลบ {1} {0} เริ่ม {1} @@ -138,7 +139,7 @@ นำเข้า การวิเคราะห์แบบเร็ว การบำรุงรักษา - ย้าย + จัดระเบียบใหม่ ไฟล์กำพร้า พร็อกซี สร้างใหม่ @@ -343,6 +344,7 @@ ลงชื่อเข้าใช้เพื่อดูแลเซิร์ฟเวอร์นี้ ผู้ใช้ ชื่อผู้ใช้ของคุณบนเซิร์ฟเวอร์นี้ + จัดระเบียบคลังภาพใหม่ โครงสร้างคลังภาพ ลบภาพ เริ่มงาน @@ -426,6 +428,58 @@ เปลี่ยนรหัสผ่าน แทนที่รหัสผ่านแล้วไปยังแผงต่อ ตั้งรหัสผ่านใหม่ + จัดระเบียบใหม่… + นำเทมเพลตโฟลเดอร์ ไฟล์ และชื่อไปใช้กับซีเควนซ์ที่เลือก โดยจะแสดงตัวอย่างการเปลี่ยนแปลงทั้งหมดก่อน + หลัง: + นำไปใช้… + จัดระเบียบใหม่ตามที่แสดงในตัวอย่าง โดยจะขอให้ยืนยันก่อน + ก่อน: + เขียนเทมเพลต หรือปิดส่วนนี้ + ปิดโดยไม่เปลี่ยนแปลงสิ่งใด + ย้ายตามโฟลเดอร์ + ย้ายเพียงเพราะโฟลเดอร์ที่ครอบอยู่ถูกย้าย + ไฟล์ที่เปลี่ยนชื่อ + โฟลเดอร์ + ซีเควนซ์ + จัดระเบียบใหม่ + เพิ่มงานที่ย้ายและเปลี่ยนชื่อต้นฉบับลงคิว โดยไม่มีสิ่งใดถูกเขียนทับหรือลบ + {0} ภาพจะได้รับชื่อใหม่ + {0} ภาพจะได้รับชื่อใหม่ + {0} โฟลเดอร์จะถูกย้าย + {0} โฟลเดอร์จะถูกย้าย + {0} ซีเควนซ์จะเปลี่ยนแปลง + {0} ซีเควนซ์จะเปลี่ยนแปลง + จัดระเบียบใหม่ตอนนี้หรือไม่ + ชื่อของแต่ละภาพตามที่การนำเข้าตั้งให้ เช่น {date}_{time}_{n:0000} ไฟล์ที่อยู่คู่กับภาพจะเปลี่ยนตาม + ไฟล์ + เปลี่ยนชื่อภาพของแต่ละซีเควนซ์ หากปิดไว้ชื่อไฟล์ทั้งหมดจะคงเดิม + เปลี่ยนชื่อ {0} ไฟล์แล้ว + เปลี่ยนชื่อ {0} ไฟล์แล้ว + โฟลเดอร์ของแต่ละซีเควนซ์ในคลังภาพ เช่น {year}/{date} {camera} โดย {title} คือชื่อใหม่ + โฟลเดอร์ + ย้ายแต่ละซีเควนซ์ไปยังโฟลเดอร์ที่เทมเพลตกำหนด หากปิดไว้ทุกโฟลเดอร์จะอยู่ที่เดิม + ซีเควนซ์ที่เลือกรายการหนึ่งไม่อยู่ในคลังภาพแล้ว โปรดปิดแล้วเลือกใหม่ + {0}: {1} + เปิดอย่างน้อยหนึ่งส่วนที่จะเปลี่ยน + ไม่มีอะไรต้องเปลี่ยน: ซีเควนซ์เหล่านี้เป็นไปตามเทมเพลตอยู่แล้ว + จัดระเบียบใหม่… + นำเทมเพลตใหม่ไปใช้กับซีเควนซ์ที่อยู่ในคลังภาพแล้ว โดยจะแสดงตัวอย่างการเปลี่ยนแปลงทั้งหมดก่อน + เปิดงาน + แสดงงานและบันทึกงานในหน้า “งาน” + คลังภาพเปลี่ยนแปลงระหว่างการยืนยัน โปรดตรวจดูตัวอย่างใหม่แล้วนำไปใช้อีกครั้ง + กำลังวางแผน… + ตัวอย่าง + สิ่งที่แต่ละซีเควนซ์จะกลายเป็น ตามลำดับที่นำการเปลี่ยนแปลงไปใช้ ยังไม่มีสิ่งใดเปลี่ยนแปลง + เพิ่มการจัดระเบียบใหม่ลงคิวแล้ว + โฟลเดอร์นี้อยู่ที่เดิม + จัดระเบียบใหม่ {0} ซีเควนซ์ + จัดระเบียบใหม่ {0} ซีเควนซ์ + จัดระเบียบซีเควนซ์ทั้งหมดใหม่ + ชื่อใหม่ของแต่ละซีเควนซ์ เช่น {date} {camera} โดย {title} คือชื่อปัจจุบัน + ชื่อซีเควนซ์ + ตั้งชื่อแต่ละซีเควนซ์ตามที่เทมเพลตสร้าง หากปิดไว้ทุกชื่อจะคงเดิม + การจัดระเบียบใหม่รับได้สูงสุด {0} ซีเควนซ์ต่อครั้ง หรือทุกซีเควนซ์: ล้างตัวกรองแล้วเลือกทั้งหมด + ซีเควนซ์ที่เปลี่ยน: {0} · ไฟล์ที่เปลี่ยนชื่อ: {1} · ชื่อที่คงไว้: {2} ผู้ดูแลระบบ ผู้แก้ไข ผู้อัปโหลด diff --git a/i18n/th/Archive.th.resx b/i18n/th/Archive.th.resx index e68eeccb..d098fc62 100644 --- a/i18n/th/Archive.th.resx +++ b/i18n/th/Archive.th.resx @@ -15,6 +15,7 @@ รอจนกว่าจะนำการเปลี่ยนแปลงไปใช้เสร็จ ชุดนี้ว่างเปล่า โปรดเปลี่ยนการเลือกหรือตัวกรอง จะไม่มีสิ่งใดเปลี่ยนแปลง + เปิดใช้เทมเพลตอย่างน้อยหนึ่งรายการ คลังภาพต้องออนไลน์และเขียนได้ รอให้การจำลองการทำงานเสร็จก่อน รอจนกว่าจะอ่านคลังภาพเสร็จ @@ -81,6 +82,12 @@ {0} ถูกเขียนโดย Chronos เวอร์ชันที่ใหม่กว่า (รูปแบบ {1}) คลังภาพ {0} ออฟไลน์อยู่ คลังภาพ {0} เป็นแบบอ่านอย่างเดียว + {0:N0} ซีเควนซ์ยังคงใช้ชื่อไฟล์เดิม: มีภาพที่กำลังใช้งานอยู่ หรือชื่อใหม่ของภาพถูกใช้ไปแล้ว + {0:N0} ซีเควนซ์ยังคงใช้ชื่อไฟล์เดิม: มีภาพที่กำลังใช้งานอยู่ หรือชื่อใหม่ของภาพถูกใช้ไปแล้ว + {0:N0} ซีเควนซ์ไม่ได้ถูกจัดระเบียบใหม่ตามแผน: ซีเควนซ์เปลี่ยนแปลงหลังจากสร้างแผนแล้ว + {0:N0} ซีเควนซ์ไม่ได้ถูกจัดระเบียบใหม่ตามแผน: ซีเควนซ์เปลี่ยนแปลงหลังจากสร้างแผนแล้ว + {0:N0} ซีเควนซ์ยังคงใช้ชื่อและชื่อไฟล์เดิม: ไฟล์ซีเควนซ์มาจาก Chronos เวอร์ชันที่ใหม่กว่า + {0:N0} ซีเควนซ์ยังคงใช้ชื่อและชื่อไฟล์เดิม: ไฟล์ซีเควนซ์มาจาก Chronos เวอร์ชันที่ใหม่กว่า {0} เปลี่ยนแปลงหลังจากสร้างแผนแล้ว การ์ดหรือโฟลเดอร์ {0} ไม่พร้อมใช้งานแล้ว คลังภาพเปลี่ยนแปลงหลังจากสร้างแผนนี้แล้ว @@ -146,6 +153,14 @@ ภาพที่ไม่ได้จัดทำดัชนี: {0}, ภาพที่หายไป: {1} {0}: สร้าง {1}, ใช้ซ้ำ {2}, อ่านไม่ได้ {3}, รอ {4} พร็อกซีสำหรับเซิร์ฟเวอร์: ส่งแล้ว {0}, ไม่ได้ส่ง {1} + คงไว้ตามเดิม เพราะโฟลเดอร์ที่ครอบอยู่ไม่ได้ย้าย: {0} + คงไว้ตามเดิม เพราะเปลี่ยนแปลงหลังจากสร้างแผน: {0} + คงชื่อไฟล์เดิม เพราะมีภาพที่กำลังใช้งานอยู่ หรือชื่อใหม่ถูกใช้ไปแล้ว: {0} + คงชื่อไฟล์เดิม เพราะภาพเปลี่ยนแปลงหลังจากสร้างแผน: {0} + คงชื่อและชื่อไฟล์เดิม เพราะไฟล์ซีเควนซ์มาจาก Chronos เวอร์ชันที่ใหม่กว่า: {0} + คงชื่อและชื่อไฟล์เดิม เพราะเปลี่ยนแปลงหลังจากสร้างแผน: {0} + ซีเควนซ์ที่เปลี่ยน: {0}, ไฟล์ที่เปลี่ยนชื่อ: {1} + การจัดระเบียบใหม่เสร็จสมบูรณ์เมื่อเปิดคลังภาพ รายงานเท่านั้น: ไม่มีการเปลี่ยนแปลงใดๆ โฟลเดอร์: {0}, จัดทำดัชนี: {1}, ลงทะเบียน: {2}, เอาออก: {3} ไม่พบซีเควนซ์: {0} @@ -200,14 +215,30 @@ โฟลเดอร์ของคลังภาพที่ย้าย นำไปใช้ {0} จาก {1} - เปลี่ยนชื่อ {0:N0} ซีเควนซ์ - เปลี่ยนชื่อ {0:N0} ซีเควนซ์ - ย้าย {0:N0} ซีเควนซ์ - ย้าย {0:N0} ซีเควนซ์ การเปลี่ยนแปลง เปลี่ยน {0:N0} จาก {1:N0} ซีเควนซ์ เปลี่ยน {0:N0} จาก {1:N0} ซีเควนซ์ - เทมเพลต + ภาพที่เก็บไว้ในที่เดิมนอกโฟลเดอร์ originals จะคงชื่อเดิม + ภาพที่หายไปจะคงชื่อเดิม + ภาพที่ไม่เคยตรวจสอบจะคงชื่อเดิม โปรดตรวจสอบซีเควนซ์ก่อน + อ่านไฟล์ซีเควนซ์ไม่ได้ ซีเควนซ์จะคงเดิม รวมถึงทุกโฟลเดอร์ที่ครอบซีเควนซ์นี้อยู่ + ย้ายตามโฟลเดอร์ + {0}: จาก {1} เป็น {2} + ไฟล์ + ชื่อไฟล์ + โฟลเดอร์ + โฟลเดอร์ + จัดระเบียบใหม่ {0:N0} ซีเควนซ์ + จัดระเบียบใหม่ {0:N0} ซีเควนซ์ + จัดระเบียบคลังภาพ {0} ใหม่ + คงชื่อเดิม {0:N0} ชื่อ + คงชื่อเดิม {0:N0} ชื่อ + กำลังจำลองการทำงาน… + เปลี่ยนชื่อ {0:N0} ไฟล์ + เปลี่ยนชื่อ {0:N0} ไฟล์ + ชื่อซีเควนซ์ + ชื่อซีเควนซ์ + หน้าต่างจัดระเบียบใหม่จะเปิดเมื่อกล่องโต้ตอบที่เปิดอยู่ปิดลง เพิ่มแท็ก นำไปใช้ แท็กของ {0:N0} ซีเควนซ์ @@ -222,9 +253,8 @@ ส่งออก CSV ตัวกรองของชุด ชุดที่กรอง - ย้าย… พร็อกซี - เปลี่ยนชื่อ… + จัดระเบียบใหม่… แก้ไขแท็ก… ภาพขนาดย่อ ตรวจสอบ diff --git a/i18n/th/Errors.th.resx b/i18n/th/Errors.th.resx index 568cca2c..de676a34 100644 --- a/i18n/th/Errors.th.resx +++ b/i18n/th/Errors.th.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 ซีเควนซ์ที่วิเคราะห์ไม่สำเร็จ: {0} จาก {1} ดูรายละเอียดในบันทึกงาน + โฟลเดอร์ของซีเควนซ์นี้ไม่ได้อยู่ในตำแหน่งที่ดัชนีระบุ โปรดลองอีกครั้งหลังการสแกนครั้งถัดไป เปิดคลังภาพไม่ได้ สำรองหรือแทนที่ดัชนีปัจจุบันไม่ได้ การกู้คืนจะทำงานอีกครั้งเมื่อเริ่มโปรแกรมครั้งถัดไป กู้คืนข้อมูลสำรองนี้ไม่ได้ โปรดเลือกชุดอื่น @@ -37,9 +38,11 @@ ต้นฉบับ {0} ไฟล์หายไปหรือเปลี่ยนแปลงหลังจากจัดเก็บเข้าคลัง โปรดตรวจสอบคลังภาพ เทมเพลตว่างเปล่า ตัวแปรว่างที่ตำแหน่ง {1}: เขียนชื่อไว้ระหว่างวงเล็บปีกกา + ภาพจะสูญเสียนามสกุลไฟล์: ใส่จุดไว้หน้า {ext} หรือเอา {ext} ออก ชื่อไฟล์มีเครื่องหมายทับไม่ได้ ให้ใส่โฟลเดอร์ไว้ในเทมเพลตโฟลเดอร์ รูปแบบหลังเครื่องหมายทวิภาคไม่เหมาะกับตัวแปรนั้น ชื่อจะซ้ำกัน: เพิ่มหมายเลขเฟรม เวลา หรือชื่อเดิม + การสแกนจะข้ามโฟลเดอร์ที่ขึ้นต้นด้วยจุด หรือที่ชื่อ originals, proxies หรือ exports วงเล็บปีกกาที่เปิดที่ตำแหน่ง {1} ไม่มีการปิด ไม่รู้จักตัวแปร “{0}” ที่ตำแหน่ง {1} วงเล็บปีกกาปิดที่ตำแหน่ง {1} ไม่มีวงเล็บเปิด ให้พิมพ์สองตัวติดกันหากต้องการวงเล็บปีกกาตามตัวอักษร diff --git a/i18n/th/Jobs.th.resx b/i18n/th/Jobs.th.resx index 5700d04b..0c3c8698 100644 --- a/i18n/th/Jobs.th.resx +++ b/i18n/th/Jobs.th.resx @@ -76,7 +76,7 @@ นำเข้า การวิเคราะห์แบบเร็ว การบำรุงรักษา - ย้ายคลังภาพ + จัดระเบียบใหม่ ไฟล์กำพร้า พร็อกซี สร้างดัชนีใหม่ diff --git a/i18n/th/Library.th.resx b/i18n/th/Library.th.resx index 274a7abf..cde2134a 100644 --- a/i18n/th/Library.th.resx +++ b/i18n/th/Library.th.resx @@ -10,17 +10,16 @@ ดาวน์โหลด ส่งออกรายการ โฟลเดอร์ - ย้าย… เปิด พร็อกซี ให้คะแนน เรนเดอร์ + จัดระเบียบใหม่… ซิงค์ แท็ก… อัปโหลด ตรวจสอบ ลงทะเบียนโฟลเดอร์ - การย้ายทำได้กับซีเควนซ์ของคลังภาพทีละหนึ่งคลังเท่านั้น เหมือนกันทั้งบนพีซีเครื่องนี้และบนเซิร์ฟเวอร์: ไม่มีอะไรต้องซิงค์ ยังไม่ได้ใช้มุมมองที่บันทึกไว้ โปรดเลือกมุมมองก่อน บัญชีเซิร์ฟเวอร์ของคุณดาวน์โหลดต้นฉบับไม่ได้ @@ -32,6 +31,7 @@ ลงชื่อเข้าใช้ Chronos Server ในหน้าจอเซิร์ฟเวอร์ก่อน ซีเควนซ์ที่เลือกไม่มีอะไรต้องดึงจากเซิร์ฟเวอร์ เซิร์ฟเวอร์มีทุกอย่างที่อยู่ในซีเควนซ์ที่เลือกแล้ว + การจัดระเบียบใหม่ทำได้กับซีเควนซ์ของคลังภาพทีละคลังเท่านั้น ใช้ได้เฉพาะกับซีเควนซ์บนพีซีเครื่องนี้ แต่รายการที่เลือกอยู่บนเซิร์ฟเวอร์ การถ่ายโอนของซีเควนซ์นี้กำลังดำเนินการอยู่แล้ว ล้างตัวกรอง diff --git a/i18n/th/Server.th.resx b/i18n/th/Server.th.resx index 6c99ceaf..13ea4ed9 100644 --- a/i18n/th/Server.th.resx +++ b/i18n/th/Server.th.resx @@ -40,6 +40,7 @@ การเชื่อมต่อล้มเหลว ดูรายละเอียดในบันทึก ไฟล์หนึ่งของซีเควนซ์นี้เปิดอยู่ในโปรแกรมอื่น โปรดปิดไฟล์นั้นแล้วลองอีกครั้ง โฟลเดอร์ของซีเควนซ์นี้ไม่อยู่บนดิสก์แล้ว จึงไม่เหลือสิ่งใดให้ย้ายไปที่ถังขยะ + โฟลเดอร์ของซีเควนซ์นี้ไม่ได้อยู่ในตำแหน่งที่ดัชนีของเซิร์ฟเวอร์ระบุ โปรดลองอีกครั้งหลังการสแกนครั้งถัดไปของเซิร์ฟเวอร์ บัญชีของคุณไม่มีสิทธิ์ทำสิ่งนี้ ภาพของซีเควนซ์เปลี่ยนแปลงบนเซิร์ฟเวอร์ โปรดโหลดใหม่แล้วแก้ไขอีกครั้ง ไฟล์ที่ได้รับเสียหาย โปรดอัปโหลดอีกครั้ง @@ -68,11 +69,14 @@ เซิร์ฟเวอร์นี้ทำงานประเภทนั้นไม่ได้ เอาออกหรือปิดใช้งานผู้ดูแลระบบคนสุดท้ายไม่ได้ ไม่อนุญาตให้ใช้เมธอดนี้ที่นี่ + โฟลเดอร์ใหม่จะอยู่ภายในโฟลเดอร์ของซีเควนซ์อื่น ที่อยู่นั้นไม่ใช่ Chronos Server ไม่พบ โปรดเปลี่ยนรหัสผ่านของคุณก่อน ภาพถูกลบออกจากซีเควนซ์ระหว่างที่กำลังอัปโหลด จึงไม่ได้เพิ่มภาพนี้ อ่าน {0} ไม่ได้ และหากไม่มีแฮชของไฟล์ สำเนาอื่นจะไม่รู้ว่าไฟล์นี้ถูกลบ โปรดปิดโปรแกรมที่ใช้ไฟล์นี้อยู่หรือตรวจดูสิทธิ์ของไฟล์ แล้วลองอีกครั้ง + คลังภาพเปลี่ยนแปลงหลังการจำลองการทำงาน โปรดตรวจดูแผนอีกครั้ง + เซิร์ฟเวอร์หยุดสร้างแผนนี้: ใช้เวลานานเกินไป หรือมีการขอพร้อมกันมากเกินไป โปรดลองอีกครั้งในอีกสักครู่ คลังภาพนี้ไม่สร้างพร็อกซี พร็อกซีนี้สร้างจากภาพอื่น เซิร์ฟเวอร์ไม่ต้องการพร็อกซีของภาพนี้ diff --git a/i18n/th/Settings.th.resx b/i18n/th/Settings.th.resx index f4989fcc..bcb753e5 100644 --- a/i18n/th/Settings.th.resx +++ b/i18n/th/Settings.th.resx @@ -65,6 +65,7 @@ ดาวต่อเมกะพิกเซล ความกว้างการวิเคราะห์ px ด้านยาว + โฟลเดอร์และไฟล์ที่อยู่ในคลังภาพแล้วจะคงชื่อเดิมไว้ ชื่อไฟล์ โฟลเดอร์ ว่าง {0} @@ -74,10 +75,12 @@ เลือกโฟลเดอร์คลังภาพ ตัวอย่าง ขนาดพร็อกซี + จัดระเบียบใหม่… รีเซ็ตคลังภาพ เทมเพลตการตั้งชื่อ ขนาดพร็อกซี และขนาดภาพขนาดย่อของคลังภาพนี้จะกลับเป็นค่าเริ่มต้นสำหรับทุกพีซีและเซิร์ฟเวอร์ที่ใช้คลังภาพนี้ โฟลเดอร์และไฟล์ที่อยู่ในคลังภาพแล้วจะคงชื่อเดิมไว้ รีเซ็ตการตั้งค่าของ {0} หรือไม่ โฟลเดอร์คลังภาพ + บันทึกเทมเพลตของคลังภาพแล้ว ขนาดภาพขนาดย่อ กลับเป็นอัตโนมัติ เลือกโฟลเดอร์ diff --git a/i18n/th/Tooltips.th.resx b/i18n/th/Tooltips.th.resx index 99255220..22f37b88 100644 --- a/i18n/th/Tooltips.th.resx +++ b/i18n/th/Tooltips.th.resx @@ -36,6 +36,7 @@ เปิดซีเควนซ์ของสำเนาแรกในหน้าแก้ไข ค้นหาภาพที่เหมือนกันข้ามซีเควนซ์ด้วยแฮช · อ่านเฉพาะดัชนี แสดงซีเควนซ์ของปีนี้ + ชื่อไฟล์ของแต่ละภาพตามที่การนำเข้าตั้งให้ · ตรวจสอบขณะพิมพ์ แสดงเฉพาะซีเควนซ์ของกล้องตัวเดียว เลือกค่านี้ เลือกอีกครั้งเพื่อล้าง แสดงเฉพาะซีเควนซ์ที่อยู่ในสถานะเดียว @@ -71,7 +72,10 @@ สร้างดัชนีใหม่จากไฟล์ไซด์คาร์ หากไม่มีจะสแกนเมทาดาทาทั้งหมดแทน และไม่ลบต้นฉบับเด็ดขาด เพิ่มการสร้างใหม่ลงคิว · ระหว่างนี้ยังใช้คลังภาพได้ตามปกติ เลือกโฟลเดอร์ใหม่ของคลังภาพที่คุณย้ายไป ซีเควนซ์ทั้งหมดจะย้ายตาม - ทำการเปลี่ยนแปลงตามนี้ทุกประการกับโฟลเดอร์ ไฟล์ไซด์คาร์ และดัชนี · ทำต่อได้หลังเกิดการขัดข้อง + เพิ่มงานที่จะทำการเปลี่ยนแปลงตามนี้ทุกประการลงคิว · หยุดชั่วคราวและดำเนินการต่อได้ใน “งาน” + เปลี่ยนชื่อภาพด้วยเทมเพลตนี้ · หากปิดไว้ ภาพจะคงชื่อเดิม + ย้ายโฟลเดอร์ของซีเควนซ์ไปตามโครงสร้างนี้ · หากปิดไว้ โฟลเดอร์จะอยู่ที่เดิม + เปลี่ยนชื่อซีเควนซ์ด้วยเทมเพลตนี้ · หากปิดไว้ ชื่อจะคงเดิม เลือกข้อมูลสำรองของดัชนีใน การตั้งค่า › ขั้นสูง ข้อมูลสำรองจะแทนที่ดัชนีเมื่อเริ่มโปรแกรมครั้งถัดไป เปลี่ยนแท็กของซีเควนซ์เหล่านี้ในไฟล์ไซด์คาร์และดัชนี เรียกใช้การดำเนินการเดิมอีกครั้ง @@ -80,9 +84,8 @@ เรียกใช้การวิเคราะห์เชิงลึกกับทุกซีเควนซ์ในชุด ย้ายชุดไปที่ถังขยะของคลังภาพ · แสดงการจำลองการทำงานก่อน แล้วให้คุณพิมพ์เพื่อยืนยัน ส่งออกชุดเป็น CSV: หนึ่งแถวต่อซีเควนซ์ - ย้ายชุดไปยังโครงสร้างโฟลเดอร์ใหม่ · จำลองการทำงานก่อน สร้างหรือรีเฟรชพร็อกซี - เปลี่ยนชื่อของซีเควนซ์ในชุดด้วยเทมเพลต · จำลองการทำงานก่อน + นำเทมเพลตโฟลเดอร์ ไฟล์ และชื่อไปใช้กับชุด · จำลองการทำงานก่อน แล้วจึงเรียกใช้เป็นงาน เพิ่มหรือเอาแท็กออกจากทั้งชุด สร้างหรือรีเฟรชภาพขนาดย่อ คำนวณแฮชของต้นฉบับในชุดใหม่ @@ -471,12 +474,12 @@ ดึงสิ่งที่ {0:N0} ซีเควนซ์ยังขาดอยู่ที่นี่ (ต้นฉบับหรือไฟล์เรนเดอร์) จากเซิร์ฟเวอร์ · เรียกใช้เป็นงานถ่ายโอน บันทึก {0:N0} แถวเป็น CSV ในโฟลเดอร์ที่คุณเลือก บันทึก {0:N0} แถวเป็น CSV ในโฟลเดอร์ที่คุณเลือก - ย้าย {0:N0} ซีเควนซ์ไปยังโครงสร้างโฟลเดอร์ใหม่ของคลังภาพ · แสดงการจำลองการทำงานก่อน - ย้าย {0:N0} ซีเควนซ์ไปยังโครงสร้างโฟลเดอร์ใหม่ของคลังภาพ · แสดงการจำลองการทำงานก่อน สร้างพร็อกซี JPEG ของ {0:N0} ซีเควนซ์ · เรียกใช้เป็นงานเดียว สร้างพร็อกซี JPEG ของ {0:N0} ซีเควนซ์ · เรียกใช้เป็นงานเดียว ให้คะแนน {0:N0} ซีเควนซ์ โดยบันทึกในไฟล์ไซด์คาร์และดัชนี ให้คะแนน {0:N0} ซีเควนซ์ โดยบันทึกในไฟล์ไซด์คาร์และดัชนี + นำเทมเพลตโฟลเดอร์ ไฟล์ และชื่อไปใช้กับ {0:N0} ซีเควนซ์ในคลังภาพของตน · จำลองการทำงานก่อน แล้วจึงเรียกใช้เป็นงาน + นำเทมเพลตโฟลเดอร์ ไฟล์ และชื่อไปใช้กับ {0:N0} ซีเควนซ์ในคลังภาพของตน · จำลองการทำงานก่อน แล้วจึงเรียกใช้เป็นงาน เพิ่มหรือเอาแท็กออกจาก {0:N0} ซีเควนซ์ เพิ่มหรือเอาแท็กออกจาก {0:N0} ซีเควนซ์ ส่งสิ่งที่เซิร์ฟเวอร์ยังไม่มีจาก {0:N0} ซีเควนซ์ (ต้นฉบับและการตั้งค่า หรือไฟล์เรนเดอร์) · เรียกใช้เป็นงานถ่ายโอน @@ -692,6 +695,7 @@ “สมดุล” เหมาะกับงานส่วนใหญ่ “ดีที่สุด” วัดที่ความละเอียดสองเท่าและอ่านล่วงหน้าได้ไกลกว่า “เร็ว” วัดที่ครึ่งความละเอียดโดยใช้การเคลื่อนไหวแบบร่าง แสดงรายการตัวเข้ารหัสอีกครั้งหลังติดตั้งไดรเวอร์หรือโคเดก ตรวจหาส่วนขยายโคเดกอีกครั้งหลังติดตั้ง งานถัดไปจะใช้ส่วนขยายเหล่านั้น + นำเทมเพลตของคลังภาพไปใช้กับซีเควนซ์ที่อยู่ในคลังภาพแล้ว · จำลองการทำงานก่อน คืนค่าการตั้งค่าทั้งหมดของพีซีเครื่องนี้เป็นค่าเริ่มต้น โดยจะถามก่อน เขียนเทมเพลตและขนาดเริ่มต้นลงใน archive.json ของคลังภาพนี้ทันที รีเซ็ตการตั้งค่าทั้งหมดทันที diff --git a/i18n/tr/Admin.tr.resx b/i18n/tr/Admin.tr.resx index e588139e..46578c44 100644 --- a/i18n/tr/Admin.tr.resx +++ b/i18n/tr/Admin.tr.resx @@ -9,6 +9,7 @@ Chronos Server Çalışma süresi Sürüm + {0} arşivi yeniden düzenledi · {1} {0} arşiv düzenini değiştirdi {0}, {1} sildi {0} bir görev başlattı: {1} @@ -138,7 +139,7 @@ İçe aktarma Hızlı analiz Bakım - Taşıma + Yeniden düzenleme Sahipsiz dosyalar Proxy'ler Yeniden oluşturma @@ -343,6 +344,7 @@ Bu sunucuyu yönetmek için oturum açar Kullanıcı Bu sunucudaki kullanıcı adınız + Arşiv yeniden düzenlendi Arşiv düzeni Fotoğraflar silindi Görev başlatıldı @@ -426,6 +428,58 @@ Parolayı değiştir Parolayı değiştirir ve panele devam eder Yeni bir parola seçin + Yeniden düzenle… + Seçili sekanslara klasör, dosya ve başlık şablonlarını uygular; önizleme önce her değişikliği gösterir + Sonra: + Uygula… + Önizlemede gösterildiği gibi yeniden düzenler; önce onay istenir + Önce: + Bir şablon yazın veya bu bölümü kapatın. + Hiçbir şeyi değiştirmeden kapatır + Klasörüyle taşınır + Yalnızca içinde bulunduğu bir klasör taşındığı için taşınır + Yeniden adlandırılan dosyalar + Klasör + Sekans + Yeniden düzenle + Orijinalleri taşıyan ve yeniden adlandıran görevi kuyruğa alır; hiçbir şeyin üzerine yazılmaz, hiçbir şey silinmez + {0} fotoğraf yeni ad alır. + {0} fotoğraf yeni ad alır. + {0} klasör taşınır. + {0} klasör taşınır. + {0} sekans değişir. + {0} sekans değişir. + Şimdi yeniden düzenlensin mi? + Her fotoğrafa içe aktarmanın verdiği ad, örn. {date}_{time}_{n:0000}; fotoğrafın yanındaki dosyalar onu izler + Dosyalar + Her sekansın fotoğraflarını yeniden adlandırır; kapalıyken tüm dosya adları korunur + {0} dosya yeniden adlandırıldı + {0} dosya yeniden adlandırıldı + Her sekansın arşivdeki klasörü, örn. {year}/{date} {camera}; {title} yeni başlıktır + Klasörler + Her sekansı şablonunun belirlediği klasöre taşır; kapalıyken tüm klasörler yerinde kalır + Seçili sekanslardan biri artık arşivde değil; kapatıp yeniden seçin. + {0}: {1} + Değiştirmek için en az bir bölümü açın. + Değiştirilecek bir şey yok: bu sekanslar zaten şablonlara uyuyor. + Yeniden düzenle… + Yeni şablonları arşivde zaten bulunan sekanslara uygular; önizleme önce her değişikliği gösterir + Görevi aç + Görevi ve günlüğünü Görevler sayfasında gösterir + Onay sırasında arşiv değişti; yeni önizlemeyi denetleyip yeniden uygulayın. + Planlanıyor… + Önizleme + Değişikliklerin uygulanacağı sırayla her sekansın neye dönüşeceği; henüz hiçbir şey değişmedi + Yeniden düzenleme kuyruğa alındı. + Bu klasör yerinde kalır + {0} sekansı yeniden düzenle + {0} sekansı yeniden düzenle + Tüm sekansları yeniden düzenle + Her sekansın yeni başlığı, örn. {date} {camera}; {title} mevcut başlıktır + Başlıklar + Her sekansa şablonunun oluşturduğu başlığı verir; kapalıyken tüm başlıklar korunur + Yeniden düzenleme bir seferde en fazla {0} sekansı veya tüm sekansları kapsar: filtreleri temizleyip tümünü seçin. + Değişen sekanslar: {0} · yeniden adlandırılan dosyalar: {1} · korunan adlar: {2} Yönetici Düzenleyici Yükleyici diff --git a/i18n/tr/Archive.tr.resx b/i18n/tr/Archive.tr.resx index 2b89ae21..2be448c8 100644 --- a/i18n/tr/Archive.tr.resx +++ b/i18n/tr/Archive.tr.resx @@ -15,6 +15,7 @@ Değişiklikler uygulanana kadar bekleyin. Küme boş: seçimi veya filtreyi değiştirin. Hiçbir şey değişmeyecek. + En az bir şablonu açın. Arşiv çevrimiçi ve yazılabilir olmalıdır. Deneme çalıştırmasını bekleyin. Arşiv okunana kadar bekleyin. @@ -81,6 +82,12 @@ {0}, daha yeni bir Chronos tarafından yazılmış (biçim {1}). {0} arşivi çevrimdışı. {0} arşivi salt okunur. + {0:N0} sekans dosya adlarını korudu: bir fotoğraf kullanımdaydı veya yeni adı zaten alınmıştı. + {0:N0} sekans dosya adlarını korudu: bir fotoğraf kullanımdaydı veya yeni adı zaten alınmıştı. + {0:N0} sekans planlandığı gibi yeniden düzenlenmedi: plan yapıldıktan sonra değişti. + {0:N0} sekans planlandığı gibi yeniden düzenlenmedi: plan yapıldıktan sonra değişti. + {0:N0} sekans başlığını ve dosya adlarını korudu: sekans dosyası daha yeni bir Chronos tarafından yazılmış. + {0:N0} sekans başlıklarını ve dosya adlarını korudu: sekans dosyaları daha yeni bir Chronos tarafından yazılmış. {0}, plan yapıldıktan sonra değişti. {0} kartı veya klasörü artık kullanılamıyor. Arşiv, bu plan yapıldıktan sonra değişti. @@ -146,6 +153,14 @@ Dizine eklenmemiş fotoğraflar: {0}, eksik fotoğraflar: {1} {0} — oluşturulan: {1}, yeniden kullanılan: {2}, okunamayan: {3}, bekleyen: {4} Sunucu için proxy'ler — gönderilen: {0}, gönderilemeyen: {1} + Olduğu gibi bırakıldı, içinde bulunduğu klasör yerinde kaldı: {0} + Olduğu gibi bırakıldı, plan yapıldıktan sonra değişti: {0} + Dosya adları korundu, bir fotoğraf kullanımdaydı veya yeni adı zaten alınmıştı: {0} + Dosya adları korundu, fotoğraflar plan yapıldıktan sonra değişti: {0} + Başlık ve dosya adları korundu, sekans dosyası daha yeni bir Chronos tarafından yazılmış: {0} + Başlık ve dosya adları korundu, plan yapıldıktan sonra değişti: {0} + Değişen sekanslar: {0}, yeniden adlandırılan dosyalar: {1} + Yeniden düzenleme, arşiv açıldığında tamamlandı Yalnızca rapor: hiçbir şey değiştirilmedi. Klasörler: {0}, dizine eklenen: {1}, dahil edilen: {2}, kaldırılan: {3} Sekans bulunamadı: {0} @@ -200,14 +215,30 @@ Taşınan arşivin klasörü Uygula {0} / {1} - {0:N0} sekansı yeniden adlandır - {0:N0} sekansı yeniden adlandır - {0:N0} sekansı taşı - {0:N0} sekansı taşı Değişiklikler {0:N0} / {1:N0} değişiyor {0:N0} / {1:N0} değişiyor - Şablon + Yerinde tutulan ve originals klasörünün dışında kalan fotoğraflar adlarını korur. + Eksik fotoğraflar adlarını korur. + Hiç doğrulanmamış fotoğraflar adlarını korur; önce sekansı doğrulayın. + Sekans dosyası okunamıyor; sekans ve içinde bulunduğu her klasör olduğu gibi kalır. + Klasörünü izler + {0}: {1} yerine {2} + Dosya + Dosya adları + Klasör + Klasörler + {0:N0} sekansı yeniden düzenle + {0:N0} sekansı yeniden düzenle + {0} arşivini yeniden düzenle + {0:N0} ad korundu + {0:N0} ad korundu + Deneme çalıştırması… + {0:N0} dosya yeniden adlandırıldı + {0:N0} dosya yeniden adlandırıldı + Başlık + Başlıklar + Yeniden düzenleme, açık olan iletişim kutusu kapandığında açılır Etiket ekle Uygula {0:N0} sekansın etiketleri @@ -222,9 +253,8 @@ CSV dışa aktar Küme filtresi Filtrelenmiş küme - Taşı… Proxy'ler - Yeniden adlandır… + Yeniden düzenle… Etiketleri düzenle… Küçük resimler Doğrula diff --git a/i18n/tr/Errors.tr.resx b/i18n/tr/Errors.tr.resx index 350ff6c2..678f04b6 100644 --- a/i18n/tr/Errors.tr.resx +++ b/i18n/tr/Errors.tr.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Analiz edilemeyen sekanslar: {0} / {1}; görev günlüğüne bakın. + Bu sekansın klasörü dizinde belirtilen yerde değil; sonraki taramadan sonra yeniden deneyin. Arşiv açılamadı. Geçerli dizin yedeklenemedi veya değiştirilemedi; geri yükleme bir sonraki başlangıçta yeniden çalışır. Bu yedek geri yüklenemiyor; başka bir yedek seçin. @@ -37,9 +38,11 @@ {0} orijinal eksik veya arşivlendikten sonra değişmiş; arşivi doğrulayın. Şablon boş. {1}. konumda boş yer tutucu: süslü parantezlerin arasına bir ad yazın. + Fotoğraflar uzantılarını kaybederdi: {ext} önüne bir nokta yazın veya {ext} yer tutucusunu çıkarın. Dosya adları eğik çizgi içeremez; klasörleri klasör şablonuna yazın. İki noktadan sonraki biçim, yer tutucusuna uygun değil. Adlar yinelenecek: kare numarasını, saati veya orijinal adı ekleyin. + Taramalar, nokta ile başlayan veya adı originals, proxies ya da exports olan klasörleri atlar. {1}. konumda açılan süslü parantez hiç kapatılmamış. {1}. konumda bilinmeyen yer tutucu: “{0}”. {1}. konumdaki kapanış süslü parantezinin açılışı yok; düz parantez için iki kez yazın. diff --git a/i18n/tr/Jobs.tr.resx b/i18n/tr/Jobs.tr.resx index ce847301..af4dc7ff 100644 --- a/i18n/tr/Jobs.tr.resx +++ b/i18n/tr/Jobs.tr.resx @@ -76,7 +76,7 @@ İçe aktarma Hızlı analiz Bakım - Arşivi taşıma + Yeniden düzenleme Sahipsiz dosyalar Proxy'ler Dizini yeniden oluşturma diff --git a/i18n/tr/Library.tr.resx b/i18n/tr/Library.tr.resx index 3c725c73..b1b99066 100644 --- a/i18n/tr/Library.tr.resx +++ b/i18n/tr/Library.tr.resx @@ -10,17 +10,16 @@ İndir Listeyi dışa aktar Klasör - Taşı… Aç Proxy'ler Puan İşle + Yeniden düzenle… Eşitle Etiketler… Karşıya yükle Doğrula Klasör dahil et - Taşıma aynı anda yalnızca tek bir arşivin sekansları üzerinde çalışır. Bu bilgisayarda ve sunucuda aynı: eşitlenecek bir şey yok. Kullanımda kayıtlı görünüm yok; önce birini seçin. Sunucu hesabınız orijinalleri indiremez. @@ -32,6 +31,7 @@ Önce Sunucu ekranından bir Chronos Server'da oturum açın. Seçili sekanslar için sunucudan alınacak bir şey yok. Seçili sekansların içerdiği her şey sunucuda zaten var. + Yeniden düzenleme bir seferde tek bir arşivin sekansları üzerinde çalışır. Yalnızca bu bilgisayardaki sekanslar için; seçili sekanslar yalnızca sunucuda bulunuyor. Bu sekans için zaten bir aktarım sürüyor. Filtreleri temizle diff --git a/i18n/tr/Server.tr.resx b/i18n/tr/Server.tr.resx index 48da7c48..b84f38ef 100644 --- a/i18n/tr/Server.tr.resx +++ b/i18n/tr/Server.tr.resx @@ -40,6 +40,7 @@ Bağlantı başarısız oldu; ayrıntılar günlükte. Sekansın bir dosyası başka bir programda açık; dosyayı kapatıp yeniden deneyin. Klasörü artık diskte değil; çöp kutusuna taşınacak bir şey kalmadı. + Bu sekansın klasörü sunucu dizininde belirtilen yerde değil; sunucunun sonraki taramasından sonra yeniden deneyin. Hesabınızın bunu yapma izni yok. Sekansın fotoğrafları sunucuda değişti; sekansı yeniden yükleyip düzenlemenizi tekrar uygulayın. Dosya hasarlı ulaştı; yeniden karşıya yükleyin. @@ -68,11 +69,14 @@ Bu sunucu bu türde bir görevi çalıştıramaz. Son yönetici kaldırılamaz veya devre dışı bırakılamaz. Bu yönteme burada izin verilmiyor. + Yeni bir klasör, başka bir sekansın klasörünün içinde kalırdı. Bu adres bir Chronos Server değil. Bulunamadı. Önce parolanızı değiştirin. Fotoğraf karşıya yüklenirken sekanstan silindi; bu nedenle eklenmedi. {0} okunamıyor ve karması olmadan diğer kopyalar onun silindiğini öğrenemez; dosyayı kullanan programı kapatın veya izinlerini denetleyin, sonra yeniden deneyin. + Arşiv, deneme çalıştırmasından sonra değişti; planı yeniden gözden geçirin. + Sunucu bu planı hazırlamayı bıraktı: çok uzun sürdü veya aynı anda çok fazla plan istendi; birazdan yeniden deneyin. Bu arşiv proxy oluşturmuyor. Proxy başka bir fotoğraftan oluşturulmuş. Sunucunun bu fotoğrafın proxy'sine ihtiyacı yok. diff --git a/i18n/tr/Settings.tr.resx b/i18n/tr/Settings.tr.resx index d7419682..8bd251c7 100644 --- a/i18n/tr/Settings.tr.resx +++ b/i18n/tr/Settings.tr.resx @@ -65,6 +65,7 @@ megapiksel başına yıldız Analiz genişliği px uzun kenar + Arşivde zaten bulunan klasörler ve dosyalar adlarını korur. Dosya adları Klasörler {0} boş @@ -74,10 +75,12 @@ Arşiv klasörünü seçin Önizleme Proxy boyutu + Yeniden düzenle… Arşivi sıfırla Ad şablonları, proxy boyutu ve küçük resim boyutu, arşivi kullanan her bilgisayar ve sunucu için varsayılanlarına döner. Arşivde zaten bulunan klasörler ve dosyalar adlarını korur. {0} arşivinin ayarları sıfırlansın mı? Arşiv klasörü + Arşiv şablonları kaydedildi Küçük resim boyutu Otomatiğe dön Klasör seç diff --git a/i18n/tr/Tooltips.tr.resx b/i18n/tr/Tooltips.tr.resx index 81e49abd..700a5722 100644 --- a/i18n/tr/Tooltips.tr.resx +++ b/i18n/tr/Tooltips.tr.resx @@ -36,6 +36,7 @@ İlk kopyanın sekansını Düzenleme bölümünde açar Sekanslar arasındaki aynı fotoğrafları karmaya göre bulur · yalnızca dizini okur Bu yılın sekanslarını gösterir + Her fotoğrafın, içe aktarmaların verdiği şekliyle dosya adı · siz yazdıkça denetlenir Yalnızca tek bir kameranın sekanslarını tutar Bu değeri seçer; temizlemek için yeniden seçin Yalnızca tek bir durumdaki sekansları tutar @@ -71,7 +72,10 @@ Dizini sidecar dosyalarından yeniden oluşturur; gerekirse tam meta veri taramasına geçer; orijinalleri asla silmez Yeniden oluşturmayı kuyruğa alır · bu sırada arşiv kullanılabilir kalır Taşıdığınız bir arşivin yeni klasörünü seçer; sekansları da onu izler - Klasörlerde, sidecar dosyalarında ve dizinde tam olarak bu değişiklikleri yapar · çökmeden sonra kaldığı yerden sürer + Tam olarak bu değişiklikleri yapan bir görevi kuyruğa alır · Görevler'de duraklatılıp sürdürülebilir + Fotoğrafları bu şablonla yeniden adlandırır · kapalıyken adlarını korurlar + Sekans klasörlerini bu düzene taşır · kapalıyken yerlerinde kalırlar + Başlıkları bu şablonla değiştirir · kapalıyken oldukları gibi kalırlar Ayarlar › Gelişmiş bölümünde dizinin bir yedeğini seçin; yedek bir sonraki başlangıçta dizinin yerini alır Bu sekansların etiketlerini sidecar dosyalarında ve dizinde değiştirir Aynı eylemi yeniden çalıştırır @@ -80,9 +84,8 @@ Kümedeki her sekansta ayrıntılı analizi çalıştırır Kümeyi arşivin çöp kutusuna taşır · önce deneme çalıştırmasını gösterir, ardından onaylamak için yazmanızı ister Kümeyi CSV olarak dışa aktarır: sekans başına bir satır - Kümeyi yeni bir klasör düzenine taşır · önce deneme çalıştırması Proxy'leri oluşturur veya yeniler - Kümedeki başlıkları bir şablonla yeniden adlandırır · önce deneme çalıştırması + Kümeye klasör, dosya ve başlık şablonlarını uygular · önce deneme çalıştırması, ardından bir görev Kümenin tamamına etiket ekler veya kaldırır Küçük resimleri oluşturur veya yeniler Kümedeki orijinallerin karmasını yeniden hesaplar @@ -471,12 +474,12 @@ {0:N0} sekansın burada eksik olanlarını (orijinaller veya işleme çıktıları) sunucudan alır · aktarım görevleri olarak çalışır {0:N0} satırı seçtiğiniz bir klasöre CSV olarak kaydeder {0:N0} satırı seçtiğiniz bir klasöre CSV olarak kaydeder - {0:N0} sekansı arşivinde yeni bir klasör düzenine taşır · önce deneme çalıştırmasını gösterir - {0:N0} sekansı arşivlerinde yeni bir klasör düzenine taşır · önce deneme çalıştırmasını gösterir {0:N0} sekansın JPEG proxy'lerini oluşturur · tek görev olarak çalışır {0:N0} sekansın JPEG proxy'lerini oluşturur · tek görev olarak çalışır {0:N0} sekansın puanını sidecar dosyasında ve dizinde ayarlar {0:N0} sekansın puanını sidecar dosyalarında ve dizinde ayarlar + Klasör, dosya ve başlık şablonlarını {0:N0} sekansa kendi arşivinde uygular · önce deneme çalıştırması, ardından bir görev + Klasör, dosya ve başlık şablonlarını {0:N0} sekansa kendi arşivlerinde uygular · önce deneme çalıştırması, ardından bir görev {0:N0} sekansa etiket ekler veya kaldırır {0:N0} sekansa etiket ekler veya kaldırır {0:N0} sekansın sunucuda eksik olanlarını (orijinaller ve ayarlar ya da işleme çıktıları) gönderir · aktarım görevi olarak çalışır @@ -692,6 +695,7 @@ “Dengeli” çoğu iş için uygundur; “En iyi” çift çözünürlükte ölçer ve daha ileriyi okur; “Hızlı” yarım çözünürlükte, taslak hareketle ölçer Sürücü veya codec kurulumundan sonra kodlayıcıları yeniden listeler Bir codec uzantısı kurduktan sonra uzantıları yeniden arar; sonraki görevler bunları kullanır + Arşivin şablonlarını içinde zaten bulunan sekanslara uygular · önce deneme çalıştırması Bu bilgisayardaki tüm ayarları varsayılanlarına döndürür; önce sorar Varsayılan şablonları ve boyutları şimdi bu arşivin archive.json dosyasına yazar Tüm ayarları şimdi sıfırlar diff --git a/i18n/uk/Admin.uk.resx b/i18n/uk/Admin.uk.resx index 23302e3c..3d732544 100644 --- a/i18n/uk/Admin.uk.resx +++ b/i18n/uk/Admin.uk.resx @@ -9,6 +9,7 @@ Chronos Server Час роботи Версія + {0}: реорганізовано архів · {1} {0}: змінено структуру архіву {0}: видалено {1} {0}: запущено {1} @@ -156,7 +157,7 @@ Імпорт Швидкий аналіз Обслуговування - Переміщення + Реорганізація Файли-сироти Проксі Перебудова @@ -391,6 +392,7 @@ Увійти, щоб адмініструвати цей сервер Користувач Ваше ім’я користувача на цьому сервері + Архів реорганізовано Структура архіву Фото видалено Завдання запущено @@ -478,6 +480,68 @@ Змінити пароль Замінити пароль і перейти до панелі Виберіть новий пароль + Реорганізувати… + Застосувати шаблони папок, файлів і назв до вибраних послідовностей; спершу попередній перегляд покаже кожну зміну + Після: + Застосувати… + Реорганізувати, як показано в попередньому перегляді; спершу з’явиться запит на підтвердження + До: + Впишіть шаблон або вимкніть цю частину. + Закрити, нічого не змінюючи + Разом із папкою + Переміщується лише тому, що переміщується папка, у якій вона міститься + Перейменовані файли + Папка + Послідовність + Реорганізувати + Додати до черги завдання, яке переміщує й перейменовує оригінали; нічого не перезаписується й не видаляється + {0} фото отримають нові імена. + {0} фото отримають нові імена. + {0} фото отримає нове ім’я. + {0} фото отримають нові імена. + Буде переміщено {0} папки. + Буде переміщено {0} папок. + Буде переміщено {0} папку. + Буде переміщено {0} папок. + Зміняться {0} послідовності. + Зміниться {0} послідовностей. + Зміниться {0} послідовність. + Зміниться {0} послідовностей. + Реорганізувати зараз? + Ім’я кожного фото, яке дає йому імпорт, наприклад {date}_{time}_{n:0000}; файли поруч із фото перейменовуються разом із ним + Файли + Перейменувати фото кожної послідовності; якщо вимкнено, усі імена файлів залишаються + Перейменовано {0} файли + Перейменовано {0} файлів + Перейменовано {0} файл + Перейменовано {0} файлів + Папка кожної послідовності в архіві, наприклад {year}/{date} {camera}; {title} — це нова назва + Папки + Перемістити кожну послідовність у папку, яку дає її шаблон; якщо вимкнено, кожна папка залишається на місці + Однієї з вибраних послідовностей більше немає в архіві; закрийте вікно й виберіть знову. + {0}: {1} + Увімкніть принаймні одну частину, яку потрібно змінити. + Змінювати нічого: ці послідовності вже відповідають шаблонам. + Реорганізувати… + Застосувати нові шаблони до послідовностей, які вже є в архіві; спершу попередній перегляд покаже кожну зміну + Відкрити завдання + Показати завдання та його журнал на сторінці «Завдання» + Архів змінився під час підтвердження; перевірте оновлений попередній перегляд і застосуйте знову. + Планування… + Попередній перегляд + Якою стане кожна послідовність, у порядку застосування змін; поки що нічого не змінено + Реорганізацію додано до черги. + Ця папка залишається на місці + Реорганізувати {0} послідовності + Реорганізувати {0} послідовностей + Реорганізувати {0} послідовність + Реорганізувати {0} послідовностей + Реорганізувати всі послідовності + Нова назва кожної послідовності, наприклад {date} {camera}; {title} — це поточна назва + Назви + Дати кожній послідовності назву, яку створює її шаблон; якщо вимкнено, усі назви залишаються + Реорганізація обробляє щонайбільше {0} послідовностей за раз або всі послідовності: скиньте фільтри й виберіть усе. + Змінено послідовностей: {0} · перейменовано файлів: {1} · збережено імен: {2} Адміністратор Редактор Вивантажувач diff --git a/i18n/uk/Archive.uk.resx b/i18n/uk/Archive.uk.resx index 469c391b..ef6a8331 100644 --- a/i18n/uk/Archive.uk.resx +++ b/i18n/uk/Archive.uk.resx @@ -17,6 +17,7 @@ Зачекайте, доки зміни буде застосовано. Набір порожній: змініть вибір або фільтр. Нічого не зміниться. + Увімкніть принаймні один шаблон. Архів має бути доступним і відкритим для запису. Дочекайтеся пробного запуску. Зачекайте, доки архів буде прочитано. @@ -101,6 +102,18 @@ {0} записано новішою версією Chronos (формат {1}). Архів {0} недоступний. Архів {0} доступний лише для читання. + {0:N0} послідовності зберегли імена файлів: одне з фото використовувалося або його нове ім’я вже було зайняте. + {0:N0} послідовностей зберегли імена файлів: одне з фото використовувалося або його нове ім’я вже було зайняте. + {0:N0} послідовність зберегла імена файлів: одне з фото використовувалося або його нове ім’я вже було зайняте. + {0:N0} послідовностей зберегли імена файлів: одне з фото використовувалося або його нове ім’я вже було зайняте. + {0:N0} послідовності не реорганізовано за планом: їх змінено після складання плану. + {0:N0} послідовностей не реорганізовано за планом: їх змінено після складання плану. + {0:N0} послідовність не реорганізовано за планом: її змінено після складання плану. + {0:N0} послідовностей не реорганізовано за планом: їх змінено після складання плану. + {0:N0} послідовності зберегли назви й імена файлів: їхні файли послідовностей записано новішою версією Chronos. + {0:N0} послідовностей зберегли назви й імена файлів: їхні файли послідовностей записано новішою версією Chronos. + {0:N0} послідовність зберегла назву й імена файлів: її файл послідовності записано новішою версією Chronos. + {0:N0} послідовностей зберегли назви й імена файлів: їхні файли послідовностей записано новішою версією Chronos. {0} змінено після складання плану. Картка або папка {0} більше недоступна. Архів змінився після складання цього плану. @@ -178,6 +191,14 @@ Непроіндексовані фото: {0}, відсутні фото: {1} {0} — створено: {1}, використано повторно: {2}, нечитабельні: {3}, в очікуванні: {4} Проксі для сервера — надіслано: {0}, не надіслано: {1} + Залишено без змін, бо папка, що її містить, залишилася на місці: {0} + Залишено без змін, змінено після складання плану: {0} + Імена файлів збережено, одне з фото використовувалося або його нове ім’я було зайняте: {0} + Імена файлів збережено, фото змінено після складання плану: {0} + Назву й імена файлів збережено, файл послідовності записано новішою версією Chronos: {0} + Назву й імена файлів збережено, змінено після складання плану: {0} + Змінено послідовностей: {0}, перейменовано файлів: {1} + Реорганізацію завершено під час відкриття архіву Лише звіт: нічого не змінено. Папки: {0}, проіндексовано: {1}, приєднано: {2}, вилучено: {3} Послідовність не знайдено: {0} @@ -238,20 +259,38 @@ Папка переміщеного архіву Застосувати {0} з {1} - Перейменувати {0:N0} послідовності - Перейменувати {0:N0} послідовностей - Перейменувати {0:N0} послідовність - Перейменувати {0:N0} послідовностей - Перемістити {0:N0} послідовності - Перемістити {0:N0} послідовностей - Перемістити {0:N0} послідовність - Перемістити {0:N0} послідовностей Зміни Зміняться {0:N0} з {1:N0} Зміниться {0:N0} з {1:N0} Зміниться {0:N0} з {1:N0} Зміниться {0:N0} з {1:N0} - Шаблон + Фото, залишені на місці поза папкою originals, зберігають свої імена. + Відсутні фото зберігають свої імена. + Фото, які ще жодного разу не перевірялися, зберігають свої імена; спершу перевірте послідовність. + Не вдалося прочитати файл послідовності; послідовність залишається як є, як і будь-яка папка, що її містить. + Слідує за папкою + {0}: з {1} на {2} + Файл + Імена файлів + Папка + Папки + Реорганізувати {0:N0} послідовності + Реорганізувати {0:N0} послідовностей + Реорганізувати {0:N0} послідовність + Реорганізувати {0:N0} послідовностей + Реорганізувати {0} + Збережено {0:N0} імені + Збережено {0:N0} імен + Збережено {0:N0} ім’я + Збережено {0:N0} імен + Пробний запуск… + Перейменовано {0:N0} файли + Перейменовано {0:N0} файлів + Перейменовано {0:N0} файл + Перейменовано {0:N0} файлів + Назва + Назви + Реорганізація відкриється, щойно закриється відкрите вікно Додати теги Застосувати Теги {0:N0} послідовностей @@ -270,9 +309,8 @@ Експортувати CSV Фільтр набору Відфільтрований набір - Перемістити… Проксі - Перейменувати… + Реорганізувати… Змінити теги… Мініатюри Перевірити diff --git a/i18n/uk/Errors.uk.resx b/i18n/uk/Errors.uk.resx index 1870e607..273975ff 100644 --- a/i18n/uk/Errors.uk.resx +++ b/i18n/uk/Errors.uk.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Не вдалося проаналізувати послідовності: {0} з {1}; див. журнал завдання. + Папка цієї послідовності не там, де її вказує індекс; спробуйте знову після наступного сканування. Не вдалося відкрити архів. Не вдалося створити копію поточного індексу або замінити його; відновлення повториться під час наступного запуску. Цю резервну копію неможливо відновити; виберіть іншу. @@ -41,9 +42,11 @@ {0} оригіналів відсутні або змінилися після архівування; перевірте архів. Шаблон порожній. Порожнє поле в позиції {1}: впишіть назву між фігурними дужками. + Фото втратять розширення: поставте крапку перед {ext} або приберіть {ext}. Імена файлів не можуть містити скісну риску; папки задайте в шаблоні папок. Формат після двокрапки не підходить для цього поля. Імена повторюватимуться: додайте номер кадру, час або оригінальне ім’я. + Сканування пропускає папки, що починаються з крапки або називаються originals, proxies чи exports. Фігурна дужка, відкрита в позиції {1}, ніде не закривається. Невідоме поле «{0}» у позиції {1}. Закривна фігурна дужка в позиції {1} не має відкривної; щоб отримати саму дужку, подвойте її. diff --git a/i18n/uk/Jobs.uk.resx b/i18n/uk/Jobs.uk.resx index a13180d6..1dfda1c2 100644 --- a/i18n/uk/Jobs.uk.resx +++ b/i18n/uk/Jobs.uk.resx @@ -78,7 +78,7 @@ Імпорт Швидкий аналіз Обслуговування - Переміщення архіву + Реорганізація Файли-сироти Проксі Перебудова індексу diff --git a/i18n/uk/Library.uk.resx b/i18n/uk/Library.uk.resx index 0cf12424..641e6e56 100644 --- a/i18n/uk/Library.uk.resx +++ b/i18n/uk/Library.uk.resx @@ -10,17 +10,16 @@ Завантажити Експортувати список Папка - Перемістити… Відкрити Проксі Оцінка Рендерити + Реорганізувати… Синхронізувати Теги… Вивантажити Перевірити Приєднати папку - За один раз можна переміщувати послідовності лише одного архіву. Послідовність однакова на цьому ПК і на сервері: синхронізувати нічого. Жодне збережене подання не використовується; спершу виберіть подання. Ваш обліковий запис на сервері не може завантажувати оригінали. @@ -32,6 +31,7 @@ Спершу відкрийте екран «Сервер» і увійдіть на Chronos Server. Для вибраних послідовностей на сервері немає нічого для завантаження. Сервер уже має все, що містять вибрані послідовності. + Реорганізація працює з послідовностями лише одного архіву за раз. Лише для послідовностей на цьому ПК; вибрані послідовності зберігаються на сервері. Передача цієї послідовності вже триває. Скинути фільтри diff --git a/i18n/uk/Server.uk.resx b/i18n/uk/Server.uk.resx index 828d430c..4c027755 100644 --- a/i18n/uk/Server.uk.resx +++ b/i18n/uk/Server.uk.resx @@ -40,6 +40,7 @@ Не вдалося підключитися; подробиці в журналі. Файл послідовності відкрито в іншій програмі; закрийте його й спробуйте ще раз. Її папки більше немає на диску; переміщувати до кошика нічого. + Папка цієї послідовності не там, де її вказує індекс сервера; спробуйте знову після його наступного сканування. Ваш обліковий запис не має на це права. Фото послідовності змінилися на сервері; перезавантажте її й застосуйте свою зміну ще раз. Файл надійшов пошкодженим; вивантажте його ще раз. @@ -68,11 +69,14 @@ Цей сервер не може виконувати завдання такого типу. Останнього адміністратора не можна видалити чи вимкнути. Цей метод тут не дозволено. + Нова папка опинилася б усередині папки іншої послідовності. За цією адресою немає Chronos Server. Не знайдено. Спочатку змініть пароль. Фото видалили з послідовності під час його вивантаження, тому його не додано. Не вдалося прочитати {0}, а без його хешу інші копії не дізнаються, що його видалено; закрийте програму, яка його використовує, або перевірте дозволи, а потім спробуйте ще раз. + Архів змінився після пробного запуску; перегляньте план ще раз. + Сервер припинив складати цей план: це тривало задовго або забагато планів запитано одночасно; спробуйте трохи згодом. Цей архів не створює проксі. Проксі створено з іншого фото. Серверу не потрібен проксі цього фото. diff --git a/i18n/uk/Settings.uk.resx b/i18n/uk/Settings.uk.resx index c02560c9..4ae941ea 100644 --- a/i18n/uk/Settings.uk.resx +++ b/i18n/uk/Settings.uk.resx @@ -67,6 +67,7 @@ зір на мегапіксель Ширина аналізу пкс за довшою стороною + Папки й файли, які вже є в архіві, зберігають свої імена. Імена файлів Папки {0} вільно @@ -76,10 +77,12 @@ Виберіть папку архіву Попередній перегляд Розмір проксі + Реорганізувати… Скинути архів Його шаблони імен, розмір проксі й розмір мініатюр повернуться до значень за замовчуванням для кожного ПК і сервера, що його використовують. Папки й файли, які вже є в архіві, збережуть свої імена. Скинути налаштування архіву {0}? Папка архіву + Шаблони архіву збережено Розмір мініатюр Повернути «Авто» Вибрати папку diff --git a/i18n/uk/Tooltips.uk.resx b/i18n/uk/Tooltips.uk.resx index aa5ec325..209f3bd2 100644 --- a/i18n/uk/Tooltips.uk.resx +++ b/i18n/uk/Tooltips.uk.resx @@ -38,6 +38,7 @@ Відкрити послідовність першої копії на екрані «Редагування» Знайти однакові фото в різних послідовностях за хешем · читає лише індекс Показати послідовності цього року + Ім’я файлу кожного фото, як його дає імпорт · перевіряється під час введення Залишити лише послідовності однієї камери Вибрати це значення; повторний вибір скидає його Залишити лише послідовності в одному стані @@ -73,7 +74,10 @@ Перебудувати індекс із супровідних файлів; без них виконується повне сканування метаданих; оригінали ніколи не видаляються Поставити перебудову в чергу · тим часом архівом можна користуватися Вибрати нову папку архіву, який ви перемістили; його послідовності переходять разом із ним - Внести саме ці зміни в папки, супровідні файли та індекс · продовжується після збою + Додати до черги завдання, яке внесе саме ці зміни · його можна призупинити й відновити в розділі «Завдання» + Перейменувати фото за цим шаблоном · якщо вимкнено, вони зберігають свої імена + Перемістити папки послідовностей у цю структуру · якщо вимкнено, вони залишаються на місці + Змінити назви за цим шаблоном · якщо вимкнено, вони залишаються як є Виберіть резервну копію індексу в розділі «Налаштування › Додатково»; вона замінить індекс під час наступного запуску Змінити теги цих послідовностей у супровідних файлах та індексі Ще раз виконати ту саму дію @@ -82,9 +86,8 @@ Виконати глибокий аналіз кожної послідовності набору Перемістити набір до кошика архіву · спершу показує пробний запуск, потім просить підтвердити введенням Експортувати набір як CSV: один рядок на послідовність - Перемістити набір у нову структуру папок · спершу пробний запуск Створити або оновити проксі - Змінити назви послідовностей набору за шаблоном · спершу пробний запуск + Застосувати шаблони папок, файлів і назв до набору · спершу пробний запуск, потім завдання Додати або вилучити теги для всього набору Створити або оновити мініатюри Повторно обчислити хеші оригіналів набору @@ -485,10 +488,6 @@ Зберегти {0:N0} рядків як CSV у вибрану вами папку Зберегти {0:N0} рядок як CSV у вибрану вами папку Зберегти {0:N0} рядків як CSV у вибрану вами папку - Перемістити {0:N0} послідовності в нову структуру папок їхнього архіву · спершу пробний запуск - Перемістити {0:N0} послідовностей у нову структуру папок їхнього архіву · спершу пробний запуск - Перемістити {0:N0} послідовність у нову структуру папок її архіву · спершу пробний запуск - Перемістити {0:N0} послідовностей у нову структуру папок їхнього архіву · спершу пробний запуск Створити JPEG-проксі для {0:N0} послідовностей · виконується як одне завдання Створити JPEG-проксі для {0:N0} послідовностей · виконується як одне завдання Створити JPEG-проксі для {0:N0} послідовності · виконується як одне завдання @@ -497,6 +496,10 @@ Задати оцінку для {0:N0} послідовностей у їхніх супровідних файлах та індексі Задати оцінку для {0:N0} послідовності в її супровідному файлі та індексі Задати оцінку для {0:N0} послідовностей у їхніх супровідних файлах та індексі + Застосувати шаблони папок, файлів і назв до {0:N0} послідовностей їхнього архіву · спершу пробний запуск, потім завдання + Застосувати шаблони папок, файлів і назв до {0:N0} послідовностей їхнього архіву · спершу пробний запуск, потім завдання + Застосувати шаблони папок, файлів і назв до {0:N0} послідовності її архіву · спершу пробний запуск, потім завдання + Застосувати шаблони папок, файлів і назв до {0:N0} послідовностей їхнього архіву · спершу пробний запуск, потім завдання Додати або вилучити теги для {0:N0} послідовностей Додати або вилучити теги для {0:N0} послідовностей Додати або вилучити теги для {0:N0} послідовності @@ -730,6 +733,7 @@ «Збалансований» підходить для більшості робіт; «Найкращий» вимірює з подвоєною роздільністю й читає далі наперед; «Швидкий» вимірює з половинною роздільністю й чорновим рухом Знову скласти список кодувальників після встановлення драйвера чи кодека Знову шукати розширення кодеків після інсталяції одного з них; наступні завдання їх використовуватимуть + Застосувати шаблони архіву до послідовностей, які вже є в ньому · спершу пробний запуск Повернути всі налаштування цього ПК до значень за замовчуванням; спершу з’явиться запит Записати шаблони й розміри за замовчуванням у файл archive.json цього архіву зараз Скинути всі налаштування зараз diff --git a/i18n/vi/Admin.vi.resx b/i18n/vi/Admin.vi.resx index aa40db3c..2b6e20f3 100644 --- a/i18n/vi/Admin.vi.resx +++ b/i18n/vi/Admin.vi.resx @@ -9,6 +9,7 @@ Chronos Server Thời gian hoạt động Phiên bản + {0} đã tổ chức lại kho lưu trữ · {1} {0} đã thay đổi bố cục kho lưu trữ {0} đã xóa {1} {0} đã bắt đầu {1} @@ -138,7 +139,7 @@ Nhập Phân tích nhanh Bảo trì - Di chuyển + Tổ chức lại Tệp mồ côi Proxy Dựng lại @@ -343,6 +344,7 @@ Đăng nhập để quản trị máy chủ này Người dùng Tên người dùng của bạn trên máy chủ này + Đã tổ chức lại kho lưu trữ Bố cục kho lưu trữ Đã xóa ảnh Đã bắt đầu tác vụ @@ -426,6 +428,58 @@ Đổi mật khẩu Thay mật khẩu và tiếp tục vào bảng quản trị Chọn mật khẩu mới + Tổ chức lại… + Áp dụng mẫu thư mục, tệp và tiêu đề cho các chuỗi ảnh đã chọn; trước tiên, bản xem trước hiển thị mọi thay đổi + Sau: + Áp dụng… + Tổ chức lại đúng như bản xem trước; trước tiên sẽ yêu cầu xác nhận + Trước: + Hãy viết một mẫu, hoặc tắt phần này. + Đóng mà không thay đổi gì + Đi theo thư mục + Chỉ di chuyển vì thư mục chứa nó được di chuyển + Tệp đã đổi tên + Thư mục + Chuỗi ảnh + Tổ chức lại + Đưa vào hàng đợi tác vụ di chuyển và đổi tên các bản gốc; không có gì bị ghi đè hay xóa + {0} ảnh sẽ được đặt tên mới. + {0} ảnh sẽ được đặt tên mới. + {0} thư mục sẽ được di chuyển. + {0} thư mục sẽ được di chuyển. + {0} chuỗi ảnh sẽ thay đổi. + {0} chuỗi ảnh sẽ thay đổi. + Tổ chức lại ngay? + Tên của mỗi ảnh theo cách lượt nhập đặt tên, ví dụ {date}_{time}_{n:0000}; các tệp đi kèm một ảnh sẽ đổi tên theo ảnh đó + Tệp + Đổi tên các ảnh của mỗi chuỗi ảnh; khi tắt, mọi tên tệp được giữ nguyên + Đã đổi tên {0} tệp + Đã đổi tên {0} tệp + Thư mục của mỗi chuỗi ảnh trong kho lưu trữ, ví dụ {year}/{date} {camera}; {title} là tiêu đề mới + Thư mục + Di chuyển mỗi chuỗi ảnh vào thư mục do mẫu tạo ra; khi tắt, mọi thư mục vẫn ở nguyên chỗ + Một chuỗi ảnh đã chọn không còn trong kho lưu trữ; hãy đóng hộp thoại rồi chọn lại. + {0}: {1} + Hãy bật ít nhất một phần cần thay đổi. + Không có gì để thay đổi: các chuỗi ảnh này đã tuân theo các mẫu. + Tổ chức lại… + Áp dụng các mẫu mới cho những chuỗi ảnh đã có trong kho lưu trữ; trước tiên, bản xem trước hiển thị mọi thay đổi + Mở tác vụ + Hiển thị tác vụ và nhật ký của tác vụ trên trang Tác vụ + Kho lưu trữ đã thay đổi trong lúc xác nhận; hãy kiểm tra bản xem trước mới rồi áp dụng lại. + Đang lập kế hoạch… + Xem trước + Mỗi chuỗi ảnh sẽ trở thành thế nào, theo thứ tự áp dụng thay đổi; hiện chưa có gì thay đổi + Tác vụ tổ chức lại đã vào hàng đợi. + Thư mục này vẫn ở nguyên chỗ + Tổ chức lại {0} chuỗi ảnh + Tổ chức lại {0} chuỗi ảnh + Tổ chức lại mọi chuỗi ảnh + Tiêu đề mới của mỗi chuỗi ảnh, ví dụ {date} {camera}; {title} là tiêu đề hiện tại + Tiêu đề + Đặt cho mỗi chuỗi ảnh tiêu đề do mẫu tạo ra; khi tắt, mọi tiêu đề được giữ nguyên + Mỗi lần chỉ tổ chức lại được tối đa {0} chuỗi ảnh, hoặc toàn bộ chuỗi ảnh: hãy xóa bộ lọc và chọn tất cả. + Chuỗi ảnh đã thay đổi: {0} · tệp đã đổi tên: {1} · tên được giữ nguyên: {2} Quản trị viên Biên tập viên Người tải lên diff --git a/i18n/vi/Archive.vi.resx b/i18n/vi/Archive.vi.resx index 2e982dae..7ba15d49 100644 --- a/i18n/vi/Archive.vi.resx +++ b/i18n/vi/Archive.vi.resx @@ -15,6 +15,7 @@ Hãy đợi đến khi các thay đổi được áp dụng. Tập hợp đang trống: hãy thay đổi vùng chọn hoặc bộ lọc. Sẽ không có gì thay đổi. + Hãy bật ít nhất một mẫu. Kho lưu trữ phải đang trực tuyến và cho phép ghi. Hãy đợi lượt chạy thử hoàn tất. Hãy đợi đến khi đọc xong kho lưu trữ. @@ -81,6 +82,12 @@ {0} được ghi bởi một phiên bản Chronos mới hơn (định dạng {1}). Kho lưu trữ {0} đang ngoại tuyến. Kho lưu trữ {0} ở chế độ chỉ đọc. + {0:N0} chuỗi ảnh vẫn giữ tên tệp: một ảnh đang được sử dụng hoặc tên mới của ảnh đã được dùng. + {0:N0} chuỗi ảnh vẫn giữ tên tệp: một ảnh đang được sử dụng hoặc tên mới của ảnh đã được dùng. + {0:N0} chuỗi ảnh chưa được tổ chức lại như dự kiến: chuỗi ảnh đã thay đổi sau khi lập kế hoạch. + {0:N0} chuỗi ảnh chưa được tổ chức lại như dự kiến: các chuỗi ảnh đã thay đổi sau khi lập kế hoạch. + {0:N0} chuỗi ảnh vẫn giữ tiêu đề và tên tệp: tệp chuỗi ảnh được ghi bởi một phiên bản Chronos mới hơn. + {0:N0} chuỗi ảnh vẫn giữ tiêu đề và tên tệp: các tệp chuỗi ảnh được ghi bởi một phiên bản Chronos mới hơn. {0} đã thay đổi sau khi lập kế hoạch. Thẻ nhớ hoặc thư mục {0} không còn khả dụng. Kho lưu trữ đã thay đổi sau khi lập kế hoạch này. @@ -146,6 +153,14 @@ Ảnh chưa lập chỉ mục: {0}, ảnh bị thiếu: {1} {0}: tạo mới {1}, dùng lại {2}, không đọc được {3}, đang chờ {4} Proxy cho máy chủ: đã gửi {0}, chưa gửi được {1} + Giữ nguyên, thư mục chứa nó vẫn ở nguyên chỗ: {0} + Giữ nguyên, đã thay đổi sau khi lập kế hoạch: {0} + Giữ tên tệp, một ảnh đang được sử dụng hoặc tên mới của ảnh đã được dùng: {0} + Giữ tên tệp, ảnh đã thay đổi sau khi lập kế hoạch: {0} + Giữ tiêu đề và tên tệp, tệp chuỗi ảnh được ghi bởi một phiên bản Chronos mới hơn: {0} + Giữ tiêu đề và tên tệp, đã thay đổi sau khi lập kế hoạch: {0} + Chuỗi ảnh đã thay đổi: {0}, tệp đã đổi tên: {1} + Việc tổ chức lại đã hoàn tất khi mở kho lưu trữ Chỉ báo cáo: không có gì thay đổi. Thư mục: {0}, đã lập chỉ mục: {1}, đã tiếp nhận: {2}, đã loại bỏ: {3} Không tìm thấy chuỗi ảnh: {0} @@ -200,14 +215,30 @@ Thư mục của kho lưu trữ đã di chuyển Áp dụng {0} trên {1} - Đổi tên {0:N0} chuỗi ảnh - Đổi tên {0:N0} chuỗi ảnh - Di chuyển {0:N0} chuỗi ảnh - Di chuyển {0:N0} chuỗi ảnh Thay đổi {0:N0} trên {1:N0} sẽ thay đổi {0:N0} trên {1:N0} sẽ thay đổi - Mẫu + Ảnh được giữ tại chỗ bên ngoài thư mục originals vẫn giữ tên. + Ảnh bị thiếu vẫn giữ tên. + Ảnh chưa từng được xác minh vẫn giữ tên; hãy xác minh chuỗi ảnh trước. + Không đọc được tệp chuỗi ảnh; chuỗi ảnh được giữ nguyên, mọi thư mục chứa nó cũng vậy. + Theo thư mục chứa + {0}: từ {1} thành {2} + Tệp + Tên tệp + Thư mục + Thư mục + Tổ chức lại {0:N0} chuỗi ảnh + Tổ chức lại {0:N0} chuỗi ảnh + Tổ chức lại {0} + Giữ nguyên {0:N0} tên + Giữ nguyên {0:N0} tên + Đang chạy thử… + Đã đổi tên {0:N0} tệp + Đã đổi tên {0:N0} tệp + Tiêu đề + Tiêu đề + Tổ chức lại sẽ mở khi hộp thoại đang mở được đóng Thêm nhãn Áp dụng Nhãn của {0:N0} chuỗi ảnh @@ -222,9 +253,8 @@ Xuất CSV Bộ lọc tập hợp Tập đã lọc - Di chuyển… Proxy - Đổi tên… + Tổ chức lại… Gắn lại nhãn… Hình thu nhỏ Xác minh diff --git a/i18n/vi/Errors.vi.resx b/i18n/vi/Errors.vi.resx index bd207d24..d6b64ad7 100644 --- a/i18n/vi/Errors.vi.resx +++ b/i18n/vi/Errors.vi.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 Chuỗi ảnh chưa được phân tích: {0} trên {1}; hãy xem nhật ký tác vụ. + Thư mục của chuỗi ảnh này không nằm ở vị trí mà chỉ mục ghi nhận; hãy thử lại sau lượt quét tiếp theo. Không thể mở kho lưu trữ. Không thể sao lưu hoặc thay thế chỉ mục hiện tại; việc khôi phục sẽ chạy lại ở lần khởi động tiếp theo. Không thể khôi phục bản sao lưu này; hãy chọn bản khác. @@ -37,9 +38,11 @@ {0} bản gốc bị thiếu hoặc đã thay đổi kể từ khi được lưu trữ; hãy xác minh kho lưu trữ. Mẫu đang trống. Biến trống ở vị trí {1}: hãy viết một tên giữa hai dấu ngoặc nhọn. + Ảnh sẽ mất phần mở rộng: hãy viết dấu chấm trước {ext}, hoặc bỏ {ext} đi. Tên tệp không được chứa dấu gạch chéo; hãy đặt thư mục trong mẫu thư mục. Định dạng sau dấu hai chấm không phù hợp với biến của nó. Tên sẽ bị trùng: hãy thêm số khung hình, thời gian hoặc tên gốc. + Lượt quét bỏ qua các thư mục bắt đầu bằng dấu chấm hoặc có tên originals, proxies hay exports. Dấu ngoặc nhọn mở ở vị trí {1} không được đóng. Biến không xác định “{0}” ở vị trí {1}. Dấu ngoặc nhọn đóng ở vị trí {1} không có dấu mở tương ứng; hãy viết hai lần để có một dấu ngoặc nhọn thực. diff --git a/i18n/vi/Jobs.vi.resx b/i18n/vi/Jobs.vi.resx index 73b8d585..184ae463 100644 --- a/i18n/vi/Jobs.vi.resx +++ b/i18n/vi/Jobs.vi.resx @@ -76,7 +76,7 @@ Nhập Phân tích nhanh Bảo trì - Di chuyển kho lưu trữ + Tổ chức lại Tệp mồ côi Proxy Dựng lại chỉ mục diff --git a/i18n/vi/Library.vi.resx b/i18n/vi/Library.vi.resx index 1f63fff4..ad20fcb5 100644 --- a/i18n/vi/Library.vi.resx +++ b/i18n/vi/Library.vi.resx @@ -10,17 +10,16 @@ Tải xuống Xuất danh sách Thư mục - Di chuyển… Mở Proxy Xếp hạng Kết xuất + Tổ chức lại… Đồng bộ hóa Nhãn… Tải lên Xác minh Tiếp nhận thư mục - Chỉ có thể di chuyển các chuỗi ảnh của một kho lưu trữ mỗi lần. Giống nhau trên máy tính này và trên máy chủ: không có gì để đồng bộ hóa. Chưa dùng chế độ xem đã lưu nào; hãy chọn một chế độ xem trước. Tài khoản máy chủ của bạn không thể tải xuống bản gốc. @@ -32,6 +31,7 @@ Hãy đăng nhập vào một Chronos Server trước, trên màn hình Máy chủ. Các chuỗi ảnh đã chọn không có gì cần lấy từ máy chủ. Máy chủ đã có mọi thứ mà các chuỗi ảnh đã chọn đang chứa. + Mỗi lần tổ chức lại chỉ áp dụng cho các chuỗi ảnh của một kho lưu trữ. Chỉ dành cho chuỗi ảnh trên máy tính này; vùng chọn nằm trên máy chủ. Một lượt truyền của chuỗi ảnh này đang diễn ra. Xóa bộ lọc diff --git a/i18n/vi/Server.vi.resx b/i18n/vi/Server.vi.resx index 0a9280d2..836afe53 100644 --- a/i18n/vi/Server.vi.resx +++ b/i18n/vi/Server.vi.resx @@ -40,6 +40,7 @@ Kết nối thất bại; xem chi tiết trong nhật ký. Một tệp của chuỗi ảnh đang được mở trong chương trình khác; hãy đóng tệp đó rồi thử lại. Thư mục của chuỗi ảnh không còn trên đĩa; không còn gì để chuyển vào thùng rác. + Thư mục của chuỗi ảnh này không nằm ở vị trí mà chỉ mục của máy chủ ghi nhận; hãy thử lại sau lượt quét tiếp theo của máy chủ. Tài khoản của bạn không có quyền làm việc này. Ảnh của chuỗi ảnh đã thay đổi trên máy chủ; hãy tải lại rồi áp dụng lại chỉnh sửa của bạn. Tệp nhận được bị hỏng; hãy tải lên lại. @@ -68,11 +69,14 @@ Máy chủ này không thể chạy loại tác vụ đó. Không thể loại bỏ hoặc vô hiệu hóa quản trị viên cuối cùng. Phương thức này không được phép tại đây. + Một thư mục mới sẽ nằm bên trong thư mục của một chuỗi ảnh khác. Địa chỉ đó không phải là Chronos Server. Không tìm thấy. Hãy đổi mật khẩu trước. Ảnh đã bị xóa khỏi chuỗi ảnh trong khi đang được tải lên, nên ảnh không được thêm vào. Không thể đọc {0}, và nếu không có mã băm của tệp, các bản sao khác sẽ không biết tệp đã bị xóa; hãy đóng chương trình đang dùng tệp hoặc kiểm tra quyền truy cập của tệp, rồi thử lại. + Kho lưu trữ đã thay đổi sau lượt chạy thử; hãy xem lại kế hoạch. + Máy chủ đã ngừng lập kế hoạch này: mất quá nhiều thời gian, hoặc có quá nhiều yêu cầu cùng lúc; hãy thử lại sau ít phút. Kho lưu trữ này không tạo proxy. Proxy được tạo từ một ảnh khác. Máy chủ không cần proxy của ảnh này. diff --git a/i18n/vi/Settings.vi.resx b/i18n/vi/Settings.vi.resx index 71a5a30b..946384c8 100644 --- a/i18n/vi/Settings.vi.resx +++ b/i18n/vi/Settings.vi.resx @@ -65,6 +65,7 @@ sao mỗi megapixel Độ rộng phân tích px cạnh dài + Thư mục và tệp đã có trong kho lưu trữ vẫn giữ tên. Tên tệp Thư mục {0} trống @@ -74,10 +75,12 @@ Chọn thư mục kho lưu trữ Xem trước Kích thước proxy + Tổ chức lại… Đặt lại kho lưu trữ Các mẫu đặt tên, kích thước proxy và kích thước hình thu nhỏ của kho lưu trữ trở về mặc định cho mọi máy tính và máy chủ sử dụng kho này. Thư mục và tệp đã có trong kho lưu trữ vẫn giữ tên. Đặt lại cài đặt của {0}? Thư mục kho lưu trữ + Đã lưu các mẫu của kho lưu trữ Kích thước hình thu nhỏ Về Tự động Chọn thư mục diff --git a/i18n/vi/Tooltips.vi.resx b/i18n/vi/Tooltips.vi.resx index 70fbe22e..d1fc0a7e 100644 --- a/i18n/vi/Tooltips.vi.resx +++ b/i18n/vi/Tooltips.vi.resx @@ -36,6 +36,7 @@ Mở chuỗi ảnh của bản sao đầu tiên trong Chỉnh sửa Tìm ảnh giống hệt nhau giữa các chuỗi ảnh theo mã băm · chỉ đọc chỉ mục Hiển thị các chuỗi ảnh của năm này + Tên tệp của mỗi ảnh, theo cách lượt nhập đặt tên · được kiểm tra khi bạn nhập Chỉ giữ các chuỗi ảnh của một máy ảnh Chọn giá trị này; chọn lại để bỏ chọn Chỉ giữ các chuỗi ảnh ở một trạng thái @@ -71,7 +72,10 @@ Dựng lại chỉ mục từ các tệp sidecar; nếu thiếu thì quét toàn bộ siêu dữ liệu; không bao giờ xóa bản gốc Đưa việc dựng lại vào hàng đợi · kho lưu trữ vẫn dùng được trong lúc đó Chọn thư mục mới của kho lưu trữ bạn đã di chuyển; các chuỗi ảnh của nó sẽ đi theo - Thực hiện đúng các thay đổi này với thư mục, sidecar và chỉ mục · tiếp tục được sau sự cố + Đưa vào hàng đợi một tác vụ thực hiện đúng các thay đổi này · tạm dừng và tiếp tục tác vụ trong mục Tác vụ + Đổi tên các ảnh theo mẫu này · khi tắt, ảnh vẫn giữ tên + Di chuyển thư mục của các chuỗi ảnh vào bố cục này · khi tắt, thư mục vẫn ở nguyên chỗ + Thay đổi tiêu đề theo mẫu này · khi tắt, tiêu đề được giữ nguyên Chọn một bản sao lưu của chỉ mục trong Cài đặt › Nâng cao; bản này sẽ thay thế chỉ mục ở lần khởi động tiếp theo Thay đổi nhãn của các chuỗi ảnh này trong sidecar và chỉ mục Chạy lại cùng thao tác đó @@ -80,9 +84,8 @@ Chạy phân tích sâu trên mọi chuỗi ảnh trong tập hợp Chuyển tập hợp vào thùng rác của kho lưu trữ · hiển thị lượt chạy thử, sau đó yêu cầu bạn nhập để xác nhận Xuất tập hợp dưới dạng CSV: mỗi chuỗi ảnh một hàng - Di chuyển tập hợp vào bố cục thư mục mới · chạy thử trước Tạo hoặc làm mới proxy - Đổi tiêu đề của tập hợp theo một mẫu · chạy thử trước + Áp dụng mẫu thư mục, tệp và tiêu đề cho tập hợp · chạy thử trước, sau đó là một tác vụ Thêm hoặc loại bỏ nhãn trên toàn bộ tập hợp Tạo hoặc làm mới hình thu nhỏ Băm lại các bản gốc của tập hợp @@ -471,12 +474,12 @@ Lấy từ máy chủ những gì {0:N0} chuỗi ảnh còn thiếu ở đây (bản gốc hoặc bản kết xuất) · chạy dưới dạng các tác vụ truyền Lưu {0:N0} hàng dưới dạng CSV vào thư mục bạn chọn Lưu {0:N0} hàng dưới dạng CSV vào thư mục bạn chọn - Di chuyển {0:N0} chuỗi ảnh vào bố cục thư mục mới của kho lưu trữ · hiển thị lượt chạy thử trước - Di chuyển {0:N0} chuỗi ảnh vào bố cục thư mục mới của kho lưu trữ tương ứng · hiển thị lượt chạy thử trước Tạo proxy JPEG cho {0:N0} chuỗi ảnh · chạy dưới dạng một tác vụ Tạo proxy JPEG cho {0:N0} chuỗi ảnh · chạy dưới dạng một tác vụ Đặt xếp hạng cho {0:N0} chuỗi ảnh, trong tệp sidecar và chỉ mục Đặt xếp hạng cho {0:N0} chuỗi ảnh, trong các tệp sidecar và chỉ mục + Áp dụng mẫu thư mục, tệp và tiêu đề cho {0:N0} chuỗi ảnh của kho lưu trữ chứa nó · chạy thử trước, sau đó là một tác vụ + Áp dụng mẫu thư mục, tệp và tiêu đề cho {0:N0} chuỗi ảnh của kho lưu trữ chứa chúng · chạy thử trước, sau đó là một tác vụ Thêm hoặc loại bỏ nhãn trên {0:N0} chuỗi ảnh Thêm hoặc loại bỏ nhãn trên {0:N0} chuỗi ảnh Gửi những gì máy chủ còn thiếu của {0:N0} chuỗi ảnh (bản gốc và cài đặt, hoặc bản kết xuất) · chạy dưới dạng tác vụ truyền @@ -692,6 +695,7 @@ Cân bằng phù hợp với hầu hết công việc; Tốt nhất đo ở độ phân giải gấp đôi và đọc trước xa hơn; Nhanh đo ở nửa độ phân giải với chuyển động nháp Liệt kê lại các bộ mã hóa sau khi cài trình điều khiển hoặc codec Tìm lại các tiện ích mở rộng codec sau khi cài đặt; các tác vụ tiếp theo sẽ sử dụng chúng + Áp dụng các mẫu của kho lưu trữ cho những chuỗi ảnh đã có trong đó · chạy thử trước Đưa mọi cài đặt của máy tính này về mặc định; sẽ hỏi trước Ghi ngay các mẫu và kích thước mặc định vào tệp archive.json của kho lưu trữ này Đặt lại mọi cài đặt ngay diff --git a/i18n/zh-Hans/Admin.zh-Hans.resx b/i18n/zh-Hans/Admin.zh-Hans.resx index be11a716..4ca16c73 100644 --- a/i18n/zh-Hans/Admin.zh-Hans.resx +++ b/i18n/zh-Hans/Admin.zh-Hans.resx @@ -9,6 +9,7 @@ Chronos 服务器 已运行 版本 + {0} 重新组织了档案库 · {1} {0} 更改了档案库布局 {0} 删除了 {1} {0} 启动了 {1} @@ -138,7 +139,7 @@ 导入 快速分析 维护 - 移动 + 重新组织 孤立文件 代理 重建 @@ -343,6 +344,7 @@ 登录以管理此服务器 用户 你在此服务器上的用户名 + 档案库已重新组织 档案库布局 照片已删除 任务已启动 @@ -426,6 +428,58 @@ 更改密码 替换密码并进入面板 设置新密码 + 重新组织… + 将文件夹、文件名和标题模板应用到所选序列;会先预览每项更改 + 更改后: + 应用… + 按预览所示重新组织;会先请求确认 + 更改前: + 请填写模板,或关闭此部分。 + 关闭,不做任何更改 + 连带移动 + 仅因其所在的文件夹移动而随之移动 + 已重命名的文件 + 文件夹 + 序列 + 重新组织 + 将移动并重命名原始文件的任务加入队列;不会覆盖或删除任何内容 + {0} 张照片将获得新名称。 + {0} 张照片将获得新名称。 + {0} 个文件夹将被移动。 + {0} 个文件夹将被移动。 + {0} 个序列将发生更改。 + {0} 个序列将发生更改。 + 立即重新组织? + 每张照片在导入时得到的名称,例如 {date}_{time}_{n:0000};照片旁的附带文件会随之更名 + 文件 + 重命名每个序列的照片;关闭时保留所有文件名 + 已重命名 {0} 个文件 + 已重命名 {0} 个文件 + 每个序列在档案库中的文件夹,例如 {year}/{date} {camera};{title} 为新标题 + 文件夹 + 将每个序列移到其模板给出的文件夹;关闭时所有文件夹保持原位 + 某个所选序列已不在档案库中;请关闭后重新选择。 + {0}:{1} + 请至少启用一个要更改的部分。 + 无需更改:这些序列已符合模板。 + 重新组织… + 将新模板应用到档案库中已有的序列;会先预览每项更改 + 打开任务 + 在“任务”页面显示该任务及其日志 + 确认期间档案库发生了更改;请检查新的预览后重新应用。 + 正在生成计划… + 预览 + 每个序列将变成什么样,按更改的应用顺序排列;目前尚未更改任何内容 + 重新组织任务已加入队列。 + 此文件夹保持原位 + 重新组织 {0} 个序列 + 重新组织 {0} 个序列 + 重新组织所有序列 + 每个序列的新标题,例如 {date} {camera};{title} 为当前标题 + 标题 + 按模板为每个序列生成标题;关闭时保留所有标题 + 一次最多重新组织 {0} 个序列,或者全部序列:请清除筛选并全选。 + 已更改的序列:{0} · 已重命名的文件:{1} · 保留的名称:{2} 管理员 编辑者 上传者 diff --git a/i18n/zh-Hans/Archive.zh-Hans.resx b/i18n/zh-Hans/Archive.zh-Hans.resx index 71f64d82..39a991b0 100644 --- a/i18n/zh-Hans/Archive.zh-Hans.resx +++ b/i18n/zh-Hans/Archive.zh-Hans.resx @@ -15,6 +15,7 @@ 请等待更改应用完成。 集合为空:请更改选择或筛选条件。 不会有任何更改。 + 请至少启用一个模板。 档案库必须在线且可写。 请等待试运行完成。 请等待档案库读取完成。 @@ -81,6 +82,12 @@ {0} 由更新版本的 Chronos 写入(格式 {1})。 档案库 {0} 处于离线状态。 档案库 {0} 为只读。 + {0:N0} 个序列保留了原文件名:某张照片正在使用中,或其新名称已被占用。 + {0:N0} 个序列保留了原文件名:某张照片正在使用中,或其新名称已被占用。 + {0:N0} 个序列未按计划重新组织:生成计划后它发生了更改。 + {0:N0} 个序列未按计划重新组织:生成计划后它们发生了更改。 + {0:N0} 个序列保留了标题和文件名:其序列文件由更新版本的 Chronos 写入。 + {0:N0} 个序列保留了标题和文件名:它们的序列文件由更新版本的 Chronos 写入。 {0} 在生成计划后发生了更改。 存储卡或文件夹 {0} 已不可用。 档案库在生成此计划后发生了更改。 @@ -146,6 +153,14 @@ 未编入索引的照片:{0},缺失的照片:{1} {0}:生成 {1},复用 {2},无法读取 {3},等待中 {4} 发往服务器的代理:已发送 {0},未发送 {1} + 保持原样,其所在文件夹未移动:{0} + 保持原样,生成计划后已更改:{0} + 保留文件名,某张照片正在使用中或其新名称已被占用:{0} + 保留文件名,生成计划后照片已更改:{0} + 保留标题和文件名,其序列文件由更新版本的 Chronos 写入:{0} + 保留标题和文件名,生成计划后已更改:{0} + 已更改的序列:{0},已重命名的文件:{1} + 重新组织已在打开档案库时完成 仅报告:未做任何更改。 文件夹:{0},已编入索引:{1},已纳入:{2},已移除:{3} 未找到序列:{0} @@ -200,14 +215,30 @@ 已移动档案库的文件夹 应用 {0} / {1} - 重命名 {0:N0} 个序列 - 重命名 {0:N0} 个序列 - 移动 {0:N0} 个序列 - 移动 {0:N0} 个序列 更改 {1:N0} 个中有 {0:N0} 个将更改 {1:N0} 个中有 {0:N0} 个将更改 - 模板 + 在 originals 文件夹之外原位保留的照片保留原名。 + 缺失的照片保留原名。 + 从未校验过的照片保留原名;请先校验该序列。 + 无法读取序列文件;该序列保持原样,其所在的任何文件夹也保持原样。 + 随所在文件夹移动 + {0}:从 {1} 改为 {2} + 文件 + 文件名 + 文件夹 + 文件夹 + 重新组织 {0:N0} 个序列 + 重新组织 {0:N0} 个序列 + 重新组织 {0} + 保留 {0:N0} 个名称 + 保留 {0:N0} 个名称 + 正在试运行… + 已重命名 {0:N0} 个文件 + 已重命名 {0:N0} 个文件 + 标题 + 标题 + 当前打开的对话框关闭后,“重新组织”才会打开 添加标签 应用 {0:N0} 个序列的标签 @@ -222,9 +253,8 @@ 导出 CSV 集合筛选 筛选后的集合 - 移动… 代理 - 重命名… + 重新组织… 重设标签… 缩略图 校验 diff --git a/i18n/zh-Hans/Errors.zh-Hans.resx b/i18n/zh-Hans/Errors.zh-Hans.resx index 2ca7fbbd..18b78b1a 100644 --- a/i18n/zh-Hans/Errors.zh-Hans.resx +++ b/i18n/zh-Hans/Errors.zh-Hans.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 未分析的序列:{1} 个中有 {0} 个;请查看任务日志。 + 此序列的文件夹不在索引记录的位置;请在下次扫描后重试。 无法打开档案库。 无法备份或替换当前索引;将在下次启动时再次运行恢复。 无法恢复此备份;请选择其他备份。 @@ -37,9 +38,11 @@ {0} 个原始文件缺失或自归档以来已更改;请校验档案库。 模板为空。 位置 {1} 处的标记为空:请在花括号之间写入名称。 + 照片会丢失扩展名:请在 {ext} 前加一个点,或去掉 {ext}。 文件名不能包含斜杠;请将文件夹写在文件夹模板中。 冒号后的格式不适用于该标记。 名称会重复:请加入帧序号、时间或原始文件名。 + 扫描会跳过以点开头或名为 originals、proxies 或 exports 的文件夹。 位置 {1} 处的左花括号没有闭合。 位置 {1} 处的标记“{0}”未知。 位置 {1} 处的右花括号没有对应的左花括号;如需输入花括号本身,请连写两个。 diff --git a/i18n/zh-Hans/Jobs.zh-Hans.resx b/i18n/zh-Hans/Jobs.zh-Hans.resx index 5e367310..18dc0390 100644 --- a/i18n/zh-Hans/Jobs.zh-Hans.resx +++ b/i18n/zh-Hans/Jobs.zh-Hans.resx @@ -76,7 +76,7 @@ 导入 快速分析 维护 - 移动档案库 + 重新组织 孤立文件 代理 重建索引 diff --git a/i18n/zh-Hans/Library.zh-Hans.resx b/i18n/zh-Hans/Library.zh-Hans.resx index 484ec105..cf106900 100644 --- a/i18n/zh-Hans/Library.zh-Hans.resx +++ b/i18n/zh-Hans/Library.zh-Hans.resx @@ -10,17 +10,16 @@ 下载 导出列表 文件夹 - 移动… 打开 代理 评分 渲染 + 重新组织… 同步 标签… 上传 校验 纳入文件夹 - “移动”一次只能处理一个档案库中的序列。 此电脑与服务器上的内容相同:无需同步。 当前未使用已保存的视图;请先选择一个。 你的服务器账户无权下载原始文件。 @@ -32,6 +31,7 @@ 请先在“服务器”屏幕上登录 Chronos 服务器。 所选序列没有需要从服务器获取的内容。 服务器上已有所选序列的全部内容。 + 重新组织每次只能处理同一个档案库中的序列。 仅适用于此电脑上的序列;所选内容位于服务器上。 此序列的传输已在进行中。 清除筛选 diff --git a/i18n/zh-Hans/Server.zh-Hans.resx b/i18n/zh-Hans/Server.zh-Hans.resx index 9a1483cf..019e7cc9 100644 --- a/i18n/zh-Hans/Server.zh-Hans.resx +++ b/i18n/zh-Hans/Server.zh-Hans.resx @@ -40,6 +40,7 @@ 连接失败;详细信息请查看日志。 该序列的某个文件已在另一个程序中打开;请关闭它后重试。 其文件夹已不在磁盘上;没有可移到回收站的内容。 + 此序列的文件夹不在服务器索引记录的位置;请在服务器下次扫描后重试。 你的账户无权执行此操作。 该序列的照片已在服务器上更改;请重新加载后再次应用你的编辑。 文件传输后已损坏;请重新上传。 @@ -68,11 +69,14 @@ 此服务器无法运行该类任务。 无法移除或禁用最后一个管理员。 此处不允许使用此方法。 + 新文件夹将位于另一个序列的文件夹之内。 该地址不是 Chronos 服务器。 未找到。 请先更改密码。 此照片在上传过程中已从序列中删除,因此未被添加。 无法读取 {0};没有它的哈希,其他副本将无法得知它已被删除。请关闭正在使用它的程序或检查其权限,然后重试。 + 试运行后档案库发生了更改;请重新检查计划。 + 服务器已停止生成此计划:耗时过长,或同时请求的计划过多;请稍后重试。 此档案库不生成代理。 该代理是由另一张照片生成的。 服务器不需要此照片的代理。 diff --git a/i18n/zh-Hans/Settings.zh-Hans.resx b/i18n/zh-Hans/Settings.zh-Hans.resx index 81c48327..f2d917ef 100644 --- a/i18n/zh-Hans/Settings.zh-Hans.resx +++ b/i18n/zh-Hans/Settings.zh-Hans.resx @@ -65,6 +65,7 @@ 颗星/百万像素 分析宽度 像素(长边) + 档案库中已有的文件夹和文件保留原名。 文件名 文件夹 可用 {0} @@ -74,10 +75,12 @@ 选择档案库文件夹 预览 代理尺寸 + 重新组织… 重置档案库设置 对于使用此档案库的每台电脑和服务器,其命名模板、代理尺寸和缩略图尺寸都将恢复为默认值。档案库中已有的文件夹和文件保留原名。 重置 {0} 的设置? 档案库文件夹 + 档案库模板已保存 缩略图尺寸 恢复自动 选择文件夹 diff --git a/i18n/zh-Hans/Tooltips.zh-Hans.resx b/i18n/zh-Hans/Tooltips.zh-Hans.resx index 5669eb85..23ca9ea0 100644 --- a/i18n/zh-Hans/Tooltips.zh-Hans.resx +++ b/i18n/zh-Hans/Tooltips.zh-Hans.resx @@ -36,6 +36,7 @@ 在“编辑”屏幕中打开第一个副本所属的序列 按哈希在各序列间查找相同的照片 · 仅读取索引 显示这一年的序列 + 每张照片的文件名,与导入时的命名方式相同 · 输入时检查 只保留某一台相机的序列 选择此值;再次选择即可清除 只保留处于某一状态的序列 @@ -71,7 +72,10 @@ 根据附属文件重建索引;必要时改为完整扫描元数据;绝不删除原始文件 将重建加入队列 · 期间档案库仍可使用 选择已移动档案库的新文件夹;其中的序列会随之更新 - 完全按列出的更改修改文件夹、附属文件和索引 · 崩溃后可继续 + 将完全执行这些更改的任务加入队列 · 可在“任务”中暂停和继续 + 按此模板重命名照片 · 关闭时保留原名 + 将序列文件夹移入此结构 · 关闭时保持原位 + 按此模板更改标题 · 关闭时保持不变 在“设置 › 高级”中选择索引的备份;它会在下次启动时替换索引 在附属文件和索引中更改这些序列的标签 再次运行相同的操作 @@ -80,9 +84,8 @@ 对集合中的每个序列运行深度分析 将集合移到档案库的回收站 · 先显示试运行结果,再要求你输入内容以确认 将集合导出为 CSV:每个序列一行 - 将集合移动到新的文件夹结构 · 先试运行 生成或刷新代理 - 用模板重命名集合中的标题 · 先试运行 + 将文件夹、文件名和标题模板应用到集合 · 先试运行,再创建任务 为整个集合添加或移除标签 生成或刷新缩略图 重新计算集合中原始文件的哈希 @@ -471,12 +474,12 @@ 从服务器获取 {0:N0} 个序列在此处缺少的内容(原始文件或渲染结果)· 作为传输任务运行 将 {0:N0} 行以 CSV 格式保存到你选择的文件夹 将 {0:N0} 行以 CSV 格式保存到你选择的文件夹 - 将 {0:N0} 个序列移到所属档案库中新的文件夹结构 · 先显示试运行结果 - 将 {0:N0} 个序列移到所属档案库中新的文件夹结构 · 先显示试运行结果 为 {0:N0} 个序列生成 JPEG 代理 · 作为一个任务运行 为 {0:N0} 个序列生成 JPEG 代理 · 作为一个任务运行 在附属文件和索引中设置 {0:N0} 个序列的评分 在附属文件和索引中设置 {0:N0} 个序列的评分 + 将文件夹、文件名和标题模板应用到所属档案库中的 {0:N0} 个序列 · 先试运行,再创建任务 + 将文件夹、文件名和标题模板应用到所属档案库中的 {0:N0} 个序列 · 先试运行,再创建任务 为 {0:N0} 个序列添加或移除标签 为 {0:N0} 个序列添加或移除标签 向服务器发送 {0:N0} 个序列中服务器缺少的内容(原始文件和设置,或渲染结果)· 作为传输任务运行 @@ -692,6 +695,7 @@ “均衡”适合大多数工作;“最佳”以双倍分辨率测量并预读更多帧;“快速”以一半分辨率测量,并使用草稿级运动估计 安装驱动程序或编解码器后重新列出编码器 安装编解码器扩展后重新查找;之后的任务将使用它们 + 将档案库的模板应用到其中已有的序列 · 先试运行 将此电脑的所有设置恢复为默认值;会先询问 立即将默认模板和尺寸写入此档案库的 archive.json 立即重置所有设置 diff --git a/i18n/zh-Hant/Admin.zh-Hant.resx b/i18n/zh-Hant/Admin.zh-Hant.resx index a2a74beb..39c177f2 100644 --- a/i18n/zh-Hant/Admin.zh-Hant.resx +++ b/i18n/zh-Hant/Admin.zh-Hant.resx @@ -9,6 +9,7 @@ Chronos Server 已執行時間 版本 + {0} 重新組織了典藏庫 · {1} {0} 變更了典藏庫結構 {0} 刪除了 {1} {0} 啟動了 {1} @@ -138,7 +139,7 @@ 匯入 快速分析 維護 - 移動 + 重新組織 孤立檔案 代理檔 重建 @@ -343,6 +344,7 @@ 登入以管理此伺服器 使用者 您在此伺服器上的使用者名稱 + 典藏庫已重新組織 典藏庫結構 相片已刪除 工作已啟動 @@ -426,6 +428,58 @@ 變更密碼 更換密碼並繼續前往面板 設定新密碼 + 重新組織… + 將資料夾、檔名與標題範本套用到選取的序列;會先預覽每項變更 + 變更後: + 套用… + 依預覽所示重新組織;會先要求確認 + 變更前: + 請輸入範本,或關閉此部分。 + 關閉而不做任何變更 + 連帶移動 + 僅因其所在的資料夾移動而隨之移動 + 已重新命名的檔案 + 資料夾 + 序列 + 重新組織 + 將移動並重新命名原始檔的工作排入佇列;不會覆寫或刪除任何內容 + {0} 張相片將取得新名稱。 + {0} 張相片將取得新名稱。 + {0} 個資料夾將會移動。 + {0} 個資料夾將會移動。 + {0} 個序列將會變更。 + {0} 個序列將會變更。 + 要立即重新組織嗎? + 每張相片在匯入時取得的名稱,例如 {date}_{time}_{n:0000};相片旁的附帶檔案會隨之更名 + 檔案 + 重新命名每個序列的相片;關閉時保留所有檔名 + 已重新命名 {0} 個檔案 + 已重新命名 {0} 個檔案 + 每個序列在典藏庫中的資料夾,例如 {year}/{date} {camera};{title} 為新標題 + 資料夾 + 將每個序列移至其範本產生的資料夾;關閉時所有資料夾維持原位 + 某個選取的序列已不在典藏庫中;請關閉後重新選取。 + {0}:{1} + 請至少啟用一個要變更的部分。 + 沒有需要變更的項目:這些序列已符合範本。 + 重新組織… + 將新範本套用到典藏庫中現有的序列;會先預覽每項變更 + 開啟工作 + 在「工作」頁面顯示此工作及其記錄 + 確認期間典藏庫已變更;請檢查新的預覽後再套用一次。 + 正在建立計畫… + 預覽 + 每個序列將變成的樣子,依變更套用的順序排列;目前尚未變更任何內容 + 重新組織工作已排入佇列。 + 此資料夾維持原位 + 重新組織 {0} 個序列 + 重新組織 {0} 個序列 + 重新組織所有序列 + 每個序列的新標題,例如 {date} {camera};{title} 為目前的標題 + 標題 + 依範本為每個序列產生標題;關閉時保留所有標題 + 一次最多可重新組織 {0} 個序列,或全部序列:請清除篩選並全選。 + 已變更的序列:{0} · 已重新命名的檔案:{1} · 保留的名稱:{2} 管理員 編輯者 上傳者 diff --git a/i18n/zh-Hant/Archive.zh-Hant.resx b/i18n/zh-Hant/Archive.zh-Hant.resx index 42f70937..984d6277 100644 --- a/i18n/zh-Hant/Archive.zh-Hant.resx +++ b/i18n/zh-Hant/Archive.zh-Hant.resx @@ -15,6 +15,7 @@ 請等候變更套用完成。 此集合是空的:請變更選取範圍或篩選條件。 不會有任何變更。 + 請至少啟用一個範本。 典藏庫必須在線上且可寫入。 請等候試執行完成。 請等候典藏庫讀取完成。 @@ -81,6 +82,12 @@ {0} 是由較新版本的 Chronos 寫入(格式 {1})。 典藏庫 {0} 已離線。 典藏庫 {0} 為唯讀。 + {0:N0} 個序列保留了原檔名:某張相片正在使用中,或其新名稱已被使用。 + {0:N0} 個序列保留了原檔名:某張相片正在使用中,或其新名稱已被使用。 + {0:N0} 個序列未依計畫重新組織:計畫建立後它已變更。 + {0:N0} 個序列未依計畫重新組織:計畫建立後它們已變更。 + {0:N0} 個序列保留了標題與檔名:其序列檔是由較新版本的 Chronos 寫入。 + {0:N0} 個序列保留了標題與檔名:它們的序列檔是由較新版本的 Chronos 寫入。 {0} 在計畫建立後已變更。 記憶卡或資料夾 {0} 已無法使用。 典藏庫在此計畫建立後已變更。 @@ -146,6 +153,14 @@ 未建立索引的相片:{0},遺失的相片:{1} {0}:已產生 {1},重複使用 {2},無法讀取 {3},等待中 {4} 供伺服器使用的代理檔:已傳送 {0},未傳送 {1} + 維持原狀,其所在的資料夾未移動:{0} + 維持原狀,計畫建立後已變更:{0} + 保留檔名,某張相片正在使用中或其新名稱已被使用:{0} + 保留檔名,計畫建立後相片已變更:{0} + 保留標題與檔名,其序列檔是由較新版本的 Chronos 寫入:{0} + 保留標題與檔名,計畫建立後已變更:{0} + 已變更的序列:{0},已重新命名的檔案:{1} + 重新組織已在開啟典藏庫時完成 僅報告:未做任何變更。 資料夾:{0},已建立索引:{1},已納入:{2},已移除:{3} 找不到序列:{0} @@ -200,14 +215,30 @@ 已移動典藏庫的資料夾 套用 {0} / {1} - 重新命名 {0:N0} 個序列 - 重新命名 {0:N0} 個序列 - 移動 {0:N0} 個序列 - 移動 {0:N0} 個序列 變更 {1:N0} 個中有 {0:N0} 個會變更 {1:N0} 個中有 {0:N0} 個會變更 - 範本 + 在 originals 資料夾外原地保留的相片會保留原名。 + 遺失的相片會保留原名。 + 從未驗證的相片會保留原名;請先驗證此序列。 + 無法讀取序列檔;此序列維持原狀,其所在的任何資料夾也是如此。 + 隨所在資料夾移動 + {0}:從 {1} 改為 {2} + 檔案 + 檔名 + 資料夾 + 資料夾 + 重新組織 {0:N0} 個序列 + 重新組織 {0:N0} 個序列 + 重新組織 {0} + 保留 {0:N0} 個名稱 + 保留 {0:N0} 個名稱 + 正在試執行… + 已重新命名 {0:N0} 個檔案 + 已重新命名 {0:N0} 個檔案 + 標題 + 標題 + 目前開啟的對話方塊關閉後,「重新組織」才會開啟 新增標籤 套用 {0:N0} 個序列的標籤 @@ -222,9 +253,8 @@ 匯出 CSV 集合篩選 篩選後的集合 - 移動… 代理檔 - 重新命名… + 重新組織… 變更標籤… 縮圖 驗證 diff --git a/i18n/zh-Hant/Errors.zh-Hant.resx b/i18n/zh-Hant/Errors.zh-Hant.resx index f0dd0f08..797c7617 100644 --- a/i18n/zh-Hant/Errors.zh-Hant.resx +++ b/i18n/zh-Hant/Errors.zh-Hant.resx @@ -5,6 +5,7 @@ System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 未分析的序列:{0} / {1};請參閱工作記錄。 + 此序列的資料夾不在索引記錄的位置;請在下次掃描後再試一次。 無法開啟典藏庫。 無法備份或取代目前的索引;下次啟動時會再次執行還原。 無法還原此備份;請選擇其他備份。 @@ -37,9 +38,11 @@ 有 {0} 個原始檔在典藏後遺失或已變更;請驗證典藏庫。 範本是空的。 位置 {1} 有空白標記:請在大括號之間輸入名稱。 + 相片會失去副檔名:請在 {ext} 前加上句點,或移除 {ext}。 檔名不能包含斜線;請將資料夾放在資料夾範本中。 冒號後的格式不適用於此標記。 名稱會重複:請加入影格編號、時間或原始名稱。 + 掃描會略過以句點開頭,或名為 originals、proxies 或 exports 的資料夾。 位置 {1} 開啟的大括號從未關閉。 位置 {1} 有未知的標記「{0}」。 位置 {1} 的右大括號沒有對應的左大括號;若要輸入大括號字元本身,請連續輸入兩個。 diff --git a/i18n/zh-Hant/Jobs.zh-Hant.resx b/i18n/zh-Hant/Jobs.zh-Hant.resx index 236e3694..3addb597 100644 --- a/i18n/zh-Hant/Jobs.zh-Hant.resx +++ b/i18n/zh-Hant/Jobs.zh-Hant.resx @@ -76,7 +76,7 @@ 匯入 快速分析 維護 - 移動典藏庫 + 重新組織 孤立檔案 代理檔 重建索引 diff --git a/i18n/zh-Hant/Library.zh-Hant.resx b/i18n/zh-Hant/Library.zh-Hant.resx index f7fbd3e3..0e091892 100644 --- a/i18n/zh-Hant/Library.zh-Hant.resx +++ b/i18n/zh-Hant/Library.zh-Hant.resx @@ -10,17 +10,16 @@ 下載 匯出清單 資料夾 - 移動… 開啟 建立代理檔 分級 算圖 + 重新組織… 同步 標籤… 上傳 驗證 納入資料夾 - 「移動」一次只能處理同一個典藏庫的序列。 此電腦與伺服器上的內容相同:沒有需要同步的項目。 目前未使用已儲存的檢視;請先選擇一個。 您的伺服器帳戶無法下載原始檔。 @@ -32,6 +31,7 @@ 請先在「伺服器」畫面登入 Chronos Server。 選取的序列沒有需要從伺服器取得的內容。 伺服器已有選取序列的所有內容。 + 重新組織一次只能處理同一個典藏庫中的序列。 僅適用於此電腦上的序列;所選項目位於伺服器上。 此序列已有傳輸正在進行。 清除篩選 diff --git a/i18n/zh-Hant/Server.zh-Hant.resx b/i18n/zh-Hant/Server.zh-Hant.resx index 559cca35..9eaa48d6 100644 --- a/i18n/zh-Hant/Server.zh-Hant.resx +++ b/i18n/zh-Hant/Server.zh-Hant.resx @@ -40,6 +40,7 @@ 連線失敗;詳細資料請參閱記錄。 此序列的某個檔案已在其他程式中開啟;請將其關閉後再試一次。 其資料夾已不在磁碟上;沒有可移至垃圾桶的內容。 + 此序列的資料夾不在伺服器索引記錄的位置;請在伺服器下次掃描後再試一次。 您的帳戶無法執行此操作。 序列的相片已在伺服器上變更;請重新載入後再次套用您的編輯。 檔案傳送時已損毀;請重新上傳。 @@ -68,11 +69,14 @@ 此伺服器無法執行該類型的工作。 無法移除或停用最後一位管理員。 此處不允許使用這個方法。 + 新資料夾會位於另一個序列的資料夾之內。 該位址不是 Chronos Server。 找不到。 請先變更密碼。 上傳期間此相片已從序列中刪除,因此未加入。 無法讀取 {0};少了它的雜湊值,其他副本就無法得知它已被刪除。請關閉正在使用它的程式或檢查其權限,然後再試一次。 + 試執行後典藏庫已變更;請重新檢查計畫。 + 伺服器已停止建立此計畫:耗時過長,或同時要求的計畫過多;請稍後再試。 此典藏庫不產生代理檔。 此代理檔是由其他相片產生的。 伺服器不需要此相片的代理檔。 diff --git a/i18n/zh-Hant/Settings.zh-Hant.resx b/i18n/zh-Hant/Settings.zh-Hant.resx index 44b5b182..dfe8ec16 100644 --- a/i18n/zh-Hant/Settings.zh-Hant.resx +++ b/i18n/zh-Hant/Settings.zh-Hant.resx @@ -65,6 +65,7 @@ 個星點/百萬像素 分析寬度 px(長邊) + 典藏庫中現有的資料夾與檔案會保留其名稱。 檔名 資料夾 {0} 可用 @@ -74,10 +75,12 @@ 選擇典藏庫資料夾 預覽 代理檔大小 + 重新組織… 重設典藏庫 其命名範本、代理檔大小與縮圖大小,會為所有使用此典藏庫的電腦與伺服器恢復為預設值。典藏庫中現有的資料夾與檔案會保留其名稱。 要重設 {0} 的設定嗎? 典藏庫資料夾 + 典藏庫範本已儲存 縮圖大小 恢復自動 選擇資料夾 diff --git a/i18n/zh-Hant/Tooltips.zh-Hant.resx b/i18n/zh-Hant/Tooltips.zh-Hant.resx index 191c4e0c..23fdf274 100644 --- a/i18n/zh-Hant/Tooltips.zh-Hant.resx +++ b/i18n/zh-Hant/Tooltips.zh-Hant.resx @@ -36,6 +36,7 @@ 在「編輯」畫面中開啟第一個副本所屬的序列 依雜湊值尋找各序列間相同的相片 · 只讀取索引 顯示此年份的序列 + 每張相片的檔名,與匯入時的命名方式相同 · 輸入時即檢查 只保留某一台相機的序列 選擇此值;再次選擇即可清除 只保留處於某一狀態的序列 @@ -71,7 +72,10 @@ 根據附屬檔重建索引;必要時改為完整掃描中繼資料;絕不刪除原始檔 將重建排入佇列 · 期間仍可使用典藏庫 選擇您移動後的典藏庫所在的新資料夾;其中的序列會隨之更新 - 完全依照上列內容變更資料夾、附屬檔與索引 · 當機後可繼續 + 將完全執行這些變更的工作排入佇列 · 可在「工作」中暫停與繼續 + 依此範本重新命名相片 · 關閉時保留原名 + 將序列資料夾移入此結構 · 關閉時維持原位 + 依此範本變更標題 · 關閉時維持不變 在「設定 › 進階」中選擇索引的備份;它會在下次啟動時取代索引 在附屬檔與索引中變更這些序列的標籤 再次執行相同的動作 @@ -80,9 +84,8 @@ 對集合中的每個序列執行深度分析 將集合移至典藏庫的垃圾桶 · 會先顯示試執行結果,再要求您輸入確認 將集合匯出為 CSV:每個序列一列 - 將集合移至新的資料夾結構 · 會先試執行 產生或更新代理檔 - 以範本重新命名集合中的標題 · 會先試執行 + 將資料夾、檔名與標題範本套用到集合 · 先試執行,再建立工作 為整個集合新增或移除標籤 產生或更新縮圖 重新計算集合中原始檔的雜湊值 @@ -471,12 +474,12 @@ 從伺服器取得 {0:N0} 個序列在此處缺少的內容(原始檔或算圖成果) · 以傳輸工作執行 將 {0:N0} 列以 CSV 格式儲存至您選擇的資料夾 將 {0:N0} 列以 CSV 格式儲存至您選擇的資料夾 - 將 {0:N0} 個序列移至其典藏庫的新資料夾結構 · 會先試執行 - 將 {0:N0} 個序列移至其典藏庫的新資料夾結構 · 會先試執行 為 {0:N0} 個序列建立 JPEG 代理檔 · 以單一工作執行 為 {0:N0} 個序列建立 JPEG 代理檔 · 以單一工作執行 在附屬檔與索引中設定 {0:N0} 個序列的分級 在附屬檔與索引中設定 {0:N0} 個序列的分級 + 將資料夾、檔名與標題範本套用到其典藏庫中的 {0:N0} 個序列 · 先試執行,再建立工作 + 將資料夾、檔名與標題範本套用到其典藏庫中的 {0:N0} 個序列 · 先試執行,再建立工作 為 {0:N0} 個序列新增或移除標籤 為 {0:N0} 個序列新增或移除標籤 傳送 {0:N0} 個序列中伺服器缺少的內容(原始檔與設定,或算圖成果) · 以傳輸工作執行 @@ -692,6 +695,7 @@ 「平衡」適合大多數工作;「最佳」以兩倍解析度測量並預先讀取更多影格;「快速」以一半解析度測量並使用草稿品質的動態 安裝驅動程式或編解碼器後,重新列出編碼器 安裝延伸模組後,重新尋找編解碼器延伸模組;之後的工作會使用它們 + 將典藏庫的範本套用到其中現有的序列 · 先試執行 將此電腦的所有設定恢復為預設值;會先詢問 立即將預設的範本與大小寫入此典藏庫的 archive.json 立即重設所有設定 diff --git a/src/Chronos.App/Archive/ArchiveDialogViewModels.cs b/src/Chronos.App/Archive/ArchiveDialogViewModels.cs index ac36558d..f7f8f186 100644 --- a/src/Chronos.App/Archive/ArchiveDialogViewModels.cs +++ b/src/Chronos.App/Archive/ArchiveDialogViewModels.cs @@ -1,6 +1,5 @@ using System.IO; using System.Windows.Input; -using System.Windows.Threading; using Chronos.App.Infrastructure; using Chronos.App.Settings; using Chronos.Core.Archiving; @@ -196,160 +195,6 @@ public sealed class RebuildDialogViewModel : ArchiveDialogViewModel } } -/// -/// Mass rename (titles) or move (folder layout) of a set (BRIEF §7, §12.5): the template is checked as it is typed, -/// the dry run lists every change, and Apply makes exactly those changes (journaled, so a crash resumes it). -/// -public sealed class RenameDialogViewModel : ArchiveDialogViewModel -{ - private readonly ArchiveService _archives; - private readonly Core.Model.Archive _archive; - private readonly IReadOnlyList _set; - private readonly Func _applied; - private readonly DispatcherTimer _delay = new() { Interval = TimeSpan.FromMilliseconds(400) }; - private RenamePlan? _plan; - private string? _planError; - private IReadOnlyList _rows = []; - private CancellationTokenSource? _planning; - - public RenameDialogViewModel(RenameMode mode, ArchiveService archives, Core.Model.Archive archive, IReadOnlyList set, Func applied, - Action close) - : base(close) - { - Mode = mode; - _archives = archives; - _archive = archive; - _set = set; - _applied = applied; - var initial = mode == RenameMode.Folders ? archive.FolderTemplate : "{title}"; - Template = new EditableField(initial, t => MassRename.Validate(mode, t), committed => _ = PlanAsync(), - () => Loc.L(mode == RenameMode.Folders ? "Tooltips.Archive.FolderTemplate" : "Tooltips.Archive.TitleTemplate")); - Template.PropertyChanged += (_, e) => - { - if (e.PropertyName != nameof(EditableField.Text)) return; - _delay.Stop(); - _delay.Start(); - }; - _delay.Tick += (_, _) => - { - _delay.Stop(); - _ = PlanAsync(); - }; - ApplyCommand = new AsyncRelayCommand(ApplyAsync, () => ApplyBlocker is null); - } - - /// Why Apply is disabled; null when it can run. - private string? ApplyBlocker => - IsBusy ? Loc.L("Archive.Blocked.Applying") - : Template.Error is { } error ? error - : _plan is null ? _planError ?? Loc.L("Archive.Blocked.Planning") - : _plan.Steps.Count == 0 ? Loc.L("Archive.Blocked.NoChanges") - : null; - - public string ApplyToolTip => ApplyBlocker ?? Loc.L("Tooltips.Archive.RenameApply"); - - public RenameMode Mode { get; } - - public string Heading => Loc.Plural(Mode == RenameMode.Folders ? "Archive.Rename.MoveHeading" : "Archive.Rename.Heading", _set.Count); - - public EditableField Template { get; } - - public IReadOnlyList Rows { get => _rows; private set => Set(ref _rows, value); } - - public string SummaryText => _plan is null ? string.Empty : MassRename.Summary(_plan, _set.Count); - - public ICommand ApplyCommand { get; } - - public override void Dispose() - { - _delay.Stop(); - _planning?.Cancel(); - base.Dispose(); - } - - /// - /// The dry run of the current template (the engine's plan; nothing changes on disk); it clears the last failure and - /// stands in for a dry run still waiting on typing, which would otherwise throw this plan away. - /// - public Task PlanAsync() - { - _delay.Stop(); - ClearError(); - return DryRunAsync(); - } - - private async Task DryRunAsync() - { - _planning?.Cancel(); - _plan = null; - _planError = null; - Rows = []; - OnPlanChanged(); - if (Template.HasErrors) return; - var cts = _planning = new CancellationTokenSource(); - var template = Template.Text; - var ids = _set.Select(s => s.Id).ToList(); - try - { - var plan = await Task.Run(() => _archives.PlanRenameAsync(_archive.Id, ids, Mode == RenameMode.Folders ? template : null, - Mode == RenameMode.Titles ? template : null, cts.Token), cts.Token); - if (cts.IsCancellationRequested) return; - _plan = plan; - Rows = MassRename.Rows(plan, Mode); - } - catch (OperationCanceledException) when (cts.IsCancellationRequested) - { - return; - } - catch (Exception ex) when (ex is ArgumentException or DatabaseException or FormatException) - { - Log.Warning("archive", "Rename plan failed", ex); - _planError = ArchiveFailures.Cause(ex); - ShowError(ex); - } - OnPlanChanged(); - } - - private void OnPlanChanged() - { - OnPropertyChanged(nameof(SummaryText)); - OnPropertyChanged(nameof(ApplyToolTip)); - CommandManager.InvalidateRequerySuggested(); - } - - private async Task ApplyAsync() - { - if (_plan is not { } plan) return; - ClearError(); - IsBusy = true; - // A tick posted before the apply ended must not bring its progress back. - var progress = new Progress(n => - { - if (IsBusy) BusyText = Loc.L("Archive.Rename.Applying", Formatting.Count(n), Formatting.Count(plan.Steps.Count)); - }); - try - { - await Task.Run(() => _archives.ApplyRenameAsync(plan, progress)); - Log.Info("archive", $"{Mode} applied to {plan.Steps.Count} sequence(s)"); - await _applied(plan.Steps.Count); - Close(); - return; - } - catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or StaleRenamePlanException or DatabaseException) - { - Log.Warning("archive", "Rename failed", ex); - ShowError(ex); - } - finally - { - IsBusy = false; - BusyText = null; - } - // Part of the plan may have been applied, or the archive changed under it: the dry run shows what is left. - await DryRunAsync(); - } -} - /// Add and remove tags on a set (BRIEF §12.5 Retag): the dry run counts the sequences that change. public sealed class RetagDialogViewModel : ArchiveDialogViewModel { diff --git a/src/Chronos.App/Archive/ArchiveDialogs.xaml b/src/Chronos.App/Archive/ArchiveDialogs.xaml index 5bb231f7..3411efe6 100644 --- a/src/Chronos.App/Archive/ArchiveDialogs.xaml +++ b/src/Chronos.App/Archive/ArchiveDialogs.xaml @@ -6,12 +6,12 @@ xmlns:infra="clr-namespace:Chronos.App.Infrastructure" xmlns:shell="clr-namespace:Chronos.App.Shell"> - - @@ -88,8 +88,9 @@ - - + + + @@ -98,40 +99,86 @@ - + + - - - + + + + + + + + + + + - - + + - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + - - - - - - + + + diff --git a/src/Chronos.App/Archive/ArchiveScenes.cs b/src/Chronos.App/Archive/ArchiveScenes.cs index d551c319..d16d4eb9 100644 --- a/src/Chronos.App/Archive/ArchiveScenes.cs +++ b/src/Chronos.App/Archive/ArchiveScenes.cs @@ -5,11 +5,11 @@ namespace Chronos.App.Archiving; /// /// The Archive views that --capture renders (archive-<view>-<theme>.png) and the screen smoke /// tests check, on the sample archive: the tree with figures and charts, the maintenance view with its reports, the -/// rebuild dialog, the Move dialog with its dry run, and the trash (Maintenance › Trash…) with deleted sequences. +/// rebuild dialog, the Reorganize dialog with its dry run, and the trash (Maintenance › Trash…) with deleted sequences. /// public static class ArchiveScenes { - public static readonly IReadOnlyList Views = ["overview", "maintenance", "rebuild", "move", "trash"]; + public static readonly IReadOnlyList Views = ["overview", "maintenance", "rebuild", "reorganize", "trash"]; public static async Task ShowAsync(ShellViewModel shell, string view) { @@ -32,13 +32,13 @@ public static class ArchiveScenes archive.ViewIndex = 0; (await archive.OpenRebuildDialogAsync())?.ShowFolders(SampleReports.Folders(locations)); break; - case "move": + case "reorganize": archive.ViewIndex = 0; - await archive.OpenRenameDialogAsync(RenameMode.Folders); - if (archive.Dialog is RenameDialogViewModel move) + await archive.OpenReorganizeDialogAsync(); + if (archive.Dialog is ReorganizeDialogViewModel reorganize) { - move.Template.Text = "{year}/{date} {title}"; - await move.PlanAsync(); + reorganize.Folders.Field.Text = "{year}/{date} {title}"; + await reorganize.PlanAsync(); } break; case "trash": diff --git a/src/Chronos.App/Archive/MassOperations.cs b/src/Chronos.App/Archive/MassOperations.cs index d0ee149c..2bbc65c1 100644 --- a/src/Chronos.App/Archive/MassOperations.cs +++ b/src/Chronos.App/Archive/MassOperations.cs @@ -1,6 +1,4 @@ using Chronos.App.Library; -using Chronos.App.Settings; -using Chronos.Core.Archiving; using Chronos.Core.Localization; using Chronos.Core.Model; using Chronos.Core.Naming; @@ -8,43 +6,6 @@ using Chronos.Data.Repositories; namespace Chronos.App.Archiving; -/// What a mass rename changes: the sequence titles (Rename) or the folder layout (Move). -public enum RenameMode -{ - Titles, - Folders, -} - -/// One line of the rename dry run: before → after. -public sealed record RenameRow(Guid SequenceId, string From, string To); - -/// -/// Mass rename and move of sequences (BRIEF §7, §12.5): the template is checked live, the engine's dry run -/// () is listed line by line, and applying makes exactly those changes. -/// -public static class MassRename -{ - /// The first problem of a template, localized; null when it can be used. - public static string? Validate(RenameMode mode, string? template) - { - if (string.IsNullOrWhiteSpace(template)) return Loc.L("Errors.Template.Empty", string.Empty, 1); - if (mode == RenameMode.Folders) return NamingPreview.Validate(template, isFolder: true); - var parsed = PathTemplate.Parse(template); - return parsed.Errors is [var error, ..] ? Loc.L("Errors.Template." + error.Code, error.Token ?? string.Empty, error.Position + 1) : null; - } - - /// The changes of a plan as rows: titles or folders, whichever the mode changes. - public static IReadOnlyList Rows(RenamePlan plan, RenameMode mode) => - [ - .. plan.Steps.Select(s => mode == RenameMode.Folders - ? new RenameRow(s.SequenceId, s.FromFolder, s.ToFolder) - : new RenameRow(s.SequenceId, s.FromTitle ?? string.Empty, s.ToTitle ?? string.Empty)), - ]; - - /// "12 of 36 sequences change"; sequences that only move with a folder they are in are listed, not counted. - public static string Summary(RenamePlan plan, int setSize) => Loc.Plural("Archive.Rename.Summary", plan.Steps.Count(s => !s.Carried), setSize); -} - /// Adding and removing tags on a set of sequences (BRIEF §12.5 Retag). public static class Retag { diff --git a/src/Chronos.App/Archive/ReorganizeDialogViewModel.cs b/src/Chronos.App/Archive/ReorganizeDialogViewModel.cs new file mode 100644 index 00000000..6c90fa95 --- /dev/null +++ b/src/Chronos.App/Archive/ReorganizeDialogViewModel.cs @@ -0,0 +1,291 @@ +using System.IO; +using System.Windows.Input; +using System.Windows.Threading; +using Chronos.App.Settings; +using Chronos.Core.Archiving; +using Chronos.Core.Diagnostics; +using Chronos.Core.Localization; +using Chronos.Data; +using Chronos.Data.Archiving; +using Chronos.Data.Archiving.Jobs; +using Chronos.Ui.Mvvm; + +namespace Chronos.App.Archiving; + +/// +/// One template of a Reorganize: its switch and its text, checked as it is typed while the switch is on (an unused +/// template never blocks the others). +/// +public sealed class ReorganizeTemplate : ObservableObject +{ + private readonly Action _toggled; + private bool _isEnabled; + + internal ReorganizeTemplate(ReorganizeParts part, string text, bool isEnabled, string toolTipKey, Action typed, Action toggled, Action committed) + { + Part = part; + _isEnabled = isEnabled; + _toggled = toggled; + Field = new EditableField(text, t => _isEnabled ? ReorganizePlans.Validate(part, t) : null, _ => committed(), () => Loc.L(toolTipKey)); + Field.PropertyChanged += (_, e) => + { + if (e.PropertyName == nameof(EditableField.Text)) typed(); + }; + } + + public ReorganizeParts Part { get; } + + public EditableField Field { get; } + + /// The template is applied; off, that part of every sequence stays as it is. + public bool IsEnabled + { + get => _isEnabled; + set + { + if (!Set(ref _isEnabled, value)) return; + // An error of a template turned off no longer counts, and one turned on is shown again. + Field.Refresh(); + _toggled(); + } + } + + /// The template the dry run uses; null while the switch is off. + public string? Template => _isEnabled ? Field.Text : null; + + /// The problem that keeps the dry run from running; null when the template is off or usable. + public string? Error => _isEnabled ? Field.Error : null; +} + +/// +/// Reorganize (owner review 2, R7; BRIEF §7.1, §12.5): new folder, file and title templates applied to sequences already in +/// the archive — a set, or every sequence. Each template has its switch and starts from the archive's settings; the dry run +/// (the engine's plan, nothing changes on disk) follows the typing and lists each sequence that changes with its new +/// folder, title and first file names, and the photos that keep their names with why, or why the whole sequence stays as +/// it is (a sidecar that cannot be read). Apply queues the Reorganize job of +/// exactly that plan (): resumable, paused and followed in Jobs, refused when the +/// archive changed after the dry run. +/// +public sealed class ReorganizeDialogViewModel : ArchiveDialogViewModel +{ + private readonly ArchiveService _archives; + private readonly Core.Model.Archive _archive; + private readonly IReadOnlyList? _set; + private readonly Func _enqueue; + private readonly DispatcherTimer _delay = new() { Interval = TimeSpan.FromMilliseconds(400) }; + + /// Guards and : only the latest dry run started ever publishes its result. + private readonly Lock _gate = new(); + + private DryRun _run = new(null); + private CancellationTokenSource? _planning; + + /// The sequences to reorganize; null for every sequence of . + /// The templates switched on at the start. + /// Queues the Reorganize job and says so. + public ReorganizeDialogViewModel(ArchiveService archives, Core.Model.Archive archive, IReadOnlyList? set, ReorganizeParts enabled, + Func enqueue, Action close) + : base(close) + { + ArgumentNullException.ThrowIfNull(archive); + _archives = archives; + _archive = archive; + _set = set; + _enqueue = enqueue; + Folders = Template(ReorganizeParts.Folders, archive.FolderTemplate, "Tooltips.Archive.FolderTemplate"); + Files = Template(ReorganizeParts.Files, archive.FileTemplate, "Tooltips.Archive.FileTemplate"); + Titles = Template(ReorganizeParts.Titles, "{title}", "Tooltips.Archive.TitleTemplate"); + _delay.Tick += (_, _) => _ = PlanAsync(); + ApplyCommand = new AsyncRelayCommand(ApplyAsync, () => ApplyBlocker is null); + + ReorganizeTemplate Template(ReorganizeParts part, string text, string toolTip) => + new(part, text, enabled.HasFlag(part), toolTip, OnTyped, () => _ = PlanAsync(), OnCommitted); + } + + public ReorganizeTemplate Folders { get; } + public ReorganizeTemplate Files { get; } + public ReorganizeTemplate Titles { get; } + + public IReadOnlyList Templates => [Folders, Files, Titles]; + + /// "Reorganize 36 sequences", or "Reorganize ChronosArchive" for every sequence. + public string Heading => _set is null ? Loc.L("Archive.Reorganize.HeadingAll", _archive.Name) : Loc.Plural("Archive.Reorganize.Heading", _set.Count); + + /// The last dry run, one row per sequence that changes or keeps photo names, in the order the job applies them. + public IReadOnlyList Rows => _run.Rows ?? []; + + /// The plan of the templates on screen; null while it is made, when it failed, or once the templates changed. + public RenamePlan? Plan => _run is { Plan: { } plan } run && run.For == Current() ? plan : null; + + public string SummaryText => Plan is { } plan ? ReorganizePlans.Summary(plan, _set?.Count ?? plan.Subjects.Count) : string.Empty; + + /// Queues the job of the plan on screen and closes. + public ICommand ApplyCommand { get; } + + public string ApplyToolTip => ApplyBlocker ?? Loc.L("Tooltips.Archive.ReorganizeApply"); + + /// Why Apply is disabled; null when it can run. + private string? ApplyBlocker + { + get + { + if (IsBusy) return Loc.L("Archive.Blocked.Applying"); + if (!Templates.Any(t => t.IsEnabled)) return Loc.L("Archive.Blocked.NoTemplate"); + if (Templates.Select(t => t.Error).FirstOrDefault(e => e is not null) is { } error) return error; + var run = _run; + if (run.For is null || run.For != Current()) return Loc.L("Archive.Blocked.Planning"); + if (run.Plan is not { } plan) return run.Error ?? Loc.L("Archive.Blocked.Planning"); + return plan.Steps.Any(s => s.Changes) ? null : Loc.L("Archive.Blocked.NoChanges"); + } + } + + /// The templates switched on, as the engine takes them; null when none is on or one of them cannot be used. + public RenameTemplates? Current() + { + if (Templates.Any(t => t.Error is not null)) return null; + var templates = new RenameTemplates(Folders.Template, Files.Template, Titles.Template); + return templates.IsEmpty ? null : templates; + } + + /// + /// The dry run of the templates on screen; it clears the last failure and stands in for one still waiting on typing. + /// + public Task PlanAsync() + { + _delay.Stop(); + ClearError(); + return DryRunAsync(); + } + + public override void Dispose() + { + _delay.Stop(); + lock (_gate) _planning?.Cancel(); + base.Dispose(); + } + + /// The rows, the templates' messages and the summary in the new language. + protected override void OnLanguageChanged() + { + foreach (var template in Templates) template.Field.Refresh(); + lock (_gate) + { + if (_run.Plan is { } plan) _run = _run with { Rows = ReorganizePlans.Rows(plan) }; + } + base.OnLanguageChanged(); + } + + /// Typing makes the dry run on screen old at once (Apply waits) and plans again once the typing pauses. + private void OnTyped() + { + OnPlanChanged(); + _delay.Stop(); + _delay.Start(); + } + + /// + /// Enter, or the focus leaving a field, plans at once, unless the dry run on screen or the one under way is already of + /// these templates: a click on Apply takes the focus from the field first, and an identical dry run started then + /// would turn Apply off under the click. + /// + private void OnCommitted() + { + if (IsPlanned()) _delay.Stop(); + else _ = PlanAsync(); + } + + /// The templates on screen have their plan, or a dry run of them is under way; false after a failed one. + private bool IsPlanned() + { + lock (_gate) return _run.For is { } templates && templates == Current() && (_run.Plan is not null || _planning is not null); + } + + private async Task DryRunAsync() + { + var templates = Current(); + // The checks of the fields are the stricter ones; this is the engine's last word on what it can expand. + var unusable = templates?.Problem() is not null ? Loc.L("Errors.Template.Format") : null; + var cts = templates is null || unusable is not null ? null : new CancellationTokenSource(); + lock (_gate) + { + _planning?.Cancel(); + _planning = cts; + _run = new DryRun(templates, Error: unusable); + } + BusyText = cts is null ? null : Loc.L("Archive.Reorganize.Planning"); + OnPlanChanged(); + if (cts is null) return; + + var set = _set; + DryRun result; + Exception? failure = null; + try + { + var plan = await Task.Run(() => _archives.PlanReorganizeAsync(_archive.Id, set, templates!, cts.Token), cts.Token); + result = new DryRun(templates, plan, ReorganizePlans.Rows(plan)); + } + catch (OperationCanceledException) when (cts.IsCancellationRequested) + { + // A newer dry run took its place, or the dialog closed. + result = new DryRun(templates); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or ArgumentException or InvalidDataException or DatabaseException + or FormatException) + { + Log.Warning("archive", "Reorganize dry run failed", ex); + failure = ex; + result = new DryRun(templates, Error: ArchiveFailures.Cause(ex)); + } + bool latest; + lock (_gate) + { + latest = ReferenceEquals(_planning, cts); + if (latest) + { + _planning = null; + _run = result; + } + } + cts.Dispose(); + if (!latest) return; + BusyText = null; + if (failure is not null) ShowError(failure); + OnPlanChanged(); + } + + private void OnPlanChanged() + { + OnPropertyChanged(nameof(Rows)); + OnPropertyChanged(nameof(Plan)); + OnPropertyChanged(nameof(SummaryText)); + OnPropertyChanged(nameof(ApplyToolTip)); + CommandManager.InvalidateRequerySuggested(); + } + + private async Task ApplyAsync() + { + var run = _run; + if (run is not { Plan: { } plan, For: { } templates } || templates != Current()) return; + ClearError(); + IsBusy = true; + try + { + await _enqueue(ArchiveJobs.Reorganize(_archive, plan, templates)); + Log.Info("archive", $"Reorganize of {plan.Steps.Count(s => s.Changes)} sequence(s) in {_archive.RootPath} queued"); + } + catch (DatabaseException ex) + { + Log.Warning("archive", "The reorganize was not queued", ex); + ShowError(ex); + return; + } + finally + { + IsBusy = false; + } + Close(); + } + + /// A dry run: the templates it is for and, once it ended, its plan and rows, or why it failed. + private sealed record DryRun(RenameTemplates? For, RenamePlan? Plan = null, IReadOnlyList? Rows = null, string? Error = null); +} diff --git a/src/Chronos.App/Archive/ReorganizePlans.cs b/src/Chronos.App/Archive/ReorganizePlans.cs new file mode 100644 index 00000000..cf897784 --- /dev/null +++ b/src/Chronos.App/Archive/ReorganizePlans.cs @@ -0,0 +1,160 @@ +using Chronos.App.Settings; +using Chronos.Core.Archiving; +using Chronos.Core.Localization; +using Chronos.Core.Naming; + +namespace Chronos.App.Archiving; + +/// What a Reorganize changes (owner review 2, R7): the sequences' folders, their photos' file names, their titles. +[Flags] +public enum ReorganizeParts +{ + None = 0, + Folders = 1, + Files = 2, + Titles = 4, +} + +/// One change of a dry-run row, before and after: a folder or a file name (read left to right) or a title. +public sealed record ReorganizeLine(string Label, string From, string To, bool IsPath); + +/// +/// One sequence of the Reorganize dry run: its name, what concerns it as a whole (it follows its folder, how many of its +/// files get a new name), its changes (the first renamed files as samples) and the photos that keep their names, with why, +/// or why the whole sequence stays as it is. +/// +/// The sequence has no title: is its folder, read left to right. +public sealed record ReorganizeRow(Guid SequenceId, string Name, bool IsNamePath, string Note, IReadOnlyList Lines, IReadOnlyList Kept) +{ + public bool HasNote => Note.Length > 0; + + public bool HasKept => Kept.Count > 0; + + /// What a screen reader says after the name: the note, every change and every kept line. + public string Description => string.Join(Environment.NewLine, + [.. HasNote ? [Note] : (string[])[], .. Lines.Select(l => Loc.L("Archive.Reorganize.Change", l.Label, l.From, l.To)), .. Kept]); +} + +/// +/// The words of a Reorganize (owner review 2, R7; BRIEF §7.1, §12.5): each template checked as it is typed, the engine's +/// dry run () as rows and a summary. +/// +public static class ReorganizePlans +{ + /// What Reorganize… changes when opened from a mass bar: the archive's layout, folders and file names. + public const ReorganizeParts Layout = ReorganizeParts.Folders | ReorganizeParts.Files; + + /// + /// The first problem of for , localized; null when it can be used. + /// Folders and files follow the rules of the archive's templates (Settings › Archive); a title may use any token. + /// + public static string? Validate(ReorganizeParts part, string? template) + { + if (string.IsNullOrWhiteSpace(template)) return Loc.L("Errors.Template.Empty", string.Empty, 1); + switch (part) + { + case ReorganizeParts.Folders: + return NamingPreview.Validate(template, isFolder: true); + case ReorganizeParts.Files: + return NamingPreview.Validate(template, isFolder: false); + } + var parsed = PathTemplate.Parse(template); + if (parsed.Errors is [var error, ..]) return Loc.L("Errors.Template." + error.Code, error.Token ?? string.Empty, error.Position + 1); + try + { + foreach (var frame in NamingPreview.SampleFrames) parsed.ExpandText(frame); + } + catch (FormatException) + { + return Loc.L("Errors.Template.Format"); + } + return null; + } + + /// + /// The rows of a plan, in the order it applies them; a step that changes nothing lists why photos keep their names, or + /// why the whole sequence stays as it is. + /// + public static IReadOnlyList Rows(RenamePlan plan) => [.. plan.Steps.Where(s => s.Changes || s.Blocked.Count > 0).Select(Row)]; + + public static ReorganizeRow Row(RenameStep step) + { + var title = string.IsNullOrWhiteSpace(step.ToTitle) ? step.FromTitle : step.ToTitle; + var named = !string.IsNullOrWhiteSpace(title); + var lines = new List(); + if (step.MovesFolder) lines.Add(new(Loc.L("Archive.Reorganize.Folder"), step.FromFolder, step.ToFolder, IsPath: true)); + if (step.Retitles) lines.Add(new(Loc.L("Archive.Reorganize.Title"), step.FromTitle ?? string.Empty, step.ToTitle ?? string.Empty, IsPath: false)); + lines.AddRange(step.FileSamples.Select(f => new ReorganizeLine(Loc.L("Archive.Reorganize.File"), f.From, f.To, IsPath: true))); + string[] notes = + [ + step.Carried ? Loc.L("Archive.Reorganize.Carried") : string.Empty, + step.FileChanges > 0 ? Loc.Plural("Archive.Reorganize.Renamed", step.FileChanges) : string.Empty, + ]; + var kept = step.Blocked.Select(b => b.Frames > 0 + ? Loc.L("Archive.Reorganize.Blocked." + b.Reason) + Loc.Separator + Loc.Plural("Shell.Status.Photos", b.Frames) + : Loc.L("Archive.Reorganize.Blocked." + b.Reason)).ToList(); + var name = named ? title! : step.ToFolder.Length > 0 ? step.ToFolder : step.SequenceId.ToString("N")[..8]; + return new ReorganizeRow(step.SequenceId, name, !named, string.Join(Loc.Separator, notes.Where(n => n.Length > 0)), lines, kept); + } + + /// The sequences that change as chosen; those that only follow a folder they are in are listed, not counted. + public static int Changed(RenamePlan plan) => plan.Steps.Count(s => s.Changes && !s.Carried); + + /// + /// "12 of 36 change · 3,600 files renamed · 20 names kept": the files only when the plan renames files, the names kept + /// only when photos keep theirs. + /// + /// The set is every sequence planned, including those that change nothing. + public static string Summary(RenamePlan plan, int setSize) + { + var parts = new List { Loc.Plural("Archive.Rename.Summary", Changed(plan), setSize) }; + if (plan.FileTemplate is not null) parts.Add(Loc.Plural("Archive.Reorganize.Renamed", plan.Steps.Sum(s => s.FileChanges))); + var kept = plan.Steps.Sum(s => s.Blocked.Sum(b => b.Frames)); + if (kept > 0) parts.Add(Loc.Plural("Archive.Reorganize.Kept", kept)); + return string.Join(Loc.Separator, parts); + } +} + +/// +/// What Settings › Archive offers to reorganize after its templates changed (owner review 2, R7): per archive, every +/// template changed since its offer was last taken. A change while that archive's toast is still up joins the offer on +/// screen instead of raising another toast; a change in another archive raises its own, and each toast takes only its +/// archive's offer. +/// +/// How long a toast stays up. +public sealed class ReorganizeOffer(TimeSpan toastTime) +{ + private readonly Dictionary _pending = []; + + /// + /// Records that of changed at ; true when a + /// toast should offer it (none of that archive is up), raised at . + /// + public bool Add(Core.Model.Archive archive, ReorganizeParts part, DateTime now) + { + ArgumentNullException.ThrowIfNull(archive); + var known = _pending.TryGetValue(archive.Id, out var pending); + var shown = known && pending!.Raised is { } raised && now - raised < toastTime; + _pending[archive.Id] = new Pending(archive, (known ? pending!.Parts : ReorganizeParts.None) | part, shown ? pending!.Raised : now); + return !shown; + } + + /// + /// The toast of raised at left the screen (dismissed, timed out, + /// pushed out by newer ones): the next change raises a new one. A toast older than the one up now changes nothing. + /// + public void Closed(Guid archiveId, DateTime raised) + { + if (_pending.TryGetValue(archiveId, out var pending) && pending.Raised == raised) _pending[archiveId] = pending with { Raised = null }; + } + + /// + /// The offer of when its toast's action runs: the archive as it was last saved and every + /// template changed; null when taken already. Other archives' offers stay. + /// + public (Core.Model.Archive Archive, ReorganizeParts Parts)? Take(Guid archiveId) => + _pending.Remove(archiveId, out var pending) ? (pending.Archive, pending.Parts) : null; + + /// When the toast on screen was raised; null once it left. + private sealed record Pending(Core.Model.Archive Archive, ReorganizeParts Parts, DateTime? Raised); +} diff --git a/src/Chronos.App/Editor/EditorViewModel.cs b/src/Chronos.App/Editor/EditorViewModel.cs index 1f54ee17..2dd816a7 100644 --- a/src/Chronos.App/Editor/EditorViewModel.cs +++ b/src/Chronos.App/Editor/EditorViewModel.cs @@ -150,6 +150,7 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable session.Source.JobChanged += OnJobChanged; session.Source.ReadOnlyChanged += OnReadOnlyChanged; shell.Services.Sync.Changed += OnSyncChanged; + shell.Services.SequenceReorganized += OnSequenceReorganized; UpdateMarkers(); RefreshSteps(); RequestCorrections(); @@ -708,6 +709,7 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable Session.Source.JobChanged -= OnJobChanged; Session.Source.ReadOnlyChanged -= OnReadOnlyChanged; Shell.Services.Sync.Changed -= OnSyncChanged; + Shell.Services.SequenceReorganized -= OnSequenceReorganized; foreach (var tab in Tabs) tab.Dispose(); base.Dispose(); await Session.DisposeAsync(); @@ -1182,6 +1184,15 @@ public sealed class EditorViewModel : LocalizedViewModel, IAsyncDisposable if (ServerJob is { } job) await Session.Source.CancelJobAsync(job.Id, CancellationToken.None); } + /// + /// A Reorganize of this PC moved the folder of a sequence or renamed it or its files (any thread): the open sequence of + /// this PC is read again where it is now, so its frames decode and its project goes there. + /// + private void OnSequenceReorganized(Guid sequenceId) => _dispatcher.BeginInvoke(() => + { + if (!_disposed && !IsRemote && sequenceId == Session.Content.Sequence.Id) _ = ReloadAsync(null); + }); + /// The session, the sync links or the rights changed (any thread): whether the Export "Sync" option applies. private void OnSyncChanged() => _dispatcher.BeginInvoke(() => _ = OnSyncChangedAsync()); diff --git a/src/Chronos.App/Editor/ISequenceSource.cs b/src/Chronos.App/Editor/ISequenceSource.cs index 4f41af01..2ecd873f 100644 --- a/src/Chronos.App/Editor/ISequenceSource.cs +++ b/src/Chronos.App/Editor/ISequenceSource.cs @@ -45,9 +45,10 @@ public interface ISequenceSource : IAsyncDisposable Task LoadAsync(CancellationToken cancellationToken); /// - /// Whether the frames read last are still the sequence's, in the same order: frames inserted - /// or removed since (a sync download, an import of earlier photos, a scan) moved the stored project's positions. A - /// server sequence whose frames changed becomes . + /// Whether the frames read last are still the sequence's, in the same order and folder: frames + /// inserted or removed since (a sync download, an import of earlier photos, a scan) moved the stored project's + /// positions, and a Reorganize may have moved the folder. A server sequence whose frames changed becomes + /// . /// /// The sequence is gone. Task FramesCurrentAsync(CancellationToken cancellationToken); diff --git a/src/Chronos.App/Editor/LocalSequenceSource.cs b/src/Chronos.App/Editor/LocalSequenceSource.cs index 741088db..aaa07f4b 100644 --- a/src/Chronos.App/Editor/LocalSequenceSource.cs +++ b/src/Chronos.App/Editor/LocalSequenceSource.cs @@ -51,6 +51,9 @@ public sealed class LocalSequenceSource : ISequenceSource /// The frames version of the frames last read (), whose order the project's positions follow. private int _framesVersion = -1; + /// The archive-relative folder the last read found the sequence in (); a Reorganize moves it. + private string? _relativeFolder; + private ArchivePaths? _paths; private SequencePaths? _folder; @@ -98,7 +101,8 @@ public sealed class LocalSequenceSource : ISequenceSource if ((frames[i].Flags & FrameFlags.Missing) == 0) files[i] = paths.FromRelative(frames[i].RelativePath); } _companions = [.. frames.Select(f => companions.GetValueOrDefault(f.Id))]; - (_paths, _folder, _files, _frameIds, _framesVersion) = (paths, folder, files, [.. frames.Select(f => f.Id)], sequence.FramesVersion); + (_paths, _folder, _relativeFolder, _files, _frameIds, _framesVersion) = + (paths, folder, sequence.Folder, files, [.. frames.Select(f => f.Id)], sequence.FramesVersion); var context = SequenceContext.FromFrames(frames); var (report, otherFrames) = ReadReport(folder, frames.Count); return new SequenceContent(sequence, frames, ReadProject(sequence, folder), LightAnalyzer.Analyze(frames), report, @@ -109,12 +113,15 @@ public sealed class LocalSequenceSource : ISequenceSource }, cancellationToken); } - /// An insertion bumps the row's frames version in the transaction that renumbers the frames. + /// + /// An insertion bumps the row's frames version in the transaction that renumbers the frames; a Reorganize that moved + /// the folder leaves the version but not the files where they were read. + /// public async Task FramesCurrentAsync(CancellationToken cancellationToken) { - var framesVersion = _framesVersion; + var (framesVersion, folder) = (_framesVersion, _relativeFolder); var row = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); - return row.FramesVersion == framesVersion; + return row.FramesVersion == framesVersion && row.Folder == folder; } public async ValueTask DecodeAsync(int index, int maxLongEdge, DecodePurpose purpose, CancellationToken cancellationToken) @@ -157,7 +164,7 @@ public sealed class LocalSequenceSource : ISequenceSource { ArgumentNullException.ThrowIfNull(project); ArgumentNullException.ThrowIfNull(basis); - var (paths, folder, frameIds, framesVersion) = (_paths, _folder, _frameIds, _framesVersion); + var (paths, folder, relativeFolder, frameIds, framesVersion) = (_paths, _folder, _relativeFolder, _frameIds, _framesVersion); if (paths is null || folder is null) throw new InvalidOperationException("LoadAsync first."); return Task.Run(async () => { @@ -168,8 +175,13 @@ public sealed class LocalSequenceSource : ISequenceSource { var row = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); // Frames were inserted or removed since the editor read them, so its positions name the old order. Insertions - // hold this lease, so the frames do not change again before this save ends. - if (row.FramesVersion != framesVersion) throw new FramesChangedException(Loc.L("Editor.Error.FramesArriving")); + // hold this lease, so the frames do not change again before this save ends. A Reorganize moves the folder under + // it too: moved since the read, the project goes to the new folder once the editor read the sequence there, + // and the folder it left is never created again. + if (row.FramesVersion != framesVersion || row.Folder != relativeFolder) throw new FramesChangedException(Loc.L("Editor.Error.FramesArriving")); + // Moved by another index of the archive (a server's Reorganize), which this index finds at its next scan; the folder + // it left may hold another sequence that index moved into it since. + if (!SequenceFolders.Holds(folder, _sequenceId)) throw Missing(); var stored = ReadProject(row, folder); var merged = ProjectMerge.SameValues(stored, basis) ? project : ProjectMerge.Merge(basis, project, stored); var json = merged.ToJson(); @@ -218,9 +230,10 @@ public sealed class LocalSequenceSource : ISequenceSource /// /// The sequence row with its frames as one state: the frames are listed between two reads of the row that find the /// same frames version (an insertion renumbers the frames and moves the row's positions in one transaction, and - /// bumps the version), so the project's positions name these frames. + /// bumps the version), so the project's positions name these frames, and the same folder (a Reorganize moves the + /// folder and rewrites the frames' paths in one transaction, the version kept), so the files are where they were read. /// - /// The sequence is gone, or an insertion landed during every attempt. + /// The sequence is gone, or an insertion or a move landed during every attempt. private async Task<(Sequence Row, List Frames)> ReadFramesAsync(CancellationToken cancellationToken) { for (var attempt = 0; attempt < ReadAttempts; attempt++) @@ -234,7 +247,7 @@ public sealed class LocalSequenceSource : ISequenceSource if (page.Count < PageSize) break; } var after = await _db.Sequences.GetAsync(_sequenceId, cancellationToken) ?? throw Missing(); - if (after.FramesVersion == before.FramesVersion) return (after, frames); + if (after.FramesVersion == before.FramesVersion && after.Folder == before.Folder) return (after, frames); } throw new EditorException(Loc.L("Editor.Error.FramesArriving")); } @@ -281,7 +294,8 @@ public sealed class LocalSequenceSource : ISequenceSource } /// -/// The frames of a sequence of this PC changed since the editor read them (frames inserted or removed): nothing was -/// saved. The editor reads them again, moves its positions as the index moved the stored ones, and saves again. +/// The frames of a sequence of this PC changed since the editor read them (frames inserted or removed, or their folder +/// moved by a Reorganize): nothing was saved. The editor reads them again, moves its positions as the index moved the +/// stored ones, and saves again. /// public sealed class FramesChangedException(string message) : EditorException(message); diff --git a/src/Chronos.App/Infrastructure/AppServices.cs b/src/Chronos.App/Infrastructure/AppServices.cs index fa2a549d..9e5ce17e 100644 --- a/src/Chronos.App/Infrastructure/AppServices.cs +++ b/src/Chronos.App/Infrastructure/AppServices.cs @@ -111,6 +111,12 @@ public sealed class AppServices : IAsyncDisposable /// Sync with the signed-in server: engine, job connection, background comparison. public SyncHost Sync { get; } + /// + /// A job of this PC moved a sequence's folder or changed its title or file names (a Reorganize step), with the + /// sequence's id (any thread): an open editor reads it again where it is now. + /// + public event Action? SequenceReorganized; + public IEncoderInventory Encoders { get; set; } /// Decode tier per format on this PC and the missing codec extensions (Settings › Formats). @@ -452,6 +458,12 @@ public sealed class AppServices : IAsyncDisposable // The housekeeping schedule trims the cache to Settings › Storage › Cache limit (owner review 2, R10). CleanupSteps = [new CacheTrimStep(() => CacheStore.Folder(Environment, Settings), () => Settings.CacheLimitGb * (1L << 30))], BackupDirectory = Environment.BackupDirectory, + // Told after each step of a Reorganize, while the rest of the job runs. + SequenceChanged = (id, _, _) => + { + SequenceReorganized?.Invoke(id); + return Task.CompletedTask; + }, }; Archives = new ArchiveService(database, archive); Processing = new ProcessingService(database, ProcessingOptions(archive)); diff --git a/src/Chronos.App/Library/MassActions.cs b/src/Chronos.App/Library/MassActions.cs index 2e2a050d..97ad0fc1 100644 --- a/src/Chronos.App/Library/MassActions.cs +++ b/src/Chronos.App/Library/MassActions.cs @@ -13,7 +13,9 @@ public enum MassAction Verify, Tag, Rate, - Move, + + /// Folders, file names and titles from templates (owner review 2, R7), for the sequences of one archive. + Reorganize, Upload, Download, Delete, @@ -71,7 +73,8 @@ public static class MassActions return null; } if (targets.Count == 0) return Loc.L("Library.Blocked.ServerOnly"); - return action == MassAction.Move && targets.Select(t => t.Sequence.ArchiveId).Distinct().Count() > 1 ? Loc.L("Library.Blocked.Archives") : null; + // One plan, one job: a Reorganize renames inside one archive, never across two. + return action == MassAction.Reorganize && targets.Select(t => t.Sequence.ArchiveId).Distinct().Count() > 1 ? Loc.L("Library.Blocked.OneArchive") : null; } /// The enabled tooltip: what the action does to how many sequences. diff --git a/src/Chronos.App/Sections/ArchiveView.xaml b/src/Chronos.App/Sections/ArchiveView.xaml index bb169121..783aaad1 100644 --- a/src/Chronos.App/Sections/ArchiveView.xaml +++ b/src/Chronos.App/Sections/ArchiveView.xaml @@ -423,8 +423,8 @@ - `) : emptyState("Admin.Library.Empty", ``); applyStrings(itemsHost); @@ -343,6 +344,7 @@ async function renderList(root, { api, setMeta, actions, onEvent }, params) { ${escapeHtml(plural("Admin.Library.Selected", selection.size))}${selectAll} ${JOBS.map(job).join("")} + @@ -362,6 +364,8 @@ async function renderList(root, { api, setMeta, actions, onEvent }, params) { } if (action === "all") return selectAll(); if (action === "csv") return exportCsv(); + // A modal dialog: the button stays enabled, so the focus comes back to it when the dialog closes. + if (action === "reorganize") return reorganize(); button.disabled = true; try { if (action === "job") await queueJobs(button.dataset.kind); @@ -415,6 +419,28 @@ async function renderList(root, { api, setMeta, actions, onEvent }, params) { toast([done, skipped > 0 ? plural("Admin.Library.Skipped", skipped) : "", failure ?? ""].filter(Boolean).join(" · "), failure !== null); } + /** Whether a filter narrows the list (the sort order does not). */ + function isFiltered() { + return FILTERS.some((f) => f !== "sort" && filters[f]); + } + + /** + * Reorganize (owner review 2, R7) of the selected sequences: their ids, at most a bulk request's thousand (one plan, + * one job). Beyond that, every sequence of the archive, but only while the selection is exactly what Select all + * fetched without a filter and the archive has not grown since: a sequence unticked or added later is never included. + */ + async function reorganize() { + const ids = [...selection.ids]; + const everything = ids.length > BULK_LIMIT && matching !== null && !isFiltered() && total === matching.length && + ids.length === matching.length && matching.every((s) => selection.has(s.id)); + if (!everything && ids.length > BULK_LIMIT) { + toast(t("Admin.Reorganize.TooMany", formatNumber(BULK_LIMIT)), true); + return; + } + const names = new Map(selectedRows().map((s) => [s.id, s.displayTitle])); + await openReorganize({ api, target: everything ? { all: true } : { sequenceIds: ids }, names }); + } + async function retag() { const datalist = facets.tags.map((f) => ``).join(""); const data = await formDialog({ diff --git a/src/Chronos.Server/Admin/web/reorganize.js b/src/Chronos.Server/Admin/web/reorganize.js new file mode 100644 index 00000000..ad7299e7 --- /dev/null +++ b/src/Chronos.Server/Admin/web/reorganize.js @@ -0,0 +1,386 @@ +// Reorganize dialog of the admin panel (owner review 2, R7; BRIEF §12.5, §14.8): folder, file and title templates applied +// to sequences already in the archive, the Library's selection or every sequence. Each change of a template asks the +// server for a dry run (nothing is touched) and the table shows what every sequence becomes, in the order the changes +// apply. Apply confirms that very plan by its fingerprint, and the server runs it as a job (kind "move") that moves and +// renames the originals, never overwriting or deleting one (only photos whose SHA-256 is known get new names). +import { t, plural, applyStrings } from "./i18n.js"; +import { escapeHtml, attr, formatNumber, toast, errorText, confirmDialog, markInvalid, clearInvalid } from "./ui.js"; + +const ENDPOINT = "/api/v1/archive/reorganize"; +/** Wait after the last keystroke before the dry run, and the steps the table draws at a time. */ +const PLAN_DELAY = 400; +const PAGE = 200; +/** The parts a Reorganize changes: the template's request field, its switch and its field, with their strings. */ +const PARTS = [ + { key: "folder", field: "folderTemplate", label: "Admin.Reorganize.Folders", use: "Admin.Reorganize.Folders.Tip", tip: "Admin.Reorganize.FolderTemplate.Tip" }, + { key: "file", field: "fileTemplate", label: "Admin.Reorganize.Files", use: "Admin.Reorganize.Files.Tip", tip: "Admin.Reorganize.FileTemplate.Tip" }, + { key: "title", field: "titleTemplate", label: "Admin.Reorganize.Titles", use: "Admin.Reorganize.Titles.Tip", tip: "Admin.Reorganize.TitleTemplate.Tip" }, +]; + +let dialogs = 0; + +/** + * Opens the Reorganize dialog. target is { all: true } (every sequence of the archive) or { sequenceIds } (at most a + * bulk request's thousand); names maps sequence ids to the titles the page shows. templates ({ folderTemplate, + * fileTemplate, titleTemplate }) fills the fields, else the archive's settings do; use lists the parts switched on + * ("folder", "file", "title"), else those with a template. Resolves when the dialog closes: the queued job, or null. + */ +export function openReorganize({ api, target, names = new Map(), templates = null, use = null } = {}) { + return new Promise((resolve) => { + const id = `reorganize-${++dialogs}`; + /** The last dry run, with key: the request it answers. */ + let plan = null; + let shown = PAGE; + let timer = null; + let planning = false; + let again = false; + let loaded = false; + let busy = false; + let queued = null; + /** A message the next plan shows (why the plan was made again). */ + let notice = ""; + const title = target.all ? t("Admin.Reorganize.TitleAll") : plural("Admin.Reorganize.Title", target.sequenceIds.length); + + const dialog = document.createElement("dialog"); + dialog.className = "dialog reorganize"; + dialog.setAttribute("aria-labelledby", `${id}-title`); + dialog.innerHTML = ` +
+

${escapeHtml(title)}

+
${PARTS.map((p) => ` + + + `).join("")} +
+
+ + +
+ + +
+
`; + document.body.appendChild(dialog); + applyStrings(dialog); + const form = dialog.querySelector("form"); + const totals = dialog.querySelector(".reorg-totals"); + const preview = dialog.querySelector(".reorg-preview"); + const rows = dialog.querySelector(".reorg-rows"); + const foot = dialog.querySelector(".table-foot"); + const shownText = dialog.querySelector(".reorg-shown"); + const errorLine = dialog.querySelector(".error"); + const closeButton = dialog.querySelector('[data-act="close"]'); + const applyButton = dialog.querySelector('[data-act="apply"]'); + const check = (p) => dialog.querySelector(`[data-part="${p.key}"]`); + const input = (p) => form.elements[p.field]; + const errorHost = (p) => dialog.querySelector(`[data-error="${p.key}"]`); + + for (const p of PARTS) { + check(p).addEventListener("change", () => { + clearField(p); + showError(""); + drawButtons(); + // A part switched on without a template: its field is where the next step is. + if (check(p).checked && input(p).value.trim() === "") { + input(p).focus(); + clearTimeout(timer); + preview.classList.add("stale"); + return; + } + schedule(0); + }); + input(p).addEventListener("input", () => { + clearField(p); + showError(""); + schedule(PLAN_DELAY); + }); + } + // Enter in a template plans at once (a form of several fields without a submit button never submits on Enter); + // only the Apply button changes anything. + form.addEventListener("keydown", (e) => { + if (e.key !== "Enter" || e.isComposing || !(e.target instanceof HTMLInputElement) || e.target.type === "checkbox") return; + e.preventDefault(); + if (loaded && !busy) schedule(0); + }); + form.addEventListener("submit", (e) => e.preventDefault()); + closeButton.addEventListener("click", () => { + if (!busy) dialog.close(); + }); + applyButton.addEventListener("click", apply); + dialog.querySelector('[data-act="more"]').addEventListener("click", () => { + shown += PAGE; + drawRows(); + if (foot.hidden) preview.focus(); + }); + // Esc closes, except while the change is being sent. + dialog.addEventListener("cancel", (e) => { + if (busy) e.preventDefault(); + }); + const signedOut = () => dialog.close(); + window.addEventListener("chronos:signed-out", signedOut); + dialog.addEventListener("close", () => { + clearTimeout(timer); + window.removeEventListener("chronos:signed-out", signedOut); + dialog.remove(); + resolve(queued); + }); + dialog.showModal(); + start(); + + /** The templates to start from: given, or the archive's settings (and its title template when it has one). */ + async function start() { + let values = templates; + if (!values) { + try { + const settings = await api.get("/api/v1/archive/settings"); + values = { folderTemplate: settings.folderTemplate, fileTemplate: settings.fileTemplate, titleTemplate: settings.titleTemplate ?? "" }; + } catch (err) { + showError(errorText(err)); + values = {}; + } + } + if (!dialog.open) return; + const on = new Set(use ?? PARTS.filter((p) => String(values[p.field] ?? "").trim() !== "").map((p) => p.key)); + for (const p of PARTS) { + input(p).value = values[p.field] ?? ""; + check(p).checked = on.has(p.key); + } + loaded = true; + drawButtons(); + (PARTS.map(input).find((field) => !field.disabled) ?? check(PARTS[0])).focus(); + schedule(0); + } + + /** The request the fields make (without dryRun); null when no part is switched on. */ + function request() { + const body = target.all ? { all: true } : { all: false, sequenceIds: target.sequenceIds }; + let any = false; + for (const p of PARTS) { + if (!check(p).checked) continue; + body[p.field] = input(p).value.trim(); + any = true; + } + return any ? body : null; + } + + function keyNow() { + return JSON.stringify(request()); + } + + /** Plans again after delay ms; what the table shows until then no longer matches the fields. */ + function schedule(delay) { + clearTimeout(timer); + preview.classList.add("stale"); + drawButtons(); + timer = setTimeout(runPlan, delay); + } + + /** One dry run at a time: a change made while one is answered plans again right after it. */ + async function runPlan() { + if (!loaded || !dialog.open) return; + if (planning) { + again = true; + return; + } + const body = request(); + const blank = PARTS.find((p) => check(p).checked && input(p).value.trim() === ""); + if (!body || blank) { + plan = null; + if (blank) fieldError(blank, t("Admin.Reorganize.Blank")); + drawPlan(); + return; + } + const key = JSON.stringify(body); + planning = true; + totals.textContent = t("Admin.Reorganize.Planning"); + drawButtons(); + try { + const answer = await api.post(ENDPOINT, { ...body, dryRun: true }); + if (!dialog.open) return; + plan = { ...answer, key }; + shown = PAGE; + PARTS.forEach(clearField); + showError(notice); + notice = ""; + } catch (err) { + if (!dialog.open) return; + plan = null; + // A refusal of an older request is not shown: the fields changed since, and the next plan tells. + if (key === keyNow()) showProblem(err); + } finally { + planning = false; + } + if (again) { + again = false; + drawPlan(); + runPlan(); + return; + } + drawPlan(); + } + + function drawPlan() { + const current = plan !== null && plan.key === keyNow(); + preview.classList.toggle("stale", !current); + if (!request()) { + totals.textContent = t("Admin.Reorganize.NothingChosen"); + preview.hidden = true; + } else if (!plan) { + totals.textContent = ""; + preview.hidden = true; + } else if (plan.steps.length === 0) { + totals.textContent = t("Admin.Reorganize.NothingToChange"); + preview.hidden = true; + } else { + totals.textContent = t("Admin.Reorganize.Totals", formatNumber(plan.sequences), formatNumber(plan.files), formatNumber(plan.kept)); + preview.hidden = false; + drawRows(); + } + drawButtons(); + } + + function drawRows() { + const steps = plan.steps; + rows.innerHTML = steps.slice(0, shown).map(rowHtml).join(""); + foot.hidden = steps.length <= shown; + shownText.textContent = t("Admin.Library.Shown", formatNumber(Math.min(shown, steps.length)), formatNumber(steps.length)); + } + + /** + * One step: the sequence's title, its folder and its renamed files, before and after, with the photos that keep their + * names, or why the whole sequence stays as it is. + */ + function rowHtml(s) { + const fromTitle = s.fromTitle ?? null; + const toTitle = s.toTitle ?? null; + const name = names.get(s.sequenceId) ?? toTitle ?? fromTitle ?? folderName(s.fromFolder); + // Before reads the old state only: an untitled sequence goes by the page's name for it or its folder, never by the + // title it is about to get. + const before = fromTitle ?? names.get(s.sequenceId) ?? folderName(s.fromFolder); + const sequence = fromTitle !== toTitle ? change(before, toTitle ?? before, "auto") + : `${escapeHtml(name)}`; + const folder = s.fromFolder !== s.toFolder ? change(s.fromFolder || "/", s.toFolder || "/", "ltr", "path") + : `${escapeHtml(s.fromFolder || "/")}`; + const carried = s.carried + ? `${escapeHtml(t("Admin.Reorganize.Carried"))}` : ""; + const samples = (s.fileSamples ?? []).map((f) => `
  • ${escapeHtml(f.from)} → ${escapeHtml(f.to)}
  • `).join(""); + const files = s.fileChanges > 0 + ? `${escapeHtml(formatNumber(s.fileChanges))}${samples ? `
      ${samples}
    ` : ""}` + : `—`; + const kept = (s.blocked ?? []).map((b) => `
  • ${escapeHtml(b.photos > 0 + ? t("Admin.Reorganize.KeptPhotos", plural("Admin.Dashboard.PhotoCount", b.photos), b.message) : b.message)}
  • `).join(""); + return `
    + ${sequence}${carried} + ${folder} + ${files}${kept ? `
      ${kept}
    ` : ""}
    +
    `; + } + + function drawButtons() { + for (const p of PARTS) { + check(p).disabled = busy || !loaded; + input(p).disabled = busy || !loaded || !check(p).checked; + } + applyButton.disabled = busy || planning || plan === null || plan.key !== keyNow() || plan.sequences === 0; + closeButton.disabled = busy; + } + + /** + * The confirmation names what moves; the plan sent back is the one the table showed. The fields cannot change + * meanwhile, but a dry run scheduled before may answer during it: the same plan again (same request and fingerprint) + * is applied all the same; a different one is shown instead, and Apply waits for the user. + */ + async function apply() { + if (applyButton.disabled) return; + const chosen = plan; + const moves = chosen.steps.filter((s) => s.fromFolder !== s.toFolder).length; + const body = [plural("Admin.Reorganize.ConfirmSequences", chosen.sequences), + moves > 0 ? plural("Admin.Reorganize.ConfirmFolders", moves) : "", + chosen.files > 0 ? plural("Admin.Reorganize.ConfirmFiles", chosen.files) : ""].filter(Boolean).join(" "); + const confirmed = await confirmDialog({ + title: t("Admin.Reorganize.ConfirmTitle"), + body, + confirm: t("Admin.Reorganize.Confirm"), + confirmTip: t("Admin.Reorganize.Confirm.Tip"), + cancel: t("Admin.Common.Keep"), + cancelTip: t("Admin.Common.Keep.Tip"), + }); + if (!confirmed || !dialog.open) return; + if (plan !== chosen && (plan?.key !== chosen.key || plan.fingerprint !== chosen.fingerprint)) { + // A failed dry run already says why; a new plan is on screen to be checked. + if (plan) showError(t("Admin.Reorganize.PlanChanged")); + return; + } + busy = true; + showError(""); + drawButtons(); + try { + const job = await api.post(ENDPOINT, { ...JSON.parse(chosen.key), dryRun: false, fingerprint: chosen.fingerprint }); + queued = job; + busy = false; + dialog.close(); + toast(t("Admin.Reorganize.Queued"), false, + { label: t("Admin.Reorganize.OpenJob"), tip: t("Admin.Reorganize.OpenJob.Tip"), href: `#/jobs?job=${encodeURIComponent(job.id)}` }); + } catch (err) { + busy = false; + if (!dialog.open) return; + if (err?.code === "plan_changed") { + // The archive changed since the dry run: the new plan is shown, and Apply waits for it. + notice = err.message || t("Admin.Error.Unreachable"); + plan = null; + schedule(0); + } else { + showProblem(err); + } + drawButtons(); + (applyButton.disabled ? closeButton : applyButton).focus(); + } + } + + /** + * A refusal on the field it names (a template, with the rule it breaks after a colon and the message saying why; or the + * folders for a nested target), else under the table. + */ + function showProblem(err) { + const part = PARTS.find((p) => p.field === String(err?.details ?? "").split(":")[0]); + if (err?.code === "invalid_template" && part) fieldError(part, err.message); + else if (err?.code === "nested_target") fieldError(PARTS[0], err.message, err.details); + else if (err?.code === "not_found") showError(t("Admin.Reorganize.Gone")); + else showError(errorText(err)); + } + + function fieldError(part, message, path = "") { + markInvalid(input(part), path ? `${message} ${path}` : message); + errorHost(part).innerHTML = escapeHtml(message) + (path ? ` ${escapeHtml(path)}` : ""); + } + + function clearField(part) { + clearInvalid(input(part)); + errorHost(part).textContent = ""; + } + + function showError(message) { + errorLine.textContent = message; + } + }); +} + +/** Old and new value, one above the other; screen readers hear which is which. */ +function change(was, now, dir, cls = "") { + return `${escapeHtml(t("Admin.Reorganize.Before"))} ${escapeHtml(was)}` + + `${escapeHtml(t("Admin.Reorganize.After"))} ${escapeHtml(now)}`; +} + +/** The last part of a sequence folder ("2026/2026-09-28 Roof" → "2026-09-28 Roof"), its name when it has no title. */ +function folderName(folder) { + return String(folder ?? "").split("/").filter(Boolean).pop() ?? "—"; +} diff --git a/src/Chronos.Server/Admin/web/ui.js b/src/Chronos.Server/Admin/web/ui.js index 39f6629d..67637d1a 100644 --- a/src/Chronos.Server/Admin/web/ui.js +++ b/src/Chronos.Server/Admin/web/ui.js @@ -122,25 +122,49 @@ export function emptyState(sentenceKey, button = "") { return `
    ${button}
    `; } -/** Shows a toast at the bottom (inline end) for 8 s (hover pauses). */ -export function toast(message, isError = false) { +/** + * Shows a toast at the bottom (inline end) for 8 s, 15 s with an action (the pointer over it or the keyboard focus in it + * pauses). action ({ label, tip, href } or { label, tip, run }) adds a link or a button after the message, which closes + * the toast. + */ +export function toast(message, isError = false, action = null) { const host = document.getElementById("toasts") ?? document.body.appendChild(Object.assign(document.createElement("div"), { id: "toasts" })); const item = document.createElement("div"); - item.className = `toast${isError ? " error" : ""}`; + item.className = `toast${isError ? " error" : ""}${action ? " with-action" : ""}`; item.setAttribute("role", isError ? "alert" : "status"); - item.textContent = message; + item.appendChild(Object.assign(document.createElement("span"), { textContent: message })); + if (action) { + const control = document.createElement(action.href ? "a" : "button"); + control.className = "btn small"; + if (action.href) control.href = action.href; + else control.type = "button"; + control.textContent = action.label; + control.title = action.tip; + control.addEventListener("click", () => { + item.remove(); + action.run?.(); + }); + item.appendChild(control); + } host.appendChild(item); - let remaining = 8000; + let remaining = action ? 15000 : 8000; let started = Date.now(); let timer = setTimeout(() => item.remove(), remaining); - item.addEventListener("mouseenter", () => { + let held = 0; + const pause = () => { + if (held++ > 0) return; clearTimeout(timer); remaining -= Date.now() - started; - }); - item.addEventListener("mouseleave", () => { + }; + const resume = () => { + if (--held > 0) return; started = Date.now(); - timer = setTimeout(() => item.remove(), remaining); - }); + timer = setTimeout(() => item.remove(), Math.max(remaining, 2000)); + }; + item.addEventListener("mouseenter", pause); + item.addEventListener("mouseleave", resume); + item.addEventListener("focusin", pause); + item.addEventListener("focusout", resume); } let dialogs = 0; diff --git a/src/Chronos.Server/Api/ArchiveEndpoints.cs b/src/Chronos.Server/Api/ArchiveEndpoints.cs index 1bfee04e..900f7c11 100644 --- a/src/Chronos.Server/Api/ArchiveEndpoints.cs +++ b/src/Chronos.Server/Api/ArchiveEndpoints.cs @@ -1,5 +1,6 @@ using Microsoft.AspNetCore.Mvc; using Chronos.Core.Archiving; +using Chronos.Core.Localization; using Chronos.Core.Model; using Chronos.Core.Naming; using Chronos.Data; @@ -13,12 +14,16 @@ using Chronos.Server.Storage; namespace Chronos.Server.Api; -/// /api/v1/archive (admin): templates and proxy policy, scan/rebuild/verify/maintenance jobs, statistics. +/// +/// /api/v1/archive (admin): templates and proxy policy, scan/rebuild/verify/maintenance jobs, statistics, and +/// Reorganize (owner review 2, R7): new templates applied to sequences already in the archive. +/// public static class ArchiveEndpoints { public static void Map(RouteGroupBuilder api) { var archive = api.MapGroup("/archive").Requires(Permissions.ManageArchive); + archive.MapPost("/reorganize", ReorganizeAsync); // The form saves every field: it starts from what archive.json holds now, also a desktop's change since the last poll. archive.MapGet("/settings", async (HttpContext c, ServerArchive a, ChronosDatabase db, [FromServices] ArchiveService? archives) => Results.Json(Settings(archives is null ? a.Current : await a.RefreshAsync(archives, db, c.RequestAborted)), ProtocolJson.Default.ArchiveSettingsDto)); @@ -65,21 +70,28 @@ public static class ArchiveEndpoints /// /// Writes the name, templates and proxy policy into the archive's archive.json through the archive engine (so a - /// restart and the proxy jobs see them), then into the index. 503 archive_offline while the archive cannot be - /// written; 409 archive_busy while another process holds its settings; 409 archive_manifest when its - /// archive.json is damaged, written by a newer Chronos or of another archive; 409 archive_policy when it holds a - /// thumbnail or proxy setting this API cannot set and Chronos cannot use (details: thumbnailPolicy or - /// proxyPolicy, the property to correct in the file). Nothing is written. + /// restart and the proxy jobs see them), then into the index. 400 bad_request (details name, + /// proxyLongEdge), 400 invalid_template (: folderTemplate or + /// fileTemplate, with the rule it breaks; only a template the request changes is held to the rules, so one + /// archive.json holds from before them never fails a save of the other fields); 503 archive_offline while the + /// archive cannot be written; 409 archive_busy while another process holds its settings; 409 + /// archive_manifest when its archive.json is damaged, written by a newer Chronos or of another archive; 409 + /// archive_policy when it holds a thumbnail or proxy setting this API cannot set and Chronos cannot use (details: + /// thumbnailPolicy or proxyPolicy, the property to correct in the file). Nothing is written. /// private static async Task UpdateAsync(HttpContext context, Caller caller, ArchiveSettingsDto request, ChronosDatabase db, ServerArchive archive, [FromServices] ArchiveService? archives, AuditLog audit) { var name = request.Name?.Trim(); if (string.IsNullOrEmpty(name) || name.Length > ArchiveSettings.MaxNameLength) return ApiErrors.BadRequest(context, "bad_request", "name"); - foreach (var (field, template) in new[] { ("folderTemplate", request.FolderTemplate), ("fileTemplate", request.FileTemplate) }) - { - if (string.IsNullOrWhiteSpace(template) || !PathTemplate.Parse(template).IsValid) return ApiErrors.BadRequest(context, "invalid_template", field); - } + if (string.IsNullOrWhiteSpace(request.FolderTemplate)) return ApiErrors.BadRequest(context, "invalid_template", "folderTemplate"); + if (string.IsNullOrWhiteSpace(request.FileTemplate)) return ApiErrors.BadRequest(context, "invalid_template", "fileTemplate"); + // The rules Reorganize checks (a folder scans never enter, a lost extension or names that repeat) hold a template the + // request changes, as the engine does: one archive.json holds already, saved before them, never fails another save. + var templates = new LayoutTemplates { Folder = request.FolderTemplate, File = request.FileTemplate }; + var stored = new LayoutTemplates { Folder = archive.Current.FolderTemplate, File = archive.Current.FileTemplate }; + if (new ArchiveSettings(name, templates, new ProxyPolicy(), new ThumbnailPolicy()).CheckTemplates(stored) is { } problem) + return InvalidTemplate(context, problem); if (!ProxyPolicy.IsValidLongEdge(request.ProxyLongEdge)) return ApiErrors.BadRequest(context, "bad_request", "proxyLongEdge"); var engine = archives ?? new ArchiveService(db, new ArchiveServiceOptions { Owner = ArchiveModule.Owner }); @@ -101,6 +113,11 @@ public static class ArchiveEndpoints { return ApiErrors.Conflict(context, "archive_manifest"); } + catch (TemplateRuleException ex) + { + // archive.json held other templates than the index (a desktop's edit since): the request's breaks a rule for it. + return InvalidTemplate(context, new TemplateProblem(ex.ParamName!, ex.Rule)); + } catch (ArgumentException ex) { // The request's fields were checked above: what fails is a value read from archive.json (a thumbnail size, or a @@ -122,6 +139,117 @@ public static class ArchiveEndpoints return Results.Json(Settings(updated), ProtocolJson.Default.ArchiveSettingsDto); } + /// + /// Reorganize: folder, file and title templates applied to sequenceIds or, with all, to every sequence of the + /// archive (BRIEF §12.5). With dryRun the plan, nothing touched: per sequence its folder and title before and after, + /// the photos renamed with the first of them, and the photos that keep their names and why, or why the whole sequence + /// stays as it is. Otherwise the request carries + /// that plan's fingerprint and the server queues a move job (202) that applies exactly that plan, refused when the + /// archive changed before it ran. 400 bad_request (details sequenceIds: neither or both of them, none, or + /// more than ; templates: none; fingerprint), 400 + /// invalid_template (: folderTemplate, fileTemplate or + /// titleTemplate, with the rule it breaks); 404 + /// not_found (sequence: not in the archive); 409 nested_target (details: the folder that would lie + /// inside a sequence's folder), plan_changed (details: the fingerprint now), job_unavailable; 503 + /// archive_offline, plan_dropped (the plan was stopped: past its time, let go for newer ones, or the server + /// stopping). Audited; the job tells each sequence it changes as sequenceChanged (reorganized) + /// once that sequence's step is journaled (a step that failed half-way, once its folder moved and its index rows followed; a plan the server + /// completes as it starts, no one: no client is connected yet). Photos a sequence receives between the dry run and the + /// confirmation under the names the plan leaves them keep the fingerprint as it was. A dry run's plan is made apart from + /// the request, a few at once and each for a limited time, and kept a few minutes, a refusal too, while what it reads + /// from the index stays as it was (; the sequences' rows, and how many photos of those + /// planned are hashed): the same dry run again (also after the first was cut off), and its confirmation, take it instead + /// of planning again. So plan_changed answers a change the index has, photos a verify hashed among them; one made + /// on disk alone since the dry run (a folder made by hand, a desktop writing to a shared archive before a scan) is found + /// by the job, which then fails and changes nothing. + /// + private static async Task ReorganizeAsync(HttpContext context, Caller caller, ReorganizeRequest request, ChronosDatabase db, ServerArchive archive, + [FromServices] ArchiveService? archives, JobEngineHost host, AuditLog audit, ReorganizePlanCache plans) + { + var ct = context.RequestAborted; + if (request.All == (request.SequenceIds is not null) || request.SequenceIds is { Count: 0 or > LibraryEndpoints.MaxBulkIds }) + return ApiErrors.BadRequest(context, "bad_request", "sequenceIds"); + var templates = new RenameTemplates(request.FolderTemplate, request.FileTemplate, request.TitleTemplate); + if (templates.IsEmpty) return ApiErrors.BadRequest(context, "bad_request", "templates"); + if (templates.Check() is { } problem) return InvalidTemplate(context, problem); + if (!request.DryRun && string.IsNullOrWhiteSpace(request.Fingerprint)) return ApiErrors.BadRequest(context, "bad_request", "fingerprint"); + if (ArchiveService.GetAvailability(archive.Current) != ArchiveAvailability.Online) + return ApiErrors.Result(context, StatusCodes.Status503ServiceUnavailable, "archive_offline"); + var sequences = request.All ? null : request.SequenceIds; + // Stamped before planning: a change committed while the plan is made gives the next request another key. + var key = ReorganizePlanCache.Key.Of(archive.Id, await db.Sequences.GetStampAsync(archive.Id, sequences, ct), sequences, templates); + RenamePlan plan; + try + { + // Made whatever becomes of this request, until the cache stops it: the same request again takes it. + plan = await plans.GetOrPlanAsync(key, stop => LibraryEndpoints.Engine(archives, db).PlanReorganizeAsync(archive.Id, sequences, templates, stop), ct); + } + catch (NestedRenameException ex) + { + return ApiErrors.Conflict(context, "nested_target", ex.Target); + } + catch (ArgumentException) + { + return ApiErrors.NotFound(context, "sequence"); + } + catch (OperationCanceledException) when (!ct.IsCancellationRequested) + { + // Stopped: past its time (a read that hangs), let go for newer plans, or the server stopping. + return ApiErrors.Result(context, StatusCodes.Status503ServiceUnavailable, "plan_dropped"); + } + var fingerprint = plan.Fingerprint(); + if (request.DryRun) return Results.Json(Plan(context, plan, fingerprint), ProtocolJson.Default.ReorganizePlanDto); + if (!string.Equals(fingerprint, request.Fingerprint, StringComparison.Ordinal)) return ApiErrors.Conflict(context, "plan_changed", fingerprint); + if (!host.CanRun(JobKind.Move)) return ApiErrors.Conflict(context, "job_unavailable", JobWire.Kind(JobKind.Move)); + var job = await host.Engine.EnqueueAsync(ArchiveJobs.Reorganize(archive.Current, plan, templates), caller.Id, ct); + plans.Forget(key); + await audit.WriteAsync(caller, context, "archive_reorganized", "job", job.Id.ToString(), + $"{plan.Steps.Count(s => s.Changes)} · {plan.Steps.Sum(s => s.FileChanges)} · {templates.Folder} · {templates.File} · {templates.Title}"); + return Results.Json(Dto.Job(job), ProtocolJson.Default.JobDto, statusCode: StatusCodes.Status202Accepted); + } + + /// + /// 400 invalid_template for a template that cannot be used. The details name its field (fileTemplate); when + /// it parses but breaks a rule of the archive's templates (), the rule follows after a colon + /// (folderTemplate:reserved_folder, fileTemplate:file_separator, fileTemplate:extension, + /// fileTemplate:not_unique) and the message says why in the request's language, as the desktop's fields do + /// (Errors.Template.<Rule>); otherwise the message is that the template is not valid. + /// + private static IResult InvalidTemplate(HttpContext context, TemplateProblem problem) + { + if (problem.Rule is not { } rule) return ApiErrors.BadRequest(context, "invalid_template", problem.Field); + var message = Loc.Get("Errors.Template." + rule, RequestCulture.Of(context)) ?? ApiErrors.Message(context, "invalid_template"); + var wire = string.Concat(rule.Select((c, i) => char.IsUpper(c) ? (i > 0 ? "_" : string.Empty) + char.ToLowerInvariant(c) : c.ToString())); + return Results.Json(new ApiError("invalid_template", message, $"{problem.Field}:{wire}"), ProtocolJson.Default.ApiError, + statusCode: StatusCodes.Status400BadRequest); + } + + /// The dry run as the API answers it, with each reason something stays as it is in the request's language. + private static ReorganizePlanDto Plan(HttpContext context, RenamePlan plan, string fingerprint) + { + var culture = RequestCulture.Of(context); + return new ReorganizePlanDto( + [.. plan.Steps.Select(s => new ReorganizeStepDto(s.SequenceId, s.FromFolder, s.ToFolder, s.FromTitle, s.ToTitle, s.Carried, s.FramesVersion, + s.FileChanges, [.. s.FileSamples.Select(f => new ReorganizeFileDto(f.From, f.To))], + [.. s.Blocked.Select(b => new ReorganizeBlockedDto(Wire(b.Reason), b.Frames, Loc.Get("Archive.Reorganize.Blocked." + b.Reason, culture) ?? Wire(b.Reason)))]))], + plan.Steps.Count(s => s.Changes), + plan.Steps.Sum(s => s.FileChanges), + plan.Steps.Sum(s => s.Blocked.Sum(b => b.Frames)), + fingerprint); + } + + /// + /// Wire name of a reason something stays as it is: photos that keep their names (in_place, unhashed, + /// missing), or the whole sequence (unreadable). + /// + public static string Wire(RenameBlock reason) => reason switch + { + RenameBlock.InPlace => "in_place", + RenameBlock.Unhashed => "unhashed", + RenameBlock.Missing => "missing", + _ => "unreadable", + }; + private static async Task EnqueueAsync(HttpContext context, Caller caller, ServerArchive archive, JobEngineHost host, AuditLog audit, JobKind kind) { if (!host.CanRun(kind)) return ApiErrors.Conflict(context, "job_unavailable", JobWire.Kind(kind)); diff --git a/src/Chronos.Server/Api/FileEndpoints.cs b/src/Chronos.Server/Api/FileEndpoints.cs index 84dbeff8..f6eed718 100644 --- a/src/Chronos.Server/Api/FileEndpoints.cs +++ b/src/Chronos.Server/Api/FileEndpoints.cs @@ -63,7 +63,8 @@ public static class FileEndpoints /// (); the sequence's thumbnails, proxy state and light analysis follow as background jobs. /// 204; 413 too_large; 422 proxy_not_wanted (the server decodes that original itself, or it is missing or /// damaged), invalid_proxy, proxy_mismatch or proxy_too_small, which concern that proxy only; 409 - /// proxies_disabled, which concerns them all; 503 archive_offline. + /// proxies_disabled, which concerns them all; 503 archive_offline, or sequence_busy while another writer + /// holds the sequence (a Reorganize moving its folder) for longer than the lease wait. /// private static async Task StoreProxyAsync(HttpContext context, Guid id, ChronosDatabase db, ServerArchive archive, [FromServices] ArchiveService? archives, SequenceJobs follow) @@ -83,14 +84,20 @@ public static class FileEndpoints ProxyStoreResult result; try { - result = images.StoreProxy(archive.Current, sequence, frame, body.ToArray()); + result = await images.StoreProxyAsync(archive.Current, sequence, frame, body.ToArray(), ct); } catch (ArchiveOfflineException) { return ApiErrors.Result(context, StatusCodes.Status503ServiceUnavailable, "archive_offline"); } + catch (LeaseUnavailableException) + { + return ApiErrors.Result(context, StatusCodes.Status503ServiceUnavailable, "sequence_busy"); + } switch (result) { + case ProxyStoreResult.Gone: + return ApiErrors.NotFound(context, "frame"); case ProxyStoreResult.Disabled: return ApiErrors.Conflict(context, "proxies_disabled"); case ProxyStoreResult.Invalid: diff --git a/src/Chronos.Server/Api/ReorganizePlanCache.cs b/src/Chronos.Server/Api/ReorganizePlanCache.cs new file mode 100644 index 00000000..aee06934 --- /dev/null +++ b/src/Chronos.Server/Api/ReorganizePlanCache.cs @@ -0,0 +1,223 @@ +using Chronos.Core.Archiving; +using Chronos.Data.Repositories; + +namespace Chronos.Server.Api; + +/// +/// Reorganize's dry runs kept a short while (owner review 2, R7): the same dry run asked again, and the confirmation that +/// follows it, take the plan made then instead of reading every sidecar and photo folder of the selection again (with +/// all, of the whole archive), while what the plan reads from the index is as it was then +/// () and for at most once made. A refusal (a folder +/// inside a sequence's, a sequence not in the archive) follows from the same reads, so it is kept as a plan is; a failure +/// is not. A plan is made apart from the request that asked for it, once for every request of the same key: a request cut +/// off meanwhile (a proxy's timeout) leaves it to be made, and the same request again waits for it or takes it. At most +/// plans are made at once; one still being made past , let go for newer +/// ones (), or when the server stops, is stopped, and whoever waits for it is told it was dropped +/// (). A change made on disk alone, which the index does not have, is not seen by a +/// kept plan: the move job plans again and refuses a plan that no longer matches the archive, so nothing changes +/// that the dry run did not show. +/// +public sealed class ReorganizePlanCache : IDisposable +{ + /// How long a plan is kept once made; then its timer lets it go. + public static readonly TimeSpan Lifetime = TimeSpan.FromMinutes(5); + + /// + /// Plans kept or being made at most (each holds a step for every sequence it changes or carries, or whose photos keep + /// their names). One more lets go the kept plan asked for first; with none kept, the plan being made asked for first, + /// which stops. + /// + public const int Capacity = 8; + + /// Plans made at once at most; the others wait for their turn. + public const int Concurrency = 2; + + /// + /// How long a plan may take, from when it was asked (its wait for a turn included): then it stops. A read that hangs + /// still holds its turn until it returns. + /// + public static readonly TimeSpan PlanTimeout = TimeSpan.FromMinutes(15); + + private readonly TimeProvider _time; + private readonly Lock _gate = new(); + private readonly Dictionary _plans = []; + private readonly SemaphoreSlim _turns = new(Concurrency); + private readonly CancellationTokenRegistration _stopping; + private long _order; + + /// The host, whose stopping stops the plans being made. + public ReorganizePlanCache(TimeProvider time, IHostApplicationLifetime? lifetime = null) + { + _time = time; + if (lifetime is not null) _stopping = lifetime.ApplicationStopping.Register(Clear); + } + + /// + /// What a plan is kept by: the archive, the stamp of what it reads from the index, the sequences (all of them, or the ids + /// in the order given, which decides the folder that gets " (2)") and the templates. + /// + public readonly record struct Key(Guid ArchiveId, string Stamp, string Sequences, RenameTemplates Templates) + { + /// The sequences of the request; null for every sequence of the archive. + public static Key Of(Guid archiveId, string stamp, IReadOnlyList? sequenceIds, RenameTemplates templates) => + new(archiveId, stamp, sequenceIds is null ? "*" : string.Join(',', sequenceIds.Select(id => id.ToString("N"))), templates); + } + + /// Plans kept or being made now. + internal int Count + { + get + { + lock (_gate) return _plans.Count; + } + } + + /// + /// The plan kept for , the one being made for it, or the one starts making + /// now, apart from the caller, then kept; stops when its token is cancelled. A refusal + /// (, ) is kept as a plan is; a failure is passed to + /// every caller waiting for it and not kept, and so is a plan stopped (). + /// stops the wait only: the plan is still made, and kept. + /// + public Task GetOrPlanAsync(Key key, Func> plan, CancellationToken cancellationToken = default) + { + ArgumentNullException.ThrowIfNull(plan); + Entry? entry; + bool start; + lock (_gate) + { + // Never past its lifetime, whatever its timer. + if (_plans.TryGetValue(key, out entry) && entry.Made is { } made && _time.GetUtcNow() - made >= Lifetime) Remove(key); + start = !_plans.TryGetValue(key, out entry); + if (start) + { + if (_plans.Count >= Capacity) Remove(_plans.MinBy(p => (p.Value.Made is null, p.Value.Order)).Key); + var asked = new Entry(++_order); + asked.Deadline = _time.CreateTimer(_ => TimeOut(key, asked), null, PlanTimeout, Timeout.InfiniteTimeSpan); + _plans[key] = entry = asked; + } + } + if (start) _ = MakeAsync(key, entry!, plan); + return entry!.Plan.Task.WaitAsync(cancellationToken); + } + + /// Forgets the plan kept for : its job is queued, and what the job changes gives the index another stamp. + public void Forget(Key key) + { + lock (_gate) Remove(key); + } + + public void Dispose() + { + _stopping.Dispose(); + Clear(); + } + + /// Lets every plan go; those being made stop. + private void Clear() + { + lock (_gate) + { + foreach (var key in _plans.Keys.ToList()) Remove(key); + } + } + + private async Task MakeAsync(Key key, Entry entry, Func> plan) + { + var stop = entry.Stop.Token; + RenamePlan? made = null; + Exception? refused = null; + try + { + await _turns.WaitAsync(stop).ConfigureAwait(false); + var making = Task.Run(() => plan(stop), CancellationToken.None); + // The turn ends with the work, also when no one waits for it any more (a read that hangs). + _ = making.ContinueWith(t => + { + _ = t.Exception; + _turns.Release(); + }, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); + made = await making.WaitAsync(stop).ConfigureAwait(false); + } + catch (Exception ex) when (ex is NestedRenameException || ex.GetType() == typeof(ArgumentException)) + { + // A folder inside a sequence's, a sequence not in the archive: what the key holds decides it, as it does a plan. + refused = ex; + } + catch (Exception ex) + { + // A failure, or the plan stopped (past its time, let go, the server stopping): the next request plans again. + lock (_gate) + { + if (_plans.GetValueOrDefault(key) == entry) Remove(key); + } + if (ex is OperationCanceledException canceled) entry.Plan.SetCanceled(canceled.CancellationToken); + else entry.Plan.SetException(ex); + // Observed here: a request cut off before it ended no longer waits for it. + _ = entry.Plan.Task.Exception; + return; + } + lock (_gate) + { + if (_plans.GetValueOrDefault(key) == entry) + { + entry.Made = _time.GetUtcNow(); + entry.Deadline?.Dispose(); + entry.Expiry = _time.CreateTimer(_ => Expire(key, entry), null, Lifetime, Timeout.InfiniteTimeSpan); + } + } + if (refused is null) + { + entry.Plan.SetResult(made!); + return; + } + entry.Plan.SetException(refused); + _ = entry.Plan.Task.Exception; + } + + /// A plan still being made at stops. + private void TimeOut(Key key, Entry entry) + { + lock (_gate) + { + // Made as its deadline fired: kept for its lifetime. + if (_plans.GetValueOrDefault(key) == entry && entry.Made is null) Remove(key); + } + } + + private void Expire(Key key, Entry entry) + { + lock (_gate) + { + if (_plans.GetValueOrDefault(key) == entry) Remove(key); + } + } + + private void Remove(Key key) + { + if (!_plans.Remove(key, out var entry)) return; + entry.Deadline?.Dispose(); + entry.Expiry?.Dispose(); + // Stopped outside this lock: the wait for it ends on the thread pool. + if (entry.Made is null) _ = entry.Stop.CancelAsync(); + } + + /// A plan being made ( null) or kept, and the order it was asked in. + private sealed class Entry(long order) + { + public long Order { get; } = order; + + public TaskCompletionSource Plan { get; } = new(TaskCreationOptions.RunContinuationsAsynchronously); + + /// Stops the plan while it is made; a source with no timer and no parent, so nothing to release. + public CancellationTokenSource Stop { get; } = new(); + + public DateTimeOffset? Made { get; set; } + + /// Stops the plan at while it is made. + public ITimer? Deadline { get; set; } + + /// Lets the plan go at once made. + public ITimer? Expiry { get; set; } + } +} diff --git a/src/Chronos.Server/Hosting/ServerHost.cs b/src/Chronos.Server/Hosting/ServerHost.cs index 21cf2c2e..8dc65b71 100644 --- a/src/Chronos.Server/Hosting/ServerHost.cs +++ b/src/Chronos.Server/Hosting/ServerHost.cs @@ -142,6 +142,7 @@ public static class ServerHost services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); + services.AddSingleton(); services.AddSingleton(); services.AddSingleton(); services.AddHostedService(sp => sp.GetRequiredService()); diff --git a/src/Chronos.Server/Jobs/RenderNodeService.cs b/src/Chronos.Server/Jobs/RenderNodeService.cs index 3e0e7e90..8118e3da 100644 --- a/src/Chronos.Server/Jobs/RenderNodeService.cs +++ b/src/Chronos.Server/Jobs/RenderNodeService.cs @@ -1,5 +1,6 @@ using System.Globalization; using System.Text.Json; +using Chronos.Core.Archiving; using Chronos.Core.Model; using Chronos.Data; using Chronos.Data.Jobs; @@ -175,7 +176,16 @@ public sealed class RenderNodeService( if (await uploads.StageVerifiedAsync(upload, cancellationToken) is not { } staged) return Outcome.Fail(422, "hash_mismatch"); var output = JsonSerializer.Deserialize(upload.RenderJson, ProtocolJson.Default.RenderResultRequest)!; var sequence = await db.Sequences.GetAsync(job.TargetIds[0], cancellationToken); - var render = sequence is null ? null : await renders.CommitAsync(sequence, staged, output, node.ClientName, cancellationToken); + Render? render; + try + { + render = sequence is null ? null : await renders.CommitAsync(sequence, staged, output, node.ClientName, cancellationToken); + } + catch (Exception ex) when (ex is LeaseUnavailableException or ArchiveOfflineException or FolderMovedException) + { + // The node keeps the job and completes again. + return await uploads.ReceiveAgainAsync(upload, staged, ex); + } if (render is null) { UploadStore.TryDelete(staged); diff --git a/src/Chronos.Server/Storage/ArchiveModule.cs b/src/Chronos.Server/Storage/ArchiveModule.cs index 0f7aaf94..6e00c265 100644 --- a/src/Chronos.Server/Storage/ArchiveModule.cs +++ b/src/Chronos.Server/Storage/ArchiveModule.cs @@ -3,14 +3,17 @@ using Chronos.Data; using Chronos.Data.Archiving; using Chronos.Data.Housekeeping; using Chronos.Data.Jobs; +using Chronos.Protocol; using Chronos.Server.Configuration; +using Chronos.Server.Events; namespace Chronos.Server.Storage; /// /// The archive engine behind the server (BRIEF §7, §14.4): ingest of verified uploads, lookup of proxies and /// thumbnails, and its job handlers (scan, rebuild, verify, import, thumbnails, proxies, maintenance, the duplicates and -/// orphans reports, index backups and clean-ups with the server's own steps, the s in DI); a scan +/// orphans reports, index backups and clean-ups with the server's own steps, the s in DI, and Reorganize's +/// move jobs, which tell connected clients of the sequences they change); a scan /// queues thumbnails and proxies of what it indexes, as an upload does. Decoding is managed only (BRIEF §4.2). Recurring /// work (the periodic scan, the nightly backup of an SQLite index, clean-ups) is queued by the server's system schedules /// (, owner review 2, R10). @@ -25,9 +28,17 @@ public static class ArchiveModule services.AddSingleton(sp => { var options = sp.GetRequiredService(); + var db = sp.GetRequiredService(); + var events = sp.GetRequiredService(); // Photos the running job processes at once: the settings' value as it is when each sequence starts (owner review 1). - return new ArchiveService(sp.GetRequiredService(), new ArchiveServiceOptions + return new ArchiveService(db, new ArchiveServiceOptions { + // A Reorganize tells connected clients of every sequence it changed (BRIEF §14.3). + SequenceChanged = async (id, change, ct) => + { + if (await db.Sequences.GetAsync(id, ct) is { } sequence) + events.Publish(new SequenceChangedEvent(id, change, sequence.FramesVersion, sequence.SettingsVersion)); + }, Decoder = DecoderFactory.CreateServer(), Owner = Owner, ImagesAfterScan = true, diff --git a/src/Chronos.Server/Storage/RenderStore.cs b/src/Chronos.Server/Storage/RenderStore.cs index f77a5713..d5a7aed1 100644 --- a/src/Chronos.Server/Storage/RenderStore.cs +++ b/src/Chronos.Server/Storage/RenderStore.cs @@ -1,47 +1,64 @@ +using Chronos.Core.Archiving; using Chronos.Core.IO; +using Chronos.Core.Localization; using Chronos.Core.Model; using Chronos.Data; +using Chronos.Data.Archiving; using Chronos.Protocol; namespace Chronos.Server.Storage; /// Files a verified render output under the sequence's exports/ folder (BRIEF §7) and records it. -public sealed class RenderStore(ChronosDatabase db, ServerArchive archive, TimeProvider time) +/// The archive engine whose sequence lease the filing takes; one of its own when none is registered. +public sealed class RenderStore(ChronosDatabase db, ServerArchive archive, TimeProvider time, ArchiveService? archives = null) { + private readonly ArchiveService _archives = archives ?? new ArchiveService(db, new ArchiveServiceOptions { Owner = ArchiveModule.Owner }); + /// /// Moves (on the archive volume) to <sequence folder>/exports/, never - /// replacing an existing export, and inserts the render row. Null when the sequence has no folder in the archive yet. + /// replacing an existing export, and inserts the render row, both under the sequence's lease with its folder as the + /// index has it then: a Reorganize may have moved it since was read, and moves the row's + /// path along when it moves it later. Null when the sequence left the index or has no folder in the archive yet; nothing + /// is moved then. /// + /// The sequence is not in the folder the index has (another index moved it, and + /// maybe another sequence into that folder): nothing is moved, and the filing can be done again once this index's next + /// scan found the folder. public Task CommitAsync(Sequence sequence, string stagedFile, RenderResultRequest output, string producedBy, CancellationToken cancellationToken) => CommitAsync(sequence, stagedFile, output, producedBy, Guid.CreateVersion7(), cancellationToken); /// As above, keeping : a render a client sends keeps the id it has on that client. - public async Task CommitAsync(Sequence sequence, string stagedFile, RenderResultRequest output, string producedBy, Guid id, - CancellationToken cancellationToken) - { - if (string.IsNullOrEmpty(sequence.Folder) || ArchivePathGuard.Resolve(archive.Root, sequence.Folder.TrimEnd('/') + "/exports") is not { } exports) - return null; - Directory.CreateDirectory(exports); - var target = Unique(exports, output.FileName); - File.Move(stagedFile, target); - var render = new Render + /// The sequence is not in the folder the index has. + public Task CommitAsync(Sequence sequence, string stagedFile, RenderResultRequest output, string producedBy, Guid id, + CancellationToken cancellationToken) => + _archives.UnderLeaseAsync(sequence, async row => { - Id = id, - SequenceId = sequence.Id, - PresetName = output.PresetName, - OutputPath = LongPath.ToPortableRelative(archive.Root, target), - Codec = output.Codec, - Width = output.Width, - Height = output.Height, - Fps = output.Fps, - DurationSeconds = output.DurationSeconds, - Bytes = output.Size, - Created = time.GetUtcNow(), - ProducedBy = producedBy, - }; - await db.Renders.InsertAsync(render, cancellationToken); - return render; - } + if (row is null || string.IsNullOrEmpty(row.Folder) || ArchivePathGuard.Resolve(archive.Root, row.Folder.TrimEnd('/') + "/exports") is not { } exports) + return null; + // A folder another index moved is found by this index's next scan; until then nothing is filed, so it is not created + // again, nor filed among the exports of another sequence that index moved into it since. + if (!SequenceFolders.Holds(new ArchivePaths(archive.Root).Sequence(row.Folder), row.Id)) throw new FolderMovedException(); + Directory.CreateDirectory(exports); + var target = Unique(exports, output.FileName); + File.Move(stagedFile, target); + var render = new Render + { + Id = id, + SequenceId = row.Id, + PresetName = output.PresetName, + OutputPath = LongPath.ToPortableRelative(archive.Root, target), + Codec = output.Codec, + Width = output.Width, + Height = output.Height, + Fps = output.Fps, + DurationSeconds = output.DurationSeconds, + Bytes = output.Size, + Created = time.GetUtcNow(), + ProducedBy = producedBy, + }; + await db.Renders.InsertAsync(render, cancellationToken); + return (Render?)render; + }, cancellationToken); private static string Unique(string folder, string fileName) { @@ -52,3 +69,9 @@ public sealed class RenderStore(ChronosDatabase db, ServerArchive archive, TimeP return candidate; } } + +/// +/// A sequence is not in the folder the index has (another index of the archive moved it): nothing was filed into it, and +/// this index's next scan finds the folder, after which the filing can be done again. +/// +public sealed class FolderMovedException() : IOException(Loc.L("Errors.Archive.FolderMoved")); diff --git a/src/Chronos.Server/Storage/RenderUploads.cs b/src/Chronos.Server/Storage/RenderUploads.cs index 02e2214d..80e55955 100644 --- a/src/Chronos.Server/Storage/RenderUploads.cs +++ b/src/Chronos.Server/Storage/RenderUploads.cs @@ -1,5 +1,7 @@ using System.Globalization; using System.Text.Json; +using Chronos.Core.Archiving; +using Chronos.Core.Model; using Chronos.Data; using Chronos.Data.Repositories; using Chronos.Protocol; @@ -87,8 +89,16 @@ public sealed class RenderUploads( var sequence = await db.Sequences.GetAsync(sequenceId, cancellationToken); var result = new RenderResultRequest(output.FileName, output.Size, output.Sha256, output.PresetName, output.Codec, output.Width, output.Height, output.Fps, output.DurationSeconds); - var render = sequence is null ? null : await renders.CommitAsync(sequence, staged, result, output.ProducedBy ?? caller.ClientName ?? caller.User.Username, - output.RenderId, cancellationToken); + Render? render; + try + { + render = sequence is null ? null : await renders.CommitAsync(sequence, staged, result, output.ProducedBy ?? caller.ClientName ?? caller.User.Username, + output.RenderId, cancellationToken); + } + catch (Exception ex) when (ex is LeaseUnavailableException or ArchiveOfflineException or FolderMovedException) + { + return await uploads.ReceiveAgainAsync(upload, staged, ex); + } if (render is null) { UploadStore.TryDelete(staged); diff --git a/src/Chronos.Server/Storage/UploadService.cs b/src/Chronos.Server/Storage/UploadService.cs index f3468b48..1455256d 100644 --- a/src/Chronos.Server/Storage/UploadService.cs +++ b/src/Chronos.Server/Storage/UploadService.cs @@ -1,6 +1,7 @@ using System.Collections.Concurrent; using System.Globalization; using Microsoft.AspNetCore.Http.Features; +using Chronos.Core.Archiving; using Chronos.Data; using Chronos.Data.Archiving; using Chronos.Data.Repositories; @@ -303,6 +304,27 @@ public sealed class UploadService( return null; } + /// + /// A verified upload whose filing was refused before anything moved, for a reason that passes: its sequence held by + /// another writer past the lease wait (503 sequence_busy), the archive offline or read-only (503 + /// archive_offline), or the sequence's folder not where the index has it until this index's next scan (503 + /// folder_moved, ). The staged copy goes and the upload receives again with its + /// part file, so the client completes it again, as it does after any 503. + /// + public async Task> ReceiveAgainAsync(Upload upload, string staged, Exception refusal) + { + ArgumentNullException.ThrowIfNull(upload); + logger.LogWarning("Upload {Upload} ({File}) not filed for now: {Reason}", upload.Id, upload.FileName, refusal.Message); + UploadStore.TryDelete(staged); + await db.Uploads.TryTransitionAsync(upload.Id, UploadState.Committing, UploadState.Receiving, cancellationToken: CancellationToken.None); + return Fail(503, refusal switch + { + ArchiveOfflineException => "archive_offline", + FolderMovedException => "folder_moved", + _ => "sequence_busy", + }); + } + private async Task FailAsync(Upload upload) { await db.Uploads.TryTransitionAsync(upload.Id, UploadState.Committing, UploadState.Failed, cancellationToken: CancellationToken.None); diff --git a/src/Chronos.Ui/Controls/Toasts.cs b/src/Chronos.Ui/Controls/Toasts.cs index dc1ad5c7..3d21c0b5 100644 --- a/src/Chronos.Ui/Controls/Toasts.cs +++ b/src/Chronos.Ui/Controls/Toasts.cs @@ -29,6 +29,11 @@ public sealed class Toast : ObservableObject /// before they have read why. /// public bool RunsFromNotification { get; init; } + + /// The toast left the screen: dismissed, timed out, pushed out by newer ones or closed by its action. + public event EventHandler? Closed; + + internal void OnClosed() => Closed?.Invoke(this, EventArgs.Empty); } /// @@ -78,8 +83,9 @@ public class ToastHost : ItemsControl { if (_timers.Remove(toast, out var timer)) timer.Stop(); var hadFocus = IsKeyboardFocusWithin; - Toasts.Remove(toast); + var removed = Toasts.Remove(toast); if (hadFocus && !IsKeyboardFocusWithin && _returnFocus is UIElement { IsVisible: true } previous) previous.Focus(); + if (removed) toast.OnClosed(); } /// Moves the keyboard to the newest toast's first control; false when no toast is shown. diff --git a/tests/Chronos.App.Tests/Archive/ArchiveLogicTests.cs b/tests/Chronos.App.Tests/Archive/ArchiveLogicTests.cs index e6570b36..cb5cf339 100644 --- a/tests/Chronos.App.Tests/Archive/ArchiveLogicTests.cs +++ b/tests/Chronos.App.Tests/Archive/ArchiveLogicTests.cs @@ -225,28 +225,23 @@ public sealed class ArchiveLogicTests } [Test] - public void RenameTemplatesAreCheckedAndThePlanListedByMode() + public void PlannedTitlesAndFoldersAreListedAsReorganizeRows() { - Assert.Null(MassRename.Validate(RenameMode.Titles, "{title} · {camera}")); - Assert.NotNull(MassRename.Validate(RenameMode.Titles, "{title")); - Assert.NotNull(MassRename.Validate(RenameMode.Titles, " ")); - Assert.Null(MassRename.Validate(RenameMode.Folders, "{year}/{date} {title}")); - Assert.NotNull(MassRename.Validate(RenameMode.Folders, "{nope}")); - var a = Seq("Harbour", new DateTime(2026, 9, 28)); var b = Seq("Comet", new DateTime(2026, 8, 13)); var subjects = new[] { a, b }.Select(s => new RenameSubject(s.Id, s.Folder, s.Title, s.FirstCapture, "Canon", "Canon EOS R5", null)).ToList(); var titles = RenamePlanner.Plan(Main.Id, subjects, null, "{title} · {camera}", subjects.Select(s => s.Folder), _ => false); - var rows = MassRename.Rows(titles, RenameMode.Titles); - Assert.Equal("Harbour", rows[0].From); - Assert.Equal("Harbour · Canon EOS R5", rows[0].To); - Assert.Equal("2 of 5 change", MassRename.Summary(titles, 5)); + var retitled = ReorganizePlans.Rows(titles).Select(r => r.Lines.Single()).ToList(); + Assert.SequenceEqual(new[] { "Harbour>Harbour · Canon EOS R5", "Comet>Comet · Canon EOS R5" }, retitled.Select(l => $"{l.From}>{l.To}")); + Assert.False(retitled.Any(l => l.IsPath), "titles read in the language's direction"); + Assert.Equal("2 of 5 change", ReorganizePlans.Summary(titles, 5)); Assert.Empty(RenamePlanner.Plan(Main.Id, subjects, "{year}/{title}", null, subjects.Select(s => s.Folder), _ => false).Steps); var folders = RenamePlanner.Plan(Main.Id, subjects, "{year}/{date} {title}", null, subjects.Select(s => s.Folder), _ => false); - var moves = MassRename.Rows(folders, RenameMode.Folders); - Assert.SequenceEqual(new[] { "2026/Harbour", "2026/Comet" }, moves.Select(r => r.From)); - Assert.SequenceEqual(new[] { "2026/2026-09-28 Harbour", "2026/2026-08-13 Comet" }, moves.Select(r => r.To)); + var moves = ReorganizePlans.Rows(folders).Select(r => r.Lines.Single()).ToList(); + Assert.SequenceEqual(new[] { "2026/Harbour", "2026/Comet" }, moves.Select(l => l.From)); + Assert.SequenceEqual(new[] { "2026/2026-09-28 Harbour", "2026/2026-08-13 Comet" }, moves.Select(l => l.To)); + Assert.True(moves.All(l => l.IsPath), "folders read left to right"); } [Test] diff --git a/tests/Chronos.App.Tests/Archive/ArchiveScreenSmokeTests.cs b/tests/Chronos.App.Tests/Archive/ArchiveScreenSmokeTests.cs index be34d062..a6e091de 100644 --- a/tests/Chronos.App.Tests/Archive/ArchiveScreenSmokeTests.cs +++ b/tests/Chronos.App.Tests/Archive/ArchiveScreenSmokeTests.cs @@ -94,17 +94,18 @@ public sealed class ArchiveScreenSmokeTests Assert.Equal(0, ((SolidColorBrush)frame.Background).Color.A, "the disabled tree keeps its panel's fill instead of the system's white"); AssertNoErrorShown(app); - await ArchiveScenes.ShowAsync(app.Shell, "move"); - var move = Assert.NotNull(archive.Dialog as RenameDialogViewModel); - Assert.NotEmpty(move.Rows, "the dry run lists the folders that change"); - Assert.Null(move.ErrorText); - await app.ExpectAsync("archive-move"); - Assert.True(ButtonFor(app, move.ApplyCommand).IsEnabled, "Apply follows the dry run"); - Assert.True(ButtonFor(app, move.CloseCommand).IsDefault, "Enter takes the safe way out"); + await ArchiveScenes.ShowAsync(app.Shell, "reorganize"); + var reorganize = Assert.NotNull(archive.Dialog as ReorganizeDialogViewModel); + Assert.NotEmpty(reorganize.Rows, "the dry run lists the sequences that change"); + Assert.Null(reorganize.ErrorText); + await app.ExpectAsync("archive-reorganize"); + Assert.True(ButtonFor(app, reorganize.ApplyCommand).IsEnabled, "Apply follows the dry run"); + Assert.True(ButtonFor(app, reorganize.CloseCommand).IsDefault, "Enter takes the safe way out"); + foreach (var box in app.FindAll().Where(c => c.IsVisible)) Assert.NotNull(box.ToolTip, "every template switch says what it does"); AssertNoErrorShown(app); AssertEveryButtonIsNamed(app); - move.CloseCommand.Execute(null); + reorganize.CloseCommand.Execute(null); archive.RetagSetCommand.Execute(null); var retag = Assert.NotNull(archive.Dialog as RetagDialogViewModel); retag.Add.Text = "sunset"; @@ -134,14 +135,15 @@ public sealed class ArchiveScreenSmokeTests await app.ExpectAsync("archive-rebuild-ar"); Assert.Equal(FlowDirection.LeftToRight, TextFor(app, archive.SelectedArchive!.RootPath).FlowDirection, "the archive folder reads left to right"); - await ArchiveScenes.ShowAsync(app.Shell, "move"); - var move = Assert.NotNull(archive.Dialog as RenameDialogViewModel); - await app.ExpectAsync("archive-move-ar"); - var template = Assert.NotNull(app.FindAll().FirstOrDefault(t => t.IsVisible && EditBehavior.GetField(t) == move.Template)); + await ArchiveScenes.ShowAsync(app.Shell, "reorganize"); + var reorganize = Assert.NotNull(archive.Dialog as ReorganizeDialogViewModel); + await app.ExpectAsync("archive-reorganize-ar"); + var template = Assert.NotNull(app.FindAll().FirstOrDefault(t => t.IsVisible && EditBehavior.GetField(t) == reorganize.Folders.Field)); Assert.Equal(FlowDirection.LeftToRight, template.FlowDirection, "the naming template reads left to right"); - Assert.Equal(FlowDirection.LeftToRight, TextFor(app, move.Rows[0].From).FlowDirection, "a folder before the move reads left to right"); - Assert.Equal(FlowDirection.LeftToRight, TextFor(app, move.Rows[0].To).FlowDirection, "a folder after the move reads left to right"); - move.CloseCommand.Execute(null); + var folder = reorganize.Rows.SelectMany(r => r.Lines).First(l => l.IsPath); + Assert.Equal(FlowDirection.LeftToRight, TextFor(app, folder.From).FlowDirection, "a folder before the move reads left to right"); + Assert.Equal(FlowDirection.LeftToRight, TextFor(app, folder.To).FlowDirection, "a folder after the move reads left to right"); + reorganize.CloseCommand.Execute(null); } finally { diff --git a/tests/Chronos.App.Tests/Archive/ReorganizeDialogTests.cs b/tests/Chronos.App.Tests/Archive/ReorganizeDialogTests.cs new file mode 100644 index 00000000..7ebdce48 --- /dev/null +++ b/tests/Chronos.App.Tests/Archive/ReorganizeDialogTests.cs @@ -0,0 +1,405 @@ +using System.Globalization; +using System.IO; +using System.Security.Cryptography; +using System.Text.Json; +using Chronos.App.Archiving; +using Chronos.App.DesignTime; +using Chronos.App.Infrastructure; +using Chronos.App.Shell; +using Chronos.App.Tests.Import; +using Chronos.App.Tests.Uploader; +using Chronos.App.Tests.Windows; +using Chronos.Core.Archiving; +using Chronos.Core.Localization; +using Chronos.Core.Model; +using Chronos.Data; +using Chronos.Data.Archiving; +using Chronos.Data.Archiving.Jobs; +using Chronos.Data.Jobs; +using Chronos.Testing; +using Chronos.Ui.Controls; + +namespace Chronos.App.Tests.Archiving; + +/// +/// Reorganize… (owner review 2, R7): each template with its switch, the dry run listed sequence by sequence, and Apply +/// queuing the job of exactly the plan on screen, which the job then applies. +/// +public sealed class ReorganizeDialogTests(TestContext context) +{ + private static readonly DateTime Start = new(2026, 9, 28, 18, 0, 0); + + [Test] + public void EachTemplateIsCheckedAsItsPartIsNamed() + { + Loc.SetCulture(CultureInfo.GetCultureInfo("en")); + Assert.Null(ReorganizePlans.Validate(ReorganizeParts.Folders, "{year}/{date} {title}")); + Assert.NotNull(ReorganizePlans.Validate(ReorganizeParts.Folders, "{nope}")); + Assert.Null(ReorganizePlans.Validate(ReorganizeParts.Files, "{date}_{n:000}")); + Assert.Equal(Loc.L("Errors.Template.FileSeparator"), ReorganizePlans.Validate(ReorganizeParts.Files, "{year}/{n}"), "a file name has no folder"); + Assert.Equal(Loc.L("Errors.Template.NotUnique"), ReorganizePlans.Validate(ReorganizeParts.Files, "{date}"), "file names tell the photos apart"); + Assert.Null(ReorganizePlans.Validate(ReorganizeParts.Titles, "{title} · {camera}")); + Assert.Null(ReorganizePlans.Validate(ReorganizeParts.Titles, "{date}"), "every photo of a sequence shares its title"); + Assert.NotNull(ReorganizePlans.Validate(ReorganizeParts.Titles, "{title")); + foreach (var part in new[] { ReorganizeParts.Folders, ReorganizeParts.Files, ReorganizeParts.Titles }) + Assert.Equal(Loc.L("Errors.Template.Empty", string.Empty, 1), ReorganizePlans.Validate(part, " "), part.ToString()); + } + + [Test] + public void TheDryRunIsListedSequenceBySequence() + { + Loc.SetCulture(CultureInfo.GetCultureInfo("en")); + var moved = new RenameStep(Guid.CreateVersion7(), "2026/Harbour", "2026/2026-09-28 Harbour", "Harbour", "Harbour sunset") + { + FramesVersion = 3, + FileChanges = 120, + FileSamples = + [ + new FileRename(Guid.CreateVersion7(), "originals/IMG_0001.JPG", "originals/Harbour sunset_001.JPG"), + new FileRename(Guid.CreateVersion7(), "originals/IMG_0002.JPG", "originals/Harbour sunset_002.JPG"), + ], + Blocked = [new RenameBlocked(RenameBlock.Unhashed, 12)], + }; + var carried = new RenameStep(Guid.CreateVersion7(), "2026/Harbour/Night", "2026/2026-09-28 Harbour/Night", null, null, Carried: true); + var kept = new RenameStep(Guid.CreateVersion7(), "2025/Comet", "2025/Comet", "Comet", "Comet") { Blocked = [new RenameBlocked(RenameBlock.Unreadable, 0)] }; + var plan = new RenamePlan(Guid.CreateVersion7(), Guid.CreateVersion7(), [moved, kept, carried]) + { + FileTemplate = "{title}_{n:000}", + Subjects = [moved.SequenceId, kept.SequenceId], + }; + + var rows = ReorganizePlans.Rows(plan); + + Assert.Count(3, rows); + var first = rows[0]; + Assert.Equal("Harbour sunset", first.Name); + Assert.False(first.IsNamePath, "a title reads in the language's direction"); + Assert.Equal(Loc.Plural("Archive.Reorganize.Renamed", 120), first.Note); + Assert.SequenceEqual( + [ + $"{Loc.L("Archive.Reorganize.Folder")}|2026/Harbour|2026/2026-09-28 Harbour|True", + $"{Loc.L("Archive.Reorganize.Title")}|Harbour|Harbour sunset|False", + $"{Loc.L("Archive.Reorganize.File")}|originals/IMG_0001.JPG|originals/Harbour sunset_001.JPG|True", + $"{Loc.L("Archive.Reorganize.File")}|originals/IMG_0002.JPG|originals/Harbour sunset_002.JPG|True", + ], + first.Lines.Select(l => $"{l.Label}|{l.From}|{l.To}|{l.IsPath}")); + Assert.SequenceEqual([Loc.L("Archive.Reorganize.Blocked.Unhashed") + Loc.Separator + Loc.Plural("Shell.Status.Photos", 12)], first.Kept); + Assert.Contains(Loc.L("Archive.Reorganize.Change", Loc.L("Archive.Reorganize.Folder"), "2026/Harbour", "2026/2026-09-28 Harbour"), first.Description); + Assert.Contains(first.Kept[0], first.Description); + + var comet = rows[1]; + Assert.Empty(comet.Lines, "nothing of it changes"); + Assert.SequenceEqual([Loc.L("Archive.Reorganize.Blocked.Unreadable")], comet.Kept, "an unreadable sidecar has no photo count"); + Assert.False(comet.HasNote); + + var night = rows[2]; + Assert.Equal("2026/2026-09-28 Harbour/Night", night.Name, "without a title, the row is named by its folder"); + Assert.True(night.IsNamePath); + Assert.Equal(Loc.L("Archive.Reorganize.Carried"), night.Note); + + // A sequence carried along is listed, not counted; the names kept are the photos', not the sequences'. + Assert.Equal(1, ReorganizePlans.Changed(plan)); + Assert.Equal(string.Join(Loc.Separator, Loc.Plural("Archive.Rename.Summary", 1, 2), Loc.Plural("Archive.Reorganize.Renamed", 120), + Loc.Plural("Archive.Reorganize.Kept", 12)), ReorganizePlans.Summary(plan, 2)); + Assert.Equal(Loc.Plural("Archive.Rename.Summary", 1, 2), ReorganizePlans.Summary(plan with { FileTemplate = null, Steps = [moved with { Blocked = [] }] }, 2), + "no file template, no file count; nothing kept, nothing said"); + } + + [Test] + public void TemplatesChangedWhileTheToastIsUpJoinItsOffer() + { + var main = new Core.Model.Archive { Id = Guid.CreateVersion7(), Name = "Main", RootPath = "/archive" }; + var other = new Core.Model.Archive { Id = Guid.CreateVersion7(), Name = "Other", RootPath = "/other" }; + var offer = new ReorganizeOffer(TimeSpan.FromSeconds(8)); + var now = new DateTime(2026, 10, 27, 9, 0, 0, DateTimeKind.Utc); + + Assert.True(offer.Add(main, ReorganizeParts.Folders, now), "the first change raises the toast"); + var saved = main with { FileTemplate = "{date}_{n:000}" }; + Assert.False(offer.Add(saved, ReorganizeParts.Files, now.AddSeconds(5)), "a change while it is up joins it"); + Assert.Equal((saved, ReorganizeParts.Folders | ReorganizeParts.Files), offer.Take(main.Id), "both templates, the archive as saved last"); + Assert.Null(offer.Take(main.Id), "a second toast of the same offer finds it taken"); + + Assert.True(offer.Add(main, ReorganizeParts.Folders, now.AddSeconds(6)), "once taken, the next change raises a toast again"); + Assert.True(offer.Add(other, ReorganizeParts.Files, now.AddSeconds(7)), "another archive has its own toast"); + Assert.Equal((other, ReorganizeParts.Files), offer.Take(other.Id)); + Assert.True(offer.Add(other, ReorganizeParts.Files, now.AddSeconds(8))); + Assert.True(offer.Add(other, ReorganizeParts.Folders, now.AddSeconds(17)), "the toast is gone: a new one"); + + // Each toast takes its own archive's offer: the older toast of Main opens Main, not the Other changed since. + Assert.Equal((main, ReorganizeParts.Folders), offer.Take(main.Id)); + Assert.Equal((other, ReorganizeParts.Files | ReorganizeParts.Folders), offer.Take(other.Id), "Other's offer stayed for its own toast"); + Assert.Null(offer.Take(main.Id)); + } + + [Test] + public void AToastGoneEarlyLetsTheNextChangeRaiseItsOwn() + { + var main = new Core.Model.Archive { Id = Guid.CreateVersion7(), Name = "Main", RootPath = "/archive" }; + var offer = new ReorganizeOffer(TimeSpan.FromSeconds(8)); + var now = new DateTime(2026, 10, 27, 9, 0, 0, DateTimeKind.Utc); + + Assert.True(offer.Add(main, ReorganizeParts.Folders, now)); + offer.Closed(main.Id, now); + Assert.True(offer.Add(main, ReorganizeParts.Files, now.AddSeconds(2)), "dismissed after a second: the next change has a toast of its own"); + Assert.False(offer.Add(main, ReorganizeParts.Titles, now.AddSeconds(3)), "and joins it while it is up"); + offer.Closed(main.Id, now); + Assert.False(offer.Add(main, ReorganizeParts.Titles, now.AddSeconds(4)), "an older toast leaving changes nothing for the one up"); + Assert.Equal((main, ReorganizeParts.Folders | ReorganizeParts.Files | ReorganizeParts.Titles), offer.Take(main.Id), + "the toast up offers every change since the last one taken"); + offer.Closed(main.Id, now.AddSeconds(2)); + Assert.Null(offer.Take(main.Id), "the toast closing after its action finds nothing to keep"); + } + + /// + /// The toasts' host says when a toast leaves the screen, as Settings › Archive needs to know whether its offer is still + /// up: dismissed, pushed out by three newer ones, timed out or closed by its action, once each. + /// + [Test] + [WindowsOnly] + public void AToastLeavingTheScreenSaysSoOnce() => WpfApplication.Dispatcher.Invoke(() => + { + var host = new ToastHost(); + var closed = new List(); + Toast Show(string title) + { + var toast = new Toast { Title = title }; + toast.Closed += (_, _) => closed.Add(title); + host.Show(toast); + return toast; + } + + var first = Show("first"); + var second = Show("second"); + host.Dismiss(second); + host.Dismiss(second); + Assert.SequenceEqual(["second"], closed, "dismissed, once"); + Show("third"); + Show("fourth"); + Assert.Empty(closed.Skip(1), "three on screen"); + Show("fifth"); + Assert.SequenceEqual(["second", "first"], closed, "the oldest pushed out by a fourth"); + host.Dismiss(first); + Assert.Count(2, closed, "a toast gone already says nothing"); + foreach (var toast in host.Toasts.ToList()) host.Dismiss(toast); + }); + + [Test] + public async Task SwitchesChooseTheTemplatesAndApplyQueuesExactlyThatPlan() + { + Loc.SetCulture(CultureInfo.GetCultureInfo("en")); + var directory = context.CreateTempDirectory("reorganize-dialog"); + await using var db = await ChronosDatabase.OpenAsync(DatabaseOptions.Sqlite(Path.Combine(directory, "index.db")), context.Cancellation); + var archives = new ArchiveService(db, new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(TestTiming.Budget(20)) }); + var archive = await archives.CreateAsync(Path.Combine(directory, "archive"), "Main", cancellationToken: context.Cancellation); + var harbour = await UploadAsync(archives, archive, "harbour", Start, 1); + var comet = await UploadAsync(archives, archive, "comet", Start.AddDays(1), 11); + var (before, title) = (await db.Sequences.GetAsync(harbour)) is { } filed ? (filed.Folder, filed.Title ?? string.Empty) : default; + + var queued = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var closed = false; + using var dialog = new ReorganizeDialogViewModel(archives, archive, [harbour, comet], ReorganizePlans.Layout, request => + { + queued.TrySetResult(request); + return Task.CompletedTask; + }, _ => closed = true); + + // From the mass bar: the archive's layout, folders and file names, prefilled from its settings. + Assert.True(dialog.Folders.IsEnabled); + Assert.True(dialog.Files.IsEnabled); + Assert.False(dialog.Titles.IsEnabled); + Assert.Equal(new RenameTemplates(archive.FolderTemplate, archive.FileTemplate), dialog.Current()); + Assert.Equal(Loc.Plural("Archive.Reorganize.Heading", 2), dialog.Heading); + await dialog.PlanAsync(); + Assert.Empty(dialog.Rows, "photos filed with the archive's templates already follow them"); + Assert.Equal(Loc.L("Archive.Blocked.NoChanges"), dialog.ApplyToolTip); + Assert.False(dialog.ApplyCommand.CanExecute(null)); + + // A template switched off neither counts nor blocks with its errors; switched on, its error does. + dialog.Titles.Field.Text = "{title"; + Assert.Null(dialog.Titles.Error); + Assert.Null(dialog.Current()!.Title); + dialog.Titles.IsEnabled = true; + Assert.NotNull(dialog.Titles.Error); + Assert.Null(dialog.Current()); + Assert.Equal(dialog.Titles.Error, dialog.ApplyToolTip); + dialog.Titles.IsEnabled = false; + dialog.Folders.IsEnabled = false; + dialog.Files.IsEnabled = false; + Assert.Null(dialog.Current()); + Assert.Equal(Loc.L("Archive.Blocked.NoTemplate"), dialog.ApplyToolTip); + Assert.False(dialog.ApplyCommand.CanExecute(null)); + + dialog.Folders.IsEnabled = true; + dialog.Folders.Field.Text = "{year}/{date}"; + dialog.Titles.Field.Text = "Shoot {date}"; + dialog.Titles.IsEnabled = true; + Assert.Equal(Loc.L("Archive.Blocked.Planning"), dialog.ApplyToolTip, "the dry run on screen is not the one of the templates typed"); + await dialog.PlanAsync(); + + var plan = Assert.NotNull(dialog.Plan); + Assert.Count(2, dialog.Rows); + var row = dialog.Rows.Single(r => r.SequenceId == harbour); + Assert.Equal("Shoot 2026-09-28", row.Name); + Assert.SequenceEqual([$"{before}>2026/2026-09-28", $"{title}>Shoot 2026-09-28"], row.Lines.Select(l => $"{l.From}>{l.To}"), "folders and titles, no file names"); + Assert.Equal(Loc.Plural("Archive.Rename.Summary", 2, 2), dialog.SummaryText); + Assert.Null(plan.FileTemplate); + Assert.True(dialog.ApplyCommand.CanExecute(null)); + + // Typing again: Apply waits for the dry run of what is on screen; Enter plans it at once. + dialog.Folders.Field.Text = "{year}/{date} {title}"; + Assert.Null(dialog.Plan); + Assert.False(dialog.ApplyCommand.CanExecute(null)); + Assert.True(dialog.Folders.Field.Commit()); + Assert.Equal(Loc.L("Archive.Reorganize.Planning"), dialog.BusyText, "a template changed since its dry run plans without waiting for the typing to pause"); + dialog.Folders.Field.Text = "{year}/{date}"; + await dialog.PlanAsync(); + plan = Assert.NotNull(dialog.Plan); + + // A click on Apply takes the focus from the field first, which commits it: the dry run on screen is of that text + // already, so no other one starts and Apply stays on under the click. + Assert.True(dialog.Folders.Field.IsDirty, "typed, not committed"); + Assert.True(dialog.Folders.Field.Commit()); + Assert.Same(plan, dialog.Plan); + Assert.Null(dialog.BusyText); + Assert.True(dialog.ApplyCommand.CanExecute(null)); + + dialog.ApplyCommand.Execute(null); + var request = await queued.Task.WaitAsync(TimeSpan.FromSeconds(TestTiming.Budget(20))); + await UntilAsync(() => closed); + Assert.Equal(JobKind.Move, request.Kind); + Assert.SequenceEqual([archive.Id], request.Targets); + Assert.Equal(archive.Name, request.Label); + Assert.Equal(JobPriority.User, request.Priority); + using (var parameters = JsonDocument.Parse(request.ParametersJson!)) + { + var json = parameters.RootElement; + Assert.Equal("{year}/{date}", json.GetProperty("folderTemplate").GetString()); + Assert.Equal("Shoot {date}", json.GetProperty("titleTemplate").GetString()); + Assert.False(json.TryGetProperty("fileTemplate", out var file) && file.ValueKind != JsonValueKind.Null, "the file names were switched off"); + Assert.Equal(plan.Fingerprint(), json.GetProperty("fingerprint").GetString()); + } + Assert.Equal(before, (await db.Sequences.GetAsync(harbour))!.Folder, "the job reorganizes, not the dialog"); + + // The job applies the plan the dialog showed. + await using var engine = new JobEngine(db, archives.CreateJobHandlers(), + new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) }); + await engine.StartAsync(context.Cancellation); + var job = await engine.EnqueueAsync(request, cancellationToken: context.Cancellation); + await WaitForAsync(db, job.Id); + var after = (await db.Sequences.GetAsync(harbour))!; + Assert.Equal(("2026/2026-09-28", "Shoot 2026-09-28"), (after.Folder, after.Title)); + Assert.True(Directory.Exists(Path.Combine(archive.RootPath, "2026", "2026-09-28"))); + } + + /// + /// The Settings toast's Reorganize… is reached from another screen while the Archive screen may have a dialog open (a + /// Delete moving sequences, the trash): that dialog is neither replaced nor stopped. Reorganize says it waits, and + /// opens once that dialog closes, on every sequence with every part the toasts offered meanwhile. + /// + [Test] + [WindowsOnly] + public void TheToastsReorganizeWaitsForTheDialogOpenOnTheArchiveScreen() + { + Loc.SetCulture(CultureInfo.GetCultureInfo("en")); + var environment = AppEnvironment.ForCapture(); + try + { + SingleThreadedContext.Run(async () => + { + var services = new AppServices(environment, new AppSettings { Language = "en", FirstRunCompleted = true }, () => { }, new NoDialogs()); + var sample = SampleData.Configure(services); + await sample.OpenEmptyAsync(); + await sample.FillAsync(); + var shell = new ShellViewModel(services); + try + { + var toasts = new List(); + shell.PendingToasts.CollectionChanged += (_, e) => toasts.AddRange(e.NewItems?.OfType() ?? []); + var screen = shell.Archive; + await screen.LoadAsync(); + var archive = Assert.NotNull(screen.SelectedArchive); + await screen.OpenTrashAsync(); + var trash = Assert.NotNull(screen.Dialog as TrashDialogViewModel); + + await screen.OpenReorganizeAllAsync(archive with { FileTemplate = "{date}_{n:0000}" }, ReorganizeParts.Files); + await screen.OpenReorganizeAllAsync(archive, ReorganizeParts.Folders); + Assert.Same(trash, screen.Dialog); + Assert.Equal(Loc.L("Archive.Reorganize.Waiting"), toasts[^1].Title); + + trash.CloseCommand.Execute(null); + await UntilAsync(() => screen.Dialog is ReorganizeDialogViewModel); + var reorganize = (ReorganizeDialogViewModel)screen.Dialog!; + await UntilAsync(() => reorganize.BusyText is null); + Assert.Null(reorganize.ErrorText); + Assert.Equal(Loc.L("Archive.Reorganize.HeadingAll", archive.Name), reorganize.Heading); + Assert.True(reorganize.Folders.IsEnabled, "the parts of both toasts"); + Assert.True(reorganize.Files.IsEnabled); + Assert.False(reorganize.Titles.IsEnabled); + Assert.Equal(archive.FileTemplate, reorganize.Files.Field.Text, "the archive's templates as the index holds them when it opens"); + reorganize.CloseCommand.Execute(null); + Assert.Null(screen.Dialog); + } + finally + { + shell.Dispose(); + await services.DisposeAsync(); + } + }); + } + finally + { + environment.DeleteCaptureData(); + } + } + + /// Dialogs that answer like a user who cancels everything. + private sealed class NoDialogs : IAppDialogs + { + public string? PickFolder(string title, string? initialFolder = null) => null; + public string? PickJsonFile(string title) => null; + public bool Confirm(ConfirmRequest request) => false; + public bool SignIn(string server, string? username, Func> signIn) => false; + } + + /// Uploads two photos ten seconds apart into a new sequence filed with the archive's templates; returns its id. + private async Task UploadAsync(ArchiveService archives, Core.Model.Archive archive, string key, DateTime start, int seed) + { + Guid id = default; + var staging = Path.Combine(new ArchivePaths(archive.RootPath).StagingDirectory, "uploads"); + Directory.CreateDirectory(staging); + for (var i = 0; i < 2; i++) + { + var bytes = ImportTestData.Jpeg(start.AddSeconds(10 * i), seed + i); + var path = Path.Combine(staging, $"{Guid.NewGuid():N}.part"); + await File.WriteAllBytesAsync(path, bytes, context.Cancellation); + var request = new IngestRequest(archive.Id, null, null, key, path, $"IMG_{seed + i:0000}.JPG", bytes.Length, Convert.ToHexStringLower(SHA256.HashData(bytes)), + null, null); + id = (await archives.Ingest.CommitAsync(request, context.Cancellation)).SequenceId; + } + return id; + } + + private async Task WaitForAsync(ChronosDatabase db, Guid jobId) + { + var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(30)); + Job? job = null; + while (DateTime.UtcNow < until) + { + job = await db.Jobs.GetAsync(jobId, context.Cancellation); + if (job?.State == JobState.Done) return; + if (job?.State is JobState.Failed or JobState.Cancelled) Assert.Fail($"The reorganize job ended {job.State}: {job.Error}\n{job.LogTail}"); + await Task.Delay(20, context.Cancellation); + } + Assert.Fail($"The reorganize job did not finish (now {job?.State})."); + } + + private static async Task UntilAsync(Func condition) + { + var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(20)); + while (!condition()) + { + Assert.True(DateTime.UtcNow < until, "timed out"); + await Task.Delay(20); + } + } +} diff --git a/tests/Chronos.App.Tests/Editor/EditorSmokeTests.cs b/tests/Chronos.App.Tests/Editor/EditorSmokeTests.cs index 8ee354e5..76b0d6b9 100644 --- a/tests/Chronos.App.Tests/Editor/EditorSmokeTests.cs +++ b/tests/Chronos.App.Tests/Editor/EditorSmokeTests.cs @@ -330,6 +330,59 @@ public sealed class EditorSmokeTests } }); + /// + /// A Reorganize of this PC moves the folder of the sequence open in the editor: the editor reads it again where it is + /// now as soon as its step is done, so its frames decode and its project goes there. + /// + [Test] + public Task AnOpenSequenceIsReadAgainWhereAReorganizeMovedIt() => ScreenHost.RunAsync(async () => + { + await using var app = await ScreenSmokeTests.SampleApp.StartAsync(); + var id = await app.Sample.FillEditorAsync(); + var db = app.Services.Database!; + var archives = app.Services.Archives!; + var source = new LocalSequenceSource(db, id, Chronos.Core.Imaging.Decoders.DecoderFactory.CreateClient(null), null); + var content = await source.LoadAsync(CancellationToken.None); + var editor = new EditorViewModel(app.Shell, new EditorSession(source, content, []), [], EncoderHost.Client); + await using (editor) + { + var archive = (await db.Archives.GetAsync(content.Sequence.ArchiveId))!; + var templates = new Chronos.Core.Archiving.RenameTemplates("Moved/{date}"); + var plan = await archives.PlanReorganizeAsync(archive.Id, [id], templates, CancellationToken.None); + var moved = plan.Steps.Single().ToFolder; + await using var engine = new Chronos.Data.Jobs.JobEngine(db, archives.CreateJobHandlers(), new Chronos.Data.Jobs.JobEngineOptions + { + WorkerId = "test", + Kinds = [JobKind.Move], + PollInterval = TimeSpan.FromMilliseconds(50), + }); + await engine.StartAsync(CancellationToken.None); + var job = await Chronos.Data.Archiving.ArchiveJobs.EnqueueAsync(engine, Chronos.Data.Archiving.ArchiveJobs.Reorganize(archive, plan, templates)); + // The editor reads its photos as it opens; on Windows the folder cannot move while one is open, and the job that + // failed holds the plan for its retry. + for (var attempt = 1; ; attempt++) + { + Job? ended = null; + for (var i = 0; i < 1200 && ended is null; i++) + { + await Task.Delay(25); + if (await db.Jobs.GetAsync(job.Id) is { State: JobState.Done or JobState.Failed or JobState.Cancelled } now) ended = now; + } + Assert.NotNull(ended, "the move job ends"); + if (ended!.State == JobState.Done) break; + Assert.True(ended.State == JobState.Failed && attempt < 20, ended.Error); + await Task.Delay(250); + await engine.ResumeAsync(job.Id, CancellationToken.None); + } + + for (var i = 0; i < 400 && editor.Session.Content.Sequence.Folder != moved; i++) await Task.Delay(25); + Assert.Equal(moved, editor.Session.Content.Sequence.Folder); + Assert.True(await source.FramesCurrentAsync(CancellationToken.None), "the editor holds the frames where they are now"); + using var frame = await source.DecodeAsync(0, 32, Chronos.Core.Imaging.DecodePurpose.Thumbnail, CancellationToken.None); + Assert.NotNull(frame, "its frames decode"); + } + }); + /// /// At the 1200 px minimum beside the 200 px rail (owner review 1, R1), the preview's tools stay inside the preview in /// every language, crop mask on (the crop-result tool enabled): they take a second line rather than lose Play and Full screen. diff --git a/tests/Chronos.App.Tests/Editor/ProjectStoreTests.cs b/tests/Chronos.App.Tests/Editor/ProjectStoreTests.cs index 9074b9f7..6539be00 100644 --- a/tests/Chronos.App.Tests/Editor/ProjectStoreTests.cs +++ b/tests/Chronos.App.Tests/Editor/ProjectStoreTests.cs @@ -215,6 +215,44 @@ public sealed class ProjectStoreTests(TestContext context) } } + [Test] + public async Task AnEditorOpenWhileAReorganizeMovesItsFolderSavesWhereTheSequenceIsNow() + { + var (db, sequenceId, root) = await ArchiveAsync(6); + await using (db) + { + var options = new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }; + await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, options); + var content = await source.LoadAsync(context.Cancellation); + var session = new EditorSession(source, content, [], TimeSpan.FromMilliseconds(20)); + await using (session) + { + Assert.True(session.SetHero(2)); + Assert.True(await session.FlushAsync()); + + // Only the folder template changed: the Reorganize moves the folder and keeps the frames version. + var service = new ArchiveService(db, options); + var plan = await service.PlanRenameAsync(content.Sequence.ArchiveId, [sequenceId], "Moved/{title}", null, context.Cancellation); + await service.ApplyRenameAsync(plan, null, context.Cancellation); + var moved = new ArchivePaths(root).Sequence(plan.Steps.Single().ToFolder); + Assert.Equal(content.Sequence.FramesVersion, (await db.Sequences.GetAsync(sequenceId))!.FramesVersion); + Assert.False(await source.FramesCurrentAsync(context.Cancellation), "the files are no longer where the editor read them"); + + session.Edit(p => p with { Exposure = p.Exposure with { ExposureOffsetEv = 0.4 } }); + Assert.True(await session.FlushAsync()); + + var row = (await db.Sequences.GetAsync(sequenceId))!; + Assert.Equal(0.4, ProjectSettings.FromJson(row.SettingsJson!).Exposure.ExposureOffsetEv); + Assert.Equal(row.SettingsJson, File.ReadAllText(moved.ProjectPath), "the moved folder's project has the edit"); + Assert.False(Directory.Exists(Path.Combine(root, "Synthetic")), "the folder it left is not created again"); + Assert.True(await source.FramesCurrentAsync(context.Cancellation)); + Assert.Equal(moved.Exports, session.Content.ExportsFolder); + using var frame = await source.DecodeAsync(1, 32, DecodePurpose.Thumbnail, context.Cancellation); + Assert.NotNull(frame, "the frames are read where they are now"); + } + } + } + [Test] public async Task ASaveThatDoesNotReachTheIndexThrows() { @@ -230,6 +268,54 @@ public sealed class ProjectStoreTests(TestContext context) } } + [Test] + public async Task ASaveAfterAnotherIndexMovedTheFolderWritesNothing() + { + var (db, sequenceId, root) = await ArchiveAsync(4); + await using (db) + { + await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, + new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }); + var content = await source.LoadAsync(context.Cancellation); + + // A server sharing the archive moved the folder; this index finds it there at its next scan. + var left = Path.Combine(root, "Synthetic"); + Directory.Move(left, Path.Combine(root, "Moved")); + var gone = await Assert.ThrowsAsync(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation)); + + Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + Assert.Equal(content.Sequence.SettingsVersion, (await db.Sequences.GetAsync(sequenceId))!.SettingsVersion, "nothing recorded"); + } + } + + [Test] + public async Task ASaveNeverWritesIntoAnotherSequenceMovedIntoTheFolder() + { + var (db, sequenceId, root) = await ArchiveAsync(4); + await using (db) + { + await using var source = new LocalSequenceSource(db, sequenceId, DecoderFactory.CreateClient(null), null, + new ArchiveServiceOptions { Owner = "test", LeaseWait = TimeSpan.FromSeconds(20) }); + var content = await source.LoadAsync(context.Cancellation); + + // A server sharing the archive moved the folder away, then another sequence into the folder it left; this index + // finds both at its next scan. + var paths = new ArchivePaths(root); + Directory.Move(paths.Sequence("Synthetic").Folder, paths.Sequence("Moved").Folder); + var stranger = paths.Sequence("Synthetic"); + Directory.CreateDirectory(stranger.MetaDirectory); + ManifestStore.WriteSequence(stranger.ManifestPath, ManifestStore.ReadSequence(paths.Sequence("Moved").ManifestPath) with { Id = Guid.NewGuid() }); + const string theirs = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":7}}}"""; + await File.WriteAllTextAsync(stranger.ProjectPath, theirs, context.Cancellation); + var gone = await Assert.ThrowsAsync(() => source.SaveProjectAsync(content.Project with { HeroFrame = 1 }, content.Project, context.Cancellation)); + + Assert.Equal(Loc.L("Editor.Error.Missing"), gone.Message); + Assert.Equal(theirs, await File.ReadAllTextAsync(stranger.ProjectPath, context.Cancellation), "the other sequence's project is untouched"); + Assert.Equal(content.Sequence.SettingsVersion, (await db.Sequences.GetAsync(sequenceId))!.SettingsVersion, "nothing recorded"); + } + } + [Test] public async Task JobsGoToTheEngine() { diff --git a/tests/Chronos.App.Tests/Infrastructure/ErrorTextTests.cs b/tests/Chronos.App.Tests/Infrastructure/ErrorTextTests.cs index 7840b050..9f56e5d7 100644 --- a/tests/Chronos.App.Tests/Infrastructure/ErrorTextTests.cs +++ b/tests/Chronos.App.Tests/Infrastructure/ErrorTextTests.cs @@ -2,9 +2,11 @@ using System.Globalization; using System.IO; using System.Net; using System.Net.Http; +using Chronos.App.Infrastructure; using Chronos.App.Shell; using Chronos.Core.Archiving; using Chronos.Core.Localization; +using Chronos.Data.Archiving; using Chronos.Protocol; using Chronos.Protocol.Client; using Chronos.Testing; @@ -60,4 +62,15 @@ public sealed class ErrorTextTests Assert.Equal("Something went wrong.", ErrorText.For(new IOException(@"Access to the path 'D:\Archive' is denied."))); Assert.Equal(@"The archive D:\Shoots is read-only.", ErrorText.For(new ArchiveOfflineException(@"D:\Shoots", ArchiveAvailability.ReadOnly))); } + + [Test] + public void ATemplateAnArchiveRefusesSaysTheRuleItBreaks() + { + // A new archive with this PC's templates, one saved before the rules existed: the toast says what to change. + var refused = new TemplateRuleException("fileTemplate", "NotUnique"); + const string Sentence = "Names would repeat: add the frame number, the time or the original name."; + Assert.Equal(Sentence, ErrorText.For(refused)); + Assert.Equal(Sentence, ArchiveActions.Cause(refused)); + Assert.Equal("Something went wrong.", ArchiveActions.Cause(new ArgumentException("The archive setting name is invalid.", "name"))); + } } diff --git a/tests/Chronos.App.Tests/Library/LibraryScreenSmokeTests.cs b/tests/Chronos.App.Tests/Library/LibraryScreenSmokeTests.cs index 0b3aeeb7..04d8498e 100644 --- a/tests/Chronos.App.Tests/Library/LibraryScreenSmokeTests.cs +++ b/tests/Chronos.App.Tests/Library/LibraryScreenSmokeTests.cs @@ -58,7 +58,7 @@ public sealed class LibraryScreenSmokeTests await LibraryScenes.ShowAsync(app.Shell, "mass"); Assert.Equal(LibraryScenes.MassSelection, library.SelectionCount); await app.ExpectAsync("library-mass", waitForThumbnails: true); - foreach (var command in new[] { library.AnalyseCommand, library.ProxiesCommand, library.VerifyCommand, library.TagCommand, library.MoveCommand, + foreach (var command in new[] { library.AnalyseCommand, library.ProxiesCommand, library.VerifyCommand, library.TagCommand, library.ReorganizeCommand, library.ExportListCommand, library.DeleteCommand }) Assert.True(ButtonFor(app, command).IsEnabled, "the bar's archive actions work on sequences of this PC"); Assert.True(library.CanRate); diff --git a/tests/Chronos.App.Tests/Library/MassActionsTests.cs b/tests/Chronos.App.Tests/Library/MassActionsTests.cs index 9f1ed47a..c5e38232 100644 --- a/tests/Chronos.App.Tests/Library/MassActionsTests.cs +++ b/tests/Chronos.App.Tests/Library/MassActionsTests.cs @@ -65,7 +65,7 @@ public sealed class MassActionsTests var remote = Remote("Sunrise over Superga"); SelectedSequence[] mixed = [harbour, remote]; - foreach (var action in new[] { MassAction.Analyse, MassAction.Proxies, MassAction.Verify, MassAction.Tag, MassAction.Rate, MassAction.Move, MassAction.Delete }) + foreach (var action in new[] { MassAction.Analyse, MassAction.Proxies, MassAction.Verify, MassAction.Tag, MassAction.Rate, MassAction.Reorganize, MassAction.Delete }) { Assert.Null(MassActions.Blocker(action, mixed, SignedIn), action.ToString()); Assert.SequenceEqual([harbour], MassActions.Targets(action, mixed, SignedIn), action.ToString()); @@ -76,11 +76,21 @@ public sealed class MassActionsTests } [Test] - public void MoveStaysInsideOneArchive() + public void ReorganizeStaysInsideOneArchive() { SelectedSequence[] two = [Only("Harbour sunset"), new(Local("Aurora", Guid.CreateVersion7()), null)]; - Assert.Equal(Loc.L("Library.Blocked.Archives"), MassActions.Blocker(MassAction.Move, two, Offline)); + Assert.Equal(Loc.L("Library.Blocked.OneArchive"), MassActions.Blocker(MassAction.Reorganize, two, Offline)); Assert.Null(MassActions.Blocker(MassAction.Delete, two, Offline), "the trash of each archive takes its own sequences"); + + // A server card in the selection is left out: the archive of the sequences here is still one. + var remote = Remote("Sunrise over Superga"); + SelectedSequence[] withCard = [two[0], Only("Comet"), remote]; + Assert.Null(MassActions.Blocker(MassAction.Reorganize, withCard, SignedIn)); + Assert.SequenceEqual(withCard[..2], MassActions.Targets(MassAction.Reorganize, withCard, SignedIn)); + Assert.Equal(Loc.L("Library.Blocked.ServerOnly"), MassActions.Blocker(MassAction.Reorganize, [remote], SignedIn)); + Assert.Equal(Loc.L("Library.Blocked.NoIndex"), MassActions.Blocker(MassAction.Reorganize, [two[0]], new SelectionContext(HasEngine: false, IsSignedIn: false, default)), + "the dry run and the job need the engine"); + Assert.Equal(Loc.Plural("Tooltips.Library.Mass.Reorganize", 2), MassActions.ToolTip(MassAction.Reorganize, 2)); } [Test] diff --git a/tests/Chronos.App.Tests/Settings/SettingsLogicTests.cs b/tests/Chronos.App.Tests/Settings/SettingsLogicTests.cs index 97223f09..3d48219f 100644 --- a/tests/Chronos.App.Tests/Settings/SettingsLogicTests.cs +++ b/tests/Chronos.App.Tests/Settings/SettingsLogicTests.cs @@ -37,6 +37,8 @@ public sealed class SettingsLogicTests [Case("{date}", "Errors.Template.NotUnique", "", 0)] [Case("{year}/{n}", "Errors.Template.FileSeparator", "", 0)] [Case("{date:%}_{n}", "Errors.Template.Format", "", 0)] + [Case("{n}{ext}", "Errors.Template.Extension", "", 0)] + [Case("{title}_{ext}", "Errors.Template.Extension", "", 0)] public void InvalidFileTemplatesExplainTheProblem(string template, string key, string token, int position) { var expected = position > 0 ? Loc.L(key, token, position) : Loc.L(key); @@ -56,6 +58,18 @@ public sealed class SettingsLogicTests { Assert.Null(NamingPreview.Validate("{year}/{month}/{camera}", isFolder: true)); Assert.Equal("2026/09/Canon EOS R5/IMG_4211.CR2", NamingPreview.FirstNames("{year}/{month}/{camera}", "{name}")[0]); + Assert.Null(NamingPreview.Validate("{name}.{ext}", isFolder: false)); + } + + [Theory] + [Case("Originals/{year}")] + [Case("{year}/exports")] + [Case(".archive/{date}")] + [Case("{year}/.chronos")] + public void FolderTemplatesScansWouldSkipAreRefused(string template) + { + Assert.Equal(Loc.L("Errors.Template.ReservedFolder"), NamingPreview.Validate(template, isFolder: true), template); + Assert.Empty(NamingPreview.FirstNames(template, TemplateDefaults.File)); } [Test] diff --git a/tests/Chronos.Core.Tests/Archiving/LeaseFileTests.cs b/tests/Chronos.Core.Tests/Archiving/LeaseFileTests.cs index 9280b5e5..49ba2025 100644 --- a/tests/Chronos.Core.Tests/Archiving/LeaseFileTests.cs +++ b/tests/Chronos.Core.Tests/Archiving/LeaseFileTests.cs @@ -70,9 +70,12 @@ public sealed class LeaseFileTests(TestContext context) var duration = TimeSpan.FromSeconds(TestTiming.Budget(0.3)); using var lease = LeaseFile.TryAcquire(locks, "seq-1", "server", duration); Assert.NotNull(lease); + var first = LeaseFile.Read(lease.Path)!.Expires; await Task.Delay(duration * 3); Assert.True(lease.IsHeld); - Assert.Greater((LeaseFile.Read(lease.Path)!.Expires - DateTimeOffset.UtcNow).TotalMilliseconds, 0); + // Renewed: the expiry moved on. Whether it is still ahead of the clock at this instant depends on when the last + // timer ran, which a busy runner can delay by a few milliseconds past it. + Assert.Greater((LeaseFile.Read(lease.Path)!.Expires - first).TotalMilliseconds, duration.TotalMilliseconds); Assert.Null(LeaseFile.TryAcquire(locks, "seq-1", "client", duration)); } diff --git a/tests/Chronos.Core.Tests/Archiving/ReorganizeTests.cs b/tests/Chronos.Core.Tests/Archiving/ReorganizeTests.cs new file mode 100644 index 00000000..ab9c1676 --- /dev/null +++ b/tests/Chronos.Core.Tests/Archiving/ReorganizeTests.cs @@ -0,0 +1,774 @@ +using System.Text; +using Chronos.Core.Archiving; +using Chronos.Core.Naming; +using Chronos.Testing; + +namespace Chronos.Core.Tests.Archiving; + +/// Reorganize (owner review 2, R7): file names planned from a template, and the two-phase renames of a sequence's files. +[Category("archive")] +public sealed class ReorganizeTests(TestContext context) +{ + private static readonly DateTime Start = new(2026, 9, 28, 18, 0, 0); + + /// Frames in index order, every one hashed, ten seconds apart. + private static SequenceManifest Sequence(params string[] files) => new() + { + Id = Guid.NewGuid(), + Camera = new SidecarCamera { Make = "Canon", Model = "Canon EOS R5" }, + Versions = new ManifestVersions { Frames = 4 }, + Frames = [.. files.Select((f, i) => new SidecarFrame + { + Id = Guid.NewGuid(), + I = i, + File = f, + Original = $"IMG_{i + 1:0000}{Path.GetExtension(f)}", + Sha256 = new string((char)('a' + i % 6), 64), + CapturedAt = Start.AddSeconds(10 * i), + })], + }; + + private static FileRenamePlan Plan(SequenceManifest manifest, string template, string? title = null, IEnumerable? extra = null) => + FileRenames.Plan(manifest, title, PathTemplate.Parse(template), [.. manifest.Frames.Select(f => f.File), .. extra ?? []]); + + [Test] + public void FramesAreNamedInIndexOrderAndNamesTakenGetNumbersAsFilingDoes() + { + var manifest = Sequence("originals/c.JPG", "originals/a.JPG", "originals/b.JPG", "originals/d.JPG"); + var plan = Plan(manifest, "{date}"); + Assert.SequenceEqual(["originals/2026-09-28.JPG", "originals/2026-09-28_2.JPG", "originals/2026-09-28_3.JPG", "originals/2026-09-28_4.JPG"], + plan.Moves.Select(m => m.To)); + Assert.SequenceEqual(manifest.Frames.Select(f => f.Id), plan.Moves.Select(m => m.FrameId)); + Assert.Equal(4, plan.Frames); + Assert.SequenceEqual(plan.Moves.Take(FileRenames.SampleCount), plan.Samples); + Assert.Empty(plan.Blocked); + } + + [Test] + public void AChainOfNamesIsPlannedAndAFileNoFrameListsKeepsItsName() + { + // Frame 1 now holds the name frame 0 gets, frame 2 the one frame 1 gets: 2→1, 3→2, 4→3. A file no frame lists holds "4". + var manifest = Sequence("originals/2.JPG", "originals/3.JPG", "originals/4.JPG"); + var plan = Plan(manifest, "{n:0}"); + Assert.SequenceEqual(["originals/2.JPG>originals/1.JPG", "originals/3.JPG>originals/2.JPG", "originals/4.JPG>originals/3.JPG"], + plan.Moves.Select(m => $"{m.From}>{m.To}")); + + var stray = Plan(manifest, "{n:0}", extra: ["originals/1.jpg", "originals/notes.txt"]); + Assert.Equal("originals/1_2.JPG", stray.Moves[0].To); + } + + [Test] + public void PhotosInPlaceUnhashedOrMissingKeepTheirNamesAndHoldThem() + { + var manifest = Sequence("IMG_0001.JPG", "originals/IMG_0002.JPG", "originals/IMG_0003.JPG", "originals/IMG_0004.JPG"); + manifest = manifest with { Frames = [manifest.Frames[0], manifest.Frames[1] with { Sha256 = null }, manifest.Frames[2], manifest.Frames[3]] }; + // The third photo is not on disk; the fourth would take its name. + var plan = FileRenames.Plan(manifest, "IMG_0003", PathTemplate.Parse("{title}"), ["IMG_0001.JPG", "originals/IMG_0002.JPG", "originals/IMG_0004.JPG"]); + Assert.SequenceEqual([(RenameBlock.InPlace, 1), (RenameBlock.Unhashed, 1), (RenameBlock.Missing, 1)], plan.Blocked.Select(b => (b.Reason, b.Frames))); + Assert.Equal("originals/IMG_0004.JPG>originals/IMG_0003_2.JPG", plan.Moves.Select(m => $"{m.From}>{m.To}").Single()); + Assert.Equal(1, plan.Frames); + } + + [Test] + public void CompanionsFollowTheirPhotoAndTheirNamesAreKeptFree() + { + var manifest = Sequence("originals/A.CR2", "originals/B.CR2"); + var plan = Plan(manifest, "{n:0000}", extra: ["originals/A.xmp", "originals/B.CR2.xmp", "originals/0001.xmp"]); + // "0001.xmp" belongs to no frame: the first photo, whose companion would take it, gets the next free name. + Assert.SequenceEqual(["originals/A.CR2>originals/0001_2.CR2", "originals/A.xmp>originals/0001_2.xmp", + "originals/B.CR2>originals/0002.CR2", "originals/B.CR2.xmp>originals/0002.CR2.xmp"], plan.Moves.Select(m => $"{m.From}>{m.To}")); + Assert.SequenceEqual([false, true, false, true], plan.Moves.Select(m => m.Companion)); + Assert.Equal(2, plan.Frames); + Assert.Count(2, plan.Samples); + } + + [Test] + public void TheTrashAndReorganizeFindTheSameCompanionsWhateverTheirCase() + { + var sequence = Folder(out _); + var manifest = Sequence("originals/A.CR2", "originals/B.CR2"); + foreach (var file in new[] { "originals/A.CR2", "originals/B.CR2", "originals/a.XMP", "originals/b.cr2.Xmp", "originals/c.xmp" }) Write(sequence, file, file); + var present = FileRenames.ListPresent(sequence, manifest); + var plan = FileRenames.Plan(manifest, null, PathTemplate.Parse("{n:0000}"), present); + Assert.SequenceEqual(["originals/A.CR2>originals/0001.CR2", "originals/a.XMP>originals/0001.XMP", "originals/B.CR2>originals/0002.CR2", + "originals/b.cr2.Xmp>originals/0002.cr2.Xmp"], plan.Moves.Select(m => $"{m.From}>{m.To}")); + var index = new FrameCompanions.Index(sequence); + Assert.SequenceEqual(["originals/a.XMP"], index.Of("originals/A.CR2")); + Assert.SequenceEqual(["originals/b.cr2.Xmp"], index.Of("originals/B.CR2")); + Assert.SequenceEqual(plan.Moves.Where(m => m.Companion).Select(m => m.From), manifest.Frames.SelectMany(f => FrameCompanions.Of(sequence, f.File))); + } + + [Test] + public void NamesGivenOnceStayAsTheyAre() + { + var manifest = Sequence("originals/x.JPG", "originals/y.JPG"); + var plan = Plan(manifest, "{date}_{n:000}"); + var renamed = FileRenameJournal.Applied(manifest, FileRenameJournal.Create(manifest.Versions.Frames, plan.Moves, "t"))!; + Assert.Equal(manifest.Versions.Frames + 1, renamed.Versions.Frames); + Assert.SequenceEqual(manifest.Frames.Select(f => f.Id), renamed.Frames.Select(f => f.Id)); + Assert.Empty(Plan(renamed, "{date}_{n:000}").Moves); + Assert.Null(FileRenameJournal.Applied(renamed, FileRenameJournal.Create(manifest.Versions.Frames, plan.Moves, "t"))); + } + + [Test] + public void APlanWithAFileTemplateCountsSamplesAndListsWhatKeepsItsName() + { + var renamed = Sequence("originals/a.JPG", "originals/b.JPG"); + var adopted = Sequence("a.JPG"); + var subjects = new[] + { + new RenameSubject(renamed.Id, "s/one", "Trip", Start, "Canon", "Canon EOS R5", null) { Files = new SequenceFiles(renamed, [.. renamed.Frames.Select(f => f.File)]) }, + new RenameSubject(adopted.Id, "s/two", "Adopted", Start, "Canon", "Canon EOS R5", null) { Files = new SequenceFiles(adopted, ["a.JPG"]) }, + new RenameSubject(Guid.NewGuid(), "s/three", null, Start, "Canon", "Canon EOS R5", null), + }; + var plan = RenamePlanner.Plan(Guid.NewGuid(), subjects, null, "{title} 2026", ["s/one", "s/two", "s/three"], _ => false, fileTemplate: "{title}_{n:00}"); + Assert.Equal("{title}_{n:00}", plan.FileTemplate); + Assert.SequenceEqual(subjects.Select(s => s.SequenceId), plan.Subjects); + var one = plan.Steps.Single(s => s.SequenceId == renamed.Id); + Assert.Equal((2, 4), (one.FileChanges, one.FramesVersion)); + // The new title names the files. + Assert.SequenceEqual(["originals/Trip 2026_01.JPG", "originals/Trip 2026_02.JPG"], one.FileSamples.Select(f => f.To)); + var two = plan.Steps.Single(s => s.SequenceId == adopted.Id); + Assert.Equal((0, 0), (two.FileChanges, two.FramesVersion)); + Assert.Equal((RenameBlock.InPlace, 1), (two.Blocked.Single().Reason, two.Blocked.Single().Frames)); + Assert.True(two.Changes, "its title changes"); + var three = plan.Steps.Single(s => s.SequenceId == subjects[2].SequenceId); + Assert.Equal(RenameBlock.Unreadable, three.Blocked.Single().Reason); + + // Nothing but kept names: listed, changes nothing. + var keptOnly = RenamePlanner.Plan(Guid.NewGuid(), [subjects[1]], null, null, ["s/two"], _ => false, fileTemplate: "{n}"); + Assert.False(keptOnly.Steps.Single().Changes); + } + + [Test] + public void FoldersTheTemplateGaveAlreadyStayAndASecondRunPlansNothing() + { + // Two sequences of one day filed by the template, the second beside the first; a third elsewhere, a fourth whose + // folder differs only in case, a fifth with a number filing never gives. + const string Template = "{year}/{date} {title}"; + RenameSubject At(string folder) => new(Guid.NewGuid(), folder, "Sunset", Start, null, null, null); + RenameSubject[] subjects = [At("2026/2026-09-28 Sunset"), At("2026/2026-09-28 Sunset (2)"), At("inbox/c"), At("2026/2026-09-28 sunset (4)"), + At("2026/2026-09-28 Sunset (03)")]; + var plan = RenamePlanner.Plan(Guid.NewGuid(), subjects, Template, null, subjects.Select(s => s.Folder), _ => false); + Assert.SequenceEqual([(subjects[2].SequenceId, "2026/2026-09-28 Sunset (3)"), (subjects[3].SequenceId, "2026/2026-09-28 Sunset (4)"), + (subjects[4].SequenceId, "2026/2026-09-28 Sunset (5)")], plan.Steps.Select(s => (s.SequenceId, s.ToFolder))); + + // Where the plan put them, the same template changes nothing. + var moved = plan.Steps.ToDictionary(s => s.SequenceId, s => s.ToFolder); + RenameSubject[] after = [.. subjects.Select(s => moved.TryGetValue(s.SequenceId, out var to) ? s with { Folder = to } : s)]; + var onDisk = after.Select(s => s.Folder).ToHashSet(StringComparer.OrdinalIgnoreCase); + Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), after, Template, null, onDisk, onDisk.Contains).Steps); + // Nor in another order. + Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), [.. after.Reverse()], Template, null, onDisk, onDisk.Contains).Steps); + } + + [Test] + public void TheFingerprintFollowsWhatThePlanChanges() + { + var manifest = Sequence("originals/a.JPG"); + RenamePlan Make(SequenceManifest m) => RenamePlanner.Plan(Guid.NewGuid(), [new RenameSubject(m.Id, "s", "T", Start, null, null, null) + { Files = new SequenceFiles(m, [.. m.Frames.Select(f => f.File)]) }], null, null, ["s"], _ => false, fileTemplate: "{n:000}"); + var plan = Make(manifest); + Assert.Equal(64, plan.Fingerprint().Length); + Assert.Equal(plan.Fingerprint(), Make(manifest).Fingerprint()); + // A photo received since under the name the plan gives it raises the frames version only: the plan is the one shown. + var received = manifest with + { + Versions = new ManifestVersions { Frames = 5 }, + Frames = [.. manifest.Frames, manifest.Frames[0] with { Id = Guid.NewGuid(), I = 1, File = "originals/002.JPG", CapturedAt = Start.AddSeconds(10) }], + }; + Assert.Equal(plan.Fingerprint(), Make(received).Fingerprint()); + // One the plan would rename too, or a file renamed otherwise, is another plan. + Assert.NotEqual(plan.Fingerprint(), Make(received with { Frames = [.. received.Frames.SkipLast(1), received.Frames[1] with { File = "originals/b.JPG" }] }).Fingerprint()); + Assert.NotEqual(plan.Fingerprint(), Make(manifest with { Frames = [manifest.Frames[0] with { File = "originals/c.JPG" }] }).Fingerprint()); + } + + [Test] + public void AStepNamedAfterTheTitleSaysSo() + { + var manifest = Sequence("originals/a.JPG"); + RenameStep Step(string? folder, string? file) => RenamePlanner.Plan(Guid.NewGuid(), [new RenameSubject(manifest.Id, "s", "Roof", Start, null, null, null) + { Files = new SequenceFiles(manifest, [.. manifest.Frames.Select(f => f.File)]) }], folder, null, ["s"], _ => false, fileTemplate: file).Steps.Single(); + Assert.True(Step("moved/{TITLE}", null) is { MovesFolder: true, NamedByTitle: true, UsesTitle: true, Retitles: false }); + Assert.True(Step(null, "{title}_{n:000}") is { FileChanges: 1, NamedByTitle: true, UsesTitle: true }); + Assert.True(Step("moved/{date}", "{n:000}") is { MovesFolder: true, FileChanges: 1, NamedByTitle: false, UsesTitle: false }); + } + + [Test] + public void APlanKeepsItsTemplatesSoTheNamesOfAFirstPhotoNoLongerFirstAreTold() + { + const string Folder = "moved/{date} {title}", Title = "{title} {time}"; + var manifest = Sequence("originals/a.JPG", "originals/b.JPG"); + // Another sequence holds the folder the template gives: this one takes its " (2)". + var plan = RenamePlanner.Plan(Guid.NewGuid(), [new RenameSubject(manifest.Id, "s", "Roof", Start, null, null, null) + { Files = new SequenceFiles(manifest, [.. manifest.Frames.Select(f => f.File)]) }], Folder, Title, ["s", "moved/2026-09-28 Roof 18-00-00"], _ => false); + Assert.Equal((Folder, Title, (string?)null), (plan.FolderTemplate, plan.TitleTemplate, plan.FileTemplate)); + var step = plan.Steps.Single(); + Assert.Equal(("moved/2026-09-28 Roof 18-00-00 (2)", "Roof 18-00-00"), (step.ToFolder, step.ToTitle)); + + // From the sidecar as it was, the templates give what the plan gives; with its first photo gone, they name it otherwise. + var (title, folder) = RenamePlanner.Names(manifest, "Roof", Folder, Title); + Assert.Equal(("Roof 18-00-00", "moved/2026-09-28 Roof 18-00-00"), (title, folder)); + Assert.True(RenamePlanner.Gives(folder!, step.ToFolder)); + var (laterTitle, laterFolder) = RenamePlanner.Names(manifest with { Frames = [manifest.Frames[1]] }, "Roof", Folder, Title); + Assert.Equal(("Roof 18-00-10", "moved/2026-09-28 Roof 18-00-10"), (laterTitle, laterFolder)); + Assert.False(RenamePlanner.Gives(laterFolder!, step.ToFolder)); + // Without templates, the title stays and no folder is given. + Assert.Equal(("Roof", (string?)null), RenamePlanner.Names(manifest, "Roof", null, null)); + + // Only the folder itself or a number filing gives. + Assert.True(RenamePlanner.Gives("a/b", "a/b")); + Assert.True(RenamePlanner.Gives("a/b", "a/b (12)")); + Assert.False(RenamePlanner.Gives("a/b", "a/b (1)")); + Assert.False(RenamePlanner.Gives("a/b", "a/b (02)")); + Assert.False(RenamePlanner.Gives("a/b", "A/b")); + Assert.False(RenamePlanner.Gives("a/b", "a/b (2) x")); + } + + [Test] + public void TemplatesAreCheckedAsTheArchiveSettingsAre() + { + Assert.Null(new RenameTemplates("{year}/{title}", "{date}_{n}", "{title} 2026").Problem()); + Assert.Null(new RenameTemplates(File: "{name}.{ext}", Title: "Paris: {title}?").Problem()); + Assert.Equal("folderTemplate", new RenameTemplates(Folder: " ").Problem()); + Assert.Equal("fileTemplate", new RenameTemplates(File: "{nope}").Problem()); + Assert.Equal("fileTemplate", new RenameTemplates(File: "{date:%}").Problem()); + Assert.Equal("titleTemplate", new RenameTemplates(Title: "{title").Problem()); + // Not valid, blank or written with an unusable format: no rule to name. + Assert.Equal(new TemplateProblem("fileTemplate", null), new RenameTemplates(File: "{date:%}").Check()); + Assert.True(new RenameTemplates().IsEmpty); + } + + [Theory] + [Case("{n}{ext}", "fileTemplate", "Extension")] + [Case("{date}_{n}_{ext}", "fileTemplate", "Extension")] + [Case("{title}", "fileTemplate", "NotUnique")] + [Case("{date}_{hm}", "fileTemplate", "NotUnique")] + [Case("{year}/{n}", "fileTemplate", "FileSeparator")] + [Case("Originals/{date:yyyy}/{title}", "folderTemplate", "ReservedFolder")] + [Case("{year}/exports", "folderTemplate", "ReservedFolder")] + [Case(".archive/{date}", "folderTemplate", "ReservedFolder")] + [Case("{date:.yyyy}", "folderTemplate", "ReservedFolder")] + public void TemplatesThatWouldLoseOrHidePhotosAreRefused(string template, string field, string rule) + { + var folder = field == "folderTemplate"; + var templates = folder ? new RenameTemplates(Folder: template) : new RenameTemplates(File: template); + Assert.Equal(field, templates.Problem()); + Assert.Equal(new TemplateProblem(field, rule), templates.Check()); + Assert.Equal(rule, folder ? TemplateRules.FolderRule(PathTemplate.Parse(template)) : TemplateRules.FileRule(PathTemplate.Parse(template))); + } + + /// A sidecar of , each photo's first capture time (none when null), titled . + private static RenameSubject Filed(string folder, string? title, DateTime? first, params string[] files) + { + var manifest = Sequence(files) with { Title = title, Created = new DateTimeOffset(2026, 10, 1, 9, 30, 0, TimeSpan.Zero) }; + manifest = manifest with { Frames = [.. manifest.Frames.Select(f => f with { CapturedAt = first?.AddSeconds(10 * f.I) })] }; + return new RenameSubject(manifest.Id, folder, title, first, "Canon", "Canon EOS R5", null) + { + Files = new SequenceFiles(manifest, [.. manifest.Frames.Select(f => f.File)]), + }; + } + + [Theory] + [Case("{year}/{date} {ext}", "2026/2026-09-28 CR2", "2026/2026-09-28 JPG")] + [Case("{date} {name}", "2026-09-28 IMG_0001", "2026-09-28 IMG_0001 (2)")] + [Case("{year}/{date} {camera} {iso}", "2026/2026-09-28 Canon EOS R5", "2026/2026-09-28 Canon EOS R5 (2)")] + public void FoldersFiledFromTheFirstPhotoStayWhereFilingPutThem(string template, string raw, string jpeg) + { + // RAW and JPEG of one day, filed by the template from their first photo ({ext}, {name}… are that photo's). + RenameSubject[] subjects = + [ + Filed(raw, null, Start, "originals/2026-09-28_0001.CR2", "originals/2026-09-28_0002.CR2"), + Filed(jpeg, null, Start, "originals/2026-09-28_0001.JPG", "originals/2026-09-28_0002.JPG"), + ]; + var folders = subjects.Select(s => s.Folder).ToHashSet(StringComparer.OrdinalIgnoreCase); + Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), subjects, template, null, folders, folders.Contains).Steps); + // The context filing saw: the folder each first frame gives. + var context = FrameNaming.Context(subjects[0].Files!.Manifest.Frames[0], subjects[0].Files!.Manifest, null); + Assert.Equal(raw.Replace(" (2)", string.Empty, StringComparison.Ordinal), PathTemplate.Parse(template).ExpandFolder(context)); + } + + [Test] + public void ASequenceWithoutACaptureTimeNeverTakesTodaysDate() + { + // No time in the sidecar: the day the sequence was made, as its files are named; no sidecar and no time: no move. + var timeless = Filed("inbox/a", null, null, "originals/a.JPG"); + var plan = RenamePlanner.Plan(Guid.NewGuid(), [timeless], "{date}", null, ["inbox/a"], _ => false); + Assert.Equal("2026-10-01", plan.Steps.Single().ToFolder); + var row = new RenameSubject(Guid.NewGuid(), "inbox/b", "B", null, null, null, null); + Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), [row], "{date}", "{title} {date}", ["inbox/b"], _ => false).Steps); + } + + [Test] + public void ASequenceWhoseSidecarCannotBeReadStaysAsItIsAndSoDoesTheFolderAroundIt() + { + var a = Filed("a", "A", Start, "originals/a.JPG"); + // Unreadable, titled as D: had it been planned, D would get " (2)". + var unreadable = new RenameSubject(Guid.NewGuid(), "u", "D", Start, null, null, null) { Unreadable = true }; + var carrier = Filed("c", "C", Start, "originals/c.JPG"); + var inner = new RenameSubject(Guid.NewGuid(), "c/n", "N", Start, null, null, null) { Unreadable = true }; + var d = Filed("d", "D", Start, "originals/d.JPG"); + var plan = RenamePlanner.Plan(Guid.NewGuid(), [a, unreadable, carrier, d], "moved/{title}", "{title} 2026", ["a", "u", "c", "c/n", "d"], _ => false, + [inner]); + var steps = plan.Steps.ToDictionary(s => s.SequenceId); + Assert.Equal(("moved/A 2026", "A 2026"), (steps[a.SequenceId].ToFolder, steps[a.SequenceId].ToTitle)); + Assert.Equal(("moved/D 2026", "D 2026"), (steps[d.SequenceId].ToFolder, steps[d.SequenceId].ToTitle)); + foreach (var kept in new[] { unreadable, inner }) + { + var step = steps[kept.SequenceId]; + Assert.Equal((kept.Folder, kept.Title), (step.ToFolder, step.ToTitle)); + Assert.False(step.Changes); + Assert.Equal(RenameBlock.Unreadable, step.Blocked.Single().Reason); + } + // Its own sidecar reads: the title changes, the folder cannot take the sequence inside along. + Assert.Equal(("c", "C 2026"), (steps[carrier.SequenceId].ToFolder, steps[carrier.SequenceId].ToTitle)); + Assert.False(steps[inner.SequenceId].Carried); + + // With a file template, a sequence without its sidecar's files stays too. + var noFiles = new RenameSubject(Guid.NewGuid(), "x", "X", Start, null, null, null); + var files = RenamePlanner.Plan(Guid.NewGuid(), [noFiles], "moved/{title}", null, ["x"], _ => false, fileTemplate: "{n}"); + Assert.Equal(("x", false), (files.Steps.Single().ToFolder, files.Steps.Single().Changes)); + } + + [Test] + public void AFolderATitleWouldHideFromScansIsEscapedAndFound() + { + var archive = new ArchivePaths(context.CreateTempDirectory("archive")); + var originals = archive.FromRelative("inbox/a/originals"); + Directory.CreateDirectory(originals); + File.WriteAllBytes(Path.Combine(originals, "IMG_0001.JPG"), TestPhotos.Jpeg(Start, 1)); + var subject = new RenameSubject(Guid.NewGuid(), "inbox/a", "Exports", Start, null, null, null); + var step = RenamePlanner.Plan(Guid.NewGuid(), [subject], "{year}/{title}", null, ["inbox/a"], _ => false).Steps.Single(); + Assert.Equal("2026/_Exports", step.ToFolder); + RenamePlanner.MoveFolder(archive, step); + Assert.SequenceEqual(["2026/_Exports"], ArchiveScanner.FindSequenceFolders(archive).Select(f => f.RelativeFolder)); + } + + [Test] + public void TitlesKeepWhatAFileNameCannotHold() + { + var paris = new RenameSubject(Guid.NewGuid(), "s/paris", "Paris: night", Start, null, null, null); + var plan = RenamePlanner.Plan(Guid.NewGuid(), [paris], "{title}", "{title} 2026", ["s/paris"], _ => false); + // The title is text; the folder it names is a file name. + Assert.Equal(("Paris: night 2026", "Paris_ night 2026"), (plan.Steps.Single().ToTitle, plan.Steps.Single().ToFolder)); + Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), [paris with { Folder = "Paris_ night" }], "{title}", "{title}", ["Paris_ night"], _ => false).Steps); + } + + [Test] + public void TwoFoldersThatDifferOnlyInCaseAreNeverGivenOneFolder() + { + // A case-sensitive server: "trip (2)" and "TRIP (2)" are two folders, both of which "Trip (2)" would keep. + RenameSubject At(string folder) => new(Guid.NewGuid(), folder, "Trip", Start, null, null, null); + RenameSubject[] subjects = [At("trip (2)"), At("TRIP (2)")]; + var onDisk = new HashSet(["trip (2)", "TRIP (2)"], StringComparer.Ordinal); + var plan = RenamePlanner.Plan(Guid.NewGuid(), subjects, "{title}", null, onDisk, onDisk.Contains); + var targets = plan.Steps.Select(s => s.ToFolder).ToList(); + Assert.SequenceEqual(["Trip (2)", "Trip"], targets); + + // Where they went, the same template changes nothing. + RenameSubject[] after = [.. subjects.Zip(targets, (s, t) => s with { Folder = t })]; + var moved = new HashSet(targets, StringComparer.Ordinal); + Assert.Empty(RenamePlanner.Plan(Guid.NewGuid(), after, "{title}", null, moved, moved.Contains).Steps); + } + + [Test] + public void ACaseOnlyMoveOntoAnotherFolderIsRefused() + { + var archive = new ArchivePaths(context.CreateTempDirectory("archive")); + Directory.CreateDirectory(archive.FromRelative("trip (2)")); + File.WriteAllText(Path.Combine(archive.FromRelative("trip (2)"), "a.txt"), "a"); + var step = new RenameStep(Guid.NewGuid(), "trip (2)", "Trip (2)", "Trip", "Trip"); + if (Directory.Exists(archive.FromRelative("TRIP (2)"))) + { + // Case-insensitive: the folder takes the new case, and the step repeated finds it done. + RenamePlanner.MoveFolder(archive, step); + RenamePlanner.MoveFolder(archive, step); + Assert.SequenceEqual(["Trip (2)"], Directory.EnumerateDirectories(archive.Root).Select(Path.GetFileName)); + Assert.Equal("a", File.ReadAllText(Path.Combine(archive.FromRelative("Trip (2)"), "a.txt"))); + } + else + { + // Case-sensitive: another folder holds the new name exactly; neither moves. + Directory.CreateDirectory(archive.FromRelative("Trip (2)")); + Assert.Throws(() => RenamePlanner.MoveFolder(archive, step)); + Assert.Equal("a", File.ReadAllText(Path.Combine(archive.FromRelative("trip (2)"), "a.txt"))); + Assert.Empty(Directory.EnumerateFileSystemEntries(archive.FromRelative("Trip (2)"))); + } + } + + [Test] + public void AChangeOfCaseIsNeverPlannedOntoAnotherFolderOfThatExactName() + { + // A case-sensitive server: "Trip (2)" is a folder of its own beside the sequence at "trip (2)", and no sequence's. + var subject = new RenameSubject(Guid.NewGuid(), "trip (2)", "Trip", Start, null, null, null); + var onDisk = new HashSet(["trip (2)", "Trip (2)"], StringComparer.Ordinal); + var plan = RenamePlanner.Plan(Guid.NewGuid(), [subject], "{title}", null, ["trip (2)"], onDisk.Contains, existsExactly: onDisk.Contains); + Assert.Equal("Trip", plan.Steps.Single().ToFolder); + + // Case-insensitive, the only folder of that name is its own: it keeps its number, in the template's case. + var own = RenamePlanner.Plan(Guid.NewGuid(), [subject], "{title}", null, ["trip (2)"], f => f.Equals("trip (2)", StringComparison.OrdinalIgnoreCase), + existsExactly: f => f == "trip (2)"); + Assert.Equal("Trip (2)", own.Steps.Single().ToFolder); + } + + [Test] + public void AFolderExistsExactlyOnlyInTheCaseOfEveryLevel() + { + var archive = new ArchivePaths(context.CreateTempDirectory("archive")); + Directory.CreateDirectory(archive.FromRelative("trip/day")); + File.WriteAllText(Path.Combine(archive.FromRelative("trip/day"), "a.txt"), "a"); + Assert.True(RenamePlanner.ExistsExactly(archive, "trip/day")); + Assert.False(RenamePlanner.ExistsExactly(archive, "Trip/day")); + Assert.False(RenamePlanner.ExistsExactly(archive, "trip/Day")); + Assert.False(RenamePlanner.ExistsExactly(archive, "trip/night")); + + // An outer level's case alone: the folder moves on any file system (a case-insensitive one keeps the outer name as it was). + var step = new RenameStep(Guid.NewGuid(), "trip/day", "Trip/day", "T", "T"); + RenamePlanner.MoveFolder(archive, step); + RenamePlanner.MoveFolder(archive, step); + Assert.Equal("a", File.ReadAllText(Path.Combine(archive.FromRelative("Trip/day"), "a.txt"))); + } + + [Test] + public void AFolderTheDiskSpellsAsTheTemplateDoesIsTheSequencesOwn() + { + // A case-insensitive file system: the index has "trip (2)" and "Trip/day", the disk spells them "Trip (2)" (renamed in + // Explorer since the last scan) and "trip/day" (an outer level a change of case left as it was). The folders found + // under the template's exact names are the sequences' own: a change of case is all the plan makes, never " (n)". + var disk = new HashSet(["Trip", "Trip (2)", "trip", "trip/day"], StringComparer.Ordinal); + bool OnDisk(string f) => disk.Contains(f, StringComparer.OrdinalIgnoreCase); + var renamed = new RenameSubject(Guid.NewGuid(), "trip (2)", "Trip", Start, null, null, null); + var plan = RenamePlanner.Plan(Guid.NewGuid(), [renamed], "{title}", null, ["trip (2)", "Trip"], OnDisk, existsExactly: disk.Contains); + Assert.Equal("Trip (2)", plan.Steps.Single().ToFolder); + var outer = new RenameSubject(Guid.NewGuid(), "Trip/day", "day", Start, null, null, null); + plan = RenamePlanner.Plan(Guid.NewGuid(), [outer], "trip/day", null, ["Trip/day"], OnDisk, existsExactly: disk.Contains); + Assert.Equal("trip/day", plan.Steps.Single().ToFolder); + } + + [Test] + public void ACaseOnlyTargetOnDiskIsRefusedOnlyBesideTheSequencesOwnFolder() + { + var archive = new ArchivePaths(context.CreateTempDirectory("archive")); + foreach (var folder in (string[])["Trip", "Trip (2)", "walk/day"]) + { + Directory.CreateDirectory(archive.FromRelative(folder)); + File.WriteAllText(Path.Combine(archive.FromRelative(folder), "a.txt"), folder); + } + // The index has "trip (2)" and "Walk/day": on a case-sensitive file system those are folders of their own beside the + // ones the template names. + var caseSensitive = !Directory.Exists(archive.FromRelative("trip (2)")); + if (caseSensitive) + { + Directory.CreateDirectory(archive.FromRelative("trip (2)")); + Directory.CreateDirectory(archive.FromRelative("Walk/day")); + } + bool OnDisk(string f) => Directory.Exists(archive.FromRelative(f)); + bool Exactly(string f) => RenamePlanner.ExistsExactly(archive, f); + var renamed = new RenameSubject(Guid.NewGuid(), "trip (2)", "Trip", Start, null, null, null); + var outer = new RenameSubject(Guid.NewGuid(), "Walk/day", "day", Start, null, null, null); + var first = RenamePlanner.Plan(Guid.NewGuid(), [renamed], "{title}", null, ["trip (2)", "Trip", "Walk/day"], OnDisk, existsExactly: Exactly).Steps.Single(); + var second = RenamePlanner.Plan(Guid.NewGuid(), [outer], "walk/day", null, ["trip (2)", "Trip", "Walk/day"], OnDisk, existsExactly: Exactly).Steps.Single(); + if (caseSensitive) + { + Assert.Equal(("Trip (3)", "walk/day (2)"), (first.ToFolder, second.ToFolder)); + return; + } + // Case-insensitive: each sequence keeps its own folder, which is already as the template spells it, so applying the + // steps (twice, as a resumed plan does) moves nothing and loses nothing. + Assert.Equal(("Trip (2)", "walk/day"), (first.ToFolder, second.ToFolder)); + foreach (var step in (RenameStep[])[first, second, first, second]) RenamePlanner.MoveFolder(archive, step); + Assert.SequenceEqual(["Trip", "Trip (2)", "walk"], Directory.EnumerateDirectories(archive.Root).Select(Path.GetFileName).Order(StringComparer.Ordinal)); + Assert.Equal("Trip (2)", File.ReadAllText(Path.Combine(archive.FromRelative("Trip (2)"), "a.txt"))); + Assert.Equal("walk/day", File.ReadAllText(Path.Combine(archive.FromRelative("walk/day"), "a.txt"))); + } + + [Test] + public void PhotosOfALongTitleKeepTheirExtension() + { + // As long as a title goes, less the room the number and the extension take: the name gives way before ".{ext}". + var manifest = Sequence("originals/a.JPG", "originals/b.JPG", "originals/c.JPG"); + var title = new string('t', 186) + " harbour"; + const string Template = "{title}_{n:0000}.{ext}"; + var plan = Plan(manifest, Template, title); + Assert.Equal(3, plan.Frames); + foreach (var move in plan.Moves) + { + Assert.True(move.To.EndsWith(".JPG", StringComparison.Ordinal), move.To); + Assert.True(Path.GetFileName(move.To).Length <= PathTemplate.MaxSegmentLength + 2, move.To); + } + Assert.Equal(3, plan.Moves.Select(m => m.To).Distinct(StringComparer.OrdinalIgnoreCase).Count()); + // Renamed so, the template names them again as they are. + var renamed = FileRenameJournal.Applied(manifest, FileRenameJournal.Create(manifest.Versions.Frames, plan.Moves, "t"))!; + Assert.Empty(Plan(renamed, Template, title).Moves); + } + + [Test] + public void ExtensionsAPhotoLostComeBackFromItsName() + { + var manifest = Sequence("originals/0001CR3", "originals/0002.CR3"); + manifest = manifest with { Frames = [.. manifest.Frames.Select(f => f with { Original = $"IMG_{f.I + 1:0000}.CR3" })] }; + Assert.Equal("CR3", FrameNaming.Context(manifest.Frames[0], manifest, null).Extension); + Assert.SequenceEqual(["originals/0001CR3>originals/0001.CR3"], Plan(manifest, "{n:0000}").Moves.Select(m => $"{m.From}>{m.To}")); + // A file that has an extension of a photo keeps that one, whatever the card's name said. + Assert.Equal("CR3", FrameNaming.Context(manifest.Frames[1] with { Original = "IMG_0002.JPG" }, manifest, null).Extension); + } + + [Test] + public void ManyPhotosOfOneNameAreNamedInLinearTimeAsTheSearchFromTwoNamesThem() + { + // Against the search from _2 it replaces, with names taken by stray files and companions in the way. + var taken = new HashSet(["a/x.JPG", "a/x_3.JPG", "a/x_4.xmp"], StringComparer.OrdinalIgnoreCase); + var reference = new HashSet(taken, StringComparer.OrdinalIgnoreCase); + var names = new UniqueNames(taken); + for (var i = 0; i < 12; i++) + { + // Every third photo has an XMP companion: "x_4" is free for the others, not for it. + Func companion = i % 3 == 1 ? c => !reference.Contains(Path.ChangeExtension(c, ".xmp")) : _ => true; + var expected = "a/x.JPG"; + for (var n = 2; reference.Contains(expected) || !companion(expected); n++) expected = FrameNaming.Numbered("a/x.JPG", n); + reference.Add(expected); + Assert.Equal(expected, names.Claim("a/x.JPG", companion), $"photo {i}"); + } + + var frames = Enumerable.Range(0, 20_000).Select(i => $"originals/{i:00000}.JPG").ToArray(); + var manifest = Sequence(frames); + var clock = System.Diagnostics.Stopwatch.StartNew(); + var plan = Plan(manifest, "{title}", title: "Sunset"); + Assert.True(clock.Elapsed.TotalSeconds < TestTiming.Budget(5), $"{clock.Elapsed.TotalSeconds:0.0} s"); + Assert.SequenceEqual(["originals/Sunset.JPG", "originals/Sunset_2.JPG", "originals/Sunset_3.JPG"], plan.Samples.Select(s => s.To)); + Assert.Equal("originals/Sunset_20000.JPG", plan.Moves[^1].To); + } + + private SequencePaths Folder(out ArchivePaths archive) + { + archive = new ArchivePaths(context.CreateTempDirectory("archive")); + var sequence = archive.Sequence("s"); + Directory.CreateDirectory(sequence.Originals); + Directory.CreateDirectory(sequence.MetaDirectory); + return sequence; + } + + private static void Write(SequencePaths sequence, string file, string text) => File.WriteAllText(sequence.File(file), text, Encoding.UTF8); + + private static string Read(SequencePaths sequence, string file) => File.ReadAllText(sequence.File(file), Encoding.UTF8); + + [Test] + public void FilesMoveInTwoPhasesSoChainsAndSwapsNeverMeet() + { + var sequence = Folder(out _); + Write(sequence, "originals/a.jpg", "A"); + Write(sequence, "originals/b.jpg", "B"); + Write(sequence, "originals/c.jpg", "C"); + Guid x = Guid.NewGuid(), y = Guid.NewGuid(), z = Guid.NewGuid(); + // A swap (a↔b) and a chain into a name that frees up (c→a's place is taken by b, so c→d). + var journal = FileRenameJournal.Create(7, [new FileRename(x, "originals/a.jpg", "originals/b.jpg"), new FileRename(y, "originals/b.jpg", "originals/a.jpg"), + new FileRename(z, "originals/c.jpg", "originals/d.jpg")], "t1"); + FileRenameJournal.Write(sequence, journal); + var done = FileRenameJournal.Run(sequence, journal); + Assert.Equal(2, done.Phase); + Assert.Equal(("A", "B", "C"), (Read(sequence, "originals/b.jpg"), Read(sequence, "originals/a.jpg"), Read(sequence, "originals/d.jpg"))); + Assert.FileMissing(sequence.File("originals/c.jpg")); + Assert.True(journal.Files.All(f => !File.Exists(sequence.File(f.Temp)))); + Assert.True(journal.Files.All(f => Path.GetFileName(f.Temp).StartsWith(".chronos-rename-t1-", StringComparison.Ordinal)), "hidden, never a photo"); + } + + [Test] + public void AFailedMovePutsEveryFileBackAndChangesNothing() + { + var sequence = Folder(out _); + Write(sequence, "originals/a.jpg", "A"); + Write(sequence, "originals/b.jpg", "B"); + var journal = FileRenameJournal.Create(1, [new FileRename(Guid.NewGuid(), "originals/a.jpg", "originals/x.jpg"), + new FileRename(Guid.NewGuid(), "originals/b.jpg", "originals/y.jpg")], "t2"); + FileRenameJournal.Write(sequence, journal); + // Another file took the second name after the plan: nothing is written over it, and the first file goes back. + Write(sequence, "originals/y.jpg", "other"); + Assert.Throws(() => FileRenameJournal.Run(sequence, journal)); + Assert.Equal(("A", "B", "other"), (Read(sequence, "originals/a.jpg"), Read(sequence, "originals/b.jpg"), Read(sequence, "originals/y.jpg"))); + Assert.FileMissing(sequence.File("originals/x.jpg")); + Assert.Null(FileRenameJournal.Read(sequence)); + } + + [Theory] + [Case(1)] + [Case(2)] + public void ARenameACrashInterruptedIsCompleted(int phase) + { + var sequence = Folder(out _); + var manifest = Sequence("originals/2.jpg", "originals/3.jpg", "originals/4.jpg"); + foreach (var f in manifest.Frames) Write(sequence, f.File, f.Id.ToString()); + var plan = Plan(manifest, "{n:0}"); + var journal = FileRenameJournal.Create(manifest.Versions.Frames, plan.Moves, "t3") with { Phase = phase }; + FileRenameJournal.Write(sequence, journal); + // Phase 1: the first file reached its temporary name. Phase 2: every file did, and the first its new name. + File.Move(sequence.File(journal.Files[0].From), sequence.File(journal.Files[0].Temp)); + if (phase == 2) + { + foreach (var f in journal.Files.Skip(1)) File.Move(sequence.File(f.From), sequence.File(f.Temp)); + File.Move(sequence.File(journal.Files[0].Temp), sequence.File(journal.Files[0].To)); + } + + var recovered = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)); + Assert.SequenceEqual(["originals/1.jpg", "originals/2.jpg", "originals/3.jpg"], recovered.Frames.Select(f => f.File)); + Assert.Equal(manifest.Versions.Frames + 1, recovered.Versions.Frames); + foreach (var f in recovered.Frames) Assert.Equal(f.Id.ToString(), Read(sequence, f.File)); + Assert.FileMissing(sequence.File("originals/4.jpg")); + Assert.True(journal.Files.All(f => !File.Exists(sequence.File(f.Temp)))); + } + + /// + /// A rename of (a chain of names that free up, a swap, a cycle of three) a crash interrupted + /// in its first phase, once its first file reached its temporary name; each file holds its frame's id. + /// + private static (SequenceManifest Manifest, FileRenameJournal Journal) Interrupted(SequencePaths sequence, string shape) + { + string[][] names = shape switch + { + "chain" => [["originals/2.jpg", "originals/3.jpg", "originals/4.jpg"], ["originals/1.jpg", "originals/2.jpg", "originals/3.jpg"]], + "swap" => [["originals/a.jpg", "originals/b.jpg"], ["originals/b.jpg", "originals/a.jpg"]], + _ => [["originals/a.jpg", "originals/b.jpg", "originals/c.jpg"], ["originals/b.jpg", "originals/c.jpg", "originals/a.jpg"]], + }; + var (from, to) = (names[0], names[1]); + var manifest = Sequence(from); + foreach (var f in manifest.Frames) Write(sequence, f.File, f.Id.ToString()); + var journal = FileRenameJournal.Create(manifest.Versions.Frames, [.. manifest.Frames.Select((f, i) => new FileRename(f.Id, f.File, to[i]))], "t4"); + FileRenameJournal.Write(sequence, journal); + File.Move(sequence.File(journal.Files[0].From), sequence.File(journal.Files[0].Temp)); + return (manifest, journal); + } + + private static void AssertEveryFrameHoldsItsPhoto(SequencePaths sequence, SequenceManifest recovered) + { + foreach (var f in recovered.Frames) Assert.Equal(f.Id.ToString(), Read(sequence, f.File)); + Assert.Empty(Directory.EnumerateFiles(sequence.Originals, ".chronos-rename-*")); + } + + [Theory] + [Case("chain")] + [Case("swap")] + [Case("cycle")] + public void ARecoveryRunAgainLeavesEveryFileWithItsFrame(string shape) + { + var sequence = Folder(out _); + var (manifest, _) = Interrupted(sequence, shape); + // Completed, but the sidecar that follows was never written (a full disk, a crash before it): the journal is found again. + var first = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)); + Assert.Equal(2, Assert.NotNull(FileRenameJournal.Read(sequence)).Phase); + var again = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)); + Assert.SequenceEqual(first.Frames.Select(f => f.File), again.Frames.Select(f => f.File)); + Assert.False(manifest.Frames.Select(f => f.File).SequenceEqual(again.Frames.Select(f => f.File)), "every frame has its new name"); + AssertEveryFrameHoldsItsPhoto(sequence, again); + } + + [Test] + [WindowsOnly] + public void ARecoveryCutShortWhileFilesTakeTheirNewNamesGoesOnFromThere() + { + var sequence = Folder(out _); + var (manifest, journal) = Interrupted(sequence, "chain"); + // The last file reached its temporary name too, and another program holds it: the recovery stops at it. + File.Move(sequence.File(journal.Files[2].From), sequence.File(journal.Files[2].Temp)); + using (new FileStream(sequence.File(journal.Files[2].Temp), FileMode.Open, FileAccess.Read, FileShare.None)) + Assert.Throws(() => FileRenameJournal.Recover(sequence, manifest)); + Assert.Equal("originals/1.jpg", journal.Files[0].To); + Assert.Equal(manifest.Frames[0].Id.ToString(), Read(sequence, "originals/1.jpg")); + + // Run again, it goes on from there: no file that took its new name moves again. + var recovered = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)); + Assert.SequenceEqual(["originals/1.jpg", "originals/2.jpg", "originals/3.jpg"], recovered.Frames.Select(f => f.File)); + AssertEveryFrameHoldsItsPhoto(sequence, recovered); + } + + [Test] + public void ANewNameTakenMeanwhileNeverStrandsAPhoto() + { + var sequence = Folder(out _); + var (manifest, journal) = Interrupted(sequence, "chain"); + // Copied in under the name the second file gets after the crash: never written over. Its own old name is the third + // file's new one, so it takes the first free number of that name. + Write(sequence, "originals/2.jpg", "other"); + FileRenameJournal.Delete(sequence); + Assert.NotNull(FileRenameJournal.Read(sequence)); + + var recovered = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)); + Assert.SequenceEqual(["originals/1.jpg", "originals/3_2.jpg", "originals/3.jpg"], recovered.Frames.Select(f => f.File)); + Assert.Equal("other", Read(sequence, "originals/2.jpg")); + AssertEveryFrameHoldsItsPhoto(sequence, recovered); + // The new name is in the journal, so a recovery run again finds every file where it is. + Assert.Equal("originals/3_2.jpg", Assert.NotNull(FileRenameJournal.Read(sequence)).Files[1].To); + Assert.SequenceEqual(recovered.Frames.Select(f => f.File), Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)).Frames.Select(f => f.File)); + AssertEveryFrameHoldsItsPhoto(sequence, recovered); + Assert.Equal(journal.Files.Count, Directory.EnumerateFiles(sequence.Originals).Count() - 1); + } + + [Test] + public void APhotoWhoseCompanionsNewNameIsTakenStaysWithItsCompanion() + { + var sequence = Folder(out _); + var manifest = Sequence("originals/A.CR2"); + Write(sequence, "originals/A.CR2", "photo"); + Write(sequence, "originals/A.xmp", "sidecar"); + var id = manifest.Frames[0].Id; + FileRename[] moves = [new(id, "originals/A.CR2", "originals/0001.CR2"), new(id, "originals/A.xmp", "originals/0001.xmp", Companion: true)]; + var journal = FileRenameJournal.Create(manifest.Versions.Frames, moves, "t5") with { Phase = 2 }; + FileRenameJournal.Write(sequence, journal); + foreach (var f in journal.Files) File.Move(sequence.File(f.From), sequence.File(f.Temp)); + Write(sequence, "originals/0001.xmp", "other"); + + // Both go back to their names, together; the frame keeps its file. + Assert.Null(FileRenameJournal.Recover(sequence, manifest)); + Assert.Equal(("photo", "sidecar", "other"), (Read(sequence, "originals/A.CR2"), Read(sequence, "originals/A.xmp"), Read(sequence, "originals/0001.xmp"))); + Assert.FileMissing(sequence.File("originals/0001.CR2")); + Assert.Empty(Directory.EnumerateFiles(sequence.Originals, ".chronos-rename-*")); + } + + [Test] + public void APhotoThatTookItsNewNameGoesBackWithACompanionWhoseNewNameIsTaken() + { + var sequence = Folder(out _); + var manifest = Sequence("originals/A.CR2"); + Write(sequence, "originals/A.CR2", "photo"); + Write(sequence, "originals/A.xmp", "sidecar"); + var id = manifest.Frames[0].Id; + FileRename[] moves = [new(id, "originals/A.CR2", "originals/0001.CR2"), new(id, "originals/A.xmp", "originals/0001.xmp", Companion: true)]; + var journal = FileRenameJournal.Create(manifest.Versions.Frames, moves, "t6") with { Phase = 2 }; + FileRenameJournal.Write(sequence, journal); + foreach (var f in journal.Files) File.Move(sequence.File(f.From), sequence.File(f.Temp)); + // Stopped once the photo took its new name, before its companion did; then something took the companion's, and the + // photo's old name too. + File.Move(sequence.File(journal.Files[0].Temp), sequence.File(journal.Files[0].To)); + Write(sequence, "originals/0001.xmp", "other"); + Write(sequence, "originals/A.CR2", "another"); + + // The photo goes back with its companion, both to the first free number of its old name; the frame names the photo. + var recovered = Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)); + Assert.Equal("originals/A_2.CR2", recovered.Frames.Single().File); + Assert.Equal(("photo", "sidecar"), (Read(sequence, "originals/A_2.CR2"), Read(sequence, "originals/A_2.xmp"))); + Assert.Equal(("other", "another"), (Read(sequence, "originals/0001.xmp"), Read(sequence, "originals/A.CR2"))); + Assert.FileMissing(sequence.File("originals/0001.CR2")); + Assert.Empty(Directory.EnumerateFiles(sequence.Originals, ".chronos-rename-*")); + // Run again, every file stays where it is. + Assert.Equal("originals/A_2.CR2", Assert.NotNull(FileRenameJournal.Recover(sequence, manifest)).Frames.Single().File); + Assert.Equal(("photo", "sidecar"), (Read(sequence, "originals/A_2.CR2"), Read(sequence, "originals/A_2.xmp"))); + } + + [Test] + public void ADamagedPlanJournalIsSkippedAtOpenAndFailsItsOwnJob() + { + var archive = new ArchivePaths(context.CreateTempDirectory("archive")); + var good = new RenameJournal(new RenamePlan(Guid.NewGuid(), Guid.NewGuid(), []), []); + RenameJournal.Write(archive, good); + var damaged = Guid.NewGuid(); + File.WriteAllText(RenameJournal.PathFor(archive, damaged), "{ \"plan\": "); + var empty = Guid.NewGuid(); + File.WriteAllText(RenameJournal.PathFor(archive, empty), "{}"); + + // The archive still opens: the readable journal resumes, the others stay where they are. + Assert.Equal(good.Plan.Id, RenameJournal.ListPending(archive).Single().Plan.Id); + Assert.True(File.Exists(RenameJournal.PathFor(archive, damaged))); + // The job of a damaged plan fails with the reason instead of planning again. + Assert.Throws(() => RenameJournal.Read(archive, damaged)); + Assert.Throws(() => RenameJournal.Read(archive, empty)); + Assert.Null(RenameJournal.Read(archive, Guid.NewGuid())); + } +} diff --git a/tests/Chronos.Core.Tests/Archiving/TestPhotos.cs b/tests/Chronos.Core.Tests/Archiving/TestPhotos.cs index 97646872..aaefe1e9 100644 --- a/tests/Chronos.Core.Tests/Archiving/TestPhotos.cs +++ b/tests/Chronos.Core.Tests/Archiving/TestPhotos.cs @@ -8,7 +8,7 @@ namespace Chronos.Core.Tests.Archiving; internal static class TestPhotos { public static byte[] Jpeg(DateTime captured, int seed, string make = "Canon", string model = "Canon EOS R5", string? serial = "0431", - int width = 48, int height = 32, int orientation = 1) + int width = 48, int height = 32, int orientation = 1, string? lens = null) { using var image = new ImageBuffer(width, height); var random = new Random(seed); @@ -28,14 +28,16 @@ internal static class TestPhotos FNumber = 8, Iso = 100, Orientation = orientation, + LensModel = lens, }); return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [exif[4..]] }); } - public static string Write(string path, DateTime captured, int seed, string make = "Canon", string model = "Canon EOS R5", string? serial = "0431") + public static string Write(string path, DateTime captured, int seed, string make = "Canon", string model = "Canon EOS R5", string? serial = "0431", + string? lens = null) { Directory.CreateDirectory(Path.GetDirectoryName(path)!); - File.WriteAllBytes(path, Jpeg(captured, seed, make, model, serial)); + File.WriteAllBytes(path, Jpeg(captured, seed, make, model, serial, lens: lens)); return path; } diff --git a/tests/Chronos.Core.Tests/Naming/FrameNamingTests.cs b/tests/Chronos.Core.Tests/Naming/FrameNamingTests.cs new file mode 100644 index 00000000..4408d442 --- /dev/null +++ b/tests/Chronos.Core.Tests/Naming/FrameNamingTests.cs @@ -0,0 +1,210 @@ +using Chronos.Core.Archiving; +using Chronos.Core.Import; +using Chronos.Core.Metadata; +using Chronos.Core.Model; +using Chronos.Core.Naming; +using Chronos.Core.Tests.Archiving; +using Chronos.Testing; +using static Chronos.Core.Tests.Import.ImportTestKit; + +namespace Chronos.Core.Tests.Naming; + +/// Import, upload and Reorganize name a photo alike (owner review 2, R7). +[Category("naming")] +public sealed class FrameNamingTests(TestContext context) +{ + private const string EveryToken = "{date}_{time}_{hm}_{sessionstart}_{n:0000}_{nsession}_{camera}_{lens}_{iso}_{shutter}_{aperture}_{name}_{title}"; + + private static FrameMetadata Metadata(DateTime captured) => new() + { + Make = "Canon", + Model = "Canon EOS R5", + LensModel = "RF15-35mm F2.8 L IS USM", + Iso = 400, + ExposureTime = 1.0 / 250, + FNumber = 8, + CapturedAt = captured, + TimestampSource = TimestampSource.ExifOriginal, + }; + + [Test] + public void AFrameInItsSequenceIsNamedAsTheUploadOfItsPhotoWas() + { + var start = new DateTime(2026, 9, 28, 18, 2, 11); + var template = PathTemplate.Parse(EveryToken); + var frames = Enumerable.Range(0, 3) + .Select(i => SequenceFrames.FromMetadata(Guid.NewGuid(), $"originals/x{i}.CR3", $"IMG_{4211 + i}.CR3", 100, new string('a', 64), Metadata(start.AddSeconds(5 * i)))) + .ToList(); + var first = Metadata(start); + var manifest = SequenceFrames.Insert(new SequenceManifest + { + Id = Guid.NewGuid(), + Camera = new SidecarCamera { Make = first.Make, Model = first.Model }, + Lens = first.LensModel, + }, frames); + + for (var i = 0; i < 3; i++) + { + var filed = template.ExpandFile(FrameNaming.Context(Metadata(start.AddSeconds(5 * i)), $"IMG_{4211 + i}.CR3", start.AddSeconds(5 * i), start, i + 1, "Harbour")); + Assert.Equal(filed, template.ExpandFile(FrameNaming.Context(manifest.Frames[i], manifest, "Harbour"))); + } + Assert.Equal("2026-09-28_18-02-16_18-02_2026-09-28 18-02_0002_0002_Canon EOS R5_RF15-35mm F2.8 L IS USM_400_1-250_f8_IMG_4212_Harbour.CR3", + template.ExpandFile(FrameNaming.Context(manifest.Frames[1], manifest, "Harbour"))); + } + + [Test] + public void AFrameWithoutACaptureTimeTakesTheStartOfItsSequence() + { + var created = new DateTimeOffset(2026, 10, 1, 9, 30, 0, TimeSpan.Zero); + var manifest = new SequenceManifest + { + Id = Guid.NewGuid(), + Created = created, + Frames = [new SidecarFrame { Id = Guid.NewGuid(), File = "originals/a.jpg", Original = "DSC_0001.JPG" }], + }; + var context = FrameNaming.Context(manifest.Frames[0], manifest, null); + Assert.Equal(new DateTime(2026, 10, 1, 9, 30, 0), context.CapturedAt); + Assert.Equal(context.CapturedAt, context.SessionStart); + Assert.Equal("DSC_0001", context.OriginalName); + Assert.Equal("jpg", context.Extension); + Assert.Equal(1, context.Number); + + // After a first photo that has one, that photo's time. + var first = new DateTime(2026, 9, 28, 18, 0, 0); + var timed = manifest with + { + Frames = [manifest.Frames[0] with { CapturedAt = first }, new SidecarFrame { Id = Guid.NewGuid(), I = 1, File = "originals/b.jpg", Original = "DSC_0002.JPG" }], + }; + var second = FrameNaming.Context(timed.Frames[1], timed, null); + Assert.Equal((first, first, 2), (second.CapturedAt, second.SessionStart, second.Number)); + } + + [Test] + public void TakenNamesGetNumbersBeforeTheExtensionAsFilingGivesThem() + { + var template = PathTemplate.Parse("{date}"); + var context = FrameNaming.Context(Metadata(new DateTime(2026, 9, 28, 18, 0, 0)), "IMG_1.JPG", new DateTime(2026, 9, 28, 18, 0, 0), + new DateTime(2026, 9, 28, 18, 0, 0), 1, null); + var taken = new HashSet(StringComparer.OrdinalIgnoreCase) { "originals/2026-09-28.jpg" }; + var names = new UniqueNames(taken); + Assert.Equal("originals/2026-09-28_2.JPG", FrameNaming.FileName(template, context, names, "originals/")); + Assert.Equal("originals/2026-09-28_3.JPG", FrameNaming.FileName(template, context, names, "originals/")); + Assert.Contains("originals/2026-09-28_3.JPG", taken); + Assert.Equal("a/IMG_5_2.CR2", new UniqueNames(new HashSet(["a/IMG_5.CR2"])).Claim("a/IMG_5.CR2")); + } + + [Test] + public async Task AnImportedSessionIsNamedAsReorganizeNamesItsFrames() + { + var card = context.CreateTempDirectory("card"); + TestPhotos.WriteSeries(Path.Combine(card, "DCIM", "100CANON"), Start, 4, TimeSpan.FromSeconds(10)); + const string fileTemplate = "{date}_{time}_{n:0000}_{camera}_{name}"; + var plan = await PlanAsync(card, context.CreateTempDirectory("archive"), new ImportOptions { FileTemplate = fileTemplate }); + var session = plan.Sessions.Single(); + + var manifest = Filed(card, session); + var reorganized = FileRenames.Plan(manifest, session.Title, PathTemplate.Parse(fileTemplate), [.. manifest.Frames.Select(f => f.File)]); + Assert.Empty(reorganized.Moves); + Assert.Equal(0, reorganized.Frames); + Assert.SequenceEqual(session.Items.Select(i => i.FileName), + manifest.Frames.Select(f => PathTemplate.Parse(fileTemplate).ExpandFile(FrameNaming.Context(f, manifest, session.Title)))); + } + + /// + /// The sequence an import files of into: the plan's names, each + /// frame from its photo's metadata, the camera and lens of the first. + /// + private static SequenceManifest Filed(string source, PlannedSession session) + { + var frames = session.Items.Select(item => SequenceFrames.FromMetadata(Guid.NewGuid(), "originals/" + item.FileName, Path.GetFileName(item.SourcePath), + item.Size, new string('b', 64), MetadataReader.Read(Path.Combine(source, item.SourcePath)), item.CapturedAt)).ToList(); + var first = MetadataReader.Read(Path.Combine(source, session.Items[0].SourcePath)); + return SequenceFrames.Insert(new SequenceManifest + { + Id = Guid.NewGuid(), + Camera = new SidecarCamera { Make = first.Make, Model = first.Model }, + Lens = first.LensModel, + }, frames); + } + + private static List Renames(SequenceManifest manifest, string? title, string template) => + [.. FileRenames.Plan(manifest, title, PathTemplate.Parse(template), [.. manifest.Frames.Select(f => f.File)]).Moves.Select(m => $"{m.From}>{m.To}")]; + + [Test] + public async Task ASecondSessionOfACardIsNumberedByTheImportAndRenamedByReorganize() + { + // Two sessions of one card two hours apart: the import numbers them, while each sequence is one session of its own. + var card = context.CreateTempDirectory("card"); + var folder = Path.Combine(card, "DCIM", "100CANON"); + TestPhotos.WriteSeries(folder, Start, 2, TimeSpan.FromSeconds(10)); + TestPhotos.WriteSeries(folder, Start.AddHours(2), 2, TimeSpan.FromSeconds(10), firstSeed: 10, firstNumber: 3); + const string fileTemplate = "{session}_{n:0000}"; + var plan = await PlanAsync(card, context.CreateTempDirectory("archive"), new ImportOptions { FileTemplate = fileTemplate, MinimumSessionFrames = 1 }); + Assert.SequenceEqual(["1_0001.JPG 1_0002.JPG", "2_0001.JPG 2_0002.JPG"], plan.Sessions.Select(s => string.Join(' ', s.Items.Select(i => i.FileName)))); + + // A divergence FrameNaming names: Reorganize calls the second sequence's session 1, and its dry run lists the renames. + Assert.Empty(Renames(Filed(card, plan.Sessions[0]), plan.Sessions[0].Title, fileTemplate)); + Assert.SequenceEqual(["originals/2_0001.JPG>originals/1_0001.JPG", "originals/2_0002.JPG>originals/1_0002.JPG"], + Renames(Filed(card, plan.Sessions[1]), plan.Sessions[1].Title, fileTemplate)); + } + + [Test] + public async Task AWholeFolderOfTwoCamerasNamesEveryPhotoWithTheFirstOnesCamera() + { + var folder = Path.Combine(context.CreateTempDirectory("source"), "Etna"); + TestPhotos.WriteSeries(folder, Start, 2, TimeSpan.FromSeconds(10), prefix: "CAN_"); + TestPhotos.WriteSeries(folder, Start.AddSeconds(5), 2, TimeSpan.FromSeconds(10), firstSeed: 40, prefix: "NIK_", make: "NIKON CORPORATION", model: "NIKON Z 8"); + const string fileTemplate = "{camera}_{n:0000}"; + var plan = await PlanAsync(folder, context.CreateTempDirectory("archive"), new ImportOptions { Grouping = ImportGrouping.WholeFolder, FileTemplate = fileTemplate }); + var session = plan.Sessions.Single(); + Assert.Equal(2, session.Cameras); + Assert.SequenceEqual(["CAN_0001.JPG", "NIK_0001.JPG", "CAN_0002.JPG", "NIK_0002.JPG"], session.Items.Select(i => Path.GetFileName(i.SourcePath))); + + // The sequence carries the first photo's camera, which names every photo of it, the second body's too: Reorganize agrees. + Assert.SequenceEqual(["Canon EOS R5_0001.JPG", "Canon EOS R5_0002.JPG", "Canon EOS R5_0003.JPG", "Canon EOS R5_0004.JPG"], + session.Items.Select(i => i.FileName)); + Assert.Empty(Renames(Filed(folder, session), session.Title, fileTemplate)); + } + + [Test] + public async Task ALensChangedDuringASessionNamesItsPhotosAsTheirSequenceDoes() + { + var card = context.CreateTempDirectory("card"); + var folder = Path.Combine(card, "DCIM", "100CANON"); + for (var i = 0; i < 4; i++) + TestPhotos.Write(Path.Combine(folder, $"IMG_{i + 1:0000}.JPG"), Start.AddSeconds(10 * i), i + 1, lens: i < 2 ? "RF15-35mm" : "RF24-70mm"); + const string fileTemplate = "{lens}_{n:0000}"; + var plan = await PlanAsync(card, context.CreateTempDirectory("archive"), new ImportOptions { FileTemplate = fileTemplate }); + var session = plan.Sessions.Single(); + // The sequence carries the lens of its first photo, which names every photo of it. + Assert.SequenceEqual(["RF15-35mm_0001.JPG", "RF15-35mm_0002.JPG", "RF15-35mm_0003.JPG", "RF15-35mm_0004.JPG"], session.Items.Select(i => i.FileName)); + + var frames = session.Items.Select(item => SequenceFrames.FromMetadata(Guid.NewGuid(), "originals/" + item.FileName, Path.GetFileName(item.SourcePath), + item.Size, new string('c', 64), MetadataReader.Read(Path.Combine(card, item.SourcePath)), item.CapturedAt)).ToList(); + var manifest = SequenceFrames.Insert(new SequenceManifest + { + Id = Guid.NewGuid(), + Camera = new SidecarCamera { Make = "Canon", Model = "Canon EOS R5" }, + Lens = "RF15-35mm", + }, frames); + Assert.Empty(FileRenames.Plan(manifest, session.Title, PathTemplate.Parse(fileTemplate), [.. manifest.Frames.Select(f => f.File)]).Moves); + } + + [Test] + public void AnUploadIsNamedWithItsSequencesCameraAsReorganizeNamesIt() + { + // The creator's hint stands for the camera the photos do not name; a second body's photo takes the sequence's camera. + var start = new DateTime(2026, 9, 28, 18, 2, 11); + var frames = new[] { Metadata(start), Metadata(start.AddSeconds(5)) with { Make = "GoPro", Model = "HERO12 Black", LensModel = null } } + .Select((m, i) => SequenceFrames.FromMetadata(Guid.NewGuid(), $"IMG_{i}.JPG", $"IMG_{i}.JPG", 100, new string('a', 64), m)).ToList(); + var manifest = SequenceFrames.Insert(new SequenceManifest + { + Id = Guid.NewGuid(), + Camera = new SidecarCamera { Model = "Hinted body" }, + Lens = "RF15-35mm F2.8 L IS USM", + }, frames); + var template = PathTemplate.Parse("{camera}_{lens}_{n:00}"); + Assert.SequenceEqual(["Hinted body_RF15-35mm F2.8 L IS USM_01.JPG", "Hinted body_RF15-35mm F2.8 L IS USM_02.JPG"], + manifest.Frames.Select(f => template.ExpandFile(FrameNaming.Context(f, manifest, null)))); + } +} diff --git a/tests/Chronos.Core.Tests/Naming/PathTemplateTests.cs b/tests/Chronos.Core.Tests/Naming/PathTemplateTests.cs index dd9c6cc1..655cf05d 100644 --- a/tests/Chronos.Core.Tests/Naming/PathTemplateTests.cs +++ b/tests/Chronos.Core.Tests/Naming/PathTemplateTests.cs @@ -58,6 +58,71 @@ public sealed class PathTemplateTests public void ReservedWindowsNamesAreEscaped() => Assert.Equal("_CON.CR2", PathTemplate.Parse("{title}").ExpandFile(Frame with { Title = "CON" })); + [Theory] + [Case(".NET Conf", "2026/_.NET Conf")] + [Case("Exports", "2026/_Exports")] + [Case("originals", "2026/_originals")] + [Case("PROXIES", "2026/_PROXIES")] + [Case(".chronos", "2026/_.chronos")] + [Case("Harbour", "2026/Harbour")] + public void FolderLevelsScansNeverEnterAreEscaped(string title, string expected) + { + var template = PathTemplate.Parse("{year}/{title}"); + Assert.Equal(expected, template.ExpandFolder(Frame with { Title = title })); + Assert.Equal(title != "Harbour", template.WritesHiddenFolder(Frame with { Title = title })); + Assert.Equal(title != "Harbour", PathTemplate.IsHiddenFolder(title)); + } + + [Theory] + [Case("{n}", true)] + [Case("{name}.{ext}", true)] + [Case("{n} .{ext}", true)] + [Case("{n}.CR3", true)] + [Case("{n}{ext}", false)] + [Case("{n}_{ext}", false)] + [Case("{n}. {ext}", false)] + [Case("{n}.{ext}{ext}", false)] + public void AFileTemplateKeepsTheExtensionOnlyWithItsDot(string template, bool keeps) + { + var parsed = PathTemplate.Parse(template); + Assert.Equal(keeps, parsed.KeepsExtension, template); + Assert.Equal(keeps, parsed.ExpandFile(Frame).EndsWith(".CR2", StringComparison.Ordinal), parsed.ExpandFile(Frame)); + } + + [Test] + public void ALongNameIsShortenedBeforeItsExtension() + { + // A title as long as titles go: the number gives way, the extension never does. + var title = new string('a', 195); + var name = PathTemplate.Parse("{title}_{n:0000}.{ext}").ExpandFile(Frame with { Title = title }); + Assert.Equal(title + "_.CR2", name); + Assert.Equal(PathTemplate.MaxSegmentLength, name.Length); + // Appended, the extension comes after the longest name. + Assert.Equal(title + "_0001.CR2", PathTemplate.Parse("{title}_{n:0000}").ExpandFile(Frame with { Title = title })); + // Short names are as they were. + Assert.Equal("Harbour sunset_0001.CR2", PathTemplate.Parse("{title}_{n:0000}.{ext}").ExpandFile(Frame)); + } + + [Theory] + [Case("{title} 2026", "Paris: night", "Paris: night 2026")] + [Case("{title} 2026", "24/7 roof", "24/7 roof 2026")] + [Case("{title}", "Aux. trip", "Aux. trip")] + [Case("{title}", "What?", "What?")] + [Case("{title}", "Sunset...", "Sunset...")] + [Case(" {title}\t", "Dawn", "Dawn")] + public void TitlesAreTextNotFileNames(string template, string title, string expected) => + Assert.Equal(expected, PathTemplate.Parse(template).ExpandText(Frame with { Title = title })); + + [Test] + public void TextKeepsToTheLongestTitle() + { + var text = PathTemplate.Parse("{title}{title}").ExpandText(Frame with { Title = new string('a', 150) }); + Assert.Equal(PathTemplate.MaxTextLength, text.Length); + // A character outside the basic plane is never cut in two. + var emoji = PathTemplate.Parse("{title}").ExpandText(Frame with { Title = new string('a', 199) + "\U0001F305" }); + Assert.Equal(new string('a', 199), emoji); + } + [Test] public void ErrorsCarryPositionAndToken() { diff --git a/tests/Chronos.Data.Tests/Archiving/ArchiveFixture.cs b/tests/Chronos.Data.Tests/Archiving/ArchiveFixture.cs index d9276d78..a75fb906 100644 --- a/tests/Chronos.Data.Tests/Archiving/ArchiveFixture.cs +++ b/tests/Chronos.Data.Tests/Archiving/ArchiveFixture.cs @@ -112,17 +112,24 @@ internal sealed class ArchiveFixture : IAsyncDisposable return job; } - /// Stages a verified upload-like file for ingest: returns its path, size and SHA-256. - public (string Path, long Size, string Sha256) Stage(DateTime captured, int seed, string make = "Canon", string model = "Canon EOS R5") + /// Stages a verified upload-like file for ingest ( null: a photo that records no time): returns its path, size and SHA-256. + public (string Path, long Size, string Sha256) Stage(DateTime? captured, int seed, string? make = "Canon", string? model = "Canon EOS R5", string? lens = null) { var staging = Path.Combine(Paths.StagingDirectory, "uploads"); Directory.CreateDirectory(staging); - var bytes = Photos.Jpeg(captured, seed, make, model); + var bytes = Photos.Jpeg(captured, seed, make, model, lens); var path = Path.Combine(staging, $"{Guid.NewGuid():N}.part"); File.WriteAllBytes(path, bytes); return (path, bytes.Length, Convert.ToHexStringLower(SHA256.HashData(bytes))); } + /// Every file under with the hash of its content, in path order: what a test compares to tell that nothing there changed. + public static List FilesOf(string folder) => + [ + .. Directory.EnumerateFiles(folder, "*", SearchOption.AllDirectories).Order(StringComparer.Ordinal) + .Select(p => $"{Path.GetRelativePath(folder, p).Replace('\\', '/')} {Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(p)))}"), + ]; + public async ValueTask DisposeAsync() { foreach (var owned in _owned) await owned.DisposeAsync(); @@ -132,7 +139,7 @@ internal sealed class ArchiveFixture : IAsyncDisposable /// Small real JPEGs with Exif made by the in-house encoder; each seed gives distinct bytes. internal static class Photos { - public static byte[] Jpeg(DateTime captured, int seed, string make = "Canon", string model = "Canon EOS R5") + public static byte[] Jpeg(DateTime? captured, int seed, string? make = "Canon", string? model = "Canon EOS R5", string? lens = null) { using var image = new ImageBuffer(48, 32); var random = new Random(seed); @@ -142,7 +149,7 @@ internal static class Photos var level = (float)random.NextDouble(); for (var i = 0; i < plane.Length; i++) plane[i] = level * (0.5f + 0.5f * (i % 48) / 48f); } - var exif = ExifWriter.BuildJpegApp1(new FrameMetadata { Make = make, Model = model, BodySerial = "0431", CapturedAt = captured, Iso = 100 }); + var exif = ExifWriter.BuildJpegApp1(new FrameMetadata { Make = make, Model = model, LensModel = lens, BodySerial = "0431", CapturedAt = captured, Iso = 100 }); return JpegEncoder.Encode(image, new JpegEncodeOptions { Quality = 85, App1Segments = [exif[4..]] }); } diff --git a/tests/Chronos.Data.Tests/Archiving/ArchiveSettingsTests.cs b/tests/Chronos.Data.Tests/Archiving/ArchiveSettingsTests.cs index 3eef7682..33d39de7 100644 --- a/tests/Chronos.Data.Tests/Archiving/ArchiveSettingsTests.cs +++ b/tests/Chronos.Data.Tests/Archiving/ArchiveSettingsTests.cs @@ -2,6 +2,7 @@ using System.Text.Json.Nodes; using Chronos.Core.Archiving; using Chronos.Core.Codecs.Jpeg; using Chronos.Core.Imaging; +using Chronos.Core.Localization; using Chronos.Core.Metadata; using Chronos.Core.Model; using Chronos.Data.Archiving; @@ -90,6 +91,19 @@ public sealed class ArchiveSettingsTests(TestContext context) var template = await Assert.ThrowsAsync(() => fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { Folder = "{year/{date" } }, fx.Ct)); Assert.Equal("folderTemplate", template.ParamName); + // The rules every template is held to wherever it is typed: a folder scans never enter, a lost extension, names that repeat. + foreach (var (folder, file, field) in new[] + { + ("exports/{date}", "{n}", "folderTemplate"), ("{date}", "{n}{ext}", "fileTemplate"), ("{date}", "{title}", "fileTemplate"), + }) + { + var rule = await Assert.ThrowsAsync(() => + fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { Folder = folder, File = file } }, fx.Ct)); + Assert.Equal(field, rule.ParamName, $"{folder} · {file}"); + } + var created = await Assert.ThrowsAsync(() => + fx.Service.CreateAsync(context.CreateTempDirectory("other"), "Other", new LayoutTemplates { Folder = "{date}", File = "{n}{ext}" }, null, fx.Ct)); + Assert.Equal("fileTemplate", created.ParamName); var proxies = await Assert.ThrowsAsync(() => fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Proxies = s.Proxies with { LongEdge = 100 } }, fx.Ct)); Assert.Equal("proxyLongEdge", proxies.ParamName); @@ -102,6 +116,37 @@ public sealed class ArchiveSettingsTests(TestContext context) Assert.Equal(before, await File.ReadAllTextAsync(fx.Paths.ManifestPath, fx.Ct)); } + [Test] + public async Task TemplatesSavedBeforeTheRulesNeverFailAnEditOfAnotherSetting() + { + await using var fx = await ArchiveFixture.CreateAsync(context); + // An archive.json of 0.1.0-rc.5 or earlier: both templates break a rule new templates are held to. + var manifest = ManifestStore.ReadArchive(fx.Paths.ManifestPath); + ManifestStore.WriteArchive(fx.Paths.ManifestPath, manifest with { LayoutTemplates = new LayoutTemplates { Folder = "exports/{date}", File = "{title}" } }); + + // The desktop saves one row at a time: each edit keeps the templates it does not change. + var proxies = await fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Proxies = s.Proxies with { LongEdge = 2560 } }, fx.Ct); + Assert.Equal(("exports/{date}", "{title}", 2560), (proxies.FolderTemplate, proxies.FileTemplate, proxies.ProxyLongEdge)); + await fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Name = "Studio" }, fx.Ct); + var folder = await fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { Folder = "{year}/{date}" } }, fx.Ct); + Assert.Equal(("{year}/{date}", "{title}"), (folder.FolderTemplate, folder.FileTemplate)); + + // A template given anew is held to every rule, and the refusal says which. + var before = await File.ReadAllTextAsync(fx.Paths.ManifestPath, fx.Ct); + var refused = await Assert.ThrowsAsync(() => + fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { File = "{n}{ext}" } }, fx.Ct)); + Assert.Equal(("fileTemplate", "Extension", Loc.L("Errors.Template.Extension")), (refused.ParamName, refused.Rule, refused.Message)); + Assert.Equal(before, await File.ReadAllTextAsync(fx.Paths.ManifestPath, fx.Ct)); + + var file = await fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { File = "{date}_{n:0000}" } }, fx.Ct); + Assert.Equal(("Studio", "{year}/{date}", "{date}_{n:0000}", 2560), (file.Name, file.FolderTemplate, file.FileTemplate, file.ProxyLongEdge)); + + // A new archive has nothing to keep: its templates meet every rule. + var created = await Assert.ThrowsAsync(() => fx.Service.CreateAsync(context.CreateTempDirectory("other"), "Other", + new LayoutTemplates { Folder = "exports/{date}", File = "{date}_{n:0000}" }, null, fx.Ct)); + Assert.Equal(("folderTemplate", "ReservedFolder"), (created.ParamName, created.Rule)); + } + [Test] public async Task AnOfflineArchiveIsNotChangedAndItsIndexSettingsAreShown() { diff --git a/tests/Chronos.Data.Tests/Archiving/FrameTrashTests.cs b/tests/Chronos.Data.Tests/Archiving/FrameTrashTests.cs index d3bf3221..a0cb07b0 100644 --- a/tests/Chronos.Data.Tests/Archiving/FrameTrashTests.cs +++ b/tests/Chronos.Data.Tests/Archiving/FrameTrashTests.cs @@ -1127,6 +1127,90 @@ public abstract class FrameTrashTests(TestContext context) : DatabaseTest(contex Assert.SequenceEqual(frames.Select(f => f.Id), (await fx.Db.Frames.ListBySequenceAsync(sequence.Id)).Select(f => f.Id)); } + /// The files of a sequence as its sidecar names them, after checking that the index names the same ones and that each holds its photo. + private static async Task> FilesAsync(ArchiveFixture fx, Guid id) + { + var sequence = Assert.NotNull(await fx.Db.Sequences.GetAsync(id)); + var folder = fx.Paths.Sequence(sequence.Folder); + var sidecar = ManifestStore.ReadSequence(folder.ManifestPath); + var rows = await fx.Db.Frames.ListBySequenceAsync(id); + Assert.SequenceEqual(sidecar.Frames.Select(f => (f.Id, folder.ArchiveRelative(f.File))), rows.Select(r => (r.Id, r.RelativePath))); + foreach (var frame in sidecar.Frames) Assert.Equal(frame.Sha256, Sha(folder.File(frame.File))); + return [.. sidecar.Frames.Select(f => f.File)]; + } + + [Test] + public async Task PhotosDeletedBeforeAReorganizeComeBackBesideTheNamesItGave() + { + var fx = await FixtureAsync(); + var (sequence, frames) = await UploadedAsync(fx, 4); + var numbered = new RenameTemplates(File: "{n:000}"); + await fx.Service.ApplyRenameAsync(await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [sequence.Id], numbered, fx.Ct), null, fx.Ct); + var folder = fx.Paths.Sequence(sequence.Folder); + File.WriteAllText(folder.File("originals/002.xmp"), "second"); + await fx.ScanAsync(); + // The record keeps the names the photo and its companion had: 002.JPG and 002.xmp. + var deleted = await DeleteAsync(fx, (await fx.Db.Sequences.GetAsync(sequence.Id))!, frames[1]); + Assert.SequenceEqual(["originals/002.JPG", "originals/002.xmp"], FrameTrash.ReadEntry(fx.Paths, deleted.Entry.Name)!.Photos.Single().Files.Select(f => f.From)); + + // Moved and renamed since: the photos that stay take 001-003, the deleted photo's name included. + var moved = new RenameTemplates(Folder: "moved/{date}", File: "{n:000}"); + await fx.Service.ApplyRenameAsync(await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [sequence.Id], moved, fx.Ct), null, fx.Ct); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG", "originals/003.JPG"], await FilesAsync(fx, sequence.Id)); + + // Restored into the sequence where it is now, under its own name made free: its companion follows that name. + var restored = await fx.Service.RestoreEntryAsync(fx.Archive.Id, deleted.Entry.Name, null, fx.Ct); + Assert.Equal(1, restored.Photos); + var row = (await fx.Db.Sequences.GetAsync(sequence.Id))!; + Assert.Equal("moved/2026-09-28", row.Folder); + Assert.SequenceEqual(["originals/001.JPG", "originals/002_2.JPG", "originals/002.JPG", "originals/003.JPG"], await FilesAsync(fx, sequence.Id)); + var now = fx.Paths.Sequence(row.Folder); + Assert.Equal(frames[1].Sha256, Sha(now.File("originals/002_2.JPG"))); + Assert.Equal("second", File.ReadAllText(now.File("originals/002_2.xmp"))); + Assert.SequenceEqual(frames.Select(f => f.Id), (await fx.Db.Frames.ListBySequenceAsync(sequence.Id)).Select(f => f.Id)); + Assert.DoesNotContain(TrashKind.Photos, (await fx.Service.ListTrashAsync(fx.Archive.Id, fx.Ct)).Select(e => e.Kind)); + } + + [Test] + public async Task AReorganizeWaitsForARestoreItsEntryHoldsThenSettlesItFirst() + { + var fx = await FixtureAsync(); + var (sequence, frames) = await UploadedAsync(fx, 3); + var folder = fx.Paths.Sequence(sequence.Folder); + var deleted = await DeleteAsync(fx, sequence, frames[1]); + // A restore died after moving the original back, before the sidecar; the entry is being emptied meanwhile. + var journal = RestoreJournal(fx, deleted.Entry); + journal.Write(folder); + var back = journal.Photos[0].Moves[0]; + File.Move(fx.Paths.FromRelative(back.To), folder.File(back.From)); + var templates = new RenameTemplates(Folder: "moved/{date}", File: "{n:000}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [sequence.Id], templates, fx.Ct); + Assert.Equal(2, plan.Steps.Single().FileChanges); + var before = await FilesAsync(fx, sequence.Id); + + using (Assert.NotNull(LeaseFile.TryAcquire(fx.Paths.LocksDirectory, SequenceTrash.EntryLease(deleted.Entry.Name), "other"))) + { + // Neither the folder nor a file name changes under that restore. + await Assert.ThrowsAsync(() => fx.Service.ApplyRenameAsync(plan, null, fx.Ct)); + Assert.Equal(sequence.Folder, (await fx.Db.Sequences.GetAsync(sequence.Id))!.Folder); + Assert.SequenceEqual(before, await FilesAsync(fx, sequence.Id)); + Assert.FileExists(folder.RestoreJournalPath); + Assert.FileExists(folder.File(back.From)); + } + + // Once the entry is free the rename resumes: the restore is settled first (the original goes back into its entry), + // then the folder moves and the files are renamed; the photo then comes back beside them. + Assert.Equal(1, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct)); + Assert.Equal(frames[1].Sha256, Sha(fx.Paths.FromRelative(back.To))); + var row = (await fx.Db.Sequences.GetAsync(sequence.Id))!; + Assert.Equal("moved/2026-09-28", row.Folder); + Assert.FileMissing(fx.Paths.Sequence(row.Folder).RestoreJournalPath); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG"], await FilesAsync(fx, sequence.Id)); + Assert.Equal(1, (await fx.Service.RestoreEntryAsync(fx.Archive.Id, deleted.Entry.Name, null, fx.Ct)).Photos); + Assert.SequenceEqual(frames.Select(f => f.Id), (await fx.Db.Frames.ListBySequenceAsync(sequence.Id)).Select(f => f.Id)); + Assert.Count(3, await FilesAsync(fx, sequence.Id)); + } + [Test] public async Task ARestoreIntoANewSequenceStoppedBetweenPhotosKeepsItsRecordTrue() { diff --git a/tests/Chronos.Data.Tests/Archiving/MassRenameTests.cs b/tests/Chronos.Data.Tests/Archiving/MassRenameTests.cs index 0f4f5db6..1037a9a8 100644 --- a/tests/Chronos.Data.Tests/Archiving/MassRenameTests.cs +++ b/tests/Chronos.Data.Tests/Archiving/MassRenameTests.cs @@ -1,5 +1,8 @@ using Chronos.Core.Archiving; +using Chronos.Core.Model; +using Chronos.Core.Project; using Chronos.Data.Archiving; +using Chronos.Data.Processing; using Chronos.Testing; using static Chronos.Data.Tests.Archiving.ArchiveFixture; @@ -233,6 +236,331 @@ public sealed class MassRenameTests(TestContext context) Assert.Equal(0, (await fx.ScanAsync()).Indexed); } + [Test] + public async Task ExportsInsideAMovedFolderAreStillReachable() + { + await using var fx = await CreateAsync(context); + var ids = await NestedAsync(fx); + // Exports of "trips" and of "trips/day2" in their folders, one of "trips/day2/dawn" saved in the exports of "trips" + // (the Export tab's folder picker), one of "trips" outside the archive, a row whose path only starts with the same + // letters, and one of "trips/day2" in "trips" whose file is gone. + var outside = Path.Combine(context.CreateTempDirectory("exports"), "Trips elsewhere.mp4"); + List renders = + [ + await RenderAsync(fx, ids[0], "trips/exports/Trips.mp4"), + await RenderAsync(fx, ids[1], "trips/day2/exports/Day 2.mp4"), + await RenderAsync(fx, ids[2], "trips/exports/Dawn.mp4"), + await RenderAsync(fx, ids[0], outside), + await RenderAsync(fx, ids[0], "trips 2/exports/Other.mp4", write: false), + await RenderAsync(fx, ids[1], "trips/exports/Gone.mp4", write: false), + ]; + var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, [ids[0]], "moved/{date}", null, fx.Ct); + Assert.SequenceEqual([false, true, true], plan.Steps.Select(s => s.Carried)); + + await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + string[] expected = + [ + "moved/2026-09-28/exports/Trips.mp4", "moved/2026-09-28/day2/exports/Day 2.mp4", "moved/2026-09-28/exports/Dawn.mp4", outside, + "trips 2/exports/Other.mp4", "trips/exports/Gone.mp4", + ]; + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders)); + foreach (var path in expected[..4]) Assert.FileExists(Path.IsPathRooted(path) ? path : fx.Paths.FromRelative(path)); + + // A crash after the steps were recorded but before the journal said so: completed again, and again, nothing moves twice. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + Assert.Equal(1, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct)); + Assert.Equal(0, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct)); + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders)); + } + + [Test] + public async Task AnotherIndexFindsTheExportsWhereAReorganizeMovedTheirFolder() + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + // This index's exports: of "inbox/a" in its folder, of "inbox/b" saved in the exports of "inbox/a", of "inbox/c" in its own. + List renders = + [ + await RenderAsync(fx, ids[0], "inbox/a/exports/A.mp4"), + await RenderAsync(fx, ids[1], "inbox/a/exports/B.mp4"), + await RenderAsync(fx, ids[2], "inbox/c/exports/C.mp4"), + ]; + var (server, archive) = await fx.OtherWriterAsync(); + + // The other index (a server sharing this desktop's archive) moves "inbox/a", then "inbox/c" into the folder it left. + var first = await server.PlanRenameAsync(archive.Id, [ids[0]], "moved/{date}", null, fx.Ct); + await server.ApplyRenameAsync(first, null, fx.Ct); + var second = await server.PlanRenameAsync(archive.Id, [ids[2]], "inbox/a", null, fx.Ct); + Assert.Equal("inbox/a", second.Steps.Single().ToFolder); + await server.ApplyRenameAsync(second, null, fx.Ct); + + // A scan here finds both where they are now (the new "inbox/a" first): each export follows the folder its file moved with. + await fx.ScanAsync(); + Assert.Equal("moved/2026-09-28", (await fx.Db.Sequences.GetAsync(ids[0], fx.Ct))!.Folder); + Assert.Equal("inbox/a", (await fx.Db.Sequences.GetAsync(ids[2], fx.Ct))!.Folder); + string[] expected = ["moved/2026-09-28/exports/A.mp4", "moved/2026-09-28/exports/B.mp4", "inbox/a/exports/C.mp4"]; + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders)); + foreach (var path in expected) Assert.FileExists(fx.Paths.FromRelative(path)); + Assert.Equal(0, (await fx.ScanAsync()).Indexed); + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders)); + } + + [Test] + public async Task AnExportWrittenWhereItsFolderWasStaysWithItsFile() + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + List renders = [await RenderAsync(fx, ids[0], "inbox/a/exports/A.mp4")]; + var (server, archive) = await fx.OtherWriterAsync(); + + // The other index moves "inbox/a"; a writer here that read the folder before files an export where it was, creating + // it again. Another export of the sequence is missing from both places. + var plan = await server.PlanRenameAsync(archive.Id, [ids[0]], "moved/{date}", null, fx.Ct); + await server.ApplyRenameAsync(plan, null, fx.Ct); + renders.Add(await RenderAsync(fx, ids[0], "inbox/a/exports/Late.mp4")); + renders.Add(await RenderAsync(fx, ids[0], "inbox/a/exports/Gone.mp4", write: false)); + + // The scan here moves the rows whose file went with the folder or is nowhere, and keeps the one whose file stayed. + await fx.ScanAsync(); + Assert.Equal("moved/2026-09-28", (await fx.Db.Sequences.GetAsync(ids[0], fx.Ct))!.Folder); + string[] expected = ["moved/2026-09-28/exports/A.mp4", "inbox/a/exports/Late.mp4", "moved/2026-09-28/exports/Gone.mp4"]; + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders)); + foreach (var path in expected[..2]) Assert.FileExists(fx.Paths.FromRelative(path)); + } + + [Test] + public async Task AnImageSequenceExportIsAFolderThatFollowsAsAFileDoes() + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + // Image-sequence exports: of "inbox/a" in its folder, and of "inbox/b" saved in the exports of "inbox/a". + List renders = + [ + await RenderAsync(fx, ids[0], "inbox/a/exports/A frames", frames: true), + await RenderAsync(fx, ids[1], "inbox/a/exports/B frames", frames: true), + ]; + var (server, archive) = await fx.OtherWriterAsync(); + + // The other index moves "inbox/a"; a writer here that read the folder before files one where it was, creating it again. + var plan = await server.PlanRenameAsync(archive.Id, [ids[0]], "moved/{date}", null, fx.Ct); + await server.ApplyRenameAsync(plan, null, fx.Ct); + renders.Add(await RenderAsync(fx, ids[0], "inbox/a/exports/Late frames", frames: true)); + + // Each folder follows, or stays, as a file would: both that moved with the folder, not the one written where it was. + await fx.ScanAsync(); + string[] expected = ["moved/2026-09-28/exports/A frames", "moved/2026-09-28/exports/B frames", "inbox/a/exports/Late frames"]; + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders)); + foreach (var path in expected) Assert.FileExists(Path.Combine(fx.Paths.FromRelative(path), "000001.png")); + } + + [Test] + public async Task AnExportNeverNamesTheOneAnotherSequenceBroughtIntoItsOldFolder() + { + // The new folder is scanned after "inbox/a", then before it. "inbox/a" and "inbox/c" each have an export of the + // same name: the one of "inbox/a" gone, both there, or the one of "inbox/c" gone. + var cases = from template in new[] { "moved/{date}", "done/{date}" } + from files in new[] { (A: false, C: true), (A: true, C: true), (A: true, C: false) } + select (template, files.A, files.C); + foreach (var (template, a, c) in cases) + { + var label = $"{template}, a {(a ? "there" : "gone")}, c {(c ? "there" : "gone")}"; + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + List renders = + [ + await RenderAsync(fx, ids[0], "inbox/a/exports/Clip.mp4", write: a), + await RenderAsync(fx, ids[2], "inbox/c/exports/Clip.mp4", write: c), + ]; + if (a) await File.WriteAllTextAsync(fx.Paths.FromRelative("inbox/a/exports/Clip.mp4"), "a", fx.Ct); + if (c) await File.WriteAllTextAsync(fx.Paths.FromRelative("inbox/c/exports/Clip.mp4"), "c", fx.Ct); + var (server, archive) = await fx.OtherWriterAsync(); + + // The other index moves "inbox/a", then "inbox/c" into the folder it left, their exports along. + var first = await server.PlanRenameAsync(archive.Id, [ids[0]], template, null, fx.Ct); + await server.ApplyRenameAsync(first, null, fx.Ct); + await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [ids[2]], "inbox/a", null, fx.Ct), null, fx.Ct); + + // Each row follows its own sequence's folder, its file there or missing there too, and never names the other one's. + await fx.ScanAsync(); + string[] expected = [first.Steps.Single().ToFolder + "/exports/Clip.mp4", "inbox/a/exports/Clip.mp4"]; + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders), label); + if (a) Assert.Equal("a", await File.ReadAllTextAsync(fx.Paths.FromRelative(expected[0]), fx.Ct), label); + if (c) Assert.Equal("c", await File.ReadAllTextAsync(fx.Paths.FromRelative(expected[1]), fx.Ct), label); + Assert.Equal(0, (await fx.ScanAsync()).Indexed); + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders), label); + } + } + + [Test] + public async Task AnExportSavedInAnotherSequencesFolderNeverNamesTheOneBroughtIntoIt() + { + // The new folder is scanned after "inbox/a", then before it. + foreach (var template in new[] { "moved/{date}", "done/{date}" }) + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + // "inbox/b" saved an export in the exports of "inbox/a" (the Export tab's folder picker); "inbox/c" has one of the same name. + List renders = + [ + await RenderAsync(fx, ids[1], "inbox/a/exports/Clip.mp4"), + await RenderAsync(fx, ids[2], "inbox/c/exports/Clip.mp4"), + ]; + await File.WriteAllTextAsync(fx.Paths.FromRelative("inbox/a/exports/Clip.mp4"), "b", fx.Ct); + await File.WriteAllTextAsync(fx.Paths.FromRelative("inbox/c/exports/Clip.mp4"), "c", fx.Ct); + var (server, archive) = await fx.OtherWriterAsync(); + + // The other index moves "inbox/a", the export of "inbox/b" along, then "inbox/c" into the folder it left, its export along. + var first = await server.PlanRenameAsync(archive.Id, [ids[0]], template, null, fx.Ct); + await server.ApplyRenameAsync(first, null, fx.Ct); + await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [ids[2]], "inbox/a", null, fx.Ct), null, fx.Ct); + + // The export of "inbox/b" follows the folder its file moved with and never names the one of "inbox/c". + await fx.ScanAsync(); + string[] expected = [first.Steps.Single().ToFolder + "/exports/Clip.mp4", "inbox/a/exports/Clip.mp4"]; + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders), template); + Assert.Equal("b", await File.ReadAllTextAsync(fx.Paths.FromRelative(expected[0]), fx.Ct), template); + Assert.Equal("c", await File.ReadAllTextAsync(fx.Paths.FromRelative(expected[1]), fx.Ct), template); + Assert.Equal(0, (await fx.ScanAsync()).Indexed); + Assert.SequenceEqual(expected, await OutputsAsync(fx, renders), template); + } + } + + [Test] + public async Task APhotoDeletionWhoseFolderMovedWhileItWaitedForTheLeaseIsRefused() + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + var frames = await fx.Db.Frames.ListBySequenceAsync(ids[0], cancellationToken: fx.Ct); + var deletion = await fx.Service.FrameTrash.PlanDeleteAsync(ids[0], [frames[1].Id], cancellationToken: fx.Ct); + Assert.True(deletion.CanDelete); + var pause = TimeSpan.FromSeconds(TestTiming.Budget(0.5)); + + // Another process holds the sequence and moves its folder (a Reorganize), while the deletion waits for the lease. + Task delete; + using (await LeaseFile.AcquireAsync(fx.Paths.LocksDirectory, $"seq-{ids[0]:N}", "other", TimeSpan.FromSeconds(5), cancellationToken: fx.Ct)) + { + delete = fx.Service.FrameTrash.DeleteAsync(deletion, cancellationToken: fx.Ct); + await Task.Delay(pause, fx.Ct); + Assert.False(delete.IsCompleted, "the deletion waits for the other process"); + Directory.CreateDirectory(fx.Paths.FromRelative("moved")); + Directory.Move(fx.Paths.FromRelative("inbox/a"), fx.Paths.FromRelative("moved/a")); + await using var tx = await fx.Db.BeginAsync(fx.Ct); + await tx.Sequences.RelocateAsync(ids[0], "moved/a", null, fx.Ct); + await tx.Frames.RebaseFolderAsync(ids[0], "inbox/a", "moved/a", fx.Ct); + await tx.CommitAsync(fx.Ct); + } + + await Assert.ThrowsAsync(() => delete); + Assert.Count(3, await fx.Db.Frames.ListBySequenceAsync(ids[0], cancellationToken: fx.Ct)); + Assert.Count(3, ManifestStore.ReadSequence(fx.Paths.Sequence("moved/a").ManifestPath).Frames); + foreach (var f in frames) Assert.FileExists(fx.Paths.FromRelative(f.RelativePath.Replace("inbox/a/", "moved/a/", StringComparison.Ordinal))); + Assert.Empty(await fx.Service.Trash.ListAsync(fx.Archive, fx.Ct)); + Assert.False(Directory.Exists(fx.Paths.FromRelative("inbox/a")), "the folder it left is not created again"); + } + + [Test] + public async Task AnInterruptedMoveTakesTheExportsAlongWhenItResumes() + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + List renders = []; + foreach (var (id, folder) in ids.Zip(["inbox/a", "inbox/b", "inbox/c"])) renders.Add(await RenderAsync(fx, id, $"{folder}/exports/Clip.mp4")); + var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, ids, "renamed/{date}", null, fx.Ct); + using var cts = new CancellationTokenSource(); + await Assert.ThrowsAsync(() => fx.Service.ApplyRenameAsync(plan, new SyncProgress(_ => cts.Cancel()), cts.Token)); + Assert.Count(1, RenameJournal.ListPending(fx.Paths).Single().Completed); + + // Crash in the middle of the next step: its folder moved with its export, the index not yet updated. + var next = plan.Steps[1]; + Directory.CreateDirectory(Path.GetDirectoryName(fx.Paths.FromRelative(next.ToFolder))!); + Directory.Move(fx.Paths.FromRelative(next.FromFolder), fx.Paths.FromRelative(next.ToFolder)); + + await fx.Service.OpenAsync(fx.Archive.RootPath, fx.Ct); // the next start finds the journal + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.Equal(0, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct)); + var outputs = await OutputsAsync(fx, renders); + Assert.SequenceEqual(ids.Select(id => $"{plan.Steps.Single(s => s.SequenceId == id).ToFolder}/exports/Clip.mp4"), outputs); + foreach (var path in outputs) Assert.FileExists(fx.Paths.FromRelative(path)); + } + + [Test] + public async Task WritersThatReadTheSequenceBeforeItsFolderMovedWriteWhereItIsNow() + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + var stale = (await fx.Db.Sequences.GetAsync(ids[0], fx.Ct))!; + var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, [ids[0]], "moved/{date}", null, fx.Ct); + await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + var now = fx.Paths.Sequence(plan.Steps.Single().ToFolder); + var left = fx.Paths.Sequence(stale.Folder).Folder; + Assert.False(Directory.Exists(left)); + + // A thumbnail pass and an analysis's project update that read the row before the move take their leases after it. + await fx.Service.Images.BuildThumbnailsAsync(fx.Archive, stale, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); + Assert.FileExists(now.ThumbsPackPath); + Assert.True(((await fx.Db.Sequences.GetAsync(ids[0], fx.Ct))!.Status & SequenceStatus.ThumbsBuilt) != 0, "the pass is recorded"); + var projects = new ProjectStore(fx.Db, new SequenceWriter(new ArchiveServiceOptions { Owner = "analysis" })); + Assert.True(await projects.UpdateAsync(fx.Paths, stale, p => p with { HeroFrame = 1 }, fx.Ct)); + Assert.Equal(1, ProjectSettings.FromJson(await File.ReadAllTextAsync(now.ProjectPath, fx.Ct)).HeroFrame); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + } + + [Test] + public async Task APhotoFiledWhileTheFolderMovesGoesWhereTheSequenceIsNow() + { + await using var fx = await CreateAsync(context); + var ids = await PopulateAsync(fx); + var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, [ids[0]], "moved/{date}", null, fx.Ct); + var staged = fx.Stage(Start.AddMinutes(30), 99); + var pause = TimeSpan.FromSeconds(TestTiming.Budget(0.5)); + + // Another process writes the sequence: the move waits for it, and an upload that read the row meanwhile waits behind the move. + Task apply; + Task upload; + using (await LeaseFile.AcquireAsync(fx.Paths.LocksDirectory, $"seq-{ids[0]:N}", "other", TimeSpan.FromSeconds(5), cancellationToken: fx.Ct)) + { + apply = fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + await Task.Delay(pause, fx.Ct); + upload = fx.Service.Ingest.CommitAsync(new IngestRequest(fx.Archive.Id, ids[0], null, null, staged.Path, "LATE.JPG", staged.Size, staged.Sha256, + null, null), fx.Ct); + await Task.Delay(pause, fx.Ct); + Assert.False(apply.IsCompleted || upload.IsCompleted, "both wait for the other process"); + } + + await apply; + var filed = await upload; + var now = plan.Steps.Single().ToFolder; + Assert.True(filed.RelativePath.StartsWith(now + "/", StringComparison.Ordinal), filed.RelativePath); + Assert.FileExists(fx.Paths.FromRelative(filed.RelativePath)); + Assert.Count(4, await fx.Db.Frames.ListBySequenceAsync(ids[0], cancellationToken: fx.Ct)); + Assert.False(Directory.Exists(fx.Paths.FromRelative("inbox/a")), "the folder it left is not created again"); + } + + /// + /// A render row of at (archive-relative or absolute), with its + /// file unless told otherwise; with an image sequence's export, a folder of frames. + /// + private static async Task RenderAsync(ArchiveFixture fx, Guid sequenceId, string output, bool write = true, bool frames = false) + { + if (write) + { + var file = Path.IsPathRooted(output) ? output : fx.Paths.FromRelative(output); + if (frames) file = Path.Combine(file, "000001.png"); + Directory.CreateDirectory(Path.GetDirectoryName(file)!); + await File.WriteAllBytesAsync(file, [1, 2, 3], fx.Ct); + } + var render = new Render { Id = Guid.CreateVersion7(), SequenceId = sequenceId, PresetName = "1080p", OutputPath = output, Bytes = 3, Created = DateTimeOffset.UtcNow }; + await fx.Db.Renders.InsertAsync(render, fx.Ct); + return render.Id; + } + + private static async Task> OutputsAsync(ArchiveFixture fx, IEnumerable renders) + { + var outputs = new List(); + foreach (var id in renders) outputs.Add((await fx.Db.Renders.GetAsync(id, fx.Ct))!.OutputPath); + return outputs; + } + [Test] public async Task AFolderInsideASequenceFolderIsRefused() { diff --git a/tests/Chronos.Data.Tests/Archiving/ProxyTests.cs b/tests/Chronos.Data.Tests/Archiving/ProxyTests.cs index f0789eb8..5bdd18bf 100644 --- a/tests/Chronos.Data.Tests/Archiving/ProxyTests.cs +++ b/tests/Chronos.Data.Tests/Archiving/ProxyTests.cs @@ -2,9 +2,11 @@ using Chronos.Core.Archiving; using Chronos.Core.Codecs.Jpeg; using Chronos.Core.Imaging; using Chronos.Core.Imaging.Decoders; +using Chronos.Core.Localization; using Chronos.Core.Metadata; using Chronos.Core.Model; using Chronos.Data.Archiving; +using Chronos.Data.Tests.Processing; using Chronos.Testing; using static Chronos.Data.Tests.Archiving.ArchiveFixture; @@ -37,11 +39,11 @@ public sealed class ProxyTests(TestContext context) var folder = fx.Paths.Sequence(sequence.Folder); var images = fx.Service.Images; - Assert.Equal(ProxyStoreResult.Invalid, images.StoreProxy(fx.Archive, sequence, frames[0], "not a photo"u8.ToArray())); - Assert.Equal(ProxyStoreResult.WrongFrame, images.StoreProxy(fx.Archive, sequence, frames[0], Proxy(frames[1].CapturedAt!.Value, 1))); + Assert.Equal(ProxyStoreResult.Invalid, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], "not a photo"u8.ToArray(), fx.Ct)); + Assert.Equal(ProxyStoreResult.WrongFrame, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], Proxy(frames[1].CapturedAt!.Value, 1), fx.Ct)); Assert.FileMissing(folder.Proxy(0)); var proxy = Proxy(frames[0].CapturedAt!.Value, 2); - Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frames[0], proxy)); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], proxy, fx.Ct)); Assert.SequenceEqual(proxy, await File.ReadAllBytesAsync(folder.Proxy(0), fx.Ct)); // The proxy pass keeps what was sent and makes none from the originals here, even when forced. @@ -62,6 +64,148 @@ public sealed class ProxyTests(TestContext context) Assert.Equal((0, 1, 1), (again.Built, again.Reused, again.Undecodable)); } + [Test] + public async Task ProxiesSentOrMadeAfterTheFolderMovedGoWhereTheSequenceIsNow() + { + await using var fx = await CreateAsync(context); + var (stale, frames) = await HeifSequenceAsync(fx); + var images = fx.Service.Images; + var plan = await fx.Service.PlanRenameAsync(fx.Archive.Id, [stale.Id], "moved/{date}", null, fx.Ct); + await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + var now = fx.Paths.Sequence(plan.Steps.Single().ToFolder); + var left = fx.Paths.Sequence(stale.Folder).Folder; + Assert.False(Directory.Exists(left)); + + // A proxy upload and a proxy pass that read the sequence before the move write once they hold its lease. + var proxy = Proxy(frames[0].CapturedAt!.Value, 2); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, stale, frames[0], proxy, fx.Ct)); + Assert.SequenceEqual(proxy, await File.ReadAllBytesAsync(now.Proxy(0), fx.Ct)); + var pass = await images.BuildProxiesAsync(fx.Archive, stale, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); + Assert.Equal((0, 1, 0, 1), (pass.Built, pass.Reused, pass.Undecodable, pass.Waiting)); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + + // Deleted since: nothing is written. + Assert.True(await fx.Db.Sequences.DeleteAsync(stale.Id, fx.Ct)); + Assert.Equal(ProxyStoreResult.Gone, await images.StoreProxyAsync(fx.Archive, stale, frames[1], Proxy(frames[1].CapturedAt!.Value, 3), fx.Ct)); + Assert.FileMissing(now.Proxy(1)); + } + + [Test] + public async Task ProxiesOfAFolderAnotherIndexMovedWaitForThisIndexsScan() + { + await using var fx = await CreateAsync(context); + var (sequence, frames) = await HeifSequenceAsync(fx); + var images = fx.Service.Images; + var left = fx.Paths.Sequence(sequence.Folder).Folder; + var (server, archive) = await fx.OtherWriterAsync(); + var plan = await server.PlanRenameAsync(archive.Id, [sequence.Id], "moved/{date}", null, fx.Ct); + await server.ApplyRenameAsync(plan, null, fx.Ct); + var moved = fx.Paths.Sequence(plan.Steps.Single().ToFolder); + + // This index still has the folder where it was: a proxy sent and a proxy pass write nothing, anywhere. + var proxy = Proxy(frames[0].CapturedAt!.Value, 2); + Assert.Equal(ProxyStoreResult.Gone, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], proxy, fx.Ct)); + var refused = await Assert.ThrowsAsync(() => + images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct)); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), refused.Message); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + Assert.FileMissing(moved.Proxy(0)); + + // Once this index's scan found it there, they go where it is. + await fx.ScanAsync(); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], proxy, fx.Ct)); + Assert.SequenceEqual(proxy, await File.ReadAllBytesAsync(moved.Proxy(0), fx.Ct)); + } + + [Test] + public async Task ImagesOfAFolderAnotherSequenceTookAreNotWrittenThere() + { + await using var fx = await CreateAsync(context); + var (sequence, frames) = await HeifSequenceAsync(fx); + Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "other"), Start.AddDays(3), 2, firstSeed: 70); + await fx.ScanAsync(); + var stranger = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id, fx.Ct)).Single(l => l.Folder == "inbox/other").Id; + var images = fx.Service.Images; + var (server, archive) = await fx.OtherWriterAsync(); + await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [sequence.Id], "moved/{date}", null, fx.Ct), null, fx.Ct); + await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [stranger], sequence.Folder, null, fx.Ct), null, fx.Ct); + var folder = fx.Paths.Sequence(sequence.Folder).Folder; + var before = FilesOf(folder); + + // This index still has the sequence in the folder the other sequence holds now: a proxy sent, a proxy pass and a + // thumbnail pass write nothing there. + Assert.Equal(ProxyStoreResult.Gone, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 2), fx.Ct)); + foreach (var pass in new Func>[] + { + () => images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct), + () => images.BuildThumbnailsAsync(fx.Archive, sequence, force: true, 0, (_, _) => ValueTask.CompletedTask, fx.Ct), + }) + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), (await Assert.ThrowsAsync(pass)).Message); + Assert.SequenceEqual(before, FilesOf(folder)); + } + + [Test] + public async Task AProxyPassLetsAnotherProcessReorganizeBetweenItsBatches() + { + await using var fx = await CreateAsync(context); + Guid id = default; + for (var i = 0; i < 4; i++) + { + var staged = fx.Stage(Start.AddSeconds(10 * i), 60 + i); + id = (await fx.Service.Ingest.CommitAsync(new IngestRequest(fx.Archive.Id, null, null, "batches", staged.Path, $"IMG_{i + 1:0000}.JPG", + staged.Size, staged.Sha256, null, null), fx.Ct)).SequenceId; + } + var sequence = (await fx.Db.Sequences.GetAsync(id, fx.Ct))!; + var left = fx.Paths.Sequence(sequence.Folder).Folder; + // The second photo is read as a PNG, through the decoders (JPEGs are decoded without them), and slowly. + var sidecar = ManifestStore.ReadSequence(fx.Paths.Sequence(sequence.Folder).ManifestPath); + ManifestStore.WriteSequence(fx.Paths.Sequence(sequence.Folder).ManifestPath, sidecar with + { + Frames = [.. sidecar.Frames.Select(f => f.I == 1 ? f with { Format = ImageFileFormat.Png } : f)], + }); + var gate = new GateDecoder { Hold = Path.GetFileName(sidecar.Frames[1].File) }; + var (server, archive) = await fx.OtherWriterAsync(); + var plan = await server.PlanRenameAsync(archive.Id, [id], "moved/{date}", null, fx.Ct); + var moved = fx.Paths.Sequence(plan.Steps.Single().ToFolder); + + // A proxy pass here, one photo at a time, in batches of a quarter of its lease wait. + var batch = TimeSpan.FromSeconds(TestTiming.Budget(2)); + var here = new ArchiveService(fx.Db, new ArchiveServiceOptions + { + Owner = "test", + LeaseWait = batch * 4, + Decoder = new ImageDecoder([gate]), + Parallelism = () => 1, + }); + var pass = Task.Run(() => here.Images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct)); + await Task.WhenAny(gate.Holding.Task, pass).WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); + if (pass.IsCompleted) Assert.Fail($"The pass ended before the held photo: {await pass}"); + var held = DateTime.UtcNow; + + // Another process sharing the archive reorganizes the sequence: it holds the sequence, then waits for the thumbnail lease. + var move = Task.Run(() => server.ApplyRenameAsync(plan, null, fx.Ct)); + var until = DateTime.UtcNow + TimeSpan.FromSeconds(TestTiming.Budget(30)); + while (LeaseFile.Holder(fx.Paths.LocksDirectory, $"seq-{id:N}")?.Owner != "other") + { + Assert.False(move.IsCompleted, "the Reorganize waits for the pass"); + Assert.True(DateTime.UtcNow < until, "the Reorganize holds the sequence"); + await Task.Delay(20, fx.Ct); + } + var rest = held + batch + TimeSpan.FromSeconds(0.5) - DateTime.UtcNow; + if (rest > TimeSpan.Zero) await Task.Delay(rest, fx.Ct); + gate.Release(); + + // The batch ends with that photo and lets the lease go: the Reorganize moves the folder before the pass ends, and the + // pass, finding the folder gone from where this index has it, stops there. + await move.WaitAsync(TimeSpan.FromSeconds(TestTiming.Budget(60)), fx.Ct); + var stopped = await Assert.ThrowsAsync(() => pass); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), stopped.Message); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + Assert.FileExists(moved.Proxy(0)); + Assert.FileExists(moved.Proxy(1)); + Assert.FileMissing(moved.Proxy(2)); + } + [Test] public async Task AProxyLeftByARenumberedFrameIsAskedForAgain() { @@ -99,8 +243,8 @@ public sealed class ProxyTests(TestContext context) // A client or render node sending one that small is refused; one of the policy's size (1920 px) is kept. var frame = frames[0] with { Width = 4032, Height = 3024 }; - Assert.Equal(ProxyStoreResult.TooSmall, images.StoreProxy(fx.Archive, sequence, frame, Proxy(frame.CapturedAt!.Value, 6, 160, 120))); - Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frame, Proxy(frame.CapturedAt!.Value, 7, 1920, 1440))); + Assert.Equal(ProxyStoreResult.TooSmall, await images.StoreProxyAsync(fx.Archive, sequence, frame, Proxy(frame.CapturedAt!.Value, 6, 160, 120), fx.Ct)); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, sequence, frame, Proxy(frame.CapturedAt!.Value, 7, 1920, 1440), fx.Ct)); var again = await images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); Assert.Equal((0, 1, 0, 1), (again.Built, again.Reused, again.Undecodable, again.Waiting)); Assert.FileExists(folder.Proxy(0)); @@ -114,7 +258,7 @@ public sealed class ProxyTests(TestContext context) var manifest = ManifestStore.ReadArchive(fx.Paths.ManifestPath); ManifestStore.WriteArchive(fx.Paths.ManifestPath, manifest with { ProxyPolicy = new ProxyPolicy { LongEdge = ProxyPolicy.Disabled } }); - Assert.Equal(ProxyStoreResult.Disabled, fx.Service.Images.StoreProxy(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 4))); + Assert.Equal(ProxyStoreResult.Disabled, await fx.Service.Images.StoreProxyAsync(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 4), fx.Ct)); Assert.FileMissing(fx.Paths.Sequence(sequence.Folder).Proxy(0)); } @@ -170,7 +314,7 @@ public sealed class ProxyTests(TestContext context) // A client makes one from the index's time: it is kept, and the next pass reuses it rather than making its own. var sent = Proxy(frame.CapturedAt!.Value, 1); - Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frame, sent)); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, sequence, frame, sent, fx.Ct)); var again = await images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); Assert.Equal((0, 1), (again.Built, again.Reused)); Assert.SequenceEqual(sent, await File.ReadAllBytesAsync(folder.Proxy(0), fx.Ct)); @@ -264,7 +408,7 @@ public sealed class ProxyTests(TestContext context) await using var fx = await CreateAsync(context); var (sequence, frames) = await HeifSequenceAsync(fx); var images = fx.Service.Images; - Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frames[1], Proxy(frames[1].CapturedAt!.Value, 1))); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, sequence, frames[1], Proxy(frames[1].CapturedAt!.Value, 1), fx.Ct)); // A pass resumed at frame 1 (paused, retried or restarted) finds that frame done, but frame 0 still waits: the // status must not tell a server's clients that nothing is wanted. @@ -272,7 +416,7 @@ public sealed class ProxyTests(TestContext context) Assert.Equal((0, 1, 0, 0), (resumed.Built, resumed.Reused, resumed.Undecodable, resumed.Waiting)); Assert.False(await ProxiesBuiltAsync(fx, sequence), "frame 0 has no proxy"); - Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 2))); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 2), fx.Ct)); await images.BuildProxiesAsync(fx.Archive, sequence, force: false, 1, (_, _) => ValueTask.CompletedTask, fx.Ct); Assert.True(await ProxiesBuiltAsync(fx, sequence), "every frame has its proxy"); } @@ -290,7 +434,7 @@ public sealed class ProxyTests(TestContext context) { Frames = [.. sidecar.Frames.Select(f => f with { Tier = DecodeTier.EmbeddedPreview, Flags = f.Flags | FrameFlags.PreviewOnly, PreviewW = 160, PreviewH = 120 })], }); - Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 1))); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 1), fx.Ct)); // Frame 0 now renders from its proxy, not from the thumbnail: it caps nothing. Its tier stays the original's. await images.BuildProxiesAsync(fx.Archive, sequence, force: false, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); @@ -315,7 +459,7 @@ public sealed class ProxyTests(TestContext context) var (sequence, frames) = await HeifSequenceAsync(fx); var folder = fx.Paths.Sequence(sequence.Folder); var images = fx.Service.Images; - Assert.Equal(ProxyStoreResult.Stored, images.StoreProxy(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 1, 640, 480))); + Assert.Equal(ProxyStoreResult.Stored, await images.StoreProxyAsync(fx.Archive, sequence, frames[0], Proxy(frames[0].CapturedAt!.Value, 1, 640, 480), fx.Ct)); Task ThumbnailsAsync(bool force = false) => images.BuildThumbnailsAsync(fx.Archive, sequence, force, 0, (_, _) => ValueTask.CompletedTask, fx.Ct); (int, int) Entry() diff --git a/tests/Chronos.Data.Tests/Archiving/ReorganizeTests.cs b/tests/Chronos.Data.Tests/Archiving/ReorganizeTests.cs new file mode 100644 index 00000000..dde4c690 --- /dev/null +++ b/tests/Chronos.Data.Tests/Archiving/ReorganizeTests.cs @@ -0,0 +1,1353 @@ +using System.Collections.Concurrent; +using System.Security.Cryptography; +using Chronos.Core.Archiving; +using Chronos.Core.Import; +using Chronos.Core.Localization; +using Chronos.Core.Model; +using Chronos.Core.Naming; +using Chronos.Data.Archiving; +using Chronos.Data.Archiving.Jobs; +using Chronos.Data.Jobs; +using Chronos.Data.Repositories; +using Chronos.Testing; +using static Chronos.Data.Tests.Archiving.ArchiveFixture; + +namespace Chronos.Data.Tests.Archiving; + +/// +/// Reorganize (owner review 2, R7): new folder, file and title templates applied to sequences already in the archive, with a +/// dry run, two-phase file renames under a journal, crash recovery, stale plans and the move job. +/// +[Category("archive")] +public sealed class ReorganizeTests(TestContext context) +{ + private static IngestRequest Upload(ArchiveFixture fx, (string Path, long Size, string Sha256) staged, string name, string key) => + new(fx.Archive.Id, null, null, key, staged.Path, name, staged.Size, staged.Sha256, null, null); + + /// Uploads photos ten seconds apart (from ) into the sequence of ; returns its id. + private static async Task UploadAsync(ArchiveFixture fx, int count, int firstSeed = 1, int firstSecond = 0, string key = "upload-1") + { + Guid id = default; + for (var i = 0; i < count; i++) + { + var staged = fx.Stage(Start.AddSeconds(firstSecond + 10 * i), firstSeed + i); + id = (await fx.Service.Ingest.CommitAsync(Upload(fx, staged, $"IMG_{firstSeed + i:0000}.JPG", key), fx.Ct)).SequenceId; + } + return id; + } + + /// + /// A sequence whose names follow "{n:0}" no more: two photos filed as 1 and 2, then an earlier one filed before them as 1_2. + /// Renamed with "{n:0}" again they chain: 1_2→1, 1→2, 2→3. + /// + private static async Task ChainAsync(ArchiveFixture fx) + { + await fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { File = "{n:0}" } }, fx.Ct); + await UploadAsync(fx, 2, firstSeed: 2, firstSecond: 10); + var id = await UploadAsync(fx, 1, firstSeed: 1); + Assert.SequenceEqual(["originals/1_2.JPG", "originals/1.JPG", "originals/2.JPG"], await FilesAsync(fx, id)); + return id; + } + + /// + /// The files of a sequence as its sidecar names them, after checking that the index names the same files in the same + /// order at the same frames version, that every file holds its frame's photo and that no journal is left. + /// + private static async Task> FilesAsync(ArchiveFixture fx, Guid id) + { + var sequence = Assert.NotNull(await fx.Db.Sequences.GetAsync(id)); + var folder = fx.Paths.Sequence(sequence.Folder); + var sidecar = ManifestStore.ReadSequence(folder.ManifestPath); + var rows = await fx.Db.Frames.ListBySequenceAsync(id); + Assert.SequenceEqual(sidecar.Frames.Select(f => f.Id), rows.Select(r => r.Id)); + Assert.Equal(sidecar.Versions.Frames, sequence.FramesVersion); + Assert.Equal(sidecar.Title, sequence.Title); + foreach (var (frame, row) in sidecar.Frames.Zip(rows)) + { + Assert.Equal(folder.ArchiveRelative(frame.File), row.RelativePath); + Assert.Equal(Path.GetFileName(frame.File), row.FileName); + Assert.Equal(frame.Sha256, Convert.ToHexStringLower(SHA256.HashData(File.ReadAllBytes(folder.File(frame.File))))); + } + Assert.Null(FileRenameJournal.Read(folder)); + Assert.Empty(Directory.EnumerateFiles(folder.Originals, ".chronos-rename-*")); + return [.. sidecar.Frames.Select(f => f.File)]; + } + + [Test] + public async Task FilesAreRenamedExactlyAsTheDryRunSaid() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 3); + var before = await FilesAsync(fx, id); + var version = (await fx.Db.Sequences.GetAsync(id))!.FramesVersion; + var templates = new RenameTemplates(File: "{title}_{n:000}", Title: "Roof"); + + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct); + var step = plan.Steps.Single(); + Assert.Equal((3, version, "Roof"), (step.FileChanges, step.FramesVersion, step.ToTitle)); + Assert.SequenceEqual(before.Zip(["originals/Roof_001.JPG", "originals/Roof_002.JPG", "originals/Roof_003.JPG"], (f, t) => $"{f}>{t}"), + step.FileSamples.Select(s => $"{s.From}>{s.To}")); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + + var result = await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.Equal(3, result.Files); + Assert.SequenceEqual([id], result.Changed); + Assert.SequenceEqual(["originals/Roof_001.JPG", "originals/Roof_002.JPG", "originals/Roof_003.JPG"], await FilesAsync(fx, id)); + Assert.Equal(version + 1, (await fx.Db.Sequences.GetAsync(id))!.FramesVersion); + Assert.Equal("Roof", (await fx.Db.Sequences.GetAsync(id))!.Title); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.Equal(0, (await fx.ScanAsync()).Indexed); + // Applied again, the templates change nothing. + Assert.False((await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct)).Steps.Any(s => s.Changes)); + } + + [Test] + public async Task ASecondReorganizeWithTheSameTemplatesPlansNothing() + { + await using var fx = await CreateAsync(context); + var first = await UploadAsync(fx, 2); + var second = await UploadAsync(fx, 2, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + // One day for both: the second sequence's folder gets " (2)". + var templates = new RenameTemplates(Folder: "days/{date}", File: "{date}_{n:000}"); + await fx.Service.ApplyRenameAsync(await fx.Service.PlanReorganizeAsync(fx.Archive.Id, null, templates, fx.Ct), null, fx.Ct); + var folders = new List(); + foreach (var id in new[] { first, second }) folders.Add((await fx.Db.Sequences.GetAsync(id))!.Folder); + Assert.SequenceEqual(["days/2026-09-28", "days/2026-09-28 (2)"], folders.Order(StringComparer.Ordinal)); + + var again = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, null, templates, fx.Ct); + Assert.Count(2, again.Subjects); + Assert.False(again.Steps.Any(s => s.Changes), string.Join(", ", again.Steps.Select(s => $"{s.FromFolder}>{s.ToFolder}"))); + } + + [Test] + public async Task UploadsAndImportsAreNamedAsReorganizeNamesThem() + { + await using var fx = await CreateAsync(context); + await UploadAsync(fx, 3); + var card = context.CreateTempDirectory("card"); + Photos.WriteSeries(Path.Combine(card, "DCIM", "100CANON"), Start.AddDays(1), 4, firstSeed: 30); + var import = await fx.Service.PlanImportAsync(fx.Archive.Id, card, + new ImportOptions { FolderTemplate = fx.Archive.FolderTemplate, FileTemplate = fx.Archive.FileTemplate }, null, null, fx.Ct); + var engine = await fx.StartEngineAsync(); + await fx.WaitForAsync((await engine.EnqueueAsync(ArchiveJobs.Import(fx.Archive, import, null), cancellationToken: fx.Ct)).Id, JobState.Done); + Assert.Count(2, await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)); + + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, null, new RenameTemplates(fx.Archive.FolderTemplate, fx.Archive.FileTemplate), fx.Ct); + Assert.Empty(plan.Steps); + Assert.Count(2, plan.Subjects); + } + + [Test] + public async Task UploadsAreFiledWithTheirSequencesCameraAndLensAsReorganizeNamesThem() + { + await using var fx = await CreateAsync(context); + const string FolderTemplate = "{year}/{date} {camera} {ext}", FileTemplate = "{camera}_{lens}_{n:0000}"; + await fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { Folder = FolderTemplate, File = FileTemplate } }, fx.Ct); + // A sequence created with the camera it is for, whose photos name none: the hint names them. + var hinted = new Sequence + { + Id = Guid.CreateVersion7(), + ArchiveId = fx.Archive.Id, + Title = "Roof", + Folder = string.Empty, + CameraModel = "GoPro HERO12 Black", + Origin = SequenceOrigin.Server, + UpdatedAt = DateTimeOffset.UtcNow, + }; + await fx.Db.Sequences.UpsertAsync(hinted, fx.Ct); + for (var i = 0; i < 2; i++) + { + var staged = fx.Stage(Start.AddSeconds(10 * i), 40 + i, make: null, model: null); + await fx.Service.Ingest.CommitAsync(new IngestRequest(fx.Archive.Id, hinted.Id, null, null, staged.Path, $"GOPR{i:0000}.JPG", staged.Size, + staged.Sha256, null, null), fx.Ct); + } + // A lens changed during a session: its photos take the first one's, as the sequence does. + Guid lensed = default; + foreach (var (lens, i) in new[] { "RF15-35mm", "RF24-70mm" }.Select((l, i) => (l, i))) + { + var staged = fx.Stage(Start.AddHours(2).AddSeconds(10 * i), 50 + i, lens: lens); + lensed = (await fx.Service.Ingest.CommitAsync(Upload(fx, staged, $"IMG_{i:0000}.JPG", "upload-2"), fx.Ct)).SequenceId; + } + + Assert.SequenceEqual(["originals/GoPro HERO12 Black__0001.JPG", "originals/GoPro HERO12 Black__0002.JPG"], await FilesAsync(fx, hinted.Id)); + Assert.Equal("2026/2026-09-28 GoPro HERO12 Black JPG", (await fx.Db.Sequences.GetAsync(hinted.Id))!.Folder); + Assert.SequenceEqual(["originals/Canon EOS R5_RF15-35mm_0001.JPG", "originals/Canon EOS R5_RF15-35mm_0002.JPG"], await FilesAsync(fx, lensed)); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, null, new RenameTemplates(FolderTemplate, FileTemplate), fx.Ct); + Assert.Count(2, plan.Subjects); + Assert.Empty(plan.Steps); + } + + [Test] + public async Task AnUploadWithoutACaptureTimeIsFiledAsReorganizeNamesIt() + { + await using var fx = await CreateAsync(context); + const string FolderTemplate = "{year}/{date} {hm}", FileTemplate = "{date}_{time}_{n:0000}"; + await fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { Folder = FolderTemplate, File = FileTemplate } }, fx.Ct); + // Photos that record no time: the first takes its file's, the second the one its client sent; never the time they are filed. + var noon = new DateTime(2026, 9, 28, 12, 0, 0); + var first = fx.Stage(null, 60); + File.SetLastWriteTime(first.Path, noon); + var id = (await fx.Service.Ingest.CommitAsync(Upload(fx, first, "IMG_0001.JPG", "upload-1"), fx.Ct)).SequenceId; + var second = fx.Stage(null, 61); + await fx.Service.Ingest.CommitAsync(Upload(fx, second, "IMG_0002.JPG", "upload-1") with { ClientCapturedAt = noon.AddSeconds(10) }, fx.Ct); + + Assert.Equal("2026/2026-09-28 12-00", (await fx.Db.Sequences.GetAsync(id))!.Folder); + Assert.SequenceEqual(["originals/2026-09-28_12-00-00_0001.JPG", "originals/2026-09-28_12-00-10_0002.JPG"], await FilesAsync(fx, id)); + Assert.Empty((await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(FolderTemplate, FileTemplate), fx.Ct)).Steps); + } + + [Test] + public async Task APhotoSkippedMidSessionLeavesNumbersThatReorganizeCloses() + { + await using var fx = await CreateAsync(context); + // The card's second photo is in the archive already (uploaded before): the import skips it. + var day = Start.AddDays(1); + await fx.Service.Ingest.CommitAsync(Upload(fx, fx.Stage(day.AddSeconds(10), 31), "IMG_0002.JPG", "upload-1"), fx.Ct); + var card = context.CreateTempDirectory("card"); + Photos.WriteSeries(Path.Combine(card, "DCIM", "100CANON"), day, 4, firstSeed: 30); + const string FileTemplate = "{date}_{n:0000}"; + var import = await fx.Service.PlanImportAsync(fx.Archive.Id, card, new ImportOptions { FolderTemplate = "{year}/{date} card", FileTemplate = FileTemplate }, + null, null, fx.Ct); + Assert.SequenceEqual([ImportAction.Copy, ImportAction.SkipInArchive, ImportAction.Copy, ImportAction.Copy], import.Sessions.Single().Items.Select(i => i.Action)); + var engine = await fx.StartEngineAsync(); + await fx.WaitForAsync((await engine.EnqueueAsync(ArchiveJobs.Import(fx.Archive, import, null), cancellationToken: fx.Ct)).Id, JobState.Done); + + // Filed with the numbers the import showed, the skipped photo's left out; Reorganize numbers the sequence as it is + // now, which its dry run lists (a divergence FrameNaming names). + var imported = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == "2026/2026-09-29 card").Id; + Assert.SequenceEqual(["originals/2026-09-29_0001.JPG", "originals/2026-09-29_0003.JPG", "originals/2026-09-29_0004.JPG"], await FilesAsync(fx, imported)); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [imported], new RenameTemplates(File: FileTemplate), fx.Ct); + Assert.SequenceEqual(["originals/2026-09-29_0003.JPG>originals/2026-09-29_0002.JPG", "originals/2026-09-29_0004.JPG>originals/2026-09-29_0003.JPG"], + plan.Steps.Single().FileSamples.Select(s => $"{s.From}>{s.To}")); + } + + [Test] + public async Task ASequenceWhoseSidecarCannotBeReadStaysAsItIsAndTheOthersMove() + { + await using var fx = await CreateAsync(context); + var good = await UploadAsync(fx, 2); + var torn = await UploadAsync(fx, 2, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + var foreign = await UploadAsync(fx, 2, firstSeed: 30, firstSecond: 7200, key: "upload-3"); + var last = await UploadAsync(fx, 2, firstSeed: 40, firstSecond: 10800, key: "upload-4"); + async Task FolderOf(Guid id) => fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder); + File.WriteAllText((await FolderOf(torn)).ManifestPath, "{ \"schemaVersion\": 1, \"id\": "); + File.Copy((await FolderOf(good)).ManifestPath, (await FolderOf(foreign)).ManifestPath, overwrite: true); + var kept = new Dictionary(); + foreach (var id in new[] { torn, foreign }) kept[id] = (await fx.Db.Sequences.GetAsync(id))!.Folder; + + var templates = new RenameTemplates(Folder: "moved/{date}", Title: "{title} {hm}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, null, templates, fx.Ct); + foreach (var id in kept.Keys) + { + var step = plan.Steps.Single(s => s.SequenceId == id); + Assert.Equal((kept[id], step.FromTitle), (step.ToFolder, step.ToTitle)); + Assert.False(step.Changes); + Assert.Equal(RenameBlock.Unreadable, step.Blocked.Single().Reason); + } + // The one after them gets the " (2)" they never take. + Assert.Equal(("moved/2026-09-28 (2)", "21-00"), (plan.Steps.Single(s => s.SequenceId == last).ToFolder, plan.Steps.Single(s => s.SequenceId == last).ToTitle)); + + var result = await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.SequenceEqual([good, last], result.Changed); + Assert.Equal("moved/2026-09-28", (await fx.Db.Sequences.GetAsync(good))!.Folder); + foreach (var id in kept.Keys) Assert.Equal(kept[id], (await fx.Db.Sequences.GetAsync(id))!.Folder); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.Equal(0, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct)); + } + + [Test] + public async Task AChainOfNewNamesIsRenamedThroughTemporaryNames() + { + await using var fx = await CreateAsync(context); + var id = await ChainAsync(fx); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(File: "{n:0}"), fx.Ct); + Assert.Equal(3, plan.Steps.Single().FileChanges); + await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.SequenceEqual(["originals/1.JPG", "originals/2.JPG", "originals/3.JPG"], await FilesAsync(fx, id)); + } + + [Theory] + [Case(1)] + [Case(2)] + public async Task ARenameACrashInterruptedIsCompletedAtTheNextOpen(int phase) + { + await using var fx = await CreateAsync(context); + var id = await ChainAsync(fx); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(File: "{n:0}"), fx.Ct); + + // The process stopped inside the step: the plan's journal and the sequence's, files part-way through their phase. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder); + var manifest = ManifestStore.ReadSequence(folder.ManifestPath); + var moves = FileRenames.Plan(manifest, null, PathTemplate.Parse("{n:0}"), FileRenames.ListPresent(folder, manifest)).Moves; + var journal = FileRenameJournal.Create(manifest.Versions.Frames, moves, "crash") with { Phase = phase }; + FileRenameJournal.Write(folder, journal); + File.Move(folder.File(journal.Files[0].From), folder.File(journal.Files[0].Temp)); + if (phase == 2) + { + foreach (var file in journal.Files.Skip(1)) File.Move(folder.File(file.From), folder.File(file.Temp)); + File.Move(folder.File(journal.Files[0].Temp), folder.File(journal.Files[0].To)); + } + + await fx.Service.OpenAsync(fx.Archive.RootPath, fx.Ct); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.SequenceEqual(["originals/1.JPG", "originals/2.JPG", "originals/3.JPG"], await FilesAsync(fx, id)); + Assert.Equal(manifest.Versions.Frames + 1, (await fx.Db.Sequences.GetAsync(id))!.FramesVersion); + } + + [Test] + public async Task APlanWhosePhotosChangedAppliesWithoutTheirNames() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 2); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(File: "{n:000}", Title: "Roof"), fx.Ct); + // A photo arrives after the dry run, filed between them: the names shown are no longer the ones the template gives. + await UploadAsync(fx, 1, firstSeed: 9, firstSecond: 5); + var before = await FilesAsync(fx, id); + + // The title changes, the files keep their names. + var result = await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.SequenceEqual([id], result.FilesKept); + Assert.SequenceEqual([id], result.Changed); + Assert.Equal(0, result.Files); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + Assert.Equal("Roof", (await fx.Db.Sequences.GetAsync(id))!.Title); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task PhotosReceivedUnderTheNamesThePlanGivesLeaveItAsItWas() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 2); + // The archive files new photos as the Reorganize names them, which its photos do not follow yet. + const string Template = "{n:000}"; + await fx.Service.UpdateSettingsAsync(fx.Archive.Id, s => s with { Templates = s.Templates with { File = Template } }, fx.Ct); + var templates = new RenameTemplates(File: Template); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct); + Assert.Equal(2, plan.Steps.Single().FileChanges); + var request = ArchiveJobs.Reorganize(fx.Archive, plan, templates); + + // A camera still uploads into it: its photo is filed under the name the plan leaves it, which changes nothing of the plan. + await UploadAsync(fx, 1, firstSeed: 3, firstSecond: 20); + Assert.Equal("originals/003.JPG", (await FilesAsync(fx, id))[2]); + var now = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct); + Assert.NotEqual(plan.Steps.Single().FramesVersion, now.Steps.Single().FramesVersion); + Assert.Equal(plan.Fingerprint(), now.Fingerprint()); + + // The job confirmed before it applies it as it was shown. + var engine = await fx.StartEngineAsync(); + var done = await fx.WaitForAsync((await engine.EnqueueAsync(request, cancellationToken: fx.Ct)).Id, JobState.Done); + Assert.Contains(Loc.L("Archive.Log.Reorganized", 1, 2), done.LogTail); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG", "originals/003.JPG"], await FilesAsync(fx, id)); + } + + [Test] + public async Task CompanionsMoveWithTheirPhoto() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 2); + var before = await FilesAsync(fx, id); + var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder); + File.WriteAllText(folder.File(Path.ChangeExtension(before[0], ".xmp")), "first"); + File.WriteAllText(folder.File(before[1] + ".xmp"), "second"); + await fx.ScanAsync(); + + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(File: "{n:000}"), fx.Ct); + Assert.Equal(2, plan.Steps.Single().FileChanges); + await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG"], await FilesAsync(fx, id)); + Assert.Equal("first", File.ReadAllText(folder.File("originals/001.xmp"))); + Assert.Equal("second", File.ReadAllText(folder.File("originals/002.JPG.xmp"))); + Assert.SequenceEqual(["001.JPG", "001.xmp", "002.JPG", "002.JPG.xmp"], Directory.EnumerateFiles(folder.Originals).Select(Path.GetFileName).Order(StringComparer.Ordinal)); + Assert.Equal(0, (await fx.ScanAsync()).Indexed); + } + + [Test] + public async Task PhotosAdoptedInPlaceKeepTheirNames() + { + await using var fx = await CreateAsync(context); + Photos.WriteSeries(Path.Combine(fx.Paths.Root, "inbox", "a"), Start, 3); + await fx.ScanAsync(); + var id = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single().Id; + + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(File: "{n:000}"), fx.Ct); + var step = plan.Steps.Single(); + Assert.False(step.Changes); + Assert.Equal((RenameBlock.InPlace, 3), (step.Blocked.Single().Reason, step.Blocked.Single().Frames)); + var result = await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.Empty(result.Changed); + Assert.SequenceEqual(["IMG_0001.JPG", "IMG_0002.JPG", "IMG_0003.JPG"], ManifestStore.ReadSequence(fx.Paths.Sequence("inbox/a").ManifestPath).Frames.Select(f => f.File)); + } + + [Test] + public async Task AMoveJobAppliesTheConfirmedPlanAndRefusesOneTheArchiveOutgrew() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 3); + var engine = await fx.StartEngineAsync(); + var templates = new RenameTemplates(Folder: "reorganized/{date}", File: "{n:000}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct); + var job = await engine.EnqueueAsync(ArchiveJobs.Reorganize(fx.Archive, plan, templates), cancellationToken: fx.Ct); + Assert.Equal(JobKind.Move, job.Kind); + var done = await fx.WaitForAsync(job.Id, JobState.Done); + Assert.Equal((1, 1), (done.ProgressDone, done.ProgressTotal)); + Assert.Contains(Loc.L("Archive.Log.Reorganized", 1, 3), done.LogTail); + Assert.Equal("reorganized/2026-09-28", (await fx.Db.Sequences.GetAsync(id))!.Folder); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG", "originals/003.JPG"], await FilesAsync(fx, id)); + + var back = new RenameTemplates(File: "{date}_{n:0000}"); + var again = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], back, fx.Ct); + await UploadAsync(fx, 1, firstSeed: 9, firstSecond: 5); + var before = await FilesAsync(fx, id); + var refused = await fx.WaitForAsync((await engine.EnqueueAsync(ArchiveJobs.Reorganize(fx.Archive, again, back), cancellationToken: fx.Ct)).Id, JobState.Failed); + Assert.Equal(Loc.L("Archive.Error.StalePlan"), refused.Error); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task AHeldPlanWaitsForItsJob() + { + await using var fx = await CreateAsync(context); + var first = await UploadAsync(fx, 2); + var second = await UploadAsync(fx, 2, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + var templates = new RenameTemplates(File: "{n:000}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [first, second], templates, fx.Ct); + Assert.Count(2, plan.Steps); + var untouched = await FilesAsync(fx, second); + + // The job stops after the first sequence (paused) and holds its plan: an archive open leaves the rest alone. + using var cts = new CancellationTokenSource(); + await Assert.ThrowsAsync(() => fx.Service.Renamer.ApplyAsync(fx.Archive, plan, null, (_, _) => + { + cts.Cancel(); + return ValueTask.CompletedTask; + }, cts.Token)); + Assert.True(MassRenamer.Hold(fx.Archive, plan.Id)); + Assert.Equal(0, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct)); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG"], await FilesAsync(fx, first)); + Assert.SequenceEqual(untouched, await FilesAsync(fx, second)); + Assert.True(Assert.NotNull(RenameJournal.Read(fx.Paths, plan.Id)).Held); + + // Resumed from its checkpoint, the job completes it and counts the whole plan; once its journal is gone a run finds the plan complete. + var engine = await fx.StartEngineAsync(); + var request = ArchiveJobs.Reorganize(fx.Archive, plan, templates); + var resumed = await fx.WaitForAsync((await fx.EnqueueWithCheckpointAsync(engine, request, "plan:" + plan.Id.ToString("N"))).Id, JobState.Done); + Assert.Contains(Loc.L("Archive.Log.Reorganized", 2, 4), resumed.LogTail); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG"], await FilesAsync(fx, second)); + Assert.Null(RenameJournal.Read(fx.Paths, plan.Id)); + var later = await fx.WaitForAsync((await fx.EnqueueWithCheckpointAsync(engine, request, "plan:" + plan.Id.ToString("N"))).Id, JobState.Done); + Assert.Contains(Loc.L("Archive.Log.ReorganizedEarlier"), later.LogTail); + } + + /// + /// An uploaded sequence with a nested one adopted from a subfolder of its folder ("extra"), planned to move to + /// "moved/{date}" with new file names: the nested one is carried. + /// + private static async Task<(Guid Parent, Guid Nested, RenamePlan Plan)> CarrierAsync(ArchiveFixture fx) + { + var parent = await UploadAsync(fx, 2); + var folder = (await fx.Db.Sequences.GetAsync(parent))!.Folder; + Photos.WriteSeries(Path.Combine(fx.Paths.FromRelative(folder), "extra"), Start.AddDays(3), 2, firstSeed: 50); + await fx.ScanAsync(); + var nested = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == folder + "/extra").Id; + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [parent], new RenameTemplates(Folder: "moved/{date}", File: "{n:000}"), fx.Ct); + Assert.SequenceEqual([(parent, false, 2), (nested, true, 0)], plan.Steps.Select(s => (s.SequenceId, s.Carried, s.FileChanges))); + return (parent, nested, plan); + } + + /// The folder of a sequence as the index has it, after checking that every frame the index lists is on disk there. + private static async Task FolderAsync(ArchiveFixture fx, Guid id) + { + var sequence = Assert.NotNull(await fx.Db.Sequences.GetAsync(id)); + foreach (var frame in await fx.Db.Frames.ListBySequenceAsync(id)) + { + Assert.True(frame.RelativePath.StartsWith(sequence.Folder + "/", StringComparison.Ordinal), frame.RelativePath); + Assert.FileExists(fx.Paths.FromRelative(frame.RelativePath)); + } + return sequence.Folder; + } + + [Test] + public async Task AStepWhosePhotosChangedUnderItsLeasesMovesWithoutRenamingThem() + { + await using var fx = await CreateAsync(context); + var (parent, nested, plan) = await CarrierAsync(fx); + + // A photo uploaded once the plan's own checks passed, before its step: the folder moves with the one inside it, + // whose index row follows, and the files keep their names. + var result = await fx.Service.Renamer.ApplyAsync(fx.Archive, plan, async _ => await UploadAsync(fx, 1, firstSeed: 9, firstSecond: 5), null, fx.Ct); + Assert.SequenceEqual([parent], result.FilesKept); + Assert.SequenceEqual([parent, nested], result.Changed); + Assert.Equal(("moved/2026-09-28", "moved/2026-09-28/extra"), (await FolderAsync(fx, parent), await FolderAsync(fx, nested))); + var files = await FilesAsync(fx, parent); + Assert.Count(3, files); + Assert.Empty(files.Intersect(plan.Steps[0].FileSamples.Select(s => s.To))); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task ASequenceStillReceivingPhotosKeepsItsFileNamesWhileTheJobGoesOn() + { + await using var fx = await CreateAsync(context); + var first = await UploadAsync(fx, 2); + var second = await UploadAsync(fx, 2, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + var third = await UploadAsync(fx, 2, firstSeed: 40, firstSecond: 7200, key: "upload-3"); + var templates = new RenameTemplates(Folder: "moved/{date} {hm}", File: "{n:000}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [first, second, third], templates, fx.Ct); + var told = new ConcurrentQueue(); + var service = new ArchiveService(fx.Db, new ArchiveServiceOptions + { + Owner = "jobs", + LeaseWait = TimeSpan.FromSeconds(TestTiming.Budget(20)), + SequenceChanged = (id, _, _) => + { + told.Enqueue(id); + return Task.CompletedTask; + }, + }); + await using var engine = new JobEngine(fx.Db, service.CreateJobHandlers(), + new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) }); + await engine.StartAsync(fx.Ct); + + // A camera uploads into the second sequence while the job waits for the first. + Job job; + using (await LeaseFile.AcquireAsync(fx.Paths.LocksDirectory, $"seq-{first:N}", "editor", TimeSpan.FromSeconds(5), cancellationToken: fx.Ct)) + { + job = await engine.EnqueueAsync(ArchiveJobs.Reorganize(fx.Archive, plan, templates), cancellationToken: fx.Ct); + var until = DateTime.UtcNow.AddSeconds(TestTiming.Budget(15)); + while (RenameJournal.ListPending(fx.Paths).Count == 0) + { + Assert.True(DateTime.UtcNow < until, "the job never started its plan"); + await Task.Delay(20, fx.Ct); + } + await UploadAsync(fx, 1, firstSeed: 30, firstSecond: 3605, key: "upload-2"); + } + var received = await FilesAsync(fx, second); + + // Its folder moves and its files keep their names; the sequence after it is reorganized; the job then says why it failed. + var failed = await fx.WaitForAsync(job.Id, JobState.Failed, (int)TestTiming.Budget(60)); + Assert.Equal(Loc.Plural("Archive.Error.ReorganizeKept", 1), failed.Error); + Assert.Contains(Loc.L("Archive.Log.Reorganized", 3, 4), failed.LogTail); + Assert.Contains(Loc.L("Archive.Log.ReorganizeFilesKept", plan.Steps.Single(s => s.SequenceId == second).FromFolder), failed.LogTail); + Assert.Equal(("moved/2026-09-28 18-00", "moved/2026-09-28 19-00", "moved/2026-09-28 20-00"), + (await FolderAsync(fx, first), await FolderAsync(fx, second), await FolderAsync(fx, third))); + Assert.SequenceEqual(received, await FilesAsync(fx, second)); + foreach (var id in new[] { first, third }) Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG"], await FilesAsync(fx, id)); + Assert.SequenceEqual([first, second, third], told); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task AFileThatCannotTakeItsNewNameKeepsTheNamesAndTheStepCompletes() + { + await using var fx = await CreateAsync(context); + var (parent, nested, plan) = await CarrierAsync(fx); + var before = await FilesAsync(fx, parent); + // A folder holds the name the second photo gets: that file cannot move there, so every file goes back to its name. + var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(parent))!.Folder); + Directory.CreateDirectory(folder.File(plan.Steps[0].FileSamples[1].To)); + + var result = await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.SequenceEqual([parent], result.FilesBusy); + Assert.SequenceEqual([parent, nested], result.Changed); + Assert.Equal(0, result.Files); + // The folder moved, the one inside it with it, both index rows followed, and the files kept their names. + Assert.Equal(("moved/2026-09-28", "moved/2026-09-28/extra"), (await FolderAsync(fx, parent), await FolderAsync(fx, nested))); + Assert.SequenceEqual(before, await FilesAsync(fx, parent)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task AFailedJobHoldsItsPlanAndTellsTheSequencesItChanged() + { + await using var fx = await CreateAsync(context); + var first = await UploadAsync(fx, 2); + var second = await UploadAsync(fx, 2, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + var templates = new RenameTemplates(File: "{n:000}", Title: "Roof"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [first, second], templates, fx.Ct); + var told = new ConcurrentQueue<(Guid, string)>(); + var service = new ArchiveService(fx.Db, new ArchiveServiceOptions + { + Owner = "jobs", + LeaseWait = TimeSpan.FromSeconds(TestTiming.Budget(20)), + SequenceChanged = (id, change, _) => + { + told.Enqueue((id, change)); + return Task.CompletedTask; + }, + }); + await using var engine = new JobEngine(fx.Db, service.CreateJobHandlers(), + new JobEngineOptions { Workers = 1, WorkerId = "test", PollInterval = TimeSpan.FromMilliseconds(50), CheckpointInterval = TimeSpan.FromMilliseconds(50) }); + await engine.StartAsync(fx.Ct); + + // An editor holds the first sequence while the job starts its plan (planned again: its own id); the second is retitled meanwhile. + Job job; + using (await LeaseFile.AcquireAsync(fx.Paths.LocksDirectory, $"seq-{first:N}", "editor", TimeSpan.FromSeconds(5), cancellationToken: fx.Ct)) + { + job = await engine.EnqueueAsync(ArchiveJobs.Reorganize(fx.Archive, plan, templates), cancellationToken: fx.Ct); + var until = DateTime.UtcNow.AddSeconds(TestTiming.Budget(15)); + while (RenameJournal.ListPending(fx.Paths).Count == 0) + { + Assert.True(DateTime.UtcNow < until, "the job never started its plan"); + await Task.Delay(20, fx.Ct); + } + await fx.Service.SetSequenceInfoAsync(second, "Roof north", [], 0, null, fx.Ct); + } + + var failed = await fx.WaitForAsync(job.Id, JobState.Failed, (int)TestTiming.Budget(60)); + Assert.Equal(Loc.L("Archive.Error.StalePlan"), failed.Error); + Assert.Contains(Loc.L("Archive.Log.Reorganized", 1, 2), failed.LogTail); + Assert.SequenceEqual([(first, MoveJobHandler.Change)], told); + var journal = RenameJournal.ListPending(fx.Paths).Single(); + Assert.True(journal.Held, "only the job's retry goes on with it"); + Assert.SequenceEqual([first], journal.Completed); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG"], await FilesAsync(fx, first)); + var untouched = await FilesAsync(fx, second); + Assert.Equal("Roof north", (await fx.Db.Sequences.GetAsync(second))!.Title); + + // An archive open leaves it alone; the retry checks the rest as a plan applied anew and gives it up. + Assert.Equal(0, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct)); + Assert.SequenceEqual(untouched, await FilesAsync(fx, second)); + var retried = await fx.WaitForAsync((await fx.EnqueueWithCheckpointAsync(engine, ArchiveJobs.Reorganize(fx.Archive, plan, templates), + "plan:" + journal.Plan.Id.ToString("N"))).Id, JobState.Failed, (int)TestTiming.Budget(60)); + Assert.Equal(Loc.L("Archive.Error.StalePlan"), retried.Error); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.SequenceEqual(untouched, await FilesAsync(fx, second)); + Assert.Count(1, told); + } + + [Test] + public async Task FileRenamesLeftHalfWayAreCompletedAtAnOpenWhileTheirPlanWaitsForItsJob() + { + await using var fx = await CreateAsync(context); + var id = await ChainAsync(fx); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(File: "{n:0}", Title: "Roof"), fx.Ct); + // Its job failed inside the step once every file reached its temporary name: the plan held, the sequence's journal left. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [], Held: true)); + var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder); + var manifest = ManifestStore.ReadSequence(folder.ManifestPath); + var moves = FileRenames.Plan(manifest, "Roof", PathTemplate.Parse("{n:0}"), FileRenames.ListPresent(folder, manifest)).Moves; + var journal = FileRenameJournal.Create(manifest.Versions.Frames, moves, "held") with { Phase = 2 }; + FileRenameJournal.Write(folder, journal); + foreach (var file in journal.Files) File.Move(folder.File(file.From), folder.File(file.Temp)); + + // Every photo goes on to its new name and the sidecar names it; the rest (the title) waits for the job. + await fx.Service.OpenAsync(fx.Archive.RootPath, fx.Ct); + Assert.SequenceEqual(["originals/1.JPG", "originals/2.JPG", "originals/3.JPG"], ManifestStore.ReadSequence(folder.ManifestPath).Frames.Select(f => f.File)); + Assert.Null(FileRenameJournal.Read(folder)); + Assert.Empty(Directory.EnumerateFiles(folder.Originals, ".chronos-rename-*")); + Assert.True(Assert.NotNull(RenameJournal.Read(fx.Paths, plan.Id)).Held); + Assert.Null((await fx.Db.Sequences.GetAsync(id))!.Title); + + // Its job's retry completes it: the index follows the sidecar and the title changes. + var result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.SequenceEqual([id], result.Changed); + Assert.SequenceEqual(["originals/1.JPG", "originals/2.JPG", "originals/3.JPG"], await FilesAsync(fx, id)); + Assert.Equal("Roof", (await fx.Db.Sequences.GetAsync(id))!.Title); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task ASequenceDeletedBeforeTheJobRanIsNamedAndThePlanRefused() + { + await using var fx = await CreateAsync(context); + var first = await UploadAsync(fx, 2); + var second = await UploadAsync(fx, 2, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + var templates = new RenameTemplates(File: "{n:000}"); + var request = ArchiveJobs.Reorganize(fx.Archive, await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [first, second], templates, fx.Ct), templates); + var before = await FilesAsync(fx, first); + // Deleted while the job waited in the queue. + await fx.Service.Trash.DeleteAsync(await fx.Service.Trash.PlanAsync([second], null, fx.Ct), null, null, fx.Ct); + + var engine = await fx.StartEngineAsync(); + var failed = await fx.WaitForAsync((await engine.EnqueueAsync(request, cancellationToken: fx.Ct)).Id, JobState.Failed); + Assert.Equal(Loc.L("Archive.Error.StalePlan"), failed.Error); + Assert.Contains(Loc.L("Archive.Log.SequenceMissing", second), failed.LogTail); + Assert.SequenceEqual(before, await FilesAsync(fx, first)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task ATitleEditedAfterThePlanIsNeverWrittenOver() + { + await using var fx = await CreateAsync(context); + var first = await UploadAsync(fx, 1); + var second = await UploadAsync(fx, 1, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + foreach (var id in new[] { first, second }) await fx.Service.SetSequenceInfoAsync(id, "Roof", [], 0, null, fx.Ct); + var templates = new RenameTemplates(Title: "{title} 2026"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [first, second], templates, fx.Ct); + + // Retitled once the first sequence is done: refused before anything of it changes. + var stale = await Assert.ThrowsAsync(() => fx.Service.Renamer.ApplyAsync(fx.Archive, plan, null, + async (_, _) => await fx.Service.SetSequenceInfoAsync(second, "Roof north", [], 0, null, fx.Ct), fx.Ct)); + Assert.Equal(second, stale.SequenceId); + Assert.Equal(("Roof 2026", "Roof north"), ((await fx.Db.Sequences.GetAsync(first))!.Title, (await fx.Db.Sequences.GetAsync(second))!.Title)); + await FilesAsync(fx, second); + + // Held by its job, the rest is refused as a plan applied anew. + Assert.True(MassRenamer.Hold(fx.Archive, plan.Id)); + await Assert.ThrowsAsync(() => fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.Null(RenameJournal.Read(fx.Paths, plan.Id)); + + // Interrupted, the rest resumes without it; an edit only the index has (the server's API) counts as well. + var again = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [second], templates, fx.Ct); + RenameJournal.Write(fx.Paths, new RenameJournal(again, [])); + await fx.Db.Sequences.EditAsync(second, new SequenceEdit { Title = "Roof south" }, null, fx.Ct); + var result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, again.Id, null, fx.Ct)); + Assert.SequenceEqual([second], result.Dropped); + Assert.Empty(result.Changed); + var row = Assert.NotNull(await fx.Db.Sequences.GetAsync(second)); + Assert.Equal(("Roof south", "Roof north"), (row.Title, ManifestStore.ReadSequence(fx.Paths.Sequence(row.Folder).ManifestPath).Title)); + } + + [Test] + public async Task ASidecarOfANewerFormatIsNeverRewrittenNorAreItsFilesRenamed() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 2); + var before = await FilesAsync(fx, id); + var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder); + var templates = new RenameTemplates(File: "{n:000}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct); + Assert.Equal(2, plan.Steps.Single().FileChanges); + + // A newer Chronos sharing the archive rewrote the sidecar after the dry run: refused before any file moves. + var json = File.ReadAllText(folder.ManifestPath); + Assert.Contains("\"schemaVersion\":1", json); + var newer = json.Replace("\"schemaVersion\":1", $"\"schemaVersion\":{SequenceManifest.CurrentSchemaVersion + 1}", StringComparison.Ordinal); + File.WriteAllText(folder.ManifestPath, newer); + await Assert.ThrowsAsync(() => fx.Service.ApplyRenameAsync(plan, null, fx.Ct)); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + // So is its step, under its lease, when the sidecar changes once the plan's own checks passed. + File.WriteAllText(folder.ManifestPath, json); + await Assert.ThrowsAsync(() => fx.Service.Renamer.ApplyAsync(fx.Archive, plan, _ => + { + File.WriteAllText(folder.ManifestPath, newer); + return ValueTask.CompletedTask; + }, null, fx.Ct)); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + Assert.Null(FileRenameJournal.Read(folder)); + + // Interrupted there, its job resumes the plan without its files and says why; a new dry run renames none of them. + var engine = await fx.StartEngineAsync(); + var failed = await fx.WaitForAsync((await fx.EnqueueWithCheckpointAsync(engine, ArchiveJobs.Reorganize(fx.Archive, plan, templates), + "plan:" + plan.Id.ToString("N"))).Id, JobState.Failed); + Assert.Equal(Loc.Plural("Archive.Error.ReorganizeNewer", 1), failed.Error); + Assert.Contains(Loc.L("Archive.Log.ReorganizeNewerKept", plan.Steps.Single().FromFolder), failed.LogTail); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + var again = (await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct)).Steps.Single(); + Assert.Equal((0, RenameBlock.Unreadable), (again.FileChanges, again.Blocked.Single().Reason)); + } + + [Test] + public async Task AFolderTakenAfterThePlanIsNeverMovedInto() + { + await using var fx = await CreateAsync(context); + var first = await UploadAsync(fx, 1); + var second = await UploadAsync(fx, 1, firstSeed: 20, firstSecond: 86400, key: "upload-2"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [first, second], new RenameTemplates(Folder: "moved/{date}"), fx.Ct); + Assert.SequenceEqual(["moved/2026-09-28", "moved/2026-09-29"], plan.Steps.Select(s => s.ToFolder)); + var from = await FolderAsync(fx, second); + var stranger = fx.Paths.FromRelative("moved/2026-09-29/note.txt"); + + // Once the first moved, something takes the second's new folder (a restore from the trash, a copy). + await Assert.ThrowsAsync(() => fx.Service.Renamer.ApplyAsync(fx.Archive, plan, null, (_, _) => + { + Directory.CreateDirectory(Path.GetDirectoryName(stranger)!); + File.WriteAllText(stranger, "kept"); + return ValueTask.CompletedTask; + }, fx.Ct)); + Assert.Equal(("moved/2026-09-28", from), (await FolderAsync(fx, first), await FolderAsync(fx, second))); + + // Held, the rest is refused before anything moves; interrupted, it is dropped. + Assert.True(MassRenamer.Hold(fx.Archive, plan.Id)); + await Assert.ThrowsAsync(() => fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [first])); + var result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.SequenceEqual([second], result.Dropped); + Assert.Equal(from, await FolderAsync(fx, second)); + Assert.Equal("kept", File.ReadAllText(stranger)); + Assert.SequenceEqual(["note.txt"], Directory.EnumerateFileSystemEntries(Path.GetDirectoryName(stranger)!).Select(Path.GetFileName)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task AChangeOfCaseOntoAnotherFolderOfThatExactNameIsRefusedBeforeItMoves() + { + await using var fx = await CreateAsync(context); + Directory.CreateDirectory(fx.Paths.FromRelative("probe")); + var caseSensitive = !Directory.Exists(fx.Paths.FromRelative("PROBE")); + Directory.Delete(fx.Paths.FromRelative("probe")); + if (!caseSensitive) TestContext.Skip("needs a case-sensitive file system, where two folders differ only in case"); + var id = await UploadAsync(fx, 1); + await fx.Service.ApplyRenameAsync(await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(Folder: "trip (2)"), fx.Ct), null, fx.Ct); + var templates = new RenameTemplates(Folder: "Trip"); + // Planned while no other folder holds that name: the folder keeps its number, in the template's case. + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct); + Assert.Equal("Trip (2)", plan.Steps.Single().ToFolder); + + // A folder of exactly that name appears beside it (a copy): refused before anything moves, and dropped when an + // interrupted plan resumes, instead of failing at every archive open. + var stranger = fx.Paths.FromRelative("Trip (2)/note.txt"); + Directory.CreateDirectory(Path.GetDirectoryName(stranger)!); + File.WriteAllText(stranger, "kept"); + await Assert.ThrowsAsync(() => fx.Service.ApplyRenameAsync(plan, null, fx.Ct)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + Assert.Equal(1, await fx.Service.Renamer.ResumePendingAsync(fx.Archive, fx.Ct)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.Equal("trip (2)", await FolderAsync(fx, id)); + + // Planned now, the sequence takes a folder of its own, and the other folder stays as it was. + var again = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct); + Assert.Equal("Trip", again.Steps.Single().ToFolder); + await fx.Service.ApplyRenameAsync(again, null, fx.Ct); + Assert.Equal("Trip", await FolderAsync(fx, id)); + Assert.Equal("kept", File.ReadAllText(stranger)); + Assert.SequenceEqual(["note.txt"], Directory.EnumerateFileSystemEntries(Path.GetDirectoryName(stranger)!).Select(Path.GetFileName)); + } + + [Test] + public async Task PhotosHashedAfterThePlanKeepTheNamesItShowed() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 3); + var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder); + var manifest = ManifestStore.ReadSequence(folder.ManifestPath); + // The second photo was never verified: the dry run says it keeps its name. + ManifestStore.WriteSequence(folder.ManifestPath, manifest with { Frames = [manifest.Frames[0], manifest.Frames[1] with { Sha256 = null }, manifest.Frames[2]] }); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(File: "{n:000}"), fx.Ct); + Assert.Equal((2, RenameBlock.Unhashed), (plan.Steps.Single().FileChanges, plan.Steps.Single().Blocked.Single().Reason)); + + // A verify hashes it afterwards, which leaves the frames version as it is: the plan would now rename it too, so none is. + ManifestStore.WriteSequence(folder.ManifestPath, manifest); + var before = await FilesAsync(fx, id); + var result = await fx.Service.ApplyRenameAsync(plan, null, fx.Ct); + Assert.SequenceEqual([id], result.FilesKept); + Assert.Empty(result.Changed); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + + // So it is when resumed after an interruption before its step. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.SequenceEqual([id], result.FilesKept); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + } + + [Test] + public async Task NamesComeFromATitleEditedAfterThePlanNever() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 2); + await fx.Service.SetSequenceInfoAsync(id, "Roof", [], 0, null, fx.Ct); + var from = await FolderAsync(fx, id); + // The folder and the files are named after the title, which the plan does not change. + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(Folder: "moved/{title}", File: "{title}_{n:000}"), fx.Ct); + Assert.True(plan.Steps.Single() is { ToFolder: "moved/Roof", FileChanges: 2, Retitles: false, NamedByTitle: true }); + var before = await FilesAsync(fx, id); + + // Retitled once the plan's own checks passed: refused before anything of it moves. + await Assert.ThrowsAsync(() => fx.Service.Renamer.ApplyAsync(fx.Archive, plan, + async _ => await fx.Service.SetSequenceInfoAsync(id, "Roof north", [], 0, null, fx.Ct), null, fx.Ct)); + Assert.Equal(from, await FolderAsync(fx, id)); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + + // Held by its job, the rest is refused as a plan applied anew; interrupted, it is dropped. + Assert.True(MassRenamer.Hold(fx.Archive, plan.Id)); + await Assert.ThrowsAsync(() => fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + var result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.SequenceEqual([id], result.Dropped); + Assert.Equal(from, await FolderAsync(fx, id)); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + Assert.Equal("Roof north", (await fx.Db.Sequences.GetAsync(id))!.Title); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task APlanAnArchiveOpenCompletesTellsTheSequencesItChanged() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 1); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(Folder: "moved/{date}"), fx.Ct); + // Its job yielded to another, or its host stopped, before the step: the plan is not held. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + var told = new ConcurrentQueue<(Guid, string)>(); + var service = new ArchiveService(fx.Db, new ArchiveServiceOptions + { + Owner = "test", + SequenceChanged = (sequence, change, _) => + { + told.Enqueue((sequence, change)); + return Task.CompletedTask; + }, + }); + + await service.OpenAsync(fx.Archive.RootPath, fx.Ct); + Assert.SequenceEqual([(id, MassRenamer.Change)], told); + Assert.Equal("moved/2026-09-28", await FolderAsync(fx, id)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + [WindowsOnly] + public async Task AMovedFolderWhoseSidecarCannotBeWrittenHasEveryIndexRowFollowIt() + { + await using var fx = await CreateAsync(context); + var parent = await UploadAsync(fx, 2); + var folder = (await fx.Db.Sequences.GetAsync(parent))!.Folder; + Photos.WriteSeries(Path.Combine(fx.Paths.FromRelative(folder), "extra"), Start.AddDays(3), 2, firstSeed: 50); + await fx.ScanAsync(); + var nested = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == folder + "/extra").Id; + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [parent], new RenameTemplates(Folder: "moved/{date}", Title: "Roof"), fx.Ct); + Assert.SequenceEqual([(parent, false), (nested, true)], plan.Steps.Select(s => (s.SequenceId, s.Carried))); + string[] sidecars = [fx.Paths.Sequence(folder).ManifestPath, fx.Paths.Sequence("moved/2026-09-28").ManifestPath]; + void Writable(bool writable) + { + foreach (var sidecar in sidecars.Where(File.Exists)) + File.SetAttributes(sidecar, writable ? File.GetAttributes(sidecar) & ~FileAttributes.ReadOnly : File.GetAttributes(sidecar) | FileAttributes.ReadOnly); + } + + try + { + // Its sidecar can be read, not written: the new title fails once the folder moved. + Writable(false); + await Assert.ThrowsAsync(() => fx.Service.ApplyRenameAsync(plan, null, fx.Ct)); + // Both index rows followed the folder all the same; the title waits for the rest of the step. + Assert.Equal(("moved/2026-09-28", "moved/2026-09-28/extra"), (await FolderAsync(fx, parent), await FolderAsync(fx, nested))); + Assert.Null((await fx.Db.Sequences.GetAsync(parent))!.Title); + Assert.Empty(Assert.NotNull(RenameJournal.Read(fx.Paths, plan.Id)).Completed); + } + finally + { + Writable(true); + } + + var result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.SequenceEqual([parent, nested], result.Changed); + Assert.Equal("Roof", (await fx.Db.Sequences.GetAsync(parent))!.Title); + await FilesAsync(fx, parent); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task AMovedFolderWhoseSidecarCannotBeReadThereHasItsIndexRowFollowAndIsTold() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 2); + var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder); + // The sidecar is a link, relative to where it lies, to a file outside the archive: one level deeper it leads nowhere. + // Unlike a read-only file, this holds whoever runs the test (root on the Linux runner). + var outside = Path.Combine(context.CreateTempDirectory("outside"), "sequence.json"); + File.Move(folder.ManifestPath, outside); + try + { + File.CreateSymbolicLink(folder.ManifestPath, Path.GetRelativePath(folder.MetaDirectory, outside)); + } + catch (Exception ex) when (ex is IOException or UnauthorizedAccessException) + { + File.Move(outside, folder.ManifestPath); + TestContext.Skip("needs symbolic links (Developer Mode on Windows)"); + } + var deeper = string.Concat(Enumerable.Repeat("moved/", folder.RelativeFolder.Split('/').Length)) + "{date}"; + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(Folder: deeper, Title: "Roof"), fx.Ct); + var to = plan.Steps.Single().ToFolder; + var told = new ConcurrentQueue<(Guid, string)>(); + var service = new ArchiveService(fx.Db, new ArchiveServiceOptions + { + Owner = "test", + SequenceChanged = (sequence, change, _) => + { + told.Enqueue((sequence, change)); + return Task.CompletedTask; + }, + }); + + // The new title cannot be read where the folder moved: its index row followed it all the same, and clients hear of it. + await Assert.ThrowsAsync(() => service.ApplyRenameAsync(plan, null, fx.Ct)); + Assert.Equal(to, await FolderAsync(fx, id)); + Assert.Null((await fx.Db.Sequences.GetAsync(id))!.Title); + Assert.SequenceEqual([(id, MassRenamer.Change)], told); + Assert.Empty(Assert.NotNull(RenameJournal.Read(fx.Paths, plan.Id)).Completed); + + // Readable again, the retry completes the step. + var sidecar = fx.Paths.Sequence(to).ManifestPath; + File.Delete(sidecar); + File.Move(outside, sidecar); + var result = Assert.NotNull(await service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.SequenceEqual([id], result.Changed); + Assert.Equal("Roof", (await fx.Db.Sequences.GetAsync(id))!.Title); + await FilesAsync(fx, id); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + /// Moves the first photo of a sequence to the trash, as the editor's Delete does. + private static async Task TrashFirstPhotoAsync(ArchiveFixture fx, Guid id) + { + var sequence = Assert.NotNull(await fx.Db.Sequences.GetAsync(id)); + var first = (await fx.Db.Frames.ListBySequenceAsync(id))[0]; + var plan = await fx.Service.FrameTrash.PlanDeleteAsync(id, [first.Id], sequence.FramesVersion, fx.Ct); + Assert.True(plan.CanDelete, string.Join(", ", plan.Blocked)); + await fx.Service.FrameTrash.DeleteAsync(plan, "editor", null, fx.Ct); + } + + [Test] + public async Task AFolderOrTitleNamedAfterAPhotoNoLongerFirstIsNeverGiven() + { + await using var fx = await CreateAsync(context); + var trashed = await UploadAsync(fx, 3); + var earlier = await UploadAsync(fx, 2, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + var other = await UploadAsync(fx, 2, firstSeed: 40, firstSecond: 7200, key: "upload-3"); + var templates = new RenameTemplates(Folder: "moved/{date} {time}", File: "{n:000}", Title: "{time}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [trashed, earlier, other], templates, fx.Ct); + Assert.SequenceEqual(["moved/2026-09-28 18-00-00", "moved/2026-09-28 19-00-00", "moved/2026-09-28 20-00-00"], plan.Steps.Select(s => s.ToFolder)); + var from = new Dictionary(); + foreach (var id in new[] { trashed, earlier }) from[id] = await FolderAsync(fx, id); + var files = new Dictionary>(); + + // Once the plan's own checks passed, the first photo of one goes to the trash and a photo taken before the first of + // another is filed into it: the templates now name each after another photo. + var result = await fx.Service.Renamer.ApplyAsync(fx.Archive, plan, async _ => + { + await TrashFirstPhotoAsync(fx, trashed); + await UploadAsync(fx, 1, firstSeed: 30, firstSecond: 3595, key: "upload-2"); + foreach (var id in from.Keys) files[id] = await FilesAsync(fx, id); + }, null, fx.Ct); + + // Both stay as they were, their folder, title and file names; the other is reorganized. + Assert.SequenceEqual([trashed, earlier], result.Dropped); + Assert.SequenceEqual([other], result.Changed); + foreach (var id in from.Keys) + { + Assert.Equal(from[id], await FolderAsync(fx, id)); + Assert.Null((await fx.Db.Sequences.GetAsync(id))!.Title); + Assert.SequenceEqual(files[id], await FilesAsync(fx, id)); + } + Assert.Equal(("moved/2026-09-28 20-00-00", "20-00-00"), (await FolderAsync(fx, other), (await fx.Db.Sequences.GetAsync(other))!.Title)); + Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG"], await FilesAsync(fx, other)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + + // Planned now, they are named after their first photo as it is. + var again = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [trashed, earlier], templates, fx.Ct); + Assert.SequenceEqual([("moved/2026-09-28 18-00-10", "18-00-10"), ("moved/2026-09-28 18-59-55", "18-59-55")], + again.Steps.Select(s => (s.ToFolder, s.ToTitle))); + } + + [Test] + public async Task ARetryOfAJobThatKeptSequencesPlansAgain() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 2); + var from = await FolderAsync(fx, id); + var templates = new RenameTemplates(Folder: "moved/{date} {time}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], templates, fx.Ct); + // Its job held the plan before its step (paused); the first photo then went to the trash. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [], Held: true)); + await TrashFirstPhotoAsync(fx, id); + + // Resumed, the job leaves the sequence as it was and says why it failed. + var engine = await fx.StartEngineAsync(); + var job = await fx.EnqueueWithCheckpointAsync(engine, ArchiveJobs.Reorganize(fx.Archive, plan, templates), "plan:" + plan.Id.ToString("N")); + var failed = await fx.WaitForAsync(job.Id, JobState.Failed); + Assert.Equal(Loc.Plural("Archive.Error.ReorganizeKept", 1), failed.Error); + Assert.Contains(Loc.L("Archive.Log.ReorganizeDropped", from), failed.LogTail); + Assert.Equal(from, await FolderAsync(fx, id)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + + // Retried, it plans again instead of taking the plan for one an archive open completed: the archive is no longer + // the one the plan was confirmed for. + await engine.ResumeAsync(job.Id, fx.Ct); + var retried = await fx.WaitForAsync(job.Id, JobState.Failed); + Assert.Equal(Loc.L("Archive.Error.StalePlan"), retried.Error); + Assert.False(retried.LogTail!.Contains(Loc.L("Archive.Log.ReorganizedEarlier"), StringComparison.Ordinal), retried.LogTail); + Assert.Equal(from, await FolderAsync(fx, id)); + } + + [Test] + public async Task ASequenceAFolderWasToCarryIsToldItStayedWithIt() + { + await using var fx = await CreateAsync(context); + var parent = await UploadAsync(fx, 2); + var folder = (await fx.Db.Sequences.GetAsync(parent))!.Folder; + Photos.WriteSeries(Path.Combine(fx.Paths.FromRelative(folder), "extra"), Start.AddDays(3), 2, firstSeed: 50); + await fx.ScanAsync(); + var nested = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == folder + "/extra").Id; + var templates = new RenameTemplates(Folder: "moved/{date}", Title: "Roof"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [parent], templates, fx.Ct); + Assert.SequenceEqual([(parent, false), (nested, true)], plan.Steps.Select(s => (s.SequenceId, s.Carried))); + var inner = plan.Steps[1].ToTitle ?? plan.Steps[1].FromFolder; + + // Interrupted before its step; a newer Chronos then rewrote the sidecar of the folder that carries the other. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + var sidecar = fx.Paths.Sequence(folder).ManifestPath; + var json = File.ReadAllText(sidecar); + Assert.Contains("\"schemaVersion\":1", json); + File.WriteAllText(sidecar, json.Replace("\"schemaVersion\":1", $"\"schemaVersion\":{SequenceManifest.CurrentSchemaVersion + 1}", StringComparison.Ordinal)); + + // Resumed, both stay where they are: the one inside is not said to have changed, and the job fails for the newer sidecar alone. + var engine = await fx.StartEngineAsync(); + var failed = await fx.WaitForAsync((await fx.EnqueueWithCheckpointAsync(engine, ArchiveJobs.Reorganize(fx.Archive, plan, templates), + "plan:" + plan.Id.ToString("N"))).Id, JobState.Failed); + Assert.Equal(Loc.Plural("Archive.Error.ReorganizeNewer", 1), failed.Error); + Assert.Contains(Loc.L("Archive.Log.ReorganizeNewerKept", "Roof"), failed.LogTail); + Assert.Contains(Loc.L("Archive.Log.ReorganizeCarriedKept", inner), failed.LogTail); + Assert.False(failed.LogTail!.Contains(Loc.L("Archive.Log.ReorganizeDropped", inner), StringComparison.Ordinal), failed.LogTail); + Assert.Equal((folder, folder + "/extra"), (await FolderAsync(fx, parent), await FolderAsync(fx, nested))); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task AnArchiveOpensWhenAnInterruptedRenameMeetsASidecarOfANewerFormat() + { + await using var fx = await CreateAsync(context); + var id = await ChainAsync(fx); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(File: "{n:0}"), fx.Ct); + // Interrupted inside the step once every file reached its temporary name; a newer Chronos then rewrote the sidecar. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + var folder = fx.Paths.Sequence((await fx.Db.Sequences.GetAsync(id))!.Folder); + var manifest = ManifestStore.ReadSequence(folder.ManifestPath); + var moves = FileRenames.Plan(manifest, null, PathTemplate.Parse("{n:0}"), FileRenames.ListPresent(folder, manifest)).Moves; + var journal = FileRenameJournal.Create(manifest.Versions.Frames, moves, "crash") with { Phase = 2 }; + FileRenameJournal.Write(folder, journal); + foreach (var file in journal.Files) File.Move(folder.File(file.From), folder.File(file.Temp)); + var json = File.ReadAllText(folder.ManifestPath); + Assert.Contains("\"schemaVersion\":1", json); + var newer = json.Replace("\"schemaVersion\":1", $"\"schemaVersion\":{SequenceManifest.CurrentSchemaVersion + 1}", StringComparison.Ordinal); + File.WriteAllText(folder.ManifestPath, newer); + + // Completing it would rewrite that sidecar, which this build never does: each open logs it, and the archive opens. + for (var open = 0; open < 2; open++) + { + Assert.Equal(fx.Archive.Id, (await fx.Service.OpenAsync(fx.Archive.RootPath, fx.Ct)).Id); + // Nothing is lost: the plan and the sequence's journal wait, and every photo is at the name that journal gives it. + Assert.NotNull(RenameJournal.Read(fx.Paths, plan.Id)); + Assert.NotNull(FileRenameJournal.Read(folder)); + foreach (var file in journal.Files) Assert.FileExists(folder.File(file.To)); + Assert.Equal(newer, File.ReadAllText(folder.ManifestPath)); + } + } + + [Test] + public async Task AResumedStepWhoseFolderMovedKeepsATitleEditedSinceAndTheNamesFromIt() + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 2); + await fx.Service.SetSequenceInfoAsync(id, "Roof", [], 0, null, fx.Ct); + // The folder and the files are named after the title, which the plan does not change. + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(Folder: "moved/{title}", File: "{title}_{n:000}"), fx.Ct); + var step = plan.Steps.Single(); + Assert.True(step is { ToFolder: "moved/Roof", FileChanges: 2, Retitles: false, NamedByTitle: true }); + + // Retitled since the plan, and a run of it interrupted once the folder moved, before its index row followed. + await fx.Service.SetSequenceInfoAsync(id, "Roof north", [], 0, null, fx.Ct); + var before = await FilesAsync(fx, id); + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [])); + RenamePlanner.MoveFolder(fx.Paths, step); + + // Resumed, its index row follows the folder; the title stays, and so do the file names that came from the old one. + var result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.SequenceEqual([id], result.TitlesKept); + Assert.SequenceEqual([id], result.Changed); + Assert.Equal(0, result.Files); + Assert.Equal("moved/Roof", await FolderAsync(fx, id)); + Assert.Equal("Roof north", (await fx.Db.Sequences.GetAsync(id))!.Title); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + /// "trips" with photos of its own, "trips/day2" inside it and "trips/day2/dawn" inside that, adopted by a scan; their ids in that order. + private static async Task> NestedAsync(ArchiveFixture fx) + { + Photos.WriteSeries(Path.Combine(fx.Paths.Root, "trips"), Start, 2); + Photos.WriteSeries(Path.Combine(fx.Paths.Root, "trips", "day2"), Start.AddDays(1), 3, firstSeed: 10); + Photos.WriteSeries(Path.Combine(fx.Paths.Root, "trips", "day2", "dawn"), Start.AddDays(2), 2, firstSeed: 20); + await fx.ScanAsync(); + var locations = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).OrderBy(l => l.Folder, StringComparer.Ordinal).ToList(); + Assert.SequenceEqual(["trips", "trips/day2", "trips/day2/dawn"], locations.Select(l => l.Folder)); + return [.. locations.Select(l => l.Id)]; + } + + [Theory] + [Case(false)] + [Case(true)] + public async Task ASequenceLeftAsItWasInsideAFolderThatMovesGoesWithIt(bool held) + { + await using var fx = await CreateAsync(context); + var ids = await NestedAsync(fx); + var (trips, day2, dawn) = (ids[0], ids[1], ids[2]); + var templates = new RenameTemplates(Folder: "moved/{date} {time}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [trips, day2], templates, fx.Ct); + // The inner one moves out first, with the one inside it; then the folder around it moves. + Assert.SequenceEqual([(day2, false), (trips, false), (dawn, true)], plan.Steps.Select(s => (s.SequenceId, s.Carried))); + var title = (await fx.Db.Sequences.GetAsync(day2))!.Title; + var files = new List(); + + // Once the plan's own checks passed, the first photo of the inner one goes to the trash: the templates now name it after another. + using var pause = new CancellationTokenSource(); + Func, ValueTask>? stepDone = null; + if (held) + { + stepDone = (_, _) => + { + pause.Cancel(); + return ValueTask.CompletedTask; + }; + } + var run = fx.Service.Renamer.ApplyAsync(fx.Archive, plan, async _ => + { + await TrashFirstPhotoAsync(fx, day2); + files.AddRange((await fx.Db.Frames.ListBySequenceAsync(day2)).Select(f => f.FileName)); + }, stepDone, pause.Token); + RenameResult result; + if (held) + { + // Its job paused once the inner one stayed, with the one inside it, and held the plan; retried, it goes on. + await Assert.ThrowsAsync(() => run); + Assert.SequenceEqual(new[] { day2, dawn }.Order(), Assert.NotNull(RenameJournal.Read(fx.Paths, plan.Id)).Completed.Order()); + Assert.True(MassRenamer.Hold(fx.Archive, plan.Id)); + result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + } + else + { + result = await run; + } + + // It stays in the folder around it, which moves as planned and takes it along with the one inside it: no index row + // is left behind, its title and file names stay, and neither is said to have stayed as it was. + Assert.SequenceEqual([trips, day2, dawn], result.Changed); + Assert.SequenceEqual([day2], result.TitlesKept); + Assert.Empty(result.Dropped); + Assert.Empty(result.CarriedKept); + Assert.Equal(("moved/2026-09-28 18-00-00", "moved/2026-09-28 18-00-00/day2", "moved/2026-09-28 18-00-00/day2/dawn"), + (await FolderAsync(fx, trips), await FolderAsync(fx, day2), await FolderAsync(fx, dawn))); + Assert.Equal(title, (await fx.Db.Sequences.GetAsync(day2))!.Title); + Assert.Count(2, files); + Assert.SequenceEqual(files, (await fx.Db.Frames.ListBySequenceAsync(day2)).Select(f => f.FileName)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + Assert.Equal(0, (await fx.ScanAsync()).Indexed); + } + + [Test] + public async Task ARetriedJobTakesAlongASequenceLeftAsItWasInsideAFolderItMoves() + { + await using var fx = await CreateAsync(context); + var parent = await UploadAsync(fx, 2); + var folder = (await fx.Db.Sequences.GetAsync(parent))!.Folder; + Photos.WriteSeries(Path.Combine(fx.Paths.FromRelative(folder), "extra"), Start.AddDays(3), 3, firstSeed: 50); + await fx.ScanAsync(); + var nested = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == folder + "/extra").Id; + var templates = new RenameTemplates(Folder: "moved/{date} {time}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [parent, nested], templates, fx.Ct); + Assert.SequenceEqual([nested, parent], plan.Steps.Select(s => s.SequenceId)); + var name = plan.Steps[0].ToTitle ?? plan.Steps[0].FromFolder; + // Its job held the plan before its first step (paused); the first photo of the inner one then went to the trash. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [], Held: true)); + await TrashFirstPhotoAsync(fx, nested); + + // Resumed, the job moves the folder around it as planned, with it inside, and fails for it alone: never for the plan. + var engine = await fx.StartEngineAsync(); + var failed = await fx.WaitForAsync((await fx.EnqueueWithCheckpointAsync(engine, ArchiveJobs.Reorganize(fx.Archive, plan, templates), + "plan:" + plan.Id.ToString("N"))).Id, JobState.Failed); + Assert.Equal(Loc.Plural("Archive.Error.ReorganizeKept", 1), failed.Error); + Assert.Contains(Loc.L("Archive.Log.Reorganized", 2, 0), failed.LogTail); + Assert.Contains(Loc.L("Archive.Log.ReorganizeTitleKept", name), failed.LogTail); + Assert.False(failed.LogTail!.Contains(Loc.L("Archive.Log.ReorganizeDropped", name), StringComparison.Ordinal), failed.LogTail); + Assert.Equal(("moved/2026-09-28 18-00-00", "moved/2026-09-28 18-00-00/extra"), (await FolderAsync(fx, parent), await FolderAsync(fx, nested))); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task AFolderNamedAfterAPhotoNoLongerFirstStaysWithTheSequencesInside() + { + await using var fx = await CreateAsync(context); + var parent = await UploadAsync(fx, 3); + var folder = (await fx.Db.Sequences.GetAsync(parent))!.Folder; + Photos.WriteSeries(Path.Combine(fx.Paths.FromRelative(folder), "extra"), Start.AddDays(3), 2, firstSeed: 50); + await fx.ScanAsync(); + var nested = (await fx.Db.Sequences.ListLocationsAsync(fx.Archive.Id)).Single(l => l.Folder == folder + "/extra").Id; + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [parent], new RenameTemplates(Folder: "moved/{date} {time}", File: "{n:000}"), fx.Ct); + Assert.SequenceEqual([(parent, false, 3), (nested, true, 0)], plan.Steps.Select(s => (s.SequenceId, s.Carried, s.FileChanges))); + var files = new List(); + + // Once the plan's own checks passed, the first photo of the folder that carries the other goes to the trash. + var result = await fx.Service.Renamer.ApplyAsync(fx.Archive, plan, async _ => + { + await TrashFirstPhotoAsync(fx, parent); + files.AddRange(await FilesAsync(fx, parent)); + }, null, fx.Ct); + + // It stays as it was, and the one inside stays with it, told why; the plan is over. + Assert.SequenceEqual([parent], result.Dropped); + Assert.SequenceEqual([nested], result.CarriedKept); + Assert.Empty(result.Changed); + Assert.Equal((folder, folder + "/extra"), (await FolderAsync(fx, parent), await FolderAsync(fx, nested))); + Assert.SequenceEqual(files, await FilesAsync(fx, parent)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Theory] + [Case(false)] + [Case(true)] + public async Task AStepWhoseFolderMovedBeforeItsFirstPhotoWentKeepsItsTitleAndFileNames(bool held) + { + await using var fx = await CreateAsync(context); + var id = await UploadAsync(fx, 3); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [id], new RenameTemplates(Folder: "moved/{date} {time}", File: "{n:000}", Title: "{time}"), + fx.Ct); + var step = plan.Steps.Single(); + Assert.True(step is { ToFolder: "moved/2026-09-28 18-00-00", ToTitle: "18-00-00", FileChanges: 3 }); + + // The first photo went to the trash; a run of the plan was then interrupted (or failed, and its job held it) once + // the folder moved, before its index row followed. + await TrashFirstPhotoAsync(fx, id); + var before = await FilesAsync(fx, id); + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [], Held: held)); + RenamePlanner.MoveFolder(fx.Paths, step); + + // Resumed, its index row follows the folder; the title and file names stay, the templates naming it after another photo now. + var result = Assert.NotNull(await fx.Service.Renamer.ResumeAsync(fx.Archive, plan.Id, null, fx.Ct)); + Assert.SequenceEqual([id], result.TitlesKept); + Assert.SequenceEqual([id], result.Changed); + Assert.Empty(result.Dropped); + Assert.Equal(0, result.Files); + Assert.Equal("moved/2026-09-28 18-00-00", await FolderAsync(fx, id)); + Assert.Null((await fx.Db.Sequences.GetAsync(id))!.Title); + Assert.SequenceEqual(before, await FilesAsync(fx, id)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } + + [Test] + public async Task AJobRetriedWhileTheArchiveIsOfflineKeepsItsPlanForTheNextRetry() + { + var root = context.CreateTempDirectory("archive"); + await using var fx = await CreateAsync(context, root); + var first = await UploadAsync(fx, 2); + var second = await UploadAsync(fx, 2, firstSeed: 20, firstSecond: 3600, key: "upload-2"); + var templates = new RenameTemplates(File: "{n:000}"); + var plan = await fx.Service.PlanReorganizeAsync(fx.Archive.Id, [first, second], templates, fx.Ct); + // Its job held the plan before its first step (paused); the drive was then unplugged. + RenameJournal.Write(fx.Paths, new RenameJournal(plan, [], Held: true)); + var unplugged = root + "-unplugged"; + Directory.Move(root, unplugged); + + // Retried, the job fails as the archive does: no journal found there says nothing, and it keeps its plan. + var engine = await fx.StartEngineAsync(); + var checkpoint = "plan:" + plan.Id.ToString("N"); + var job = await fx.EnqueueWithCheckpointAsync(engine, ArchiveJobs.Reorganize(fx.Archive, plan, templates), checkpoint); + var failed = await fx.WaitForAsync(job.Id, JobState.Failed); + Assert.Equal(Loc.L("Archive.Error.Offline", fx.Paths.Root), failed.Error); + Assert.Equal(checkpoint, failed.Checkpoint); + Assert.False(failed.LogTail!.Contains(Loc.L("Archive.Log.ReorganizedEarlier"), StringComparison.Ordinal), failed.LogTail); + + // Plugged in again, the next retry completes the plan. + Directory.Move(unplugged, root); + await engine.ResumeAsync(job.Id, fx.Ct); + var done = await fx.WaitForAsync(job.Id, JobState.Done); + Assert.Contains(Loc.L("Archive.Log.Reorganized", 2, 4), done.LogTail); + foreach (var id in new[] { first, second }) Assert.SequenceEqual(["originals/001.JPG", "originals/002.JPG"], await FilesAsync(fx, id)); + Assert.Empty(RenameJournal.ListPending(fx.Paths)); + } +} diff --git a/tests/Chronos.Data.Tests/Processing/AnalysisJobTests.cs b/tests/Chronos.Data.Tests/Processing/AnalysisJobTests.cs index c630c6f6..c259345b 100644 --- a/tests/Chronos.Data.Tests/Processing/AnalysisJobTests.cs +++ b/tests/Chronos.Data.Tests/Processing/AnalysisJobTests.cs @@ -455,6 +455,33 @@ public sealed class AnalysisJobTests(TestContext context) Assert.Contains("13", ProjectSettings.FromJson(await ProjectJsonAsync(fx, folder)).Timing.FrameRate.ReasonArgs!); } + [Test] + public async Task ADeepAnalysisWhoseFolderAnotherChronosMovedRecordsNothingAndCreatesNoFolder() + { + // One decode at a time, so the held one is the only photo being read while the folder moves. + await using var fx = await ProcessingFixture.CreateAsync(context, o => o with { DeepAnalysis = o.DeepAnalysis with { MaxDegreeOfParallelism = 1 } }); + var sequence = await fx.AddAsync(Flickering(12)); + var left = fx.Folder(sequence).Folder; + var (server, archive) = await fx.Archive.OtherWriterAsync(); + await fx.StartEngineAsync(); + + // A server sharing this desktop's archive reorganizes the sequence while the deep pass reads its photos. + fx.Decoder.HoldFrame(5); + var deep = await fx.EnqueueAsync(ProcessingJobs.DeepAnalysis([sequence.Id])); + await fx.Decoder.Holding.Task.WaitAsync(TimeSpan.FromSeconds(60), fx.Ct); + var plan = await server.PlanRenameAsync(archive.Id, [sequence.Id], "Moved/{date}", null, fx.Ct); + await server.ApplyRenameAsync(plan, null, fx.Ct); + fx.Decoder.Hold = null; + fx.Decoder.Release(); + var done = await fx.WaitForAsync(deep.Id, JobState.Done); + + Assert.Contains(Loc.L("Advisor.Log.FramesChangedElsewhere", sequence.DisplayTitle), done.LogTail); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + var moved = fx.Archive.Paths.Sequence(plan.Steps.Single().ToFolder); + Assert.FileMissing(moved.AnalysisPath); + Assert.False((await fx.Db.Sequences.GetAsync(sequence.Id, fx.Ct))!.Status.HasFlag(SequenceStatus.AnalyzedDeep), "nothing is recorded"); + } + [Test] public async Task ALightAnalysisOvertakenByAScanMarksNothingAnalysedAndRunsAgain() { diff --git a/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs b/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs index aa3e512b..abacdad5 100644 --- a/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs +++ b/tests/Chronos.Data.Tests/Processing/RenderJobTests.cs @@ -9,6 +9,7 @@ using Chronos.Core.Project; using Chronos.Core.Video; using Chronos.Data.Jobs; using Chronos.Data.Processing; +using Chronos.Data.Tests.Archiving; using Chronos.Testing; namespace Chronos.Data.Tests.Processing; @@ -126,6 +127,55 @@ public sealed class RenderJobTests(TestContext context) Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); } + [Test] + public async Task ARenderOfAFolderAnotherIndexMovedWaitsForThisIndexsScan() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Scene()); + var left = fx.Folder(sequence).Folder; + var (server, archive) = await fx.Archive.OtherWriterAsync(); + var plan = await server.PlanRenameAsync(archive.Id, [sequence.Id], "Moved/{date}", null, fx.Ct); + await server.ApplyRenameAsync(plan, null, fx.Ct); + await fx.StartEngineAsync(); + + // A server sharing the archive moved the folder; this index has not scanned since. Nothing renders, nothing is flagged. + var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); + var failed = await fx.WaitForAsync(job.Id, JobState.Failed); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), failed.Error); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); + Assert.True((await fx.Db.Frames.ListBySequenceAsync(sequence.Id, cancellationToken: fx.Ct)).All(f => (f.Flags & (FrameFlags.Missing | FrameFlags.Undecodable)) == 0), "no frame flagged"); + + // Once this index's scan found it there, the render goes into its exports. + await fx.Archive.ScanAsync(); + var again = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); + await fx.WaitForAsync(again.Id, JobState.Done); + var moved = fx.Archive.Paths.Sequence(plan.Steps.Single().ToFolder); + Assert.FileExists(Path.Combine(moved.Exports, "clip-MJPEG.avi")); + Assert.False(Directory.Exists(left)); + } + + [Test] + public async Task ARenderNeverWritesIntoAnotherSequenceMovedIntoItsFolder() + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Scene()); + var stranger = await fx.AddAsync(Scene(), "Other"); + var (server, archive) = await fx.Archive.OtherWriterAsync(); + await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [sequence.Id], "Moved/{date}", null, fx.Ct), null, fx.Ct); + await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [stranger.Id], sequence.Folder, null, fx.Ct), null, fx.Ct); + var folder = fx.Folder(sequence).Folder; + var before = ArchiveFixture.FilesOf(folder); + await fx.StartEngineAsync(); + + // A server sharing the archive moved the folder away and the other sequence into it; this index has not scanned since. + var job = await fx.EnqueueAsync(ProcessingJobs.Render(sequence, Mjpeg, 96, 64)); + var failed = await fx.WaitForAsync(job.Id, JobState.Failed); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), failed.Error); + Assert.SequenceEqual(before, ArchiveFixture.FilesOf(folder), "the other sequence's files are untouched"); + Assert.Empty(await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); + } + [Test] public async Task AFrameThatNoLongerDecodesIsReplacedByItsNeighbourAndLeftOutNextTime() { @@ -325,6 +375,50 @@ public sealed class RenderJobTests(TestContext context) Assert.Count(2, await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)); } + [Test] + public async Task ARenderResumedAfterItsFolderMovedNeverDeletesWhatAnotherSequenceBroughtIntoIt() + { + // The crashed attempt's checkpoint names the folder it chose the output in, or (written by an older version) does not. + foreach (var named in new[] { true, false }) + { + await using var fx = await ProcessingFixture.CreateAsync(context); + var sequence = await fx.AddAsync(Scene()); + var stranger = await fx.AddAsync(Scene(), "Other"); + var output = Path.Combine(fx.Folder(sequence).Exports, "clip-MJPEG.avi"); + // The crashed attempt left its encoder's temporary file and a finished output it never recorded; the other + // sequence has an export of that name, and a hidden file that looks like such a leftover. + Directory.CreateDirectory(fx.Folder(sequence).Exports); + await File.WriteAllBytesAsync(Path.Combine(fx.Folder(sequence).Exports, ".clip-MJPEG.avi.0badf00d.tmp"), new byte[100], fx.Ct); + await File.WriteAllBytesAsync(output, new byte[100], fx.Ct); + Directory.CreateDirectory(fx.Folder(stranger).Exports); + await File.WriteAllBytesAsync(Path.Combine(fx.Folder(stranger).Exports, ".clip-MJPEG.avi.0ddba11.tmp"), new byte[50], fx.Ct); + await File.WriteAllBytesAsync(Path.Combine(fx.Folder(stranger).Exports, "clip-MJPEG.avi"), Encoding.ASCII.GetBytes("RIFF theirs"), fx.Ct); + + // Another index moves the folder away, the leftovers along, then the other sequence into the folder it left; this + // index's scan finds both before the job resumes. + var (server, archive) = await fx.Archive.OtherWriterAsync(); + var plan = await server.PlanRenameAsync(archive.Id, [sequence.Id], "Moved/{date}", null, fx.Ct); + await server.ApplyRenameAsync(plan, null, fx.Ct); + await server.ApplyRenameAsync(await server.PlanRenameAsync(archive.Id, [stranger.Id], sequence.Folder, null, fx.Ct), null, fx.Ct); + await fx.Archive.ScanAsync(); + var before = ArchiveFixture.FilesOf(fx.Folder(sequence).Folder); + await fx.StartEngineAsync(); + + var job = await fx.Archive.EnqueueWithCheckpointAsync(fx.Engine, ProcessingJobs.Render(sequence, Mjpeg, 96, 64), + new RenderCheckpoint([], 0, output, named ? sequence.Folder : null).ToJson()); + await fx.WaitForAsync(job.Id, JobState.Done); + + Assert.SequenceEqual(before, ArchiveFixture.FilesOf(fx.Folder(sequence).Folder), $"{named}: the other sequence's files are untouched"); + // Its leftovers are removed where the folder took them when the checkpoint says where it chose the output, and + // stay otherwise: the render then takes another name. + var moved = fx.Archive.Paths.Sequence(plan.Steps.Single().ToFolder).Exports; + Assert.SequenceEqual(named ? ["clip-MJPEG.avi"] : [".clip-MJPEG.avi.0badf00d.tmp", "clip-MJPEG (2).avi", "clip-MJPEG.avi"], Entries(moved), named.ToString()); + var rendered = (await fx.Db.Renders.ListBySequenceAsync(sequence.Id, fx.Ct)).Single().OutputPath; + Assert.Equal(plan.Steps.Single().ToFolder + (named ? "/exports/clip-MJPEG.avi" : "/exports/clip-MJPEG (2).avi"), rendered); + Assert.Equal("RIFF", Encoding.ASCII.GetString((await File.ReadAllBytesAsync(fx.Archive.Paths.FromRelative(rendered), fx.Ct))[..4])); + } + } + [Test] public async Task ConcurrentRendersOfOnePresetKeepBothOutputs() { diff --git a/tests/Chronos.Data.Tests/Repositories/CatalogRepositoryTests.cs b/tests/Chronos.Data.Tests/Repositories/CatalogRepositoryTests.cs index b63f81e4..aae1b752 100644 --- a/tests/Chronos.Data.Tests/Repositories/CatalogRepositoryTests.cs +++ b/tests/Chronos.Data.Tests/Repositories/CatalogRepositoryTests.cs @@ -361,6 +361,43 @@ public abstract class CatalogRepositoryTests(TestContext context) : RepositoryTe Assert.True((await Chronos.Data.Processing.SequenceFrames.ListAsync(db, sequence.Id, Ct)).All(f => (f.Flags, f.PreviewWidth, f.PreviewHeight) == (FrameFlags.None, 4, 3))); } + [Test] + public async Task FramesTakeTheNamesAReorganizeGaveTheirFiles() + { + var db = await OpenChronosAsync(); + var archive = TestData.Archive(); + await db.Archives.UpsertAsync(archive, Ct); + var sequence = TestData.Sequence(archive.Id) with { FramesVersion = 3 }; + var other = TestData.Sequence(archive.Id); + await db.Sequences.UpsertAsync(sequence, Ct); + await db.Sequences.UpsertAsync(other, Ct); + // More frames than one batched PostgreSQL statement holds, and a frame of another sequence named in the same call. + const int count = 1203; + var frames = Enumerable.Range(0, count).Select(i => TestData.Frame(sequence.Id, i)).ToList(); + var foreign = TestData.Frame(other.Id, 0); + await db.Frames.BulkInsertAsync([.. frames, foreign], Ct); + + var renamed = frames.Take(count - 1).Select(f => new FrameFileName(f.Id, $"s/originals/{count - f.Index:00000}.cr3", $"{count - f.Index:00000}.cr3")).ToList(); + Assert.Equal(count - 1, await db.Frames.RenameFilesAsync(sequence.Id, [.. renamed, new FrameFileName(foreign.Id, "x/y.cr3", "y.cr3")], 3, 4, Ct)); + var read = new List(); + for (var last = -1; ;) + { + var page = await db.Frames.ListBySequenceAsync(sequence.Id, last, 1000, Ct); + read.AddRange(page); + if (page.Count < 1000) break; + last = page[^1].Index; + } + Assert.SequenceEqual(frames.Select(f => f.Id), read.Select(f => f.Id)); + Assert.SequenceEqual([.. renamed.Select(r => (r.RelativePath, r.FileName)), (frames[^1].RelativePath, frames[^1].FileName)], + read.Select(f => (f.RelativePath, f.FileName))); + Assert.Equal((foreign.RelativePath, foreign.FileName), (await db.Frames.GetAsync(foreign.Id, Ct)) is { } f2 ? (f2.RelativePath, f2.FileName) : default); + Assert.Equal(4, (await db.Sequences.GetAsync(sequence.Id, Ct))!.FramesVersion); + + // A row another writer moved past the version the renames started from keeps its own. + await db.Frames.RenameFilesAsync(sequence.Id, [], 3, 9, Ct); + Assert.Equal(4, (await db.Sequences.GetAsync(sequence.Id, Ct))!.FramesVersion); + } + [Test] public async Task RendersKeepTheSequenceCountInStep() { diff --git a/tests/Chronos.Data.Tests/Repositories/SequenceStampTests.cs b/tests/Chronos.Data.Tests/Repositories/SequenceStampTests.cs new file mode 100644 index 00000000..d48cec95 --- /dev/null +++ b/tests/Chronos.Data.Tests/Repositories/SequenceStampTests.cs @@ -0,0 +1,113 @@ +using Chronos.Core.Model; +using Chronos.Data.Repositories; +using Chronos.Data.Tests.Infrastructure; +using Chronos.Testing; + +namespace Chronos.Data.Tests.Repositories; + +/// +/// The stamp of what a Reorganize plans from in an archive's index () on both +/// dialects: the server makes a kept Reorganize plan again once it is another one, and only then (owner review 2, R7). +/// +public abstract class SequenceStampTests(TestContext context) : RepositoryTest(context) +{ + [Test] + public async Task TheStampFollowsWhatAReorganizePlansFromAndNothingElse() + { + var db = await OpenChronosAsync(); + var archive = TestData.Archive(); + var other = TestData.Archive("Other"); + await db.Archives.UpsertAsync(archive, Ct); + await db.Archives.UpsertAsync(other, Ct); + var roof = TestData.Sequence(archive.Id, new DateTime(2026, 9, 28, 18, 0, 0), "Roof"); + var inner = TestData.Sequence(archive.Id, null, "Inner") with { Folder = roof.Folder + "/inner" }; + var ridge = TestData.Sequence(archive.Id, new DateTime(2026, 9, 29, 7, 0, 0), "Ridge"); + IReadOnlyList planned = [roof.Id]; + var empty = await db.Sequences.GetStampAsync(archive.Id, planned, Ct); + foreach (var sequence in new[] { roof, inner, ridge }) await db.Sequences.UpsertAsync(sequence, Ct); + var stamp = await db.Sequences.GetStampAsync(archive.Id, planned, Ct); + Assert.NotEqual(empty, stamp); + Assert.Equal(stamp, await db.Sequences.GetStampAsync(archive.Id, planned, Ct)); + Assert.NotEqual(stamp, await db.Sequences.GetStampAsync(archive.Id, null, Ct)); + + // What the plan does not read: another archive, and the writes of every upload, verify, tag or status change elsewhere. + await db.Sequences.UpsertAsync(TestData.Sequence(other.Id), Ct); + await VerifyAsync(db, await PhotoAsync(db, ridge, 0, hashed: false)); + await VerifyAsync(db, await PhotoAsync(db, inner, 0, hashed: false)); + Assert.Equal(SequenceEditOutcome.Updated, (await db.Sequences.EditAsync(ridge.Id, new SequenceEdit { Title = "Ridge at dawn", Notes = "cold" }, null, Ct)).Outcome); + foreach (var id in new[] { roof.Id, ridge.Id }) + { + Assert.True(await db.Sequences.SetTagsAsync(id, ["sky"], Ct)); + Assert.True(await db.Sequences.UpdateStatusAsync(id, SequenceStatus.ProxiesBuilt, SequenceStatus.None, Ct)); + Assert.True(await db.Sequences.RecordVerifiedAsync(id, SequenceStatus.None, SequenceStatus.None, TestData.Now, Ct)); + } + Assert.Equal(stamp, await db.Sequences.GetStampAsync(archive.Id, planned, Ct)); + + // What it reads gives one never seen before: the sequences planned, the titles inside their folders, every folder. + var seen = new HashSet(StringComparer.Ordinal) { empty, stamp }; + async Task ChangedAsync(string what) => Assert.True(seen.Add(await db.Sequences.GetStampAsync(archive.Id, planned, Ct)), what); + Assert.Equal(SequenceEditOutcome.Updated, (await db.Sequences.EditAsync(roof.Id, new SequenceEdit { Title = "Roof at noon" }, null, Ct)).Outcome); + await ChangedAsync("title"); + var scanned = await PhotoAsync(db, roof, 0, hashed: false); + await ChangedAsync("photos"); + await VerifyAsync(db, scanned); + await ChangedAsync("photos hashed by a verify, which a file template renames"); + Assert.Equal(SequenceEditOutcome.Updated, (await db.Sequences.EditAsync(inner.Id, new SequenceEdit { Title = "Inner court" }, null, Ct)).Outcome); + await ChangedAsync("title of a sequence a moving folder would carry"); + Assert.True(await db.Sequences.RelocateAsync(ridge.Id, "2026/ridge", null, Ct)); + await ChangedAsync("folder of a sequence not planned"); + Assert.True(await db.Sequences.RelocateAsync(roof.Id, "2026/moved", null, Ct)); + await ChangedAsync("folder"); + var added = TestData.Sequence(archive.Id); + await db.Sequences.UpsertAsync(added, Ct); + await ChangedAsync("a sequence added"); + Assert.True(await db.Sequences.DeleteAsync(added.Id, Ct)); + Assert.Contains(await db.Sequences.GetStampAsync(archive.Id, planned, Ct), seen); + + // With every sequence planned, a photo anywhere changes the plan read, and so does a verify that hashes one; a verify + // that hashes none still does not. + var all = await db.Sequences.GetStampAsync(archive.Id, null, Ct); + Assert.True(await db.Sequences.RecordVerifiedAsync(ridge.Id, SequenceStatus.None, SequenceStatus.None, TestData.Now.AddDays(1), Ct)); + Assert.Equal(all, await db.Sequences.GetStampAsync(archive.Id, null, Ct)); + var photo = await PhotoAsync(db, ridge, 1, hashed: false); + var uploaded = await db.Sequences.GetStampAsync(archive.Id, null, Ct); + Assert.NotEqual(all, uploaded); + await VerifyAsync(db, photo); + var verified = await db.Sequences.GetStampAsync(archive.Id, null, Ct); + Assert.False(verified == all || verified == uploaded, "a photo hashed"); + } + + /// + /// A photo indexed into a sequence, as an upload does, or without its hash, as a scan does: the frame, then the row's + /// counts and frames version. + /// + private async Task PhotoAsync(ChronosDatabase db, Sequence sequence, int index, bool hashed = true) + { + var frame = TestData.Frame(sequence.Id, index); + frame = frame with { RelativePath = $"{sequence.Folder}/originals/{frame.FileName}", Sha256 = hashed ? frame.Sha256 : null }; + await db.Frames.BulkInsertAsync([frame], Ct); + Assert.NotNull(await db.Sequences.RefreshStatsAsync(sequence.Id, Ct)); + return frame; + } + + /// What a verify writes once it hashed a photo never hashed: the hash, then the sequence's verify time, and not another frames version. + private async Task VerifyAsync(ChronosDatabase db, Frame frame) + { + var version = (await db.Sequences.GetAsync(frame.SequenceId, Ct))!.FramesVersion; + var sha256 = TestData.Frame(frame.SequenceId, frame.Index).Sha256; + Assert.Equal(1, await db.Frames.UpdateIntegrityAsync([new FrameIntegrity(frame.Id, FrameFlags.None, sha256)], Ct)); + Assert.True(await db.Sequences.RecordVerifiedAsync(frame.SequenceId, SequenceStatus.Verified, SequenceStatus.None, TestData.Now, Ct)); + Assert.Equal(version, (await db.Sequences.GetAsync(frame.SequenceId, Ct))!.FramesVersion); + } +} + +public sealed class SqliteSequenceStampTests(TestContext context) : SequenceStampTests(context) +{ + protected override Backend Backend => Backend.SqliteMemory; +} + +[RequiresEnvironment(PgTestServer.Variable)] +public sealed class PostgresSequenceStampTests(TestContext context) : SequenceStampTests(context) +{ + protected override Backend Backend => Backend.Postgres; +} diff --git a/tests/Chronos.Data.Tests/Sync/FakeSyncRemote.cs b/tests/Chronos.Data.Tests/Sync/FakeSyncRemote.cs index bbfc6bd6..14ffe107 100644 --- a/tests/Chronos.Data.Tests/Sync/FakeSyncRemote.cs +++ b/tests/Chronos.Data.Tests/Sync/FakeSyncRemote.cs @@ -103,22 +103,38 @@ internal sealed class FakeSyncRemote : ISyncRemote } } - public Task GetManifestAsync(Guid id, CancellationToken cancellationToken) + /// Runs once, before the next manifest is answered: the archive on this PC changing while the sync compares. + public Func? OnceBeforeManifest { get; set; } + + public async Task GetManifestAsync(Guid id, CancellationToken cancellationToken) { + if (OnceBeforeManifest is { } before) + { + OnceBeforeManifest = null; + await before(); + } lock (_gate) { ManifestCalls++; if (Refused.Contains(id)) throw new ChronosApiException(HttpStatusCode.Forbidden, new ApiError("forbidden", "refused")); - return Task.FromResult(Find(id).Manifest(SentProxies.ContainsKey)); + return Find(id).Manifest(SentProxies.ContainsKey); } } - public Task> ListFramesAsync(Guid sequenceId, CancellationToken cancellationToken) + /// Runs once, before the next frame listing is answered (frame positions translated against the server's frames). + public Func? OnceBeforeFrames { get; set; } + + public async Task> ListFramesAsync(Guid sequenceId, CancellationToken cancellationToken) { + if (OnceBeforeFrames is { } before) + { + OnceBeforeFrames = null; + await before(); + } lock (_gate) { var sequence = Find(sequenceId); - return Task.FromResult>([.. sequence.Frames.Select(sequence.FrameDto)]); + return [.. sequence.Frames.Select(sequence.FrameDto)]; } } diff --git a/tests/Chronos.Data.Tests/Sync/SyncServiceTests.cs b/tests/Chronos.Data.Tests/Sync/SyncServiceTests.cs index d3b5d18f..174f505b 100644 --- a/tests/Chronos.Data.Tests/Sync/SyncServiceTests.cs +++ b/tests/Chronos.Data.Tests/Sync/SyncServiceTests.cs @@ -1,3 +1,4 @@ +using Chronos.Core.Localization; using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Data.Archiving; @@ -97,6 +98,35 @@ public sealed class SyncServiceTests(TestContext context) Assert.Equal(SyncStatus.InSync, (await f.EntryAsync("Harbour")).Status); } + [Test] + public async Task SettingsTakenWhileAReorganizeMovesTheFolderGoWhereTheSequenceIsNow() + { + await using var f = await SyncFixture.CreateAsync(context); + var photos = f.NewPhotos(2); + var local = await f.LocalAsync("Harbour", photos); + var remote = f.Remote.Add("Harbour", photos); + await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct); + await f.RefreshAsync(); + var left = f.Archive.Paths.Sequence((await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.Folder).Folder; + + // The server's edit is taken after a Reorganize moved the folder of the copy the comparison had read. + f.Remote.EditSettings(remote.Id, SyncFixture.Window33); + f.Remote.OnceBeforeManifest = async () => + { + var plan = await f.Archive.Service.PlanRenameAsync(f.Archive.Archive.Id, [local.Id], "moved/{title}", null, f.Ct); + await f.Archive.Service.ApplyRenameAsync(plan, null, f.Ct); + }; + await f.RefreshAsync(); + Assert.Null(f.Remote.OnceBeforeManifest, "the folder moved during the comparison"); + + var taken = (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!; + Assert.Equal("moved/Harbour", taken.Folder); + Assert.True(SyncRules.SameSettings(SyncFixture.Window33, taken.SettingsJson), "the server's edit reached this PC"); + var project = await File.ReadAllTextAsync(f.Archive.Paths.Sequence(taken.Folder).ProjectPath, f.Ct); + Assert.True(SyncRules.SameSettings(SyncFixture.Window33, project), "project.json in the moved folder follows the index"); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + } + [Test] public async Task PositionsSentToTheServerNameItsFramesAndWaitForPhotosItLacks() { @@ -403,6 +433,144 @@ public sealed class SyncServiceTests(TestContext context) Assert.Equal(SyncStatus.InSync, (await f.EntryAsync("Holy grail")).Status); } + [Test] + public async Task SaveBothWhileAReorganizeMovesTheFolderKeepsTheCopyWhereTheSequenceIsNow() + { + await using var f = await SyncFixture.CreateAsync(context); + var (local, remote) = await ConflictAsync(f); + var left = f.Archive.Paths.Sequence(local.Folder).Folder; + + // A Reorganize moves the folder while the server's version is read. + f.Remote.OnceBeforeManifest = async () => + { + var plan = await f.Archive.Service.PlanRenameAsync(f.Archive.Archive.Id, [local.Id], "moved/{title}", null, f.Ct); + await f.Archive.Service.ApplyRenameAsync(plan, null, f.Ct); + }; + var copy = await f.Sync.ResolveAsync(f.Remote, remote.Id, SyncResolution.SaveBoth, f.Ct); + Assert.Null(f.Remote.OnceBeforeManifest, "the folder moved during the resolution"); + + var taken = (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!; + Assert.Equal("moved/Holy grail", taken.Folder); + Assert.Equal(copy, Assert.Contains(Directory.GetFiles(f.Archive.Paths.Sequence(taken.Folder).MetaDirectory, "project.this-pc-*.json"), _ => true)); + Assert.True(SyncRules.SameSettings(SyncFixture.Window41, await File.ReadAllTextAsync(copy!, f.Ct)), "this PC's version is kept"); + Assert.True(SyncRules.SameSettings(SyncFixture.Window33, taken.SettingsJson)); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + } + + [Test] + public async Task SaveBothThatCannotKeepThisPcsVersionTakesNothing() + { + await using var f = await SyncFixture.CreateAsync(context); + // The server holds a photo this PC does not have yet, and its settings name a frame: taking them reads the server's + // frames, after this PC's copy was kept and before the server's version is written. + var photos = f.NewPhotos(3); + var local = await f.LocalAsync("Holy grail", photos[..2]); + var remote = f.Remote.Add("Holy grail", photos); + await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct); + await f.RefreshAsync(); + local = await f.EditLocalSettingsAsync(local.Id, SyncFixture.Window41); + var theirs = """{"heroFrame":1,"exposure":{"deflickerWindow":{"isAuto":false,"manual":33}}}"""; + f.Remote.EditSettings(remote.Id, theirs); + await f.RefreshAsync(); + Assert.NotNull((await f.EntryAsync("Holy grail")).Link!.ConflictRemote); + var left = f.Archive.Paths.Sequence(local.Folder).Folder; + + // Another index moves the folder while the server's version is read, so this PC's version cannot be kept there; this + // index's scan finds the folder before the server's version would be written. + var (other, archive) = await f.Archive.OtherWriterAsync(); + string? moved = null; + f.Remote.OnceBeforeManifest = async () => + { + var plan = await other.PlanRenameAsync(archive.Id, [local.Id], "moved/{title}", null, f.Ct); + await other.ApplyRenameAsync(plan, null, f.Ct); + moved = plan.Steps.Single().ToFolder; + }; + f.Remote.OnceBeforeFrames = () => f.Archive.ScanAsync(); + var refused = await Assert.ThrowsAsync(() => f.Sync.ResolveAsync(f.Remote, remote.Id, SyncResolution.SaveBoth, f.Ct)); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), refused.Message, "the user hears to try again after the next scan"); + // The server's frames were not read for a version that is not taken: the scan comes now. + f.Remote.OnceBeforeFrames = null; + await f.Archive.ScanAsync(); + + var kept = (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!; + Assert.Equal(moved, kept.Folder, "the scan found the folder"); + Assert.True(SyncRules.SameSettings(SyncFixture.Window41, kept.SettingsJson), "this PC's version is not replaced without its copy"); + var meta = f.Archive.Paths.Sequence(kept.Folder).MetaDirectory; + Assert.Empty(Directory.GetFiles(meta, SyncService.SavedCopyPattern)); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + Assert.NotNull((await f.EntryAsync("Holy grail")).Link!.ConflictRemote, "still a conflict"); + + // Asked again where the sequence is now, both versions are kept. + var copy = await f.Sync.ResolveAsync(f.Remote, remote.Id, SyncResolution.SaveBoth, f.Ct); + Assert.Equal(copy, Assert.Contains(Directory.GetFiles(meta, SyncService.SavedCopyPattern), _ => true)); + Assert.True(SyncRules.SameSettings(SyncFixture.Window41, await File.ReadAllTextAsync(copy!, f.Ct)), "this PC's version is kept"); + } + + [Test] + public async Task TakeServerWhereAnotherIndexMovedTheFolderWritesNothing() + { + await using var f = await SyncFixture.CreateAsync(context); + var (local, remote) = await ConflictAsync(f); + var left = f.Archive.Paths.Sequence(local.Folder).Folder; + + // Another index moves the folder while the server's version is read; this index has not scanned it since. + var (other, archive) = await f.Archive.OtherWriterAsync(); + f.Remote.OnceBeforeManifest = async () => + { + var plan = await other.PlanRenameAsync(archive.Id, [local.Id], "moved/{title}", null, f.Ct); + await other.ApplyRenameAsync(plan, null, f.Ct); + }; + var refused = await Assert.ThrowsAsync(() => f.Sync.ResolveAsync(f.Remote, remote.Id, SyncResolution.TakeServer, f.Ct)); + Assert.Null(f.Remote.OnceBeforeManifest, "the folder moved during the resolution"); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), refused.Message, "the user hears to try again after the next scan"); + + Assert.True(SyncRules.SameSettings(SyncFixture.Window41, (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.SettingsJson), "nothing applied"); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + Assert.True(SyncRules.SameSettings(SyncFixture.Window41, await File.ReadAllTextAsync(f.Archive.Paths.Sequence("moved/Holy grail").ProjectPath, f.Ct)), + "the moved project is this PC's version"); + } + + [Test] + public async Task TakeServerAndSaveBothWriteNothingIntoAnotherSequenceMovedIntoTheFolder() + { + const string strangers = """{"exposure":{"deflickerWindow":{"isAuto":false,"manual":7}}}"""; + foreach (var resolution in new[] { SyncResolution.TakeServer, SyncResolution.SaveBoth }) + { + await using var f = await SyncFixture.CreateAsync(context); + var (local, remote) = await ConflictAsync(f); + var stranger = await f.LocalAsync("Stranger", f.NewPhotos(2), strangers); + var folder = f.Archive.Paths.Sequence(local.Folder); + + // Another index moves the folder away while the server's version is read, then another sequence (first parked + // elsewhere: its folder is the same name with a number) into the folder it left; this index has scanned neither. + var (other, archive) = await f.Archive.OtherWriterAsync(); + List? before = null; + f.Remote.OnceBeforeManifest = async () => + { + foreach (var (id, template) in new[] { (local.Id, "moved/{title}"), (stranger.Id, "parked/{title}"), (stranger.Id, local.Folder) }) + await other.ApplyRenameAsync(await other.PlanRenameAsync(archive.Id, [id], template, null, f.Ct), null, f.Ct); + before = ArchiveFixture.FilesOf(folder.Folder); + }; + var refused = await Assert.ThrowsAsync(() => f.Sync.ResolveAsync(f.Remote, remote.Id, resolution, f.Ct)); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), refused.Message, $"{resolution}: the user hears to try again after the next scan"); + + // Neither version went into the other sequence's folder, nor replaced this PC's where the sequence is. + Assert.Equal(stranger.Id, SequenceTrash.SidecarId(folder.ManifestPath), "the other sequence holds the folder"); + Assert.SequenceEqual(before!, ArchiveFixture.FilesOf(folder.Folder), $"{resolution}: the other sequence's files are untouched"); + Assert.True(SyncRules.SameSettings(SyncFixture.Window41, (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.SettingsJson), "nothing applied"); + var moved = f.Archive.Paths.Sequence("moved/Holy grail"); + Assert.True(SyncRules.SameSettings(SyncFixture.Window41, await File.ReadAllTextAsync(moved.ProjectPath, f.Ct)), "the moved project is this PC's version"); + Assert.Empty(Directory.GetFiles(moved.MetaDirectory, SyncService.SavedCopyPattern)); + + // Chosen again once this index's scan found both, it is done where the sequence is now. + await f.Archive.ScanAsync(); + var copy = await f.Sync.ResolveAsync(f.Remote, remote.Id, resolution, f.Ct); + Assert.True(SyncRules.SameSettings(SyncFixture.Window33, await File.ReadAllTextAsync(moved.ProjectPath, f.Ct)), resolution.ToString()); + Assert.Equal(resolution == SyncResolution.SaveBoth, copy is not null && Path.GetDirectoryName(copy) == moved.MetaDirectory); + Assert.True(SyncRules.SameSettings(strangers, await File.ReadAllTextAsync(folder.ProjectPath, f.Ct)), "the other sequence keeps its own"); + } + } + [Test] public async Task KeepMineRefusesWhenTheServerChangedAfterTheConflictWasShown() { @@ -441,7 +609,8 @@ public sealed class SyncServiceTests(TestContext context) var later = SyncFixture.Window41.Replace("41", "45", StringComparison.Ordinal); await f.EditLocalSettingsAsync(local.Id, later); - await Assert.ThrowsAsync(() => f.Sync.ResolveAsync(f.Remote, remote.Id, SyncResolution.TakeServer, f.Ct)); + var refused = await Assert.ThrowsAsync(() => f.Sync.ResolveAsync(f.Remote, remote.Id, SyncResolution.TakeServer, f.Ct)); + Assert.Equal(Loc.L("Errors.Sync.ChangedAgain"), refused.Message); Assert.True(SyncRules.SameSettings(later, (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.SettingsJson), "this PC's later edit is kept"); Assert.True(SyncRules.SameSettings(SyncFixture.Window33, remote.SettingsJson)); diff --git a/tests/Chronos.Data.Tests/Sync/SyncTransferTests.cs b/tests/Chronos.Data.Tests/Sync/SyncTransferTests.cs index 7419a590..fea24a8e 100644 --- a/tests/Chronos.Data.Tests/Sync/SyncTransferTests.cs +++ b/tests/Chronos.Data.Tests/Sync/SyncTransferTests.cs @@ -6,6 +6,7 @@ using Chronos.Core.Model; using Chronos.Core.Project; using Chronos.Core.Render; using Chronos.Data.Sync; +using Chronos.Data.Tests.Archiving; using Chronos.Protocol; using Chronos.Testing; @@ -384,6 +385,54 @@ public sealed class SyncTransferTests(TestContext context) Assert.Equal(SyncStatus.InSync, (await f.EntryAsync("Harbour")).Status); } + [Test] + public async Task AnOriginalIsRestoredOnlyWhereTheSequenceIsNow() + { + // The folder the sequence left holds another sequence now, or nothing. + foreach (var taken in new[] { true, false }) + { + await using var f = await SyncFixture.CreateAsync(context); + var photos = f.NewPhotos(3); + var local = await f.LocalAsync("Harbour", photos); + var stranger = taken ? await f.LocalAsync("Stranger", f.NewPhotos(2)) : null; + var lost = (await f.Db.Frames.ListBySequenceAsync(local.Id, cancellationToken: f.Ct))[1]; + File.Delete(f.Archive.Paths.FromRelative(lost.RelativePath)); + await f.Archive.Service.Verifier.VerifyAsync(f.Archive.Archive, [local.Id], default, (_, _, _) => ValueTask.CompletedTask, cancellationToken: f.Ct); + var remote = f.Remote.Add("Harbour", photos); + await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct); + await f.RefreshAsync(); + var engine = await f.StartEngineAsync(); + + // Another index moves the folder away, then the other sequence (first parked elsewhere: its folder is the same + // name with a number) into the folder it left; this index has scanned neither. + var folder = f.Archive.Paths.Sequence(local.Folder).Folder; + var (other, archive) = await f.Archive.OtherWriterAsync(); + var moves = stranger is null ? [(local.Id, "moved/{title}")] : new[] { (local.Id, "moved/{title}"), (stranger.Id, "parked/{title}"), (stranger.Id, local.Folder) }; + foreach (var (id, template) in moves) + await other.ApplyRenameAsync(await other.PlanRenameAsync(archive.Id, [id], template, null, f.Ct), null, f.Ct); + var before = taken ? ArchiveFixture.FilesOf(folder) : null; + + var job = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Harbour", SyncDownloadMode.Originals, null); + var failed = await f.Archive.WaitForAsync(job.Id, JobState.Failed); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), failed.Error, taken.ToString()); + if (taken) Assert.SequenceEqual(before!, ArchiveFixture.FilesOf(folder), "the other sequence's files are untouched"); + else Assert.False(Directory.Exists(folder), "the folder it left is not created again"); + + // Once this index's scan found it there, the original goes back into the folder the sequence is in now. + await f.Archive.ScanAsync(); + job = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Harbour", SyncDownloadMode.Originals, null); + await f.Archive.WaitForAsync(job.Id, JobState.Done); + var moved = (await f.Db.Sequences.GetAsync(local.Id, f.Ct))!.Folder; + Assert.Equal("moved/Harbour", moved); + var restored = (await f.Db.Frames.GetAsync(lost.Id, f.Ct))!; + Assert.Equal(moved + lost.RelativePath[local.Folder.Length..], restored.RelativePath); + Assert.Equal(lost.Sha256, Sha(await File.ReadAllBytesAsync(f.Archive.Paths.FromRelative(restored.RelativePath), f.Ct))); + Assert.True((await f.Db.Frames.ListBySequenceAsync(local.Id, cancellationToken: f.Ct)).All(fr => (fr.Flags & FrameFlags.Missing) == 0), "nothing missing"); + if (taken) Assert.SequenceEqual(before!, ArchiveFixture.FilesOf(folder), "the other sequence's files are still untouched"); + else Assert.False(Directory.Exists(folder)); + } + } + [Test] public async Task OriginalsTheServerHasNotHashedAreDownloadedAndHashedHere() { @@ -600,6 +649,55 @@ public sealed class SyncTransferTests(TestContext context) Assert.Equal(0, (await f.EntryAsync("Star trails")).Link!.ExportsToGet); } + [Test] + public async Task TheServersRendersGoWhereTheSequenceIsNow() + { + await using var f = await SyncFixture.CreateAsync(context); + var photos = f.NewPhotos(2); + var local = await f.LocalAsync("Star trails", photos); + var remote = f.Remote.Add("Star trails", photos); + var first = new FakeRender(Guid.CreateVersion7(), "Star trails 4K.mp4", "4K HEVC", [.. Enumerable.Range(0, 3000).Select(i => (byte)i)]); + remote.Renders.Add(first); + await f.Sync.LinkAsync(f.Server, remote.Id, local.Id, f.Ct); + await f.RefreshAsync(); + var engine = await f.StartEngineAsync(); + var left = f.Archive.Paths.Sequence(local.Folder).Folder; + + // A Reorganize here moves the folder while the server's renders are listed: the render goes where the sequence is. + string? moved = null; + f.Remote.OnceBeforeManifest = async () => + { + var plan = await f.Archive.Service.PlanRenameAsync(f.Archive.Archive.Id, [local.Id], "moved/{title}", null, f.Ct); + await f.Archive.Service.ApplyRenameAsync(plan, null, f.Ct); + moved = plan.Steps.Single().ToFolder; + }; + var job = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Star trails", SyncDownloadMode.Exports, null); + await f.Archive.WaitForAsync(job.Id, JobState.Done); + Assert.Equal($"{moved}/exports/Star trails 4K.mp4", (await f.Db.Renders.GetAsync(first.Id, f.Ct))!.OutputPath); + Assert.FileExists(f.Archive.Paths.FromRelative($"{moved}/exports/Star trails 4K.mp4")); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + + // Another index moves it: nothing is filed until this index's scan finds it there. + var second = new FakeRender(Guid.CreateVersion7(), "Star trails 1080p.mp4", "1080p", [.. Enumerable.Range(0, 2000).Select(i => (byte)(i * 3))]); + remote.Renders.Add(second); + remote.UpdatedAt = DateTimeOffset.UtcNow.AddSeconds(1); + var (other, archive) = await f.Archive.OtherWriterAsync(); + var away = await other.PlanRenameAsync(archive.Id, [local.Id], "elsewhere/{title}", null, f.Ct); + await other.ApplyRenameAsync(away, null, f.Ct); + job = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Star trails", SyncDownloadMode.Exports, null); + var failed = await f.Archive.WaitForAsync(job.Id, JobState.Failed); + Assert.Equal(Loc.L("Errors.Archive.FolderMoved"), failed.Error); + Assert.False(Directory.Exists(f.Archive.Paths.Sequence(moved!).Folder), "the folder it left is not created again"); + Assert.Null(await f.Db.Renders.GetAsync(second.Id, f.Ct)); + + await f.Archive.ScanAsync(); + job = await f.Sync.EnqueueDownloadAsync(engine, f.Server, remote.Id, "Star trails", SyncDownloadMode.Exports, null); + await f.Archive.WaitForAsync(job.Id, JobState.Done); + var fetched = (await f.Db.Renders.GetAsync(second.Id, f.Ct))!; + Assert.Equal("elsewhere/Star trails/exports/Star trails 1080p.mp4", fetched.OutputPath); + Assert.SequenceEqual(second.Bytes, await File.ReadAllBytesAsync(f.Archive.Paths.FromRelative(fetched.OutputPath), f.Ct)); + } + [Test] public async Task RendersMadeHereAreSentOnRequestAndAGoneFileIsReported() { diff --git a/tests/Chronos.Server.Tests/Api/AdminTests.cs b/tests/Chronos.Server.Tests/Api/AdminTests.cs index 53d74800..1e1284fe 100644 --- a/tests/Chronos.Server.Tests/Api/AdminTests.cs +++ b/tests/Chronos.Server.Tests/Api/AdminTests.cs @@ -175,6 +175,22 @@ public sealed class AdminTests(TestContext context) using (var bad = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { FolderTemplate = "{year/{date" }, ProtocolJson.Default.ArchiveSettingsDto)) Assert.Equal("folderTemplate", (await bad.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template")).Details); + // Templates that would hide sequences from scans, drop extensions or repeat names: refused as Reorganize refuses them, + // with the rule after the field and the message saying why, as the desktop does. + foreach (var (refused, details, rule) in new[] + { + (archive with { FolderTemplate = "Originals/{year}" }, "folderTemplate:reserved_folder", "ReservedFolder"), + (archive with { FileTemplate = "{n}{ext}" }, "fileTemplate:extension", "Extension"), + (archive with { FileTemplate = "{date}" }, "fileTemplate:not_unique", "NotUnique"), + (archive with { FileTemplate = " " }, "fileTemplate", (string?)null), + }) + { + using var response = await admin.PutAsJsonAsync("/api/v1/archive/settings", refused, ProtocolJson.Default.ArchiveSettingsDto); + var error = await response.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template"); + Assert.Equal(details, error.Details); + Assert.Equal(Chronos.Core.Localization.Loc.Get(rule is null ? "Server.Error.InvalidTemplate" : "Errors.Template." + rule, + System.Globalization.CultureInfo.GetCultureInfo("en")), error.Message); + } using (var good = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { Name = "Studio", ProxyLongEdge = 2560 }, ProtocolJson.Default.ArchiveSettingsDto)) { var saved = await good.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto); @@ -250,4 +266,54 @@ public sealed class AdminTests(TestContext context) } await File.WriteAllBytesAsync(path, saved, context.Cancellation); } + + [Test] + public async Task TemplatesSavedBeforeTheRulesNeverFailASaveOfTheOtherFields() + { + await using var server = await TestServer.StartAsync(context, services: Chronos.Server.Storage.ArchiveModule.Register); + var admin = await server.AdminAsync(); + // An archive.json of 0.1.0-rc.5 or earlier: both templates break a rule new templates are held to. + var path = new Chronos.Core.Archiving.ArchivePaths(server.Options.ArchivePath).ManifestPath; + var manifest = Chronos.Core.Archiving.ManifestStore.ReadArchive(path); + Chronos.Core.Archiving.ManifestStore.WriteArchive(path, manifest with + { + LayoutTemplates = new Chronos.Core.Archiving.LayoutTemplates { Folder = "exports/{date}", File = "{date}" }, + }); + using var read = await admin.GetAsync("/api/v1/archive/settings"); + var archive = await read.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto); + Assert.Equal(("exports/{date}", "{date}"), (archive.FolderTemplate, archive.FileTemplate)); + + // The form sends every field with each save: the name and the proxies change, the templates stay as they are. + using (var put = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { Name = "Studio", ProxyLongEdge = 2560 }, ProtocolJson.Default.ArchiveSettingsDto)) + { + var saved = await put.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto); + Assert.Equal(("Studio", "exports/{date}", "{date}", 2560), (saved.Name, saved.FolderTemplate, saved.FileTemplate, saved.ProxyLongEdge)); + } + archive = archive with { Name = "Studio", ProxyLongEdge = 2560 }; + + // A template given anew is held to every rule; each one is fixed alone. + using (var refused = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { FileTemplate = "{n}{ext}" }, ProtocolJson.Default.ArchiveSettingsDto)) + Assert.Equal("fileTemplate:extension", (await refused.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template")).Details); + using (var folder = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { FolderTemplate = "{year}/{date}" }, ProtocolJson.Default.ArchiveSettingsDto)) + { + var saved = await folder.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto); + Assert.Equal(("{year}/{date}", "{date}"), (saved.FolderTemplate, saved.FileTemplate)); + } + archive = archive with { FolderTemplate = "{year}/{date}" }; + + // A desktop fixed the file template in archive.json since the form was read: the old one the form still sends is no + // longer the file's, so it is held to the rules and the save says which one it breaks. + Chronos.Core.Archiving.ManifestStore.WriteArchive(path, Chronos.Core.Archiving.ManifestStore.ReadArchive(path) with + { + LayoutTemplates = new Chronos.Core.Archiving.LayoutTemplates { Folder = "{year}/{date}", File = "{date}_{n:0000}" }, + }); + var before = await File.ReadAllBytesAsync(path, context.Cancellation); + using (var stale = await admin.PutAsJsonAsync("/api/v1/archive/settings", archive with { ProxyLongEdge = 1280 }, ProtocolJson.Default.ArchiveSettingsDto)) + { + var error = await stale.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template"); + Assert.Equal(("fileTemplate:not_unique", Chronos.Core.Localization.Loc.Get("Errors.Template.NotUnique", System.Globalization.CultureInfo.GetCultureInfo("en"))), + (error.Details, error.Message)); + } + Assert.SequenceEqual(before, await File.ReadAllBytesAsync(path, context.Cancellation)); + } } diff --git a/tests/Chronos.Server.Tests/Api/ReorganizeTests.cs b/tests/Chronos.Server.Tests/Api/ReorganizeTests.cs new file mode 100644 index 00000000..ceb41b6c --- /dev/null +++ b/tests/Chronos.Server.Tests/Api/ReorganizeTests.cs @@ -0,0 +1,892 @@ +using System.Collections.Concurrent; +using System.Net; +using System.Net.Http.Json; +using Microsoft.Extensions.DependencyInjection; +using Chronos.Core.Archiving; +using Chronos.Core.Codecs.Jpeg; +using Chronos.Core.Model; +using Chronos.Data.Archiving; +using Chronos.Protocol; +using Chronos.Server.Api; +using Chronos.Server.Events; +using Chronos.Server.Storage; +using Chronos.Testing; + +namespace Chronos.Server.Tests.Api; + +/// +/// Reorganize on the server (owner review 2, R7): POST /api/v1/archive/reorganize, its dry run and the plan kept from it +/// for the confirmation (), the move job that applies the confirmed plan (paused and +/// resumed too), and what the request may not do, against the real archive engine. +/// +[Category("server")] +public sealed class ReorganizeTests(TestContext context) +{ + private const string Url = "/api/v1/archive/reorganize"; + private static readonly TimeSpan Wait = TimeSpan.FromSeconds(TestTiming.Budget(30)); + + [Test] + public async Task AReorganizeIsDryRunThenAppliedByAJob() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + Guid id = default; + for (var i = 0; i < 3; i++) id = (await Uploads.UploadAsync(editor, Photo(i), $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId; + await UntilIdleAsync(server); + var before = await server.Database.Frames.ListBySequenceAsync(id); + + var request = new ReorganizeRequest([id], false, "reorganized/{title}", "{title}_{n:000}", "Roof", DryRun: true); + ReorganizePlanDto plan; + using (var dry = await admin.PostAsJsonAsync(Url, request, ProtocolJson.Default.ReorganizeRequest)) + plan = await dry.ReadAsync(ProtocolJson.Default.ReorganizePlanDto); + Assert.Equal((1, 3, 0), (plan.Sequences, plan.Files, plan.Kept)); + var step = plan.Steps.Single(); + Assert.Equal((id, "reorganized/Roof", "Roof", 3), (step.SequenceId, step.ToFolder, step.ToTitle, step.FileChanges)); + Assert.SequenceEqual(["originals/Roof_001.JPG", "originals/Roof_002.JPG", "originals/Roof_003.JPG"], step.FileSamples.Select(f => f.To)); + Assert.Equal(64, plan.Fingerprint.Length); + Assert.SequenceEqual(before.Select(f => f.RelativePath), (await server.Database.Frames.ListBySequenceAsync(id)).Select(f => f.RelativePath)); + + using (var missing = await admin.PostAsJsonAsync(Url, request with { DryRun = false }, ProtocolJson.Default.ReorganizeRequest)) + Assert.Equal("fingerprint", (await missing.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request")).Details); + using (var wrong = await admin.PostAsJsonAsync(Url, request with { DryRun = false, Fingerprint = "0123" }, ProtocolJson.Default.ReorganizeRequest)) + Assert.Equal(plan.Fingerprint, (await wrong.ExpectErrorAsync(HttpStatusCode.Conflict, "plan_changed")).Details); + + using var events = server.Services.GetRequiredService().Subscribe(); + JobDto job; + using (var applied = await admin.PostAsJsonAsync(Url, request with { DryRun = false, Fingerprint = plan.Fingerprint }, ProtocolJson.Default.ReorganizeRequest)) + { + await applied.ExpectAsync(HttpStatusCode.Accepted); + job = await applied.ReadAsync(ProtocolJson.Default.JobDto); + } + Assert.Equal("move", job.Kind); + await UntilJobAsync(admin, job.Id, "done"); + + var sequence = (await server.Database.Sequences.GetAsync(id))!; + Assert.Equal(("reorganized/Roof", "Roof"), (sequence.Folder, sequence.Title)); + var after = await server.Database.Frames.ListBySequenceAsync(id); + Assert.SequenceEqual(before.Select(f => f.Id), after.Select(f => f.Id)); + Assert.SequenceEqual(["reorganized/Roof/originals/Roof_001.JPG", "reorganized/Roof/originals/Roof_002.JPG", "reorganized/Roof/originals/Roof_003.JPG"], + after.Select(f => f.RelativePath)); + foreach (var (was, now) in before.Zip(after)) + Assert.Equal(was.Sha256, Uploads.Sha(File.ReadAllBytes(Path.Combine(server.Options.ArchivePath, now.RelativePath)))); + Assert.NotEmpty((await server.Database.Audit.ListAsync(null, "archive_reorganized", 10, null)).Items); + + var until = DateTime.UtcNow + Wait; + while (true) + { + using var timeout = new CancellationTokenSource(until - DateTime.UtcNow); + var e = await events.Reader.ReadAsync(timeout.Token); + if (e is SequenceChangedEvent { Change: "reorganized" } changed && changed.SequenceId == id) + { + Assert.Equal(sequence.FramesVersion, changed.FramesVersion); + break; + } + } + } + + [Test] + public async Task AnExportMovesWithItsFolderAndStaysDownloadable() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + var id = (await Uploads.UploadAsync(editor, Photo(1), "IMG_0001.JPG", sessionKey: "roof")).SequenceId; + await UntilIdleAsync(server); + var folder = (await server.Database.Sequences.GetAsync(id))!.Folder; + var video = Uploads.Photo(4096, 28); + var relative = $"{folder}/exports/Roof - 4K.mp4"; + Directory.CreateDirectory(Path.GetDirectoryName(Path.Combine(server.Options.ArchivePath, relative))!); + await File.WriteAllBytesAsync(Path.Combine(server.Options.ArchivePath, relative), video); + var render = new Render { Id = Guid.CreateVersion7(), SequenceId = id, PresetName = "4K HEVC", OutputPath = relative, Bytes = video.Length, Created = DateTimeOffset.UtcNow }; + await server.Database.Renders.InsertAsync(render); + + // A new folder and title, the files keep their names: the folder moves with its exports. + var request = new ReorganizeRequest([id], false, "reorganized/{title}", null, "Roof", DryRun: true); + ReorganizePlanDto plan; + using (var dry = await admin.PostAsJsonAsync(Url, request, ProtocolJson.Default.ReorganizeRequest)) + plan = await dry.ReadAsync(ProtocolJson.Default.ReorganizePlanDto); + JobDto job; + using (var applied = await admin.PostAsJsonAsync(Url, request with { DryRun = false, Fingerprint = plan.Fingerprint }, ProtocolJson.Default.ReorganizeRequest)) + { + await applied.ExpectAsync(HttpStatusCode.Accepted); + job = await applied.ReadAsync(ProtocolJson.Default.JobDto); + } + await UntilJobAsync(admin, job.Id, "done"); + + Assert.Equal("reorganized/Roof", (await server.Database.Sequences.GetAsync(id))!.Folder); + Assert.Equal("reorganized/Roof/exports/Roof - 4K.mp4", (await server.Database.Renders.GetAsync(render.Id))!.OutputPath); + using var response = await editor.GetAsync($"/api/v1/renders/{render.Id}/file"); + await response.ExpectAsync(HttpStatusCode.OK); + await Http.BytesEqualAsync(video, response.Content.ReadAsByteArrayAsync()); + Assert.False(Directory.Exists(Path.Combine(server.Options.ArchivePath, folder)), "nothing is left at the old place"); + } + + [Test] + public async Task AnExportFiledAfterItsFolderMovedGoesWhereTheSequenceIsNow() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var id = (await Uploads.UploadAsync(editor, Photo(1), "IMG_0001.JPG", sessionKey: "roof")).SequenceId; + await UntilIdleAsync(server); + var stale = (await server.Database.Sequences.GetAsync(id))!; + + // A render node's output read the sequence before a Reorganize moved its folder, and is filed after it. + var archives = server.Services.GetRequiredService(); + var plan = await archives.PlanRenameAsync(stale.ArchiveId, [id], "reorganized/{date}", null, CancellationToken.None); + await archives.ApplyRenameAsync(plan, null, CancellationToken.None); + var folder = plan.Steps.Single().ToFolder; + var video = Uploads.Photo(4096, 29); + var staged = Path.Combine(context.CreateTempDirectory("staged"), "render.mp4"); + await File.WriteAllBytesAsync(staged, video); + var render = Assert.NotNull(await server.Services.GetRequiredService().CommitAsync(stale, staged, + new RenderResultRequest("Roof - 4K.mp4", video.Length, Uploads.Sha(video), "4K HEVC", "hevc", 3840, 2160, 25, 4), "studio-pc", CancellationToken.None)); + + Assert.Equal($"{folder}/exports/Roof - 4K.mp4", render.OutputPath); + await Http.BytesEqualAsync(video, File.ReadAllBytesAsync(Path.Combine(server.Options.ArchivePath, render.OutputPath))); + Assert.False(Directory.Exists(Path.Combine(server.Options.ArchivePath, stale.Folder)), "the folder it left is not created again"); + } + + [Test] + public async Task AnExportOfAFolderAnotherIndexMovedIsNotFiled() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var id = (await Uploads.UploadAsync(editor, Photo(1), "IMG_0001.JPG", sessionKey: "roof")).SequenceId; + await UntilIdleAsync(server); + var sequence = (await server.Database.Sequences.GetAsync(id))!; + + // A desktop sharing the archive moved the folder; this server's index still has it at the old place. + var left = Path.Combine(server.Options.ArchivePath, sequence.Folder); + Directory.Move(left, Path.Combine(server.Options.ArchivePath, "elsewhere")); + var video = Uploads.Photo(4096, 30); + var staged = Path.Combine(context.CreateTempDirectory("staged"), "render.mp4"); + await File.WriteAllBytesAsync(staged, video); + await Assert.ThrowsAsync(() => server.Services.GetRequiredService().CommitAsync(sequence, staged, + new RenderResultRequest("Roof - 4K.mp4", video.Length, Uploads.Sha(video), "4K HEVC", "hevc", 3840, 2160, 25, 4), "studio-pc", CancellationToken.None)); + + Assert.FileExists(staged); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + Assert.Empty(await server.Database.Renders.ListBySequenceAsync(id)); + } + + [Test] + public async Task AnExportIsNeverFiledAmongThoseOfAnotherSequenceMovedIntoItsFolder() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var id = (await Uploads.UploadAsync(editor, Photo(1), "IMG_0001.JPG", sessionKey: "roof")).SequenceId; + var other = (await Uploads.UploadAsync(editor, Photo(2), "IMG_0002.JPG", sessionKey: "cam")).SequenceId; + await UntilIdleAsync(server); + var sequence = (await server.Database.Sequences.GetAsync(id))!; + var stranger = (await server.Database.Sequences.GetAsync(other))!; + + // A desktop sharing the archive moved the folder away, then the other sequence into the folder it left; this server's + // index still has both where they were. + var folder = Path.Combine(server.Options.ArchivePath, sequence.Folder); + Directory.Move(folder, Path.Combine(server.Options.ArchivePath, "elsewhere")); + Directory.Move(Path.Combine(server.Options.ArchivePath, stranger.Folder), folder); + var before = Files(folder); + var video = Uploads.Photo(4096, 31); + var staged = Path.Combine(context.CreateTempDirectory("staged"), "render.mp4"); + await File.WriteAllBytesAsync(staged, video); + await Assert.ThrowsAsync(() => server.Services.GetRequiredService().CommitAsync(sequence, staged, + new RenderResultRequest("Roof - 4K.mp4", video.Length, Uploads.Sha(video), "4K HEVC", "hevc", 3840, 2160, 25, 4), "studio-pc", CancellationToken.None)); + + Assert.FileExists(staged); + Assert.SequenceEqual(before, Files(folder), "the other sequence's files are untouched"); + Assert.Empty(await server.Database.Renders.ListBySequenceAsync(id)); + } + + /// Every file under with the hash of its content, in path order. + private static List Files(string folder) => + [ + .. Directory.EnumerateFiles(folder, "*", SearchOption.AllDirectories).Order(StringComparer.Ordinal) + .Select(p => $"{Path.GetRelativePath(folder, p).Replace('\\', '/')} {Uploads.Sha(File.ReadAllBytes(p))}"), + ]; + + [Test] + public async Task AReorganizeAsksForTheArchiveAndAValidRequest() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + var a = (await Uploads.UploadAsync(editor, Photo(1), "a.jpg", sessionKey: "a")).SequenceId; + var b = (await Uploads.UploadAsync(editor, Photo(2), "b.jpg", sessionKey: "b")).SequenceId; + await UntilIdleAsync(server); + var valid = new ReorganizeRequest([a], false, null, "{n:000}", null, DryRun: true); + + using (var forbidden = await editor.PostAsJsonAsync(Url, valid, ProtocolJson.Default.ReorganizeRequest)) + await forbidden.ExpectErrorAsync(HttpStatusCode.Forbidden, "forbidden"); + foreach (var (bad, details) in new[] + { + (valid with { All = true }, "sequenceIds"), + (valid with { SequenceIds = null }, "sequenceIds"), + (valid with { SequenceIds = [] }, "sequenceIds"), + (valid with { SequenceIds = [.. Enumerable.Range(0, LibraryEndpoints.MaxBulkIds + 1).Select(_ => Guid.NewGuid())] }, "sequenceIds"), + (valid with { FileTemplate = null }, "templates"), + }) + { + using var response = await admin.PostAsJsonAsync(Url, bad, ProtocolJson.Default.ReorganizeRequest); + Assert.Equal(details, (await response.ExpectErrorAsync(HttpStatusCode.BadRequest, "bad_request")).Details); + } + using (var template = await admin.PostAsJsonAsync(Url, valid with { FileTemplate = "{nope}" }, ProtocolJson.Default.ReorganizeRequest)) + Assert.Equal("fileTemplate", (await template.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template")).Details); + // The desktop's rules: no lost extension, names that tell the photos apart, no folder scans skip; each named after the + // field, with the desktop's sentence. + foreach (var (bad, details, rule) in new[] + { + (valid with { FileTemplate = "{n}{ext}" }, "fileTemplate:extension", "Extension"), + (valid with { FileTemplate = "{title}" }, "fileTemplate:not_unique", "NotUnique"), + (valid with { FileTemplate = "{year}/{n}" }, "fileTemplate:file_separator", "FileSeparator"), + (valid with { FolderTemplate = "Exports/{title}" }, "folderTemplate:reserved_folder", "ReservedFolder"), + (valid with { FolderTemplate = ".hidden/{date}" }, "folderTemplate:reserved_folder", "ReservedFolder"), + }) + { + using var refused = await admin.PostAsJsonAsync(Url, bad, ProtocolJson.Default.ReorganizeRequest); + var error = await refused.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template"); + Assert.Equal(details, error.Details); + Assert.Equal(Chronos.Core.Localization.Loc.Get("Errors.Template." + rule, System.Globalization.CultureInfo.GetCultureInfo("en")), error.Message); + } + using (var blank = await admin.PostAsJsonAsync(Url, valid with { FolderTemplate = " " }, ProtocolJson.Default.ReorganizeRequest)) + Assert.Equal("folderTemplate", (await blank.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template")).Details); + using (var unknown = await admin.PostAsJsonAsync(Url, valid with { SequenceIds = [Guid.NewGuid()] }, ProtocolJson.Default.ReorganizeRequest)) + await unknown.ExpectErrorAsync(HttpStatusCode.NotFound, "not_found"); + + // One sequence's new folder inside the other's: refused, nothing planned. + var host = (await server.Database.Sequences.GetAsync(a))!.Folder; + using (var nested = await admin.PostAsJsonAsync(Url, new ReorganizeRequest([b], false, host + "/inside", null, null, DryRun: true), + ProtocolJson.Default.ReorganizeRequest)) + Assert.Equal(host + "/inside", (await nested.ExpectErrorAsync(HttpStatusCode.Conflict, "nested_target")).Details); + + using (var all = await admin.PostAsJsonAsync(Url, valid with { SequenceIds = null, All = true }, ProtocolJson.Default.ReorganizeRequest)) + { + var plan = await all.ReadAsync(ProtocolJson.Default.ReorganizePlanDto); + Assert.Equal((2, 2), (plan.Sequences, plan.Files)); + Assert.SequenceEqual(new[] { a, b }.Order(), plan.Steps.Select(s => s.SequenceId).Order()); + } + + // The archive drive is gone: neither a dry run nor a plan kept from one is answered. + var manifest = new ArchivePaths(server.Options.ArchivePath).ManifestPath; + File.Move(manifest, manifest + ".away"); + try + { + foreach (var request in new[] { valid, valid with { SequenceIds = null, All = true }, valid with { DryRun = false, Fingerprint = new string('0', 64) } }) + { + using var offline = await admin.PostAsJsonAsync(Url, request, ProtocolJson.Default.ReorganizeRequest); + await offline.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, "archive_offline"); + } + } + finally + { + File.Move(manifest + ".away", manifest); + } + Assert.Empty((await server.Database.Jobs.ListAsync(JobState.Queued, JobKind.Move)).Items); + } + + [Test] + public async Task AReorganizeIsRefusedWhereNoJobCanApplyIt() + { + // Without the archive module the server plans, but no handler of move jobs runs here. + await using var server = await TestServer.StartAsync(context); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + var id = (await Uploads.UploadAsync(editor, Photo(1), "a.jpg", sessionKey: "a")).SequenceId; + var request = new ReorganizeRequest([id], false, "moved/{date}", null, null, DryRun: true); + string fingerprint; + using (var dry = await admin.PostAsJsonAsync(Url, request, ProtocolJson.Default.ReorganizeRequest)) + { + // No archive engine wrote the sequence's sidecar here: it stays as it is, and says why. + var plan = await dry.ReadAsync(ProtocolJson.Default.ReorganizePlanDto); + Assert.Equal("unreadable", plan.Steps.Single().Blocked.Single().Reason); + fingerprint = plan.Fingerprint; + } + using (var unavailable = await admin.PostAsJsonAsync(Url, request with { DryRun = false, Fingerprint = fingerprint }, ProtocolJson.Default.ReorganizeRequest)) + Assert.Equal("move", (await unavailable.ExpectErrorAsync(HttpStatusCode.Conflict, "job_unavailable")).Details); + Assert.Empty((await server.Database.Jobs.ListAsync(null, JobKind.Move)).Items); + Assert.Empty((await server.Database.Audit.ListAsync(null, "archive_reorganized", 10, null)).Items); + } + + [Test] + public async Task EverySequenceIsReorganizedByAJobAroundThoseAlreadyInPlace() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + var days = new ReorganizeRequest(null, true, "days/{date}", null, null, DryRun: true); + // A sequence already where the template puts it: the others of that day go beside it. + var placed = (await Uploads.UploadAsync(editor, Photo(0), "IMG_0001.JPG", sessionKey: "placed")).SequenceId; + await UntilIdleAsync(server); + await UntilJobAsync(admin, await ConfirmAsync(admin, days with { All = false, SequenceIds = [placed] }), "done"); + Assert.Equal("days/2026-09-28", (await server.Database.Sequences.GetAsync(placed))!.Folder); + var a = (await Uploads.UploadAsync(editor, Photo(1), "IMG_0002.JPG", sessionKey: "a")).SequenceId; + var b = (await Uploads.UploadAsync(editor, Photo(2), "IMG_0003.JPG", sessionKey: "b")).SequenceId; + await UntilIdleAsync(server); + + ReorganizePlanDto plan; + using (var dry = await admin.PostAsJsonAsync(Url, days, ProtocolJson.Default.ReorganizeRequest)) + plan = await dry.ReadAsync(ProtocolJson.Default.ReorganizePlanDto); + Assert.Equal((2, 0, 0), (plan.Sequences, plan.Files, plan.Kept)); + Assert.SequenceEqual(new[] { a, b }.Order(), plan.Steps.Select(s => s.SequenceId).Order()); + Assert.SequenceEqual(["days/2026-09-28 (2)", "days/2026-09-28 (3)"], plan.Steps.Select(s => s.ToFolder).Order(StringComparer.Ordinal)); + + // The job plans again over the sequences with a step only: the one left where it is still decides the " (n)". + using var events = server.Services.GetRequiredService().Subscribe(); + var job = await ConfirmAsync(admin, days with { DryRun = false, Fingerprint = plan.Fingerprint }); + await UntilJobAsync(admin, job, "done"); + var folders = new Dictionary(); + foreach (var id in new[] { placed, a, b }) folders[id] = (await server.Database.Sequences.GetAsync(id))!.Folder; + Assert.Equal("days/2026-09-28", folders[placed]); + Assert.SequenceEqual(plan.Steps.Select(s => s.ToFolder), plan.Steps.Select(s => folders[s.SequenceId])); + foreach (var id in new[] { a, b }) + Assert.True(Directory.Exists(Path.Combine(server.Options.ArchivePath, folders[id])), folders[id]); + Assert.SequenceEqual(new[] { a, b }.Order(), (await ReorganizedAsync(events, 2)).Order()); + + using var again = await admin.PostAsJsonAsync(Url, days, ProtocolJson.Default.ReorganizeRequest); + Assert.Equal(0, (await again.ReadAsync(ProtocolJson.Default.ReorganizePlanDto)).Sequences); + } + + [Test] + public async Task EverySequenceIsReorganizedByAJobWithTheOnesItCarriesAndTheOnesWhosePhotosStay() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + var roof = Guid.Empty; + for (var i = 0; i < 2; i++) roof = (await Uploads.UploadAsync(editor, Photo(i), $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId; + await UntilIdleAsync(server); + await UntilJobAsync(admin, await ConfirmAsync(admin, new ReorganizeRequest([roof], false, null, null, "Roof", DryRun: true)), "done"); + var folder = (await server.Database.Sequences.GetAsync(roof))!.Folder; + // Photos copied in by hand and found by a scan: in the layout inside the roof's folder (a sequence without a title), + // and in place in a folder of their own (titled by it). + var root = server.Options.ArchivePath; + Directory.CreateDirectory(Path.Combine(root, folder, "inner", "originals")); + await File.WriteAllBytesAsync(Path.Combine(root, folder, "inner", "originals", "IMG_0100.JPG"), Photo(3)); + Directory.CreateDirectory(Path.Combine(root, "trips")); + for (var i = 0; i < 2; i++) await File.WriteAllBytesAsync(Path.Combine(root, "trips", $"IMG_{i + 200:0000}.JPG"), Photo(4 + i)); + using (var scan = await admin.PostAsync("/api/v1/archive/scan", null)) await scan.ExpectAsync(HttpStatusCode.Accepted); + await UntilIdleAsync(server); + var locations = await server.Database.Sequences.ListLocationsAsync((await server.Database.Archives.ListAsync()).Single().Id); + var inner = locations.Single(l => l.Folder == folder + "/inner").Id; + var trips = locations.Single(l => l.Folder == "trips").Id; + var tripFiles = Directory.GetFiles(Path.Combine(root, "trips")).Order(StringComparer.Ordinal).ToList(); + + // The roof moves to its title with its photos renamed and carries the sequence inside it, whose title gives no + // folder; the trips keep their folder, and their photos their names, which the plan says why. + var every = new ReorganizeRequest(null, true, "{title}", "{n:000}", null, DryRun: true); + var plan = await DryRunAsync(admin, every); + Assert.SequenceEqual([roof, trips, inner], plan.Steps.Select(s => s.SequenceId)); + Assert.Equal(("Roof", false, 2), (plan.Steps[0].ToFolder, plan.Steps[0].Carried, plan.Steps[0].FileChanges)); + Assert.Equal(("trips", 0), (plan.Steps[1].ToFolder, plan.Steps[1].FileChanges)); + Assert.Equal(("in_place", 2), (plan.Steps[1].Blocked.Single().Reason, plan.Steps[1].Blocked.Single().Photos)); + Assert.Equal(("Roof/inner", true, 0), (plan.Steps[2].ToFolder, plan.Steps[2].Carried, plan.Steps[2].FileChanges)); + Assert.Equal((2, 2), (plan.Sequences, plan.Files)); + + // The job plans again over the sequences with a step, the carried and the kept ones among them, and ends done. + using var events = server.Services.GetRequiredService().Subscribe(); + await UntilJobAsync(admin, await ConfirmAsync(admin, every with { DryRun = false, Fingerprint = plan.Fingerprint }), "done"); + Assert.Equal(("Roof", "Roof"), ((await server.Database.Sequences.GetAsync(roof))!.Folder, (await server.Database.Sequences.GetAsync(roof))!.Title)); + Assert.SequenceEqual(["Roof/originals/001.JPG", "Roof/originals/002.JPG"], (await server.Database.Frames.ListBySequenceAsync(roof)).Select(f => f.RelativePath)); + Assert.Equal("Roof/inner", (await server.Database.Sequences.GetAsync(inner))!.Folder); + Assert.SequenceEqual(["Roof/inner/originals/IMG_0100.JPG"], (await server.Database.Frames.ListBySequenceAsync(inner)).Select(f => f.RelativePath)); + Assert.True(File.Exists(Path.Combine(root, "Roof", "inner", "originals", "IMG_0100.JPG")), "the carried photo moved with its folder"); + Assert.Equal("trips", (await server.Database.Sequences.GetAsync(trips))!.Folder); + Assert.SequenceEqual(tripFiles, Directory.GetFiles(Path.Combine(root, "trips")).Order(StringComparer.Ordinal)); + Assert.False(Directory.Exists(Path.Combine(root, folder)), "nothing is left at the old place"); + Assert.SequenceEqual(new[] { roof, inner }.Order(), (await ReorganizedAsync(events, 2)).Order()); + + // Done: the next dry run plans no change, only the photos that keep their names. + var after = await DryRunAsync(admin, every); + Assert.Equal(0, after.Sequences); + } + + [Test] + public async Task AnUploadAfterTheDryRunChangesThePlanToConfirm() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + Guid id = default; + for (var i = 0; i < 2; i++) id = (await Uploads.UploadAsync(editor, Photo(i), $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId; + await UntilIdleAsync(server); + var request = new ReorganizeRequest([id], false, null, "{n:000}", null, DryRun: true); + var shown = await DryRunAsync(admin, request); + Assert.Equal(2, shown.Files); + + // A photo arrives before Apply: the plan confirmed is not the one now, which the answer carries. + await Uploads.UploadAsync(editor, Photo(2), "IMG_0003.JPG", sessionKey: "roof"); + await UntilIdleAsync(server); + string now; + using (var changed = await admin.PostAsJsonAsync(Url, request with { DryRun = false, Fingerprint = shown.Fingerprint }, ProtocolJson.Default.ReorganizeRequest)) + now = Assert.NotNull((await changed.ExpectErrorAsync(HttpStatusCode.Conflict, "plan_changed")).Details); + Assert.NotEqual(shown.Fingerprint, now); + Assert.Empty((await server.Database.Jobs.ListAsync(null, JobKind.Move)).Items); + var replanned = await DryRunAsync(admin, request); + Assert.Equal((now, 3), (replanned.Fingerprint, replanned.Files)); + + await UntilJobAsync(admin, await ConfirmAsync(admin, request with { DryRun = false, Fingerprint = now }), "done"); + Assert.SequenceEqual(["001.JPG", "002.JPG", "003.JPG"], (await server.Database.Frames.ListBySequenceAsync(id)).Select(f => f.FileName)); + } + + [Test] + public async Task AnUploadFiledUnderTheNameThePlanGivesLeavesThePlanToConfirm() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + Guid id = default; + for (var i = 0; i < 2; i++) id = (await Uploads.UploadAsync(editor, Photo(i), $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId; + await UntilIdleAsync(server); + // The archive files new photos as the Reorganize names them; the two filed before do not follow it yet. + using (var read = await admin.GetAsync("/api/v1/archive/settings")) + { + var settings = await read.ReadAsync(ProtocolJson.Default.ArchiveSettingsDto); + using var put = await admin.PutAsJsonAsync("/api/v1/archive/settings", settings with { FileTemplate = "{n:000}" }, ProtocolJson.Default.ArchiveSettingsDto); + await put.ExpectAsync(HttpStatusCode.OK); + } + var request = new ReorganizeRequest([id], false, null, "{n:000}", null, DryRun: true); + var shown = await DryRunAsync(admin, request); + Assert.Equal(2, shown.Files); + + // The camera still uploads before Apply, a photo after the others: it takes the name the plan leaves it, so the plan + // confirmed is the one now. + await Uploads.UploadAsync(editor, Photo(2), "IMG_0003.JPG", sessionKey: "roof", capturedAt: new DateTime(2026, 9, 28, 18, 3, 0)); + await UntilIdleAsync(server); + Assert.Equal("003.JPG", (await server.Database.Frames.ListBySequenceAsync(id))[^1].FileName); + await UntilJobAsync(admin, await ConfirmAsync(admin, request with { DryRun = false, Fingerprint = shown.Fingerprint }), "done"); + Assert.SequenceEqual(["001.JPG", "002.JPG", "003.JPG"], (await server.Database.Frames.ListBySequenceAsync(id)).Select(f => f.FileName)); + } + + [Test] + public async Task AMoveJobPausedBetweenTwoSequencesCompletesTheRestWhenResumed() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + var first = (await Uploads.UploadAsync(editor, Photo(0), "IMG_0001.JPG", sessionKey: "first")).SequenceId; + var second = (await Uploads.UploadAsync(editor, Photo(1), "IMG_0002.JPG", sessionKey: "second")).SequenceId; + await UntilIdleAsync(server); + var request = new ReorganizeRequest([first, second], false, "moved/{date}", null, null, DryRun: true); + var plan = await DryRunAsync(admin, request); + Assert.SequenceEqual([first, second], plan.Steps.Select(s => s.SequenceId)); + var was = (await server.Database.Sequences.GetAsync(second))!.Folder; + + // The second sequence is busy (an editor saving it): the job moves the first, then waits for it and is paused there. + var paths = new ArchivePaths(server.Options.ArchivePath); + var busy = Assert.NotNull(LeaseFile.TryAcquire(paths.LocksDirectory, $"seq-{second:N}", "tests")); + using var events = server.Services.GetRequiredService().Subscribe(); + Guid job; + try + { + job = await ConfirmAsync(admin, request with { DryRun = false, Fingerprint = plan.Fingerprint }); + await UntilAsync(admin, job, j => j is { State: "running", ProgressDone: 1 }); + using (var pause = await admin.PostAsync($"/api/v1/jobs/{job}/pause", null)) await pause.ExpectAsync(HttpStatusCode.OK); + await UntilJobAsync(admin, job, "paused"); + // The job is paused before its run stops: once stopped, the plan waits for it. + var until = DateTime.UtcNow + Wait; + while (!RenameJournal.ListPending(paths).Single().Held) + { + Assert.True(DateTime.UtcNow < until, "the plan is held"); + await Task.Delay(50); + } + } + finally + { + busy.Dispose(); + } + Assert.Equal(plan.Steps[0].ToFolder, (await server.Database.Sequences.GetAsync(first))!.Folder); + Assert.Equal(was, (await server.Database.Sequences.GetAsync(second))!.Folder); + // The first sequence was told as soon as its step was done, before the pause. + Assert.SequenceEqual([first], await ReorganizedAsync(events, 1)); + + // Resumed, it completes the plan it held and tells the sequence it changed then, and that one only. + using (var resume = await admin.PostAsync($"/api/v1/jobs/{job}/resume", null)) await resume.ExpectAsync(HttpStatusCode.OK); + await UntilJobAsync(admin, job, "done"); + Assert.Equal(plan.Steps[1].ToFolder, (await server.Database.Sequences.GetAsync(second))!.Folder); + Assert.Empty(RenameJournal.ListPending(paths)); + Assert.SequenceEqual([second], await ReorganizedAsync(events, 1, second)); + } + + [Test] + public async Task ADryRunIsKeptForTheConfirmWhileTheIndexStaysAsItWas() + { + var clock = new ManualTimeProvider(); + await using var server = await TestServer.StartAsync(context, services: s => + { + ArchiveModule.Register(s); + s.AddSingleton(clock); + }); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + var admin = await server.AdminAsync(); + Guid id = default; + for (var i = 0; i < 2; i++) id = (await Uploads.UploadAsync(editor, Photo(i), $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId; + var other = (await Uploads.UploadAsync(editor, Photo(5), "IMG_0100.JPG", sessionKey: "other")).SequenceId; + await UntilIdleAsync(server); + var request = new ReorganizeRequest([id], false, "moved/{date}", "{n:000}", null, DryRun: true); + var target = Path.Combine(server.Options.ArchivePath, "moved", "2026-09-28"); + var before = (await server.Database.Sequences.GetAsync(id))!.Folder; + + // A folder made on disk alone is not in the index: the same dry run again is the plan made before. + var shown = await DryRunAsync(admin, request); + Assert.Equal(("moved/2026-09-28", 2), (shown.Steps.Single().ToFolder, shown.Files)); + Directory.CreateDirectory(target); + Assert.Equal(shown.Fingerprint, (await DryRunAsync(admin, request)).Fingerprint); + + // Neither are what the plan does not read: a photo uploaded into another sequence (and the jobs it queues), a verify + // of photos an upload hashed already. + var versions = (await server.Database.Sequences.GetAsync(other))!.FramesVersion; + await Uploads.UploadAsync(editor, Photo(6), "IMG_0101.JPG", sessionKey: "other"); + using (var verify = await admin.PostAsync("/api/v1/archive/verify", null)) await verify.ExpectAsync(HttpStatusCode.Accepted); + await UntilIdleAsync(server); + Assert.NotEqual(versions, (await server.Database.Sequences.GetAsync(other))!.FramesVersion); + Assert.NotNull((await server.Database.Sequences.GetAsync(id))!.VerifiedAt); + Assert.Equal(shown.Fingerprint, (await DryRunAsync(admin, request)).Fingerprint); + + // A change of what it reads plans again at once. + await Uploads.UploadAsync(editor, Photo(2), "IMG_0003.JPG", sessionKey: "roof"); + await UntilIdleAsync(server); + var beside = await DryRunAsync(admin, request); + Assert.Equal(("moved/2026-09-28 (2)", 3), (beside.Steps.Single().ToFolder, beside.Files)); + + // The confirmation takes the plan kept; the job plans again and refuses what the kept plan could not see. + Directory.Delete(target); + Assert.Equal(beside.Fingerprint, (await DryRunAsync(admin, request)).Fingerprint); + Assert.Equal("failed", (await FinishedAsync(admin, await ConfirmAsync(admin, request with { DryRun = false, Fingerprint = beside.Fingerprint }))).State); + Assert.Equal(before, (await server.Database.Sequences.GetAsync(id))!.Folder); + Assert.False(Directory.Exists(target), "nothing moved"); + Assert.Empty(RenameJournal.ListPending(new ArchivePaths(server.Options.ArchivePath))); + + // A queued plan is no longer kept; a kept one lasts its lifetime. + var free = await DryRunAsync(admin, request); + Assert.Equal(("moved/2026-09-28", 3), (free.Steps.Single().ToFolder, free.Files)); + Directory.CreateDirectory(target); + Assert.Equal(free.Fingerprint, (await DryRunAsync(admin, request)).Fingerprint); + await UntilIdleAsync(server); + clock.Advance(ReorganizePlanCache.Lifetime); + var later = await DryRunAsync(admin, request); + Assert.Equal("moved/2026-09-28 (2)", later.Steps.Single().ToFolder); + using (var changed = await admin.PostAsJsonAsync(Url, request with { DryRun = false, Fingerprint = free.Fingerprint }, ProtocolJson.Default.ReorganizeRequest)) + Assert.Equal(later.Fingerprint, (await changed.ExpectErrorAsync(HttpStatusCode.Conflict, "plan_changed")).Details); + await UntilJobAsync(admin, await ConfirmAsync(admin, request with { DryRun = false, Fingerprint = later.Fingerprint }), "done"); + Assert.Equal("moved/2026-09-28 (2)", (await server.Database.Sequences.GetAsync(id))!.Folder); + } + + [Test] + public async Task ADryRunPlansAgainOnceAVerifyHashedItsPhotos() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var admin = await server.AdminAsync(); + // Photos copied into the archive's layout by hand and found by a scan: never hashed, they keep their names. + var originals = Path.Combine(server.Options.ArchivePath, "trips", "originals"); + Directory.CreateDirectory(originals); + for (var i = 0; i < 2; i++) await File.WriteAllBytesAsync(Path.Combine(originals, $"IMG_{i:0000}.JPG"), Photo(i)); + using (var scan = await admin.PostAsync("/api/v1/archive/scan", null)) await scan.ExpectAsync(HttpStatusCode.Accepted); + await UntilIdleAsync(server); + var id = (await server.Database.Sequences.ListLocationsAsync((await server.Database.Archives.ListAsync()).Single().Id)).Single().Id; + var request = new ReorganizeRequest([id], false, null, "{n:000}", null, DryRun: true); + var unhashed = await DryRunAsync(admin, request); + Assert.Equal((0, 2), (unhashed.Files, unhashed.Kept)); + Assert.Equal("unhashed", unhashed.Steps.Single().Blocked.Single().Reason); + + // A verify hashes them and leaves the sequence's frames version as it was: the same dry run plans again, and renames them. + var versions = (await server.Database.Sequences.GetAsync(id))!.FramesVersion; + using (var verify = await admin.PostAsync("/api/v1/archive/verify", null)) await verify.ExpectAsync(HttpStatusCode.Accepted); + await UntilIdleAsync(server); + Assert.Equal(versions, (await server.Database.Sequences.GetAsync(id))!.FramesVersion); + var hashed = await DryRunAsync(admin, request); + Assert.Equal((2, 0), (hashed.Files, hashed.Kept)); + await UntilJobAsync(admin, await ConfirmAsync(admin, request with { DryRun = false, Fingerprint = hashed.Fingerprint }), "done"); + Assert.SequenceEqual(["trips/originals/001.JPG", "trips/originals/002.JPG"], (await server.Database.Frames.ListBySequenceAsync(id)).Select(f => f.RelativePath)); + Assert.True(File.Exists(Path.Combine(originals, "001.JPG")), "renamed on disk"); + } + + [Test] + public async Task KeptPlansAreTheNewestFewWithinTheirLifetime() + { + var clock = new ManualTimeProvider(); + using var plans = new ReorganizePlanCache(clock); + var archive = Guid.NewGuid(); + var templates = new RenameTemplates(Folder: "moved/{date}"); + var made = 0; + Task Plan(CancellationToken stop) + { + made++; + return Task.FromResult(new RenamePlan(Guid.NewGuid(), archive, [])); + } + ReorganizePlanCache.Key Key(int i) => ReorganizePlanCache.Key.Of(archive, "stamp", [new Guid(i, 0, 0, new byte[8])], templates); + + var kept = await plans.GetOrPlanAsync(Key(0), Plan); + Assert.True(ReferenceEquals(kept, await plans.GetOrPlanAsync(Key(0), Plan)), "kept"); + Assert.Equal(1, made); + // Another order of the sequences, every sequence, another stamp or other templates is another plan. + var (x, y) = (Guid.NewGuid(), Guid.NewGuid()); + Assert.NotEqual(ReorganizePlanCache.Key.Of(archive, "stamp", [x, y], templates), ReorganizePlanCache.Key.Of(archive, "stamp", [y, x], templates)); + Assert.Equal(ReorganizePlanCache.Key.Of(archive, "stamp", [x, y], templates), ReorganizePlanCache.Key.Of(archive, "stamp", [x, y], templates with { })); + Assert.NotEqual(ReorganizePlanCache.Key.Of(archive, "stamp", null, templates), ReorganizePlanCache.Key.Of(archive, "stamp", [x], templates)); + Assert.NotEqual(Key(0), ReorganizePlanCache.Key.Of(archive, "other", [new Guid(0, 0, 0, new byte[8])], templates)); + Assert.NotEqual(Key(0), ReorganizePlanCache.Key.Of(archive, "stamp", [new Guid(0, 0, 0, new byte[8])], templates with { File = "{n}" })); + + // At most Capacity plans: the oldest goes first. + for (var i = 1; i <= ReorganizePlanCache.Capacity; i++) + { + clock.Advance(TimeSpan.FromSeconds(1)); + await plans.GetOrPlanAsync(Key(i), Plan); + } + Assert.Equal(1 + ReorganizePlanCache.Capacity, made); + await plans.GetOrPlanAsync(Key(ReorganizePlanCache.Capacity), Plan); + Assert.Equal(1 + ReorganizePlanCache.Capacity, made); + await plans.GetOrPlanAsync(Key(0), Plan); + Assert.Equal(2 + ReorganizePlanCache.Capacity, made); + + // A plan is kept for its lifetime, from when it was made, even before its timer lets it go. + clock.Advance(ReorganizePlanCache.Lifetime - TimeSpan.FromSeconds(1)); + await plans.GetOrPlanAsync(Key(0), Plan); + Assert.Equal(2 + ReorganizePlanCache.Capacity, made); + clock.Advance(TimeSpan.FromSeconds(1)); + await plans.GetOrPlanAsync(Key(0), Plan); + Assert.Equal(3 + ReorganizePlanCache.Capacity, made); + + // A refusal follows from the same reads, and is kept as a plan is: a folder inside a sequence's, a sequence not in the + // archive. A failure is not kept, and neither is a plan or refusal forgotten. + await Assert.ThrowsAsync(() => plans.GetOrPlanAsync(Key(99), _ => throw new NestedRenameException("a/b", "a"))); + await Assert.ThrowsAsync(() => plans.GetOrPlanAsync(Key(99), Plan)); + await Assert.ThrowsAsync(() => plans.GetOrPlanAsync(Key(98), _ => throw new ArgumentException("Not in the archive."))); + await Assert.ThrowsAsync(() => plans.GetOrPlanAsync(Key(98), Plan)); + Assert.Equal(3 + ReorganizePlanCache.Capacity, made); + await Assert.ThrowsAsync(() => plans.GetOrPlanAsync(Key(97), _ => throw new IOException("The sidecar cannot be read."))); + await plans.GetOrPlanAsync(Key(97), Plan); + Assert.Equal(4 + ReorganizePlanCache.Capacity, made); + plans.Forget(Key(99)); + await plans.GetOrPlanAsync(Key(99), Plan); + Assert.Equal(5 + ReorganizePlanCache.Capacity, made); + } + + [Test] + public async Task APlanIsMadeOnceForEveryRequestAndOutlivesOneCutOff() + { + var clock = new SteppedTimeProvider(); + using var plans = new ReorganizePlanCache(clock); + var templates = new RenameTemplates(Folder: "moved/{date}"); + var key = ReorganizePlanCache.Key.Of(Guid.NewGuid(), "stamp", null, templates); + var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var made = 0; + async Task SlowPlan(CancellationToken stop) + { + Interlocked.Increment(ref made); + await release.Task; + return new RenamePlan(Guid.NewGuid(), key.ArchiveId, []); + } + + // A request cut off while its plan is made (a proxy's timeout) leaves it to be made; asked again, it is waited for. + using (var cutOff = new CancellationTokenSource()) + { + var first = plans.GetOrPlanAsync(key, SlowPlan, cutOff.Token); + await cutOff.CancelAsync(); + await Assert.ThrowsAsync(() => first); + } + var again = plans.GetOrPlanAsync(key, SlowPlan); + var meanwhile = plans.GetOrPlanAsync(key, SlowPlan); + // Being made, it is not the one let go for other plans. + for (var i = 0; i < ReorganizePlanCache.Capacity; i++) + await plans.GetOrPlanAsync(ReorganizePlanCache.Key.Of(key.ArchiveId, "stamp", [new Guid(i, 0, 0, new byte[8])], templates), PlanAtOnce); + release.SetResult(); + var plan = await again; + Assert.True(ReferenceEquals(plan, await meanwhile), "one plan for both"); + Assert.True(ReferenceEquals(plan, await plans.GetOrPlanAsync(key, SlowPlan)), "kept"); + Assert.Equal(1 + ReorganizePlanCache.Capacity, made); + Assert.Equal(ReorganizePlanCache.Capacity, plans.Count); + + // Its timer lets it go at the end of its lifetime, with no request asking. + clock.Advance(ReorganizePlanCache.Lifetime - TimeSpan.FromSeconds(1)); + Assert.Equal(ReorganizePlanCache.Capacity, plans.Count); + clock.Advance(TimeSpan.FromSeconds(1)); + Assert.Equal(0, plans.Count); + await plans.GetOrPlanAsync(key, SlowPlan); + Assert.Equal(2 + ReorganizePlanCache.Capacity, made); + + Task PlanAtOnce(CancellationToken stop) + { + Interlocked.Increment(ref made); + return Task.FromResult(new RenamePlan(Guid.NewGuid(), key.ArchiveId, [])); + } + } + + [Test] + public async Task PlansAreMadeAFewAtOnceAndStopWhenLetGoOrPastTheirTime() + { + var clock = new SteppedTimeProvider(); + using var plans = new ReorganizePlanCache(clock); + var archive = Guid.NewGuid(); + var templates = new RenameTemplates(Folder: "moved/{date}"); + ReorganizePlanCache.Key Key(int i) => ReorganizePlanCache.Key.Of(archive, "stamp", [new Guid(i, 0, 0, new byte[8])], templates); + var release = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + var started = new ConcurrentDictionary(); + var stopped = new ConcurrentDictionary(); + // A plan made once released, which tells when it starts and when it is stopped. + Func> Plan(int i) => async stop => + { + started[i] = true; + try + { + await release.Task.WaitAsync(stop); + } + catch (OperationCanceledException) + { + stopped[i] = true; + throw; + } + return new RenamePlan(Guid.NewGuid(), archive, []); + }; + + // A few are made at once; the others wait for their turn. + var asked = Enumerable.Range(0, ReorganizePlanCache.Capacity).Select(i => plans.GetOrPlanAsync(Key(i), Plan(i))).ToList(); + await EventuallyAsync(() => started.Count == ReorganizePlanCache.Concurrency); + await Task.Delay(200); + Assert.SequenceEqual(Enumerable.Range(0, ReorganizePlanCache.Concurrency), started.Keys.Order()); + + // One more lets go the plan asked first, being made with none kept: it stops, its waiter is told, the next one starts. + var newest = plans.GetOrPlanAsync(Key(ReorganizePlanCache.Capacity), Plan(ReorganizePlanCache.Capacity)); + await Assert.ThrowsAsync(() => asked[0]); + await EventuallyAsync(() => stopped.ContainsKey(0) && started.ContainsKey(ReorganizePlanCache.Concurrency)); + Assert.Equal(ReorganizePlanCache.Capacity, plans.Count); + release.SetResult(); + foreach (var plan in asked.Skip(1).Append(newest)) await plan; + Assert.SequenceEqual([0], stopped.Keys); + + // A plan still being made at its time stops, also when its work never ends (a read that hangs), and so does one still + // waiting for its turn, which never starts. + var hang = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + Func> Hanging(int i) => _ => + { + started[i] = true; + return hang.Task; + }; + var hung = plans.GetOrPlanAsync(Key(20), Hanging(20)); + var stuck = plans.GetOrPlanAsync(Key(21), Hanging(21)); + await EventuallyAsync(() => started.ContainsKey(20) && started.ContainsKey(21)); + var waiting = plans.GetOrPlanAsync(Key(22), Plan(22)); + clock.Advance(ReorganizePlanCache.PlanTimeout - TimeSpan.FromSeconds(1)); + Assert.False(hung.IsCompleted, "still in time"); + clock.Advance(TimeSpan.FromSeconds(1)); + foreach (var plan in new[] { hung, stuck, waiting }) await Assert.ThrowsAsync(() => plan); + Assert.False(started.ContainsKey(22), "stopped before its turn"); + Assert.Equal(0, plans.Count); + + // Asked again, it is made once a turn is free: the work that hangs holds its turn until it ends, and what it makes + // then is not kept. + var again = plans.GetOrPlanAsync(Key(20), Plan(30)); + await Task.Delay(200); + Assert.False(started.ContainsKey(30), "no turn while two works hang"); + hang.SetResult(new RenamePlan(Guid.NewGuid(), archive, [])); + var made = await again; + Assert.True(ReferenceEquals(made, await plans.GetOrPlanAsync(Key(20), Plan(31))), "kept"); + Assert.False(started.ContainsKey(31), "kept, not made again"); + Assert.Equal(1, plans.Count); + } + + /// Waits until holds. + private static async Task EventuallyAsync(Func condition, [System.Runtime.CompilerServices.CallerArgumentExpression(nameof(condition))] string? expression = null) + { + var until = DateTime.UtcNow + Wait; + while (!condition()) + { + Assert.True(DateTime.UtcNow < until, expression); + await Task.Delay(10); + } + } + + private static async Task DryRunAsync(HttpClient client, ReorganizeRequest request) + { + using var response = await client.PostAsJsonAsync(Url, request with { DryRun = true }, ProtocolJson.Default.ReorganizeRequest); + return await response.ReadAsync(ProtocolJson.Default.ReorganizePlanDto); + } + + /// Confirms a plan; returns the move job queued. + private static async Task ConfirmAsync(HttpClient client, ReorganizeRequest request) + { + if (request.DryRun) request = request with { DryRun = false, Fingerprint = (await DryRunAsync(client, request)).Fingerprint }; + using var response = await client.PostAsJsonAsync(Url, request, ProtocolJson.Default.ReorganizeRequest); + await response.ExpectAsync(HttpStatusCode.Accepted); + return (await response.ReadAsync(ProtocolJson.Default.JobDto)).Id; + } + + /// The sequences told reorganized, until were (or was). + private static async Task> ReorganizedAsync(EventHub.Subscription events, int count, Guid? awaited = null) + { + var told = new List(); + var until = DateTime.UtcNow + Wait; + while (awaited is { } id ? !told.Contains(id) : told.Count < count) + { + using var timeout = new CancellationTokenSource(until - DateTime.UtcNow); + if (await events.Reader.ReadAsync(timeout.Token) is SequenceChangedEvent { Change: "reorganized" } changed) told.Add(changed.SequenceId); + } + return told; + } + + [Test] + public async Task PhotosThatKeepTheirNamesAreToldWhy() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var admin = await server.AdminAsync(); + // Photos copied into the archive by hand and found by a scan stay where they are. + var folder = Path.Combine(server.Options.ArchivePath, "trips"); + Directory.CreateDirectory(folder); + for (var i = 0; i < 2; i++) await File.WriteAllBytesAsync(Path.Combine(folder, $"IMG_{i:0000}.JPG"), Photo(i)); + using (var scan = await admin.PostAsync("/api/v1/archive/scan", null)) await scan.ExpectAsync(HttpStatusCode.Accepted); + await UntilIdleAsync(server); + var id = (await server.Database.Sequences.ListLocationsAsync((await server.Database.Archives.ListAsync()).Single().Id)).Single().Id; + + var request = new ReorganizeRequest([id], false, null, "{n:000}", null, DryRun: true); + admin.DefaultRequestHeaders.AcceptLanguage.ParseAdd("it"); + using var dry = await admin.PostAsJsonAsync(Url, request, ProtocolJson.Default.ReorganizeRequest); + var plan = await dry.ReadAsync(ProtocolJson.Default.ReorganizePlanDto); + Assert.Equal((0, 0, 2), (plan.Sequences, plan.Files, plan.Kept)); + var blocked = plan.Steps.Single().Blocked.Single(); + Assert.Equal(("in_place", 2), (blocked.Reason, blocked.Photos)); + Assert.Equal(Chronos.Core.Localization.Loc.Get("Archive.Reorganize.Blocked.InPlace", System.Globalization.CultureInfo.GetCultureInfo("it")), blocked.Message); + } + + private static async Task UntilJobAsync(HttpClient client, Guid id, string state) + { + var job = await UntilAsync(client, id, j => j.State == state || j.State is "failed" or "cancelled"); + if (job.State != state) Assert.Fail($"job {job.Kind} {job.State}: {job.Error}\n{job.LogTail}"); + } + + /// The job once it ended: done, failed or cancelled. + private static Task FinishedAsync(HttpClient client, Guid id) => UntilAsync(client, id, j => j.State is "done" or "failed" or "cancelled"); + + private static async Task UntilAsync(HttpClient client, Guid id, Func reached) + { + var until = DateTime.UtcNow + Wait; + while (true) + { + using var response = await client.GetAsync($"/api/v1/jobs/{id}"); + var job = await response.ReadAsync(ProtocolJson.Default.JobDto); + if (reached(job)) return job; + Assert.True(DateTime.UtcNow < until, $"job {job.Kind} still {job.State} ({job.ProgressDone}/{job.ProgressTotal})"); + await Task.Delay(50); + } + } + + /// Waits until no job is queued or running (the thumbnails, proxies and analyses uploads queue). + private static async Task UntilIdleAsync(TestServer server) + { + var until = DateTime.UtcNow + Wait; + foreach (var state in new[] { JobState.Queued, JobState.Running, JobState.Queued, JobState.Running }) + { + while ((await server.Database.Jobs.ListAsync(state)).Items.Count > 0) + { + Assert.True(DateTime.UtcNow < until, $"jobs still {state}"); + await Task.Delay(50); + } + } + } + + private static byte[] Photo(int seed) + { + const int width = 96, height = 64; + var pixels = new byte[width * height * 3]; + for (var i = 0; i < pixels.Length; i++) pixels[i] = (byte)((i * 7 + seed * 31) % 251); + return JpegEncoder.Encode(pixels, width, height, 3, new JpegEncodeOptions { Quality = 90 }); + } +} diff --git a/tests/Chronos.Server.Tests/Hosting/AdminReorganizeTests.cs b/tests/Chronos.Server.Tests/Hosting/AdminReorganizeTests.cs new file mode 100644 index 00000000..c3408506 --- /dev/null +++ b/tests/Chronos.Server.Tests/Hosting/AdminReorganizeTests.cs @@ -0,0 +1,226 @@ +using System.Globalization; +using System.Net; +using System.Net.Http.Json; +using System.Text; +using System.Text.Json; +using System.Text.RegularExpressions; +using Chronos.Core.Codecs.Jpeg; +using Chronos.Core.Localization; +using Chronos.Core.Model; +using Chronos.Protocol; +using Chronos.Server.Storage; +using Chronos.Testing; + +namespace Chronos.Server.Tests.Hosting; + +/// +/// Reorganize on the admin panel (owner review 2, R7; Admin/web/reorganize.js): where the panel offers it (the +/// Library's mass bar, the Archive page's save toast), the dialog module and its strings, and the requests the dialog +/// writes, sent through the cookie session as api.js sends them and read back by the names the dialog reads. +/// +[Category("server")] +public sealed partial class AdminReorganizeTests(TestContext context) +{ + private const string Url = "/api/v1/archive/reorganize"; + private static readonly TimeSpan Wait = TimeSpan.FromSeconds(TestTiming.Budget(30)); + + [Test] + public async Task TheLibraryAndTheArchivePageOpenTheReorganizeDialog() + { + await using var server = await TestServer.StartAsync(context); + var library = await server.Client.GetStringAsync("/admin/pages/library.js"); + Assert.Contains(@"from ""../reorganize.js""", library); + Assert.Contains(@"data-mass=""reorganize"" data-i18n=""Admin.Reorganize.Action"" data-i18n-title=""Admin.Reorganize.Action.Tip""", library); + Assert.Contains(@"if (action === ""reorganize"") return reorganize();", library); + // The selection: its ids up to a thousand (one request); beyond, every sequence only while the selection is exactly + // what Select all fetched without a filter, the archive no larger since; a sequence unticked or added is never in it. + Assert.Contains("openReorganize({ api, target: everything ? { all: true } : { sequenceIds: ids }", library); + Assert.Contains("const everything = ids.length > BULK_LIMIT && matching !== null && !isFiltered() && total === matching.length &&", library); + Assert.Contains("ids.length === matching.length && matching.every((s) => selection.has(s.id));", library); + Assert.Contains("if (!everything && ids.length > BULK_LIMIT) {", library); + var archive = await server.Client.GetStringAsync("/admin/pages/archive.js"); + Assert.Contains(@"from ""../reorganize.js""", archive); + Assert.Contains("target: { all: true }", archive); + + using var response = await server.Client.GetAsync("/admin/reorganize.js"); + Assert.Equal(HttpStatusCode.OK, response.StatusCode); + Assert.Equal("text/javascript", response.Content.Headers.ContentType?.MediaType); + var dialog = await response.Content.ReadAsStringAsync(); + Assert.True(Regex.IsMatch(dialog, @"export function openReorganize\(\{ api, target, "), "reorganize.js exports openReorganize({ api, target, … })"); + var imports = StaticImport().Matches(dialog).Select(m => m.Groups[1].Value).ToList(); + Assert.SequenceEqual(["./i18n.js", "./ui.js"], imports); + foreach (var module in imports) + { + using var imported = await server.Client.GetAsync("/admin/" + module[2..]); + Assert.Equal(HttpStatusCode.OK, imported.StatusCode, module); + } + // A dry run at every change; Apply sends that plan's fingerprint back and links the job it queued. + Assert.Contains("api.post(ENDPOINT, { ...body, dryRun: true })", dialog); + Assert.Contains("api.post(ENDPOINT, { ...JSON.parse(chosen.key), dryRun: false, fingerprint: chosen.fingerprint })", dialog); + Assert.Contains("#/jobs?job=", dialog); + Assert.True(!Regex.IsMatch(dialog, @"\son[a-z]+="""), "inline handler"); + // Enter in a template plans at once: a form of three fields and no submit button never submits on Enter. + Assert.Contains(@"form.addEventListener(""keydown"", (e) => {", dialog); + Assert.Contains(@"if (e.key !== ""Enter"" || e.isComposing || !(e.target instanceof HTMLInputElement) || e.target.type === ""checkbox"") return;", dialog); + // An untitled sequence that gets a title reads by its old name before, never by the new title twice. + Assert.Contains("const before = fromTitle ?? names.get(s.sequenceId) ?? folderName(s.fromFolder);", dialog); + Assert.Contains(@"change(before, toTitle ?? before, ""auto"")", dialog); + // A dry run answering during the confirmation: the same plan is applied, a different one is shown and said. + Assert.Contains("if (plan !== chosen && (plan?.key !== chosen.key || plan.fingerprint !== chosen.fingerprint)) {", dialog); + Assert.Contains(@"showError(t(""Admin.Reorganize.PlanChanged""))", dialog); + Assert.True(!dialog.Contains("plan !== chosen) return;", StringComparison.Ordinal), "a confirmed apply is dropped when the same plan is answered again"); + + var en = Assert.NotNull(await server.Client.GetFromJsonAsync("/api/v1/i18n/en", ProtocolJson.Default.DictionaryStringString)); + var it = Assert.NotNull(await server.Client.GetFromJsonAsync("/api/v1/i18n/it", ProtocolJson.Default.DictionaryStringString)); + foreach (var key in Regex.Matches(dialog + library + archive, @"""(Admin\.Reorganize\.[A-Za-z.]+)""").Select(m => m.Groups[1].Value).Distinct()) + { + var name = en.ContainsKey(key) ? key : key + ".other"; + Assert.True(en.ContainsKey(name) && it.ContainsKey(name), key); + } + Assert.Equal("Riorganizza…", it["Admin.Reorganize.Action"]); + // The job renames and moves; nothing in it hashes a file again, so nothing says it verifies them. + Assert.False(en["Admin.Reorganize.Confirm.Tip"].Contains("verif", StringComparison.OrdinalIgnoreCase), en["Admin.Reorganize.Confirm.Tip"]); + Assert.False(it["Admin.Reorganize.Confirm.Tip"].Contains("verific", StringComparison.OrdinalIgnoreCase), it["Admin.Reorganize.Confirm.Tip"]); + Assert.False(Regex.IsMatch(dialog, @"^//.*\bverified\b", RegexOptions.Multiline), "the header says the moves are verified"); + } + + [Test] + public async Task TheDialogsRequestsPlanAndQueueAReorganize() + { + await using var server = await TestServer.StartAsync(context, services: ArchiveModule.Register); + var (editor, _, _) = await server.UserAsync("alberto", "editor"); + Guid id = default; + for (var i = 0; i < 2; i++) id = (await Uploads.UploadAsync(editor, Photo(i), $"IMG_{i + 1:0000}.JPG", sessionKey: "roof")).SequenceId; + await UntilIdleAsync(server); + var browser = await Browser.SignInAsync(server); + + // The body the dialog writes: the selection's ids and the parts switched on, then dryRun. + StringContent Body(string tail) => + Json($$"""{"all":false,"sequenceIds":["{{id}}"],"folderTemplate":"reorganized/{title}","fileTemplate":"{title}_{n:000}","titleTemplate":"Roof",{{tail}}}"""); + string fingerprint; + using (var dry = await browser.SendAsync(HttpMethod.Post, Url, Body("\"dryRun\":true"))) + { + await dry.ExpectAsync(HttpStatusCode.OK); + using var plan = JsonDocument.Parse(await dry.Content.ReadAsStringAsync()); + var root = plan.RootElement; + Assert.Equal((1, 2, 0), (root.GetProperty("sequences").GetInt32(), root.GetProperty("files").GetInt32(), root.GetProperty("kept").GetInt32())); + fingerprint = root.GetProperty("fingerprint").GetString()!; + Assert.Equal(64, fingerprint.Length); + var step = root.GetProperty("steps").EnumerateArray().Single(); + Assert.Equal(id, step.GetProperty("sequenceId").GetGuid()); + Assert.True(step.GetProperty("fromFolder").GetString()!.Length > 0, "fromFolder"); + Assert.Equal("reorganized/Roof", step.GetProperty("toFolder").GetString()); + Assert.Equal("Roof", step.GetProperty("toTitle").GetString()); + Assert.False(step.GetProperty("carried").GetBoolean()); + Assert.Equal(2, step.GetProperty("fileChanges").GetInt32()); + var sample = step.GetProperty("fileSamples").EnumerateArray().First(); + Assert.True(sample.GetProperty("from").GetString()!.StartsWith("originals/", StringComparison.Ordinal), "from"); + Assert.Equal("originals/Roof_001.JPG", sample.GetProperty("to").GetString()); + Assert.Equal(0, step.GetProperty("blocked").GetArrayLength()); + } + + // A template the server refuses names its field, in the page's language: the dialog marks that field. + using (var bad = await browser.SendAsync(HttpMethod.Post, Url, Json("""{"all":true,"fileTemplate":"{nope}","dryRun":true}"""))) + { + var error = await bad.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template"); + Assert.Equal("fileTemplate", error.Details); + Assert.Equal(Loc.Get("Server.Error.InvalidTemplate", CultureInfo.GetCultureInfo("it")), error.Message); + } + // One that breaks a rule says why: the dialog shows the sentence on that field. + using (var lost = await browser.SendAsync(HttpMethod.Post, Url, Json("""{"all":true,"fileTemplate":"{n}{ext}","dryRun":true}"""))) + { + var error = await lost.ExpectErrorAsync(HttpStatusCode.BadRequest, "invalid_template"); + Assert.Equal("fileTemplate:extension", error.Details); + Assert.Equal(Loc.Get("Errors.Template.Extension", CultureInfo.GetCultureInfo("it")), error.Message); + } + // A plan that no longer matches is refused with the one there is now: the dialog plans again. + using (var stale = await browser.SendAsync(HttpMethod.Post, Url, Body($"\"dryRun\":false,\"fingerprint\":\"{new string('0', 64)}\""))) + Assert.Equal(fingerprint, (await stale.ExpectErrorAsync(HttpStatusCode.Conflict, "plan_changed")).Details); + + Guid job; + using (var applied = await browser.SendAsync(HttpMethod.Post, Url, Body($"\"dryRun\":false,\"fingerprint\":\"{fingerprint}\""))) + { + await applied.ExpectAsync(HttpStatusCode.Accepted); + using var queued = JsonDocument.Parse(await applied.Content.ReadAsStringAsync()); + Assert.Equal("move", queued.RootElement.GetProperty("kind").GetString()); + job = queued.RootElement.GetProperty("id").GetGuid(); + } + await UntilJobAsync(browser, job); + var sequence = Assert.NotNull(await server.Database.Sequences.GetAsync(id)); + Assert.Equal(("reorganized/Roof", "Roof"), (sequence.Folder, sequence.Title)); + + // Every sequence (Select all without a filter) with the same templates: nothing is left to change. + using var again = await browser.SendAsync(HttpMethod.Post, Url, + Json("""{"all":true,"folderTemplate":"reorganized/{title}","fileTemplate":"{title}_{n:000}","dryRun":true}""")); + await again.ExpectAsync(HttpStatusCode.OK); + using var none = JsonDocument.Parse(await again.Content.ReadAsStringAsync()); + Assert.Equal(0, none.RootElement.GetProperty("sequences").GetInt32()); + Assert.Equal(0, none.RootElement.GetProperty("steps").GetArrayLength()); + } + + [GeneratedRegex(@"from ""(\.{1,2}/[^""]+)""")] + private static partial Regex StaticImport(); + + private static async Task UntilJobAsync(Browser browser, Guid id) + { + var until = DateTime.UtcNow + Wait; + while (true) + { + using var response = await browser.SendAsync(HttpMethod.Get, $"/api/v1/jobs/{id}"); + var job = await response.ReadAsync(ProtocolJson.Default.JobDto); + if (job.State == "done") return; + if (job.State is "failed" or "cancelled") Assert.Fail($"job {job.Kind} {job.State}: {job.Error}\n{job.LogTail}"); + Assert.True(DateTime.UtcNow < until, $"job {job.Kind} still {job.State}"); + await Task.Delay(50); + } + } + + /// Waits until no job is queued or running (the thumbnails, proxies and analyses uploads queue). + private static async Task UntilIdleAsync(TestServer server) + { + var until = DateTime.UtcNow + Wait; + foreach (var state in new[] { JobState.Queued, JobState.Running, JobState.Queued, JobState.Running }) + { + while ((await server.Database.Jobs.ListAsync(state)).Items.Count > 0) + { + Assert.True(DateTime.UtcNow < until, $"jobs still {state}"); + await Task.Delay(50); + } + } + } + + private static StringContent Json(string json) => new(json, Encoding.UTF8, "application/json"); + + private static byte[] Photo(int seed) + { + const int width = 96, height = 64; + var pixels = new byte[width * height * 3]; + for (var i = 0; i < pixels.Length; i++) pixels[i] = (byte)((i * 7 + seed * 31) % 251); + return JpegEncoder.Encode(pixels, width, height, 3, new JpegEncodeOptions { Quality = 90 }); + } + + /// The bootstrap administrator signed in to the panel (a cookie session over HTTPS), calling as api.js does. + private sealed class Browser(HttpClient client, string csrfToken) + { + public static async Task SignInAsync(TestServer server) + { + await server.AdminAsync(); + var cookies = new CookieContainer(); + var client = server.NewCookieClient(cookies); + using var login = await client.PostAsJsonAsync("/api/v1/auth/login", new LoginRequest("admin", TestServer.Password, "admin-web", Cookie: true), + ProtocolJson.Default.LoginRequest); + await login.ExpectAsync(HttpStatusCode.OK); + return new Browser(client, Assert.NotNull(cookies.GetCookies(Assert.NotNull(server.HttpsBase))["chronos_csrf"]).Value); + } + + /// JSON accepted, the page's language (Italian here), and the CSRF header on every call but a GET. + public async Task SendAsync(HttpMethod method, string url, HttpContent? content = null) + { + using var request = new HttpRequestMessage(method, url) { Content = content }; + request.Headers.Accept.ParseAdd("application/json"); + request.Headers.AcceptLanguage.ParseAdd("it"); + if (method != HttpMethod.Get) request.Headers.Add("X-CSRF-Token", csrfToken); + return await client.SendAsync(request); + } + } +} diff --git a/tests/Chronos.Server.Tests/Hosting/SystemEndpointTests.cs b/tests/Chronos.Server.Tests/Hosting/SystemEndpointTests.cs index f818b65b..23fca807 100644 --- a/tests/Chronos.Server.Tests/Hosting/SystemEndpointTests.cs +++ b/tests/Chronos.Server.Tests/Hosting/SystemEndpointTests.cs @@ -184,8 +184,9 @@ public sealed partial class SystemEndpointTests(TestContext context) var seen = await ModulesAsync(server); Assert.True(seen.Count >= 20, string.Join(", ", seen.Keys)); // The Library's views (owner review 2, R6) are modules of their own under pages/library; the web upload (R3) is the - // dialog, its hash worker and the in-house SHA-256 the worker imports. - foreach (var module in new[] { "pages/library.js", "pages/library/sequence.js", "pages/library/trash.js", "pages/library/shared.js", "upload.js", "hash-worker.js", "sha256.js" }) + // dialog, its hash worker and the in-house SHA-256 the worker imports; Reorganize (R7) is the dialog the Library and + // the Archive page import. + foreach (var module in new[] { "pages/library.js", "pages/library/sequence.js", "pages/library/trash.js", "pages/library/shared.js", "upload.js", "hash-worker.js", "sha256.js", "reorganize.js" }) Assert.True(seen.ContainsKey(module), module); } diff --git a/tests/Chronos.Server.Tests/Jobs/RenderNodeTests.cs b/tests/Chronos.Server.Tests/Jobs/RenderNodeTests.cs index b700bbed..678f37dc 100644 --- a/tests/Chronos.Server.Tests/Jobs/RenderNodeTests.cs +++ b/tests/Chronos.Server.Tests/Jobs/RenderNodeTests.cs @@ -2,9 +2,13 @@ using System.Net; using System.Net.Http.Json; using System.Text.Json; using Microsoft.Extensions.DependencyInjection; +using Chronos.Core.Archiving; +using Chronos.Data; +using Chronos.Data.Archiving; using Chronos.Protocol; using Chronos.Protocol.Client; using Chronos.Server.Jobs; +using Chronos.Server.Storage; using Chronos.Testing; namespace Chronos.Server.Tests.Jobs; @@ -120,6 +124,99 @@ public sealed class RenderNodeTests(TestContext context) Assert.Equal(render.Id, (await renders.ReadAsync(ProtocolJson.Default.ListRenderDto)).Single().Id); } + [Test] + public async Task ARenderThatCannotBeFiledForNowIsCompletedAgain() + { + // The archive engine with a short lease wait: a sequence another writer holds refuses the filing at once. + await using var server = await TestServer.StartAsync(context, o => o.ChunkSizeBytes = 64 * 1024, s => s.AddSingleton(sp => + new ArchiveService(sp.GetRequiredService(), new ArchiveServiceOptions { Owner = ArchiveModule.Owner, LeaseWait = TimeSpan.FromMilliseconds(200) }))); + var (editor, _, _) = await server.UserAsync("alberto", "editor", renderNode: true); + var frame = await Uploads.UploadAsync(editor, Uploads.Photo(5000, 54), "IMG_0001.CR3"); + var job = await JobApiTests.CreateAsync(editor, "render", frame.SequenceId, HevcJob); + var node = await RegisterAsync(editor, "studio-pc", "hevc", 8192); + using (var claim = await editor.PostAsync($"/api/v1/nodes/{node.Id}/claim", null)) await claim.ExpectAsync(HttpStatusCode.OK); + + // A render node's output, and a render a client sends of the same sequence, both fully received. + var output = Uploads.Photo(3000, 55); + var result = new RenderResultRequest("Roof - 4K HEVC.mp4", output.Length, Uploads.Sha(output), "4K HEVC", "hevc", 3840, 2160, 25, 120); + Guid fromNode; + using (var started = await editor.PostAsJsonAsync($"/api/v1/nodes/{node.Id}/jobs/{job.Id}/result", result, ProtocolJson.Default.RenderResultRequest)) + { + await started.ExpectAsync(HttpStatusCode.Created); + fromNode = Assert.NotNull((await started.ReadAsync(ProtocolJson.Default.StartUploadResponse)).UploadId); + } + using (var put = await Uploads.PutChunkAsync(editor, fromNode, 0, output)) await put.ExpectAsync(HttpStatusCode.OK); + var sent = Uploads.Photo(2000, 56); + var offered = new RenderUploadRequest(Guid.CreateVersion7(), "Roof.mp4", sent.Length, Uploads.Sha(sent), "1080p", "h264", 1920, 1080, 30, 10, null); + Guid fromClient; + using (var started = await editor.PostAsJsonAsync($"/api/v1/sequences/{frame.SequenceId}/renders", offered, ProtocolJson.Default.RenderUploadRequest)) + { + await started.ExpectAsync(HttpStatusCode.Created); + fromClient = Assert.NotNull((await started.ReadAsync(ProtocolJson.Default.StartUploadResponse)).UploadId); + } + using (var put = await Uploads.PutChunkAsync(editor, fromClient, 0, sent)) await put.ExpectAsync(HttpStatusCode.OK); + + var completions = new[] { $"/api/v1/nodes/{node.Id}/jobs/{job.Id}/result/complete", $"/api/v1/sequences/{frame.SequenceId}/renders/{fromClient}/complete" }; + var paths = new ArchivePaths(server.Options.ArchivePath); + async Task RefusedAsync(string code) + { + foreach (var complete in completions) + { + using var refused = await editor.PostAsync(complete, null); + await refused.ExpectErrorAsync(HttpStatusCode.ServiceUnavailable, code); + } + // Nothing filed, nothing staged: both uploads receive again with their chunks, and the node keeps its job. + foreach (var upload in new[] { fromNode, fromClient }) + { + Assert.Equal(Chronos.Data.Repositories.UploadState.Receiving, (await server.Database.Uploads.GetAsync(upload))!.State); + Assert.True(server.Services.GetRequiredService().Exists(upload)); + } + Assert.False(Directory.Exists(server.Options.StagingPath) && Directory.EnumerateFiles(server.Options.StagingPath).Any()); + Assert.Equal(0, (await server.Database.Sequences.GetAsync(frame.SequenceId))!.RenderedCount); + var waiting = await JobApiTests.GetAsync(editor, job.Id); + Assert.Equal(("running", node.Id.ToString()), (waiting.State, waiting.NodeId)); + } + + // Another writer holds the sequence past the lease wait (a Reorganize step, a photo deletion). + using (Assert.NotNull(LeaseFile.TryAcquire(paths.LocksDirectory, $"seq-{frame.SequenceId:N}", "tests"))) + await RefusedAsync("sequence_busy"); + // The archive drive is gone. + File.Move(paths.ManifestPath, paths.ManifestPath + ".away"); + try + { + await RefusedAsync("archive_offline"); + } + finally + { + File.Move(paths.ManifestPath + ".away", paths.ManifestPath); + } + // A desktop sharing the archive moved the sequence's folder: this server's index has it at the old place until its + // next scan, and nothing is filed there meanwhile. + var folder = (await server.Database.Sequences.GetAsync(frame.SequenceId))!.Folder; + var left = paths.FromRelative(folder); + Directory.Move(left, paths.FromRelative(folder + " moved")); + await RefusedAsync("folder_moved"); + Assert.False(Directory.Exists(left), "the folder it left is not created again"); + // The next scan finds it where it is now (moved here as a scan moves it: this composition writes no sidecars), and the + // renders are filed there. + await using (var tx = await server.Database.BeginAsync(context.Cancellation)) + { + await tx.Sequences.RelocateAsync(frame.SequenceId, folder + " moved", null, context.Cancellation); + await tx.CommitAsync(context.Cancellation); + } + + foreach (var complete in completions) + { + using var filed = await editor.PostAsync(complete, null); + await filed.ExpectAsync(HttpStatusCode.OK); + } + Assert.Equal("done", (await JobApiTests.GetAsync(editor, job.Id)).State); + var sequence = (await server.Database.Sequences.GetAsync(frame.SequenceId))!; + Assert.Equal(2, sequence.RenderedCount); + await Http.BytesEqualAsync(output, File.ReadAllBytesAsync(Path.Combine(server.Options.ArchivePath, sequence.Folder, "exports", "Roof - 4K HEVC.mp4"))); + await Http.BytesEqualAsync(sent, File.ReadAllBytesAsync(Path.Combine(server.Options.ArchivePath, sequence.Folder, "exports", "Roof.mp4"))); + } + [Test] public async Task NodesReportFailuresAndNeedTheRight() { diff --git a/tests/Chronos.Server.Tests/Uploads.cs b/tests/Chronos.Server.Tests/Uploads.cs index d5e47855..444812ce 100644 --- a/tests/Chronos.Server.Tests/Uploads.cs +++ b/tests/Chronos.Server.Tests/Uploads.cs @@ -19,11 +19,13 @@ internal static class Uploads public static string Sha(byte[] data) => Convert.ToHexStringLower(SHA256.HashData(data)); + /// The capture time the client sends; null: 2026-09-28 18:02:11. public static async Task StartAsync(HttpClient client, byte[] data, string fileName = "IMG_0001.CR3", Guid? sequenceId = null, - string? sessionKey = null, HttpStatusCode expected = HttpStatusCode.Created) + string? sessionKey = null, HttpStatusCode expected = HttpStatusCode.Created, DateTime? capturedAt = null) { using var response = await client.PostAsJsonAsync("/api/v1/uploads", - new StartUploadRequest(sequenceId, fileName, data.Length, Sha(data), new DateTime(2026, 9, 28, 18, 2, 11), sessionKey), ProtocolJson.Default.StartUploadRequest); + new StartUploadRequest(sequenceId, fileName, data.Length, Sha(data), capturedAt ?? new DateTime(2026, 9, 28, 18, 2, 11), sessionKey), + ProtocolJson.Default.StartUploadRequest); await response.ExpectAsync(expected); return await response.ReadAsync(ProtocolJson.Default.StartUploadResponse); } @@ -40,9 +42,9 @@ internal static class Uploads /// Start, every chunk, complete; returns the committed frame. public static async Task UploadAsync(HttpClient client, byte[] data, string fileName = "IMG_0001.CR3", Guid? sequenceId = null, - string? sessionKey = null) + string? sessionKey = null, DateTime? capturedAt = null) { - var start = await StartAsync(client, data, fileName, sequenceId, sessionKey); + var start = await StartAsync(client, data, fileName, sequenceId, sessionKey, capturedAt: capturedAt); var id = Assert.NotNull(start.UploadId); var chunks = (data.Length + start.ChunkSize - 1) / start.ChunkSize; for (var i = 0; i < chunks; i++)