Интеграция API в Swift: типы запросов, обработка ответов, модели

// Формируем URL
let url = URL(string: "https://api.example.com/users")!

// Создаем запрос
var request = URLRequest(url: url)
request.httpMethod = "GET"
request.addValue("application/json", forHTTPHeaderField: "Content-Type")

// Выполняем запрос
let task = URLSession.shared.dataTask(with: request) { data, response, error in
// Обрабатываем ответ
if let error = error {
print("Ошибка: \(error)")
return
}

guard let data = data else {
print("Нет данных в ответе")
return
}

do {
// Преобразуем JSON в словарь
let json = try JSONSerialization.jsonObject(with: data)
print("Получены данные: \(json)")
} catch {
print("Ошибка парсинга JSON: \(error)")
}
}

// Запускаем задачу
task.resume()

struct User: Codable {
let id: Int
let name: String
let email: String
}

class NetworkManager {
static let shared = NetworkManager()
private init() {}

func fetchUsers(completion: @escaping (Result<[User], Error>) -> Void) {
let url = URL(string: "https://api.example.com/users")!
let task = URLSession.shared.dataTask(with: url) { data, response, error in
if let error = error {
completion(.failure(error))
return
}

guard let httpResponse = response as? HTTPURLResponse,
(200...299).contains(httpResponse.statusCode) else {
completion(.failure(NetworkError.invalidResponse))
return
}

guard let data = data else {
completion(.failure(NetworkError.noData))
return
}

do {
let users = try JSONDecoder().decode([User].self, from: data)
completion(.success(users))
} catch {
completion(.failure(error))
}
}
task.resume()
}
}

enum NetworkError: Error {
case invalidResponse
case noData
}

// С использованием async/await (iOS 15+)
func fetchUsers() async throws -> [User] {
let url = URL(string: "https://api.example.com/users")!
let (data, response) = try await URLSession.shared.data(from: url)

guard let httpResponse = response as? HTTPURLResponse,
(200...299).contains(httpResponse.statusCode) else {
throw NetworkError.invalidResponse
}

return try JSONDecoder().decode([User].self, from: data)
}

// Использование
Task {
do {
let users = try await fetchUsers()
// Обновляем UI
} catch {
// Обрабатываем ошибку
}
}

// В Package.swift
dependencies: [
.package(url: "https://github.com/Alamofire/Alamofire.git", .upToNextMajor(from: "5.6.1"))
]

pod 'Alamofire', '~> 5.6.1'

import Alamofire

struct User: Codable {
let id: Int
let name: String
let email: String
}

class NetworkManager {
static let shared = NetworkManager()

func fetchUsers(completion: @escaping (Result<[User], Error>) -> Void) {
AF.request("https://api.example.com/users")
.validate()
.responseDecodable(of: [User].self) { response in
switch response.result {
case .success(let users):
completion(.success(users))
case .failure(let error):
completion(.failure(error))
}
}
}

func createUser(user: User, completion: @escaping (Result<User, Error>) -> Void) {
AF.request("https://api.example.com/users", 
method: .post,
parameters: user,
encoder: JSONParameterEncoder.default)
.validate()
.responseDecodable(of: User.self) { response in
completion(response.result)
}
}
}

// В Package.swift
dependencies: [
.package(url: "https://github.com/Moya/Moya.git", .upToNextMajor(from: "15.0.0"))
]

import Moya

enum UserService {
case getUsers
case createUser(name: String, email: String)
case updateUser(id: Int, name: String, email: String)
case deleteUser(id: Int)
}

extension UserService: TargetType {
var baseURL: URL { return URL(string: "https://api.example.com")! }

var path: String {
switch self {
case .getUsers, .createUser:
return "/users"
case .updateUser(let id, _, _), .deleteUser(let id):
return "/users/\(id)"
}
}

var method: Moya.Method {
switch self {
case .getUsers:
return .get
case .createUser:
return .post
case .updateUser:
return .put
case .deleteUser:
return .delete
}
}

var task: Task {
switch self {
case .getUsers, .deleteUser:
return .requestPlain
case .createUser(let name, let email):
return .requestParameters(
parameters: ["name": name, "email": email],
encoding: JSONEncoding.default
)
case .updateUser(_, let name, let email):
return .requestParameters(
parameters: ["name": name, "email": email],
encoding: JSONEncoding.default
)
}
}

var headers: [String : String]? {
return ["Content-Type": "application/json"]
}
}

class NetworkManager {
let provider = MoyaProvider<UserService>()

func fetchUsers(completion: @escaping ([User]?, Error?) -> Void) {
provider.request(.getUsers) { result in
switch result {
case .success(let response):
do {
let users = try JSONDecoder().decode([User].self, from: response.data)
completion(users, nil)
} catch {
completion(nil, error)
}
case .failure(let error):
completion(nil, error)
}
}
}
}

struct User: Codable {
let id: Int
let name: String
let email: String
let address: Address?

enum CodingKeys: String, CodingKey {
case id
case name
case email
case address
}
}

struct Address: Codable {
let street: String
let city: String
let zipCode: String

enum CodingKeys: String, CodingKey {
case street
case city
case zipCode = "zip_code" // Сопоставление с ключом JSON
}
}

let jsonString = """
{
"id": 1,
"name": "John Doe",
"email": "john@example.com",
"address": {
"street": "123 Main St",
"city": "New York",
"zip_code": "10001"
}
}
"""

let jsonData = jsonString.data(using: .utf8)!

do {
let decoder = JSONDecoder()
let user = try decoder.decode(User.self, from: jsonData)
print("Пользователь: \(user.name), Email: \(user.email)")
if let address = user.address {
print("Адрес: \(address.street), \(address.city)")
}
} catch {
print("Ошибка декодирования: \(error)")
}

