Batch

public enum FormaPagamento {
    DINHEIRO("Dinheiro", "DIN"),
    PIX("Pix", "PIX"),
    DEBITO("Débito", "DEB"),
    CREDITO("Crédito", "CCR");
    private final String nome;
    private final String sigla;

    // Construtor
    private FormaPagamento(String nome, String sigla) {
        this.nome = nome;
        this.sigla = sigla;
    }

    // Getters
    public String getNome() {
        return nome;
    }

    public String getSigla() {
        return sigla;
    }

    // Método para buscar pelo sigla
    public static FormaPagamento fromSigla(String sigla) {
        for (FormaPagamento formaPagamento : FormaPagamento.values()) {
            if (formaPagamento.getSigla().equalsIgnoreCase(sigla)) {
                return formaPagamento;
            }
        }
        throw new IllegalArgumentException("Sigla de pagamento inválida: " + sigla);
    }
}

import com.example.demo.config.listener.ArquivoProcessadoListener;
import com.example.demo.model.FormaPagamento;
import com.example.demo.model.Venda;
import jakarta.persistence.EntityManagerFactory;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;
import org.springframework.batch.core.job.builder.JobBuilder;
import org.springframework.batch.core.repository.JobRepository;
import org.springframework.batch.core.step.builder.StepBuilder;
import org.springframework.batch.item.database.JpaItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.builder.FlatFileItemReaderBuilder;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.FileSystemResource;
import org.springframework.transaction.PlatformTransactionManager;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;

@Configuration
public class BatchConfig {

    @Value("${input.folder}")
    private String inputFolder;

    private final JobRepository jobRepository;
    private final PlatformTransactionManager transactionManager;
    private final EntityManagerFactory entityManagerFactory;

    public BatchConfig(JobRepository jobRepository,
                       PlatformTransactionManager transactionManager,
                       EntityManagerFactory entityManagerFactory) {
        this.jobRepository = jobRepository;
        this.transactionManager = transactionManager;
        this.entityManagerFactory = entityManagerFactory;
    }

    @Bean
    public FlatFileItemReader<Venda> leitorVenda() {
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("dd/MM/yy");
        return new FlatFileItemReaderBuilder<Venda>()
                .name("leitorVenda")
                .resource(new FileSystemResource(inputFolder + "/vendas.csv"))
                .delimited()
                .delimiter(";")
                .names("idTerminal","numeroTransacao", "dataMovimento", "valorVenda", "formaPagamento")
                .fieldSetMapper(fieldSet -> {
                    Venda venda = new Venda();
                    venda.setNumeroTransacao(fieldSet.readInt("numeroTransacao"));
                    venda.setIdTerminal(fieldSet.readString("idTerminal"));
                    venda.setDataMovimento(LocalDate.parse(fieldSet.readString("dataMovimento"), formatter));
                    venda.setValorVenda(fieldSet.readDouble("valorVenda"));
                    venda.setFormaPagamento(FormaPagamento.fromSigla(fieldSet.readString("formaPagamento")));
                    return venda;
                })
                .build();
    }

    @Bean
    public JpaItemWriter<Venda> writerVenda() {
        JpaItemWriter<Venda> writer = new JpaItemWriter<>();
        writer.setEntityManagerFactory(entityManagerFactory);
        return writer;
    }

    @Bean
    public Step step1() {
        return new StepBuilder("step1", jobRepository)
                .<Venda, Venda>chunk(10, transactionManager)
                .reader(leitorVenda())
                .writer(writerVenda())
                .faultTolerant()
                .skip(Exception.class)
                .skipLimit(1)
                .listener(new ArquivoProcessadoListener(inputFolder, inputFolder + "/processados"))
                .build();
    }

    @Bean
    public Job importVendasJob(Step step1) {
        return new JobBuilder("importVendasJob", jobRepository)
                .start(step1)
                .build();
    }
}

public enum FormaPagamento {
    DIN("DIN"), PIX("PIX"), DEB("DEB"), CCR("CCR");

    private final String sigla;

    FormaPagamento(String sigla) {
        this.sigla = sigla;
    }

    public static FormaPagamento fromSigla(String sigla) {
        return Arrays.stream(FormaPagamento.values())
                .filter(fp -> fp.sigla.equalsIgnoreCase(sigla))
                .findFirst()
                .orElseThrow(() -> new IllegalArgumentException("Forma de pagamento inválida: " + sigla));
    }
}