com.itnsa.gestion.service

Interface LotSousLotService

All Superinterfaces:

IService

public interface LotSousLotService
extends IService

Field Summary

Fields

Modifier and Type	Field and Description
static String	SERVICE_ID

Method Summary

Methods

Modifier and Type	Method and Description
void	_creerLotSansTache(Lot lot)
FLotZl	ajouterLotZL(FLotZl lotZl)
Lot	creerLot(Lot lot, boolean nePasCreerTacheAuto)
void	creerLotDepuisModele(FAffaires affaire, FMdlot mdLot, List<FPlTache> listeTaches) Création des lots depuis un modèle
boolean	creerLotDepuisModele(FAffaires affaire, FMdlot mdLot, List<FPlTache> listeTaches, boolean indCreationAff)
Lot	creerLotFromAffaire(Lot lot, boolean nePasCreerTacheAuto, PlTachesAvecPiecesLiees plTachesAvecPiecesLiees, boolean movePiecesLieesAuto)
Lot	creerLotFromAffaireWithStructure(Lot lot, boolean nePasCreerTacheAuto)
Lot	creerLotWithStructure(Lot lot, boolean nePasCreerTacheAuto)
SousLot	creerSsLot(SousLot sslot)
SousLot	creerSsLot(SousLot sslot, boolean creerUneTacheAutomatiquement)
SousLot	creerSsLotFromAffaire(SousLot sousLot, List<FPlTache> listeTaches, boolean moveTask, PlTachesAvecPiecesLiees plTachesAvecPiecesLiees, boolean movePiecesLieesAuto)
SousLot	creerSsLotFromAffaireWithStructure(SousLot sousLot, List<FPlTache> listeTaches, boolean moveTask, PlTachesAvecPiecesLiees plTachesAvecPiecesLiees, boolean movePiecesLieesAuto)
void	creerSsLotLight(SousLot sslot)
SousLot	creerSsLotWithStructure(SousLot sslot)
List<FAffSstrait>	findAffSstraitByAffaire(String codeAffairePilote, String codeAffairePrest, TypeSousTraitance typeSousTraitance)
List<FAffSstrait>	findAffSstraitByAffaire(String codeAffairePilote, String codeAffairePrest, TypeSousTraitance typeSousTraitance, Double idMarche)
List<FLot>	findByListeIdent(List<Double> listeIdent) Retourne les lots.
List<FLot>	findLotByAffaire(String codeAffaire) Search the batches of an affair given in parameter.
List<FLot>	findLotByAffaireAndModule(ModuleActif moduleActif, String codeAffaire) Search the batches of an affair given in parameter.
List<FLot>	findLotLikeCodeAndAffaire(String codeAffaire, String codeLot) Recherche des lots (like code) pour un code affaire donné
List<FLot>	findLotLikeCodeAndAffaire(String codeAffaire, String codeLot, boolean loadSsLot, boolean includeCloture, Date dateRef)
List<FLot>	findLotLikeCodeAndAffaire(String codeAffaire, String codeLot, boolean loadSsLot, boolean includeCloture, Date dateRef, ModuleActif moduleActif)
List<FLot>	findLotLikeCodeAndAffaireSansSsLot(String codeAffaire, String codeLot) Chargement des lot sans le chargement des sous lots
List<FLot>	findLotLikeCodeAndAffaireSansSsLot(String codeAffaire, String codeLot, boolean includeCloture) Chargement des lot sans le chargement des sous lots
List<FLot>	findLotLikeCodeByAffaireAndModuleAndCloture(ModuleActif moduleActif, String codeAffaire, String codeLot, String cloture)
List<FSslot>	findSousLotByAffaireAndLot(String codeAffaire, String codeLot) Search the under-batches of an affair and a batch given in parameter.
List<FSslot>	findSousLotByAffaireAndLotAndModule(ModuleActif moduleActif, String codeAffaire, String codeLot) Search the under-batches of an affair and a batch given in parameter.
List<FSslot>	findSousLotLikeCodeAndAffaireAndLot(String codeAffaire, String codeLot, String codeSousLot) Recherche les sous-lots d'un lot et d'une affaire par leur code
List<FSslot>	findSousLotLikeCodeAndAffaireAndLot(String codeAffaire, String codeLot, String codeSousLot, ModuleActif moduleActif)
List<FSslot>	findSousLotLikeCodeAndAffaireAndLot(String codeAffaire, String codeLot, String codeSousLot, ModuleActif moduleActif, String cloture, Date dateRef)
List<FSslot>	findSousLotLikeCodeByAffaireAndLotAndModuleAndCloture(ModuleActif moduleActif, String codeAffaire, String codeLot, String codeSousLot, String cloture)
List<FSslot>	findSousLotLikeCodeByAffaireAndLotAndModuleAndCloture(ModuleActif moduleActif, String codeAffaire, String codeLot, String codeSousLot, String cloture, Date dateRef)
List<LotSuggest>	findSuggestLotLikeCodeLotByAffaire(String codeAffaire, String codeLot, Date dateFin, ModuleActif module, Integer nbMaxLots)
List<SousLotSuggest>	findSuggestSousLotLikeCodeSousLotByLot(Double identLot, String codeSousLot, Date dateFin, ModuleActif module, Integer nbMaxSousLots)
List<FsslotZl>	getAllSsZLLotByAfffaire(String codeAffaire) recherche toutes les zl ses sous lots
List<FLotZl>	getAllZLLotByAfffaire(String codeAffaire) recherche toutes les zl ses lots
boolean	isCodeEtatLotCoherentDepuisModule(ModuleActif module, FLot lot) Tests if a batch can be visible from the activated module according to its state code.
boolean	isCodeEtatSousLotCoherentDepuisModule(ModuleActif module, FSslot sousLot) Tests if an under-batch can be visible from the activated module according to its state code.
boolean	isCoherentAffaireLotSousLot(FAffaires affaire, FLot lot, FSslot ssLot) Vérifie la cohérence entre Affaire / lot / sous lot
boolean	isEnabledEtatClotureLot(ModuleActif module, FLot lot) Tests if the batch in parameter can be enclosed according to the parameter setting of the table F_Tables.
boolean	isEnabledEtatClotureSousLot(ModuleActif module, FSslot sousLot) Tests if the under-batch in parameter can be enclosed according to the parameter setting of the table F_Tables.
boolean	isPriseEnCompteDateDebutOperationnelleLot(ModuleActif module, FLot lot, Date dateOperation) Tests if the operational beginning date is >= to the date in parameter.
boolean	isPriseEnCompteDateDebutOperationnelleSousLot(ModuleActif module, FSslot sousLot, Date dateOperation) Tests if the operational beginning date is >= to the date in parameter.
boolean	isPriseEnCompteDateFinOperationnelleLot(ModuleActif module, FLot lot, Date dateOperation) Tests if the operational end date is >= to the date in parameter.
boolean	isPriseEnCompteDateFinOperationnelleSousLot(ModuleActif module, FSslot sousLot, Date dateOperation) Tests if the operational end date is >= to the date in parameter.
List<Lot>	listeLotDepuisModele(FAffaires affaire, FMdlot mdLot, List<String> codeLot) liste des lots en fontion du modele et du code lot
List<IdentCodeLibelleNumOrdre>	listeSousLotDepuisModele(FMdlot mdLot, String codeLot, String codeSsLot)
FSslot	loadByCodeAndIdentLot(Double identLot, String codeSousLot) Charge le sous lot avec l'identifiant du lot, et le code du sous lot.
DetailPiece	loadDetailLot(Double idLot)
DetailPiece	loadDetailSsLot(Double idSsLot)
FLot	loadLotAvecSousLotsByIdent(Double identLot)
FLot	loadLotByCodeAndAffaire(String codeAffaire, String codeLot) Searchs a batch with its code and the code of the affair linked.
FLot	loadLotByCodeAndAffaire(String codeAffaire, String codeLot, boolean chargerSousLots)
FLot	loadLotByIdent(Double identLot) Searchs a batch with its code and the code of the affair linked.
FSslot	loadSousLotByCodeAndAffaireAndLot(String codeAffaire, String codeLot, String codeSousLot) Searchs an under-batch by its code and the code of the affair linked and the code of the batch linked.
FSslot	loadSousLotByIdent(Double identSousLot) Searchs a batch with its code and the code of the affair linked.
List<FLotZl>	loadZlByAffaire(String codeAffaire)
List<FLotZl>	loadZlByLot(Double identLot)
void	majEtatLot(FLot lot, String newEtaff) Changer le code état d'un lot
void	majEtatSslot(FSslot sslot, String newEtaff) Changer le code état d'un sous lot
void	modifierListeLot(List<Double> listeIdentLot, LotUpdateLot lotUpdateLot) Met à jour les lots
void	modifierLot(FLot lot)
Lot	modifierLot(Lot lot)
FLtSstrait	modifierLtSstrait(FLtSstrait ltSstrait)
void	modifierSsLot(FSslot sslot)
SousLot	modifierSsLot(SousLot sslot)
void	modifierZonesLibresListeLot(List<Double> listeIdentLot, ZonesLibres zonesLibres)
List<TEtaff>	rechercheEtatAffaire(EtatAffaireLotSousLotCriteresRecherche critere) recherche Etat de l'Affaire
List<LotResultatRecherche>	rechercheMultiCriteresLot(LotCriteresRecherche critere)
List<FLot>	rechercheMultiCriteresPersistentLot(LotCriteresRecherche critere)
List<FLot>	searchLot(ModuleActif moduleActif, String text, FAffaires affaires, Date dtRef)
List<FLot>	searchLot(ModuleActif moduleActif, String text, String codeAffaire, Date dtRef)
List<FSslot>	searchSousLot(ModuleActif moduleActif, String text, FAffaires affaires, Date dtRef, FLot lot)
List<FSslot>	searchSousLot(ModuleActif moduleActif, String text, String codeAffaire, Date dtRef, String codeLot)
List<FSslot>	searchSslot(SslotCritereRecherche critere) Recherche multicritéres de sous lot
FLot	setIndClotureLot(FLot lot)
FSslot	setIndClotureSousLot(FSslot souslot)
void	supprimerLot(FLot lot) suppression de lot
void	supprimerSsLot(FSslot sslot) suppression de souslot

