Faça um diagrama de caso de uso e de classes para cada um dos casos abaixo:
Uma agência de viagens vende passagens, estadias em hotéis. Passeios e pacotes que podem agregar todos os anteriores. Os hotéis podem ter 3 categorias diferentes, o que define o preço de sua diária. Os hotéis e as passagens precisam de reservas. Todos os preços são dependentes da época da viagem e as passagens aéreas podem ser pagas a prazo. Defina um sistema capaz de montar pacotes e gerar relatórios de preços.

Passo 1

O enunciado pede que eu faça um diagrama de caso de uso e um diagrama de classes para o sistema descrito. Vou listar claramente o que o enunciado dá e o que é solicitado, sem resolver nada ainda:
  • O que o enunciado dá (informações relevantes):
    • A agência vende: passagens, estadias em hotéis, passeios e pacotes que podem agregar os itens anteriores.
    • Hotéis podem ter três categorias diferentes, e a categoria define o preço da diária.
    • Hotéis e passagens precisam de reservas.
    • Todos os preços dependem da época da viagem (sazonalidade).
    • Passagens aéreas podem ser pagas a prazo (parcelamento).
    • O sistema deve ser capaz de montar pacotes e gerar relatórios de preços.
  • O que o enunciado pede:
    • Um diagrama de caso de uso que represente os atores e as funcionalidades (casos de uso) principais do sistema.
    • Um diagrama de classes que modele as entidades, atributos, operações e relações necessárias para implementar o sistema descrito.
    • Não há restrição adicional; devo decidir modelagem detalhada para suportar reservas, sazonalidade de preços, parcelamento, montagem de pacotes e relatórios.

Passo 2

Rápida explicação didática sobre o diagrama de caso de uso (o que é e por que usar):
  • Um diagrama de caso de uso mostra quem usa o sistema (atores) e o que o sistema oferece (casos de uso).
  • Ator é qualquer entidade externa ao sistema que interage com ele (por exemplo: cliente, atendente/agente, sistemas externos).
  • Caso de uso é uma funcionalidade observável pelo ator (por exemplo: “Reservar passagem”, “Montar pacote”).
  • Relacionamentos importantes:
    • Associação: ligação ator ↔ caso de uso.
    • Include: quando um caso de uso sempre chama outro (reutilização).
    • Extend: quando um caso de uso opcional/condicional estende outro.
  • Por que aqui: o diagrama ajuda a visualizar requisitos funcionais essenciais (reservas, pagamentos, montagem de pacotes, relatórios).

Passo 3

Definição dos atores relevantes para o problema (lista e justificativa curta para cada um):
  • Cliente — usuário final que compra passagens, hotéis, passeios e pacotes.
  • Agente\_de\_Vendas — funcionário da agência que pode montar pacotes, confirmar reservas e emitir relatórios.
  • Sistema\_Externo\_Aéreoé — sistema da companhia aérea para verificar disponibilidade e confirmar reserva de voo.
  • Sistema\_Externo\_Hotel — sistema do hotel (ou central de reservas) para verificar disponibilidade e confirmar reserva de quarto.
  • Gateway\_de\_Pagamento — serviço externo para processar pagamentos e parcelamentos.
  • Administrador — usuário que ajusta políticas (sazonalidade, preços base, categorias de hotel) e visualiza relatórios administrativos.

Passo 4

Lista de casos de uso principais (com pequena descrição de cada um):
  • Pesquisar\_Produtos: cliente/agent pesquisa passagens, hotéis, passeios.
  • Visualizar\_Preçoç: obter preço de um produto numa data/época (considera sazonalidade e categoria de hotel).
  • Reservar\_Passagem: reservar voo (integra com Sistema\_Externo\_Aéreoé).
  • Reservar\_Hotel: reservar diária de hotel (integra com Sistema\_Externo\_Hotel).
  • Reservar\_Passeio: reservar passeio/tour local.
  • Montar\_Pacote: combinar passagens + hotel + passeios em um pacote.
  • Calcular\_Preço\_Pacoteç: sumarizar preços dos itens e aplicar descontos/políticas.
  • Efetuar\_Pagamento: pagar serviço (suporta pagamento à vista e parcelado via Gateway\_de\_Pagamento).
  • Emitir\_Confirmaçãoçã: gerar confirmações e documentos de reserva.
  • Gerar\_Relatório\_Preçosóç: relatórios de preços históricos/projeções por época e produto.
  • Gerenciar\_Políticasí: administrador define sazonalidade, multiplicadores de preço por categoria de hotel, regras de desconto.

