Add Teaching class creation with level input and activation fallback.

Made-with: Cursor

classroom_app/Auth/GoogleOAuthService.swift

@@ -48,9 +48,11 @@ final class GoogleOAuthService: NSObject {
         "profile",
         // Classroom To-do (assignments/quizzes)
         "https://www.googleapis.com/auth/classroom.courses.readonly",
+        "https://www.googleapis.com/auth/classroom.courses",
         "https://www.googleapis.com/auth/classroom.coursework.me.readonly",
         "https://www.googleapis.com/auth/classroom.announcements.readonly",
-        "https://www.googleapis.com/auth/classroom.rosters.readonly"
+        "https://www.googleapis.com/auth/classroom.rosters.readonly",
+        "https://www.googleapis.com/auth/classroom.rosters"
     ]
 
     private let tokenStore = KeychainTokenStore()

classroom_app/Google/GoogleClassroomClient.swift

@@ -8,6 +8,14 @@ enum GoogleClassroomClientError: Error {
 
 /// Minimal Google Classroom REST wrapper for a student's to-do list.
 final class GoogleClassroomClient {
+    struct CreateCourseRequest: Sendable {
+        var name: String
+        var section: String?
+        var room: String?
+        var descriptionHeading: String?
+        var description: String?
+    }
+
     struct Options: Sendable {
         var maxCourses: Int
         var maxCourseWorkPerCourse: Int
@@ -205,6 +213,94 @@ final class GoogleClassroomClient {
         )
     }
 
+    func createCourse(accessToken: String, request: CreateCourseRequest) async throws -> ClassroomCourse {
+        let trimmedName = request.name.trimmingCharacters(in: .whitespacesAndNewlines)
+        guard trimmedName.isEmpty == false else {
+            throw GoogleClassroomClientError.decodeFailed("Course name is required.")
+        }
+
+        var payload = CreateCoursePayload(
+            name: trimmedName,
+            ownerId: "me",
+            courseState: "PROVISIONED",
+            section: request.section?.nonEmptyTrimmed,
+            room: request.room?.nonEmptyTrimmed,
+            descriptionHeading: request.descriptionHeading?.nonEmptyTrimmed,
+            description: request.description?.nonEmptyTrimmed
+        )
+        if payload.descriptionHeading == nil, let section = payload.section {
+            payload.descriptionHeading = section
+        }
+
+        var requestURL = URLRequest(url: URL(string: "https://classroom.googleapis.com/v1/courses")!)
+        requestURL.httpMethod = "POST"
+        requestURL.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+        requestURL.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        requestURL.httpBody = try JSONEncoder().encode(payload)
+
+        let (data, response) = try await session.data(for: requestURL)
+        guard let http = response as? HTTPURLResponse else { throw GoogleClassroomClientError.invalidResponse }
+        guard (200..<300).contains(http.statusCode) else {
+            let body = String(data: data, encoding: .utf8) ?? "<no body>"
+            throw GoogleClassroomClientError.httpStatus(http.statusCode, body)
+        }
+
+        let created: Course
+        do {
+            created = try JSONDecoder().decode(Course.self, from: data)
+        } catch {
+            let raw = String(data: data, encoding: .utf8) ?? "<unreadable body>"
+            throw GoogleClassroomClientError.decodeFailed(raw)
+        }
+
+        let acceptedOrCreated: Course
+        do {
+            acceptedOrCreated = try await acceptOwnTeachingInvitationIfPresent(accessToken: accessToken, courseId: created.id)
+        } catch let err as GoogleClassroomClientError where err.isInsufficientScope {
+            throw err
+        } catch {
+            acceptedOrCreated = created
+        }
+
+        let finalizedCourse: Course
+        if (acceptedOrCreated.courseState ?? "PROVISIONED").uppercased() == "ACTIVE" {
+            finalizedCourse = acceptedOrCreated
+        } else {
+            do {
+                finalizedCourse = try await updateCourseState(
+                    accessToken: accessToken,
+                    courseId: acceptedOrCreated.id,
+                    courseState: "ACTIVE"
+                )
+            } catch let err as GoogleClassroomClientError where err.isInsufficientScope {
+                throw err
+            } catch {
+                finalizedCourse = acceptedOrCreated
+            }
+        }
+
+        let settledCourse = (try? await waitForCourseToSettle(accessToken: accessToken, courseId: finalizedCourse.id)) ?? finalizedCourse
+
+        let teachers = (try? await listCourseTeachers(accessToken: accessToken, courseId: settledCourse.id)) ?? []
+        let teacherNames = teachers.compactMap { teacher -> String? in
+            let profileName = teacher.profile?.name?.fullName?.trimmingCharacters(in: .whitespacesAndNewlines)
+            if let profileName, profileName.isEmpty == false { return profileName }
+            let email = teacher.profile?.emailAddress?.trimmingCharacters(in: .whitespacesAndNewlines)
+            if let email, email.isEmpty == false { return email }
+            return nil
+        }
+
+        return ClassroomCourse(
+            id: settledCourse.id,
+            name: (settledCourse.name?.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty == false) ? (settledCourse.name ?? "Course") : "Course",
+            section: settledCourse.section,
+            room: settledCourse.room,
+            teacherNames: teacherNames,
+            enrollmentCode: settledCourse.enrollmentCode,
+            courseState: settledCourse.courseState ?? "PROVISIONED"
+        )
+    }
+
     // MARK: - Courses
 
     private func listActiveCourses(accessToken: String, pageSize: Int) async throws -> [Course] {
@@ -292,6 +388,120 @@ final class GoogleClassroomClient {
         return decoded.teachers ?? []
     }
 
+    private func updateCourseState(accessToken: String, courseId: String, courseState: String) async throws -> Course {
+        var components = URLComponents(string: "https://classroom.googleapis.com/v1/courses/\(courseId)")!
+        components.queryItems = [
+            URLQueryItem(name: "updateMask", value: "courseState")
+        ]
+
+        var request = URLRequest(url: components.url!)
+        request.httpMethod = "PATCH"
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = try JSONEncoder().encode(UpdateCourseStatePayload(courseState: courseState))
+
+        let (data, response) = try await session.data(for: request)
+        guard let http = response as? HTTPURLResponse else { throw GoogleClassroomClientError.invalidResponse }
+        guard (200..<300).contains(http.statusCode) else {
+            let body = String(data: data, encoding: .utf8) ?? "<no body>"
+            throw GoogleClassroomClientError.httpStatus(http.statusCode, body)
+        }
+
+        do {
+            return try JSONDecoder().decode(Course.self, from: data)
+        } catch {
+            let raw = String(data: data, encoding: .utf8) ?? "<unreadable body>"
+            throw GoogleClassroomClientError.decodeFailed(raw)
+        }
+    }
+
+    private func acceptOwnTeachingInvitationIfPresent(accessToken: String, courseId: String) async throws -> Course {
+        for attempt in 0..<3 {
+            if let invitation = try await listOwnTeacherInvitations(accessToken: accessToken, courseId: courseId).first {
+                try await acceptInvitation(accessToken: accessToken, invitationId: invitation.id)
+                return try await fetchCourse(accessToken: accessToken, courseId: courseId)
+            }
+            if attempt < 2 {
+                try await Task.sleep(nanoseconds: 400_000_000)
+            }
+        }
+        return try await fetchCourse(accessToken: accessToken, courseId: courseId)
+    }
+
+    private func listOwnTeacherInvitations(accessToken: String, courseId: String) async throws -> [Invitation] {
+        var components = URLComponents(string: "https://classroom.googleapis.com/v1/invitations")!
+        components.queryItems = [
+            URLQueryItem(name: "userId", value: "me"),
+            URLQueryItem(name: "courseId", value: courseId)
+        ]
+
+        var request = URLRequest(url: components.url!)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+
+        let (data, response) = try await session.data(for: request)
+        guard let http = response as? HTTPURLResponse else { throw GoogleClassroomClientError.invalidResponse }
+        guard (200..<300).contains(http.statusCode) else {
+            let body = String(data: data, encoding: .utf8) ?? "<no body>"
+            throw GoogleClassroomClientError.httpStatus(http.statusCode, body)
+        }
+
+        let decoded: InvitationsList
+        do {
+            decoded = try JSONDecoder().decode(InvitationsList.self, from: data)
+        } catch {
+            let raw = String(data: data, encoding: .utf8) ?? "<unreadable body>"
+            throw GoogleClassroomClientError.decodeFailed(raw)
+        }
+
+        return (decoded.invitations ?? []).filter { ($0.role ?? "").uppercased() == "TEACHER" }
+    }
+
+    private func acceptInvitation(accessToken: String, invitationId: String) async throws {
+        var request = URLRequest(url: URL(string: "https://classroom.googleapis.com/v1/invitations/\(invitationId):accept")!)
+        request.httpMethod = "POST"
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+
+        let (data, response) = try await session.data(for: request)
+        guard let http = response as? HTTPURLResponse else { throw GoogleClassroomClientError.invalidResponse }
+        guard (200..<300).contains(http.statusCode) else {
+            let body = String(data: data, encoding: .utf8) ?? "<no body>"
+            throw GoogleClassroomClientError.httpStatus(http.statusCode, body)
+        }
+    }
+
+    private func fetchCourse(accessToken: String, courseId: String) async throws -> Course {
+        var request = URLRequest(url: URL(string: "https://classroom.googleapis.com/v1/courses/\(courseId)")!)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
+
+        let (data, response) = try await session.data(for: request)
+        guard let http = response as? HTTPURLResponse else { throw GoogleClassroomClientError.invalidResponse }
+        guard (200..<300).contains(http.statusCode) else {
+            let body = String(data: data, encoding: .utf8) ?? "<no body>"
+            throw GoogleClassroomClientError.httpStatus(http.statusCode, body)
+        }
+
+        do {
+            return try JSONDecoder().decode(Course.self, from: data)
+        } catch {
+            let raw = String(data: data, encoding: .utf8) ?? "<unreadable body>"
+            throw GoogleClassroomClientError.decodeFailed(raw)
+        }
+    }
+
+    private func waitForCourseToSettle(accessToken: String, courseId: String) async throws -> Course {
+        var latest = try await fetchCourse(accessToken: accessToken, courseId: courseId)
+        if (latest.courseState ?? "").uppercased() == "ACTIVE" { return latest }
+        for attempt in 0..<4 {
+            let delayNs: UInt64 = (attempt < 2) ? 350_000_000 : 700_000_000
+            try await Task.sleep(nanoseconds: delayNs)
+            latest = try await fetchCourse(accessToken: accessToken, courseId: courseId)
+            if (latest.courseState ?? "").uppercased() == "ACTIVE" { return latest }
+        }
+        return latest
+    }
+
     private func listCourseAnnouncements(accessToken: String, courseId: String, pageSize: Int) async throws -> [CourseAnnouncement] {
         var components = URLComponents(string: "https://classroom.googleapis.com/v1/courses/\(courseId)/announcements")!
         components.queryItems = [
@@ -419,6 +629,13 @@ private extension GoogleClassroomClientError {
         let lowercasedBody = body.lowercased()
         return lowercasedBody.contains("permission_denied") || lowercasedBody.contains("does not have permission")
     }
+
+    var isInsufficientScope: Bool {
+        guard case let .httpStatus(status, body) = self, status == 403 else { return false }
+        let lowercasedBody = body.lowercased()
+        return lowercasedBody.contains("access_token_scope_insufficient")
+            || lowercasedBody.contains("insufficient authentication scopes")
+    }
 }
 
 extension GoogleClassroomClientError: LocalizedError {
@@ -450,6 +667,32 @@ private struct Course: Decodable {
     let courseState: String?
 }
 
+private struct CreateCoursePayload: Encodable {
+    var name: String
+    var ownerId: String
+    var courseState: String
+    var section: String?
+    var room: String?
+    var descriptionHeading: String?
+    var description: String?
+}
+
+private struct UpdateCourseStatePayload: Encodable {
+    let courseState: String
+}
+
+private struct InvitationsList: Decodable {
+    let invitations: [Invitation]?
+    let nextPageToken: String?
+}
+
+private struct Invitation: Decodable {
+    let id: String
+    let courseId: String?
+    let role: String?
+    let userId: String?
+}
+
 private struct CourseWorkList: Decodable {
     let courseWork: [CourseWork]?
     let nextPageToken: String?
@@ -572,6 +815,11 @@ private extension String {
         let trimmed = trimmingCharacters(in: .whitespacesAndNewlines)
         return trimmed.isEmpty ? fallback : trimmed
     }
+
+    var nonEmptyTrimmed: String? {
+        let trimmed = trimmingCharacters(in: .whitespacesAndNewlines)
+        return trimmed.isEmpty ? nil : trimmed
+    }
 }
 
 private extension Date {

classroom_app/ViewController.swift

@@ -2362,9 +2362,13 @@ private extension ViewController {
         let refreshButton = makeScheduleRefreshButton()
         refreshButton.target = self
         refreshButton.action = #selector(teachingPageRefreshPressed(_:))
+        let createClassButton = makeTeachingCreateClassButton()
+        createClassButton.target = self
+        createClassButton.action = #selector(teachingCreateClassPressed(_:))
 
         titleRow.addArrangedSubview(titleLabel)
         titleRow.addArrangedSubview(spacer)
+        titleRow.addArrangedSubview(createClassButton)
         titleRow.addArrangedSubview(refreshButton)
 
         let heading = textLabel(teachingPageInitialHeadingText(), font: typography.dateHeading, color: palette.textSecondary)
@@ -3805,6 +3809,13 @@ private extension ViewController {
         return button
     }
 
+    private func makeTeachingCreateClassButton() -> NSButton {
+        let button = makeSchedulePillButton(title: "+ Create class")
+        button.contentTintColor = palette.textPrimary
+        button.toolTip = "Create a new Google Classroom class"
+        return button
+    }
+
     func scheduleCardsRow(todos: [ClassroomTodoItem]) -> NSView {
         let cardWidth: CGFloat = 240
         let cardsPerViewport: CGFloat = 3
@@ -4073,6 +4084,20 @@ private extension PremiumPlan {
     }
 }
 
+private extension Int {
+    var ordinalSuffix: String {
+        let tens = (self / 10) % 10
+        let ones = self % 10
+        if tens == 1 { return "th" }
+        switch ones {
+        case 1: return "st"
+        case 2: return "nd"
+        case 3: return "rd"
+        default: return "th"
+        }
+    }
+}
+
 extension ViewController: NSTextFieldDelegate {
     func control(_ control: NSControl, textView: NSTextView, doCommandBy commandSelector: Selector) -> Bool {
         if control === browseAddressField, commandSelector == #selector(NSResponder.insertNewline(_:)) {
@@ -5590,6 +5615,10 @@ private extension ViewController {
         scheduleReloadClicked()
     }
 
+    @objc func teachingCreateClassPressed(_ sender: NSButton) {
+        teachingCreateClassClicked()
+    }
+
     @objc func scheduleScrollLeftPressed(_ sender: NSButton) {
         scrollScheduleCards(direction: -1)
     }
@@ -5644,6 +5673,125 @@ private extension ViewController {
         }
     }
 
+    private struct TeachingClassFormValues {
+        let name: String
+        let section: String
+        let levels: String
+        let room: String
+        let descriptionText: String
+    }
+
+    private func teachingCreateClassClicked() {
+        guard storeKitCoordinator.hasPremiumAccess else {
+            showPaywall()
+            return
+        }
+        guard let values = promptForTeachingClassValues() else { return }
+        Task { [weak self] in
+            await self?.createTeachingClass(values)
+        }
+    }
+
+    private func promptForTeachingClassValues() -> TeachingClassFormValues? {
+        let alert = NSAlert()
+        alert.messageText = "Create class"
+        alert.informativeText = "Create a class in Google Classroom."
+        alert.addButton(withTitle: "Create")
+        alert.addButton(withTitle: "Cancel")
+
+        let content = NSView(frame: NSRect(x: 0, y: 0, width: 360, height: 222))
+        let nameField = NSTextField(string: "")
+        nameField.placeholderString = "Class name (required)"
+        let sectionField = NSTextField(string: "")
+        sectionField.placeholderString = "Section (optional)"
+        let levelField = NSComboBox(frame: .zero)
+        levelField.placeholderString = "Level(s) (optional)"
+        levelField.usesDataSource = false
+        levelField.isEditable = true
+        levelField.completes = true
+        levelField.addItems(withObjectValues: teachingClassLevelOptions())
+        let roomField = NSTextField(string: "")
+        roomField.placeholderString = "Room (optional)"
+        let descriptionField = NSTextField(string: "")
+        descriptionField.placeholderString = "Description (optional)"
+        let textFields: [NSTextField] = [nameField, sectionField, roomField, descriptionField]
+        for field in textFields {
+            field.translatesAutoresizingMaskIntoConstraints = false
+            field.focusRingType = .default
+            content.addSubview(field)
+        }
+        levelField.translatesAutoresizingMaskIntoConstraints = false
+        content.addSubview(levelField)
+        alert.accessoryView = content
+
+        NSLayoutConstraint.activate([
+            nameField.leadingAnchor.constraint(equalTo: content.leadingAnchor),
+            nameField.trailingAnchor.constraint(equalTo: content.trailingAnchor),
+            nameField.topAnchor.constraint(equalTo: content.topAnchor),
+
+            sectionField.leadingAnchor.constraint(equalTo: content.leadingAnchor),
+            sectionField.trailingAnchor.constraint(equalTo: content.trailingAnchor),
+            sectionField.topAnchor.constraint(equalTo: nameField.bottomAnchor, constant: 10),
+
+            levelField.leadingAnchor.constraint(equalTo: content.leadingAnchor),
+            levelField.trailingAnchor.constraint(equalTo: content.trailingAnchor),
+            levelField.topAnchor.constraint(equalTo: sectionField.bottomAnchor, constant: 10),
+            levelField.heightAnchor.constraint(equalToConstant: 24),
+
+            roomField.leadingAnchor.constraint(equalTo: content.leadingAnchor),
+            roomField.trailingAnchor.constraint(equalTo: content.trailingAnchor),
+            roomField.topAnchor.constraint(equalTo: levelField.bottomAnchor, constant: 10),
+
+            descriptionField.leadingAnchor.constraint(equalTo: content.leadingAnchor),
+            descriptionField.trailingAnchor.constraint(equalTo: content.trailingAnchor),
+            descriptionField.topAnchor.constraint(equalTo: roomField.bottomAnchor, constant: 10),
+            descriptionField.bottomAnchor.constraint(equalTo: content.bottomAnchor)
+        ])
+
+        let response = alert.runModal()
+        guard response == .alertFirstButtonReturn else { return nil }
+        return TeachingClassFormValues(
+            name: nameField.stringValue,
+            section: sectionField.stringValue,
+            levels: levelField.stringValue,
+            room: roomField.stringValue,
+            descriptionText: descriptionField.stringValue
+        )
+    }
+
+    private func teachingClassLevelOptions() -> [String] {
+        let earlyYears = [
+            "Nursery",
+            "Reception",
+            "Year 1",
+            "Year 2",
+            "Year 3",
+            "Year 4",
+            "Year 5",
+            "Year 6",
+            "Year 7",
+            "Year 8",
+            "Year 9",
+            "Year 10",
+            "Year 11",
+            "Year 12",
+            "Year 13",
+            "Preschool",
+            "Kindergarten"
+        ]
+        let grades = (1...12).map { "\($0)\($0.ordinalSuffix) Grade" }
+        return earlyYears + grades
+    }
+
+    private func hasRequiredScopesForClassCreation() -> Bool {
+        guard let scopeText = googleOAuth.loadTokens()?.scope?.lowercased(), !scopeText.isEmpty else { return true }
+        let required = [
+            "https://www.googleapis.com/auth/classroom.courses",
+            "https://www.googleapis.com/auth/classroom.rosters"
+        ]
+        return required.allSatisfy { scopeText.contains($0.lowercased()) }
+    }
+
     @objc func scheduleFilterDropdownChanged(_ sender: NSPopUpButton) {
         guard let selectedItem = sender.selectedItem,
               let filter = ScheduleFilter(rawValue: selectedItem.tag) else { return }
@@ -6528,6 +6676,89 @@ private extension ViewController {
         }
     }
 
+    private func createTeachingClass(_ values: TeachingClassFormValues) async {
+        do {
+            if googleOAuth.loadTokens() == nil {
+                await MainActor.run {
+                    showSimpleAlert(title: "Connect Google", message: "Connect your Google account to create classes.")
+                }
+                return
+            }
+
+            guard hasRequiredScopesForClassCreation() else {
+                await MainActor.run {
+                    _ = try? googleOAuth.signOut()
+                    applyGoogleProfile(nil)
+                    updateGoogleAuthButtonTitle()
+                    showSimpleAlert(
+                        title: "Reconnect Google",
+                        message: "Please reconnect Google once so we can get class create and auto-accept permissions."
+                    )
+                }
+                return
+            }
+
+            let trimmedName = values.name.trimmingCharacters(in: .whitespacesAndNewlines)
+            guard trimmedName.isEmpty == false else {
+                await MainActor.run {
+                    showSimpleAlert(title: "Class name required", message: "Enter a class name before creating the class.")
+                }
+                return
+            }
+
+            await MainActor.run {
+                showSimpleAlert(title: "Class created", message: "\"\(trimmedName)\" was created.\nPlease wait untill setup your class.")
+            }
+
+            let token = try await googleOAuth.validAccessToken(presentingWindow: view.window)
+            let sectionTrimmed = values.section.trimmingCharacters(in: .whitespacesAndNewlines)
+            let levelTrimmed = values.levels.trimmingCharacters(in: .whitespacesAndNewlines)
+            let effectiveSection = sectionTrimmed.isEmpty ? levelTrimmed : sectionTrimmed
+            var effectiveDescription = values.descriptionText.trimmingCharacters(in: .whitespacesAndNewlines)
+            if !levelTrimmed.isEmpty, !sectionTrimmed.isEmpty {
+                effectiveDescription = effectiveDescription.isEmpty
+                    ? "Level(s): \(levelTrimmed)"
+                    : "Level(s): \(levelTrimmed)\n\(effectiveDescription)"
+            }
+            let createdCourse = try await classroomClient.createCourse(
+                accessToken: token,
+                request: GoogleClassroomClient.CreateCourseRequest(
+                    name: trimmedName,
+                    section: effectiveSection,
+                    room: values.room,
+                    descriptionHeading: effectiveSection,
+                    description: effectiveDescription
+                )
+            )
+            await loadTeachingClasses()
+            await MainActor.run {
+                if createdCourse.courseState.uppercased() != "ACTIVE" {
+                    showSimpleAlert(
+                        title: "Class created",
+                        message: "\"\(createdCourse.name)\" was created. Please accept the class in Google Classroom."
+                    )
+                    if let classroomHome = URL(string: "https://classroom.google.com") {
+                        openURL(classroomHome)
+                    }
+                }
+            }
+        } catch {
+            await MainActor.run {
+                if errorRequiresReconsentForClassroomScopes(error) {
+                    _ = try? googleOAuth.signOut()
+                    applyGoogleProfile(nil)
+                    updateGoogleAuthButtonTitle()
+                    showSimpleAlert(
+                        title: "Reconnect Google",
+                        message: "We added Google Classroom create permissions. Please connect your Google account again and grant access."
+                    )
+                    return
+                }
+                showSimpleError("Couldn’t create class.", error: error)
+            }
+        }
+    }
+
     func showScheduleHelp() {
         let alert = NSAlert()
         alert.messageText = "Google Classroom to-do"