Methods inherited from interface com.itnsa.fwk.service.IService

getServerMessages, resetServerMessages

Field Detail

SERVICE_ID

static final String SERVICE_ID

See Also:

Constant Field Values

Method Detail

creerLot

Lot creerLot(Lot lot,
           boolean nePasCreerTacheAuto)

creerLotWithStructure

Lot creerLotWithStructure(Lot lot,
                        boolean nePasCreerTacheAuto)

creerLotDepuisModele

void creerLotDepuisModele(FAffaires affaire,
                        FMdlot mdLot,
                        List<FPlTache> listeTaches)

Création des lots depuis un modèle

creerLotDepuisModele

boolean creerLotDepuisModele(FAffaires affaire,
                           FMdlot mdLot,
                           List<FPlTache> listeTaches,
                           boolean indCreationAff)

setIndClotureLot

FLot setIndClotureLot(FLot lot)

modifierLot

void modifierLot(FLot lot)

modifierLot

Lot modifierLot(Lot lot)

creerSsLot

SousLot creerSsLot(SousLot sslot)

creerSsLot

SousLot creerSsLot(SousLot sslot,
                 boolean creerUneTacheAutomatiquement)

setIndClotureSousLot

FSslot setIndClotureSousLot(FSslot souslot)

creerSsLotWithStructure

