Samuele Locatelli
1610 lines
54 KiB
C#
1610 lines
54 KiB
C#
using NLog;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
|
|
namespace SHERPA.BBM.Controllers
|
|
{
|
|
public class BBMController : IDisposable
|
|
{
|
|
#region Private Fields
|
|
|
|
private static MainDbContext dbCtx;
|
|
private static FattDbContext dbFattCtx;
|
|
private static NLog.Logger Log = LogManager.GetCurrentClassLogger();
|
|
|
|
private string _connBBM;
|
|
private string _connFatt;
|
|
private object locDbCtx;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public BBMController(string connBBM, string connFatt)
|
|
{
|
|
_connBBM = connBBM;
|
|
_connFatt = connFatt;
|
|
dbCtx = new MainDbContext(connBBM);
|
|
Log.Info("Avviata classe BBMController.MainDbContext");
|
|
dbFattCtx = new FattDbContext(connFatt);
|
|
Log.Info("Avviata classe BBMController.FattDbContext");
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
public string currConnString
|
|
{
|
|
get
|
|
{
|
|
return dbCtx.Database.Connection.ConnectionString;
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Aggiunge un nuovo item Basket
|
|
/// </summary>
|
|
/// <param name="newItem"></param>
|
|
/// <returns></returns>
|
|
public bool BaskAddNew(DatabaseModels.BasketsModel newItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
locDbCtx
|
|
.DbSetBaskets
|
|
.Add(newItem);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina item Basket
|
|
/// </summary>
|
|
/// <param name="newItem"></param>
|
|
/// <returns></returns>
|
|
public bool BaskDelete(string CodBasket)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetBaskets
|
|
.Where(x => x.CodBasket == CodBasket)
|
|
.FirstOrDefault();
|
|
locDbCtx.DbSetBaskets.Remove(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public int BasketsCount()
|
|
{
|
|
int answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetBaskets
|
|
.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Baskets
|
|
/// </summary>
|
|
/// <param name="CompanyId"></param>
|
|
/// <param name="CustomerId"></param>
|
|
/// <param name="searchVal"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.BasketsModel> BaskGetLastDesc(int CompanyId, string searchVal)
|
|
{
|
|
List<DatabaseModels.BasketsModel> dbResult = new List<DatabaseModels.BasketsModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetBaskets
|
|
.Where(x => (x.BasketId > 1) && (x.CompanyId == CompanyId || CompanyId == 1) && (string.IsNullOrEmpty(searchVal) || x.CodBasket.Contains(searchVal) || x.Descript.Contains(searchVal)))
|
|
.OrderByDescending(x => x.CodBasket)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item Baskets
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool BaskUpdate(DatabaseModels.BasketsModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetBaskets
|
|
.Where(x => x.CodBasket == updItem.CodBasket)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetBaskets
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina item Fatt2Doc
|
|
/// </summary>
|
|
/// <param name="IdxFatt"></param>
|
|
/// <returns></returns>
|
|
public bool BillDelete(DatabaseModels.Fatt2DocModel delItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Where(x => x.IdxFatt == delItem.IdxFatt && x.DataIns == delItem.DataIns && x.DocId == delItem.DocId)
|
|
.FirstOrDefault();
|
|
locDbCtx.DbSetFatt2Doc.Remove(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina Fatture del doc indicato
|
|
/// </summary>
|
|
/// <param name="DocId"></param>
|
|
/// <returns></returns>
|
|
public bool BillDeleteByDoc(int DocId)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Where(x => x.DocId == DocId)
|
|
.ToList();
|
|
locDbCtx.DbSetFatt2Doc.RemoveRange(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Conteggio fatture
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public int BillsCount()
|
|
{
|
|
int answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Docs da Item
|
|
/// </summary>
|
|
/// <param name="DocId"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.Fatt2DocModel> BillsGetByDoc(int DocId = 0)
|
|
{
|
|
List<DatabaseModels.Fatt2DocModel> dbResult = new List<DatabaseModels.Fatt2DocModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Where(x => (x.DocId == DocId || DocId == 0))
|
|
.OrderByDescending(x => x.DataIns)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Importo complessivo fatture emesse x DOC
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public decimal BillsGetTotFatturato(int anno, int baskId, int negoId, int docId)
|
|
{
|
|
decimal answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Where(x => (x.AnnoFatt == anno || anno == 0) && (x.Document.Negotiation.BasketId == baskId || baskId <= 1) && (x.Document.NegotiationId == negoId || negoId <= 1) && (x.DocId == docId || docId <= 1) && (docId > 0 || x.Document.IsActive))
|
|
.Select(x => x.Importo)
|
|
.Sum();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Incasso complessivo fatture emesse x DOC
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public decimal BillsGetTotIncasso(int anno, int baskId, int negoId, int docId)
|
|
{
|
|
decimal answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Where(x => (x.AnnoFatt == anno || anno == 0) && (x.Document.Negotiation.BasketId == baskId || baskId <= 1) && (x.Document.NegotiationId == negoId || negoId <= 1) && (x.DocId == docId || docId <= 1) && (docId > 0 || x.Document.IsActive))
|
|
.Select(x => x.Incassato)
|
|
.Sum();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge un nuova Fattura
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool BillUpdate(DatabaseModels.Fatt2DocModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Where(x => x.IdxFatt == updItem.IdxFatt && x.DataIns == updItem.DataIns && x.DocId == updItem.DocId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Add(updItem);
|
|
}
|
|
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Company
|
|
/// </summary>
|
|
/// <param name="searchVal"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.CompanyModel> CompanyGetAll()
|
|
{
|
|
List<DatabaseModels.CompanyModel> dbResult = new List<DatabaseModels.CompanyModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetCompanies
|
|
.OrderBy(x => x.CompanyId)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
public string CounterGetNext(string CodCounter, int numZeros)
|
|
{
|
|
string answ = $"{CodCounter}.0000";
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
int nextId = 1;
|
|
var lastCount = locDbCtx
|
|
.DbSetCounters
|
|
.Where(x => x.CodCounter == CodCounter)
|
|
.OrderByDescending(x => x.LastNum)
|
|
.FirstOrDefault();
|
|
if (lastCount != null)
|
|
{
|
|
lastCount.LastNum++;
|
|
nextId = lastCount.LastNum;
|
|
}
|
|
else
|
|
{
|
|
var newRecord = new DatabaseModels.FluxCountersModel()
|
|
{
|
|
CodCounter = CodCounter,
|
|
LastNum = nextId
|
|
};
|
|
locDbCtx
|
|
.DbSetCounters
|
|
.Add(newRecord);
|
|
}
|
|
string subCounter = nextId.ToString().PadLeft(numZeros, '0');
|
|
answ = $"{CodCounter}.{subCounter}";
|
|
locDbCtx.SaveChanges();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
public int CountersCount()
|
|
{
|
|
int answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetCounters
|
|
.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Conunters
|
|
/// </summary>
|
|
/// <param name="searchVal"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.FluxCountersModel> CountersGetAll(string searchVal = "")
|
|
{
|
|
List<DatabaseModels.FluxCountersModel> dbResult = new List<DatabaseModels.FluxCountersModel>();
|
|
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetCounters
|
|
.Where(x => x.CodCounter.Contains(searchVal) || string.IsNullOrEmpty(searchVal))
|
|
.OrderBy(x => x.CodCounter)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un FluxCounter
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool CounterUpdate(DatabaseModels.FluxCountersModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetCounters
|
|
.Where(x => x.CodCounter == updItem.CodCounter)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetCounters
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public int CustomersCount()
|
|
{
|
|
int answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetCustomers
|
|
.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Customers
|
|
/// </summary>
|
|
/// <param name="searchVal"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.CustomersModel> CustomersGetAll(string searchVal)
|
|
{
|
|
List<DatabaseModels.CustomersModel> dbResult = new List<DatabaseModels.CustomersModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetCustomers
|
|
.Where(x => (x.RagSoc.Contains(searchVal) || x.Descript.Contains(searchVal) || string.IsNullOrEmpty(searchVal)))
|
|
.OrderBy(x => x.RagSoc)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un Cliente
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool CustomerUpdate(DatabaseModels.CustomersModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetCustomers
|
|
.Where(x => x.CustomerId == updItem.CustomerId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetCustomers
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
// Clear database context
|
|
dbCtx.Dispose();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina item Doc
|
|
/// </summary>
|
|
/// <param name="DocId"></param>
|
|
/// <returns></returns>
|
|
public bool DocDelete(int DocId)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.DocId == DocId)
|
|
.FirstOrDefault();
|
|
locDbCtx.DbSetDocs.Remove(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera Doc da ID
|
|
/// </summary>
|
|
/// <param name="newItem"></param>
|
|
/// <returns></returns>
|
|
public DatabaseModels.DocsModel DocGetByKey(int DocId)
|
|
{
|
|
DatabaseModels.DocsModel currDoc = null;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
currDoc = locDbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.DocId == DocId)
|
|
.FirstOrDefault();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return currDoc;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Docs
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.DocsModel> DocGetLastDesc(int numRecord)
|
|
{
|
|
List<DatabaseModels.DocsModel> dbResult = new List<DatabaseModels.DocsModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = locDbCtx.DbSetDocs.Count();
|
|
}
|
|
dbResult = locDbCtx
|
|
.DbSetDocs
|
|
.OrderByDescending(x => x.CodDoc)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco Docs
|
|
/// </summary>
|
|
/// <param name="BasketId"></param>
|
|
/// <param name="NegotiationId"></param>
|
|
/// <param name="ShowAll">Mostra tutti (=true) / solo attivi</param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.DocsModel> DocGetLastDesc(int BasketId = 0, int NegotiationId = 0, bool ShowAll = false)
|
|
{
|
|
List<DatabaseModels.DocsModel> dbResult = new List<DatabaseModels.DocsModel>();
|
|
dbResult = dbCtx
|
|
.DbSetDocs
|
|
.Where(x => (x.IsActive || ShowAll) && (x.Negotiation.BasketId == BasketId || BasketId == 1) && (x.NegotiationId == NegotiationId || NegotiationId == 1))
|
|
.OrderByDescending(x => x.CodDoc)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.ToList();
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge un nuovo item Doc
|
|
/// </summary>
|
|
/// <param name="newItem"></param>
|
|
/// <returns></returns>
|
|
public bool DocsAddNew(DatabaseModels.DocsModel newItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
locDbCtx
|
|
.DbSetDocs
|
|
.Add(newItem);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public int DocsCount()
|
|
{
|
|
int answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetDocs
|
|
.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item Doc come ACTIVE (e inactive gli altri della stessa negoziazione)
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool DocSetActive(DatabaseModels.DocsModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
// attivo record corrente
|
|
var currData = locDbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.DocId == updItem.DocId)
|
|
.FirstOrDefault();
|
|
currData.IsActive = true;
|
|
|
|
// altri record da disattivare
|
|
var otherData = locDbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.NegotiationId == updItem.NegotiationId && x.DocId != updItem.DocId)
|
|
.ToList();
|
|
|
|
// se NON fosse licenza --> disattivo altri
|
|
if (currData.DocType < BbmDocType.Licenza)
|
|
{
|
|
foreach (var item in otherData)
|
|
{
|
|
item.IsActive = false;
|
|
}
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
|
|
// rileggo
|
|
locDbCtx.Entry(currData).Reload();
|
|
// anche altri valori
|
|
foreach (var item in otherData)
|
|
{
|
|
locDbCtx.Entry(item).Reload();
|
|
}
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public bool DocsMoveNegot(int docId, int negotiationId)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.DocId == docId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
currData.NegotiationId = negotiationId;
|
|
locDbCtx.Entry(currData).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item Doc
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool DocUpdate(DatabaseModels.DocsModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.DocId == updItem.DocId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetDocs
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge un nuovo item
|
|
/// </summary>
|
|
/// <param name="newItem"></param>
|
|
/// <returns></returns>
|
|
public bool ItemAddNew(DatabaseModels.ItemsModel newItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
locDbCtx
|
|
.DbSetItems
|
|
.Add(newItem);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina item Basket
|
|
/// </summary>
|
|
/// <param name="CodItem"></param>
|
|
/// <returns></returns>
|
|
public bool ItemDelete(string CodItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetItems
|
|
.Where(x => x.CodItem == CodItem)
|
|
.FirstOrDefault();
|
|
locDbCtx.DbSetItems.Remove(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera singolo ITEM da chiave
|
|
/// </summary>
|
|
/// <param name="ItemId"></param>
|
|
/// <returns></returns>
|
|
public DatabaseModels.ItemsModel ItemFind(int ItemId)
|
|
{
|
|
DatabaseModels.ItemsModel dbResult = new DatabaseModels.ItemsModel();
|
|
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetItems
|
|
.Find(ItemId);
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Items
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.ItemsModel> ItemGetAsc()
|
|
{
|
|
List<DatabaseModels.ItemsModel> dbResult = new List<DatabaseModels.ItemsModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetItems
|
|
.OrderBy(x => x.CodItem)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Items
|
|
/// </summary>
|
|
/// <param name="searchVal"></param>
|
|
/// <param name="ResType"></param>
|
|
/// <param name="UM"></param>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.ItemsModel> ItemGetLastDesc(string searchVal, BbmResType ResType = BbmResType.ND, string UM = "", int numRecord = 0)
|
|
{
|
|
List<DatabaseModels.ItemsModel> dbResult = new List<DatabaseModels.ItemsModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = locDbCtx.DbSetItems.Count();
|
|
}
|
|
dbResult = locDbCtx
|
|
.DbSetItems
|
|
.Where(x => (x.CodItem != "ITEM.0000.0000") && (string.IsNullOrEmpty(searchVal) || (x.Descript.Contains(searchVal) || x.CodItem.Contains(searchVal))) && (x.ResType == ResType || ResType == BbmResType.ND) && (x.UM == UM || UM == ""))
|
|
.OrderByDescending(x => x.CodItem)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
public int ItemsCount()
|
|
{
|
|
int answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetItems
|
|
.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool ItemUpdate(DatabaseModels.ItemsModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetItems
|
|
.Where(x => x.ItemId == updItem.ItemId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetItems
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge un nuovo item Negotiation
|
|
/// </summary>
|
|
/// <param name="newItem"></param>
|
|
/// <returns></returns>
|
|
public bool NegotAddNew(DatabaseModels.NegotiationsModel newItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
locDbCtx
|
|
.DbSetNegotiations
|
|
.Add(newItem);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina item Negotiation
|
|
/// </summary>
|
|
/// <param name="newItem"></param>
|
|
/// <returns></returns>
|
|
public bool NegotDelete(string CodNegotiation)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetNegotiations
|
|
.Where(x => x.CodNegotiation == CodNegotiation)
|
|
.FirstOrDefault();
|
|
locDbCtx.DbSetNegotiations.Remove(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco TUTTE Negoziazioni
|
|
/// </summary>
|
|
/// <param name="searchVal"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.NegotiationsModel> NegotGetAllDesc()
|
|
{
|
|
List<DatabaseModels.NegotiationsModel> dbResult = new List<DatabaseModels.NegotiationsModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetNegotiations
|
|
.OrderByDescending(x => x.CodNegotiation)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Negoziazione dato codice
|
|
/// </summary>
|
|
/// <param name="NegotId"></param>
|
|
/// <returns></returns>
|
|
public DatabaseModels.NegotiationsModel NegotGetByKey(int NegotId)
|
|
{
|
|
DatabaseModels.NegotiationsModel dbResult = new DatabaseModels.NegotiationsModel();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetNegotiations
|
|
.Where(x => x.NegotiationId == NegotId)
|
|
.FirstOrDefault();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultime Negoziazioni
|
|
/// </summary>
|
|
/// <param name="searchVal"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.NegotiationsModel> NegotGetLastDesc(int CompanyId, int CustomerId, int BasketId, string searchVal)
|
|
{
|
|
List<DatabaseModels.NegotiationsModel> dbResult = new List<DatabaseModels.NegotiationsModel>();
|
|
dbResult = dbCtx
|
|
.DbSetNegotiations
|
|
// || x.Basket.Company.RagSoc.Contains(searchVal)
|
|
.Where(x => (x.Basket.CompanyId == CompanyId || CompanyId == 1) && (x.CustomerId == CustomerId || CustomerId == 1) && (x.BasketId == BasketId || BasketId == 1) && (x.NegotiationId > 1) && (string.IsNullOrEmpty(searchVal) || x.CodNegotiation.Contains(searchVal) || x.BasePath.Contains(searchVal)))
|
|
.OrderByDescending(x => x.CodNegotiation)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.ToList();
|
|
return dbResult;
|
|
}
|
|
|
|
public int NegotiationsCount()
|
|
{
|
|
int answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetNegotiations
|
|
.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item Negotiation
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool NegotUpdate(DatabaseModels.NegotiationsModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetNegotiations
|
|
.Where(x => x.CodNegotiation == updItem.CodNegotiation)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetNegotiations
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiunge un nuova Resource
|
|
/// </summary>
|
|
/// <param name="newItem"></param>
|
|
/// <returns></returns>
|
|
public bool ResourceAddNew(DatabaseModels.ResourcesModel newItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
locDbCtx
|
|
.DbSetResources
|
|
.Add(newItem);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Duplica resource da documento source --> target
|
|
/// </summary>
|
|
/// <param name="DocIdSrc"></param>
|
|
/// <param name="DocIdTgt"></param>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.ResourcesModel> ResourceCloneByDoc(int DocIdSrc, int DocIdTgt)
|
|
{
|
|
List<DatabaseModels.ResourcesModel> dbResult = new List<DatabaseModels.ResourcesModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetResources
|
|
.AsNoTracking()
|
|
.Where(x => x.DocId == DocIdSrc)
|
|
.ToList();
|
|
|
|
// aggiorno doc ed aggiungo...
|
|
foreach (var item in dbResult)
|
|
{
|
|
item.DocId = DocIdTgt;
|
|
locDbCtx
|
|
.DbSetResources
|
|
.Add(item);
|
|
}
|
|
// salvo!
|
|
locDbCtx.SaveChanges();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina item Resource
|
|
/// </summary>
|
|
/// <param name="ResourceId"></param>
|
|
/// <returns></returns>
|
|
public bool ResourceDelete(int ResourceId)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => x.ResourceId == ResourceId)
|
|
.FirstOrDefault();
|
|
locDbCtx.DbSetResources.Remove(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina Resource del doc indicato
|
|
/// </summary>
|
|
/// <param name="DocId"></param>
|
|
/// <returns></returns>
|
|
public bool ResourceDeleteByDoc(int DocId)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => x.DocId == DocId)
|
|
.ToList();
|
|
locDbCtx.DbSetResources.RemoveRange(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Items
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public double ResourceGetGrandTotal(int DocId = 0)
|
|
{
|
|
double answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => (x.DocId == DocId || DocId == 0))
|
|
.Select(x => x.FinalPrice)
|
|
.Sum();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco risorse
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.ResourcesModel> ResourceGetLastDesc(int anno, int numRecord)
|
|
{
|
|
List<DatabaseModels.ResourcesModel> dbResult = new List<DatabaseModels.ResourcesModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => x.Anno == anno)
|
|
.Count();
|
|
}
|
|
dbResult = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => x.Anno == anno)
|
|
.OrderByDescending(x => x.Ordinal)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Items
|
|
/// </summary>
|
|
/// <param name="docId"></param>
|
|
/// <param name="ResType"></param>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.ResourcesModel> ResourceGetLastDesc(int anno, int baskId, int negoId, int docId, BbmResType ResType = BbmResType.ND)
|
|
{
|
|
List<DatabaseModels.ResourcesModel> dbResult = new List<DatabaseModels.ResourcesModel>();
|
|
dbResult = dbCtx
|
|
.DbSetResources
|
|
.Where(x => (x.Anno == anno || anno == 0) && (x.Item.ResType == ResType || ResType == BbmResType.ND) && (x.Document.Negotiation.BasketId == baskId || baskId <= 1) && (x.Document.NegotiationId == negoId || negoId <= 1) && (x.DocId == docId || docId <= 1) && (docId > 0 || x.Document.IsActive))
|
|
.OrderByDescending(x => x.Ordinal)
|
|
.ToList();
|
|
return dbResult;
|
|
}
|
|
|
|
public int ResourcesCount()
|
|
{
|
|
int answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetResources
|
|
.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna una Resource
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool ResourceUpdate(DatabaseModels.ResourcesModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => x.ResourceId == updItem.ResourceId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetResources
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna una Resource come POSIZIONE (SE NON VA oltre i limiti)
|
|
/// </summary>
|
|
/// <param name="ResourceId"></param>
|
|
/// <param name="move">INT movimento: -1 = UP / 1 = DOWN</param>
|
|
/// <returns></returns>
|
|
public bool ResourceUpdateOrder(int ResourceId, int move)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currItem = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => x.ResourceId == ResourceId)
|
|
.FirstOrDefault();
|
|
|
|
if (currItem != null)
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => x.DocId == currItem.DocId)
|
|
.ToList();
|
|
// verifico quanti sono x determinare estremi movimento... 1 <= x <= maxOrder
|
|
bool canMove = false;
|
|
|
|
int maxOrder = currData.Count();
|
|
// se ammesso...
|
|
if (move < 0)
|
|
{
|
|
canMove = currItem.Ordinal + move >= 1;
|
|
}
|
|
else
|
|
{
|
|
canMove = currItem.Ordinal + move <= maxOrder;
|
|
}
|
|
if (canMove)
|
|
{
|
|
// recupero altro itemo x movimento opposto.
|
|
var otherItem = currData
|
|
.Where(x => x.Ordinal == currItem.Ordinal + move)
|
|
.FirstOrDefault();
|
|
if (otherItem != null)
|
|
{
|
|
otherItem.Ordinal -= move;
|
|
currItem.Ordinal += move;
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Annulla modifiche su una specifica entity (cancel update)
|
|
/// </summary>
|
|
/// <param name="item"></param>
|
|
/// <returns></returns>
|
|
public bool rollBackEntity(object item)
|
|
{
|
|
bool answ = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
if (dbCtx.Entry(item).State == System.Data.Entity.EntityState.Deleted || locDbCtx.Entry(item).State == System.Data.Entity.EntityState.Modified)
|
|
{
|
|
locDbCtx.Entry(item).Reload();
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Error($"Eccezione in rollBackEntity{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Valore complessivo DRAFT (NON confermato) x ANNO
|
|
/// </summary>
|
|
/// <param name="anno"></param>
|
|
/// <returns></returns>
|
|
public double SumTotDraft(int anno = 0)
|
|
{
|
|
double answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => ((x.Document.DataIns.Year == anno || anno == 0) && x.Document.IsActive && x.Document.IsDraft))
|
|
.Select(x => x.FinalPrice)
|
|
.Sum();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Importo complessivo fatture EMESSE x ANNO
|
|
/// </summary>
|
|
/// <param name="anno"></param>
|
|
/// <returns></returns>
|
|
public decimal SumTotImporto(int anno = 0)
|
|
{
|
|
decimal answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Where(x => (x.DataIns.Year == anno || anno == 0))
|
|
.Select(x => x.Importo)
|
|
.Sum();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Incasso complessivo fatture INCASSATE x ANNO
|
|
/// </summary>
|
|
/// <param name="anno"></param>
|
|
/// <returns></returns>
|
|
public decimal SumTotIncasso(int anno = 0)
|
|
{
|
|
decimal answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetFatt2Doc
|
|
.Where(x => (x.DataIns.Year == anno || anno == 0))
|
|
.Select(x => x.Incassato)
|
|
.Sum();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Valore complessivo ORDINATO x ANNO
|
|
/// </summary>
|
|
/// <param name="anno"></param>
|
|
/// <returns></returns>
|
|
public double SumTotOrdinato(int anno = 0)
|
|
{
|
|
double answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => ((x.Document.DataIns.Year == anno || anno == 0) && (x.Document.DocType == BbmDocType.ConfermaOrdine || x.Document.DocType == BbmDocType.Licenza)))
|
|
.Select(x => x.FinalPrice)
|
|
.Sum();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Valore complessivo TRATTATO x ANNO
|
|
/// </summary>
|
|
/// <param name="anno"></param>
|
|
/// <returns></returns>
|
|
public double SumTotTrattato(int anno = 0)
|
|
{
|
|
double answ = 0;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
answ = locDbCtx
|
|
.DbSetResources
|
|
.Where(x => ((x.Document.DataIns.Year == anno || anno == 0) && x.Document.IsActive && !x.Document.IsDraft))
|
|
.Select(x => x.FinalPrice)
|
|
.Sum();
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
public bool TagDelete(int tagId)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetTags
|
|
.Where(x => x.TagId == tagId)
|
|
.FirstOrDefault();
|
|
locDbCtx.DbSetTags.Remove(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public bool TagItemDelete(DatabaseModels.TagItemModel delItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var item2del = locDbCtx
|
|
.DbSetTags2Items
|
|
.Where(x => x.TagId == delItem.TagId && x.ItemId == delItem.ItemId)
|
|
.FirstOrDefault();
|
|
locDbCtx.DbSetTags2Items.Remove(item2del);
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public List<DatabaseModels.TagItemModel> TagItemGetByItem(int itemId)
|
|
{
|
|
List<DatabaseModels.TagItemModel> dbResult = new List<DatabaseModels.TagItemModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetTags2Items
|
|
.Where(x => (x.ItemId == itemId))
|
|
.OrderBy(x => x.TagsNav.CodTag)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
public bool TagItemUpdate(DatabaseModels.TagItemModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetTags2Items
|
|
.Where(x => x.TagId == updItem.TagId && x.ItemId == updItem.ItemId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetTags2Items
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
public List<DatabaseModels.TagModel> TagsGetAll(TagType selType)
|
|
{
|
|
List<DatabaseModels.TagModel> dbResult = new List<DatabaseModels.TagModel>();
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
dbResult = locDbCtx
|
|
.DbSetTags
|
|
.Where(x => (x.TagType == selType || selType == TagType.All))
|
|
.OrderBy(x => x.TagType)
|
|
.OrderBy(x => x.CodTag)
|
|
.ToList();
|
|
}
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un Tag
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool TagUpdate(DatabaseModels.TagModel updItem)
|
|
{
|
|
bool done = false;
|
|
using (MainDbContext locDbCtx = new MainDbContext(_connBBM))
|
|
{
|
|
try
|
|
{
|
|
var currData = locDbCtx
|
|
.DbSetTags
|
|
.Where(x => x.TagId == updItem.TagId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
locDbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
locDbCtx
|
|
.DbSetTags
|
|
.Add(updItem);
|
|
}
|
|
locDbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
return done;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
} |