API Dokümantasyonu

{
  "success": true,
  "message": "Login successful",
  "data": {
    "user": {
      "id": 1,
      "name": "Admin User",
      "email": "admin@example.com",
      "phone": null,
      "avatar": "https://ui-avatars.com/...",
      "status": "active",
      "role": {
        "id": 1,
        "name": "Süper Admin",
        "slug": "super-admin"
      }
    },
    "token": "abc123...",
    "token_type": "Bearer",
    "expires_at": "2025-01-23 10:30:00"
  }
}

{
  "success": false,
  "message": "Invalid email or password",
  "error": "INVALID_CREDENTIALS"
}

Future<Map<String, dynamic>> login(
  String email,
  String password,
) async {
  final response = await http.post(
    Uri.parse('$baseUrl/login'),
    headers: {'Content-Type': 'application/json'},
    body: jsonEncode({
      'email': email,
      'password': password,
      'device_name': 'Flutter App',
    }),
  );

  final data = jsonDecode(response.body);

  if (data['success'] == true) {
    // Token'ı kaydet
    await saveToken(data['data']['token']);
  }

  return data;
}

Future<Map<String, dynamic>> register({
  required String name,
  required String email,
  required String password,
  String? phone,
}) async {
  final response = await http.post(
    Uri.parse('$baseUrl/register'),
    headers: {'Content-Type': 'application/json'},
    body: jsonEncode({
      'name': name,
      'email': email,
      'password': password,
      'password_confirm': password,
      if (phone != null) 'phone': phone,
    }),
  );

  return jsonDecode(response.body);
}

{
  "success": true,
  "message": "Success",
  "data": {
    "books": [
      {
        "id": 1,
        "isbn": "978-605-123-456-7",
        "title": "Suç ve Ceza",
        "author": "Fyodor Dostoyevski",
        "publisher": "İş Bankası Kültür Yayınları",
        "publish_year": 2020,
        "page_count": 687,
        "language": "Türkçe",
        "description": "Rus edebiyatının...",
        "cover_image": null,
        "quantity": 3,
        "available_quantity": 2,
        "price": 85.50,
        "status": "available",
        "status_label": "Mevcut",
        "shelf": {
          "id": 1,
          "name": "Edebiyat Rafı",
          "code": "A-01"
        },
        "category": {
          "id": 2,
          "name": "Roman",
          "color": "#6366f1"
        },
        "created_at": "2024-12-27 10:00:00",
        "updated_at": "2024-12-27 10:00:00"
      }
    ],
    "pagination": {
      "current_page": 1,
      "per_page": 15,
      "total_items": 127,
      "total_pages": 9,
      "has_next": true,
      "has_previous": false
    }
  }
}

Future<Map<String, dynamic>> getBooks({
  int page = 1,
  int perPage = 15,
  String? search,
  String? status,
  int? categoryId,
  int? shelfId,
}) async {
  final queryParams = {
    'page': page.toString(),
    'per_page': perPage.toString(),
    if (search != null) 'search': search,
    if (status != null) 'status': status,
    if (categoryId != null) 'category_id': categoryId.toString(),
    if (shelfId != null) 'shelf_id': shelfId.toString(),
  };

  final uri = Uri.parse('$baseUrl/api/books')
      .replace(queryParameters: queryParams);

  final response = await http.get(uri);
  return jsonDecode(response.body);
}

{
  "success": true,
  "message": "Success",
  "data": {
    "book": {
      "id": 1,
      "isbn": "978-605-123-456-7",
      "title": "Suç ve Ceza",
      "author": "Fyodor Dostoyevski",
      "publisher": "İş Bankası Kültür Yayınları",
      "publish_year": 2020,
      "edition": "3. Baskı",
      "page_count": 687,
      "language": "Türkçe",
      "description": "Rus edebiyatının başyapıtlarından...",
      "cover_image": "http://localhost/uploads/books/suc-ve-ceza.jpg",
      "quantity": 3,
      "available_quantity": 2,
      "price": 85.50,
      "status": "available",
      "status_label": "Mevcut",
      "notes": null,
      "shelf": {
        "id": 1,
        "name": "Edebiyat Rafı",
        "code": "A-01"
      },
      "category": {
        "id": 2,
        "name": "Roman",
        "color": "#6366f1"
      },
      "added_by": {
        "id": 1,
        "name": "Admin User"
      },
      "created_at": "2024-12-27 10:00:00",
      "updated_at": "2024-12-27 10:00:00"
    }
  }
}