SousLot creerSsLotWithStructure(SousLot sslot)

modifierLtSstrait

FLtSstrait modifierLtSstrait(FLtSstrait ltSstrait)

modifierSsLot

void modifierSsLot(FSslot sslot)

modifierSsLot

SousLot modifierSsLot(SousLot sslot)

findSousLotByAffaireAndLot

List<FSslot> findSousLotByAffaireAndLot(String codeAffaire,
                                      String codeLot)

Search the under-batches of an affair and a batch given in parameter.

Parameters:

codeAffaire - The affair code

codeLot - The batch code

Returns:

List of under-batches found

findSousLotLikeCodeAndAffaireAndLot

List<FSslot> findSousLotLikeCodeAndAffaireAndLot(String codeAffaire,
                                               String codeLot,
                                               String codeSousLot)

Recherche les sous-lots d'un lot et d'une affaire par leur code

findSousLotLikeCodeAndAffaireAndLot

List<FSslot> findSousLotLikeCodeAndAffaireAndLot(String codeAffaire,
                                               String codeLot,
                                               String codeSousLot,
                                               ModuleActif moduleActif)

findSousLotLikeCodeAndAffaireAndLot

List<FSslot> findSousLotLikeCodeAndAffaireAndLot(String codeAffaire,
                                               String codeLot,
                                               String codeSousLot,
                                               ModuleActif moduleActif,
                                               String cloture,
                                               Date dateRef)

