Samuele E. Locatelli
814 lines
24 KiB
C#
814 lines
24 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Configuration;
|
|
|
|
namespace SHERPA.BBM.Controllers
|
|
{
|
|
public class BBMController : IDisposable
|
|
{
|
|
#region Private Fields
|
|
|
|
private DatabaseContext dbCtx;
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Public Constructors
|
|
|
|
public BBMController()
|
|
{
|
|
string connString = ConfigurationManager.AppSettings["BBMModel"];
|
|
dbCtx = new DatabaseContext(connString);
|
|
}
|
|
|
|
public BBMController(string connString)
|
|
{
|
|
dbCtx = new DatabaseContext(connString);
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#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;
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetBaskets
|
|
.Add(newItem);
|
|
dbCtx.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;
|
|
try
|
|
{
|
|
var item2del = dbCtx
|
|
.DbSetBaskets
|
|
.Where(x => x.CodBasket == CodBasket)
|
|
.FirstOrDefault();
|
|
dbCtx.DbSetBaskets.Remove(item2del);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Baskets
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.BasketsModel> BaskGetLastDesc(int numRecord)
|
|
{
|
|
List<DatabaseModels.BasketsModel> dbResult = new List<DatabaseModels.BasketsModel>();
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.DbSetBaskets.Count();
|
|
}
|
|
dbResult = dbCtx
|
|
.DbSetBaskets
|
|
.OrderByDescending(x => x.CodBasket)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item Baskets
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool BaskUpdate(DatabaseModels.BasketsModel updItem)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetBaskets
|
|
.Where(x => x.CodBasket == updItem.CodBasket)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetBaskets
|
|
.Add(updItem);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
public string CounterGetNext(string CodCounter)
|
|
{
|
|
string answ = $"{CodCounter}.0000";
|
|
int nextId = 1;
|
|
var lastCount = dbCtx
|
|
.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
|
|
};
|
|
dbCtx
|
|
.DbSetCounters
|
|
.Add(newRecord);
|
|
}
|
|
answ = $"{CodCounter}.{nextId:000000}";
|
|
dbCtx.SaveChanges();
|
|
|
|
return answ;
|
|
}
|
|
|
|
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;
|
|
try
|
|
{
|
|
var item2del = dbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.DocId == DocId)
|
|
.FirstOrDefault();
|
|
dbCtx.DbSetDocs.Remove(item2del);
|
|
dbCtx.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;
|
|
try
|
|
{
|
|
currDoc = dbCtx
|
|
.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>();
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.DbSetDocs.Count();
|
|
}
|
|
dbResult = dbCtx
|
|
.DbSetDocs
|
|
.OrderByDescending(x => x.CodDoc)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Docs
|
|
/// </summary>
|
|
/// <param name="CodBasket"></param>
|
|
/// <param name="CodNegotiation"></param>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.DocsModel> DocGetLastDesc(int BasketId = 0, int NegotiationId = 0, int numRecord = 0)
|
|
{
|
|
List<DatabaseModels.DocsModel> dbResult = new List<DatabaseModels.DocsModel>();
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.DbSetDocs.Count();
|
|
}
|
|
dbResult = dbCtx
|
|
.DbSetDocs
|
|
.Where(x => (x.BasketId == BasketId || BasketId == 0) && (x.NegotiationId == NegotiationId || NegotiationId == 0))
|
|
.OrderByDescending(x => x.CodDoc)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.Take(numRecord)
|
|
.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;
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetDocs
|
|
.Add(newItem);
|
|
dbCtx.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;
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.DocId == updItem.DocId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetDocs
|
|
.Add(updItem);
|
|
}
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <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;
|
|
try
|
|
{
|
|
// attivo record corrente
|
|
var currData = dbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.DocId == updItem.DocId)
|
|
.FirstOrDefault();
|
|
currData.IsActive=true;
|
|
// altri record da disattivare
|
|
var otherData = dbCtx
|
|
.DbSetDocs
|
|
.Where(x => x.NegotiationId == updItem.NegotiationId && x.DocId != updItem.DocId)
|
|
.ToList();
|
|
foreach (var item in otherData)
|
|
{
|
|
item.IsActive = false;
|
|
|
|
}
|
|
dbCtx.SaveChanges();
|
|
// rileggo
|
|
dbCtx.Entry(currData).Reload();
|
|
// anche altri valori
|
|
foreach (var item in otherData)
|
|
{
|
|
dbCtx.Entry(item).Reload();
|
|
}
|
|
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;
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetItems
|
|
.Add(newItem);
|
|
dbCtx.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;
|
|
try
|
|
{
|
|
var item2del = dbCtx
|
|
.DbSetItems
|
|
.Where(x => x.CodItem == CodItem)
|
|
.FirstOrDefault();
|
|
dbCtx.DbSetItems.Remove(item2del);
|
|
dbCtx.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)
|
|
{
|
|
var dbResult = dbCtx
|
|
.DbSetItems
|
|
.Find(ItemId);
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Items
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.ItemsModel> ItemGetLastDesc(int numRecord)
|
|
{
|
|
List<DatabaseModels.ItemsModel> dbResult = new List<DatabaseModels.ItemsModel>();
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.DbSetItems.Count();
|
|
}
|
|
dbResult = dbCtx
|
|
.DbSetItems
|
|
.OrderByDescending(x => x.CodItem)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Items
|
|
/// </summary>
|
|
/// <param name="ResType"></param>
|
|
/// <param name="UM"></param>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.ItemsModel> ItemGetLastDesc(BbmResType ResType = BbmResType.ND, string UM = "", int numRecord = 0)
|
|
{
|
|
List<DatabaseModels.ItemsModel> dbResult = new List<DatabaseModels.ItemsModel>();
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.DbSetItems.Count();
|
|
}
|
|
dbResult = dbCtx
|
|
.DbSetItems
|
|
.Where(x => (x.ResType == ResType || ResType == BbmResType.ND) && (x.UM == UM || UM == ""))
|
|
.OrderByDescending(x => x.CodItem)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool ItemUpdate(DatabaseModels.ItemsModel updItem)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetItems
|
|
.Where(x => x.ItemId == updItem.ItemId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetItems
|
|
.Add(updItem);
|
|
}
|
|
dbCtx.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;
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetNegotiations
|
|
.Add(newItem);
|
|
dbCtx.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;
|
|
try
|
|
{
|
|
var item2del = dbCtx
|
|
.DbSetNegotiations
|
|
.Where(x => x.CodNegotiation == CodNegotiation)
|
|
.FirstOrDefault();
|
|
dbCtx.DbSetNegotiations.Remove(item2del);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultime Negoziazioni
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.NegotiationsModel> NegotGetLastDesc(int numRecord)
|
|
{
|
|
List<DatabaseModels.NegotiationsModel> dbResult = new List<DatabaseModels.NegotiationsModel>();
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.DbSetNegotiations.Count();
|
|
}
|
|
dbResult = dbCtx
|
|
.DbSetNegotiations
|
|
.OrderByDescending(x => x.CodNegotiation)
|
|
.OrderByDescending(x => x.DataIns)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna un item Negotiation
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool NegotUpdate(DatabaseModels.NegotiationsModel updItem)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetNegotiations
|
|
.Where(x => x.CodNegotiation == updItem.CodNegotiation)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetNegotiations
|
|
.Add(updItem);
|
|
}
|
|
dbCtx.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;
|
|
try
|
|
{
|
|
dbCtx
|
|
.DbSetResources
|
|
.Add(newItem);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina item Resource
|
|
/// </summary>
|
|
/// <param name="ResourceId"></param>
|
|
/// <returns></returns>
|
|
public bool ResourceDelete(int ResourceId)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var item2del = dbCtx
|
|
.DbSetResources
|
|
.Where(x => x.ResourceId == ResourceId)
|
|
.FirstOrDefault();
|
|
dbCtx.DbSetResources.Remove(item2del);
|
|
dbCtx.SaveChanges();
|
|
done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elenco ultimi Items
|
|
/// </summary>
|
|
/// <param name="numRecord"></param>
|
|
/// <returns></returns>
|
|
public List<DatabaseModels.ResourcesModel> ResourceGetLastDesc(int numRecord)
|
|
{
|
|
List<DatabaseModels.ResourcesModel> dbResult = new List<DatabaseModels.ResourcesModel>();
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.DbSetResources.Count();
|
|
}
|
|
dbResult = dbCtx
|
|
.DbSetResources
|
|
.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 DocId = 0, BbmResType ResType = BbmResType.ND, int numRecord = 0)
|
|
{
|
|
List<DatabaseModels.ResourcesModel> dbResult = new List<DatabaseModels.ResourcesModel>();
|
|
// se numRecord = 0 --> passo tutti
|
|
if (numRecord == 0)
|
|
{
|
|
numRecord = dbCtx.DbSetResources.Count();
|
|
}
|
|
dbResult = dbCtx
|
|
.DbSetResources
|
|
.Where(x => (x.Item.ResType == ResType || ResType == BbmResType.ND) && (x.DocId == DocId || DocId == 0))
|
|
.OrderByDescending(x => x.Ordinal)
|
|
.Take(numRecord)
|
|
.ToList();
|
|
|
|
return dbResult;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Aggiorna una Resource
|
|
/// </summary>
|
|
/// <param name="updItem"></param>
|
|
/// <returns></returns>
|
|
public bool ResourceUpdate(DatabaseModels.ResourcesModel updItem)
|
|
{
|
|
bool done = false;
|
|
try
|
|
{
|
|
var currData = dbCtx
|
|
.DbSetResources
|
|
.Where(x => x.ResourceId == updItem.ResourceId)
|
|
.FirstOrDefault();
|
|
if (currData != null)
|
|
{
|
|
dbCtx.Entry(updItem).State = System.Data.Entity.EntityState.Modified;
|
|
}
|
|
else
|
|
{
|
|
dbCtx
|
|
.DbSetResources
|
|
.Add(updItem);
|
|
}
|
|
dbCtx.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;
|
|
try
|
|
{
|
|
var currItem = dbCtx
|
|
.DbSetResources
|
|
.Where(x => x.ResourceId == ResourceId)
|
|
.FirstOrDefault();
|
|
|
|
if (currItem != null)
|
|
{
|
|
var currData = dbCtx
|
|
.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;
|
|
}
|
|
dbCtx.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 roolBackEntity(object item)
|
|
{
|
|
bool answ = false;
|
|
dbCtx.Entry(item).Reload();
|
|
return answ;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#if false
|
|
public void RollBackAll()
|
|
{
|
|
var context = DataContextFactory.GetDataContext();
|
|
var changedEntries = context.ChangeTracker.Entries()
|
|
.Where(x => x.State != EntityState.Unchanged).ToList();
|
|
|
|
foreach (var entry in changedEntries)
|
|
{
|
|
switch (entry.State)
|
|
{
|
|
case EntityState.Modified:
|
|
entry.CurrentValues.SetValues(entry.OriginalValues);
|
|
entry.State = EntityState.Unchanged;
|
|
break;
|
|
|
|
case EntityState.Added:
|
|
entry.State = EntityState.Detached;
|
|
break;
|
|
|
|
case EntityState.Deleted:
|
|
entry.State = EntityState.Unchanged;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
} |