Bonjour,

J'utilise Talend afin de faire de l'extraction de données sur AS400.

Pour ce faire, j'utilise un composant tJava afin de pouvoir manipuler des heures dans mon job.

Je ne suis pas une star en Java et mon code me retourne une erreur "This method must return a result of type int", lors de son exécution.

Je mets ici mon bout de code pour les âmes charitables qui voudront bien se pencher sur problème.

class tournees {	

Date date = TalendDate.getCurrentDate();

public void main(int HR, int Mn){
	// Modification de la routine TalendDate afin de créer un composant customisé (TalendDate24)
	// Méthode Heures24 permettant de ne récupérer que l'heure et les minutes actuelles
	int HR = TalendDate24.getPartOfDate("HOUR_OF_DAY", date);
	int Mn = TalendDate24.getPartOfDate("MINUTE", date);
	// Ajout d'un 0 aux minutes si moins de 10 (sinon heure de type : 105 au lieu de 1005 pour 10:05)
	if (HR < 10){ 
		String HR = "0" + Integer.toString(HR);
		int HR = integer.parseInt(HR);
		tournees formHR = new tournees();
		int heure = formHR.addZero(HR, Mn);
		System.out.println(heure);
	}
	else if (HR >= 10){
		tournees formHR = new tournees();
		int heure = formHR.addZero(HR, Mn);
		System.out.println(heure);
	}
}

// Méthode addZero (ajout zero aux heures et minutes si nécessaire)
public addZero(int HR, int Mn){
	if (Mn < 10){
		String HRMn = Integer.toString(HR) + "0" + Integer.toString(Mn);
		int Hour = Integer.parseInt(HRMn);
		if (Hour >= 0700 && Hour <= 1500){
			System.out.println("Tournée pour demain matin");
		}
		else if (Hour >= 1500 && Hour <= 1800){
			System.out.println("Tournée pour demain après-midi");
		}
	return Hour;
	}
	else if (Mn >= 10){
		String HRMn = Integer.toString(HR) + Integer.toString(Mn);
		int Hour = Integer.parseInt(HRMn);
		if (Hour >= 0700 && Hour <= 1500){
			System.out.println("Tournée pour demain matin");
		}
		else if (Hour >= 1500 && Hour <= 1800){
			System.out.println("Tournée pour demain après-midi");
		}
	return Hour;
	}
}

}

Merci d'avance.

-
Edité par gadje 3 juillet 2019 à 12:02:15

Il manque juste le type de la valeur de retour de la méthode addZero

public int addZero(int HR, int Mn){

Maintenant, il va te dire que tu n'as pas prévu de valeur de retour si tes deux conditions sont fausses.

public int addZero(int HR, int Mn){
    if (Mn < 10){
        ...
        return Hour;
    }
    else if (Mn >= 10){
        ...
        return Hour;
    }
    /* Et ici, qu'est-ce qu'on fait si (Mn < 10) == false ET (Mn >= 10) == false ?
     * D'accord, ça n'arrive jamais. Mais le compilateur n'a pas à le deviner, c'est
     * ton code qui doit être plus clair.
     */
}

Au final, j'écrirais ta méthode comme ça en appliquant le principe DRY

public int addZero(int hr, int mn){
    String hrmn;
    if (mn < 10){
        hrmn = hr + "0" + mn;
    }
    else {
        hrmn = Integer.toString(hr) + Integer.toString(mn)
    }

    int hour = Integer.parseInt(hrmn);
    if (hour >= 700 && hour <= 1500){
        System.out.println("Tournée pour demain matin");
    }
    else if (hour >= 1500 && hour <= 1800){
        System.out.println("Tournée pour demain après-midi");
    }

    return hour;
}

Remarque le respect des conventions de dénomination de Java : les noms des classes commencent par une majuscule, les noms des variables par une minuscule.

Si on va plus loin, je pense même que c'est une très mauvaise idée de gérer des données de temps sous la forme de chaînes de caractères, ou qu'en tout cas tu devrais utiliser un DateFormat. Mais si tu débutes, on te pardonne

-
Edité par Zachee54 3 juillet 2019 à 12:57:19

Super Zachee54,

Je te remercie de ta clémence ;). Je débute effectivement.

Concernant le DateFormat, j'utilise une classe TalendDate qui doit avoir + ou - les mêmes méthodes. Si j'ai opté pour cette manière de faire, c'est parce que je dois faire un test sur une plage horaire, ce quoi conditionnera la tournée du lendemain (le matin ou l'après-midi). Peut être pourrais je utiliser between associée à DateFormat pour le coup ?

Je teste avec ta méthode de codage de ce pas. Encore merci pour la clarté de tes explications.

En POO, il est toujours plus propre d'utiliser les données dans une classe qui correspond à leur nature.

Si tu dois gérer des dates ou des heures, a fortiori pour détecter une plage horaire, il faut que tu utilises une classe qui implémente la notion de temps. La classe standard pour faire ça est java.util.Date, mais si tu utilises une classe d'un framework c'est très bien aussi.

Ton code sera d'autant plus robuste. Tu n'auras plus besoin de gérer les zéros non significatifs pour les minutes.

Ta méthode addZero pourra s'appeler getTournee(TalendDate) et prendre comme argument une instance qui représente une heure.
Parce que son travail, en fait, n'est pas d'ajouter des zéros là où il n'y en avait pas ; son travail est de déterminer la tournée en fonction de l'heure. Ainsi ta méthode sera concentrée sur son vrai travail, et par sur le formatage des données en amont.

Oui, je vois.