{
  "success": false,
  "message": "Kitap bulunamadı",
  "error": "NOT_FOUND"
}

Future<Map<String, dynamic>?> getBook(int id) async {
  final response = await http.get(
    Uri.parse('$booksUrl/$id'),
    headers: {'Accept': 'application/json'},
  );

  final data = jsonDecode(response.body);

  if (data['success'] == true) {
    return data['data']['book'];
  }
  return null;
}

// Kullanım örneği:
void loadBookDetail() async {
  final book = await apiService.getBook(1);
  if (book != null) {
    print('Kitap: ${book['title']}');
    print('Yazar: ${book['author']}');
  }
}

{
  "success": true,
  "message": "Success",
  "data": {
    "query": "dostoyevski",
    "books": [
      {
        "id": 1,
        "title": "Suç ve Ceza",
        "author": "Fyodor Dostoyevski",
        // ... diğer kitap alanları
      },
      {
        "id": 5,
        "title": "Karamazov Kardeşler",
        "author": "Fyodor Dostoyevski",
        // ...
      }
    ],
    "pagination": {
      "current_page": 1,
      "per_page": 20,
      "total_items": 8,
      "total_pages": 1,
      "has_next": false,
      "has_previous": false
    }
  }
}

{
  "success": false,
  "message": "Arama sorgusu en az 2 karakter olmalı",
  "error": "INVALID_QUERY"
}

Future<List<dynamic>> searchBooks({
  required String query,
  int? categoryId,
  int page = 1,
}) async {
  if (query.length < 2) return [];

  final params = {
    'q': query,
    'page': page.toString(),
    if (categoryId != null) 'category_id': categoryId.toString(),
  };

  final uri = Uri.parse('$booksUrl/search')
      .replace(queryParameters: params);

  final response = await http.get(uri);
  final data = jsonDecode(response.body);

  if (data['success'] == true) {
    return data['data']['books'] ?? [];
  }
  return [];
}

// SearchBar ile kullanım örneği:
class BookSearchDelegate extends SearchDelegate {
  final ApiService apiService;

  BookSearchDelegate(this.apiService);

  @override
  Widget buildResults(BuildContext context) {
    return FutureBuilder<List>(
      future: apiService.searchBooks(query: query),
      builder: (context, snapshot) {
        if (!snapshot.hasData) {
          return Center(child: CircularProgressIndicator());
        }
        return ListView.builder(
          itemCount: snapshot.data!.length,
          itemBuilder: (ctx, i) => ListTile(
            title: Text(snapshot.data![i]['title']),
            subtitle: Text(snapshot.data![i]['author']),
          ),
        );
      },
    );
  }
}

Future<Map<String, dynamic>?> createBook({
  required String title,
  required String author,
  String? isbn,
  String? publisher,
  int? publishYear,
  int? pageCount,
  String? language,
  int? categoryId,
  int? shelfId,
  int quantity = 1,
  double? price,
  String? description,
}) async {
  final response = await http.post(
    Uri.parse(booksUrl),
    headers: await _headers(),
    body: jsonEncode({
      'title': title,
      'author': author,
      if (isbn != null) 'isbn': isbn,
      if (publisher != null) 'publisher': publisher,
      if (publishYear != null) 'publish_year': publishYear,
      if (pageCount != null) 'page_count': pageCount,
      if (language != null) 'language': language,
      if (categoryId != null) 'category_id': categoryId,
      if (shelfId != null) 'shelf_id': shelfId,
      'quantity': quantity,
      if (price != null) 'price': price,
      if (description != null) 'description': description,
    }),
  );

  final data = jsonDecode(response.body);

  if (data['success'] == true) {
    return data['data']['book'];
  }

  // Hata durumunda
  throw Exception(data['message'] ?? 'Kitap eklenemedi');
}

// Kullanım örneği:
void addNewBook() async {
  try {
    final book = await apiService.createBook(
      title: 'Yeni Kitap',
      author: 'Yazar Adı',
      isbn: '978-605-123-456-7',
      categoryId: 2,
      quantity: 3,
    );
    print('Kitap eklendi: ${book?['id']}');
  } catch (e) {
    print('Hata: $e');
  }
}

