Application de Gestion de Notes Multi-Plateforme

name: notes_app
description: A multi-platform note management application

version: 1.0.0+1

environment:
  sdk: '>=3.0.0 <4.0.0'

dependencies:
  flutter:
    sdk: flutter
  cupertino_icons: ^1.0.2
  http: ^1.1.0
  shared_preferences: ^2.2.2
  flutter_markdown: ^0.6.15
  hive: ^2.2.3
  hive_flutter: ^1.1.0
  path_provider: ^2.0.15
  provider: ^6.0.5
  pull_to_refresh: ^2.0.0
  connectivity_plus: ^4.0.2
  intl: ^0.18.1

dev_dependencies:
  flutter_test:
    sdk: flutter
  hive_generator: ^1.1.3
  build_runner: ^2.4.6

flutter:
  uses-material-design: true
  assets:
    - assets/

import 'package:flutter/foundation.dart';
import '../models/note.dart';
import '../services/api_service.dart';
import '../services/local_db_service.dart';
import '../utils/network_utils.dart';

class NotesProvider with ChangeNotifier {
  final ApiService _apiService = ApiService();
  final LocalDbService _localDbService = LocalDbService();
  
  List _notes = [];
  bool _isLoading = false;
  String _error = '';
  bool _isOffline = false;
  
  List get notes => _notes;
  bool get isLoading => _isLoading;
  String get error => _error;
  bool get isOffline => _isOffline;
  
  NotesProvider() {
    _checkConnectivity();
    loadNotes();
  }
  
  Future _checkConnectivity() async {
    _isOffline = !(await NetworkUtils.isConnected());
    notifyListeners();
  }
  
  Future loadNotes() async {
    _isLoading = true;
    notifyListeners();
    
    try {
      if (await NetworkUtils.isConnected()) {
        // Online: fetch from API
        _notes = await _apiService.getNotes();
        // Save to local DB
        for (final note in _notes) {
          await _localDbService.saveNote(note);
        }
        _isOffline = false;
      } else {
        // Offline: load from local DB
        _notes = await _localDbService.getNotes();
        _isOffline = true;
      }
      _error = '';
    } catch (e) {
      _error = e.toString();
      // Fallback to local DB if online fetch fails
      _notes = await _localDbService.getNotes();
    }
    
    _isLoading = false;
    notifyListeners();
  }
  
  Future refreshNotes() async {
    await loadNotes();
  }
  
  Future createNote(Note note) async {
    try {
      Note createdNote;
      
      if (await NetworkUtils.isConnected()) {
        // Online: create via API
        createdNote = await _apiService.createNote(note);
        await _localDbService.saveNote(createdNote);
      } else {
        // Offline: save locally and queue operation
        final localId = DateTime.now().millisecondsSinceEpoch.toString();
        final localNote = note.copyWith(
          id: '', // Will be assigned by server later
          isSynced: false,
          localId: localId,
        );
        await _localDbService.saveNote(localNote);
        await _localDbService.addPendingOperation(
          'create',
          note.toJson(),
        );
        createdNote = localNote;
        _isOffline = true;
      }
      
      _notes.insert(0, createdNote);
      notifyListeners();
      return createdNote;
    } catch (e) {
      _error = e.toString();
      notifyListeners();
      rethrow;
    }
  }
  
  Future updateNote(Note note) async {
    try {
      Note updatedNote;
      
      if (await NetworkUtils.isConnected()) {
        // Online: update via API
        updatedNote = await _apiService.updateNote(note);
        await _localDbService.saveNote(updatedNote);
      } else {
        // Offline: update locally and queue operation
        final localNote = note.copyWith(isSynced: false);
        await _localDbService.saveNote(localNote);
        await _localDbService.addPendingOperation(
          'update',
          note.toJson(),
        );
        updatedNote = localNote;
        _isOffline = true;
      }
      
      final index = _notes.indexWhere((n) => n.id == note.id);
      if (index != -1) {
        _notes[index] = updatedNote;
      }
      notifyListeners();
      return updatedNote;
    } catch (e) {
      _error = e.toString();
      notifyListeners();
      rethrow;
    }
  }
  
  Future deleteNote(String id) async {
    try {
      final note = _notes.firstWhere((n) => n.id == id);
      
      if (await NetworkUtils.isConnected()) {
        // Online: delete via API
        await _apiService.deleteNote(id);
        await _localDbService.deleteNote(id);
      } else {
        // Offline: mark for deletion and queue operation
        await _localDbService.addPendingOperation(
          'delete',
          {'id': id},
        );
        _isOffline = true;
      }
      
      _notes.removeWhere((n) => n.id == id);
      notifyListeners();
    } catch (e) {
      _error = e.toString();
      notifyListeners();
      rethrow;
    }
  }
  
  List searchNotes(String query) {
    if (query.isEmpty) return _notes;
    
    return _notes.where((note) {
      return note.title.toLowerCase().contains(query.toLowerCase()) ||
          note.contentMd.toLowerCase().contains(query.toLowerCase());
    }).toList();
  }
  
  List filterNotesByTag(String tagLabel) {
    return _notes.where((note) {
      return note.tags.any((tag) => tag.label == tagLabel);
    }).toList();
  }
}

import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import '../../providers/auth_provider.dart';

class LoginScreen extends StatefulWidget {
  const LoginScreen({Key? key}) : super(key: key);

  @override
  _LoginScreenState createState() => _LoginScreenState();
}

class _LoginScreenState extends State {
  final _formKey = GlobalKey();
  final _emailController = TextEditingController();
  final _passwordController = TextEditingController();
  bool _isLoading = false;