Je me suis documenté sur la classe SimpleDateFormat qui semble répondre à mes besoin. Je suis cependant tout de même obligé de manipuler séparément les heures et les minutes afin de les concaténer sans les ":" pour qu'il puissent subir le prédicat défini par ma plage horaire.

J'ai effectivement une Classe "TalendDate" avec une méthode "formatDate" qui me permet de récupérer l'heure au format HH:mm (String). Ma question est de savoir s'il y a un moyen de faire un prédicat de ma plage horaire sur ce format de données.

String pattern = "HH:mm";
String heures = TalendDate.formatDate(pattern, new Date());

-
Edité par gadje 3 juillet 2019 à 15:31:10

Je me répète parce que j'ai l'impression que tu ne m'as pas compris : est-ce que par hasard la classe TalendDate n'aurait pas des méthodes utiles permettant :

• soit d'avoir les heures au format numérique (7, 15 ou 18 par exemple) ?
• soit de tester si une heure est avant ou après une autre ?
  Dans ce cas tu as ton instance TalendDate, deux autres instances qui correspondent aux heures limite (disons 15h et 18h), et tu testes quelque chose comme :

if (hour.after(heurePlancher) && hour.before(heurePlafond)) {

Ne cherche pas à tout prix à obtenir des chaînes de caractères. C'est un comportement de débutant qui pose beaucoup de problèmes en POO.
Si ta classe TalendDate est bien faite, elle doit avoir tous les outils pour faire les tests que tu veux. Sers t'en !

-
Edité par Zachee54 3 juillet 2019 à 15:43:25

Ok,

Je m'entête effectivement à vouloir comparer de entiers. J'ai fais le tour des méthodes de la Classe "TalendDate" et je pense en avoir trouvé une qui doit faire le job.

/**
     * compare two date
     *
     * @param date1 (first date)
     * @param date2 (second date)
     * @param pattern (compare specified part, example: "yyyy-MM-dd")
     * @return the result wheather two date is the same, if first one less than second one return number -1, equlas
     * return number 0, bigger than return number 1. (can compare partly)
     *
     * {talendTypes} Integer
     *
     * {Category} TalendDate
     *
     * {param} date(myDate) date1 : the first date to compare
     *
     * {param} date(myDate2) date2 : the second date to compare
     *
     * {param} String("yyyy-MM-dd") pattern : compare specified part
     *
     * {examples}
     *
     * ->> compareDate(2008/11/24 12:15:25, 2008/11/24 16:10:35) return -1
     *
     * ->> compareDate(2008/11/24 16:10:35, 2008/11/24 12:15:25) return 1
     *
     * ->> compareDate(2008/11/24 12:15:25, 2008/11/24 16:10:35,"yyyy/MM/dd") return 0 #
     */

Sachant qu'il prend 2 Date et un String en paramètre, j'essaye de trouver comment définir une variable de type Date qui servira à définir la limite entre les tournées du matin et de l'après-midi.

-
Edité par gadje 3 juillet 2019 à 16:53:34

Oui, par exemple.

Si c'est seulement la tranche horaire qui t'intéresse, il faut choisir si tu veux comparer des dates complètes (date du jour + heure) ou des heures seulement (le jour étant indifférent).
Il y a plein de techniques possibles :

• Utiliser le troisième argument de la méthode en spécifiant un pattern heures-minutes :

TalendDate.compareDate(date, horairePlancher, 'hh:mm');

• Générer tes tranches horaires pour le jour en cours, et comparer avec la date complète fournie.
  Par exemple une TalendDate valant 2019-07-03 17:45 à comparer avec des TalendDate valant respectivement 2019-07-03 15:00:00 et 2019-07-03 18:00:00.

• Extraire seulement l'heure (et éventuellement les minutes) sous forme d'entier(s) et comparer avec l'heure fournie.
  Tu peux utiliser la méthode que je vois dans ton code :

TalendDate.getPartOfDate("HOUR_OF_DAY", date)

• Supprimer le jour, le mois et l'année dans la TalendDate fournie (ou les fixer à un jour "origine", par ex 01/01/1970) et comparer ça à tes tranches horaires. Mais là on s'approche du code artisanal...

-
Edité par Zachee54 3 juillet 2019 à 17:53:35

Ok Zachee54,

je te remercie, je teste tout ça de mon côté et je reviens vers toi si tu me le permets.

J'ai finalement suivi ton conseil en ne modifiant pas les Dates en int ou en  String. j'ai utilisé la méthode compareDate qui retourne -1, 0 ou 1, selon que l'heure testée soit avant, égale à ou après l'heure de référence.

Je n'ai plus qu'à récupérer cette valeur dans un Trigger qui la contrôlera afin d'exécuter l'une ou l'autre de mes  requête.

SimpleDateFormat dateformat = new SimpleDateFormat("hh:mm");
String pattern = "HH:mm"; // Définition du pattern Heures:minutes
//Date hNow = new Date(); // Recuperation de l'heure actuelle
Date hLim = dateformat.parse("15:00");
// Définition manuelle de l'heures, actuelle
Date hNow = dateformat.parse("08:00"); // Pour test manuel, heure actuelle

	int etat = TalendDate.compareDate(hNow, hLim, pattern); // Retourne -1, 0, ou 1, si l'heure actuelle est avant, égale à, ou après l'heure limite
			  
	//row1.etat = etat; // Faire passer la valeur de etat en argument au "Trigger Run if" avec un truc dans le genre 
	

Merci encore.

-
Edité par gadje 8 juillet 2019 à 16:46:15