{
  "success": true,
  "message": "Kitap başarıyla eklendi",
  "data": {
    "book": {
      "id": 25,
      "title": "Sefiller",
      // ... tüm kitap verileri
    }
  }
}

{
  "success": false,
  "message": "Validation failed",
  "error": "VALIDATION_ERROR",
  "errors": {
    "title": "Kitap adı zorunludur.",
    "author": "Yazar adı zorunludur."
  }
}

{
  "success": true,
  "message": "Kitap başarıyla güncellendi",
  "data": {
    "book": {
      "id": 1,
      "title": "Güncellenmiş Kitap Adı",
      "status": "borrowed",
      // ... güncellenmiş kitap verileri
    }
  }
}

{
  "success": false,
  "message": "Kitap bulunamadı",
  "error": "NOT_FOUND"
}

Future<Map<String, dynamic>?> updateBook({
  required int id,
  String? title,
  String? author,
  String? status,
  int? quantity,
  int? availableQuantity,
  int? categoryId,
  int? shelfId,
}) async {
  final data = <String, dynamic>{};

  // Sadece değer verilen alanları ekle
  if (title != null) data['title'] = title;
  if (author != null) data['author'] = author;
  if (status != null) data['status'] = status;
  if (quantity != null) data['quantity'] = quantity;
  if (availableQuantity != null) data['available_quantity'] = availableQuantity;
  if (categoryId != null) data['category_id'] = categoryId;
  if (shelfId != null) data['shelf_id'] = shelfId;

  final response = await http.put(
    Uri.parse('$booksUrl/$id'),
    headers: await _headers(),
    body: jsonEncode(data),
  );

  final result = jsonDecode(response.body);
  return result['success'] == true ? result['data']['book'] : null;
}

// Kullanım: Kitap durumunu güncelle
await apiService.updateBook(
  id: 1,
  status: 'borrowed',
  availableQuantity: 1,
);

{
  "success": true,
  "message": "Kitap başarıyla silindi"
}

{
  "success": false,
  "message": "Bu işlem için giriş yapmalısınız",
  "error": "UNAUTHORIZED"
}

{
  "success": false,
  "message": "Kitap bulunamadı",
  "error": "NOT_FOUND"
}

Future<bool> deleteBook(int id) async {
  final response = await http.delete(
    Uri.parse('$booksUrl/$id'),
    headers: await _headers(),
  );

  final data = jsonDecode(response.body);
  return data['success'] == true;
}

// Dialog ile onaylama örneği:
void confirmDelete(BuildContext context, int bookId, String bookTitle) {
  showDialog(
    context: context,
    builder: (ctx) => AlertDialog(
      title: Text('Kitabı Sil'),
      content: Text('$bookTitle kitabını silmek istediğinize emin misiniz?'),
      actions: [
        TextButton(
          onPressed: () => Navigator.pop(ctx),
          child: Text('İptal'),
        ),
        ElevatedButton(
          onPressed: () async {
            final success = await apiService.deleteBook(bookId);
            Navigator.pop(ctx);
            if (success) {
              ScaffoldMessenger.of(context).showSnackBar(
                SnackBar(content: Text('Kitap silindi')),
              );
            }
          },
          style: ElevatedButton.styleFrom(backgroundColor: Colors.red),
          child: Text('Sil'),
        ),
      ],
    ),
  );
}

// Kategori Model sınıfı
class Category {
  final int id;
  final String name;
  final String slug;
  final String? description;
  final String? color;
  final String? icon;
  final int bookCount;

  Category.fromJson(Map<String, dynamic> json)
      : id = json['id'],
        name = json['name'],
        slug = json['slug'],
        description = json['description'],
        color = json['color'],
        icon = json['icon'],
        bookCount = json['book_count'] ?? 0;
}

// API Service metodu
Future<List<Category>> getCategories() async {
  final response = await http.get(
    Uri.parse('$booksUrl/categories'),
    headers: {'Accept': 'application/json'},
  );

  final data = jsonDecode(response.body);

  if (data['success'] == true) {
    return (data['data']['categories'] as List)
        .map((c) => Category.fromJson(c))
        .toList();
  }
  return [];
}