Passo 5

Relacionamentos importantes entre casos de uso (decisões de modelagem):
  • Visualizar\_Preçoç é usado por Pesquisar\_Produtos e por Montar\_Pacote. Como o cálculo de preço é um passo comum e sempre executado, usamos Include:
    • Pesquisar\_Produtos include Visualizar\_Preçoç.
    • Montar\_Pacote include Calcular\_Preço\_Pacoteç e este include Visualizar\_Preçoç para cada item.
  • Reservar\_Passagem include Efetuar\_Pagamento quando a política exige pagamento imediato; mas como o pagamento pode ser opcional/adiado (por ex. pagamento posterior), modelamos Efetuar\_Pagamento como extend em cenários alternativos de pagamento imediato.
  • Reservar\_Hotel include Efetuar\_Pagamento dependendo da política do fornecedor — modelagem análoga.
  • Efetuar\_Pagamento inclui integração com Gateway\_de\_Pagamento.
  • Gerar\_Relatório\_Preçosóç é acionado por Administrador e por Agente\_de\_Vendas.

Passo 6

Como representar textualmente o diagrama de caso de uso (instruções práticas para desenhar):
  • Desenhe um retângulo com a borda do sistema: “Sistema de Agência de Viagens”.
  • Posicione atores fora do retângulo: Cliente, Agente\_de\_Vendas, Administrador, Sistema\_Externo\_Aéreoé, Sistema\_Externo\_Hotel, Gateway\_de\_Pagamento.
  • Liste os casos de uso dentro do retângulo e ligue atores aos casos apropriados com linhas simples.
  • Representar include com seta tracejada e label «include», extend com label «extend».
  • Se quiser, agrupe casos de uso relacionados (pesquisa/consulta, reserva/pagamento, administração/relatórios).

Passo 7

Agora vamos à parte prática: teoria didática sobre diagrama de classes (o que é e conceitos que vou usar):
  • Classe: definição de um conjunto de objetos com atributos (estado) e operações (comportamento).
  • Atributo: campo com tipo (ex.: id: \text{UUID}, nome: \text{String}).
  • Método/Operação: ação que a classe pode executar (ex.: calcularPreco(): \text{Money}).
  • Associação: ligação entre classes; costuma ter multiplicidades (ex.: 1..*, 0..1).
  • Agregação vs Composição:
    • Agregação (loose): todo-parte fraco (ex.: pacote agrega produtos).
    • Composição (forte): parte não existe sem o todo (ex.: itens de reserva podem ser composição do booking).
  • Herança: generalização/especialização (ex.: Produto genérico, Passagem, HotelRoomOffer, Passeio especializações).
  • Interfaces: contratos (ex.: Reservavel com operação reservar()).

Passo 8

Escolha das classes principais do modelo (lista inicial com justificativa sucinta):
  • Cliente — representa usuário comprador.
  • Agente\_de\_Vendas e Administrador — podem ser subtipos de Usuario ou papéis distintos; vou modelar uma classe Usuario com atributo papel.
  • Produto (abstrato) — representa qualquer item comercializável; subclasses: Passagem, Hotel\_Oferta (ou Hotel), Passeio, Pacote.
  • Reserva (abstrato) — especializações: Reserva\_Passagem, Reserva\_Hotel, Reserva\_Passeio. Reserva tem vínculo com Produto correspondente.
  • Pacote — agrega vários Produto ou referências a reservas/propostas.
  • PrecoPolicy ou SeasonalPriceRule — encapsula regras de precificação por época.
  • HotelCategoria — enumeração ou classe com multiplicador de preço.
  • Pagamento — registra pagamentos; suporta parcelamento com subtipo PagamentoParcelado ou atributos parcelas: \mathbb{N}.
  • FornecedorExterno ou Integracao — representa sistemas externos Sistema\_Externo\_Aereo e Sistema\_Externo\_Hotel.
  • Relatorio — classe/facade para gerar relatórios de preços.
  • Booking — entidade que representa o processo de venda/compra que pode conter uma ou mais reservas e pagamentos.