findLotByAffaire

List<FLot> findLotByAffaire(String codeAffaire)

Search the batches of an affair given in parameter.

Parameters:

codeAffaire - The affair code

Returns:

List of batches found

findLotByAffaireAndModule

List<FLot> findLotByAffaireAndModule(ModuleActif moduleActif,
                                   String codeAffaire)

Search the batches of an affair given in parameter. The state of the batches must be allowed for the activated module given in parameter.

Parameters:

codeAffaire - The affair code

moduleActif - The module activated

Returns:

List of batches found

findLotLikeCodeByAffaireAndModuleAndCloture

List<FLot> findLotLikeCodeByAffaireAndModuleAndCloture(ModuleActif moduleActif,
                                                     String codeAffaire,
                                                     String codeLot,
                                                     String cloture)

findSousLotByAffaireAndLotAndModule

List<FSslot> findSousLotByAffaireAndLotAndModule(ModuleActif moduleActif,
                                               String codeAffaire,
                                               String codeLot)

Search the under-batches of an affair and a batch given in parameter. The state of the under-batches must be allowed for the activated module given in parameter.

Parameters:

codeAffaire - The affair code

codeLot - The batch code

moduleActif - The module activated

Returns:

List of under-batches found

findSousLotLikeCodeByAffaireAndLotAndModuleAndCloture

List<FSslot> findSousLotLikeCodeByAffaireAndLotAndModuleAndCloture(ModuleActif moduleActif,
                                                                 String codeAffaire,
                                                                 String codeLot,
                                                                 String codeSousLot,
                                                                 String cloture)

findLotLikeCodeAndAffaire

List<FLot> findLotLikeCodeAndAffaire(String codeAffaire,
                                   String codeLot)

Recherche des lots (like code) pour un code affaire donné

Parameters:

codeAffaire - Recherche exacte

codeLot - Recherche like

Returns:

La liste des lots de l'affaire

findLotLikeCodeAndAffaireSansSsLot

List<FLot> findLotLikeCodeAndAffaireSansSsLot(String codeAffaire,
                                            String codeLot)

Chargement des lot sans le chargement des sous lots

Parameters:

codeAffaire -

codeLot -

Returns:

findLotLikeCodeAndAffaireSansSsLot

List<FLot> findLotLikeCodeAndAffaireSansSsLot(String codeAffaire,
                                            String codeLot,
                                            boolean includeCloture)

Chargement des lot sans le chargement des sous lots

Parameters:

codeAffaire -

codeLot -

Returns:

findLotLikeCodeAndAffaire

List<FLot> findLotLikeCodeAndAffaire(String codeAffaire,
                                   String codeLot,
                                   boolean loadSsLot,
                                   boolean includeCloture,
                                   Date dateRef)

findLotLikeCodeAndAffaire

List<FLot> findLotLikeCodeAndAffaire(String codeAffaire,
                                   String codeLot,
                                   boolean loadSsLot,
                                   boolean includeCloture,
                                   Date dateRef,
                                   ModuleActif moduleActif)