let user = User(id: 2, name: "Jane Smith", email: "jane@example.com", 
address: Address(street: "456 Broadway", city: "Los Angeles", zipCode: "90001"))

do {
let encoder = JSONEncoder()
encoder.outputFormatting = .prettyPrinted
let jsonData = try encoder.encode(user)
if let jsonString = String(data: jsonData, encoding: .utf8) {
print(jsonString)
}
} catch {
print("Ошибка кодирования: \(error)")
}

let decoder = JSONDecoder()
decoder.keyDecodingStrategy = .convertFromSnakeCase
decoder.dateDecodingStrategy = .iso8601

// Теперь можно декодировать JSON с snake_case ключами и ISO-датами
// { "user_id": 1, "created_at": "2022-05-15T14:30:00Z" }

struct Product: Codable {
let id: Int
let name: String
let price: Double
let tags: [String]
let metadata: [String: String]

init(from decoder: Decoder) throws {
let container = try decoder.container(keyedBy: CodingKeys.self)
id = try container.decode(Int.self, forKey: .id)
name = try container.decode(String.self, forKey: .name)

// Обработка случая, когда price может быть строкой или числом
if let priceString = try? container.decode(String.self, forKey: .price) {
price = Double(priceString) ?? 0.0
} else {
price = try container.decode(Double.self, forKey: .price)
}

tags = try container.decode([String].self, forKey: .tags)
metadata = try container.decode([String: String].self, forKey: .metadata)
}
}

func makeRequestWithBasicAuth() {
let username = "user"
let password = "pass"
let loginString = "\(username):\(password)"

guard let loginData = loginString.data(using: .utf8) else { return }
let base64LoginString = loginData.base64EncodedString()

var request = URLRequest(url: URL(string: "https://api.example.com/protected")!)
request.httpMethod = "GET"
request.setValue("Basic \(base64LoginString)", forHTTPHeaderField: "Authorization")

URLSession.shared.dataTask(with: request) { data, response, error in
// Обработка ответа
}.resume()
}

struct AuthManager {
static let shared = AuthManager()

private var token: String?

mutating func setToken(_ token: String) {
self.token = token
}

func getToken() -> String? {
return token
}

// Авторизация пользователя и получение токена
func login(username: String, password: String, completion: @escaping (Result<String, Error>) -> Void) {
let parameters = ["username": username, "password": password]

AF.request("https://api.example.com/auth/login",
method: .post,
parameters: parameters,
encoding: JSONEncoding.default)
.validate()
.responseDecodable(of: TokenResponse.self) { response in
switch response.result {
case .success(let tokenResponse):
self.token = tokenResponse.token
completion(.success(tokenResponse.token))
case .failure(let error):
completion(.failure(error))
}
}
}
}

struct TokenResponse: Decodable {
let token: String
}

// Использование AuthManager с API-запросами
class UserAPI {
func getProfile(completion: @escaping (Result<User, Error>) -> Void) {
guard let token = AuthManager.shared.getToken() else {
completion(.failure(APIError.notAuthorized))
return
}

let headers: HTTPHeaders = [
"Authorization": "Bearer \(token)",
"Content-Type": "application/json"
]

AF.request("https://api.example.com/user/profile",
method: .get,
headers: headers)
.validate()
.responseDecodable(of: User.self) { response in
completion(response.result)
}
}
}

enum APIError: Error {
case notAuthorized
case serverError
case invalidResponse
}

import OAuthSwift

class OAuthManager {
let oauthswift = OAuth2Swift(
consumerKey: "YOUR_CLIENT_ID",
consumerSecret: "YOUR_CLIENT_SECRET",
authorizeUrl: "https://example.com/oauth/authorize",
accessTokenUrl: "https://example.com/oauth/token",
responseType: "code"
)

func authorize(from viewController: UIViewController, completion: @escaping (Bool) -> Void) {
oauthswift.authorize(
withCallbackURL: "yourapp://oauth-callback",
scope: "read write",
state: "STATE",
success: { credential, response, parameters in
print("Token: \(credential.oauthToken)")
// Сохраняем токен для последующих запросов
completion(true)
},
failure: { error in
print(error.localizedDescription)
completion(false)
}
)
}

func makeRequest() {
oauthswift.client.get("https://api.example.com/me") { result in
switch result {
case .success(let response):
print(response.string ?? "")
case .failure(let error):
print(error.localizedDescription)
}
}
}
}

import Security

class KeychainService {
static func save(key: String, data: Data) -> OSStatus {
let query = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrAccount as String: key,
kSecValueData as String: data
] as [String: Any]

// Удаляем старое значение, если оно существует
SecItemDelete(query as CFDictionary)

// Добавляем новое значение
return SecItemAdd(query as CFDictionary, nil)
}

static func load(key: String) -> Data? {
let query = [
kSecClass as String: kSecClassGenericPassword,
kSecAttrAccount as String: key,
kSecReturnData as String: true,
kSecMatchLimit as String: kSecMatchLimitOne
] as [String: Any]

var result: AnyObject?
let status = SecItemCopyMatching(query as CFDictionary, &result)

return status == noErr ? result as? Data : nil
}
}

// Сохранение токена в Keychain
let token = "eyJhbGciOiJIUzI1NiJ9..."
if let data = token.data(using: .utf8) {
let status = KeychainService.save(key: "api_token", data: data)
print("Сохранение в Keychain: \(status == noErr)")
}

// Загрузка токена из Keychain
if let data = KeychainService.load(key: "api_token"),
let token = String(data: data, encoding: .utf8) {
print("Токен: \(token)")
}