Passo 9

Detalhamento das classes com atributos e métodos (textual; cada nome/atributo em TeX conforme regra). Vai ser didático: explicar o que cada atributo significa e exemplos simples.
  • Classe Usuario
    • Atributos:
      • id: \text{UUID} — identificador único.
      • nome: \text{String}
      • email: \text{String}
      • papel: \text{String} — ex.: Cliente, Agente, Administrador.
    • Métodos:
      • login(email, senha): \text{bool}
      • logout(): \text{void}
  • Classe Cliente (pode herdar de Usuario ou ser usuário com papel = Cliente; escolha prática: usar Usuario com atributo papel para simplicidade).
  • Classe Produto (abstrata)
    • Atributos:
      • id: \text{UUID}
      • descricao: \text{String}
      • precoBase: \text{Money} — preço base sem sazonalidade.
    • Métodos (abstratos):
      • calcularPreco(dataIda, dataVolta, contexto): \text{Money} — cada subclasse implementa.
      • obterDisponibilidade(periodo): \text{Disponibilidade}
  • Classe Passagem (herda Produto)
    • Atributos:
      • vooNumero: \text{String}
      • classe: \text{String} — ex.: Econômica, Executiva.
      • origem: \text{String}
      • destino: \text{String}
    • Métodos:
      • calcularPreco(...): \text{Money} — aplica sazonalidade, tarifas, taxas.
      • permitirParcelamento(): \text{bool} — indica se pode ser parcelado.
  • Classe Hotel ou Hotel\_Oferta (herda Produto)
    • Atributos:
      • hotelId: \text{UUID}
      • nome: \text{String}
      • categoria: \text{HotelCategoria}
      • diariaBase: \text{Money}
    • Métodos:
      • calcularPreco(dataEntrada, dataSaida, contexto): \text{Money} — aplica multiplicador de categoria e sazonalidade.
      • verificarDisponibilidade(quartos, periodo): \text{Disponibilidade}
  • Enumeração HotelCategoria
    • Valores: Categoria\_1, Categoria\_2, Categoria\_3 (ou nomes significativos).
    • Cada valor associado a um multiplicador: \text{decimal} que ajusta diariaBase.
  • Classe Passeio (herda Produto)
    • Atributos:
      • duracao: \text{int} (horas)
      • local: \text{String}
      • capacidade: \text{int}
    • Métodos:
      • calcularPreco(...): \text{Money}
  • Classe Pacote (herda Produto ou é uma agregação de Produto)
    • Atributos:
      • itens: \text{List<Produto>}
      • desconto: \text{decimal} — desconto aplicado ao pacote.
    • Métodos:
      • calcularPreco(dataIda, dataVolta, contexto): \text{Money}
        • Implementação: soma preços dos itens (chamando calcularPreco de cada item), aplica desconto de pacote e regras de sazonalidade combinadas.
  • Classe Reserva (abstrata)
    • Atributos:
      • id: \text{UUID}
      • cliente: Usuario
      • produto: Produto
      • status: \text{String} — ex.: Pendente, Confirmada, Cancelada.
      • dataCriacao: \text{DateTime}
    • Métodos:
      • confirmar(): \text{bool}
      • cancelar(): \text{bool}
  • Classe Reserva\_Passagem (herda Reserva)
    • Atributos:
      • assento: \text{String}
      • bilheteEmitido: \text{bool}
    • Métodos:
      • confirmar(): \text{bool} — integra com Sistema\_Externo\_Aéreoé.
  • Classe Reserva\_Hotel (herda Reserva)
    • Atributos:
      • quartoTipo: \text{String}
      • numeroQuartos: \text{int}
      • dataEntrada: \text{Date}
      • dataSaida: \text{Date}
    • Métodos:
      • confirmar(): \text{bool} — integra com Sistema\_Externo\_Hotel.
  • Classe Booking
    • Atributos:
      • id: \text{UUID}
      • reservas: \text{List<Reserva>}
      • cliente: Usuario
      • status: \text{String}
    • Métodos:
      • adicionarReserva(r: Reserva): \text{void}
      • calcularTotal(): \text{Money} — soma calcularPreco de reservas/pacotes.
      • finalizarCompra(): \text{bool} — orquestra Efetuar\_Pagamento, confirma reservas.
  • Classe Pagamento
    • Atributos:
      • id: \text{UUID}
      • valor: \text{Money}
      • metodo: \text{String}
      • parcelas: \text{int} 1 para à vista.
      • status: \text{String}
    • Métodos:
      • processar(): \text{bool} — integra com Gateway\_de\_Pagamento.
      • calcularParcelas(): \text{List<Parcela>} — envia valores de cada parcela (aplica juros se necessário).
  • Classe SeasonalPriceRule (ou PrecoSazonalidade)
    • Atributos:
      • id: \text{UUID}
      • periodoInicio: \text{Date}
      • periodoFim: \text{Date}
      • multiplicador: \text{decimal} — ex.: 1{,}2 para alta temporada.
    • Métodos:
      • aplicar(precoBase): \text{Money}
  • Classe Relatorio
    • Métodos:
      • gerarRelatorioPrecos(periodo, tipoProduto): \text{RelatorioPDF/CSV}
      • gerarResumoVendas(periodo): \text{Relatorio}
  • Classes de integração:
    • SistemaExternoAereo
      • Métodos: consultarDisponibilidade(voo, data): \text{Disponibilidade}, criarReserva(dados): \text{Confirmacao}
    • SistemaExternoHotel
      • Métodos análogas.

