nextcloudfileproviderkit/Sources/NextcloudFileProviderKit/Item/Item+Unuploaded.swift at 961aa78fcf810b7b152d83414d68e07a883fc57a · nextcloud/nextcloudfileproviderkit · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
//
//  Item+CreateUnuploaded.swift
//  NextcloudFileProviderKit
//
//  Created by Claudio Cambra on 25/4/25.
//

import FileProvider

extension Item {
    // Creates a file that was previously unuploaded (e.g. a previously ignored/lock file) on server
    func createUnuploaded(
        itemTarget: NSFileProviderItem,
        baseVersion: NSFileProviderItemVersion = NSFileProviderItemVersion(),
        changedFields: NSFileProviderItemFields,
        contents newContents: URL?,
        options: NSFileProviderModifyItemOptions = [],
        request: NSFileProviderRequest = NSFileProviderRequest(),
        ignoredFiles: IgnoredFilesMatcher? = nil,
        domain: NSFileProviderDomain? = nil,
        forcedChunkSize: Int? = nil,
        progress: Progress = .init(),
        dbManager: FilesDatabaseManager
    ) async -> (Item?, Error?) {
        guard newContents != nil || domain != nil else {
            Self.logger.error(
                """
                Unable to upload modified item that was previously unuploaded.
                    filename: \(self.filename, privacy: .public)
                    either the domain is nil, the provided contents are nil, or both.
                """
            )
            return (nil, NSFileProviderError(.cannotSynchronize))
        }
        let modifiedItem = self
        var contentsLocation = newContents
        if contentsLocation == nil {
            // TODO: Find a way to test me
            assert(domain != nil)
            guard let domain, let localUrl = await localUrlForContents(domain: domain) else {
                Self.logger.error(
                    """
                    Unable to upload modified item that was previously unuploaded.
                        filename: \(modifiedItem.filename, privacy: .public)
                        local url for contents could not be acquired.
                    """
                )
                return (nil, NSFileProviderError(.cannotSynchronize))
            }
            contentsLocation = localUrl
        }
        return await Self.create(
            basedOn: itemTarget,
            contents: contentsLocation,
            domain: domain,
            account: account,
            remoteInterface: remoteInterface,
            ignoredFiles: ignoredFiles,
            forcedChunkSize: forcedChunkSize,
            progress: progress,
            dbManager: dbManager
        )
    }

    // Just modifies metadata
    func modifyUnuploaded(
        itemTarget: NSFileProviderItem,
        baseVersion: NSFileProviderItemVersion = NSFileProviderItemVersion(),
        changedFields: NSFileProviderItemFields,
        contents newContents: URL?,
        options: NSFileProviderModifyItemOptions = [],
        request: NSFileProviderRequest = NSFileProviderRequest(),
        ignoredFiles: IgnoredFilesMatcher? = nil,
        domain: NSFileProviderDomain? = nil,
        forcedChunkSize: Int? = nil,
        progress: Progress = .init(),
        dbManager: FilesDatabaseManager
    ) async -> Item? {
        var modifiedParentItemIdentifier = parentItemIdentifier
        var modifiedMetadata = metadata

        if changedFields.contains(.filename) {
            modifiedMetadata.fileName = itemTarget.filename
            if !isLockFileName(modifiedMetadata.fileName) {
                modifiedMetadata.classFile = ""
                // Do the actual upload at the end, not yet
            }
        }
        if changedFields.contains(.contents),
           let newSize = try? newContents?.resourceValues(forKeys: [.fileSizeKey]).fileSize
        {
            modifiedMetadata.size = Int64(newSize)
        }
        if changedFields.contains(.parentItemIdentifier) {
            guard let parentMetadata = dbManager.itemMetadata(
                ocId: itemTarget.parentItemIdentifier.rawValue
            ) else {
                Self.logger.error(
                    """
                    Unable to find new parent item identifier during unuploaded item modification.
                        Filename: \(self.filename, privacy: .public)
                    """
                )
                return nil
            }
            modifiedMetadata.serverUrl = parentMetadata.serverUrl + "/" + parentMetadata.fileName
            modifiedParentItemIdentifier = .init(parentMetadata.ocId)
        }
        if changedFields.contains(.creationDate),
           let newCreationDate = itemTarget.creationDate,
           let newCreationDate
        {
            modifiedMetadata.creationDate = newCreationDate
        }
        if changedFields.contains(.contentModificationDate),
           let newModificationDate = itemTarget.contentModificationDate,
           let newModificationDate
        {
            modifiedMetadata.date = newModificationDate
        }

        return Item(
            metadata: modifiedMetadata,
            parentItemIdentifier: modifiedParentItemIdentifier,
            account: account,
            remoteInterface: remoteInterface,
            dbManager: dbManager,
            remoteSupportsTrash: await remoteInterface.supportsTrash(account: account)
        )
    }
}