// Dropdown Widget örneği
Widget buildCategoryDropdown(List<Category> categories, Category? selected, Function(Category?) onChanged) {
  return DropdownButtonFormField<Category>(
    value: selected,
    decoration: InputDecoration(
      labelText: 'Kategori',
      prefixIcon: Icon(Icons.category),
    ),
    items: categories.map((cat) => DropdownMenuItem(
      value: cat,
      child: Row(children: [
        Container(
          width: 12, height: 12,
          decoration: BoxDecoration(
            color: Color(int.parse(cat.color?.replaceFirst('#', '0xFF') ?? '0xFF6366f1')),
            borderRadius: BorderRadius.circular(4),
          ),
        ),
        SizedBox(width: 8),
        Text('${cat.name} (${cat.bookCount})'),
      ]),
    )).toList(),
    onChanged: onChanged,
  );
}

// Shelf Model sınıfı
class Shelf {
  final int id;
  final String name;
  final String code;
  final String? location;
  final int? capacity;
  final int bookCount;
  final String status;

  Shelf.fromJson(Map<String, dynamic> json)
      : id = json['id'],
        name = json['name'],
        code = json['code'],
        location = json['location'],
        capacity = json['capacity'],
        bookCount = json['book_count'] ?? 0,
        status = json['status'];

  String get displayName => '$code - $name';
  bool get isActive => status == 'active';
}

// API Service metodu
Future<List<Shelf>> getShelves() async {
  final response = await http.get(
    Uri.parse('$booksUrl/shelves'),
    headers: {'Accept': 'application/json'},
  );

  final data = jsonDecode(response.body);

  if (data['success'] == true) {
    return (data['data']['shelves'] as List)
        .map((s) => Shelf.fromJson(s))
        .toList();
  }
  return [];
}

// Raf listesi Widget'ı
Widget buildShelfList(List<Shelf> shelves) {
  return ListView.builder(
    itemCount: shelves.length,
    itemBuilder: (ctx, i) {
      final shelf = shelves[i];
      final usagePercent = shelf.capacity != null 
          ? (shelf.bookCount / shelf.capacity!) * 100
          : 0.0;
      
      return ListTile(
        leading: CircleAvatar(child: Text(shelf.code)),
        title: Text(shelf.name),
        subtitle: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(shelf.location ?? 'Konum belirtilmemiş'),
            if (shelf.capacity != null)
              LinearProgressIndicator(value: usagePercent / 100),
          ],
        ),
        trailing: Text('${shelf.bookCount} kitap'),
      );
    },
  );
}

// BookStats Model
class BookStats {
  final int totalBooks;
  final int available;
  final int borrowed;
  final int reserved;
  final int damaged;
  final int totalCopies;
  final int availableCopies;

  BookStats.fromJson(Map<String, dynamic> json)
      : totalBooks = json['total_books'] ?? 0,
        available = json['available'] ?? 0,
        borrowed = json['borrowed'] ?? 0,
        reserved = json['reserved'] ?? 0,
        damaged = json['damaged'] ?? 0,
        totalCopies = json['total_copies'] ?? 0,
        availableCopies = json['available_copies'] ?? 0;
}

// API Service metodu
Future<BookStats?> getBookStats() async {
  final response = await http.get(
    Uri.parse('$booksUrl/stats'),
    headers: {'Accept': 'application/json'},
  );

  final data = jsonDecode(response.body);
  if (data['success'] == true) {
    return BookStats.fromJson(data['data']['stats']);
  }
  return null;
}

// Dashboard Stats Widget
Widget buildStatsCards(BookStats stats) {
  return GridView.count(
    crossAxisCount: 2,
    shrinkWrap: true,
    children: [
      _statCard('Toplam Kitap', stats.totalBooks.toString(), Icons.menu_book, Colors.blue),
      _statCard('Mevcut', stats.available.toString(), Icons.check_circle, Colors.green),
      _statCard('Ödünçte', stats.borrowed.toString(), Icons.swap_horiz, Colors.orange),
      _statCard('Rezerve', stats.reserved.toString(), Icons.bookmark, Colors.purple),
    ],
  );
}

Widget _statCard(String label, String value, IconData icon, Color color) {
  return Card(
    child: Padding(
      padding: EdgeInsets.all(16),
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Icon(icon, size: 40, color: color),
          SizedBox(height: 8),
          Text(value, style: TextStyle(fontSize: 28, fontWeight: FontWeight.bold)),
          Text(label, style: TextStyle(color: Colors.grey)),
        ],
      ),
    ),
  );
}

