Ayudame a crear un proyecto de cafeteria que contenga roles para usuarios y administradores, donde cada uno pueda iniciar secion en un login y tambien con su cuenta de google donde los ususarios puedan ver el menu con los productos, categorias etc hacer pedido y reservar mesas y los administradores se encraguen de la gestion del sistema, editar, eliminar, y crear, categrorias productos, control de todo, y al momento de agregar la imagen de producto que sea desde nuestra computadora y se pueda recortar la imagen antes de agregarla.... todo esto ira trabajado en JAVA Intelling idea, con maven y sprint boot con la estructura de modelos, repositorios, controladores, servicios(implementaciones y interfaces) y vistas... que lleve tambien estas dependencias: Spring Boot DevTools , Spring Web , Spring Data JPA └── SQL > Spring Data JPA, SQL Server Driver, Thymeleaf , Validation ayudame a crearlo paso a paso desde cero.

Aquí te presento un proyecto de cafeteria en Java con Spring Boot, Maven y Spring Data JPA. Este proyecto tendrá los siguientes componentes:

1. Roles para usuarios y administradores
2. Inicio de sesión con cuenta de Google
3. Menú con productos, categorías, etc.
4. Hacer pedido y reservar mesas
5. Gestión del sistema para administradores (editar, eliminar, crear categorías, productos, etc.)
6. Agregar imagen de producto desde la computadora y recortarla antes de agregarla

**Paso 1: Crear el proyecto**

1. Abre IntelliJ IDEA y crea un nuevo proyecto de Spring Boot.
2. Selecciona "Maven" como proyecto y "Spring Boot" como tipo de proyecto.
3. Selecciona "Web" como dependencia y "Spring Data JPA" como dependencia de base de datos.
4. Selecciona "SQL Server" como motor de base de datos.
5. Selecciona "Thymeleaf" como motor de plantillas.
6. Selecciona "Validation" como dependencia de validación.

**Paso 2: Configurar la base de datos**

1. Crea una nueva clase llamada `DatabaseConfig` en el paquete `com.example.cafeteria.config`.
```java
@Configuration
@EnableJpaRepositories
public class DatabaseConfig {
 
    @Bean
    public DataSource dataSource() {
        DataSourceBuilder dataSourceBuilder = DataSourceBuilder.create();
        dataSourceBuilder.driverClassName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
        dataSourceBuilder.url("jdbc:sqlserver://localhost:1433;databaseName=cafeteria");
        dataSourceBuilder.username("tu_usuario");
        dataSourceBuilder.password("tu_contraseña");
        return dataSourceBuilder.build();
    }
 
    @Bean
    public JpaVendorAdapter jpaVendorAdapter() {
        HibernateJpaVendorAdapter adapter = new HibernateJpaVendorAdapter();
        return adapter;
    }
 
    @Bean
    public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
        LocalContainerEntityManagerFactoryBean em = new LocalContainerEntityManagerFactoryBean();
        em.setDataSource(dataSource());
        em.setPackagesToScan("com.example.cafeteria.model");
        em.setJpaVendorAdapter(jpaVendorAdapter());
        em.setJpaProperties(hibernateProperties());
        return em;
    }
 
    @Bean
    public PlatformTransactionManager transactionManager() {
        JpaTransactionManager transactionManager = new JpaTransactionManager();
        transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
        return transactionManager;
    }
 
    private Properties hibernateProperties() {
        Properties properties = new Properties();
        properties.put("hibernate.dialect", "org.hibernate.dialect.SQLServerDialect");
        properties.put("hibernate.show_sql", "true");
        properties.put("hibernate.format_sql", "true");
        return properties;
    }
}
```
**Paso 3: Crear los modelos**

1. Crea una nueva clase llamada `Usuario` en el paquete `com.example.cafeteria.model`.
```java
@Entity
@Table(name = "usuarios")
public class Usuario {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    @Column(unique = true)
    private String correo;
 
    private String contraseña;
 
    @Enumerated(EnumType.STRING)
    private Rol rol;
 
    // Getters y setters
}
```
2. Crea una nueva clase llamada `Administrador` en el paquete `com.example.cafeteria.model`.
```java
@Entity
@Table(name = "administradores")
public class Administrador extends Usuario {
 
    // Atributos y métodos adicionales para administradores
}
```
3. Crea una nueva clase llamada `Producto` en el paquete `com.example.cafeteria.model`.
```java
@Entity
@Table(name = "productos")
public class Producto {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    private String nombre;
 
    private String descripcion;
 
    private Double precio;
 
    @ManyToOne
    @JoinColumn(name = "categoria_id")
    private Categoria categoria;
 
    // Getters y setters
}
```
4. Crea una nueva clase llamada `Categoria` en el paquete `com.example.cafeteria.model`.
```java
@Entity
@Table(name = "categorias")
public class Categoria {
 
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
 
    private String nombre;
 
    // Getters y setters
}
```
**Paso 4: Crear los repositorios**