loadLotByCodeAndAffaire

FLot loadLotByCodeAndAffaire(String codeAffaire,
                           String codeLot)

Searchs a batch with its code and the code of the affair linked.

Parameters:

codeLot - The batch code

codeAffaire - The affair code

Returns:

The bacth found

loadSousLotByCodeAndAffaireAndLot

FSslot loadSousLotByCodeAndAffaireAndLot(String codeAffaire,
                                       String codeLot,
                                       String codeSousLot)

Searchs an under-batch by its code and the code of the affair linked and the code of the batch linked.

Parameters:

codeSousLot - The under-batch code

codeLot - The batch code

codeAffaire - The affair code

Returns:

The under-batch found

findSousLotLikeCodeByAffaireAndLotAndModuleAndCloture

List<FSslot> findSousLotLikeCodeByAffaireAndLotAndModuleAndCloture(ModuleActif moduleActif,
                                                                 String codeAffaire,
                                                                 String codeLot,
                                                                 String codeSousLot,
                                                                 String cloture,
                                                                 Date dateRef)

loadLotByIdent

FLot loadLotByIdent(Double identLot)

Searchs a batch with its code and the code of the affair linked.

Parameters:

identLot - le code Sous Lot

loadSousLotByIdent

FSslot loadSousLotByIdent(Double identSousLot)

Searchs a batch with its code and the code of the affair linked.

Parameters:

identSousLot - l'ident du Sous Lot

Returns:

isCodeEtatSousLotCoherentDepuisModule

boolean isCodeEtatSousLotCoherentDepuisModule(ModuleActif module,
                                            FSslot sousLot)

Tests if an under-batch can be visible from the activated module according to its state code.

Parameters:

sousLot - The under-batch

module - The activated module

Returns:

True if the state code of the under-batch allows it to be visible from the activated module or if the state code is null.
False if it doesn't.

isCodeEtatLotCoherentDepuisModule

boolean isCodeEtatLotCoherentDepuisModule(ModuleActif module,
                                        FLot lot)

Tests if a batch can be visible from the activated module according to its state code.

Parameters:

Lot - The batch

module - The activated module

Returns:

True if the state code of the batch allows it to be visible from the activated module or if the state code is null.
False if it doesn't.

isCoherentAffaireLotSousLot

boolean isCoherentAffaireLotSousLot(FAffaires affaire,
                                  FLot lot,
                                  FSslot ssLot)

Vérifie la cohérence entre Affaire / lot / sous lot

Returns:

VRAI si la cohérence Affaire / lot / sous lot est vérifiée, FAUX sinon.

majEtatLot

void majEtatLot(FLot lot,
              String newEtaff)

Changer le code état d'un lot

majEtatSslot

void majEtatSslot(FSslot sslot,
                String newEtaff)

Changer le code état d'un sous lot

ajouterLotZL

FLotZl ajouterLotZL(FLotZl lotZl)

searchSslot

List<FSslot> searchSslot(SslotCritereRecherche critere)

Recherche multicritéres de sous lot

rechercheMultiCriteresPersistentLot

List<FLot> rechercheMultiCriteresPersistentLot(LotCriteresRecherche critere)

rechercheMultiCriteresLot

List<LotResultatRecherche> rechercheMultiCriteresLot(LotCriteresRecherche critere)

findSuggestLotLikeCodeLotByAffaire

List<LotSuggest> findSuggestLotLikeCodeLotByAffaire(String codeAffaire,
                                                  String codeLot,
                                                  Date dateFin,
                                                  ModuleActif module,
                                                  Integer nbMaxLots)

findSuggestSousLotLikeCodeSousLotByLot

List<SousLotSuggest> findSuggestSousLotLikeCodeSousLotByLot(Double identLot,
                                                          String codeSousLot,
                                                          Date dateFin,
                                                          ModuleActif module,
                                                          Integer nbMaxSousLots)

listeLotDepuisModele

