Working with files / attachments

amplify add api

? Select from one of the below mentioned services: `GraphQL`
? Choose the default authorization type for the API `Amazon Cognito User Pool`
 Do you want to use the default authentication and security configuration? `Default configuration`
 How do you want users to be able to sign in? `Username`
 Do you want to configure advanced settings? `No, I am done.`
? Here is the GraphQL API that we will create. Select a setting to edit or continue `Continue`
? Choose a schema template: `Blank Schema`

type Song @model @auth(rules: [{ allow: public }]) {
  id: ID!
  name: String!
  coverArtKey: String # Set as optional to allow adding file after initial create
}

amplify add storage

? Select from one of the below mentioned services: `Content (Images, audio, video, etc.)`
✔ Who should have access: `Auth users only`
✔ What kind of access do you want for Authenticated users? `create/update, read, delete`
✔ Do you want to add a Lambda Trigger for your S3 Bucket? (y/N) · `no`

let song = Song(name: name)

guard let imageData = artCover.pngData() else {
    print("Could not get data from UIImage.")
    return
}

// Create the song record
let result = try await Amplify.API.mutate(request: .create(song))
guard case .success(var createdSong) = result else {
    print("Failed with error: ", result)
    return
}

// Upload the art cover image
_ = try await Amplify.Storage.uploadData(key: createdSong.id,
                                         data: imageData,
                                         options: .init(accessLevel: .private)).value

// Update the song record with the image key
createdSong.coverArtKey = createdSong.id
let updateResult = try await Amplify.API.mutate(request: .update(createdSong))
guard case .success(let updatedSong) = updateResult else {
    print("Failed with error: ", updateResult)
    return
}

// Upload the new art image
_ = try await Amplify.Storage.uploadData(key: currentSong.id,
                                         data: imageData,
                                         options: .init(accessLevel: .private)).value

// Update the song record
currentSong.coverArtKey = currentSong.id
let result = try await Amplify.API.mutate(request: .update(currentSong))
guard case .success(let updatedSong) = result else {
    print("Failed with error: ", result)
    return
}

// Get the song record
let result = try await Amplify.API.query(request: .get(Song.self, byIdentifier: currentSong.id))
guard case .success(let queriedSong) = result else {
    print("Failed with error: ", result)
    return
}
guard let song = queriedSong else {
    print("Song may have been deleted, no song with id: ", currentSong.id)
    return
}

guard let coverArtKey = song.coverArtKey else {
    print("Song does not contain cover art")
    return
}

// Download the art cover
let imageData = try await Amplify.Storage.downloadData(key: coverArtKey,
                                                       options: .init(accessLevel: .private)).value
let image = UIImage(data: imageData)

// Get the song record
let result = try await Amplify.API.mutate(request: .get(Song.self, byIdentifier: currentSong.id))
guard case .success(let queriedSong) = result else {
    print("Failed with error: ", result)
    return
}
guard var song = queriedSong else {
    print("Song may have been deleted, no song by id: ", currentSong.id)
    return
}
guard song.coverArtKey != nil else {
    print("There is no cover art key to remove image association")
    return
}

// Set the association to nil and update it
song.coverArtKey = nil
let updateResult = try await Amplify.API.mutate(request: .update(song))
guard case .success(let updatedSong) = updateResult else {
    print("Failed with error: ", result)
    return
}

// Get the song record
let result = try await Amplify.API.query(request: .get(Song.self, byIdentifier: currentSong.id))
guard case .success(let queriedSong) = result else {
    print("Failed with error: ", result)
    return
}
guard var song = queriedSong else {
    print("Song may have been deleted, no song by id: ", currentSong.id)
    return
}
guard let coverArtKey = song.coverArtKey else {
    print("There is no cover art key to remove image association")
    return
}

// Set the association to nil and update it
song.coverArtKey = nil
let updateResult = try await Amplify.API.mutate(request: .update(song))
guard case .success(let updatedSong) = updateResult else {
    print("Failed with error: ", result)
    return
}

// Remove the image
try await Amplify.Storage.remove(key: coverArtKey,
                                 options: .init(accessLevel: .private))

