funziona

Author: MaurizioGentile

src/main/java/com/example/postgresdemo/controller/AnswerController.java

@@ -0,0 +1,111 @@
+package com.example.postgresdemo.controller;
+
+import com.example.postgresdemo.exception.ResourceNotFoundException;
+import com.example.postgresdemo.model.Operatore;
+import com.example.postgresdemo.repository.OperatoreRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.*;
+
+import javax.validation.Valid;
+import java.util.List;
+
+/**
+ * Controller REST per la gestione degli operatori.
+ * Espone endpoint per recuperare, aggiungere, aggiornare ed eliminare operatori.
+ */
+@RestController
+@RequestMapping("/operatori")
+public class OperatoreController {
+
+    @Autowired
+    private OperatoreRepository operatoreRepository;
+
+    /**
+     * Recupera tutti gli operatori in modo paginato.
+     *
+     * @param pageable Oggetto che specifica la paginazione e l'ordinamento.
+     * @return Una pagina contenente gli operatori.
+     */
+    @GetMapping
+    public Page<Operatore> getOperatori(Pageable pageable) {
+        return operatoreRepository.findAll(pageable);
+    }
+
+    /**
+     * Recupera un operatore in base al suo ID.
+     *
+     * @param id ID dell'operatore da recuperare.
+     * @return L'operatore richiesto.
+     * @throws ResourceNotFoundException Se l'operatore non viene trovato.
+     */
+    @GetMapping("/{id}")
+    public Operatore getOperatoreById(@PathVariable Integer id) {
+        return operatoreRepository.findOperatoreByIdOperatore(id)
+                .orElseThrow(() -> new ResourceNotFoundException("Operatore not found with id " + id));
+    }
+
+    /**
+     * Ricerca operatori per nome.
+     *
+     * @param nome Nome dell'operatore da cercare.
+     * @return Una lista di operatori che corrispondono al nome specificato.
+     */
+    @GetMapping("/search")
+    public ResponseEntity<List<Operatore>> findOperatoriByNome(@RequestParam String nome) {
+        List<Operatore> operatori = operatoreRepository.findOperatoreByNome(nome);
+        if (operatori.isEmpty()) {
+            return ResponseEntity.notFound().build();
+        }
+        return ResponseEntity.ok(operatori);
+    }
+
+    /**
+     * Crea un nuovo operatore.
+     *
+     * @param operatore L'oggetto Operatore da salvare.
+     * @return L'oggetto Operatore salvato.
+     */
+    @PostMapping
+    public Operatore createOperatore(@Valid @RequestBody Operatore operatore) {
+        return operatoreRepository.save(operatore);
+    }
+
+    /**
+     * Aggiorna un operatore esistente.
+     *
+     * @param id               L'ID dell'operatore da aggiornare.
+     * @param operatoreRequest L'oggetto Operatore con i nuovi dati.
+     * @return L'oggetto Operatore aggiornato.
+     * @throws ResourceNotFoundException Se l'operatore non viene trovato.
+     */
+    @PutMapping("up/{id}")
+    public Operatore updateOperatore(@PathVariable Integer id,
+                                     @Valid @RequestBody Operatore operatoreRequest) {
+        return operatoreRepository.findById(Long.valueOf(id))
+                .map(operatore -> {
+                    operatore.setNome(operatoreRequest.getNome());
+                    operatore.setEmail(operatoreRequest.getEmail());
+                    operatore.setPassword(operatoreRequest.getPassword());
+                    return operatoreRepository.save(operatore);
+                }).orElseThrow(() -> new ResourceNotFoundException("Operatore not found with id " + id));
+    }
+
+    /**
+     * Elimina un operatore esistente.
+     *
+     * @param id L'ID dell'operatore da eliminare.
+     * @return ResponseEntity con stato OK se l'eliminazione avviene con successo.
+     * @throws ResourceNotFoundException Se l'operatore non viene trovato.
+     */
+    @DeleteMapping("del/{id}")
+    public ResponseEntity<?> deleteOperatore(@PathVariable Integer id) {
+        return operatoreRepository.findById(Long.valueOf(id))
+                .map(operatore -> {
+                    operatoreRepository.delete(operatore);
+                    return ResponseEntity.ok().build();
+                }).orElseThrow(() -> new ResourceNotFoundException("Operatore not found with id " + id));
+    }
+}