List<Lot> listeLotDepuisModele(FAffaires affaire,
                             FMdlot mdLot,
                             List<String> codeLot)

liste des lots en fontion du modele et du code lot

loadZlByLot

List<FLotZl> loadZlByLot(Double identLot)

loadZlByAffaire

List<FLotZl> loadZlByAffaire(String codeAffaire)

creerSsLotLight

void creerSsLotLight(SousLot sslot)

supprimerLot

void supprimerLot(FLot lot)

suppression de lot

supprimerSsLot

void supprimerSsLot(FSslot sslot)

suppression de souslot

findAffSstraitByAffaire

List<FAffSstrait> findAffSstraitByAffaire(String codeAffairePilote,
                                        String codeAffairePrest,
                                        TypeSousTraitance typeSousTraitance)

findAffSstraitByAffaire

List<FAffSstrait> findAffSstraitByAffaire(String codeAffairePilote,
                                        String codeAffairePrest,
                                        TypeSousTraitance typeSousTraitance,
                                        Double idMarche)

isPriseEnCompteDateFinOperationnelleLot

boolean isPriseEnCompteDateFinOperationnelleLot(ModuleActif module,
                                              FLot lot,
                                              Date dateOperation)

Tests if the operational end date is >= to the date in parameter. Takes into account the parameter setting of the table F_Tables.

Parameters:

module - The activated module from which the search is launched.

lot - The bean of the batch to test

dateOperation - The date to compare

Returns:

True if the operational end date is >= to the date in parameter.
False if the operational end date is < to the date in parameter or if this criteria don't have to be taken into account according to the parameter setting.

isPriseEnCompteDateDebutOperationnelleLot

boolean isPriseEnCompteDateDebutOperationnelleLot(ModuleActif module,
                                                FLot lot,
                                                Date dateOperation)

Tests if the operational beginning date is >= to the date in parameter. Takes into account the parameter setting of the table F_Tables.

Parameters:

module - The activated module from which the search is launched.

lot - The bean of the batch to test

dateOperation - The date to compare

Returns:

True if the operational beginning date is >= to the date in parameter.
False if the operational beginning date is < to the date in parameter or if this criteria don't have to be taken into account according to the parameter setting.

isEnabledEtatClotureLot

boolean isEnabledEtatClotureLot(ModuleActif module,
                              FLot lot)

Tests if the batch in parameter can be enclosed according to the parameter setting of the table F_Tables.

Parameters:

module - The activated module from which the search is launched.

lot - The bean of the batch to test

Returns:

True if the batch in parameter is not allowed to be enclosed. (state enclosed)
False if the batch in parameter is allowed to be enclosed (according to the parameter setting) or if this criteria don't have to be taken into account according to the parameter setting.

isPriseEnCompteDateFinOperationnelleSousLot

boolean isPriseEnCompteDateFinOperationnelleSousLot(ModuleActif module,
                                                  FSslot sousLot,
                                                  Date dateOperation)

Tests if the operational end date is >= to the date in parameter. Takes into account the parameter setting of the table F_Tables.

Parameters:

module - The activated module from which the search is launched.

sousLot - The bean of the under-batch to test

dateOperation - The date to compare

Returns:

True if the operational end date is >= to the date in parameter.
False if the operational end date is < to the date in parameter or if this criteria don't have to be taken into account according to the parameter setting.

isPriseEnCompteDateDebutOperationnelleSousLot

boolean isPriseEnCompteDateDebutOperationnelleSousLot(ModuleActif module,
                                                    FSslot sousLot,
                                                    Date dateOperation)

Tests if the operational beginning date is >= to the date in parameter. Takes into account the parameter setting of the table F_Tables.

Parameters:

module - The activated module from which the search is launched.

souLot - The bean of the under-batch to test

dateOperation - The date to compare

Returns:

True if the operational beginning date is >= to the date in parameter.
False if the operational beginning date is < to the date in parameter or if this criteria don't have to be taken into account according to the parameter setting.

isEnabledEtatClotureSousLot