1. Crea una nueva clase llamada `UsuarioRepository` en el paquete `com.example.cafeteria.repository`.
```java
public interface UsuarioRepository extends JpaRepository<Usuario, Long> {
 
}
```
2. Crea una nueva clase llamada `AdministradorRepository` en el paquete `com.example.cafeteria.repository`.
```java
public interface AdministradorRepository extends JpaRepository<Administrador, Long> {
 
}
```
3. Crea una nueva clase llamada `ProductoRepository` en el paquete `com.example.cafeteria.repository`.
```java
public interface ProductoRepository extends JpaRepository<Producto, Long> {
 
}
```
4. Crea una nueva clase llamada `CategoriaRepository` en el paquete `com.example.cafeteria.repository`.
```java
public interface CategoriaRepository extends JpaRepository<Categoria, Long> {
 
}
```
**Paso 5: Crear los servicios**

1. Crea una nueva clase llamada `UsuarioService` en el paquete `com.example.cafeteria.service`.
```java
@Service
public class UsuarioService {
 
    @Autowired
    private UsuarioRepository usuarioRepository;
 
    public List<Usuario> getAllUsuarios() {
        return usuarioRepository.findAll();
    }
 
    public Usuario getUsuarioById(Long id) {
        return usuarioRepository.findById(id).orElse(null);
    }
 
    public void saveUsuario(Usuario usuario) {
        usuarioRepository.save(usuario);
    }
 
    public void deleteUsuario(Long id) {
        usuarioRepository.deleteById(id);
    }
}
```
2. Crea una nueva clase llamada `AdministradorService` en el paquete `com.example.cafeteria.service`.
```java
@Service
public class AdministradorService {
 
    @Autowired
    private AdministradorRepository administradorRepository;
 
    public List<Administrador> getAllAdministradores() {
        return administradorRepository.findAll();
    }
 
    public Administrador getAdministradorById(Long id) {
        return administradorRepository.findById(id).orElse(null);
    }
 
    public void saveAdministrador(Administrador administrador) {
        administradorRepository.save(administrador);
    }
 
    public void deleteAdministrador(Long id) {
        administradorRepository.deleteById(id);
    }
}
```
3. Crea una nueva clase llamada `ProductoService` en el paquete `com.example.cafeteria.service`.
```java
@Service
public class ProductoService {
 
    @Autowired
    private ProductoRepository productoRepository;
 
    public List<Producto> getAllProductos() {
        return productoRepository.findAll();
    }
 
    public Producto getProductoById(Long id) {
        return productoRepository.findById(id).orElse(null);
    }
 
    public void saveProducto(Producto producto) {
        productoRepository.save(producto);
    }
 
    public void deleteProducto(Long id) {
        productoRepository.deleteById(id);
    }
}
```
4. Crea una nueva clase llamada `CategoriaService` en el paquete `com.example.cafeteria.service`.
```java
@Service
public class CategoriaService {
 
    @Autowired
    private CategoriaRepository categoriaRepository;
 
    public List<Categoria> getAllCategorias() {
        return categoriaRepository.findAll();
    }
 
    public Categoria getCategoriaById(Long id) {
        return categoriaRepository.findById(id).orElse(null);
    }
 
    public void saveCategoria(Categoria categoria) {
        categoriaRepository.save(categoria);
    }
 
    public void deleteCategoria(Long id) {
        categoriaRepository.deleteById(id);
    }
}
```
**Paso 6: Crear los controladores**

