1
resposta

Atividade destinatario autenticado

import 'controllers/bank_controller.dart';
import 'exceptions/bank_controller_exceptions.dart';
import 'models/account.dart';

void main() {
  // Criando o banco
  BankController bankController = BankController();

  // Adicionando contas
  bankController.addAccount(
      id: "Ricarth",
      account:
          Account(name: "Ricarth Lima", balance: 400, isAuthenticated: true));


  bankController.addAccount(

  id: "Kako",
  account:
  Account(name: "Caio Couto", balance: 600, isAuthenticated: true));



  // Fazendo transferência
  try{
    bool result = bankController.makeTransfer(
      idSender: "Kako", idReceiver: "Ricarth", amount: 90);
  if (result){
    print("The transaction was sucessful!");
  }
    // Observando resultado
    print(result);
  } on SenderIdInvalidException catch (e){
    print(e);
    print( "The ID '${e.idSender}' is not valid.");
  } on ReceiverIdInvalidException catch (e){
    print(e);
    print("The receiver ID '${e.idReceiver}' is not valid.");
  } on SenderNotAuthenticatedException catch (e){
    print(e);
    print("Sorry! The account '${e.idSender}'is not authenticated.");
  } on SenderBalanceLowerThanAmountException catch (e){
    print(e);
    print("Your balance is not enough you need ${e.amount - e.senderBalance}.");
  }on ReceiverNotAuthenticatedException catch (e){
    print(e);
    print("Sorry! The receiver account '${e.idReceiver}' is not authenticated.");
  }



}
import '../exceptions/bank_controller_exceptions.dart';
import '../models/account.dart';

class BankController {
  final Map<String, Account> _database = {};

  addAccount({required String id, required Account account}) {
    _database[id] = account;
  }

  bool makeTransfer(
      {required String idSender,
      required String idReceiver,
      required double amount}) {
    // Verificar se ID de remetente é válido
    if (!verifyId(idSender)) {
      throw SenderIdInvalidException(idSender: idSender);
    }

    // Verificar se ID de destinatário é válido
    if (!verifyId(idReceiver)) {
     throw ReceiverIdInvalidException(idReceiver: idReceiver);
    }

    Account accountSender = _database[idSender]!;
    Account accountReceiver = _database[idReceiver]!;

    // Verificar se o remetente está autenticado
    if (!accountSender.isAuthenticated) {
      throw SenderNotAuthenticatedException(idSender: idSender);
    }

    //Verificar se o destinatario esta autenticado
    if (!accountReceiver.isAuthenticated) {
      throw ReceiverNotAuthenticatedException(idReceiver: idReceiver);
    }

    // Verificar se o remetente possui saldo suficiente
    if (accountSender.balance < amount) {
      throw SenderBalanceLowerThanAmountException(amount: amount, senderBalance: accountSender.balance);
    }

    // Se tudo estiver certo, efetivar transação
    accountSender.balance -= amount;
    accountReceiver.balance += amount;

    return true;


  }

  bool verifyId(String id) {
    return _database.containsKey(id);
  }
}
class SenderIdInvalidException implements Exception{
  static const report = "SenderIdInvalidException";
  String idSender;
  SenderIdInvalidException({required this.idSender});

  @override
  String toString() {
    return "${report}\nID sender: ${idSender}";
}
}
class ReceiverIdInvalidException implements Exception{
  static const String report = "ReceiverIdInvalidException";
  String idReceiver;
  ReceiverIdInvalidException({required this.idReceiver});

  @override
  String toString(){
    return "${report}\nID Receiver: ${idReceiver}";
  }
}
class SenderNotAuthenticatedException implements Exception{
  static const String report = "SenderNotAuthenticatedException";
  String idSender;
  SenderNotAuthenticatedException({required this.idSender});

  @override
  String toString(){
    return "${report}\n${idSender}";
  }
}
class SenderBalanceLowerThanAmountException implements Exception{
  static const String report = "SenderBalanceLowerThanAmountException";
  num amount;
  num senderBalance;
  SenderBalanceLowerThanAmountException({required this.amount, required this.senderBalance});

  @override
  String toString(){
    return "${report}\nSend: ${amount}\nSender Balance: ${senderBalance}\n";
  }
}

class ReceiverNotAuthenticatedException implements Exception{
  static const String report = "ReceiverNotAuthenticatedException";
  String idReceiver;
  ReceiverNotAuthenticatedException({required this.idReceiver});

  @override
  String toString(){
    return "${report}\n${idReceiver}";
  }
}
1 resposta

Oi Wesley, tudo bem?

Parabéns pelo excelente trabalho na atividade! Você demonstrou um bom entendimento sobre o uso de exceções para lidar com situações específicas e melhorar a legibilidade e tratamento de erros no seu código.

Alguns pontos para destacar em relação ao seu trabalho:

  1. Organização do Código: É ótimo ver como você organizou seu código, dividindo-o em classes distintas para cada exceção e mantendo uma estrutura clara para cada função. Isso torna o código mais fácil de ler e entender.

  2. Uso de Exceções Personalizadas: A criação de exceções personalizadas, como ReceiverNotAuthenticatedException, é uma prática importante para fornecer informações específicas sobre o tipo de erro que ocorreu. Isso é muito útil para depuração e tratamento de exceções de forma mais granular.

  3. Lançamento de Exceções: Você lançou as exceções nos momentos apropriados, ou seja, quando o destinatário não está autenticado e quando o ID do destinatário é inválido. Isso ajuda a garantir que a transação não seja executada se alguma dessas condições for atendida.

  4. Tratamento de Exceções: No bloco try do seu código principal, você capturou as exceções corretamente, mostrando mensagens amigáveis ao usuário e exibindo informações relevantes sobre a exceção que ocorreu. Isso é muito importante para que o usuário compreenda o motivo do erro.

  5. Validação de Dados: Além de verificar a autenticação do destinatário, você também validou se o ID do destinatário é válido antes de prosseguir com a transação. Isso garante que o código funcione de forma segura e previne erros desnecessários.

Continue aplicando essas boas práticas em suas atividades e projetos futuros. Seu trabalho demonstra habilidades sólidas em programação e entendimento das exceções em Dart. Continue praticando e expandindo seus conhecimentos em desenvolvimento de software.

Mais uma vez: excelente trabalho! Obrigada por compartilhar com a gente!

Um abraço e bons estudos.