Passo 10

Associações e multiplicidades (explicitação clara, usando TeX para multiplicidades):
  • Usuario 1 0..* Booking : um usuário pode ter vários bookings.
  • Booking 1 1..* Reserva : um booking agrega uma ou mais reservas.
  • Reserva 1 1 Produto : cada reserva refere-se a um produto específico (passagem/hotel/passeio).
  • Pacote 1 0..* Produto (agregação) : pacote agrega vários produtos.
  • Hotel 1 0..* Reserva\_Hotel : hotel pode ter várias reservas.
  • Gateway\_de\_Pagamento é representado pela classe Pagamento que chama métodos de integração externa.
  • SeasonalPriceRule 0..* associada a Produto ou ao sistema de preços — as regras são consultadas no cálculo de preço.
Explicação didática das multiplicidades:
  • 1 significa exatamente um.
  • 0..* significa zero ou mais.
  • 1..* significa um ou mais.
  • Em composição (Booking → Reserva), se o booking for cancelado, as reservas associadas podem ser canceladas automaticamente (composição forte).

Passo 11

Como calcular preço na prática (passo a passo que você pode colocar na prova ou implementar):
  1. Obter precoBase do produto:
    • Para Hotel: usar diariaBase.
    • Para Passagem: usar tarifaBase.
  2. Aplicar multiplicador de categoria do hotel (se aplicável):
    • precoIntermediario = precoBase \times multiplicadorCategoria.
  3. Aplicar regra de sazonalidade (buscar SeasonalPriceRule cujo periodoInicio \leq data \leq periodoFim):
    • precoSazonal = precoIntermediario \times multiplicadorSazonal.
  4. Para pacotes: somar preços dos itens (cada item calculado como acima) e aplicar desconto\_pacote:
    • precoPacote = (\sum precoItem) \times (1 - desconto).
  5. Para parcelamento (passagem):
    • Se parcelas > 1 e houver juros, calcular valor\_parcela usando fórmula de amortização simples ou juros simples:
      • Exemplo de juros simples: valorParcela = \dfrac{precoTotal \times (1 + taxaJuros) }{parcelas}.
    • Guardar no registro Pagamento as parcelas geradas.
Observações didáticas:
  • Sempre trate moeda com tipo Money que garante precisão (evitar float).
  • A sazonalidade pode ter múltiplas regras sobrepostas; escolha política (maior multiplicador aplicável, acumulativo, etc.) — documente essa regra.