  Future _login() async {
    if (!_formKey.currentState!.validate()) return;

    setState(() => _isLoading = true);
    
    try {
      await Provider.of(context, listen: false).login(
        _emailController.text,
        _passwordController.text,
      );
      
      // Navigate to notes list on success
      Navigator.pushReplacementNamed(context, '/notes');
    } catch (e) {
      ScaffoldMessenger.of(context).showSnackBar(
        SnackBar(content: Text('Login failed: $e')),
      );
    }
    
    setState(() => _isLoading = false);
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(title: const Text('Login')),
      body: Padding(
        padding: const EdgeInsets.all(16.0),
        child: Form(
          key: _formKey,
          child: Column(
            children: [
              TextFormField(
                controller: _emailController,
                decoration: const InputDecoration(labelText: 'Email'),
                keyboardType: TextInputType.emailAddress,
                validator: (value) {
                  if (value == null || value.isEmpty) {
                    return 'Please enter your email';
                  }
                  return null;
                },
              ),
              TextFormField(
                controller: _passwordController,
                decoration: const InputDecoration(labelText: 'Password'),
                obscureText: true,
                validator: (value) {
                  if (value == null || value.isEmpty) {
                    return 'Please enter your password';
                  }
                  return null;
                },
              ),
              const SizedBox(height: 20),
              _isLoading
                  ? const CircularProgressIndicator()
                  : ElevatedButton(
                      onPressed: _login,
                      child: const Text('Login'),
                    ),
              TextButton(
                onPressed: () {
                  Navigator.pushNamed(context, '/register');
                },
                child: const Text('Create an account'),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

import 'package:flutter/material.dart';
import 'package:provider/provider.dart';
import 'package:pull_to_refresh/pull_to_refresh.dart';
import '../../providers/notes_provider.dart';
import '../../widgets/note_card.dart';
import '../../widgets/offline_indicator.dart';
import '../../widgets/search_bar.dart';

class NotesListScreen extends StatefulWidget {
  const NotesListScreen({Key? key}) : super(key: key);

  @override
  _NotesListScreenState createState() => _NotesListScreenState();
}

class _NotesListScreenState extends State {
  final RefreshController _refreshController = RefreshController();
  String _searchQuery = '';

  @override
  void initState() {
    super.initState();
    WidgetsBinding.instance.addPostFrameCallback((_) {
      Provider.of(context, listen: false).loadNotes();
    });
  }

  Future _onRefresh() async {
    try {
      await Provider.of(context, listen: false).refreshNotes();
      _refreshController.refreshCompleted();
    } catch (e) {
      _refreshController.refreshFailed();
    }
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('My Notes'),
        actions: [
          IconButton(
            icon: const Icon(Icons.add),
            onPressed: () {
              Navigator.pushNamed(context, '/edit-note');
            },
          ),
        ],
      ),
      body: Consumer(
        builder: (context, notesProvider, child) {
          final notes = _searchQuery.isEmpty
              ? notesProvider.notes
              : notesProvider.searchNotes(_searchQuery);
          
          return Column(
            children: [
              const OfflineIndicator(),
              SearchBar(
                onSearch: (query) {
                  setState(() => _searchQuery = query);
                },
              ),
              Expanded(
                child: SmartRefresher(
                  controller: _refreshController,
                  onRefresh: _onRefresh,
                  child: notesProvider.isLoading
                      ? const Center(child: CircularProgressIndicator())
                      : notes.isEmpty
                          ? const Center(child: Text('No notes found'))
                          : ListView.builder(
                              itemCount: notes.length,
                              itemBuilder: (context, index) {
                                final note = notes[index];
                                return NoteCard(
                                  note: note,
                                  onTap: () {
                                    Navigator.pushNamed(
                                      context,
                                      '/note-detail',
                                      arguments: note.id,
                                    );
                                  },
                                );
                              },
                            ),
                ),
              ),
            ],
          );
        },
      ),
    );
  }
}

import 'package:flutter/material.dart';
import '../models/note.dart';
import 'tag_chip.dart';

class NoteCard extends StatelessWidget {
  final Note note;
  final VoidCallback onTap;

  const NoteCard({
    Key? key,
    required this.note,
    required this.onTap,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Card(
      margin: const EdgeInsets.symmetric(horizontal: 8, vertical: 4),
      child: ListTile(
        onTap: onTap,
        title: Text(
          note.title,
          maxLines: 1,
          overflow: TextOverflow.ellipsis,
        ),
        subtitle: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Text(
              note.contentMd,
              maxLines: 2,
              overflow: TextOverflow.ellipsis,
            ),
            if (note.tags.isNotEmpty) ...[
              const SizedBox(height: 4),
              Wrap(
                spacing: 4,
                children: note.tags
                    .map((tag) => TagChip(label: tag.label))
                    .toList(),
              ),
            ],
          ],
        ),
        trailing: !note.isSynced
            ? const Icon(Icons.sync_disabled, size: 16)
            : null,
      ),
    );
  }
}

import 'package:flutter/material.dart';
import 'package:flutter_markdown/flutter_markdown.dart';

class MarkdownPreview extends StatelessWidget {
  final String text;

  const MarkdownPreview({Key? key, required this.text}) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return Markdown(
      data: text,
      styleSheet: MarkdownStyleSheet(
        p: const TextStyle(fontSize: 16, height: 1.5),
        h1: const TextStyle(fontSize: 24, fontWeight: FontWeight.bold),
        h2: const TextStyle(fontSize: 22, fontWeight: FontWeight.bold),
        h3: const TextStyle(fontSize: 20, fontWeight: FontWeight.bold),
      ),
    );
  }
}