121 lines
4.2 KiB
Swift
121 lines
4.2 KiB
Swift
import Foundation
|
|
|
|
final class FeishuService {
|
|
private let baseURL = "https://open.feishu.cn/open-apis"
|
|
private let session: URLSession
|
|
private let decoder: JSONDecoder
|
|
|
|
init(session: URLSession = .shared) {
|
|
self.session = session
|
|
let decoder = JSONDecoder()
|
|
decoder.keyDecodingStrategy = .convertFromSnakeCase
|
|
self.decoder = decoder
|
|
}
|
|
|
|
func fetchBugs(
|
|
config: AppConfig,
|
|
assigneeName: String,
|
|
accessToken: String
|
|
) async throws -> [Bug] {
|
|
var allRecords: [RecordItem] = []
|
|
var pageToken: String?
|
|
var pages = 0
|
|
// 25,000 records at 500/page — guard against a runaway cursor that
|
|
// would otherwise loop forever accumulating memory.
|
|
let maxPages = 50
|
|
|
|
repeat {
|
|
pages += 1
|
|
guard pages <= maxPages else {
|
|
throw FeishuError.paginationLimitExceeded
|
|
}
|
|
let page = try await fetchPage(
|
|
appToken: config.appToken,
|
|
tableId: config.tableId,
|
|
pageToken: pageToken,
|
|
accessToken: accessToken
|
|
)
|
|
allRecords.append(contentsOf: page.items)
|
|
pageToken = page.hasMore ? page.pageToken : nil
|
|
} while pageToken != nil
|
|
|
|
return allRecords
|
|
.map { BugMapper.map($0, config: config) }
|
|
.filter { bug in
|
|
bug.assignee.localizedCaseInsensitiveContains(assigneeName)
|
|
}
|
|
}
|
|
|
|
func fetchRecordCount(
|
|
appToken: String,
|
|
tableId: String,
|
|
accessToken: String
|
|
) async throws -> Int {
|
|
let page = try await fetchPage(
|
|
appToken: appToken,
|
|
tableId: tableId,
|
|
pageToken: nil,
|
|
pageSize: 1,
|
|
accessToken: accessToken
|
|
)
|
|
return page.total ?? page.items.count
|
|
}
|
|
|
|
private func fetchPage(
|
|
appToken: String,
|
|
tableId: String,
|
|
pageToken: String?,
|
|
pageSize: Int = 500,
|
|
accessToken: String
|
|
) async throws -> RecordListData {
|
|
guard !appToken.isEmpty, !tableId.isEmpty else {
|
|
throw FeishuError.invalidConfiguration("App token and table ID must not be empty.")
|
|
}
|
|
guard var components = URLComponents(
|
|
string: "\(baseURL)/bitable/v1/apps/\(appToken)/tables/\(tableId)/records"
|
|
) else {
|
|
throw FeishuError.invalidConfiguration("App token or table ID contains invalid characters.")
|
|
}
|
|
var queryItems = [URLQueryItem(name: "page_size", value: String(pageSize))]
|
|
if let pageToken {
|
|
queryItems.append(URLQueryItem(name: "page_token", value: pageToken))
|
|
}
|
|
components.queryItems = queryItems
|
|
|
|
guard let url = components.url else {
|
|
throw FeishuError.invalidConfiguration("Could not build records request URL.")
|
|
}
|
|
|
|
var request = URLRequest(url: url)
|
|
request.httpMethod = "GET"
|
|
request.setValue("Bearer \(accessToken)", forHTTPHeaderField: "Authorization")
|
|
request.timeoutInterval = 30
|
|
|
|
let (data, response) = try await session.data(for: request)
|
|
guard let httpResponse = response as? HTTPURLResponse else {
|
|
throw FeishuError.networkError(nil)
|
|
}
|
|
|
|
let rawBody = String(data: data, encoding: .utf8) ?? "<binary \(data.count)B>"
|
|
BuggerLog.debug("fetchPage: HTTP \(httpResponse.statusCode) body=\(String(rawBody.prefix(500)))")
|
|
|
|
if httpResponse.statusCode == 401 {
|
|
throw FeishuError.unauthorized
|
|
}
|
|
|
|
let apiResponse: FeishuAPIResponse<RecordListData>
|
|
do {
|
|
apiResponse = try decoder.decode(FeishuAPIResponse<RecordListData>.self, from: data)
|
|
} catch {
|
|
BuggerLog.error("fetchPage: decode FAILED: \(error)")
|
|
BuggerLog.error("fetchPage: raw body: \(String(rawBody.prefix(1000)))")
|
|
throw FeishuError.decodingError(error, rawBody: String(rawBody.prefix(200)))
|
|
}
|
|
|
|
guard apiResponse.code == 0, let pageData = apiResponse.data else {
|
|
throw FeishuError.apiError(code: apiResponse.code, message: apiResponse.msg)
|
|
}
|
|
return pageData
|
|
}
|
|
}
|