{
  "success": true,
  "message": "Success",
  "data": {
    "persons": [
      {
        "id": 1,
        "member_no": "UYE-2024-001",
        "name": "Ahmet Yılmaz",
        "email": "ahmet@email.com",
        "phone": "05321234567",
        "membership": {
          "type": "standard",
          "start_date": "2024-01-15",
          "end_date": null,
          "is_expired": false
        },
        "borrowing": {
          "max_books": 3,
          "max_days": 15,
          "current_borrowed": 1,
          "total_borrowed": 12,
          "late_returns": 0,
          "can_borrow": true
        },
        "status": "active"
      }
    ],
    "pagination": {
      "current_page": 1,
      "per_page": 15,
      "total": 45,
      "total_pages": 3
    }
  }
}

// Kişileri listele
Future<Map<String, dynamic>> getPersons({
  int page = 1,
  int limit = 15,
  String? search,
  String? status,
}) async {
  final queryParams = {
    'page': page.toString(),
    'limit': limit.toString(),
    if (search != null) 'search': search,
    if (status != null) 'status': status,
  };
  
  final uri = Uri.parse('$baseUrl/api/persons')
    .replace(queryParameters: queryParams);
  
  final response = await http.get(uri);
  return jsonDecode(response.body);
}

// Kişi detayı getir
Future<Map<String, dynamic>> getPerson(int id) async {
  final response = await http.get(
    Uri.parse('$baseUrl/api/persons/$id'),
  );
  return jsonDecode(response.body);
}

// Kişi ara
Future<List> searchPersons(String query) async {
  final response = await http.get(
    Uri.parse('$baseUrl/api/persons/search?q=$query'),
  );
  final data = jsonDecode(response.body);
  return data['data']['persons'];
}

// Yeni kişi ekle
Future<Map<String, dynamic>> createPerson({
  required String name,
  String? email,
  String? phone,
  String membershipType = 'standard',
}) async {
  final response = await http.post(
    Uri.parse('$baseUrl/api/persons'),
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer $token',
    },
    body: jsonEncode({
      'name': name,
      if (email != null) 'email': email,
      if (phone != null) 'phone': phone,
      'membership_type': membershipType,
    }),
  );
  return jsonDecode(response.body);
}

{
  "success": true,
  "data": {
    "borrowings": [
      {
        "id": 1,
        "book": {
          "id": 5,
          "title": "Sefiller",
          "author": "Victor Hugo"
        },
        "person": {
          "id": 1,
          "name": "Ahmet Yılmaz",
          "member_no": "UYE-2024-001",
          "phone": "05321234567"
        },
        "dates": {
          "borrow_date": "2024-01-10",
          "due_date": "2024-01-25",
          "return_date": null
        },
        "status": "borrowed",
        "is_overdue": false,
        "days_left": 5,
        "extend_count": 0
      }
    ],
    "pagination": { ... }
  }
}

// Ödünç listesi
Future<Map<String, dynamic>> getBorrowings({
  int page = 1,
  String? status,
}) async {
  final queryParams = {
    'page': page.toString(),
    if (status != null) 'status': status,
  };
  
  final uri = Uri.parse('$baseUrl/api/borrowings')
    .replace(queryParameters: queryParams);
  
  final response = await http.get(uri);
  return jsonDecode(response.body);
}

// Kitap ödünç ver
Future<Map<String, dynamic>> borrowBook({
  required int bookId,
  required int personId,
  String? notes,
}) async {
  final response = await http.post(
    Uri.parse('$baseUrl/api/borrowings'),
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer $token',
    },
    body: jsonEncode({
      'book_id': bookId,
      'person_id': personId,
      if (notes != null) 'notes': notes,
    }),
  );
  return jsonDecode(response.body);
}

// Kitap iade al
Future<Map<String, dynamic>> returnBook(int borrowingId) async {
  final response = await http.post(
    Uri.parse('$baseUrl/api/borrowings/$borrowingId/return'),
    headers: {
      'Authorization': 'Bearer $token',
    },
  );
  return jsonDecode(response.body);
}

// Süre uzat
Future<Map<String, dynamic>> extendBorrowing(
  int borrowingId,
  {int days = 7}
) async {
  final response = await http.post(
    Uri.parse('$baseUrl/api/borrowings/$borrowingId/extend'),
    headers: {
      'Content-Type': 'application/json',
      'Authorization': 'Bearer $token',
    },
    body: jsonEncode({'days': days}),
  );
  return jsonDecode(response.body);
}