public WraperConto(Conto conto)
{
_conto = conto;
OnPropertyChanged("Oborot");
OnPropertyChanged("DocId");
OnPropertyChanged("Note");
OnPropertyChanged("Data");
OnPropertyChanged("Folder");
OnPropertyChanged("Reason");
OnPropertyChanged("DataInvoise");
OnPropertyChanged("NumberObject");
OnPropertyChanged("Index");
OnPropertyChanged("DDetails");
OnPropertyChanged("CDetails");
OnPropertyChanged("IsDdsPurchasesIncluded");
OnPropertyChanged("IsDdsSalesIncluded");
OnPropertyChanged("IsDdsPurchases");
OnPropertyChanged("IsDdsSales");
OnPropertyChanged("IsPurchases");
OnPropertyChanged("IsSales");
OnPropertyChanged("VopPurchases");
OnPropertyChanged("VopSales");
OnPropertyChanged("Total");
OnPropertyChanged("DName");
OnPropertyChanged("CName");
OnPropertyChanged("Pr1");
OnPropertyChanged("Pr2");
OnPropertyChanged("Kd");
OnPropertyChanged("UserId");
OnPropertyChanged("Id");
}
internal void SetSaldoConto(string idConto, decimal p)
{
Conto c = _bilancio.FindNodeById(idConto) as Conto;
if (c == null)
{
return;
}
c.SaldoIniziale = (double)p;
//una volta impostato il saldo iniziale di un conto devo provvedere a far
//quadrare tutto il bilancio. La quadratura del bilancio è automatica
//quando creo delle scritture; quando invece modifico il saldo iniziale di un conto
//tale quadratura viene a mancare. In contabilità la quadratura viene ripristinata modificando il saldo
//iniizale del patrimonio netto che nella fattispece avrà come id conto "P.P.1".
//Pertanto una volta impostato il saldo iniziale del conto eseguiro' il totale del bilancio
//e sommero tale totale (con segno cambiato) al saldo iniziale del patrimonio netto
//eseguo la totalizzaizone del bilancio
double tot = _bilancio.GetTotal;
Conto patrimonioNetto = _bilancio.FindNodeById(PATRIMONIO_NETTO) as Conto;
//reimposto ilaldo iniziale del patrimonio netto
patrimonioNetto.SaldoIniziale += tot * -1;
RaiseChangeEvent();
}
public void RemoveScrittura(ScrittureDTO scrittura)
{
Conto c = _bilancio.FindNodeById(scrittura.ParentId) as Conto;
if (c == null)
{
throw new InvalidOperationException("Tentativo di rimuovere una scrittura ad un elemento diverso da un conto");
}
Scrittura s = c.FindNodeById(scrittura.Id) as Scrittura;
if (s == null)
{
return;
}
//if (s.TipoOperazione == TipoOperazione.Accantonamento)
// c.Remove(scrittura.Id, _bilancio.AccantonamentoFinale);
//else if (s.TipoOperazione == TipoOperazione.Cassa)
// c.Remove(scrittura.Id, _bilancio.CassaFinale);
//else if (s.TipoOperazione == TipoOperazione.Banca1)
// c.Remove(scrittura.Id, _bilancio.Banca1Finale);
//else if (s.TipoOperazione == TipoOperazione.Banca2)
// c.Remove(scrittura.Id, _bilancio.Banca2Finale);
//else if (s.TipoOperazione == TipoOperazione.Banca3)
// c.Remove(scrittura.Id, _bilancio.Banca3Finale);
//else
c.Remove(scrittura.Id, _bilancio);//gestione della cancellazione scritture di contropartita
RaiseChangeEvent();
}
public static void UpdateConto(Conto CurrentConto)
{
var dbman = new DBManager(DataProvider.Firebird);
dbman.ConnectionString = Entrence.ConnectionString;
try
{
dbman.Open();
dbman.BeginTransaction();
CreateParameters(CurrentConto, false, dbman);
dbman.ExecuteNonQuery(CommandType.StoredProcedure, "UPDATECONTO");
dbman.CommitTransaction();
}
catch (Exception ex)
{
Logger.Instance().WriteLogError(ex.Message, "UpdateConto");
dbman.RollBackTransaction();
}
finally
{
dbman.Dispose();
}
}
public ScrittureContoRLSTPresenter(IScrittureContoRLSTFormView view, ContoRLSTService service, Conto conto)
{
_view = view;
_view.SetPresenter(this);
_service = service;
_conto = conto;
}
protected override void Add()
{
Conto temp = CurrentConto.Clone();
AllConto.Add(CurrentConto);
CurrentConto = temp;
}
public void TestPrelievoMaggioreDelSaldo()
{
//arrange: imposto i dati di input
var conto = new Conto(5000);
//act and assert: chiamo il metodo da testare e verifico il risultato del metodo
Assert.ThrowsException <Exception>(() => { conto.PrelevaSoldi(6000); });
}
public void TestPrelievo()
{
//arrange: imposto i dati di input
var conto = new Conto(5000);
//act: chiamo il metodo da testare
conto.PrelevaSoldi(1000);
//assert: verifico il risultato del metodo
Assert.AreEqual(conto.Saldo, 4000);
}
internal decimal CalculateTotalForSCritture(IList dtos, string conto, ref decimal initialValue)
{
//vedo se c'è un saldo iniziale verificando che il conto sia un conto finanziario
//if (!string.IsNullOrEmpty(conto))
//{
// switch (conto)
// {
// case"FF.0"://banca1
// initialValue = Convert.ToDecimal(_bilancio.Banca1Iniziale.Importo);
// break;
// case "FF.1"://banca2
// initialValue = Convert.ToDecimal(_bilancio.Banca2Iniziale.Importo);
// break;
// case "FF.2"://cassa
// initialValue = Convert.ToDecimal(_bilancio.CassaIniziale.Importo);
// break;
// case "FF.3"://accantonamento
// initialValue = Convert.ToDecimal(_bilancio.AccantonamentoIniziale.Importo);
// break;
// case "FF.4"://accantonamento
// initialValue = Convert.ToDecimal(_bilancio.Banca3Iniziale.Importo);
// break;
// default:
// break;
// }
//}
//se c'è un conto verifico il totale dal conto stesso
if (!string.IsNullOrEmpty(conto))
{
Conto current = _bilancio.FindNodeById(conto) as Conto;
//se sto verificando il saldo iniziale di una classificaizone ad esempio
if (current == null)
{
return(0);
}
initialValue = (decimal)current.SaldoIniziale;
return((decimal)current.GetTotal);
}
decimal t = 0;
foreach (ScrittureDTO item in dtos)
{
t = t + item.Importo;
}
return(t + initialValue);
}
private void ValidateOperazioniDiuCassa(Conto contoCorrente, Conto contropartita, decimal importo)
{
//verifico che il primo conto movimentato sia un conto cassa
if (contoCorrente.Id.Equals(CASSA) || contropartita.Id.Equals(CASSA))
{
if (importo > 3000 || importo < -3000)
{
throw new Exception("Attenzione! Le scritture di cassa non possono superare i 3.000 Euro!");
}
}
}
private static void CreateParameters(Conto CurrentConto, bool add, DBManager dbman)
{
if (add)
{
dbman.CreateParameters(34);
}
else
{
dbman.CreateParameters(33);
}
dbman.AddParameters(0, "@Date", CurrentConto.Data);
dbman.AddParameters(1, "@Oborot", Math.Round(CurrentConto.Oborot, 2));
dbman.AddParameters(2, "@Reason", CurrentConto.Reason);
dbman.AddParameters(3, "@Note", CurrentConto.Note);
dbman.AddParameters(4, "@DataInvoise", CurrentConto.DataInvoise);
dbman.AddParameters(5, "@NumberObject", CurrentConto.NumberObject);
dbman.AddParameters(6, "@DebitAccount", CurrentConto.DebitAccount);
dbman.AddParameters(7, "@CreditAccount", CurrentConto.CreditAccount);
dbman.AddParameters(8, "@FirmId", CurrentConto.FirmId);
dbman.AddParameters(9, "@DocumentId", CurrentConto.DocumentId);
dbman.AddParameters(10, "@CartotekaDebit", CurrentConto.CartotekaDebit);
dbman.AddParameters(11, "@CartotecaCredit", CurrentConto.CartotecaCredit);
dbman.AddParameters(12, "@DOCNUM", CurrentConto.DocNum);
dbman.AddParameters(13, "@OBOROTVALUTA", CurrentConto.OborotValutaD);
dbman.AddParameters(14, "@OBOROTKOL", CurrentConto.OborotKolD);
dbman.AddParameters(15, "@OBOROTVALUTAK", CurrentConto.OborotValutaK);
dbman.AddParameters(16, "@OBOROTKOLK", CurrentConto.OborotKolK);
dbman.AddParameters(17, "@FOLDER", CurrentConto.Folder);
dbman.AddParameters(18, "@ISDDSSALES", CurrentConto.IsDdsSales);
dbman.AddParameters(19, "@ISDDSPURCHASES", CurrentConto.IsDdsPurchases);
dbman.AddParameters(20, "@VOPPURCHASES", CurrentConto.VopPurchases);
dbman.AddParameters(21, "@VOPSALES", CurrentConto.VopSales);
dbman.AddParameters(22, "@ISDDSPURCHASESINCLUDED", CurrentConto.IsDdsPurchasesIncluded);
dbman.AddParameters(23, "@ISDDSSALESINCLUDED", CurrentConto.IsDdsSalesIncluded);
dbman.AddParameters(24, "@ISSALES", CurrentConto.IsSales);
dbman.AddParameters(25, "@ISPURCHASES", CurrentConto.IsPurchases);
dbman.AddParameters(26, "@DDETAILS", CurrentConto.DDetails);
dbman.AddParameters(27, "@CDETAILS", CurrentConto.CDetails);
dbman.AddParameters(28, "@USERID", CurrentConto.UserId);
dbman.AddParameters(29, "@PR1", CurrentConto.Pr1);
dbman.AddParameters(30, "@PR2", CurrentConto.Pr2);
dbman.AddParameters(31, "@KD", CurrentConto.KD);
if (add)
{
dbman.AddParameters(32, "@PORNOM", CurrentConto.CartotecaCredit);
dbman.AddOutputParameters(33, "@NEWID", CurrentConto.Id);
}
else
{
dbman.AddParameters(32, "@ContoID", CurrentConto.Id);
}
}
private void AddScrittura(string idConto, ScrittureDTO scrittura, Conto contropartita)
{
if (contropartita == null)
{
throw new InvalidOperationException("Contropartita nulla");
}
Conto c = _bilancio.FindNodeById(idConto) as Conto;
if (c == null)
{
throw new InvalidOperationException("Tentativo di aggingere una scrittura ad un elemento diverso da un conto");
}
//prima di aggiungere la scrittura devo eseguire una validazione sulle possibili operazioni di cassa
ValidateOperazioniDiuCassa(c, contropartita, scrittura.Importo);
Scrittura s = new Scrittura(idConto);
// s.TipoOperazione = (TipoOperazione)Enum.Parse(typeof(TipoOperazione), scrittura.TipoOperazione);
s.Importo = Convert.ToDouble(scrittura.Importo);
s.Causale = scrittura.Causale;
s.Date = scrittura.Date.Date;
s.NumeroPezza = scrittura.NumeroPezza;
s.ParentName = c.Description;
s.Riferimento1 = scrittura.Riferimento1;
s.Riferimento2 = scrittura.Riferimento2;
s.Riferimento3 = scrittura.Riferimento3;
//if (s.TipoOperazione == TipoOperazione.Cassa)
// c.Add(s, _bilancio.CassaFinale, false);
//else if (s.TipoOperazione == TipoOperazione.Accantonamento)
// c.Add(s, _bilancio.AccantonamentoFinale, false);
//else if (s.TipoOperazione == TipoOperazione.Banca1)
// c.Add(s, _bilancio.Banca1Finale, false);
//else if (s.TipoOperazione == TipoOperazione.Banca2)
// c.Add(s, _bilancio.Banca2Finale, false);
//else if (s.TipoOperazione == TipoOperazione.Banca3)
// c.Add(s, _bilancio.Banca3Finale, false);
//else
c.Add(s, contropartita, false);
scrittura.ParentId = c.Id;
scrittura.ParentName = c.Description;
scrittura.Contropartita = s.Contropartita;
scrittura.IdContropartita = s.IdContropartita;
scrittura.Id = s.Id;
RaiseChangeEvent();
}
private void CheckAddEnabled(AbstractBilancio b)
{
Conto conto = b as Conto;
if (conto == null)
{
_view.IsAddScritturaEnabled = false;
}
else
{
_view.IsAddScritturaEnabled = true;
}
}
private void CheckMessageVisibility(AbstractBilancio b)
{
Conto conto = b as Conto;
if (conto == null)
{
_view.IsMessaggioContoClassificazioneVisible = true;
}
else
{
_view.IsMessaggioContoClassificazioneVisible = false;
}
}
private void SetColumnContoVisible(AbstractBilancio b)
{
Conto conto = b as Conto;
if (conto == null)
{
_view.GridContainer.IsColumnVisible(0, true);
}
else
{
_view.GridContainer.IsColumnVisible(0, false);
}
}
static void GestisciConto(Conto target)
{
target.Deposita(100);
if (target.GetType() == typeof(ContoItaliano))
{
ContoItaliano x = (ContoItaliano)target;
}
if (target.Saldo > 50)
{
target.Ritira(2);
}
}
private void SetColumnContoVisible(AbstractBilancio b)
{
Conto contoContabile = b as Conto;
if (contoContabile == null)
{
_view.GridContainer.IsColumnVisible(0, true);
}
else
{
_view.GridContainer.IsColumnVisible(0, false);
}
//gestione delle colonne visibili
if (contoContabile != null)
{
if (contoContabile.Description == "Tesseramento diretto" || contoContabile.Description == "Deleghe edili" || contoContabile.Description == "Deleghe impianti fissi")
{
_view.GridContainer.IsColumnVisible(6, true);
_view.GridContainer.IsColumnVisible(7, true);
_view.GridContainer.IsColumnVisible(8, false);
}
else if (contoContabile.Description == "Retribuzioni personale (nette)" ||
contoContabile.Description == "Retribuzioni lorde")
{
_view.GridContainer.IsColumnVisible(8, true);
_view.GridContainer.IsColumnVisible(6, false);
_view.GridContainer.IsColumnVisible(7, false);
}
else
{
_view.GridContainer.IsColumnVisible(6, false);
_view.GridContainer.IsColumnVisible(7, false);
_view.GridContainer.IsColumnVisible(8, false);
}
}
else
{
_view.GridContainer.IsColumnVisible(6, false);
_view.GridContainer.IsColumnVisible(7, false);
_view.GridContainer.IsColumnVisible(8, false);
}
}
public int PasteScritture(string toIdConto, IList <ScrittureDTO> list)
{
Conto c = _bilancio.FindNodeById(toIdConto) as Conto;
if (c == null)
{
throw new ArgumentException("Id conto non specificato! Impossibile trovare il conto di destinazione.");
}
int _pasted = 0;
foreach (ScrittureDTO item in list)
{
//non faccio nulla se il conto di partenza è lo stesso del conto di arrivo
if (!toIdConto.Equals(item.ParentId))
{//non faccio nulla se la scrittura è autogenerata
if (!item.AutoGenerated)
{
//BilancioFenealgest.DomainLayer.Conto.TipoConto tipoCTo = Conto.CalculateTipoConto(toIdConto);
//BilancioFenealgest.DomainLayer.Conto.TipoConto tipoCFrom = Conto.CalculateTipoConto(item.ParentId);
////se non sto riscrivendo una scrittura in partita doppia tutta su spese o oentrate
//if (!(item.TipoOperazione == "Contropartita" && tipoCFrom != tipoCTo))
//{
//ottengo la scrittura di contropartita prima di cancellarla
ScrittureDTO controp = GetScritturaContropartita(item);
//rimuovo la scrittura
RemoveScrittura(item);
//aggiungo la scrittura ad un conto
AddScrittura(toIdConto, item, controp.ParentId);
//notifico che è necessario un refresh(almeno un elemento è cambiato)
_pasted++;
//}
}
}
}
return(_pasted);
}
public static bool SaveConto(Conto CurrentConto, List <SaldoAnaliticModel> debit, List <SaldoAnaliticModel> credit)
{
bool res = true;
var dbman = new DBManager(DataProvider.Firebird);
dbman.ConnectionString = Entrence.ConnectionString;
try
{
dbman.Open();
dbman.BeginTransaction();
CreateParameters(CurrentConto, true, dbman);
dbman.ExecuteNonQuery(CommandType.StoredProcedure, "ADDCONTO");
CurrentConto.Id = (int)dbman.Parameters[33].Value;
foreach (var item in debit)
{
item.CONTOID = CurrentConto.Id;
SaveContoMovementWithNo(item, dbman);
}
foreach (var item in credit)
{
item.CONTOID = CurrentConto.Id;
SaveContoMovementWithNo(item, dbman);
}
dbman.CommitTransaction();
}
catch (Exception ex)
{
res = false;
dbman.RollBackTransaction();
Logger.Instance().WriteLogError(ex.Message, "SaveConto");
}
finally
{
dbman.Dispose();
}
return(res);
}
public void UpdateConto(Conto CurrentConto)
{
RealDataContext.UpdateConto(CurrentConto);
}
public virtual bool SaveConto(Conto CurrentConto, List <SaldoAnaliticModel> debit, List <SaldoAnaliticModel> credit)
{
return(RealDataContext.SaveConto(CurrentConto, debit, credit));
}
public virtual void SaveContoWithOutTransaction(Conto currentConto)
{
RealDataContext.SaveContoWithOutTransaction(currentConto);
}
internal ScrittureDTO GetScritturaContropartita(ScrittureDTO _current)
{
//if (_current.TipoOperazione == "Contropartita")
//{
//BilancioFenealgest.DomainLayer.Conto.TipoConto c = Conto.CalculateTipoConto(_current.ParentId);
////se la contropartita è nulla vuol dire che ho passato l'intero bilancio
////*****************************
////definisco l'id della classificazione dove ricercare il conto
//string idClassificazione = "";
//if (c == BilancioFenealgest.DomainLayer.Conto.TipoConto.Entrate)
// //dovro' cercare la scrittura di contropartita nelle spese
// idClassificazione = "S";
//else
// //dovro' cercare la scrittura di contropartita nelle entrate
// idClassificazione = "E";
////rimuovo la scrittura previa ricerca
//Classificazione clas = _bilancio.FindNodeById(idClassificazione) as Classificazione;
Conto conto = _bilancio.FindNodeById(_current.IdContropartita) as Conto;
//cerco la scritttura
Scrittura s1 = conto.FindNodeById(_current.Id) as Scrittura;
if (s1 == null)
{
throw new Exception("Scrittura di partita doppia non trovata");
}
return(ScrittureConverter.ConvertToScritturaDTO(s1));
//}
//else
//{
// Conto c;
// switch (_current.TipoOperazione)
// {
// case "Cassa":
// c = _bilancio.CassaFinale;
// break;
// case "Banca2":
// c = _bilancio.Banca2Finale;
// break;
// case "Banca1":
// c = _bilancio.Banca1Finale;
// break;
// case "Banca3":
// c = _bilancio.Banca3Finale;
// break;
// case "Accantonamento":
// c = _bilancio.AccantonamentoFinale;
// break;
// default:
// throw new ArgumentException("Tipo operazione sconosciuta!");
// }
// Scrittura s1 = c.FindNodeById(_current.Id) as Scrittura;
// if (s1 == null)
// throw new Exception("Scrittura di partita doppia non trovata");
// return ScrittureConverter.ConvertToScritturaDTO(s1);
//}
}
public bool IsConto(string idConto)
{
Conto c = _bilancio.FindNodeById(idConto) as Conto;
return(c != null);
}
public void UpdateScrittura(ScrittureDTO scrittura, string contropartitaId)
{
Conto contropartita = _bilancio.FindNodeById(contropartitaId) as Conto;
Conto c = _bilancio.FindNodeById(scrittura.ParentId) as Conto;
if (c == null)
{
throw new InvalidOperationException("Tentativo di aggiornare una scrittura ad un elemento diverso da un conto");
}
if (contropartita == null)
{
throw new InvalidOperationException("Tentativo di aggiornare una scrittura con contropartita nulla");
}
//prima di aggiungere la scrittura devo eseguire una validazione sulle possibili operazioni di cassa
ValidateOperazioniDiuCassa(c, contropartita, scrittura.Importo);
Scrittura s = c.FindNodeById(scrittura.Id) as Scrittura;
if (s == null)
{
throw new InvalidOperationException("Tentativo di aggiornare una scrittura non presente nel conto");
}
//se si tratta di una scrittura autogenerata
if (s.AutoGenerated)
{
s.Importo = Convert.ToDouble(scrittura.Importo);
s.Causale = scrittura.Causale;
s.Date = scrittura.Date.Date;
s.NumeroPezza = scrittura.NumeroPezza;
return;
}
//verifico preventivamente la possibilità di fare una scrittura in partita doppia sullo
//stesso conto
//**********************************
Conto fin = null;
//TipoOperazione tip = (TipoOperazione)Enum.Parse(typeof(TipoOperazione), scrittura.TipoOperazione);
//if (tip == TipoOperazione.Cassa)
// fin = _bilancio.CassaFinale;
//else if (tip == TipoOperazione.Accantonamento)
// fin = _bilancio.AccantonamentoFinale;
//else if (tip == TipoOperazione.Banca1)
// fin = _bilancio.Banca1Finale;
//else if (tip == TipoOperazione.Banca2)
// fin = _bilancio.Banca2Finale;
//else if (tip == TipoOperazione.Banca3)
// fin = _bilancio.Banca3Finale;
//else
fin = contropartita;
if (fin != null)
{
if (c.Id.Equals(fin.Id))
{
throw new Exception("Impossibile scrivere una scrittura in partita doppia sullo stesso conto!");
}
}
//**********************************
//a questo punto rimuovo la scrittura precedente
RemoveScrittura(scrittura);
//eaggiungo la nuova scrittura
Scrittura s1 = new Scrittura();
// s1.TipoOperazione = tip;
s1.Importo = Convert.ToDouble(scrittura.Importo);
s1.Causale = scrittura.Causale;
s1.Date = scrittura.Date.Date;
s1.NumeroPezza = scrittura.NumeroPezza;
s1.Id = scrittura.Id;
s1.ParentName = c.Description;
s1.Riferimento1 = scrittura.Riferimento1;
s1.Riferimento2 = scrittura.Riferimento2;
s1.Riferimento3 = scrittura.Riferimento3;
//if (s1.TipoOperazione == TipoOperazione.Cassa)
// c.Add(s1, _bilancio.CassaFinale, false);
//else if (s1.TipoOperazione == TipoOperazione.Accantonamento)
// c.Add(s1, _bilancio.AccantonamentoFinale, false);
//else if (s1.TipoOperazione == TipoOperazione.Banca1)
// c.Add(s1, _bilancio.Banca1Finale, false);
//else if (s1.TipoOperazione == TipoOperazione.Banca2)
// c.Add(s1, _bilancio.Banca2Finale, false);
//else if (s1.TipoOperazione == TipoOperazione.Banca3)
// c.Add(s1, _bilancio.Banca3Finale, false);
//else
c.Add(s1, fin, false);
scrittura.ParentName = c.Description;
scrittura.Contropartita = s1.Contropartita;
RaiseChangeEvent();
}
internal static IEnumerable <Conto> GetAllContoGrupedByContragent(int firmaId, DateTime from, DateTime to, string nom, int accid)
{
var dbman = new DBManager(DataProvider.Firebird);
dbman.ConnectionString = Entrence.ConnectionString;
List <Conto> allConto = new List <Conto>();
try
{
dbman.Open();
StringBuilder sb = new StringBuilder();
sb.Append("select c.*,cm.LOOKUPVAL,cm.\"VALUE\" from \"conto\" c");
sb.Append(" inner join \"accounts\" a on a.\"Id\"= c.\"CreditAccount\"");
sb.Append(" inner join \"accounts\" b on b.\"Id\"= c.\"DebitAccount\"");
sb.Append(" inner join CONTOMOVEMENT cm on cm.CONTOID = c.\"Id\"");
//sb.Append(" left outer join DDSDNEV d on d.NOM=c.\"Id\"");
sb.AppendFormat(" where \"FirmId\"={0}", firmaId);
sb.AppendFormat(" AND \"Date\">='{0}.{1}.{2}' and \"Date\"<='{3}.{4}.{5}'",
from.Day,
from.Month,
from.Year,
to.Day,
to.Month,
to.Year);
sb.AppendFormat(" AND cm.ACCFIELDKEY=28 AND (c.\"CreditAccount\"={0} OR c.\"DebitAccount\"={0})", accid);
sb.Append(" AND (cm.ACCFIELDKEY=28)");
string s = sb.ToString();
dbman.ExecuteReader(CommandType.Text, s);
while (dbman.DataReader.Read())
{
var c = new Conto();
c.Id = int.Parse(dbman.DataReader["Id"].ToString());
c.CartotecaCredit = int.Parse(dbman.DataReader["CartotecaCredit"].ToString());
c.CartotekaDebit = int.Parse(dbman.DataReader["CartotekaDebit"].ToString());
c.CreditAccount = int.Parse(dbman.DataReader["CreditAccount"].ToString());
c.Data = DateTime.Parse(dbman.DataReader["Date"].ToString());
c.DataInvoise = DateTime.Parse(dbman.DataReader["DataInvoise"].ToString());
c.DebitAccount = int.Parse(dbman.DataReader["DebitAccount"].ToString());
c.DocumentId = int.Parse(dbman.DataReader["DocumentId"].ToString());
c.FirmId = int.Parse(dbman.DataReader["FirmId"].ToString());
c.Reason = dbman.DataReader["Reason"].ToString();
c.Note = dbman.DataReader["Note"].ToString();
c.NumberObject = int.Parse(dbman.DataReader["NumberObject"].ToString());
c.Oborot = decimal.Parse(dbman.DataReader["Oborot"].ToString());
c.DocNum = dbman.DataReader["DOCNUM"].ToString();
c.OborotValutaD = decimal.Parse(dbman.DataReader["OBOROTVALUTA"].ToString());
c.OborotKolD = decimal.Parse(dbman.DataReader["OBOROTKOL"].ToString());
c.OborotValutaK = decimal.Parse(dbman.DataReader["OBOROTVALUTAK"].ToString());
c.OborotKolK = decimal.Parse(dbman.DataReader["OBOROTKOLK"].ToString());
c.Folder = dbman.DataReader["FOLDER"].ToString();
c.Nd = int.Parse(dbman.DataReader["PORNOM"].ToString());
c.IsDdsPurchases = int.Parse(dbman.DataReader["ISDDSPURCHASES"].ToString());
c.IsDdsSales = int.Parse(dbman.DataReader["ISDDSSALES"].ToString());
c.IsDdsPurchasesIncluded = int.Parse(dbman.DataReader["ISDDSPURCHASESINCLUDED"].ToString());
c.IsDdsSalesIncluded = int.Parse(dbman.DataReader["ISDDSSALESINCLUDED"].ToString());
c.VopPurchases = dbman.DataReader["VOPPURCHASES"].ToString();
c.VopSales = dbman.DataReader["VOPSALES"].ToString();
c.IsSales = int.Parse(dbman.DataReader["ISSALES"].ToString());
c.IsPurchases = int.Parse(dbman.DataReader["ISPURCHASES"].ToString());
c.DDetails = dbman.DataReader["DDETAILS"].ToString();
c.CDetails = dbman.DataReader["CDETAILS"].ToString();
c.UserId = int.Parse(dbman.DataReader["USERID"].ToString());
c.Pr1 = dbman.DataReader["PR1"].ToString();
c.Pr2 = dbman.DataReader["PR2"].ToString();
c.KD = dbman.DataReader["KD"].ToString();
c.DDetails = dbman.DataReader["VALUE"].ToString();
c.CDetails = dbman.DataReader["LOOKUPVAL"].ToString();
allConto.Add(c);
}
}
catch (Exception ex)
{
Logger.Instance().WriteLogError(ex.Message, "internal static IEnumerable<Conto> GetContosByContragent(int firmaId, DateTime from, DateTime to, int code,string nom)");
}
finally
{
dbman.Dispose();
}
return(allConto);
}
public ContoRLSTService(Conto conto)
{
_conto = conto;
}
public void AddScrittura(string idConto, ScrittureDTO scrittura, string contropartita)
{
Conto c = _bilancio.FindNodeById(contropartita) as Conto;
AddScrittura(idConto, scrittura, c);
}
public void SaveConto(Conto CurrentConto)
{
RealDataContext.SaveConto(CurrentConto);
}
private void SaveContoLocal(Conto conto)
{
CreateParameters(conto, true);
DBManager.ExecuteNonQuery(CommandType.StoredProcedure, "ADDCONTO");
conto.Id = (int)DBManager.Parameters[29].Value;
}