boolean isEnabledEtatClotureSousLot(ModuleActif module,
                                  FSslot sousLot)

Tests if the under-batch in parameter can be enclosed according to the parameter setting of the table F_Tables.

Parameters:

module - The activated module from which the search is launched.

sousLot - The bean of the under-batch to test

Returns:

True if the batch in parameter is not allowed to be enclosed. (state enclosed)
False if the batch in parameter is allowed to be enclosed (according to the parameter setting) or if this criteria don't have to be taken into account according to the parameter setting.

rechercheEtatAffaire

List<TEtaff> rechercheEtatAffaire(EtatAffaireLotSousLotCriteresRecherche critere)

recherche Etat de l'Affaire

getAllSsZLLotByAfffaire

List<FsslotZl> getAllSsZLLotByAfffaire(String codeAffaire)

recherche toutes les zl ses sous lots

getAllZLLotByAfffaire

List<FLotZl> getAllZLLotByAfffaire(String codeAffaire)

recherche toutes les zl ses lots

loadLotByCodeAndAffaire

FLot loadLotByCodeAndAffaire(String codeAffaire,
                           String codeLot,
                           boolean chargerSousLots)

loadByCodeAndIdentLot

FSslot loadByCodeAndIdentLot(Double identLot,
                           String codeSousLot)

Charge le sous lot avec l'identifiant du lot, et le code du sous lot.

modifierListeLot

void modifierListeLot(List<Double> listeIdentLot,
                    LotUpdateLot lotUpdateLot)

Met à jour les lots

findByListeIdent

List<FLot> findByListeIdent(List<Double> listeIdent)

Retourne les lots.

loadLotAvecSousLotsByIdent

FLot loadLotAvecSousLotsByIdent(Double identLot)

loadDetailLot

DetailPiece loadDetailLot(Double idLot)

loadDetailSsLot

DetailPiece loadDetailSsLot(Double idSsLot)

modifierZonesLibresListeLot

void modifierZonesLibresListeLot(List<Double> listeIdentLot,
                               ZonesLibres zonesLibres)

_creerLotSansTache

void _creerLotSansTache(Lot lot)
                        throws T9Exception

Throws:

T9Exception

searchLot

List<FLot> searchLot(ModuleActif moduleActif,
                   String text,
                   FAffaires affaires,
                   Date dtRef)

searchLot

List<FLot> searchLot(ModuleActif moduleActif,
                   String text,
                   String codeAffaire,
                   Date dtRef)

searchSousLot

List<FSslot> searchSousLot(ModuleActif moduleActif,
                         String text,
                         FAffaires affaires,
                         Date dtRef,
                         FLot lot)

searchSousLot

List<FSslot> searchSousLot(ModuleActif moduleActif,
                         String text,
                         String codeAffaire,
                         Date dtRef,
                         String codeLot)

listeSousLotDepuisModele

List<IdentCodeLibelleNumOrdre> listeSousLotDepuisModele(FMdlot mdLot,
                                                      String codeLot,
                                                      String codeSsLot)

creerLotFromAffaire

Lot creerLotFromAffaire(Lot lot,
                      boolean nePasCreerTacheAuto,
                      PlTachesAvecPiecesLiees plTachesAvecPiecesLiees,
                      boolean movePiecesLieesAuto)

creerLotFromAffaireWithStructure

Lot creerLotFromAffaireWithStructure(Lot lot,
                                   boolean nePasCreerTacheAuto)

creerSsLotFromAffaire

SousLot creerSsLotFromAffaire(SousLot sousLot,
                            List<FPlTache> listeTaches,
                            boolean moveTask,
                            PlTachesAvecPiecesLiees plTachesAvecPiecesLiees,
                            boolean movePiecesLieesAuto)

creerSsLotFromAffaireWithStructure

SousLot creerSsLotFromAffaireWithStructure(SousLot sousLot,
                                         List<FPlTache> listeTaches,
                                         boolean moveTask,
                                         PlTachesAvecPiecesLiees plTachesAvecPiecesLiees,
                                         boolean movePiecesLieesAuto)