atridad/pdsman-ios
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Bug fixes

Browse Source
This commit is contained in:
Atridad Lahiji
2025-03-19 01:55:58 -06:00
parent 292180b204
commit bbad8d6948
5 changed files with 195 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

216
PDSMan/Services/PDSService.swift
View File

@ -387,76 +387,84 @@ class PDSService: ObservableObject {
// MARK: - Invite Codes
func fetchInviteCodes() async {
guard isAuthenticated, let baseURL = baseURL, let authHeader = authHeader else { return }
print("⏳ PDSService: Starting to fetch invite codes")
self.isLoading = true
defer { self.isLoading = false }
defer {
self.isLoading = false
guard let baseURL = baseURL, let authHeader = authHeader else {
print("❌ PDSService: Cannot fetch invite codes - missing authentication")
return
}
// Construct the URL for the invite codes endpoint
guard let inviteCodesURL = URL(string: "\(baseURL)/xrpc/com.atproto.admin.getInviteCodes") else {
setError("Invalid invite codes URL")
// Set up URL components for the request with any needed query parameters
guard var components = URLComponents(string: "\(baseURL)/xrpc/com.atproto.admin.getInviteCodes") else {
print("❌ PDSService: Invalid invite codes URL")
return
}
// Add query parameters
var components = URLComponents(url: inviteCodesURL, resolvingAgainstBaseURL: true)
components?.queryItems = [
components.queryItems = [
URLQueryItem(name: "sort", value: "recent"),
URLQueryItem(name: "limit", value: "100"),
URLQueryItem(name: "includeDisabled", value: "true") // Always include disabled codes
URLQueryItem(name: "includeDisabled", value: "true")
]
guard let finalURL = components?.url else {
setError("Invalid invite codes URL with parameters")
guard let url = components.url else {
print("❌ PDSService: Failed to construct URL with query parameters")
return
}
var request = URLRequest(url: finalURL)
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.addValue(authHeader, forHTTPHeaderField: "Authorization")
do {
let (data, response) = try await session.data(for: request)
guard let httpResponse = response as? HTTPURLResponse else {
setError("Invalid response from server")
guard let httpResponse = response as? HTTPURLResponse, httpResponse.statusCode == 200 else {
let statusCode = (response as? HTTPURLResponse)?.statusCode ?? 0
print("❌ PDSService: Invite codes fetch failed with status \(statusCode)")
return
}
if httpResponse.statusCode == 200 {
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let codesResponse = try decoder.decode(InviteCodesResponse.self, from: data)
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
// Debug: Print raw response
if let responseString = String(data: data, encoding: .utf8) {
print("👀 PDSService: Raw invite codes response: \(responseString)")
}
let codesResponse = try decoder.decode(InviteCodesResponse.self, from: data)
// Map the response to our model
let parsedCodes = codesResponse.codes.map { codeResp -> InviteCode in
let dateFormatter = ISO8601DateFormatter()
let createdDate = dateFormatter.date(from: codeResp.createdAt) ?? Date()
let parsedCodes = codesResponse.codes.map { codeResp -> InviteCode in
let createdDate = dateFormatter.date(from: codeResp.createdAt) ?? Date()
// Convert the uses array
let inviteUses = codeResp.uses?.map { use -> PDSMan.CodeUse in
return PDSMan.CodeUse(usedBy: use.usedBy, usedAt: use.usedAt)
}
return InviteCode(
id: codeResp.code,
uses: inviteUses,
createdAt: createdDate,
disabled: codeResp.disabled
)
// Convert the uses array
let inviteUses = codeResp.uses?.map { use -> PDSMan.CodeUse in
return PDSMan.CodeUse(usedBy: use.usedBy, usedAt: use.usedAt)
}
self.inviteCodes = parsedCodes
} else {
let responseString = String(data: data, encoding: .utf8) ?? "Unknown error"
setError("Failed to fetch invite codes: \(httpResponse.statusCode) - \(responseString)")
return InviteCode(
id: codeResp.code,
uses: inviteUses,
createdAt: createdDate,
disabled: codeResp.disabled
)
}
// Update the inviteCodes property
DispatchQueue.main.async {
self.inviteCodes = parsedCodes
self.objectWillChange.send()
print("✅ PDSService: Successfully fetched \(parsedCodes.count) invite codes")
print("✅ PDSService: Including \(parsedCodes.filter { !$0.disabled }.count) active codes")
}
} catch {
setError("Failed to fetch invite codes: \(error.localizedDescription)")
print("❌ PDSService: Error fetching invite codes: \(error.localizedDescription)")
}
}
@ -501,7 +509,13 @@ class PDSService: ObservableObject {
)
// Update the local list
self.inviteCodes.append(newCode)
DispatchQueue.main.async {
self.inviteCodes.append(newCode)
self.objectWillChange.send()
}
// Also refresh the full list to ensure we have the most up-to-date data
await fetchInviteCodes()
return newCode
} else {
@ -516,10 +530,17 @@ class PDSService: ObservableObject {
}
func disableInviteCode(_ code: String) async -> Bool {
guard isAuthenticated, let baseURL = baseURL, let authHeader = authHeader else { return false }
print("⏳ PDSService: Attempting to disable invite code: \(code)")
self.isLoading = true
defer { self.isLoading = false }
guard let baseURL = baseURL, let authHeader = authHeader else {
print("❌ PDSService: Cannot disable code - missing authentication")
return false
}
guard let disableURL = URL(string: "\(baseURL)/xrpc/com.atproto.admin.disableInviteCodes") else {
setError("Invalid disable invite code URL")
print("❌ PDSService: Invalid disable code URL")
return false
}
@ -528,7 +549,7 @@ class PDSService: ObservableObject {
request.addValue("application/json", forHTTPHeaderField: "Content-Type")
request.addValue(authHeader, forHTTPHeaderField: "Authorization")
// Create the request body with an array of codes
// Create the request body
let disableBody = ["codes": [code]]
do {
@ -538,21 +559,29 @@ class PDSService: ObservableObject {
let (data, response) = try await session.data(for: request)
guard let httpResponse = response as? HTTPURLResponse else {
setError("Invalid response from server")
print("❌ PDSService: Invalid response from server")
return false
}
// Debug: Print response details
if let responseString = String(data: data, encoding: .utf8) {
print("👀 PDSService: Disable code response: \(responseString)")
}
if httpResponse.statusCode == 200 {
// Refresh the invite codes
print("✅ PDSService: Successfully disabled code: \(code)")
// Refresh the invite codes list
await fetchInviteCodes()
return true
} else {
let responseString = String(data: data, encoding: .utf8) ?? "Unknown error"
setError("Failed to disable invite code: \(httpResponse.statusCode) - \(responseString)")
print("❌ PDSService: Failed to disable code: \(httpResponse.statusCode) - \(responseString)")
return false
}
} catch {
setError("Failed to disable invite code: \(error.localizedDescription)")
print("❌ PDSService: Error disabling code: \(error.localizedDescription)")
return false
}
}
@ -560,68 +589,67 @@ class PDSService: ObservableObject {
// MARK: - Users
func fetchUsers() async {
guard isAuthenticated, let baseURL = baseURL, let authHeader = authHeader else { return }
print("⏳ PDSService: Starting to fetch users")
self.isLoading = true
defer { self.isLoading = false }
defer {
self.isLoading = false
}
// Construct the URL for the repos endpoint
guard let reposURL = URL(string: "\(baseURL)/xrpc/com.atproto.sync.listRepos") else {
setError("Invalid list repos URL")
guard let baseURL = baseURL, let authHeader = authHeader else {
print("❌ PDSService: Cannot fetch users - missing authentication")
return
}
// Add query parameters
var components = URLComponents(url: reposURL, resolvingAgainstBaseURL: true)
components?.queryItems = [
URLQueryItem(name: "limit", value: "100")
]
guard let finalURL = components?.url else {
setError("Invalid repos URL with parameters")
// First, get a list of all repos (users) on the server
guard let repoURL = URL(string: "\(baseURL)/xrpc/com.atproto.sync.listRepos") else {
print("❌ PDSService: Invalid list repos URL")
return
}
var request = URLRequest(url: finalURL)
request.httpMethod = "GET"
request.addValue(authHeader, forHTTPHeaderField: "Authorization")
var repoRequest = URLRequest(url: repoURL)
repoRequest.httpMethod = "GET"
repoRequest.addValue(authHeader, forHTTPHeaderField: "Authorization")
do {
let (data, response) = try await session.data(for: request)
let (repoData, repoResponse) = try await session.data(for: repoRequest)
guard let httpResponse = response as? HTTPURLResponse else {
setError("Invalid response from server")
guard let httpResponse = repoResponse as? HTTPURLResponse, httpResponse.statusCode == 200 else {
let statusCode = (repoResponse as? HTTPURLResponse)?.statusCode ?? 0
print("❌ PDSService: Repos fetch failed with status \(statusCode)")
return
}
if httpResponse.statusCode == 200 {
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let reposResponse = try decoder.decode(RepoResponse.self, from: data)
// Fetch details for each user
var fetchedUsers: [PDSUser] = []
for repo in reposResponse.repos {
if let user = await fetchUserProfile(did: repo.did, isActive: repo.active) {
fetchedUsers.append(user)
}
}
// Sort users by join date (newest first)
fetchedUsers.sort { $0.joinedAt > $1.joinedAt }
self.users = fetchedUsers
} else {
let responseString = String(data: data, encoding: .utf8) ?? "Unknown error"
setError("Failed to fetch users: \(httpResponse.statusCode) - \(responseString)")
// Debug: Print raw response
if let responseString = String(data: repoData, encoding: .utf8) {
print("👀 PDSService: Raw repos response: \(responseString)")
}
let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
let reposResult = try decoder.decode(RepoResponse.self, from: repoData)
print("📊 PDSService: Found \(reposResult.repos.count) repos")
// Fetch individual user profiles
var fetchedUsers: [PDSUser] = []
for repo in reposResult.repos {
print("🔍 PDSService: Fetching profile for \(repo.did)")
if let user = await fetchUserProfile(did: repo.did, isActive: repo.active) {
fetchedUsers.append(user)
}
}
// Sort users by join date (newest first)
fetchedUsers.sort { $0.joinedAt > $1.joinedAt }
// Update the users property
DispatchQueue.main.async {
self.users = fetchedUsers
self.objectWillChange.send()
print("✅ PDSService: Successfully fetched \(fetchedUsers.count) user profiles")
}
} catch {
setError("Failed to fetch users: \(error.localizedDescription)")
print("❌ PDSService: Error fetching repos: \(error.localizedDescription)")
}
}