InviteCard.qml

/* Copyright (C) 2026 Dekko Project
 
   This file is part of Dekko email client for Ubuntu devices
 
   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License or (at your option) version 3
 
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
 
   You should have received a copy of the GNU General Public License
   along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
import QtQuick 2.9
import QtQuick.Controls.Suru 2.2
import Lomiri.Components 1.3
import Dekko.Mail 1.0
import Dekko.Mail.API 1.0
import Dekko.Mail.Stores.Accounts 1.0
import Dekko.Lomiri.Constants 1.0
 
Item {
    id: card
 
    property var invite: null
    property int maxHeight: units.gu(40)
    property var pickerRoot: null
 
    readonly property bool active: invite !== null && (invite.valid || invite.loading)
    property bool showDetails: false
    // Set while an answer is being sent, so that a second tap cannot send it twice
    property bool responding: false
 
    function answer(response) {
        if (responding) {
            return
        }
        responding = true
        invite.respond(response)
    }
 
    height: active ? Math.min(content.height, maxHeight) : 0
    visible: active
    clip: true
 
    // The invitation has to know who we are to tell which of the invited people is the user
    function shareIdentities() {
        if (invite) {
            invite.identities = AccountStore.identities
        }
    }
    onInviteChanged: {
        responding = false
        shareIdentities()
    }
    Component.onCompleted: shareIdentities()
 
    Connections {
        target: card.invite
        onResponseQueued: {
            card.responding = false
            ViewActions.orderSimpleToast(ViewKeys.toastMainWindow, qsTr("Your answer will be sent to the organizer."))
        }
        onResponseFailed: {
            card.responding = false
            ViewActions.orderSimpleToast(ViewKeys.toastMainWindow, reason)
        }
    }
 
    function statusText(status) {
        switch (status) {
        case "ACCEPTED":
            return qsTr("Accepted")
        case "TENTATIVE":
            return qsTr("Tentative")
        case "DECLINED":
            return qsTr("Declined")
        case "DELEGATED":
            return qsTr("Delegated")
        default:
            return qsTr("No answer yet")
        }
    }
 
    function headline() {
        if (!invite || !invite.valid) {
            return ""
        }
        if (invite.cancelled) {
            return qsTr("This event has been cancelled")
        }
        if (invite.method === "REPLY") {
            switch (invite.replyStatus) {
            case "ACCEPTED":
                return qsTr("%1 has accepted").arg(invite.replyFrom)
            case "TENTATIVE":
                return qsTr("%1 has tentatively accepted").arg(invite.replyFrom)
            case "DECLINED":
                return qsTr("%1 has declined").arg(invite.replyFrom)
            }
            return qsTr("Answer to an invitation")
        }
        switch (invite.response) {
        case "ACCEPTED":
            return qsTr("You have accepted this invitation")
        case "TENTATIVE":
            return qsTr("You have tentatively accepted this invitation")
        case "DECLINED":
            return qsTr("You have declined this invitation")
        }
        if (invite.method === "REQUEST") {
            return qsTr("Invitation from %1").arg(invite.organizerName)
        }
        return qsTr("Event")
    }
 
    Rectangle {
        anchors.fill: parent
        color: Suru.secondaryBackgroundColor
    }
 
    Flickable {
        anchors.fill: parent
        contentWidth: width
        contentHeight: content.height
        interactive: content.height > card.height
        boundsBehavior: Flickable.StopAtBounds
 
        Column {
            id: content
            x: Style.defaultSpacing
            width: card.width - (2 * Style.defaultSpacing)
            spacing: Style.smallSpacing
            topPadding: Style.smallSpacing
            bottomPadding: Style.smallSpacing
 
            Row {
                width: parent.width
                spacing: Style.smallSpacing
                visible: card.invite !== null && card.invite.loading
 
                ActivityIndicator {
                    running: parent.visible
                    height: units.gu(3)
                    width: height
                }
                Label {
                    anchors.verticalCenter: parent.verticalCenter
                    text: qsTr("Loading invitation…")
                }
            }
 
            Item {
                width: parent.width
                height: Math.max(calendarIcon.height, titles.height)
                visible: card.invite !== null && card.invite.valid
 
                Icon {
                    id: calendarIcon
                    name: "calendar"
                    height: Style.largeIconSize
                    width: height
                    color: Suru.foregroundColor
                    anchors {
                        left: parent.left
                        top: parent.top
                    }
                }
 
                Column {
                    id: titles
                    anchors {
                        left: calendarIcon.right
                        leftMargin: Style.smallSpacing
                        right: detailsToggle.left
                        rightMargin: Style.smallSpacing
                        top: parent.top
                    }
 
                    Label {
                        objectName: "inviteHeadline"
                        width: parent.width
                        text: card.headline()
                        fontSize: "small"
                        color: card.invite && card.invite.cancelled ? Suru.highlightColor : Suru.secondaryForegroundColor
                        Suru.highlightType: Suru.NegativeHighlight
                        wrapMode: Text.WordWrap
                    }
                    Label {
                        objectName: "inviteSummary"
                        width: parent.width
                        text: card.invite ? card.invite.summary : ""
                        visible: text !== ""
                        font.weight: Font.DemiBold
                        font.strikeout: card.invite ? card.invite.cancelled : false
                        wrapMode: Text.WordWrap
                        maximumLineCount: 3
                        elide: Text.ElideRight
                    }
                    Label {
                        objectName: "inviteWhen"
                        width: parent.width
                        text: {
                            if (!card.invite) {
                                return ""
                            }
                            var t = card.invite.when
                            if (card.invite.allDay) {
                                t += " " + qsTr("(all day)")
                            }
                            if (card.invite.recurring) {
                                t += " " + qsTr("(repeats)")
                            }
                            return t
                        }
                        wrapMode: Text.WordWrap
                    }
                    Label {
                        objectName: "inviteLocation"
                        width: parent.width
                        text: card.invite ? card.invite.location : ""
                        visible: text !== ""
                        color: Suru.secondaryForegroundColor
                        wrapMode: Text.WordWrap
                        maximumLineCount: 2
                        elide: Text.ElideRight
                    }
                    Label {
                        width: parent.width
                        visible: card.invite !== null && card.invite.valid && !card.invite.timeZoneKnown
                        text: card.invite
                              ? qsTr("The time zone \"%1\" is not known, the time shown may be wrong.").arg(card.invite.timeZoneId)
                              : ""
                        fontSize: "small"
                        color: Suru.highlightColor
                        Suru.highlightType: Suru.NegativeHighlight
                        wrapMode: Text.WordWrap
                    }
                }
 
                AbstractButton {
                    id: detailsToggle
                    objectName: "inviteDetailsToggle"
                    width: units.gu(4)
                    height: units.gu(4)
                    anchors {
                        right: parent.right
                        top: parent.top
                    }
                    onClicked: card.showDetails = !card.showDetails
 
                    Icon {
                        anchors.centerIn: parent
                        name: card.showDetails ? "up" : "down"
                        height: Style.defaultIconSize
                        width: height
                        color: Suru.foregroundColor
                    }
                }
            }
 
            Column {
                id: details
                width: parent.width
                spacing: units.gu(0.5)
                visible: card.showDetails && card.invite !== null && card.invite.valid
 
                Label {
                    width: parent.width
                    visible: card.invite !== null && card.invite.organizerEmail !== ""
                    text: card.invite ? qsTr("Organizer: %1").arg(
                                            card.invite.organizerName === card.invite.organizerEmail
                                            ? card.invite.organizerEmail
                                            : card.invite.organizerName + " <" + card.invite.organizerEmail + ">")
                                      : ""
                    wrapMode: Text.WrapAtWordBoundaryOrAnywhere
                }
 
                Label {
                    width: parent.width
                    visible: attendeeList.count > 0
                    text: qsTr("Invited:")
                    color: Suru.secondaryForegroundColor
                }
 
                Repeater {
                    id: attendeeList
                    model: card.showDetails && card.invite ? card.invite.attendees : []
                    delegate: Item {
                        width: details.width
                        height: Math.max(attendeeName.height, attendeeStatus.height)
 
                        Label {
                            id: attendeeName
                            anchors {
                                left: parent.left
                                leftMargin: Style.smallSpacing
                                right: attendeeStatus.left
                                rightMargin: Style.smallSpacing
                            }
                            text: modelData.isSelf ? qsTr("%1 (you)").arg(modelData.name) : modelData.name
                            elide: Text.ElideRight
                        }
                        Label {
                            id: attendeeStatus
                            anchors.right: parent.right
                            text: modelData.isOrganizer ? qsTr("Organizer") : card.statusText(modelData.status)
                            fontSize: "small"
                            color: Suru.secondaryForegroundColor
                        }
                    }
                }
 
                Label {
                    width: parent.width
                    visible: text !== ""
                    text: card.invite ? card.invite.description : ""
                    textFormat: Text.PlainText
                    wrapMode: Text.WrapAtWordBoundaryOrAnywhere
                    maximumLineCount: 12
                    elide: Text.ElideRight
                }
            }
 
            Flow {
                width: parent.width
                spacing: Style.smallSpacing
                visible: card.invite !== null && card.invite.valid
 
                Button {
                    objectName: "inviteAccept"
                    visible: card.invite !== null && card.invite.canRespond
                    text: qsTr("Accept")
                    color: card.invite && card.invite.response === "ACCEPTED" ? theme.palette.normal.positive
                                                                               : theme.palette.normal.foreground
                    enabled: !card.responding
                    onClicked: card.answer(CalendarInvite.Accepted)
                }
                Button {
                    objectName: "inviteTentative"
                    visible: card.invite !== null && card.invite.canRespond
                    text: qsTr("Maybe")
                    color: card.invite && card.invite.response === "TENTATIVE" ? theme.palette.normal.activity
                                                                                : theme.palette.normal.foreground
                    enabled: !card.responding
                    onClicked: card.answer(CalendarInvite.Tentative)
                }
                Button {
                    objectName: "inviteDecline"
                    visible: card.invite !== null && card.invite.canRespond
                    text: qsTr("Decline")
                    color: card.invite && card.invite.response === "DECLINED" ? theme.palette.normal.negative
                                                                               : theme.palette.normal.foreground
                    enabled: !card.responding
                    onClicked: card.answer(CalendarInvite.Declined)
                }
                Button {
                    objectName: "inviteExport"
                    visible: card.invite !== null && !card.invite.cancelled && card.invite.method !== "REPLY"
                    text: qsTr("Add to calendar")
                    color: theme.palette.normal.foreground
                    onClicked: {
                        const file = card.invite.saveToFile()
                        if (file === "") {
                            ViewActions.orderSimpleToast(ViewKeys.toastMainWindow, qsTr("The invitation could not be saved."))
                            return
                        }
                        const url = "file://" + file
                        if (isRunningOnMir) {
                            ContentActions.exportFile(card.pickerRoot, url)
                        } else {
                            Qt.openUrlExternally(url)
                        }
                    }
                }
            }
        }
    }
 
    Rectangle {
        anchors {
            left: parent.left
            right: parent.right
            bottom: parent.bottom
        }
        height: Style.lineSize
        color: Style.lineColor
    }
}