// Get the song record
let result = try await Amplify.API.mutate(request: .get(Song.self, byIdentifier: currentSong.id))
guard case .success(let queriedSong) = result else {
    print("Failed with error: ", result)
    return
}
guard let song = queriedSong else {
    print("Song may have been deleted, no song by id: ", currentSong.id)
    return
}

if let coverArt = song.coverArtKey {
    // Remove the image
    try await Amplify.Storage.remove(key: coverArt,
                                     options: .init(accessLevel: .private))
}

// Delete the song record
let deleteResult = try await Amplify.API.mutate(request: .delete(song))
guard case .success = deleteResult else {
    print("Failed with error: ", deleteResult)
    return
}

type PhotoAlbum @model @auth(rules: [{ allow: public }]) {
  id: ID!
  name: String!
  imageKeys: [String] #Set as optional to allow adding file(s) after initial create
}

// Create the photo album record
let album = PhotoAlbum(name: name)
let result = try await Amplify.API.mutate(request: .create(album))
guard case .success(var createdAlbum) = result else {
    print("Failed with error: ", result)
    return
}

// Upload the photo album images
let imageKeys = await withTaskGroup(of: String?.self) { group in
    for imageData in imagesData {
        group.addTask {
            let key = "\(album.id)-\(UUID().uuidString)"
            do {
                _ = try await Amplify.Storage.uploadData(key: key,
                                                         data: imageData,
                                                         options: .init(accessLevel: .private)).value
                return key
            } catch {
                print("Failed with error:", error)
                return nil
            }
        }
    }

    var imageKeys: [String?] = []
    for await imageKey in group {
        imageKeys.append(imageKey)
    }
    return imageKeys.compactMap { $0 }
}

// Update the album with the image keys
createdAlbum.imageKeys = imageKeys
let updateResult = try await Amplify.API.mutate(request: .update(createdAlbum))
guard case .success(let updatedAlbum) = updateResult else {
    print("Failed with error: ", updateResult)
    return
}

// Create the photo album record
let album = PhotoAlbum(name: name)
let result = try await Amplify.API.mutate(request: .create(album))
guard case .success(var createdAlbum) = result else {
    print("Failed with error: ", result)
    return
}

// Upload the photo album image
let key = "\(album.id)-\(UUID().uuidString)"
_ = try await Amplify.Storage.uploadData(key: key,
                                         data: imageData,
                                         options: .init(accessLevel: .private)).value

// Update the album with the image key
createdAlbum.imageKeys = [key]
let updateResult = try await Amplify.API.mutate(request: .update(createdAlbum))
guard case .success(let updatedAlbum) = updateResult else {
    print("Failed with error: ", updateResult)
    return
}

// Upload the new photo album image
let key = "\(currentAlbum.id)-\(UUID().uuidString)"
_ = try await Amplify.Storage.uploadData(key: key,
                                          data: imageData,
                                          options: .init(accessLevel: .private)).value

// Get the latest album
let result = try await Amplify.API.query(request: .get(PhotoAlbum.self, byIdentifier: currentAlbum.id))
guard case .success(let queriedAlbum) = result else {
    print("Failed with error: ", result)
    return
}
guard var album = queriedAlbum else {
    print("Album may have been deleted, no album with id: ", currentAlbum.id)
    return
}

guard var imageKeys = album.imageKeys else {
    print("Album does not contain images")
    return
}

// Add new to the existing keys
imageKeys.append(key)

// Update the album with the image keys
album.imageKeys = imageKeys
let updateResult = try await Amplify.API.mutate(request: .update(album))
guard case .success(let updatedAlbum) = updateResult else {
    print("Failed with error: ", updateResult)
    return
}

// Upload the new photo album image
let key = "\(currentAlbum.id)-\(UUID().uuidString)"
_ = try await Amplify.Storage.uploadData(key: key,
                                         data: imageData,
                                         options: .init(accessLevel: .private)).value

// Update the album with the image keys
var album = currentAlbum
if var imageKeys = album.imageKeys {
    imageKeys.removeLast()
    imageKeys.append(key)
    album.imageKeys = imageKeys
} else {
    album.imageKeys = [key]
}
let updateResult = try await Amplify.API.mutate(request: .update(album))
guard case .success(let updatedAlbum) = updateResult else {
    print("Failed with error: ", updateResult)
    return
}

