4
respostas

[Projeto] [Desafio3] AlertDialog e Persistência dos levels by Gabriel

Na classe TaskDao incluí as colunas faltantes no banco e atualizei a classe:

static const String tableSql = '''
                                  CREATE TABLE $_tableName(
                                    $_id TEXT NOT NULL,
                                    $_name TEXT,
                                    $_difficulty INTEGER,
                                    $_image TEXT,
                                    $_taskLevel INTEGER,
                                    $_taskProgressLevel INTEGER,
                                    $_taskProgressIndicatorValue REAL,
                                    PRIMARY KEY($_id)
                                  );
                                  ''';
    static const String _taskLevel = 'level';
    static const String _taskProgressLevel = 'progress_level';
    static const String _taskProgressIndicatorValue = 'progress_indcator_value';

    List<Task> toList(List<Map<String, dynamic>> tasksMap) {
    final List<Task> tasks = [];
    for (Map<String, dynamic> row in tasksMap) {
      final Task task = Task(
        id: row[_id],
        name: row[_name],
        image: row[_image],
        difficulty: row[_difficulty],
        taskLevel: row[_taskLevel],
        progressLevel: row[_taskProgressLevel],
        progressIndicatorValue: row[_taskProgressIndicatorValue],
      );
      tasks.add(task);
    }
    return tasks;
  }
    Map<String, dynamic> toMap(Task task) {
    return {
      _id: task.id,
      _name: task.name,
      _image: task.image,
      _difficulty: task.difficulty,
      _taskLevel: task.taskLevel,
      _taskProgressLevel: task.progressLevel,
      _taskProgressIndicatorValue: task.progressIndicatorValue,
    };
  }

Atualizei a Task nas variáveis de progresso, removendo a inicialização dos valores, obrigando a serem inicializados na construção e os métodos de calculo de progresso para manipular o banco:

  Future calculateProgress() async {
    if (isNotMaxProgress()) {
      widget.taskLevel++;
      await TaskDao().save(widget);
      setState(() {});
    }
    if (isTimeToLevelUpProgress()) {
      await progressLevelUp();
    } else {
      await updateProgress();
    }
  }

  bool isNotMaxProgress() {
    return widget.progressLevel <= 6 && widget.progressIndicatorValue < 1;
  }

  bool isTimeToLevelUpProgress() {
    return widget.progressIndicatorValue.compareTo(1) == 0 &&
        widget.progressLevel <= 5;
  }

  Future progressLevelUp() async {
    widget.progressIndicatorValue = 0;
    widget.taskLevel = 0;
    widget.progressLevel++;
    await TaskDao().save(widget);
    setState(() {});
  }

  Future updateProgress() async {
    if (widget.difficulty <= 0) {
      widget.progressIndicatorValue = 1;
      await TaskDao().save(widget);
      setState(() {});
    } else if (widget.progressIndicatorValue < 1) {
      widget.progressIndicatorValue =
          (widget.taskLevel / widget.difficulty) / 10;
      await TaskDao().save(widget);
      setState(() {});
    }
  }
}

continuarei na resposta do post....

4 respostas

Continuando....

Ainda na classe Task incluí o alerta no botão de level up :

ElevatedButton(
                          onLongPress: () {
                            showDialog(
                              context: context,
                              builder: (context) {
                                return AlertDialog(
                                  title: const Text('Deletar a tarefa'),
                                  content: const Text(
                                      "Tem certeza que deseja deletar a tarefa?"),
                                  actions: [
                                    TextButton(
                                        onPressed: (() {
                                          Navigator.pop(context);
                                        }),
                                        child: const Text('Não')),
                                    TextButton(
                                        onPressed: () {
                                          TaskDao().delete(widget.id);
                                          Navigator.pop(context);
                                        },
                                        child: const Text('Sim')),
                                  ],
                                );
                              },
                            );
                          },

No FormView incluí as novas colunas:

ElevatedButton(
                      onPressed: () {
                        if (_formKey.currentState!.validate()) {
                          TaskDao().save(Task(
                            id: const Uuid().v4(),
                            name: nameController.text,
                            image: imageController.text,
                            difficulty: int.parse(difficultyController.text),
                            taskLevel: 0,
                            progressLevel: 0,
                            progressIndicatorValue: 0.0,
                          ));

No TaskView eu arrumei o método que atualiza o progresso global utilizando o TaskDao ao invés do TaskInherited:

 Future calculateGlobalProgress() async {
    final tasks = await TaskDao().findAll();
    if (tasks.isNotEmpty) {
      final taskListSize = tasks.length;
      widget.globalLevel = tasks.fold(
        0,
        (previousValue, task) => task.progressLevel + previousValue,
      );

      for (var level = 1; level <= 7; level++) {
        if (isTimeToUpgradeGlobalProgress(
          taskListSize: taskListSize,
          level: level,
        )) {
          widget.globalProgressLevel = level;
          break;
        }
      }

      setState(() {
        widget.globalLevel;
        widget.globalProgressIndicatorValue =
            widget.globalLevel / (taskListSize * 7);
      });
    } else {
      setState(() {
        widget.globalLevel = 0;
        widget.globalProgressLevel = 0;
        widget.globalProgressIndicatorValue = 0.0;
      });
    }
  }

  bool isTimeToUpgradeGlobalProgress({
    required int taskListSize,
    required int level,
  }) {
    return widget.globalProgressLevel < level &&
        widget.globalLevel >= (taskListSize * level);
  }
}

O link do repositório: https://github.com/blandygbc/tasks_flutter_alura

vídeo com a demonstração: https://drive.google.com/file/d/1IVtW54ttJXQqrHSqih0HVutuqJRifDtt/view

Olá Gabriel!

Desculpa a demora. Muito obrigado por compartilhar o seu código com a gente. Eu estou respondendo esse tópico para organizar o fórum de Flutter. Valeu.

Parece que você atualizou a classe TaskDao e a classe Task para lidar com a persistência de dados no Flutter. É ótimo ver que você avançou no desenvolvimento do seu projeto!

Ao analisar o código que você compartilhou, percebo que você incluiu as colunas faltantes na tabela do banco de dados na classe TaskDao. Além disso, você atualizou a classe Task para manipular corretamente os valores de progresso e nível.

No método toList, você está convertendo as linhas do banco de dados em objetos Task. Isso é muito útil para recuperar os dados salvos e exibi-los na interface do usuário.

Já no método toMap, você está convertendo um objeto Task em um mapa de valores para salvar no banco de dados. Isso permite que você armazene os dados atualizados do objeto.

No código atualizado da classe Task, você implementou métodos para calcular o progresso e atualizar os valores no banco de dados. É importante notar que você está usando o método save da classe TaskDao para salvar as alterações no banco de dados.

No método calculateProgress, você está verificando se o progresso não atingiu o máximo e, em seguida, incrementando o nível da tarefa e salvando as alterações. Se for hora de subir de nível, você chama o método progressLevelUp, caso contrário, chama o método updateProgress.

No método progressLevelUp, você redefine os valores de progresso, incrementa o nível de progresso e salva as alterações no banco de dados.

No método updateProgress, você atualiza o valor do indicador de progresso com base na dificuldade da tarefa. Se a dificuldade for menor ou igual a zero, o indicador de progresso é definido como 1. Caso contrário, o indicador de progresso é calculado com base no nível da tarefa e na dificuldade.

Continue trabalhando nesse código e testando-o para garantir que as alterações estejam funcionando corretamente. Se surgirem mais dúvidas ou se precisar de mais ajuda, estou aqui para ajudar!

Espero ter ajudado e bons estudos!

Isso mesmo! Obrigado pela resposta.