1. Crea una nueva clase llamada `UsuarioController` en el paquete `com.example.cafeteria.controller`.
```java
@RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {
 
    @Autowired
    private UsuarioService usuarioService;
 
    @GetMapping
    public List<Usuario> getAllUsuarios() {
        return usuarioService.getAllUsuarios();
    }
 
    @GetMapping("/{id}")
    public Usuario getUsuarioById(@PathVariable Long id) {
        return usuarioService.getUsuarioById(id);
    }
 
    @PostMapping
    public void saveUsuario(@RequestBody Usuario usuario) {
        usuarioService.saveUsuario(usuario);
    }
 
    @DeleteMapping("/{id}")
    public void deleteUsuario(@PathVariable Long id) {
        usuarioService.deleteUsuario(id);
    }
}
```
2. Crea una nueva clase llamada `AdministradorController` en el paquete `com.example.cafeteria.controller`.
```java
@RestController
@RequestMapping("/api/administradores")
public class AdministradorController {
 
    @Autowired
    private AdministradorService administradorService;
 
    @GetMapping
    public List<Administrador> getAllAdministradores() {
        return administradorService.getAllAdministradores();
    }
 
    @GetMapping("/{id}")
    public Administrador getAdministradorById(@PathVariable Long id) {
        return administradorService.getAdministradorById(id);
    }
 
    @PostMapping
    public void saveAdministrador(@RequestBody Administrador administrador) {
        administradorService.saveAdministrador(administrador);
    }
 
    @DeleteMapping("/{id}")
    public void deleteAdministrador(@PathVariable Long id) {
        administradorService.deleteAdministrador(id);
    }
}
```
3. Crea una nueva clase llamada `ProductoController` en el paquete `com.example.cafeteria.controller`.
```java
@RestController
@RequestMapping("/api/productos")
public class ProductoController {
 
    @Autowired
    private ProductoService productoService;
 
    @GetMapping
    public List<Producto> getAllProductos() {
        return productoService.getAllProductos();
    }
 
    @GetMapping("/{id}")
    public Producto getProductoById(@PathVariable Long id) {
        return productoService.getProductoById(id);
    }
 
    @PostMapping
    public void saveProducto(@RequestBody Producto producto) {
        productoService.saveProducto(producto);
    }
 
    @DeleteMapping("/{id}")
    public void deleteProducto(@PathVariable Long id) {
        productoService.deleteProducto(id);
    }
}
```
4. Crea una nueva clase llamada `CategoriaController` en el paquete `com.example.cafeteria.controller`.
```java
@RestController
@RequestMapping("/api/categorias")
public class CategoriaController {
 
    @Autowired
    private CategoriaService categoriaService;
 
    @GetMapping
    public List<Categoria> getAllCategorias() {
        return categoriaService.getAllCategorias();
    }
 
    @GetMapping("/{id}")
    public Categoria getCategoriaById(@PathVariable Long id) {
        return categoriaService.getCategoriaById(id);
    }
 
    @PostMapping
    public void saveCategoria(@RequestBody Categoria categoria) {
        categoriaService.saveCategoria(categoria);
    }
 
    @DeleteMapping("/{id}")
    public void deleteCategoria(@PathVariable Long id) {
        categoriaService.deleteCategoria(id);
    }
}
```
**Paso 7: Crear la interfaz de usuario**

1. Crea una nueva clase llamada `LoginController` en el paquete `com.example.cafeteria.controller`.
```java
@RestController
@RequestMapping("/api/login")
public class LoginController {
 
    @Autowired
    private UsuarioService usuarioService;
 
    @PostMapping
    public void login(@RequestBody LoginRequest loginRequest) {
        // Verificar la credenciales del usuario
        Usuario usuario = usuarioService.getUsuarioByCorreo(loginRequest.getCorreo());
        if (usuario != null && usuario.getContraseña().equals(loginRequest.getContraseña())) {
            // Generar un token de autenticación
            String token = generarToken(usuario);
            // Devolver el token al cliente
            return ResponseEntity.ok(token);
        } else {
            // Devolver un error si las credenciales son incorrectas
            return ResponseEntity.badRequest().build();
        }
    }
}
```
2. Crea una nueva clase llamada `RegistroController` en el paquete `com.example.cafeteria.controller`.
```java
@RestController
@RequestMapping("/api/registro")
public class RegistroController {
 
    @Autowired
    private UsuarioService usuarioService;
 
    @PostMapping
    public void registrar(@RequestBody RegistroRequest registroRequest) {
        // Crear un nuevo usuario
        Usuario usuario = new Usuario();
        usuario.setCorreo(registroRequest.getCorreo());
        usuario.setContraseña(registroRequest.getContraseña());
        usuario.setRol(Rol.USUARIO);
        usuarioService.saveUsuario(usuario);
    }
}
```
**Paso 8: Crear la interfaz de administrador**

1. Crea una nueva clase llamada `AdministradorController` en el paquete `com.example.cafeteria.controller`.
```java
@RestController
@RequestMapping("/api/administradores")
public class AdministradorController {
 
    @Autowired
    private AdministradorService administradorService;
 
    @GetMapping
    public List<Administrador> getAllAdministradores() {
        return administradorService.getAllAdministradores();
    }
 
    @GetMapping("/{id}")
    public Administrador getAdministradorById(@PathVariable Long id) {
        return administradorService.getAdministradorById(id);
    }
 
    @PostMapping
    public void saveAdministrador(@RequestBody Administrador administrador) {
        administradorService.saveAdministrador(administrador);
    }
 
    @DeleteMapping("/{id}")
    public void deleteAdministrador(@PathVariable Long id) {
        administradorService.deleteAdministrador(id);
    }
}
```
**Paso 9: Crear la interfaz de producto**

1. Crea una nueva clase llamada `ProductoController` en el paquete `com.example.cafeteria.controller`.
```java
@RestController
@RequestMapping("/api/productos")
public class ProductoController {
 
    @Autowired
    private ProductoService productoService;
 
    @GetMapping
    public List<Producto> getAllProductos() {
        return productoService.getAllProductos();
    }
 
    @GetMapping("/{id}")
    public Producto getProductoById(@PathVariable