Passo 12

Decisões de projeto e justificativas (por que modelar assim):
  • Usar Produto abstrato permite adicionar novos tipos (ex.: seguro viagem) sem quebrar modelo.
  • Separar Reserva e Pagamento facilita diferentes fluxos (reserva sem pagamento imediato).
  • Encapsular sazonalidade em SeasonalPriceRule torna fácil alterar regras sem tocar classes de produto.
  • Modelar Pacote como agregação de produtos permite reutilizar lógica de preço e disponibilidade.
  • Representar integrações externas como classes específicas evidencia dependências e facilita teste/mocking.

Passo 13

Orientação prática para implementação / diagrama físico:
  • No UML visual:
    • Coloque classes em caixas com três seções: nome, atributos, métodos.
    • Desenhe setas de herança (linha com triângulo fechado) de Passagem, Hotel, Passeio, Pacote para Produto.
    • Use linha com losango preenchido para composição Booking Reserva.
    • Use linhas simples com multiplicidades para associar Reserva a Produto, Usuario a Booking.
    • Mostre SeasonalPriceRule ligada ao componente de precificação (pode ser uma dependência do sistema ou associação com Produto).

Resposta

Diagrama de caso de uso (representação textual):
  • Atores:
    • Cliente
    • Agente\_de\_Vendas
    • Administrador
    • Sistema\_Externo\_Aéreoé
    • Sistema\_Externo\_Hotel
    • Gateway\_de\_Pagamento
  • Casos de uso (dentro do sistema “Sistema de Agência de Viagens”):
    • Pesquisar\_Produtos
      • «include» Visualizar\_Preco
    • Visualizar\_Preco
    • Reservar\_Passagem
      • «include» Visualizar\_Preco
      • «extend» Efetuar\_Pagamento (quando pagamento imediato)
      • integra com Sistema\_Externo\_Aéreoé
    • Reservar\_Hotel
      • «include» Visualizar\_Preco
      • «extend» Efetuar\_Pagamento (quando pagamento imediato)
      • integra com Sistema\_Externo\_Hotel
    • Reservar\_Passeio
      • «include» Visualizar\_Preco
    • Montar\_Pacote
      • «include» Calcular\_Preco\_Pacote
    • Calcular\_Preco\_Pacote
      • «include» Visualizar\_Preco (para cada item)
    • Efetuar\_Pagamento
      • integra com Gateway\_de\_Pagamento
      • suporta PagamentoParcelado
    • Emitir\_Confirmacao
    • Gerar\_Relatorio\_Precos (acessível por Agente\_de\_Vendas e Administrador)
    • Gerenciar\_Politicas (por Administrador: sazonalidade, multiplicadores por categoria de hotel, regras de desconto)
  • Ligações principais (resumo):
    • Cliente — associa com Pesquisar\_Produtos, Reservar\_*, Montar\_Pacote, Efetuar\_Pagamento.
    • Agente\_de\_Vendas — associa com Montar\_Pacote, Gerar\_Relatorio\_Precos, Emitir\_Confirmacao.
    • Administrador — associa com Gerenciar\_Politicas, Gerar\_Relatorio\_Precos.
    • Integrações externas vinculadas aos casos de reserva e pagamento conforme indicado.