// Get the song record
let result = try await Amplify.API.query(request: .get(PhotoAlbum.self, byIdentifier: currentAlbum.id))
guard case .success(let queriedAlbum) = result else {
    print("Failed with error: ", result)
    return
}
guard let album = queriedAlbum else {
    print("Album may have been deleted, no album with id: ", currentAlbum.id)
    return
}

guard let imageKeysOptional = album.imageKeys else {
    print("Album does not contain images")
    return
}
let imageKeys = imageKeysOptional.compactMap { $0 }

// Download the photos
let images = await withTaskGroup(of: UIImage?.self) { group in
    for key in imageKeys {
        group.addTask {
            do {
                let imageData = try await Amplify.Storage.downloadData(key: key,
                                                                       options: .init(accessLevel: .private)).value
                return UIImage(data: imageData)
            } catch {
                print("Failed with error:", error)
                return nil
            }
        }
    }

    var images: [UIImage?] = []
    for await image in group {
        images.append(image)
    }
    return images.compactMap { $0 }
}

// Get the album record
let result = try await Amplify.API.mutate(request: .get(PhotoAlbum.self, byIdentifier: currentAlbum.id))
guard case .success(let queriedAlbum) = result else {
    print("Failed with error: ", result)
    return
}
guard var album = queriedAlbum else {
    print("Song may have been deleted, no song by id: ", currentAlbum.id)
    return
}
guard let imageKeys = album.imageKeys, !imageKeys.isEmpty else {
    print("There are no images to remove association")
    return
}

// Set the association to nil and update it
album.imageKeys = nil
let updateResult = try await Amplify.API.mutate(request: .update(album))
guard case .success(let updatedAlbum) = updateResult else {
    print("Failed with error: ", result)
    return
}

// Get the album record
let result = try await Amplify.API.query(request: .get(PhotoAlbum.self, byIdentifier: currentAlbum.id))
guard case .success(let queriedAlbum) = result else {
    print("Failed with error: ", result)
    return
}
guard let album = queriedAlbum else {
    print("Album may have been deleted, no album with id: ", currentAlbum.id)
    return
}

guard let imageKeysOptional = album.imageKeys else {
    print("Album does not contain images")
    return
}
let imageKeys = imageKeysOptional.compactMap { $0 }

// Set the associations to nil and update it
album.imageKeys = nil
let updateResult = try await Amplify.API.mutate(request: .update(album))
guard case .success(let updatedAlbum) = updateResult else {
    print("Failed with error: ", result)
    return
}

// Remove the photos
await withTaskGroup(of: Void.self) { group in
    for key in imageKeys {
        group.addTask {
            do {
                try await Amplify.Storage.remove(key: key,
                                                  options: .init(accessLevel: .private))
            } catch {
                print("Failed with error:", error)
            }
        }
    }


    for await _ in group {
    }
}

// Get the album record
let result = try await Amplify.API.query(request: .get(PhotoAlbum.self, byIdentifier: currentAlbum.id))
guard case .success(let queriedAlbum) = result else {
    print("Failed with error: ", result)
    return
}
guard let album = queriedAlbum else {
    print("Album may have been deleted, no album with id: ", currentAlbum.id)
    return
}

guard let imageKeysOptional = album.imageKeys else {
    print("Album does not contain images")

    // Delete the album record
    let deleteResult = try await Amplify.API.mutate(request: .delete(album))
    guard case .success = deleteResult else {
        print("Failed with error: ", deleteResult)
        return
    }
    return
}
let imageKeys = imageKeysOptional.compactMap { $0 }

// Remove the photos
await withTaskGroup(of: Void.self) { group in
    for key in imageKeys {
        group.addTask {
            do {
                try await Amplify.Storage.remove(key: key,
                                                 options: .init(accessLevel: .private))
            } catch {
                print("Failed with error:", error)
            }
        }
    }


    for await _ in group {
    }

}

// Delete the album record
let deleteResult = try await Amplify.API.mutate(request: .delete(album))
guard case .success = deleteResult else {
    print("Failed with error: ", deleteResult)
    return
}