// GET: Mouvements/Edit/5
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Mouvement mouvement = db.Mouvements.Find(id);
if (mouvement == null)
{
return(HttpNotFound());
}
ViewBag.EntreeMagasinID = new SelectList(db.Magasins, "MagasinID", "NomMagasin", mouvement.EntreeMagasinID);
ViewBag.SortieMagasinID = new SelectList(db.Magasins, "MagasinID", "NomMagasin", mouvement.SortieMagasinID);
ViewBag.TypeMouvementID = new SelectList(db.TypeMouvements, "TypeMouvementID", "Designation", mouvement.TypeMouvementID);
return(View(mouvement));
}
/// <summary>
/// Sauvegarde un virement
/// </summary>
/// <param name="mouvement">le mouvement d'origine du virement</param>
/// <param name="idCompte">l'id du compte sur lequel s'effectue sur le virement</param>
/// <returns>la task</returns>
public static async Task SaveVirement(Mouvement mouvement, int idCompte)
{
await DemarrageRoaming();
var create = mouvement.Id == 0;
Mouvement mouvementA;
Mouvement mouvementB;
//mise à jour
if (!create)
{
await SupprimerMouvementRoaming(mouvement.Id);
mouvement.Id = 0;
}
mouvementA = mouvement;
var idA = await AjouterMouvementRoaming(mouvementA);
var idDeviseA = (await RoamingCompteBusiness.GetCompte(mouvementA.IdCompte)).IdDevise;
var idDeviseB = (await RoamingCompteBusiness.GetCompte(idCompte)).IdDevise;
mouvementB = new Mouvement
{
Id = 0,
Commentaire = mouvementA.Commentaire,
Credit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Debit),
Debit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Credit),
Date = mouvementA.Date,
IdCompte = idCompte,
ModeMouvement = mouvementA.ModeMouvement,
Numero = mouvementA.Numero,
IdType = mouvementA.IdType,
IsTypePerso = mouvementA.IsTypePerso,
IdMouvementVirement = idA
};
var idB = await AjouterMouvementRoaming(mouvementB);
mouvementA.Id = idA;
mouvementA.IdMouvementVirement = idB;
await ModifierMouvementRoaming(mouvementA);
}
/// <summary>
/// Ajoute un mouvement à traiter dans le roaming
/// </summary>
/// <param name="mouvement">le mouvement à ajouter</param>
/// <returns>l'id roaming du mouvement ajouté</returns>
public static async Task <int> AjouterMouvementRoaming(Mouvement mouvement)
{
await DemarrageRoaming();
var mouvementId = _roamingMouvement.ListeMouvement.OrderByDescending(x => x.Id).FirstOrDefault();
var id = 1;
if (mouvementId != null)
{
id = mouvementId.Id + 1;
}
mouvement.Id = id;
_roamingMouvement.ListeMouvement.Add(mouvement);
await CalculerSolde(mouvement, null);
await SaveFile();
return(id);
}
/// <summary>
/// Ajoute un mouvement en base, ou le met à jour si déjà existant
/// </summary>
/// <param name="mouvement">le mouvement à ajouter avec l'id à 0 pour ajout, sinon l'id véritable</param>
/// <returns>l'id du mouvement ajouter/updater</returns>
public async Task <int> SaveMouvement(Mouvement mouvement)
{
//si c'est un nouveau mouvement creation
if (mouvement.Id == 0)
{
var mouvementId =
await Bdd.Connection.Table <Mouvement>().OrderByDescending(x => x.Id).FirstOrDefaultAsync();
var id = 1;
if (mouvementId != null)
{
id = mouvementId.Id + 1;
}
mouvement.Id = id;
mouvement.IsPasse = false;
await Bdd.AjouterDonnee(mouvement);
await CalculerSolde(mouvement, null);
return(id);
}
else
{
var oldMouvement = await Bdd.Connection.Table <Mouvement>().Where(x => x.Id == mouvement.Id).FirstOrDefaultAsync();
//si le mouvement à metre à jour est un ancien virement
if (mouvement.IdMouvementVirement > 0)
{
var mouvementToDelete = await Bdd.Connection.Table <Mouvement>().Where(x => x.Id == mouvement.IdMouvementVirement).FirstOrDefaultAsync();
await Bdd.DeleteDonnee(mouvementToDelete);
mouvement.IdMouvementVirement = 0;
await CalculerSolde(null, mouvementToDelete);
}
await Bdd.UpdateDonnee(mouvement);
await CalculerSolde(mouvement, oldMouvement);
return(mouvement.Id);
}
}
private void GetMouvementsPossiblesRec(PlateauIA plateau, Stack <Tuple <int, Mouvement> > possibles, ref Coords origine, Mouvement coups, int nbPrises = 0)
{
Coords tmpPos;
PieceIA tmpPiece;
Coords[] directions = GetDirections();
if (coups.Sauts.Count > 0)
{
possibles.Push(new Tuple <int, Mouvement>(nbPrises, coups));
}
for (int i = 0; i < 4; i++)
{
tmpPos = origine + directions[i];
if (Plateau.EstDansLePlateau(tmpPos))
{
tmpPiece = plateau.Get(tmpPos);
if (i < 2 && nbPrises == 0)//si le mouvement est vers l'avant, sans prise
{
if (tmpPiece == null)
{
var tmp = new Mouvement(coups);
tmp.Sauts.Enqueue(tmpPos);
possibles.Push(new Tuple <int, Mouvement>(0, tmp));
}
}
if (tmpPiece != null && tmpPiece.EstBlanc != EstBlanc && !tmpPiece.flag)
{
tmpPos = tmpPos + directions[i];
if (Plateau.EstDansLePlateau(tmpPos) && plateau.Get(tmpPos) == null)
{
// flag pour ne pas ressauter des pieces
var tmp = new Mouvement(coups);
tmp.Sauts.Enqueue(tmpPos);
tmpPiece.flag = true;
GetMouvementsPossiblesRec(plateau, possibles, ref tmpPos, tmp, nbPrises + 1);
tmpPiece.flag = false;
}
}
}
}
}
// Update is called once per frame
/*
* On met à jour les mains, ainsi que la distance entre les différents doigts de la main gauche.
*/
void Update()
{
this.hands = (Mouvement)GetComponent("Mouvement");
palmLeft = this.hands.PalmLeft;
palmRight = this.hands.PalmRight;
this.currentLeftHandDistances.Add(this.hands.getDistanceBetween(hands.ThumbLeft, palmLeft));
this.currentLeftHandDistances.Add(this.hands.getDistanceBetween(hands.IndexLeft, palmLeft));
this.currentLeftHandDistances.Add(this.hands.getDistanceBetween(hands.MiddleLeft, palmLeft));
this.currentLeftHandDistances.Add(this.hands.getDistanceBetween(hands.PinkLeft, palmLeft));
this.currentLeftHandDistances.Add(this.hands.getDistanceBetween(hands.RingLeft, palmLeft));
this.currentRightHandDistances.Add(this.hands.getDistanceBetween(hands.ThumbRight, palmRight));
this.currentRightHandDistances.Add(this.hands.getDistanceBetween(hands.IndexRight, palmRight));
this.currentRightHandDistances.Add(this.hands.getDistanceBetween(hands.MiddleRight, palmRight));
this.currentRightHandDistances.Add(this.hands.getDistanceBetween(hands.PinkRight, palmRight));
this.currentRightHandDistances.Add(this.hands.getDistanceBetween(hands.RingRight, palmRight));
this.currentRightHandMouvement.AddLast(new List <float> ()
{
palmRight.position.x, palmRight.position.y, palmRight.position.z
});
if (this.currentRightHandMouvement.Count >= 50)
{
this.currentRightHandMouvement.RemoveFirst();
}
this.staticRightHandClass = classifier.knn(3, staticDataset.DatasStatic, staticDataset.TargetStatic, currentRightHandDistances);
if (calibration && this.staticRightHandClass == 0 && canDetectMouvement)
{
this.canDetectMouvement = false;
StartCoroutine(enableMouvementDetection());
this.dynamicRighthandClass = classifier.knn(3, dynamicDataset.DatasDynamic, dynamicDataset.TargetDynamic, new List <List <float> > (currentRightHandMouvement));
}
this.staticLeftHandClass = classifier.knn(3, staticDataset.DatasStatic, staticDataset.TargetStatic, currentLeftHandDistances);
this.currentLeftHandDistances.Clear();
this.currentRightHandDistances.Clear();
}
static void FindAllValidMoves(Piece[,] Pieces, Jeton[,] Jetons, int x1, int y1, List <Mouvement> listeMouvements)
{
Mouvement mouvement = new Mouvement();
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 8; j++)
{
if (ValidMove(Pieces, Jetons, x1, y1, i, j))
{
mouvement.Departx = x1;
mouvement.Departy = y1;
mouvement.Finx = i;
mouvement.Finy = j;
TempBoardErase(Pieces, mouvement.Departx, mouvement.Departy);
for (int s = 0; s < 8; s++)
{
for (int t = 0; t < 8; t++)
{
if (!(s == mouvement.Finx && t == mouvement.Finy))
{
if (ValidMove(Pieces, Jetons, mouvement.Finx, mouvement.Finy, s, t))
{
mouvement.jetonx = s;
mouvement.jetony = t;
//Debug.Log("mouvement a ajouter:");
//mouvement.afficher();
listeMouvements.Add(new Mouvement(mouvement.Departx, mouvement.Departy, mouvement.Finx, mouvement.Finy, mouvement.jetonx, mouvement.jetony));
//Debug.Log(listeMouvements.Count);
}
}
}
}
TempBoardAdd(Pieces, mouvement.Departx, mouvement.Departy);
}
}
}
}
public ActionResult AddOrEditMouvement(Mouvement mvnt)
{
List <Dossier> ListeDossiers = dbContext.Dossiers.ToList();
List <Motif> ListeMotifs = dbContext.Motifs.ToList();
ViewBag.ListeDossiers = new SelectList(ListeDossiers, "idDossier", "codeDossier");
ViewBag.ListeMotifs = new SelectList(ListeMotifs, "idMotif", "nomMotif");
if (mvnt.idMvnt == 0)
{
dbContext.Configuration.ProxyCreationEnabled = false;
dbContext.Mouvements.Add(mvnt);
dbContext.SaveChanges();
return(Json(new { success = true, message = "Ajout : Succés" }, JsonRequestBehavior.AllowGet));
}
else
{
dbContext.Configuration.ProxyCreationEnabled = false;
dbContext.Entry(mvnt).State = EntityState.Modified;
dbContext.SaveChanges();
return(Json(new { success = true, message = "Mise à jour : Succés" }, JsonRequestBehavior.AllowGet));
}
}
public int AddMouvement(Mouvement Mouvement)
{
Context.Mouvement.Add(Mouvement);
Context.SaveChanges();
return(Context.Mouvement.Add(Mouvement).Id);
}
public ActionBaseRoulante(String description, Mouvement mouvement)
: base(description)
{
this.mouvement = mouvement;
}
public Bitmap getBitmap(int x, int y, Mouvement mouvCourant, int Joueur, Bitmap bpLoup, Bitmap bpLapin, Bitmap bpHerbe, bool bitmapOK)
{
return(dessinerPieces(grilleSelect(grilleVide(x, y), mouvCourant), Joueur, bpLoup, bpLapin, bpHerbe, bitmapOK));
}
/// <summary>
/// Sauvegarde en base un nouveau mouvement
/// </summary>
public async Task SaveMouvement()
{
//on remet en positif si un nombre est négatif
if (Credit != null && Credit != 0 && Credit < 0)
{
Credit *= -1;
}
if (Debit != null && Debit != 0 && Debit < 0)
{
Debit *= -1;
}
//ajout du mouvement
var mouvement = new Mouvement
{
Id = IdMouvementSelect ?? 0,
Commentaire = Commentaire,
Credit = Credit ?? 0,
Debit = Debit ?? 0,
Date = DateMouvement,
IdCompte = Compte.Id,
ModeMouvement = SelectedTypeMouvement.Id,
Numero = Numero,
IdType = SelectedCategorieFmList?.Id ?? 0,
IsTypePerso = SelectedCategorieFmList?.IsSousCategPerso ?? false,
IdMouvementVirement = IdMouvementVirement ?? 0,
};
if (App.ModeApp == AppareilEnum.ModeAppareilPrincipal)
{
if (SelectedCompteVirement != null && SelectedCompteVirement.Id != 0 && SelectedTypeMouvement.Id == 3)
{
await _mouvementBusiness.SaveVirement(mouvement, SelectedCompteVirement.Id);
}
else
{
await _mouvementBusiness.SaveMouvement(mouvement);
}
}
else
{
if (SelectedCompteVirement != null && SelectedCompteVirement.Id != 0 && SelectedTypeMouvement.Id == 3)
{
await RoamingMouvementBusiness.SaveVirement(mouvement, SelectedCompteVirement.Id);
}
else
{
if (IdMouvementSelect == null)
{
await RoamingMouvementBusiness.AjouterMouvementRoaming(mouvement);
}
else
{
await RoamingMouvementBusiness.ModifierMouvementRoaming(mouvement);
}
}
}
await RecompterPage(null);
await UpdateSoldeCompte();
AnnulerMouvement();
}
/// <summary>
/// Met à jour le solde du compte en fonction de la date entrée
/// </summary>
/// <returns></returns>
public async Task UpdateDateSoldeCompte()
{
//si on fait des prévisions dans le futur on doit prendre en compte les échéanciers
if (DateSoldeCompte > DateTime.Today)
{
double rajouterAuSolde = 0;
var listeEcheancier = await _echeancierBusiness.GetEcheancier();
ListeRajoutMouvement = new List <Mouvement>();
var dateFictive = DateTime.Today;
do
{
if (listeEcheancier.Count(x => x.Date == dateFictive) > 0)
{
foreach (var echeancier in listeEcheancier.Where(x => x.Date == dateFictive))
{
if ((echeancier.IsDateLimite && echeancier.DateLimite < dateFictive.AddDays(1)) ||
!echeancier.IsDateLimite)
{
var mouv = new Mouvement
{
Date = new DateTime(dateFictive.Year, dateFictive.Month, dateFictive.Day, 0, 0, 0),
Credit = echeancier.Credit,
Debit = echeancier.Debit,
Commentaire = echeancier.Commentaire,
IdCompte = echeancier.IdCompte,
IdType = echeancier.IdType,
IsPasse = false,
IdMouvementVirement = 0,
IsTypePerso = echeancier.IsTypePerso,
Numero = 0,
ModeMouvement = echeancier.ModeMouvement,
Lock = true
};
ListeRajoutMouvement.Add(mouv);
if (mouv.Debit > 0)
{
rajouterAuSolde -= mouv.Debit;
}
if (mouv.Credit > 0)
{
rajouterAuSolde += mouv.Credit;
}
echeancier.Date =
EcheancierBusiness.GetNbJoursPeriodicite(
(PeriodiciteEnum)echeancier.IdPeriodicite, echeancier.Date, echeancier.NbJours);
}
}
}
dateFictive = dateFictive.AddDays(1);
} while (dateFictive <= DateSoldeCompte);
await RecompterPage(ListeRajoutMouvement);
await RecalculerSoldeCompte(rajouterAuSolde);
}
else
{
ListeRajoutMouvement.Clear();
await RecompterPage(null);
await RecalculerSoldeCompte(null);
}
}
private void GetMouvementsPossiblesRec(PlateauIA plateau, Stack <Tuple <int, Mouvement> > possibles, Mouvement coups, ref Coords origine, Coords directionOrigineDirecteur, int nbPrises = 0)
{
if (coups.Sauts.Count > 0)
{
possibles.Push(new Tuple <int, Mouvement>(nbPrises, coups));
}
Coords tmpPos = origine;
PieceIA tmpPiece = null;
Coords direction = directionOrigineDirecteur;
int tmpPrises = 0;
bool invalideUneFois = false;
while (true)
{
tmpPos += direction;
tmpPrises = nbPrises;
if (EstMinimalementValide(plateau, origine, tmpPos, direction, ref tmpPrises, ref tmpPiece))
{
if (tmpPrises > nbPrises)
{
tmpPiece.flag = true;
var tmpCoups = new Mouvement(coups);
tmpCoups.Sauts.Enqueue(tmpPos);
GetMouvementsPossiblesRec(plateau, possibles, tmpCoups, ref tmpPos, direction, tmpPrises);
tmpPiece.flag = false;
}
else
{
var tmpCoups = new Mouvement(coups);
tmpCoups.Sauts.Enqueue(tmpPos);
possibles.Push(new Tuple <int, Mouvement>(nbPrises, tmpCoups));
}
}
else
{
if (invalideUneFois)
{
invalideUneFois = false;
break;
}
invalideUneFois = true;
}
}
if (directionOrigineDirecteur.GetVraiUnitaire() == DIAG1)
{
direction = DIAG2;
}
else
{
direction = DIAG1;
}
tmpPos = origine;
while (true)
{
tmpPos += direction;
tmpPrises = nbPrises;
if (EstMinimalementValide(plateau, origine, tmpPos, direction, ref tmpPrises, ref tmpPiece))
{
if (tmpPrises > nbPrises)
{
var tmpCoups = new Mouvement(coups);
tmpCoups.Sauts.Enqueue(tmpPos);
tmpPiece.flag = true;
GetMouvementsPossiblesRec(plateau, possibles, tmpCoups, ref tmpPos, direction, tmpPrises);
tmpPiece.flag = false;
}
else if (coups.Sauts.Count == 0)
{
var tmpCoups = new Mouvement(coups);
tmpCoups.Sauts.Enqueue(tmpPos);
possibles.Push(new Tuple <int, Mouvement>(nbPrises, tmpCoups));
}
}
else
{
if (invalideUneFois)
{
invalideUneFois = false;
break;
}
invalideUneFois = true;
}
}
tmpPos = origine;
while (true)
{
tmpPos -= direction; // la difference est la
tmpPrises = nbPrises;
if (EstMinimalementValide(plateau, origine, tmpPos, -direction, ref tmpPrises, ref tmpPiece))
{
if (tmpPrises > nbPrises)
{
var tmpCoups = new Mouvement(coups);
tmpCoups.Sauts.Enqueue(tmpPos);
tmpPiece.flag = true;
GetMouvementsPossiblesRec(plateau, possibles, tmpCoups, ref tmpPos, -direction, tmpPrises);
tmpPiece.flag = false;
}
else if (coups.Sauts.Count == 0)
{
var tmpCoups = new Mouvement(coups);
tmpCoups.Sauts.Enqueue(tmpPos);
possibles.Push(new Tuple <int, Mouvement>(nbPrises, tmpCoups));
}
}
else
{
if (invalideUneFois)
{
invalideUneFois = false;
break;
}
invalideUneFois = true;
}
}
}
// Use this for initialization
void Start()
{
personage = gameObject.GetComponent ("Perso") as Perso;
mouv = gameObject.GetComponent ("Mouvement") as Mouvement;
}
public Opération(Mouvement typedemouvementrecu, decimal montantrecu)
{
typedemouvement = typedemouvementrecu;
montant = montantrecu;
}
/// <summary>
/// Exécute les échéancier depuis le dernier démarrage de l'appli
/// </summary>
/// <returns>la task</returns>
public async Task ExecuteEcheancier()
{
var mouvementBusiness = new MouvementBusiness();
await mouvementBusiness.Initialization;
var dateDerniereExecution = (await Bdd.Connection.Table <Application>().Where(x => x.Id == 1).FirstOrDefaultAsync()).DateDernierDemarrage;
var dateMaintenant = DateUtils.GetMaintenant();
//récupération des échéanciers à éxécuter
var echeancierToExecute = await Bdd.Connection.Table <Echeancier>()
.Where(x => x.Date > dateDerniereExecution && x.Date <= dateMaintenant)
.ToListAsync();
foreach (var echeancier in echeancierToExecute)
{
do
{
if ((echeancier.Date <= echeancier.DateLimite && echeancier.IsDateLimite) ||
!echeancier.IsDateLimite)
{
//éxécution du mouvement
var mouvement = new Mouvement
{
Id = 0,
Commentaire = echeancier.Commentaire,
Credit = echeancier.Credit,
Debit = echeancier.Debit,
Date = echeancier.Date,
IdCompte = echeancier.IdCompte,
IdType = echeancier.IdType,
IsPasse = false,
IdMouvementVirement = 0,
IsTypePerso = echeancier.IsTypePerso,
Numero = 0,
ModeMouvement = echeancier.ModeMouvement
};
if (echeancier.IdCompteVirement > 0 && echeancier.IdCompte != echeancier.IdCompteVirement)
{
await mouvementBusiness.SaveVirement(mouvement, echeancier.IdCompteVirement);
}
else
{
await mouvementBusiness.SaveMouvement(mouvement);
}
}
else
{
break;
}
//enregistrement de la prochaine date
echeancier.Date = GetNbJoursPeriodicite((PeriodiciteEnum)echeancier.IdPeriodicite, echeancier.Date,
echeancier.NbJours);
await SaveEcheancier(echeancier);
//répétition tant que la date d'éxécution est toujours inférieur à aujourd'hui
} while (echeancier.Date <= dateMaintenant);
}
}
// Update is called once per frame
override protected void Update()
{
if (Input.GetKey("escape"))
{
Application.Quit();
}
if (Input.GetKey("m"))
{
SceneManager.LoadScene("MainMenu");
}
if (Input.GetKeyDown("n"))
{
PauseGame();
}
updateMouseOver();
int x = (int)mouseOver.x;
int y = (int)mouseOver.y;
if (selectedPiece != null && !enMouvement && (etat == 0))
{
updatePieceDrag(selectedPiece);
}
if (selectedJeton != null && !enMouvement && (etat == 1))
{
updateJetonDrag(selectedJeton);
}
if (Input.GetMouseButtonDown(0) && !enMouvement && !pause && (etat == 0))
{
selectPiece(x, y);
}
if (Input.GetMouseButtonDown(0) && !enMouvement && !pause && (etat == 1))
{
TryMoveJeton((int)startDrag.x, (int)startDrag.y, x, y);
}
if (Input.GetMouseButtonUp(0) && !enMouvement && !pause && (etat == 0))
{
TryMovePiece((int)startDrag.x, (int)startDrag.y, x, y);
}
if (Input.GetMouseButtonUp(0) && !enMouvement && !pause && (etat == 2))
{
mouvement = IA.GenererMouvement(pieces, jetons);
TryMovePiece(mouvement.Departx, mouvement.Departy, mouvement.Finx, mouvement.Finy);
}
if (etat == 3 && !enMouvement)
{
TryMoveJeton(mouvement.Finx, mouvement.Finy, mouvement.jetonx, mouvement.jetony);
}
if (isWhiteTurn_ && !victoire)
{
Camera.main.transform.eulerAngles = Vector3.Lerp(Camera.main.transform.eulerAngles, angleWhiteTurn_, Time.deltaTime);
Camera.main.transform.position = Vector3.Lerp(Camera.main.transform.position, positionWhiteTurn_, Time.deltaTime);
}
if (enMouvement)
{
currentLerpTime += Time.deltaTime;
if (currentLerpTime > lerptime)
{
if (selectedPiece.getIsWhite())
{
selectedPiece.transform.rotation = Quaternion.Euler(0.0f, 90.0f, 0.0f);;
}
else
{
selectedPiece.transform.rotation = Quaternion.Euler(0.0f, 270.0f, 0.0f);;
}
selectedPiece.transform.position = endPos;
selectedPiece = null;
enMouvement = false;
currentLerpTime = 0;
if (etat == 2 || etat == 3)
{
selectedJeton.GetComponent <MeshRenderer>().enabled = false;
}
else
{
selectedJeton.GetComponent <MeshRenderer>().enabled = true;
}
}
else
{
float perc = currentLerpTime / lerptime;
selectedPiece.transform.position = Vector3.Lerp(startPos, endPos, perc);
}
}
}
private void EnregistrementOperation(Mouvement typeMouv, decimal montant)
{
Operation oper = new Operation { _montant = montant, typeMouvement = typeMouv };
listeOperation.Add(oper);
}
// Use this for initialization
void Start()
{
tempsInitail = Time.timeScale;
mouv = gameObject.GetComponent ("Mouvement") as Mouvement;
bonePos = new Vector3[2,(int)Kinect.NuiSkeletonPositionIndex.Count];
}
/// <summary>
/// Sauvegarde un virement
/// </summary>
/// <param name="mouvement">le mouvement d'origine du virement</param>
/// <param name="idCompte">l'id du compte sur lequel s'effectue sur le virement</param>
/// <returns>la task</returns>
public async Task SaveVirement(Mouvement mouvement, int idCompte)
{
var create = mouvement.Id == 0;
Mouvement mouvementA;
Mouvement mouvementB;
//mise à jour
if (!create)
{
var mouvementAOld =
await Bdd.Connection.Table <Mouvement>().Where(x => x.Id == mouvement.Id).FirstOrDefaultAsync();
var mouvementBOld =
await
Bdd.Connection.Table <Mouvement>()
.Where(x => x.Id == mouvementAOld.IdMouvementVirement)
.FirstOrDefaultAsync();
var idDeviseA =
(await
Bdd.Connection.Table <Compte>().Where(x => x.Id == mouvementAOld.IdCompte).FirstOrDefaultAsync())
.IdDevise;
var idDeviseB =
(await
Bdd.Connection.Table <Compte>().Where(x => x.Id == idCompte).FirstOrDefaultAsync())
.IdDevise;
await Bdd.DeleteDonnee(mouvementBOld);
await CalculerSolde(null, mouvementBOld);
mouvementA = mouvement;
mouvementB = new Mouvement
{
Id = 0,
Commentaire = mouvementA.Commentaire,
Credit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Debit),
Debit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Credit),
Date = mouvementA.Date,
IdCompte = idCompte,
ModeMouvement = mouvementA.ModeMouvement,
Numero = mouvementA.Numero,
IdType = mouvementA.IdType,
IsTypePerso = mouvementA.IsTypePerso
};
var idMax = 0;
var residR = (await Bdd.Connection.Table <Mouvement>().OrderByDescending(x => x.Id).FirstOrDefaultAsync());
if (residR != null)
{
idMax = residR.Id;
}
var mouvementBId = idMax + 1;
mouvementA.IdMouvementVirement = mouvementBId;
mouvementB.Id = mouvementBId;
mouvementB.IdMouvementVirement = mouvementA.Id;
await Bdd.UpdateDonnee(mouvementA);
await CalculerSolde(mouvementA, mouvementAOld);
await Bdd.AjouterDonnee(mouvementB);
await CalculerSolde(mouvementB, null);
}
else //création
{
mouvementA = mouvement;
var idDeviseA =
(await
Bdd.Connection.Table <Compte>().Where(x => x.Id == mouvementA.IdCompte).FirstOrDefaultAsync())
.IdDevise;
var idDeviseB =
(await
Bdd.Connection.Table <Compte>().Where(x => x.Id == idCompte).FirstOrDefaultAsync())
.IdDevise;
mouvementB = new Mouvement
{
Id = 0,
Commentaire = mouvementA.Commentaire,
Credit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Debit),
Debit = DeviseUtils.ConvertisseurMonnaie(idDeviseA, idDeviseB, mouvementA.Credit),
Date = mouvementA.Date,
IdCompte = idCompte,
ModeMouvement = mouvementA.ModeMouvement,
Numero = mouvementA.Numero,
IdType = mouvementA.IdType,
IsTypePerso = mouvementA.IsTypePerso
};
var idMax = 0;
var residR = (await Bdd.Connection.Table <Mouvement>().OrderByDescending(x => x.Id).FirstOrDefaultAsync());
if (residR != null)
{
idMax = residR.Id;
}
var mouvementAId = idMax + 1;
var mouvementBId = idMax + 2;
mouvementA.Id = mouvementAId;
mouvementA.IdMouvementVirement = mouvementBId;
mouvementB.Id = mouvementBId;
mouvementB.IdMouvementVirement = mouvementAId;
await Bdd.AjouterDonnee(mouvementA);
await CalculerSolde(mouvementA, null);
await Bdd.AjouterDonnee(mouvementB);
await CalculerSolde(mouvementB, null);
}
}
void Start()
{
monScript = GameObject.Find("Bouton_Difficult").GetComponent <DifficultScript>();
JoueurScript = GameObject.Find("Personnage").GetComponent <Mouvement>();
CoffreScript = GameObject.Find("Coffre").GetComponent <ScriptPickup>();
}
/// <summary>
/// Ajoute un mouvement provenant de l'outil de restauration
/// </summary>
/// <param name="mouvement">le mouvement à ajouter</param>
/// <returns>la task</returns>
public async Task AjouterMouvementFmRestauration(Mouvement mouvement)
{
await Bdd.AjouterDonnee(mouvement);
}
// Use this for initialization
void Start()
{
mouv = gameObject.GetComponent ("Mouvement") as Mouvement;
}