Diagrama de classes (representação textual detalhada):
  • Usuario
    • Atributos: id: \text{UUID}, nome: \text{String}, email: \text{String}, papel: \text{String}
    • Métodos: login(email, senha): \text{bool}, logout(): \text{void}
  • Produto (abstrato)
    • Atributos: id: \text{UUID}, descricao: \text{String}, precoBase: \text{Money}
    • Métodos: calcularPreco(dataIda, dataVolta, contexto): \text{Money}, obterDisponibilidade(periodo): \text{Disponibilidade}
  • Passagem : Produto
    • Atributos: vooNumero: \text{String}, classe: \text{String}, origem: \text{String}, destino: \text{String}
    • Métodos: calcularPreco(...): \text{Money}, permitirParcelamento(): \text{bool}
  • Hotel : Produto
    • Atributos: hotelId: \text{UUID}, nome: \text{String}, categoria: \text{HotelCategoria}, diariaBase: \text{Money}
    • Métodos: calcularPreco(dataEntrada, dataSaida, contexto): \text{Money}, verificarDisponibilidade(quartos, periodo): \text{Disponibilidade}
  • Passeio : Produto
    • Atributos: duracao: \text{int}, local: \text{String}, capacidade: \text{int}
    • Métodos: calcularPreco(...): \text{Money}
  • Pacote : Produto (agregação)
    • Atributos: itens: \text{List<Produto>}, desconto: \text{decimal}
    • Métodos: calcularPreco(dataIda, dataVolta, contexto): \text{Money}
  • Reserva (abstrata)
    • Atributos: id: \text{UUID}, cliente: Usuario, produto: Produto, status: \text{String}, dataCriacao: \text{DateTime}
    • Métodos: confirmar(): \text{bool}, cancelar(): \text{bool}
  • Reserva\_Passagem : Reserva
    • Atributos: assento: \text{String}, bilheteEmitido: \text{bool}
    • Métodos: confirmar(): \text{bool} — integra com SistemaExternoAereo
  • Reserva\_Hotel : Reserva
    • Atributos: quartoTipo: \text{String}, numeroQuartos: \text{int}, dataEntrada: \text{Date}, dataSaida: \text{Date}
    • Métodos: confirmar(): \text{bool} — integra com SistemaExternoHotel
  • Booking
    • Atributos: id: \text{UUID}, reservas: \text{List<Reserva>}, cliente: Usuario, status: \text{String}
    • Métodos: adicionarReserva(r: Reserva): \text{void}, calcularTotal(): \text{Money}, finalizarCompra(): \text{bool}
  • Pagamento
    • Atributos: id: \text{UUID}, valor: \text{Money}, metodo: \text{String}, parcelas: \text{int}, status: \text{String}
    • Métodos: processar(): \text{bool}, calcularParcelas(): \text{List<Parcela>}
  • SeasonalPriceRule
    • Atributos: id: \text{UUID}, periodoInicio: \text{Date}, periodoFim: \text{Date}, multiplicador: \text{decimal}
    • Métodos: aplicar(precoBase): \text{Money}
  • HotelCategoria (enum)
    • Valores: Categoria\_1, Categoria\_2, Categoria\_3 (cada um com multiplicador: \text{decimal})
  • Relatorio
    • Métodos: gerarRelatorioPrecos(periodo, tipoProduto): \text{Arquivo}, gerarResumoVendas(periodo): \text{Arquivo}
  • Integração:
    • SistemaExternoAereo: consultarDisponibilidade(...), criarReserva(...)
    • SistemaExternoHotel: consultarDisponibilidade(...), criarReserva(...)
    • GatewayDePagamento: processarPagamento(...)
Associações e multiplicidades principais (resumo em TeX):
  • Usuario 1 0..* Booking
  • Booking 1 1..* Reserva (composição)
  • Reserva 1 1 Produto
  • Pacote 1 0..* Produto (agregação)
  • Hotel 1 0..* Reserva\_Hotel
  • SeasonalPriceRule 0..* associada ao mecanismo de cálculo de preço
Resumo prático do fluxo essencial (para implementar):
  • Usuário pesquisa → sistema chama Visualizar\_Preco (consulta SeasonalPriceRule e multiplicadores de HotelCategoria) → usuário monta pacote/reserva → cria Booking com Reservas → na finalização chama Efetuar\_Pagamento (parcelado se aplicável) → se pagamento confirmado, orquestra confirmações via SistemaExternoAereo / SistemaExternoHotel → gera confirmações e relatórios.
Observação final de incentivo: com esse modelo você tem uma estrutura flexível (produtos extensíveis, regras de preço desacopladas e reservas/pagamentos separados) que cobre todos os pontos do enunciado (categorias de hotel, sazonalidade, reservas, parcelamento, montagem de pacotes e geração de relatórios). Se quiser, eu transformo essa descrição textual em um diagrama UML no formato PlantUML ou desenho pronto para impressão.

Exercícios relacionados