public async Task <IActionResult> Edit(int id, [Bind("ID,MembreID,MontantPayer,DatePayement,MoyenPayement,IDTransaction,AvanceAccord,MontantAvance,MembreAvanceID")] Paiement paiement)
{
if (id != paiement.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(paiement);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaiementExists(paiement.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(paiement));
}
public async Task <IActionResult> PutPaiement([FromRoute] string id, [FromBody] Paiement paiement)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != paiement.uuid)
{
return(BadRequest());
}
_context.Entry(paiement).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaiementExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutPaiement(int id, Paiement paiement)
{
if (id != paiement.Id_Paiement)
{
return(BadRequest());
}
_context.Entry(paiement).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaiementExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <ActionResult <Paiement> > PostPaiement(Paiement paiement)
{
_context.Paiement.Add(paiement);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetPaiement", new { id = paiement.Id_Paiement }, paiement));
}
public static Paiement GetPaiementById(string id, bool initializer = true)
{
var pdao = PaiementDAL.SelectPaiementById(id);
var utilisateurPaiement = new Utilisateur();
var lotPaiement = new Lot();
if (initializer)
{
lotPaiement = LotORM.GetLotById(LotDAL.SelectLotById(pdao.LotId).IdLot, false);
utilisateurPaiement =
UtilisateurORM.GetUtilisateurById(
UtilisateurDAL.SelectUtilisateurById(pdao.UtilisateurId).IdUtilisateur, false);
}
var paiement = new Paiement(pdao.IdPaiement, utilisateurPaiement, pdao.TypePaiement,
pdao.ValidationPaiement, lotPaiement);
if (initializer)
{
_paiementsDictionary[paiement.IdPaiement] = paiement;
LotORM.Populate(paiement.LotPaiement);
UtilisateurORM.Populate(new List <Utilisateur>(new[]
{
paiement.UtilisateurPaiement
}));
}
return(paiement);
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Du,Motif,Type,Detail,ContratId")] Paiement paiement)
{
if (id != paiement.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(paiement);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaiementExists(paiement.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["ContratId"] = new SelectList(_context.Contrat, "Id", "Id", paiement.ContratId);
return(View(paiement));
}
public async Task <IActionResult> Edit(int id, [Bind("ID,visiteID,datePaiement,typePaiementID,montant,remarque")] Paiement paiement)
{
if (id != paiement.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(paiement);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaiementExists(paiement.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
ViewData["typePaiementID"] = new SelectList(_context.TypePaiements, "ID", "ID", paiement.typePaiementID);
ViewData["visiteID"] = new SelectList(_context.Visites, "ID", "ID", paiement.visiteID);
return(View(paiement));
}
//--------------------------------------------------------------------
public int Insert(Paiement pPaiement)
{
string[] lsCols = null;
string[] lsValues = null;
this.FillArray(ref lsCols, ref lsValues, pPaiement, true);
return(DataBase.Insert("[tblPaiement]", lsCols, lsValues));
}
//---------------------------------------------------------------------
private void FillArray(ref string[] pCols, ref string[] pValues, Paiement pPaiement, bool pIsInsertID)
{
int liCpt = 0;
int liNombre = 4 + 0;
if (pIsInsertID)
{
pCols = new string[liNombre + 1];
pValues = new string[liNombre + 1];
pCols[liCpt] = "ID";
pValues[liCpt++] = "'" + pPaiement.ID.ToString() + "'";
}
else
{
pCols = new string[liNombre];
pValues = new string[liNombre];
}
pCols[liCpt] = "Numéro";
pValues[liCpt++] = "'" + Util.DoubleQuote(pPaiement.Numéro) + "'";
pCols[liCpt] = "DatePaiement";
pValues[liCpt++] = "'" + pPaiement.DatePaiement.ToString() + "'";
pCols[liCpt] = "Montant";
pValues[liCpt++] = "'" + pPaiement.Montant.ToString() + "'";
pCols[liCpt] = "TypePaiement";
pValues[liCpt++] = "'" + Util.DoubleQuote(pPaiement.TypePaiement) + "'";
}
//---------------------------------------------------------------------
public int Update(Paiement pPaiement)
{
string[] lsCols = null;
string[] lsValues = null;
this.FillArray(ref lsCols, ref lsValues, pPaiement, false);
return(DataBase.UpdateID("tblPaiement", lsCols, lsValues, pPaiement.ID));
}
public ActionResult DeleteConfirmed(decimal id)
{
Paiement paiement = db.Paiement.Find(id);
db.Paiement.Remove(paiement);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public async Task <ActionResult> DeleteConfirmed(int id)
{
Paiement paiement = await db.Paiement.FindAsync(id);
db.Paiement.Remove(paiement);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
public override Task InitializeAsync(object navigationData)
{
Paiement paiement = (Paiement)navigationData;
Titre = paiement.Titre;
Amount = paiement.amount;
IdMagazine = paiement.IdMagazine;
return(Task.FromResult(false));
}
/// <summary>
/// Initialise la machine à café avec la boisson Café, le paiement Espèces et la quantité de sucre à 3 grammes par défaut
/// </summary>
public MachineCafé()
{
Console.WriteLine("Initialisation de la machine à café.");
_boissonChoisie = Boisson.Café;
_paiementChoisi = Paiement.Espèces;
_quantitéSucre = 3;
_boissonChoisieBool = false;
_paiementChoisiBool = false;
_quantitéSucreBool = false;
}
public bool RequestPaiement(Paiement paiement, int idMagazine)
{
RestRequest request = new RestRequest($"{Constant.PaiementRequestUrl}{Settings.CurrentUser.Id}/{idMagazine}")
{
Method = Method.POST
};
request.AddJsonBody(paiement);
return(Execute(request).StatusCode == System.Net.HttpStatusCode.OK);
}
public async Task <ActionResult> Edit([Bind(Include = "PaiementID,Amount,PaidDate,PatientID,TreatmentID")] Paiement paiement)
{
if (ModelState.IsValid)
{
db.Entry(paiement).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(paiement));
}
public async Task <ActionResult> Edit([Bind(Include = "Id,Montant,Libelle,DatePaiement,PaiementAJour")] Paiement paiement)
{
if (ModelState.IsValid)
{
db.Entry(paiement).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(paiement));
}
public async Task <IActionResult> Create([Bind("Id,Du,Motif,Type,Detail,ContratId")] Paiement paiement)
{
if (ModelState.IsValid)
{
_context.Add(paiement);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["ContratId"] = new SelectList(_context.Contrat, "Id", "Id", paiement.ContratId);
return(View(paiement));
}
public async Task <ActionResult> Create([Bind(Include = "Id,Montant,Libelle,DatePaiement,PaiementAJour")] Paiement paiement)
{
if (ModelState.IsValid)
{
db.Paiement.Add(paiement);
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
return(View(paiement));
}
public bool Contains(Paiement value)
{
foreach (Paiement s in base.List)
{
if (value.Equals(s))
{
return(true);
}
}
return(false);
}
public ActionResult Edit([Bind(Include = "id,Job_id,libelle,montant,avance,reste,type,etat,archived,status,created,Ins_id,Pos_id")] Paiement paiement)
{
if (ModelState.IsValid)
{
db.Entry(paiement).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.Job_id = new SelectList(db.Job, "id", "titre", paiement.Job_id);
ViewBag.Ins_id = new SelectList(db.Postuler, "Ins_id", "libelle", paiement.Ins_id);
return(View(paiement));
}
public static void Populate(Paiement paiement)
{
// liste des paiements qui on beusoin de se faire peupler (leurs liste utilisateurs)
if (!PaiementAlreadyInDictionary(paiement.IdPaiement))
{
GetPaiementById(paiement.IdPaiement);
}
paiement.UtilisateurPaiement = _paiementsDictionary[paiement.IdPaiement].UtilisateurPaiement;
paiement.LotPaiement = _paiementsDictionary[paiement.IdPaiement].LotPaiement;
}
public async Task <IActionResult> Create([Bind("ID,visiteID,datePaiement,typePaiementID,montant,remarque")] Paiement paiement)
{
if (ModelState.IsValid)
{
_context.Add(paiement);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
ViewData["typePaiementID"] = new SelectList(_context.TypePaiements, "ID", "ID", paiement.typePaiementID);
ViewData["visiteID"] = new SelectList(_context.Visites, "ID", "ID", paiement.visiteID);
return(View(paiement));
}
// GET: Paiements/Details/5
public async Task <ActionResult> Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Paiement paiement = await db.Paiements.FindAsync(id);
if (paiement == null)
{
return(HttpNotFound());
}
return(View(paiement));
}
// GET: Paiements/Details/5
public ActionResult Details(decimal id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Paiement paiement = db.Paiement.Find(id);
if (paiement == null)
{
return(HttpNotFound());
}
return(View(paiement));
}
public static List <Paiement> findAll()
{
List <Paiement> paiements = new List <Paiement>();
OdbcCommand cmd = new OdbcCommand("select Id from paiement", AccesBd.getConnection());
OdbcDataReader dr = cmd.ExecuteReader();
while (dr.Read())
{
Paiement paiement = find(dr.GetInt32(0));
paiements.Add(paiement);
}
cmd.Dispose();
return(paiements);
}
// GET: Paiements/Edit/5
public ActionResult Edit(decimal id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Paiement paiement = db.Paiement.Find(id);
if (paiement == null)
{
return(HttpNotFound());
}
ViewBag.Job_id = new SelectList(db.Job, "id", "titre", paiement.Job_id);
ViewBag.Ins_id = new SelectList(db.Postuler, "Ins_id", "libelle", paiement.Ins_id);
return(View(paiement));
}
//--------------------------------------------------------------------
public Paiement Find(Guid ID)
{
Paiement lPaiement = (Paiement)AbstractFind(ID);
if (Util.isNULL(lPaiement))
{
DataRow row = DataBase.SelectID(ID, "[tblPaiement]");
if (Util.isNULL(row))
{
return(null);
}
lPaiement = this.FillFields(row);
LoadedMap.Add(lPaiement.ID, lPaiement);
}
return(lPaiement);
}
//--------------------------------------------------------------------
private Paiement FillFields(DataRow pDataRow)
{
Paiement lPaiement = new Paiement();
lPaiement.Numéro = (string)pDataRow["Numéro"];
lPaiement.DatePaiement = (DateTime)pDataRow["DatePaiement"];
lPaiement.Montant = (decimal)pDataRow["Montant"];
lPaiement.TypePaiement = (string)pDataRow["TypePaiement"];
lPaiement.ID = new Guid(pDataRow["ID"].ToString());
return(lPaiement);
}
public static Paiement find(int Id)
{
Paiement paiement = null;
OdbcCommand cmd = new OdbcCommand("select * from paiement where Id=?", AccesBd.getConnection());
cmd.Parameters.Add("@id", OdbcType.Int).Value = Id;
OdbcDataReader dr = cmd.ExecuteReader();
if (dr.Read())
{
paiement = new Paiement {
Id = dr.GetInt32(0), Montant = dr.GetInt32(1), Description = dr.GetString(2), Date = dr.GetDateTime(3), Lieu = dr.GetString(4)
};
}
cmd.Dispose();
return(paiement);
}
