add codetypefichier

Kenmegne

2025-12-10 e9d80d486b912144b59ebd5939d4837105b37b99

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
/*
 * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
 * Click nbfs://nbhost/SystemFileSystem/Templates/Classes/Class.java to edit this template
 */
package com.megatim.queryadhoc.queries.metadata;
 
import com.megatim.queryadhoc.enums.TypeDonnee;
import com.megatim.queryadhoc.exceptions.BadDataValueException;
import com.megatim.queryadhoc.exceptions.ColumnNotFoundException;
import com.megatim.queryadhoc.exceptions.LocalDateTimeValueParseError;
import com.megatim.queryadhoc.model.DbColumnDescription;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.apache.commons.validator.GenericValidator;
 
/**
 *
 * @author ASUS
 */
public class ParsedDataRow {
 
    private final Map<String, Object> data;
    private final String tableName;
    private final Map<String, DbColumnDescription> columnNameToDbColumnDescription;
    private final Map<String, Object> row = new HashMap<>();
 
    public ParsedDataRow(Map<String, Object> data, List<DbColumnDescription> columnsDescription, String tableName) {
        this.data = data;
        this.tableName = tableName;
        this.columnNameToDbColumnDescription
                = columnsDescription
                        .stream()
                        .collect(Collectors.toMap(c -> c.getName().trim().toLowerCase(), c -> c));
    }
 
    public Map<String, Object> dataRow() throws ColumnNotFoundException, BadDataValueException, LocalDateTimeValueParseError {
 
        if (row.isEmpty()) {
 
            for (Map.Entry<String, Object> entry : data.entrySet()) {
 
                String key = entry.getKey();
                Object value = entry.getValue();
 
                DbColumnDescription columnDesc = columnNameToDbColumnDescription.get(key.trim());
                if (columnDesc == null) {
                    throw new ColumnNotFoundException(key, tableName);
                }
 
                row.put(key.trim(), parse(columnDesc, value));
            }
 
        }
 
        return row;
    }
 
    private Object parse(DbColumnDescription columnDesc, Object value) throws BadDataValueException, LocalDateTimeValueParseError {
 
        TypeDonnee columnType = columnDesc.getTypeDonnee();
 
        if (columnType.equals(TypeDonnee.ALPHANUMERIQUE) && (value == null
                || (value instanceof String && lengthLowerOrEquals((String) value, columnDesc.getTaille())))) {
 
            return value != null ? value.toString().replaceAll("\\s+", " ").trim() : value;
 
        } else if (columnType.equals(TypeDonnee.NUMERIQUE)) {
 
            if (value == null) {
                return 0L;
            }
 
            String stringValue = value.toString();
            if (lengthLowerOrEquals(stringValue, columnDesc.getTaille()) && GenericValidator.isLong(stringValue)) {
                return Long.valueOf(stringValue);
            }
 
        } else if (columnType.equals(TypeDonnee.DECIMAL)) {
 
            if (value == null) {
                return 0.0;
            }
 
            String stringValue = value.toString();
            if (lengthLowerOrEquals(stringValue, columnDesc.getTaille()) && GenericValidator.isDouble(stringValue)) {
                return Double.valueOf(stringValue);
            }
 
        } else if (columnType.equals(TypeDonnee.DATE)) {
 
            if (value == null) {
                return null;
            }
            String stringValue = value.toString().trim();
            
            if (stringValue.isEmpty()) {
                return null;
            }
 
            if (lengthEquals(stringValue, columnDesc.getTaille()) && GenericValidator.isDate(stringValue, columnDesc.getFormatDate(), true)) {
                return new LocalDateTimeValue(columnDesc.getFormatDate(), value).value();
            }
        }
 
        throw new BadDataValueException("La valeur " + value + " ne correspond pas au format attendu pour la colonne " + columnDesc.getName());
    }
 
    private boolean lengthEquals(String value, int columnMaxLength) {
        return value.trim().length() == columnMaxLength;
    }
 
    private boolean lengthLowerOrEquals(String value, int columnMaxLength) {
        return value.trim().length() <= columnMaxLength;
    }
}