src/main/java/com/example/postgresdemo/controller/OperatoreController.java

@@ -0,0 +1,38 @@
+package com.example.postgresdemo.controller;
+
+import com.example.postgresdemo.exception.ResourceNotFoundException;
+import com.example.postgresdemo.model.TicketGroup;
+import com.example.postgresdemo.repository.TicketGroupRepository;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.web.bind.annotation.*;
+
+import java.util.List;
+
+@RestController
+@RequestMapping("/ticketgroups")
+public class TicketGroupController {
+
+    @Autowired
+    private TicketGroupRepository ticketGroupRepository;
+
+    // Recupera tutti i TicketGroup in modo paginato
+    @GetMapping
+    public Page<TicketGroup> getAllTickets(Pageable pageable) {
+        return ticketGroupRepository.findAll(pageable);
+    }
+
+    // Recupera tutti i TicketGroup senza paginazione
+    @GetMapping("/all")
+    public List<TicketGroup> getAllTicketGroups() {
+        return ticketGroupRepository.findAllTicketGroups();
+    }
+
+    // Recupera un TicketGroup in base all'id del ticket
+    @GetMapping("/{id}")
+    public TicketGroup getTicketGroupByTicketId(@PathVariable Integer id) {
+        return ticketGroupRepository.findByIdTicket(id)
+                .orElseThrow(() -> new ResourceNotFoundException("TicketGroup not found with id_ticket " + id));
+    }
+}

src/main/java/com/example/postgresdemo/controller/QuestionController.java

@@ -8,36 +8,69 @@
 import java.io.Serializable;
 import java.util.Date;
 
+/**
+ * Classe astratta che fornisce funzionalità di audit (creazione e aggiornamento) per le entità.
+ * La classe gestisce automaticamente i timestamp di creazione e modifica di un'entità.
+ */
 @MappedSuperclass
 @EntityListeners(AuditingEntityListener.class)
 @JsonIgnoreProperties(
         value = {"createdAt", "updatedAt"},
         allowGetters = true
 )
 public abstract class AuditModel implements Serializable {
+
+    /**
+     * Data e ora di creazione dell'entità.
+     * Questo campo non può essere aggiornato dopo la creazione.
+     */
     @Temporal(TemporalType.TIMESTAMP)
     @Column(name = "created_at", nullable = false, updatable = false)
     @CreatedDate
     private Date createdAt;
 
+    /**
+     * Data e ora dell'ultimo aggiornamento dell'entità.
+     * Questo campo viene aggiornato automaticamente ogni volta che l'entità viene modificata.
+     */
     @Temporal(TemporalType.TIMESTAMP)
     @Column(name = "updated_at", nullable = false)
     @LastModifiedDate
     private Date updatedAt;
 
+    /**
+     * Restituisce la data di creazione dell'entità.
+     *
+     * @return La data di creazione.
+     */
     public Date getCreatedAt() {
         return createdAt;
     }
 
+    /**
+     * Imposta la data di creazione dell'entità.
+     *
+     * @param createdAt La data di creazione da impostare.
+     */
     public void setCreatedAt(Date createdAt) {
         this.createdAt = createdAt;
     }
 
+    /**
+     * Restituisce la data dell'ultimo aggiornamento dell'entità.
+     *
+     * @return La data dell'ultimo aggiornamento.
+     */
     public Date getUpdatedAt() {
         return updatedAt;
     }
 
+    /**
+     * Imposta la data dell'ultimo aggiornamento dell'entità.
+     *
+     * @param updatedAt La data dell'ultimo aggiornamento da impostare.
+     */
     public void setUpdatedAt(Date updatedAt) {
         this.updatedAt = updatedAt;
     }
-}
+}