public static Historique getHistorique(string idEhchere)
{
string connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
SqlConnection connection = new SqlConnection(connectionString);
string request = "SELECT * FROM Historique WHERE idEnchere = '" + idEhchere + "' ORDER BY Prix DESC";
SqlCommand command = new SqlCommand(request, connection);
Historique his = null;
try {
connection.Open();
SqlDataReader reader = command.ExecuteReader();
if (!reader.Read())
{
his = new Historique(0, "0", "0", 0, DateTime.Now);
}
else
{
his = new Historique((int)reader["Id"], (string)reader["IdMembre"], (string)reader["IdEnchere"], (decimal)reader["Prix"], (DateTime)reader["Date"]);
}
reader.Close();
return(his);
} catch (Exception e) {
System.Console.WriteLine(e.Message);
} finally {
connection.Close();
}
return(null);
}
public void commencerLesortFinal(Fichier f)
{
Fichier f2 = getFichierById(f.idFichier);
f = f2;
if (f.HangFireNotificationID != null)
{
RecurringJob.RemoveIfExists(f.HangFireRecJobNotID);
BackgroundJob.Delete(f.HangFireNotificationID);
BackgroundJob.Delete(f.HangFireID);
f.HangFireNotificationID = 0 + "";
f.HangFireRecJobNotID = 0 + "";
}
f.sortFinalComm = 1;
fichierDAOSQLServer.modifierFichier(f);
new ActionsNotification().supprimerNotDuFichier(f);
Historique h = new Historique();
h.textHistorique = "L archive " + f.Nom + " a étè conserve definitivement";
h.IdFichier = f.idFichier;
h.date = DateTime.Now;
new ActionsHistorique().ajouterHistorique(h);
}
/// <summary>
/// Calcul le résultat des deux valeurs séléctionner avec l'opérateur choisi
/// </summary>
private void Calcul()
{
if (!string.IsNullOrWhiteSpace(ValueShown1) && !string.IsNullOrWhiteSpace(ValueShown2) &&
!string.IsNullOrWhiteSpace(Operator))
{
bool error = false;
ErrorMessage = "";
int result = 0;
int value1 = int.Parse(ValueShown1);
int value2 = int.Parse(ValueShown2);
if ((value1 == 0 || value2 == 0) && Operator == "÷")
{
result = -1;
ErrorMessage = "Impossible de diviser par 0";
error = true;
}
else
{
switch (Operator)
{
case "+":
result = value1 + value2;
break;
case "-":
result = value1 - value2;
break;
case "÷":
result = value1 / value2;
break;
case "×":
result = value1 * value2;
break;
default:
result = -1;
break;
}
}
if (result >= 0 && !error)
{
Historique.Add(new mathadorOper(ValueShown1, ValueShown2, Operator, result.ToString(),
_operatorPoints[Operator]));
CalcPoint();
_firstSelectedValue.IsEnabled = false;
SetValue(_firstSelectedValue, " ");
SetValue(_lastSelectedValue, result.ToString());
}
else
{
if (!error)
{
ErrorMessage = "Resultat inferieur à 0 impossible !";
}
}
ClearValue();
}
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Date,ProduitID,QteStock,Action,QteMouv")] Historique historique)
{
if (id != historique.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(historique);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HistoriqueExists(historique.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction("Index"));
}
ViewData["ProduitID"] = new SelectList(_context.Produits, "ID", "ID", historique.ProduitID);
return(View(historique));
}
private void LoadChallenge()
{
ChangeStateValueButton(true);
LoadMathadorsValue(MathadorCollection[_rdmIndexMathador.Next(0, MathadorCollection.Count - 1)]);
Historique.Clear();
NextButton.IsEnabled = false;
}
public void supprimerHistorique(Historique h)
{
using (IDbConnection connection = new System.Data.SqlClient.SqlConnection(ConnectionHelper.conVal("CalendrierDatabase")))
{
connection.Execute($"DELETE FROM Historique WHERE IdHistorique='{h.IdHistorique}';");
}
}
public void ajouterHistorique(Historique h)
{
using (IDbConnection connection = new System.Data.SqlClient.SqlConnection(ConnectionHelper.conVal("CalendrierDatabase")))
{
connection.Execute($"INSERT INTO Historique(textHistorique,date,idFichier) values('{h.textHistorique}','{h.date}','{h.IdFichier}')");
}
}
public void Create(Historique NouvelHistorique)
{
using (_connection)
{
_connection.Open();
SqlCommand command = new SqlCommand("INSERT INTO Historique (Id_Historique,Id_Cheval,Débourrage," + //les champs de la table
"Preé_Entrainement," +
"Entraineur_Precedent,Proprietaire_Precedent)" +
"VALUES (@id_hitorique, @id_cheval,@debourrage," + //les champs a rentrer
"@pré_entrainement, @entraineur_précédent, " +
"@proprietaire_precedent)");
command.Parameters.AddWithValue("id_hitorique", NouvelHistorique.Id_Historique);
command.Parameters.AddWithValue("id_cheval", NouvelHistorique.Id_Cheval);
command.Parameters.AddWithValue("debourrage", NouvelHistorique.Débourrage);
command.Parameters.AddWithValue("pré_entrainement", NouvelHistorique.Preé_Entrainement);
command.Parameters.AddWithValue("entraineur_précédent", NouvelHistorique.Entraineur_Precedent);
command.Parameters.AddWithValue("proprietaire_precedent", NouvelHistorique.Proprietaire_Precedent);
command.ExecuteNonQuery();
_connection.Close();
}
}
public async Task <IActionResult> PutHistorique([FromRoute] int id, [FromBody] Historique historique)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != historique.HistoriqueID)
{
return(BadRequest());
}
_context.Entry(historique).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HistoriqueExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Update(Historique HistoriqueAModifier)
{
using (_connection)
{
_connection.Open();
SqlCommand command = new SqlCommand("UPDATE Historique SET Id_Cheval = @id_cheval" +
"Débourrage = @debourrage, Preé_Entrainement = pré_entrainement" +
"Entraineur_Precedent = @entraineur_précédent, Proprietaire_Precedent = @proprietaire_precedent" +
"WHERE Id_Historique = @id_hitorique");
command.Parameters.AddWithValue("id_hitorique", HistoriqueAModifier.Id_Historique);
command.Parameters.AddWithValue("id_cheval", HistoriqueAModifier.Id_Cheval);
command.Parameters.AddWithValue("debourrage", HistoriqueAModifier.Débourrage);
command.Parameters.AddWithValue("pré_entrainement", HistoriqueAModifier.Preé_Entrainement);
command.Parameters.AddWithValue("entraineur_précédent", HistoriqueAModifier.Entraineur_Precedent);
command.Parameters.AddWithValue("proprietaire_precedent", HistoriqueAModifier.Proprietaire_Precedent);
command.ExecuteNonQuery();
_connection.Close();
}
}
public Historique Get(int idAChercher)
{
Historique GetHistorique = new Historique();
using (_connection)
{
_connection.Open();
SqlCommand command = new SqlCommand("SELECT * FROM Historique where id = @idCherch", _connection);
command.Parameters.AddWithValue("idCherch", idAChercher);
using SqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
new Historique
{
Id_Historique = reader["Id_Historique"] == DBNull.Value ? 0 : (int)reader["Id_Historique"],
Id_Cheval = reader["Id_Cheval"] == DBNull.Value ? 0 : (int)reader["Id_Cheval"],
Débourrage = reader["Débourrage"] == DBNull.Value ? string.Empty : (string)reader["Débourrage"],
Preé_Entrainement = reader["Pré-entrainement"] == DBNull.Value ? string.Empty : (string)reader["Pré-entrainement"],
Entraineur_Precedent = reader["Entraineur_Precedent"] == DBNull.Value ? string.Empty : (string)reader["Entraineur_Precedent"],
Proprietaire_Precedent = reader["Proprietaire_Precedent"] == DBNull.Value ? string.Empty : (string)reader["Proprietaire_Precedent"],
};
}
}
_connection.Close();
return(GetHistorique);
}
public int BotAttaque(Personnage personnageA, Personnage personnageD, int turn, int combatid)
{
Historique historique = new Historique();
personnageD.Pv -= personnageA.Attaque - personnageD.Defense;
historique.personnageACtif = personnageA;
historique.personnagePassif = personnageD;
historique.Degat = personnageA.Attaque - personnageD.Defense;
historique.Turn = turn;
historique.CombatId = combatid;
using (var db = new DbFightContext())
{
db.Historiques.Add(historique);
}
if (personnageD.Pv < 0)
{
personnageD.Pv = 0;
using (var db = new DbFightContext())
{
var combat = db.Combats.Where(x => x.Id == combatid).First();
db.Combats.Update(combat);
db.SaveChanges();
}
}
return(personnageD.Pv);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,DateEntree,DateSortie,HopitalId,PatientId")] Historique historique)
{
if (id != historique.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(historique);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!HistoriqueExists(historique.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["HopitalId"] = new SelectList(_context.Hopitals, "Id", "Id", historique.HopitalId);
ViewData["PatientId"] = new SelectList(_context.Patients, "Id", "Nom", historique.PatientId);
return(View(historique));
}
public void SetHistorique(Historique histo)
{
if(Historique != null)
Historique.NouvelleAction -= new Historique.DelegateAction(MAJHistoriqueDel);
Historique = histo;
Historique.NouvelleAction += new Historique.DelegateAction(MAJHistoriqueDel);
}
public ActionResult DeleteConfirmed(int id)
{
Historique historique = db.Historiques.Find(id);
db.Historiques.Remove(historique);
db.SaveChanges();
return(RedirectToAction("Activite"));
}
public ActionResult UpdateEnchere(UpdateEnchereViewModel en)
{
if (ModelState.IsValid)
{
Encher model = new Encher();
Encher enOld = EnchereRequette.getEnchereById(en.Id);
Objet obj = ObjetRequette.getObjetById(en.IdObjet);
if ((enOld.PrixAchat + enOld.PasDePrix) > en.Prix)
{
ViewBag.err = "Au moins augmenter le prix par " + enOld.PasDePrix + "$!";
return(View(en));
}
Historique his = EnchereRequette.getHistorique(en.Id);
if (his.Prix > en.Prix + en.PasDePrix)
{
model.PrixAchat = en.Prix + en.PasDePrix;
model.IdAcheteur = his.IdMembre;
//// Send Email to en.IdAcheteur
}
else if (his.Prix >= en.Prix)
{
model.PrixAchat = his.Prix;
model.IdAcheteur = his.IdMembre;
//// Send Email to en.IdAcheteur
}
else
{
model.PrixAchat = his.Prix + en.PasDePrix;
model.IdAcheteur = en.IdAcheteur;
//// Send Email to his.IdMembre
}
Membre mb = MembreRequette.GetUserByNumero(model.IdAcheteur);
Utility.Mail.SendEmail(obj.Nom, model.PrixAchat, mb.Adresse);
model.Id = en.Id;
model.IdObjet = en.IdObjet;
//model.IdAcheteur = en.IdAcheteur;
model.IdVendeur = en.IdVendeur;
//model.PrixAchat = en.Prix;
model.PasDePrix = en.PasDePrix;
model.DateDepart = en.DateDepart;
model.DateFin = en.DateFin;
model.Etat = en.Etat;
EnchereRequette.updateEnchere(model);
his = new Historique(0, en.IdAcheteur, en.Id, en.Prix, DateTime.Now);
EnchereRequette.insertHistorique(his);
////// send E_mail to add //////
return(RedirectToAction("Index", "Home"));
}
return(View(en));
}
public ActionResult Edit([Bind(Include = "ID,Utilisateur,Origine,Type,Details,Statut,Date")] Historique historique)
{
if (ModelState.IsValid)
{
db.Entry(historique).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Activite"));
}
return(View(historique));
}
public bool CreateHistorique(Historique historique)
{
RestRequest request = new RestRequest()
{
Method = Method.POST
};
request.AddJsonBody(historique);
return(Execute(request).StatusCode == System.Net.HttpStatusCode.Created ? true : false);
}
public static String commArchivage(String idF)
{
ActionsFichier act = new ActionsFichier();
HangFireUtil hang = new HangFireUtil(act);
Fichier f = act.getFichierById(Int32.Parse(idF));
f.commArch = 1;
act.modifier(f);
f.type = new ActionsType().getTypeById(f.idType);
if (f.type.DUAselon == "DateAjout")
{
f.dateSuppression = f.dateAjout.AddDays(f.type.duree);
act.modifier(f);
if (f.type.action == "Destruction")
{
hang.DestructionSelonAjout(f);
}
else if (f.type.action == "Conservation")
{
hang.ConservationSelonAjout(f);
}
}
else if (f.type.DUAselon == "DateDernierAcces")
{
if (f.type.action == "Destruction")
{
hang.DestructionSelonDernerAcces(f);
}
else if (f.type.action == "Conservation")
{
hang.ConservationSelonDernerAcces(f);
}
}
Historique h = new Historique();
h.textHistorique = "les regles de conservation sont applique pour l archive " + f.Nom;
h.IdFichier = f.idFichier;
h.date = DateTime.Now;
new ActionsHistorique().ajouterHistorique(h);
if (f.sortFinalComm == 0)
{
return(RetentionArchives.ArchiveInfoGenerateur(f));
}
else if (f.sortFinalComm == 1)
{
return(RetentionArchives.ArchiveInfoGenerateur(f));
}
else
{
return("verifiez votre connection");
}
}
public ActionResult Create([Bind(Include = "ID,Utilisateur,Origine,Type,Details,Statut,Date")] Historique historique)
{
if (ModelState.IsValid)
{
db.Historiques.Add(historique);
db.SaveChanges();
return(RedirectToAction("Activite"));
}
return(View(historique));
}
public async Task <IActionResult> PostHistorique([FromBody] Historique historique)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_context.Historiques.Add(historique);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetHistorique", new { id = historique.HistoriqueID }, historique));
}
public static List <HistoEncheObjet> lesProduitsInteressants(string idMembre, string courriel)
{
string chConnexion = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
SqlConnection connexion = new SqlConnection(chConnexion);
string requete = "SELECT DISTINCT IdEnchere FROM Historique WHERE IdMembre ='" + idMembre + "'";
SqlCommand commande = new SqlCommand(requete, connexion);
commande.CommandType = System.Data.CommandType.Text;
List <Historique> maListe = new List <Historique>();
try
{
connexion.Open();
SqlDataReader dr = commande.ExecuteReader();
while (dr.Read())
{
Historique o = new Historique(
0,
(string)idMembre,
(string)dr["IdEnchere"],
10,
DateTime.Now
);
maListe.Add(o);
}
dr.Close();
List <HistoEncheObjet> listHisto = new List <HistoEncheObjet>();
foreach (Historique en in maListe)
{
listHisto.Add(getHistoEncherObjet(en.IdEnchere));
}
return(listHisto);
}
catch (Exception e)
{
System.Console.WriteLine(e.Message);
}
finally
{
connexion.Close();
}
return(null);
}
public async Task <IActionResult> Create([Bind("ID,Date,ProduitID,QteStock,Action,QteMouv")] Historique historique)
{
if (ModelState.IsValid)
{
_context.Add(historique);
await _context.SaveChangesAsync();
return(RedirectToAction("Index"));
}
ViewData["ProduitID"] = new SelectList(_context.Produits, "ID", "ID", historique.ProduitID);
return(View(historique));
}
public int Create(Historique historique)
{
Command command = new Command("CreateHistorique", true);
command.AddParameter("Id_Cheval", historique.Id_Cheval);
command.AddParameter("Debourage", historique.Debourage);
command.AddParameter("Pre_Entrainement", historique.Pre_Entrainement);
command.AddParameter("Entraineur_Precedent", historique.Entraineur_Precedent);
command.AddParameter("Proprietaire_Precedent", historique.Proprietaire_Precedent);
command.AddParameter("Elevage", historique.Elevage);
return _connection.ExecuteNonQuery(command);
}
public async Task <IActionResult> Create([Bind("Id,DateEntree,DateSortie,HopitalId,PatientId")] Historique historique)
{
if (ModelState.IsValid)
{
_context.Add(historique);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["HopitalId"] = new SelectList(_context.Hopitals, "Id", "Id", historique.HopitalId);
ViewData["PatientId"] = new SelectList(_context.Patients, "Id", "Nom", historique.PatientId);
return(View(historique));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Historique historique = db.Historiques.Find(id);
if (historique == null)
{
return(HttpNotFound());
}
return(View(historique));
}
public static string getArchiveInfo(String idArch)
{
ActionsFichier actsF = new ActionsFichier();
int idArchive = 0;
Int32.TryParse(idArch, out idArchive);
Fichier f = actsF.getFichierById(idArchive);
f.dateDernierAcces = DateTime.Now;
if (f.commArch == 1)
{
if (f.sortFinalComm == 0)
{
f.type = new ActionsType().getTypeById(f.idType);
if (f.type.DUAselon == "DateDernierAcces")
{
if (f.type.action == "Destruction")
{
new HangFireUtil(actsF).DestructionSelonDernerAcces(f);
}
else if (f.type.action == "Conservation")
{
new HangFireUtil(actsF).ConservationSelonDernerAcces(f);
}
}
}
}
Historique h = new Historique();
h.textHistorique = "L archive " + f.Nom + " de type " + f.type.nomType + " a étè accede";
h.IdFichier = f.idFichier;
h.date = DateTime.Now;
new ActionsHistorique().ajouterHistorique(h);
actsF.modifier(f);
if (f.sortFinalComm == 0)
{
return(ArchiveInfoGenerateur(f));
}
else if (f.sortFinalComm == 1)
{
return(ArchiveInfoGenerateur(f));
}
else
{
return("verifiez votre connection");
}
}
public ActionResult Historique()
{
if (User.IsInRole(SecurityRole.Demandeur))
{
Historique h = new Historique();
ApplicationUser current = db.Users.Where(u => u.UserName == User.Identity.Name).First();
var accept = db.Achats.Where(a => a.DepartmentID == current.DepartmentID && a.State == StateDemande.DemandeAccepter).ToList();
var refu = db.Achats.Where(a => a.DepartmentID == current.DepartmentID && a.State == StateDemande.DemandeRefuser).ToList();
IList <Refused> refused = new List <Refused>();
foreach (var r in refu)
{
refused.Add(new Refused {
Avis = db.Avis.Where(a => a.AchatID == r.ID && a.Accept == false).First(), Achat = r
});
}
h.Refused = refused;
h.Accepted = accept;
return(View(h));
}
else if (User.IsInRole(SecurityRole.RespAcha))
{
Historique h = new Historique();
var accept = db.Achats.Where(a => a.State == StateDemande.DemandeAccepter).ToList();
var refu = db.Achats.Where(a => a.State == StateDemande.DemandeRefuser).ToList();
IList <Refused> refused = new List <Refused>();
foreach (var r in refu)
{
refused.Add(new Refused {
Avis = db.Avis.Where(a => a.AchatID == r.ID && a.Accept == false).First(), Achat = r
});
}
h.Refused = refused;
h.Accepted = accept;
return(View(h));
}
return(View());
}
public static void insertHistorique(Historique his)
{
string connectionString = ConfigurationManager.ConnectionStrings["DefaultConnection"].ConnectionString;
SqlConnection connection = new SqlConnection(connectionString);
string request = "INSERT INTO Historique (IdMembre, IdEnchere, Prix, Date) VALUES ('" + his.IdMembre + "', '" + his.IdEnchere + "', '" + his.Prix + "', '" + his.Date.ToString("yyyy-MM-dd") + "')";
SqlCommand command = new SqlCommand(request, connection);
try {
connection.Open();
command.ExecuteNonQuery();
} catch (Exception e) {
System.Console.WriteLine(e.Message);
} finally {
connection.Close();
}
}
internal static ChevalHistoriqueAPI DALHistoriqueChevalToAPI(this Historique historique)
{
return(new ChevalHistoriqueAPI()
{
Nom_Cheval = histoRipository.GetNomChevalParHisto(historique.Id_Historique),
Pere_Cheval = histoRipository.GetNomPereChevalParHisto(historique.Id_Historique),
Mere_Cheval = histoRipository.GetNomMereChevalParHisto(historique.Id_Historique),
Race = histoRipository.GetRaceChevalParHisto(historique.Id_Historique),
Age = histoRipository.GetAgeChevalParHisto(historique.Id_Historique),
Sexe = histoRipository.GetSexeChevalParHisto(historique.Id_Historique),
Debourage = historique.Debourage,
Pre_Entrainement = historique.Pre_Entrainement,
Entraineur_Precedent = historique.Entraineur_Precedent,
Proprietaire_Precedent = historique.Pre_Entrainement,
Elevage = historique.Elevage
});
}
public bool Insert(Historique historique)
{
try
{
using (var bdd = new DataService.AcoreDBEntities())
{
bdd.Historique.Add(historique);
bdd.HistoriqueData.AddRange(historique.HistoriqueData);
bdd.SaveChanges();
}
return(true);
}
catch (Exception e)
{
Console.WriteLine("Exception: {0}", e);
return(false);
}
}
