// retourne l'objet joueur qui correspond à un nom complet ou une business Error si il n'existe pas
public FifaModeles.JoueursModele GetJoueurs(string nomCompletJoueur)
{
try
{
List <FifaModeles.JoueursModele> lJoueurs = this.ListAll();
foreach (FifaModeles.JoueursModele joueur in lJoueurs)
{
if ((joueur.prenom + " " + joueur.nom).Equals(nomCompletJoueur))
{
return(joueur);
}
}
BusinessError oErreur = new BusinessError("Ce joueur n'existe pas");
throw oErreur;
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
// renvoie true si le joueur n'a pas joué un match après la date fournie
public Boolean checkJoueurSiPasParticipation(Guid joueurId, DateTime date)
{
try
{
int countJoueursParticipation;
using (FifaManagerEphecEntities ctx = new FifaManagerEphecEntities(_Connection))
{
countJoueursParticipation = ctx.NombreParticipationJoueurApresDate(joueurId, date);
}
if (countJoueursParticipation > 0)
{
BusinessError oBusiness = new BusinessError("Le joueur a été inscrit sur une feuille de match à une date postérieure");
throw oBusiness;
}
else
{
return(true);
}
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
public static bool CheckNombreJoueurFeuillePasAssez(Guid equipeAId, Guid equipeBId, Guid matchId)
{
try
{
FeuillesMatchService fms = new FeuillesMatchService();
JoueursParticipationService jps = new JoueursParticipationService();
if (fms.FeuilleExiste(matchId))
{
int countJoueurEquipeA = jps.getCountJoueur(fms.GetFeuille(matchId, equipeAId).feuilleId);
int countJoueurEquipeB = jps.getCountJoueur(fms.GetFeuille(matchId, equipeBId).feuilleId);
if (countJoueurEquipeA >= NBMINJOUEUR && countJoueurEquipeB >= NBMINJOUEUR)
{
return(false);
}
}
else
{
BusinessError be = new BusinessError("Aucune feuille de match n'existe pour ce match, merci de les remplir avant");
throw be;
}
return(true);
}
catch (Exception ex)
{
throw ex;
}
}
//vérifie si il y n'a pas eu un transfert encodé d'un joueur lors de la saison avant la création de la participation de l'équipe
public Boolean checkPasTransfertAvantParticipation(List <EquipesModele> lEquipes, int annee)
{
try
{
//récupère la liste des transferts
TransfertsService ts = new TransfertsService();
List <FifaModeles.TransfertsModele> lTransferts = ts.ListAll();
foreach (FifaModeles.TransfertsModele transfert in lTransferts)
{
//vérfie pour chaque transfert si il y a eu déjà un transfert pour l'équipe l'année du championnat en création ou renvoie une businessError
if ((transfert.dateDebut.Year == annee || (transfert.dateFin.HasValue && transfert.dateFin.Value.Year == annee)) && (lEquipes.Any(x => x.equipeId == transfert.equipeId)))
{
BusinessError oBusiness = new BusinessError("Il y a déjà eu des transferts de joueurs enregistrés cette année, l'équipe ne peut pas être inscrite dans le championnat");
throw oBusiness;
}
}
return(true);
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
public Boolean checkPasDansQuarter(DateTime date)
{
try
{
// obtient la liste des quarters
List <FifaModeles.QuartersModele> lQuarters = this.ListAll();
foreach (FifaModeles.QuartersModele quarter in lQuarters)
{
if (date <= quarter.dateFin && date >= quarter.dateDebut)
{
// retourne un BusinessError si on trouve un quarter dans lequel la date se trouve
BusinessError bErreur = new BusinessError("La date encodée est dans un quarter");
throw bErreur;
}
}
// si il n'a trouvé de quarter qui corresponde renvoie true
return(true);
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
public FifaModeles.JoueursModele GetJoueurs(Guid joueurId)
{
try
{
List <FifaModeles.JoueursModele> lJoueurs = this.ListAll();
foreach (FifaModeles.JoueursModele joueur in lJoueurs)
{
if (joueur.joueurId == joueurId)
{
return(joueur);
}
}
BusinessError oErreur = new BusinessError("Ce joueur n'existe pas");
throw oErreur;
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
public void Set(BusinessError businessError)
{
var isFirstSet = !Errors.Any();
Errors.Add(businessError);
if (isFirstSet)
{
SetExecutionOrder(nameof(Errors));
}
}
// vérifie si une équipe participe bien à un championnat
public Boolean isParticipation(FifaModeles.EquipesModele equipe, DateTime date)
{
try
{
ChampionnatService cs = new ChampionnatService();
List <FifaModeles.ChampionnatsModele> lChampionnat = cs.ListAll();
//récupère le bon championnat
int i = 0;
FifaModeles.ChampionnatsModele championnat = null;
while (i < lChampionnat.Count && championnat == null)
{
if (date.Year == lChampionnat[i].annee)
{
championnat = lChampionnat[i];
}
i++;
}
//vérification, mais ne devrait jamais arrivé car il faut tester avant si il y a une intersaison qui existe
if (championnat == null)
{
BusinessError oBusiness = new BusinessError("Il n'y a pas de championnat à cette date");
throw oBusiness;
}
List <FifaModeles.EquipesParticipationModele> lParticipation = this.ListAll();
//vérifie si il y a une participation de l'équipe avec le championant correspondant à la date
foreach (FifaModeles.EquipesParticipationModele participation in lParticipation)
{
if (participation.championnatId == championnat.championnatId && participation.equipeId == equipe.equipeId)
{
return(true);
}
}
return(false);
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
//vérifie si l'équipe envoyée est bien dans les 3 derniers du championnat à la date envoyée
public Boolean isLastThree(EquipesModele equipe, DateTime date)
{
try
{
int NBEQUIPE = 3;
EquipesParticipationService eps = new EquipesParticipationService();
DataView oView = new GenerationTabClassementEquipe().getClassementEquipe(date).DefaultView;
//trie le tableau de manière ascendante
oView.Sort = "Points Totaux asc";
//vérifie que l'équipe d'arrivée est bien dans le championnat
if (eps.isParticipation(equipe, date))
{
if (oView.Count > NBEQUIPE)
{
for (int i = 0; i < NBEQUIPE; i++)
{
//vérifie si l'équipe est dans les 3 dernières row du tableau
if (oView[i]["Equipe :"].ToString() == equipe.nom)
{
return(true);
}
}
// retourne un BusinessError si l'équipe n'est pas dans les NBEQUIPE derniers
BusinessError bErreur = new BusinessError("L'équipe d'arrivée (" + equipe.nom + ") n'est pas classée dans les " + NBEQUIPE + " dernières équipes du classement");
throw bErreur;
}
else
{
return(true);
}
}
return(true);
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
/// <summary>
/// (message, domainType)
/// </summary>
/// <param name="businessError"></param>
/// <returns>(message, domainType)</returns>
/// <exception cref="Exception"></exception>
public static (string Message, Type Type) ErrorCode(BusinessError businessError)
{
switch (businessError)
{
case Exceptions.BusinessError.B001:
return("Cannot Add/Edit weekly report after locked time",
typeof(AddEditWeeklyReportPhrCommand));
case Exceptions.BusinessError.B002:
return("Cannot Add/Edit weekly report after locked time",
typeof(AddEditWeeklyReportPhrCommand));
default: throw new Exception("Invalid error code!");
}
}
//renvoie true si il a pu créer le championnat et en out le guid de ce nouveau championnat
public Boolean enregistrerNewChampionnat(int annee, out Guid championnatId)
{
Boolean _return = false;
championnatId = Guid.Empty;
using (FifaManagerEphecEntities ctx = new FifaManagerEphecEntities(_Connection))
{
try
{
//vérifie si un championnat existe déjà pour l'année annee et la crée si non.
if (this.ListAll().Where(x => x.annee == annee).FirstOrDefault() == null)
{
ctx.Championnats_Add(annee);
using (TransactionScope scope = new TransactionScope())
{
ctx.SaveChanges();
championnatId = this.getChampionnat(annee).championnatId;
scope.Complete();
}
_return = true;
}
if (!_return)
{
BusinessError oErreur = new BusinessError("Ce championnat existe déjà");
throw oErreur;
}
return(_return);
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
}
public void TransactionLookup(AmendData amendData)
{
try
{
amendData.Set(_tranLookupOperations.TransactionLookupForAmend(amendData));
var errors = amendData.TransactionLookup.TransactionLookupResp.Errors ?? new List <BusinessError>();
amendData.Set(errors);
}
catch (AgentConnectException acExp)
{
var error = new BusinessError
{
ErrorCategory = "AC Exception",
ErrorCode = acExp.ErrorCode.ToString(),
Message = acExp.Message
};
amendData.Set(error);
}
}
public AmendData SingleValidate(AmendData amendData)
{
try
{
// Get the all fields grouping and types for generation
amendData.Set(_gafOperations.GetInfoKeysWithGroupTypes(amendData.AmendOperationRequest.AgentId, amendData.AmendOperationRequest.AgentPos, amendData.GafInfoKeysWithGroups, GetAllFieldsTransactionType.Amend));
// Transaction Lookup
TransactionLookup(amendData);
if (DataErrorHandler.CheckForNestedErrors(amendData).Any())
{
return(amendData);
}
if (amendData.TransactionLookup.TransactionLookupResp.Payload.TransactionStatus != TransactionStatusType.AVAIL)
{
var error = new BusinessError
{
ErrorCategory = "Custom Error",
ErrorCode = string.Empty,
Message = "Transaction not available for AMEND."
};
amendData.Set(error);
}
// Validate Receive
_validationOperations.AmendValidate(amendData);
}
catch (AgentConnectException acExp)
{
var error = new BusinessError
{
ErrorCategory = "AC Exception",
ErrorCode = acExp.ErrorCode.ToString(),
Message = acExp.Message
};
amendData.Set(error);
}
return(amendData);
}
public int MyExecute(string pStoredName, List <SqlParameter> lstParam)
{
_Return = 0;
SqlConnection con = new SqlConnection();
con.ConnectionString = _Connection;
try
{
con.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandText = "secretariat." + pStoredName;
cmd.CommandType = CommandType.StoredProcedure;
foreach (SqlParameter oParam in lstParam)
{
cmd.Parameters.Add(oParam);
}
cmd.Connection = con;
_Return = cmd.ExecuteNonQuery();
con.Close();
}
catch (SqlException exsql)
{
BusinessError oErreur = new BusinessError(exsql);
throw oErreur;
}
catch (Exception ex)
{
throw ex;
}
return(_Return);
}
public SendReversalData TransactionLookup(SendReversalData sendReversalData)
{
try
{
sendReversalData.Set(_tranLookupOperations.TransactionLookupForSendReversal(sendReversalData));
var errors = sendReversalData.TransactionLookup.TransactionLookupResp.Errors ?? new List <BusinessError>();
sendReversalData.Set(errors);
}
catch (AgentConnectException acExp)
{
var error = new BusinessError
{
ErrorCategory = "AC Exception",
ErrorCode = acExp.ErrorCode.ToString(),
Message = acExp.Message
};
sendReversalData.Set(error);
}
return(sendReversalData);
}
//renvoie un quarter en fonction d'un championnat et d'un numéro de quarter (1 ou 2)
public QuartersModele getQuarter(ChampionnatsModele championnat, int numeroQuarter)
{
try
{
List <QuartersModele> lQuarterTrie = new List <QuartersModele>();
List <QuartersModele> lQuarter = new QuartersService().ListOneChampionnat(championnat);
if (numeroQuarter == 1)
{
lQuarterTrie = lQuarter.OrderBy(xx => xx.dateDebut).ToList();
}
if (numeroQuarter == 2)
{
lQuarterTrie = lQuarter.OrderByDescending(xx => xx.dateDebut).ToList();
}
if (numeroQuarter != 1 && numeroQuarter != 2)
{
// retourne un BusinessError si le numero de Quarter n'est pas bon
BusinessError bErreur = new BusinessError("Ce numéro de quarter n'est pas correct");
throw bErreur;
}
return(lQuarterTrie[0]);
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException.InnerException != null && ex.InnerException.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
public static Contracts.Domain.BusinessRules.ValidationResult Map(this FluentValidation.Results.ValidationResult validationResult)
{
if (validationResult.IsValid)
{
return(Contracts.Domain.BusinessRules.ValidationResult.Success);
}
var result = new Contracts.Domain.BusinessRules.ValidationResult();
foreach (var validationFailure in validationResult.Errors)
{
var error =
new BusinessError(
validationFailure.ErrorCode,
validationFailure.ErrorMessage,
_severtyMapper[validationFailure.Severity]);
result.AddError(error);
}
return(result);
}
public SendReversalData SingleValidate(SendReversalData sendReversalData)
{
try
{
// Transaction Lookup
TransactionLookup(sendReversalData);
if (DataErrorHandler.CheckForNestedErrors(sendReversalData).Any())
{
return(sendReversalData);
}
if (sendReversalData.TransactionLookup.TransactionLookupResp.Payload.TransactionStatus != TransactionStatusType.AVAIL)
{
var error = new BusinessError
{
ErrorCategory = "Custom Error",
ErrorCode = string.Empty,
Message = "Transaction not available for Send Reversal."
};
sendReversalData.Set(error);
}
// Validate Receive
_validationOperations.SendReversalValidate(sendReversalData);
}
catch (AgentConnectException acExp)
{
var error = new BusinessError
{
ErrorCategory = "AC Exception",
ErrorCode = acExp.ErrorCode.ToString(),
Message = acExp.Message
};
sendReversalData.Set(error);
}
return(sendReversalData);
}
public void AddError(BusinessError error)
{
this.executeErrors.Add(error);
}
/// <summary>
/// Maps the exception object to a business error object.
/// </summary>
/// <param name="source">
/// The source exception object.
/// </param>
/// <param name="errorCode">
/// The domain specific error code for the business error.
/// </param>
/// <param name="isFatalError">
/// Indicator, if the exception is a fatal one and recovery is not possible.
/// </param>
public static BusinessError ToBusinessError(this Exception source, int?errorCode = default(int?), bool?isFatalError = default(bool?))
{
return(BusinessError.FromException(source, errorCode, isFatalError));
}
public static string FormatToLogText(this BusinessError businessError)
{
return($"{businessError.ErrorCode}: {businessError.Message}" + (!string.IsNullOrEmpty(businessError.OffendingField) ? $" - {businessError.OffendingField}" : string.Empty));
}
public AmendData AmendComplete(AmendData amendData)
{
try
{
// Get the all fields grouping and types for generation
_gafOperations.GetInfoKeysWithGroupTypes(amendData.AmendOperationRequest.AgentId, amendData.AmendOperationRequest.AgentPos, amendData.GafInfoKeysWithGroups, GetAllFieldsTransactionType.Amend);
// Transaction Lookup
TransactionLookup(amendData);
if (DataErrorHandler.CheckForNestedErrors(amendData).Any())
{
return(amendData);
}
if (amendData.TransactionLookup.TransactionLookupResp.Payload.TransactionStatus != TransactionStatusType.AVAIL)
{
var error = new BusinessError
{
ErrorCategory = "Custom Error",
ErrorCode = string.Empty,
Message = "Transaction not available for AMEND."
};
amendData.Set(error);
}
// Validate Amend
_validationOperations.AmendValidate(amendData);
// Final Validate(s)
_validationOperations.AmendValidateUntilReadyForCommit(amendData);
if (DataErrorHandler.CheckForNestedErrors(amendData).Any())
{
return(amendData);
}
if (amendData.ValidationResponses.Last().Payload.ReadyForCommit)
{
CompleteSession(amendData);
}
else
{
var error = new BusinessError
{
ErrorCategory = "Custom Error",
ErrorCode = string.Empty,
Message = "Not ready to commit yet"
};
amendData.Set(error);
}
}
catch (AgentConnectException acExp)
{
var error = new BusinessError
{
ErrorCategory = "AC Exception",
ErrorCode = acExp.ErrorCode.ToString(),
Message = acExp.Message
};
amendData.Set(error);
}
return(amendData);
}
public void ExecuteFail(BusinessError error)
{
this.ExecuteResult.ExecuteFail(error);
}
public void enregistrerMatchs(DataView oView)
{
try
{
if (checkToutesDatesRemplies(oView, out string rowNumber))
{
if (checkDatesMatch(oView, out string rowNumber2))
{
using (FifaManagerEphecEntities ctx = new FifaManagerEphecEntities(_Connection))
{
//récupère la liste des équipes
EquipesService equipes = new EquipesService();
List <FifaModeles.EquipesModele> lEquipes = equipes.ListAll();
foreach (DataRowView oRow in oView)
{
//trouve l'Id des 2 équipes
Guid equipe1Id = Guid.Empty;
Guid equipe2Id = Guid.Empty;
int i = 0;
while ((equipe1Id == Guid.Empty || equipe2Id == Guid.Empty) && i < lEquipes.Count)
{
if (lEquipes[i].nom.Equals((String)oRow["Equipe à Domicile :"]))
{
equipe1Id = lEquipes[i].equipeId;
}
if (lEquipes[i].nom.Equals((String)oRow["Equipe à l'extérieur :"]))
{
equipe2Id = lEquipes[i].equipeId;
}
i++;
}
//assigne la date du match
DateTime matchDate = (DateTime)(oRow["Date du Match :"]);
//ajoute le match au DbSET
ctx.Matchs_Add(matchDate, equipe1Id, equipe2Id);
}
//enregistre le DbSet dans la database
using (TransactionScope scope = new TransactionScope())
{
ctx.SaveChanges();
scope.Complete();
}
}
}
else
{
BusinessError ex = new BusinessError("Une équipe ne peut pas jouer 2 fois le même jour", rowNumber2);
throw ex;
}
}
else
{
BusinessError ex = new BusinessError("Toutes les dates de match doivent être dans un quarter", rowNumber);
throw ex;
}
}
catch (Exception ex)
{
if (ex.InnerException != null && ex.InnerException is SqlException)
{
TechnicalError oErreur = new TechnicalError((SqlException)ex.InnerException);
throw oErreur;
}
else
{
throw ex;
}
}
}
public static void Throw(BusinessError businessError, object request)
{
var error = ErrorCode(businessError);
throw new Features.Exceptions.BusinessException(businessError.ToString(), error.Message, error.Type, request);
}
public SendReversalData SendReversalComplete(SendReversalData sendReversalData)
{
try
{
// Transaction Lookup
TransactionLookup(sendReversalData);
if (DataErrorHandler.CheckForNestedErrors(sendReversalData).Any())
{
return(sendReversalData);
}
if (sendReversalData.TransactionLookup.TransactionLookupResp.Payload.TransactionStatus != TransactionStatusType.AVAIL)
{
var error = new BusinessError
{
ErrorCategory = "Custom Error",
ErrorCode = string.Empty,
Message = "Transaction not available for SendReversal."
};
sendReversalData.Set(error);
}
// Validate SendReversal
_validationOperations.SendReversalValidate(sendReversalData);
// Final Validate(s)
_validationOperations.SendReversalValidateUntilReadyForCommit(sendReversalData);
if (DataErrorHandler.CheckForNestedErrors(sendReversalData).Any())
{
return(sendReversalData);
}
if (sendReversalData.ValidationResponses.Last().Payload.ReadyForCommit)
{
CompleteSession(sendReversalData);
}
else
{
var error = new BusinessError
{
ErrorCategory = "Custom Error",
ErrorCode = string.Empty,
Message = "Not ready to commit yet"
};
sendReversalData.Set(error);
}
}
catch (AgentConnectException acExp)
{
var error = new BusinessError
{
ErrorCategory = "AC Exception",
ErrorCode = acExp.ErrorCode.ToString(),
Message = acExp.Message
};
sendReversalData.Set(error);
}
return(sendReversalData);
}
public void ExecuteFail(BusinessError error)
{
this.Success = false;
AddError(error);
}
public BusinessException(BusinessError error)
: base(error.Message)
{
_error = error;
}
public void RemoveError(BusinessError error)
{
this.executeErrors.Remove(error);
}
protected void AddBrokenRule(BusinessError businessRule)
{
_brokenRules.Add(businessRule);
}
