/// <summary>
/// Elimina un MailOut de MailOuts y MailOutTexts
/// </summary>
/// <param name="mo">MailOut</param>
/// <returns> Numero de registros afectados </returns>
/// <history>
/// [erosado] 20/04/2016 Created
/// [erosado] 06/07/2016 Modified. Se agregó Async
/// </history>
public async static Task <int> DeleteMailOut(MailOut mo)
{
int result = 0;
await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
//Eliminamos el MailOut
dbContext.Entry(mo).State = System.Data.Entity.EntityState.Deleted;
//Obtenemos todos los MailOutText que correspondan al MailOut Que vamos a eliminar
List <MailOutText> motlst = (from x in dbContext.MailOutTexts where x.mtls == mo.mols && x.mtmoCode == mo.moCode select x).ToList();
//Eliminamos cada uno de los MailOutTexts
motlst.ForEach(x => dbContext.Entry(x).State = System.Data.Entity.EntityState.Deleted);
result = dbContext.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
}
});
return(result);
}
/// <summary>
/// Guarda la Nota y modifica el Guest
/// </summary>
/// <param name="prNote">Tipo nota</param>
///<param name="guest">Tipo de Guest</param>
/// <history>
/// [jorcanche] created 14/03/2016
/// </history>
public static async Task <int> SaveNoteGuest(PRNote prNote, Guest guest)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
//Guardamos la informacion de la nota del guest
dbContext.Entry(prNote).State = System.Data.Entity.EntityState.Added;
//Guardamos la modificación del guest si se debe modificar
if (guest != null)
{
dbContext.Entry(guest).State = System.Data.Entity.EntityState.Modified;
}
var respuesta = dbContext.SaveChanges();
transaction.Commit();
return respuesta;
}
catch
{
transaction.Rollback();
return 0;
}
}
}
}));
}
/// <summary>
/// Función para guardar un nuevo Exchange Rate agregado
/// </summary>
/// <param name="bUpd"> true - Insertar | false - Update </param>
/// <param name="exchangeRate"> Entidad ExchangeRateDate</param>
/// <param name="currencyID">Clave de la moneda</param>
/// <param name="date">Fecha del servidor </param>
/// <param name="HoursDif"> Diferencia de horas del SalesRoom</param>
/// <param name="ChangedBy"> Clave de la persona que realiza la accion </param>
/// <history>
/// [vipacheco] 14/03/2016 Created
/// [vipacheco] 10/Agosto/2016 Modified se agregó asincronia y se agrego la transaccion
/// </history>
public static void SaveExchangeRate(bool bUpd, ExchangeRate exchangeRate, string currencyID, DateTime date, short HoursDif, string ChangedBy)
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
// Insertamos un nuevo Exchange
if (bUpd)
{
dbContext.Entry(exchangeRate).State = System.Data.Entity.EntityState.Added;
}
// Actualizamos un Exchange existente
else
{
dbContext.Entry(exchangeRate).State = System.Data.Entity.EntityState.Modified;
}
// Guadarmos el Log del cambio.
dbContext.USP_OR_SaveExchangeRateLog(currencyID, date, HoursDif, ChangedBy);
// Guardamos los cambios
dbContext.SaveChanges();
transaction.Commit();
}
catch
{
transaction.Rollback();
throw;
}
}
}
}
/// <summary>
/// Agrega|Actualiza registros en el catalogo HotelGroup
/// Asigan|Desasigna Hotels de HotelGroups
/// </summary>
/// <param name="hotelGrooup">Objeto a guardar</param>
/// <param name="blnUpdate">True. Actualiza | False. Inserta</param>
/// <param name="lstAdd">Lista a asignar al Hotel Group</param>
/// <param name="lstDel">Lista a Eliminar del grupo</param>
/// <returns>-1. Existe un registro con el mismo ID | 0. No se pudo guardar | 1. Se guardó correctamente</returns>
/// <history>
/// [emoguel] created 13/05/2016
/// [emoguel] modified 27/06/2016
/// </history>
public async static Task <int> SaveHotelGroup(HotelGroup hotelGrooup, bool blnUpdate, List <Hotel> lstAdd, List <Hotel> lstDel)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region Update
if (blnUpdate)
{
dbContext.Entry(hotelGrooup).State = EntityState.Modified;
}
#endregion
#region Add
else
{
if (dbContext.HotelsGroups.Where(hoo => hoo.hgID == hotelGrooup.hgID).FirstOrDefault() != null)
{
return -1;
}
else
{
dbContext.HotelsGroups.Add(hotelGrooup);
}
}
#endregion
#region List Add
dbContext.Hotels.AsEnumerable().Where(ho => lstAdd.Any(hoo => hoo.hoID == ho.hoID)).ToList().ForEach(ho =>
{
ho.hoGroup = hotelGrooup.hgID;
dbContext.Entry(ho).State = EntityState.Modified;
});
#endregion
#region ListDel
dbContext.Hotels.AsEnumerable().Where(ho => lstDel.Any(hoo => hoo.hoID == ho.hoID)).ToList().ForEach(ho =>
{
ho.hoGroup = null;
dbContext.Entry(ho).State = EntityState.Modified;
});
#endregion
int nRes = dbContext.SaveChanges();
transacction.Commit();
return nRes;
}
catch
{
transacction.Rollback();
return 0;
}
}
}
}));
}
/// <summary>
/// Guarda un sale Type Category.
/// agregar sale Types al sale type category
/// Eliminar saleTypes del sale type category
/// </summary>
/// <param name="saleTypeCategory">Objeto a guardar en la BD</param>
/// <param name="blnUpdate">
/// True. Actualiza
/// False. Agrega
/// </param>
/// <param name="lstAddSaleTypes">Sale Types a agregar</param>
/// <param name="lstDelSaleTypes">Sale Types a Eliiminar</param>
/// <returns>-1.- Existe un registro con el mismo ID| 0. No se guardó | >0. Se guardó correctamente</returns>
/// <history>
/// [emoguel] created 01-08-2016
/// </history>
public static async Task <int> SaveSaleTypeCategory(SaleTypeCategory saleTypeCategory, bool blnUpdate, List <SaleType> lstAddSaleTypes, List <SaleType> lstDelSaleTypes)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
if (blnUpdate)
{
dbContext.Entry(saleTypeCategory).State = EntityState.Modified;
}
else
{
if (dbContext.SaleTypesCategories.Where(stc => stc.stcID == saleTypeCategory.stcID).FirstOrDefault() != null)
{
return -1;
}
else
{
dbContext.Entry(saleTypeCategory).State = EntityState.Added;
}
}
#region
//Agregar saleTypes
if (lstAddSaleTypes.Count > 0)
{
lstAddSaleTypes.ForEach(st =>
{
st.ststc = saleTypeCategory.stcID;
dbContext.Entry(st).State = EntityState.Modified;
});
}
//Eliminar saleTypes
if (lstDelSaleTypes.Count > 0)
{
lstDelSaleTypes.ForEach(st =>
{
st.ststc = null;
dbContext.Entry(st).State = EntityState.Modified;
});
}
#endregion
int nRes = dbContext.SaveChanges();
transacction.Commit();
return nRes;
}
catch
{
transacction.Rollback();
throw;
}
}
}
}));
}
/// <summary>
/// Agrega|Actualiza|Elimina registros en el catalogo Goals
/// </summary>
/// <param name="goal">objeto con los datos nuevos a guardar</param>
/// <param name="lstAdd">Registros a agregar en la BD</param>
/// <param name="lstUpdate">Registros a actualizar en la BD</param>
/// <param name="lstDel">Registros a eliminar de la BD</param>
/// <returns>0. No se guardó | >0. Se guardaron correctamente </returns>
/// <history>
/// [emoguel] created 12/05/2016
/// </history>
public static int SaveGoal(Goal goal, List <Goal> lstAdd, List <Goal> lstUpdate, List <Goal> lstDel)
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region Add
lstAdd.ForEach(go =>
{
go.goDateFrom = goal.goDateFrom;
go.goDateTo = goal.goDateTo;
go.gopd = goal.gopd;
go.gopy = goal.gopy;
dbContext.Entry(go).State = EntityState.Added;
});
#endregion
#region Update
lstUpdate.ForEach(go =>
{
go.goDateFrom = goal.goDateFrom;
go.goDateTo = goal.goDateTo;
go.gopd = goal.gopd;
go.gopy = goal.gopy;
dbContext.Entry(go).State = EntityState.Modified;
});
#endregion
#region Delete
lstDel.ForEach(go => {
dbContext.Entry(go).State = EntityState.Deleted;
});
#endregion
int nRes = dbContext.SaveChanges();
transacction.Commit();
return(nRes);
}
catch
{
transacction.Rollback();
return(0);
}
}
}
}
/// <summary>
/// Agrega|Actualiza un registro en el catalogo SalesAmountRanges
/// </summary>
/// <param name="salesAmountRange">Objeto a guardar</param>
/// <param name="blnUpdate">Truw. Actualiza | False. Agrega</param>
/// <returns>0. No se guardó | 1. Se guardó | -2. verificar el rango</returns>
/// <history>
/// [emoguel] crated 20/04/2016
/// </history>
public static int SaveSalesAmountRange(SalesAmountRange salesAmountRange, bool blnUpdate)
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
#region Validar Rango
bool blnValid = false;
var query = dbContext.SalesAmountRanges.Where(sn => sn.snFrom <= salesAmountRange.snFrom && salesAmountRange.snFrom <= sn.snTo);
if (blnUpdate)
{
query = query.Where(sn => sn.snID != salesAmountRange.snID);
}
SalesAmountRange salAmoRange = query.FirstOrDefault();
blnValid = (salAmoRange == null);
#endregion
if (blnValid)
{
dbContext.Entry(salesAmountRange).State = (blnUpdate) ? EntityState.Modified : EntityState.Added;
}
else
{
return(-2);
}
return(dbContext.SaveChanges());
}
}
/// <summary>
/// Actualiza la posición de los registros de segmentcategory
/// </summary>
/// <param name="lstSegmentsCategoriesOrder">Lista de SegmentCategory</param>
/// <returns>0. No se guardó | >0. Se guardó correctamente</returns>
/// <history>
/// [emoguel] created 03/06/2016
/// </history>
public static async Task <int> ChangeSegmentsCategoryOrder(List <SegmentCategory> lstSegmentsCategoriesOrder)
{
int nRes = await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
lstSegmentsCategoriesOrder.ForEach(sc =>
{
dbContext.Entry(sc).State = System.Data.Entity.EntityState.Modified;
});
int nSave = dbContext.SaveChanges();
transaction.Commit();
return(nSave);
}
catch
{
transaction.Rollback();
return(0);
}
}
}
});
return(nRes);
}
/// <summary>
/// Agrega|Actualiza un registro en el catalogo Desk
/// </summary>
/// <param name="desk">Objeto a guardar en la BD</param>
/// <param name="blnUpdate">True. Actualiza un registro | False. Agrega un registro</param>
/// <param name="lstIdsComputers">id's de computers a relacionar</param>
/// <returns>0. No se puedo guardar | > 0 . Se guardó correctamente | -1. Existe un registro con el mismo ID (Sólo cuando es insertar)</returns>
/// <history>
/// [emoguel] created 16/03/2016
/// [emoguel] modified 09/06/2016---> se volvió async
/// </history>
public async static Task <int> SaveDesk(Desk desk, bool blnUpdate, List <string> lstIdsComputers)
{
int nRes = await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region Actualizar
if (blnUpdate)//Si es actualizar
{
dbContext.Entry(desk).State = System.Data.Entity.EntityState.Modified;
}
#endregion
#region Agregar
else//Si es guardar
{
dbContext.Desks.Add(desk);
}
#endregion
#region Actualizar Computers
#region Desaignar
var lstComputersDes = (from cmp in dbContext.Computers
where !lstIdsComputers.Contains(cmp.cpID) &&
cmp.cpdk == desk.dkID
select cmp).ToList(); //Buscamos todas las computers asigndas que ya no estan en la lista
lstComputersDes.ForEach(cmp => cmp.cpdk = null); //Des-relacionamos las computers que no esten en la nueva lista
#endregion
#region Asignar
var lstComputersAsi = (from cmp in dbContext.Computers
where lstIdsComputers.Contains(cmp.cpID)
select cmp).ToList(); //Buscamos todas las computers que se van a asignar
lstComputersAsi.ForEach(cmp => cmp.cpdk = desk.dkID); //Des-relacionamos las computers que no esten en la nueva lista
#endregion
#endregion
int nSave = dbContext.SaveChanges();
transacction.Commit();
return(nSave);
}
catch
{
transacction.Rollback();
return(0);
}
}
}
});
return(nRes);
}
/// <summary>
/// Guarda los shows de vendedores
/// </summary>
/// <param name="guestId">Guest ID</param>
/// <param name="lstShowSalesman">Lista de shows de vendedores</param>
/// <history>
/// [aalcocer] created 10/08/2016
/// </history>
public static async Task <int> SaveShowsSalesmen(int guestId, List <ShowSalesman> lstShowSalesman)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
//Del
dbContext.ShowsSalesmen.RemoveRange(dbContext.ShowsSalesmen.Where(ss => ss.shgu == guestId));
//Add
lstShowSalesman.ForEach(ss =>
{
ShowSalesman showSalesman = ObjectHelper.CopyProperties(ss);
dbContext.Entry(showSalesman).State = EntityState.Added;
});
var nSave = dbContext.SaveChanges();
transacction.Commit();
return nSave;
}
catch
{
transacction.Rollback();
throw;
}
}
}
}));
}
/// <summary>
/// Guarda|Actualiza un registro en el catalogo
/// </summary>
/// <param name="salesRoom">Objeto a guardar</param>
/// <param name="blnUpdate">True. Actualiza | False. Inserta</param>
/// <returns>-1 Existe un registro con el mismo ID | 0. No se guardó | 1. Se guardó</returns>
/// <history>
/// [emoguel] created 22/04/2016
/// </history>
public static int SaveSalesRoom(SalesRoom salesRoom, bool blnUpdate)
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
int nRes = 0;
#region Update
if (blnUpdate)
{
dbContext.Entry(salesRoom).State = System.Data.Entity.EntityState.Modified;
return(dbContext.SaveChanges());
}
#endregion
#region Add
else
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
SalesRoom salesRoomVal = dbContext.SalesRooms.Where(sr => sr.srID == salesRoom.srID).FirstOrDefault();
if (salesRoomVal != null)
{
return(-1);
}
else
{
var GetDate = BRHelpers.GetServerDate();
salesRoom.srGiftsRcptCloseD = GetDate;
salesRoom.srCxCCloseD = GetDate;
salesRoom.srShowsCloseD = GetDate;
salesRoom.srMealTicketsCloseD = GetDate;
salesRoom.srSalesCloseD = GetDate;
dbContext.SalesRooms.Add(salesRoom);
if (dbContext.SaveChanges() > 0)
{
dbContext.USP_OR_AddAccessAdministrator("SR");
dbContext.SaveChanges();
nRes = 1;
transaction.Commit();
}
else
{
transaction.Rollback();
return(0);
}
}
}
catch
{
transaction.Rollback();
nRes = 0;
}
}
}
#endregion
return(nRes);
}
}
/// <summary>
/// Agrega|Actualiza registros del catalogo depts
/// </summary>
/// <param name="dept">Objeto a guardar</param>
/// <param name="blnUpdate">Truw. Actualiza | False. Agrega</param>
/// <param name="lstAdd">Personnels a asignar</param>
/// <param name="lstDel">Personels a desasignar</param>
/// <returns>0. No se guardó | 1. Se guardó | -1. Existe un registro con el mismo ID</returns>
/// <history>
/// [emoguel] created 04/05/2016
/// [emoguel] modified 29/07/2016--->Se volvió async
/// </history>
public static async Task <int> SaveDept(Dept dept, bool blnUpdate, List <Personnel> lstAdd, List <Personnel> lstDel)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region Update
if (blnUpdate)
{
dbContext.Entry(dept).State = EntityState.Modified;
}
#endregion
#region Add
else
{
Dept deptVal = dbContext.Depts.Where(de => de.deID == dept.deID).FirstOrDefault();
if (deptVal != null)
{
return -1;
}
else
{
dbContext.Depts.Add(dept);
}
}
#endregion
#region add personnel
if (lstAdd.Count > 0)
{
dbContext.Personnels.AsEnumerable().Where(pe => lstAdd.Any(pee => pee.peID == pe.peID)).ToList().ForEach(pe => pe.pede = dept.deID);
}
#endregion
#region del Personnel
if (lstDel.Count > 0)
{
dbContext.Personnels.AsEnumerable().Where(pe => lstDel.Any(pee => pee.peID == pe.peID)).ToList().ForEach(pe => pe.pede = null);
}
#endregion
int nRes = dbContext.SaveChanges();
transaction.Commit();
return nRes;
}
catch
{
transaction.Rollback();
return 0;
}
}
}
}));
}
/// <summary>
/// Guarda un registro en el catalogo ShowProgramcategories
/// Asigan y Desasigna showprograms a su category
/// </summary>
/// <param name="showProgramcategory">Objeto a guardar</param>
/// <param name="lstAdd">Lista para asignar</param>
/// <param name="lstDel">Lista para desasignar</param>
/// <param name="blnUpdate">True. Actualiza | False. Inserta</param>
/// <returns>-1. Existe un registro con el mismo ID | 0. No se guardó | 1. se guardó</returns>
/// <history>
/// [emoguel] created 04/06/2016
/// </history>
public static async Task <int> SaveShowProgramCategory(ShowProgramCategory showProgramcategory, List <ShowProgram> lstAdd, List <ShowProgram> lstDel, bool blnUpdate)
{
int nRes = await Task.Run(() => {
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region Actualizar
if (blnUpdate)
{
dbContext.Entry(showProgramcategory).State = System.Data.Entity.EntityState.Modified;
}
#endregion
#region Agregar
else
{
if (dbContext.ShowProgramsCategories.Where(sg => sg.sgID == showProgramcategory.sgID).FirstOrDefault() != null)
{
return(-1);
}
else
{
dbContext.ShowProgramsCategories.Add(showProgramcategory);
}
}
#endregion
#region AddShowProgram
dbContext.ShowPrograms.AsEnumerable().Where(sk => lstAdd.Any(skk => sk.skID == skk.skID)).ToList().ForEach(sk =>
{
sk.sksg = showProgramcategory.sgID;
});
#endregion
#region DelShowProgram
dbContext.ShowPrograms.AsEnumerable().Where(sk => lstDel.Any(skk => sk.skID == skk.skID)).ToList().ForEach(sk =>
{
sk.sksg = null;
});
#endregion
int nSave = dbContext.SaveChanges();
transacction.Commit();
return(nSave);
}
catch
{
transacction.Rollback();
throw;
}
}
}
});
return(nRes);
}
/// <summary>
/// Guarda un registro en el catalogo Zone
/// </summary>
/// <param name="zone">objeto a guardar</param>
/// <param name="lstAdd">Lista a asignar</param>
/// <param name="lstDel">Lista a eliminar</param>
/// <param name="blnUpdate">True. Actualiza | False. Inserta</param>
/// <returns>-1. Extiste un registro con el mismo ID | 0. No se guardó | 1. Se guardó</returns>
/// <history>
/// [emoguel] created 09/06/2016
/// </history>
public async static Task <int> SaveZone(Zone zone, List <LeadSource> lstAdd, List <LeadSource> lstDel, bool blnUpdate)
{
int nRes = await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region Update
if (blnUpdate)
{
dbContext.Entry(zone).State = System.Data.Entity.EntityState.Modified;
}
#endregion
#region Add
else
{
if (dbContext.Zones.Where(zn => zn.znID == zone.znID).FirstOrDefault() != null)
{
return(-1);
}
else
{
dbContext.Zones.Add(zone);
}
}
#endregion
#region LeadSources
//Add
dbContext.LeadSources.AsEnumerable().Where(ls => lstAdd.Any(lss => lss.lsID == ls.lsID)).ToList().ForEach(ls =>
{
ls.lszn = zone.znID;
});
//Delete
dbContext.LeadSources.AsEnumerable().Where(ls => lstDel.Any(lss => lss.lsID == ls.lsID)).ToList().ForEach(ls =>
{
ls.lszn = null;
});
#endregion
int nSave = dbContext.SaveChanges();
transacction.Commit();
return(nSave);
}
catch
{
transacction.Rollback();
return(0);
}
}
}
});
return(nRes);
}
/// <summary>
/// Función que actualiza un Meal Ticket creado anteriomente
/// </summary>
/// <param name="pMealTicket"></param>
/// <history>
/// [vipacheco] 01/04/2016 Created
/// </history>
public static void UpdateMealTicket(MealTicket pMealTicket)
{
using (var dbcontext = new IMEntities(ConnectionHelper.ConnectionString()))
{
dbcontext.Entry(pMealTicket).State = System.Data.Entity.EntityState.Modified;
dbcontext.SaveChanges();
}
}
/// <summary>
/// Elimina un MailOut de MailOuts y MailOutTexts
/// </summary>
/// <param name="_mols">mols</param>
/// <param name="_moCode">moCode</param>
/// <returns>-1 Error -0 Ya existe ese MailOut - >0 Registros Afectados</returns>
/// <history>
/// [erosado] 20/04/2016 Created
/// [erosado] 06/07/2016 Modified. Se agregó async.
/// </history>
public async static Task <int> InsertMailOut(string _mols, string _moCode)
{
int result = 0;
await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
//Verificamos que no exista un MailOut igual al que queremos insertar
if (dbContext.MailOuts.Any(x => x.mols == _mols && x.moCode == _moCode))
{
result = 0;
}
else
{
//Agregamos el nuevo MailOut
dbContext.Entry(
new MailOut()
{
mols = _mols,
moCode = _moCode
}).State = System.Data.Entity.EntityState.Added;
//Lista de Languages
List <string> languages = dbContext.Languages.Select(x => x.laID).ToList();
//Insertamos un MailOutText Por cada Lenguaje
languages.ForEach(laID => dbContext.MailOutTexts.Add(
new MailOutText()
{
mtls = _mols,
mtmoCode = _moCode,
mtla = laID,
mtU = BRHelpers.GetServerDateTime()
}));
//Guardamos Cambios
dbContext.SaveChanges();
transaction.Commit();
result = 1;
}
}
catch
{
transaction.Rollback();
throw;
}
}
}
});
return(result);
}
/// <summary>
/// Actualiza el RTF de un MailOutsText
/// </summary>
/// <param name="mot">MailOutText</param>
/// <history>
/// [erosado] 08/04/2016 Created
/// [erosado] 05/07/2016 Modified. Se agregó Async.
/// </history>
public async static Task UpdateRTFMailOutTexts(MailOutText mot)
{
await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
dbContext.Entry(mot).State = System.Data.Entity.EntityState.Modified;
dbContext.SaveChanges();
}
});
}
/// <summary>
/// Agrega|Actualiza un Program
/// Asigna una lista de leadSource
/// </summary>
/// <param name="program">Objeto a guardar</param>
/// <param name="lstAdd">LeadSources a asignar</param>
/// <param name="blnUpdate">True. Actualiza | False. inserta</param>
/// <returns>-1. Existe un registro con el mismo ID | 0. No se guardó | >0. Se guardó</returns>
/// <history>
/// [emoguel] created 26/05/2016
/// </history>
public async static Task <int> SaveProgram(Program program, List <LeadSource> lstAdd, bool blnUpdate)
{
int nRes = 0;
nRes = await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region MyRegion
if (blnUpdate)//Actualiza
{
dbContext.Entry(program).State = EntityState.Modified;
}
#endregion
#region Add
else
{
if (dbContext.Programs.Where(pg => pg.pgID == program.pgID).FirstOrDefault() != null)
{
return(-1);
}
else
{
dbContext.Programs.Add(program);
}
}
#endregion
#region LeadSource
dbContext.LeadSources.AsEnumerable().Where(ls => lstAdd.Any(lss => lss.lsID == ls.lsID)).ToList().ForEach(ls =>
{
ls.lspg = program.pgID;
});
#endregion
int nSave = dbContext.SaveChanges();
transacction.Commit();
return(nSave);
}
catch
{
transacction.Rollback();
return(0);
}
}
}
});
return(nRes);
}
/// <summary>
/// Guarda|Actualiza un registro en el catalogo LocationsCategories
/// Asigna|desasigna locations de loa¿cationscategories
/// </summary>
/// <param name="locationCategory">Objeto a guardar</param>
/// <param name="lstAdd">Locations a asignar</param>
/// <param name="lstDel">Locations a desasignar</param>
/// <param name="blnUpdate">True. Actualiza | False. Agrega</param>
/// <returns>-1. Existe un registro con el mismo ID | 0. No se guardó | >0. Se guardó correctamente</returns>
/// <history>
/// [emoguel] created 18/05/2016
/// [emoguel] modified 29/07/2016 se volvió async
/// </history>
public static async Task <int> SaveLocationCategories(LocationCategory locationCategory, List <Location> lstAdd, List <Location> lstDel, bool blnUpdate)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
if (blnUpdate)
{
dbContext.Entry(locationCategory).State = EntityState.Modified;
}
else
{
var locationVal = dbContext.LocationsCategories.Where(lc => lc.lcID == locationCategory.lcID).FirstOrDefault();
if (locationVal != null)
{
return -1;
}
else
{
dbContext.LocationsCategories.Add(locationCategory);
}
}
#region Locations
dbContext.Locations.AsEnumerable().Where(lo => lstAdd.Any(loo => loo.loID == lo.loID)).ToList().ForEach(lo =>
{//Agresignar locaciones
lo.lolc = locationCategory.lcID;
});
dbContext.Locations.AsEnumerable().Where(lo => lstDel.Any(loo => loo.loID == lo.loID)).ToList().ForEach(lo =>
{//Agresignar locaciones
lo.lolc = null;
});
#endregion
int nRes = dbContext.SaveChanges();
transacction.Commit();
return nRes;
}
catch
{
transacction.Rollback();
return 0;
}
}
}
}));
}
/// <summary>
/// Guarda|Actualiza un registro en el catalogo
/// </summary>
/// <param name="warehouse">Objeto a guardar</param>
/// <param name="blnUpdate">True. Actualiza | False. Inserta</param>
/// <returns>-1 Existe un registro con el mismo ID | 0. No se guardó | 1. Se guardó</returns>
/// <history>
/// [emoguel] created 22/04/2016
/// </history>
public static int SaveWarehouse(Warehouse warehouse, bool blnUpdate)
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
int nRes = 0;
#region Update
if (blnUpdate)
{
dbContext.Entry(warehouse).State = System.Data.Entity.EntityState.Modified;
return(dbContext.SaveChanges());
}
#endregion
#region Add
else
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
Warehouse warehouseVal = dbContext.Warehouses.Where(wh => wh.whID == warehouse.whID).FirstOrDefault();
if (warehouseVal != null)
{
return(-1);
}
else
{
dbContext.Warehouses.Add(warehouse);
if (dbContext.SaveChanges() > 0)
{
dbContext.USP_OR_AddAccessAdministrator("WH");
dbContext.SaveChanges();
nRes = 1;
transaction.Commit();
}
else
{
transaction.Rollback();
return(0);
}
}
}
catch
{
transaction.Rollback();
nRes = 0;
}
}
}
#endregion
return(nRes);
}
}
/// <summary>
/// Guarda los cambios de un Sale
/// </summary>
/// <param name="sale"></param>
/// <history>
/// [jorcanche] creted 28062016
/// </history>
public static async Task <int> SaveChangedSale(Sale sale)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
var personel = dbContext.Personnels.First();
sale.Personnel_LinerCaptain1 = personel;
dbContext.Entry(sale).State = System.Data.Entity.EntityState.Modified;
return dbContext.SaveChanges();
}
}));
}
/// <summary>
/// Agrega|Actualiza un membershipGroup
/// Asigna|Desasina una lista de membershiptype
/// </summary>
/// <param name="membershipGroup">Objeto a guardar</param>
/// <param name="lstAdd">lista a asignar</param>
/// <param name="blnUpdate">True. Actualiza | False. Inserta</param>
/// <returns>0. No se pudo guardar | >1. Se guardó correctamente | -1. Existe un registro con el mismo ID</returns>
/// <history>
/// [emoguel] created 19/05/2016
/// </history>
public async static Task <int> SaveMembershipGroup(MembershipGroup membershipGroup, List <MembershipType> lstAdd, bool blnUpdate)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transaccion = dbContext.Database.BeginTransaction(IsolationLevel.Serializable))
{
try
{
#region Update
if (blnUpdate)
{
dbContext.Entry(membershipGroup).State = System.Data.Entity.EntityState.Modified;
}
#endregion
#region Add
else
{
if (dbContext.MembershipsGroups.Where(mg => mg.mgID == membershipGroup.mgID).FirstOrDefault() != null)
{
return -1;
}
else
{
dbContext.MembershipsGroups.Add(membershipGroup);
}
}
#endregion
#region membership a asignar
dbContext.MembershipTypes.AsEnumerable().Where(mt => lstAdd.Any(mtt => mtt.mtID == mt.mtID)).ToList().ForEach(mt =>
{
mt.mtGroup = membershipGroup.mgID;
});
#endregion
int nRes = 0;
nRes = dbContext.SaveChanges();
transaccion.Commit();
return nRes;
}
catch
{
transaccion.Rollback();
return 0;
}
}
}
}));
}
/// <summary>
/// Agrega|Actualiza folios outhousePR y outhousecancellation
/// </summary>
/// <param name="idPr">id Del PR</param>
/// <param name="lstAsigned">Lista de asignados</param>
/// <param name="lstCancel">Lista de cancelados</param>
/// <returns>0. No se guardó | >0. Se guardó correctamente</returns>
/// <history>
/// [emoguel] created 09/05/2016
/// </history>
public async static Task <int> SaveFoliosOuthousePR(string idPr, List <FolioInvitationOuthousePR> lstAsigned, List <FolioInvitationOuthousePRCancellation> lstCancel)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transaction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region Assigados
lstAsigned.ForEach(f =>
{
f.fippe = idPr;
dbContext.Entry(f).State = (f.fipID > 0) ? EntityState.Modified : EntityState.Added;
});
#endregion
#region Cancel
lstCancel.ForEach(f =>
{
f.ficpe = idPr;
dbContext.Entry(f).State = (f.ficID > 0) ? EntityState.Modified : EntityState.Added;
});
#endregion
int nRes = dbContext.SaveChanges();
transaction.Commit();
return nRes;
}
catch
{
transaction.Rollback();
return 0;
}
}
}
}));
}
/// <summary>
/// Guarda un nuevo Gift Receipt y retorna el ID asignado
/// </summary>
/// <param name="giftReceipt"></param>
/// <returns></returns>
/// <history>
/// [vipacheco] 2/Mayo/2016 Created
/// [vipacheco] 07/Julio/2016 Modified --> Se agregó asincronia
/// [vipacheco] 05/Agosto/2016 Modified --> Se agregó estandarizacion del return
/// </history>
public async static Task <int> SaveGiftReceipt(GiftsReceipt giftReceipt)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
// Guardamos el Gift Receipt Nuevo
dbContext.Entry(giftReceipt).State = System.Data.Entity.EntityState.Added;
dbContext.SaveChanges();
return giftReceipt.grID; // Obtenemos el ID del nuevo Gift Receipt
}
}));
}
/// <summary>
/// Agrega|Actualiza un registro en el catalogo market
/// Asigna|Desasigna agencies al market
/// </summary>
/// <param name="market">Objeto a guardar</param>
/// <param name="lstAdd">Agencias a asignar</param>
/// <param name="lstDel">Agencias a desasignar</param>
/// <param name="blnUpdate">True. Actualiza | False. Inserta</param>
/// <returns></returns>
/// <history>
/// [emoguel] modified 29/07/2016-->Se volvió async
/// </history>
public static async Task <int> SaveMarket(Market market, List <Agency> lstAdd, bool blnUpdate)
{
return(await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
#region UpdateMarket
if (blnUpdate)
{
dbContext.Entry(market).State = EntityState.Modified;
}
#endregion
#region Add market
else
{
if (dbContext.Markets.Where(mk => mk.mkID == market.mkID).FirstOrDefault() != null)
{
return -1;
}
else
{
dbContext.Markets.Add(market);
}
}
#endregion
#region Agencies
//Add markets
dbContext.Agencies.AsEnumerable().Where(ag => lstAdd.Any(agg => agg.agID == ag.agID)).ToList().ForEach(ag =>
{
ag.agmk = market.mkID;
});
#endregion
int nRes = dbContext.SaveChanges();
transacction.Commit();
return nRes;
}
catch
{
transacction.Rollback();
return 0;
}
}
}
}));
}
/// <summary>
/// Cambia el password del usuario.
/// </summary>
/// <param name="user">UserName</param>
/// <param name="newPassword">New Password</param>
/// <param name="serverDate">Server Date</param>
/// <returns>bool</returns>
/// <history>
/// [edgrodriguez] 03/Mar/2016 Created
/// [edgrodriguez] 22/Mar/2016 Modified. Se agregó el dbContext.Entry. Ya que el usuario
/// lo obtiene desde otro método.
/// </history>
public static bool ChangePassword(string user, string newPassword, DateTime serverDate)
{
int result;
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
Personnel personnel = GetPersonnelById(user);
personnel.pePwd = newPassword;
personnel.pePwdD = serverDate.Date;
dbContext.Entry(personnel).State = System.Data.Entity.EntityState.Modified;
result = dbContext.SaveChanges();
}
return(Convert.ToBoolean(result));
}
/// <summary>
/// Agrega Folios CxCPR y FolioCxCCancellation
/// </summary>
/// <param name="personnel"></param>
/// <param name="lstFoliosCxCPR"></param>
/// <param name="lstFoliosCancell"></param>
/// <returns>0. No se guardó | >0. Se guardó correctamente</returns>
/// <history>
/// [emoguel] created 07/05/2016
/// [emoguel] modified 09/06/2016 -->Se volvió async
/// </history>
public async static Task <int> SaveFoliosCxCByPR(PersonnelShort personnel, List <FolioCxCPR> lstFoliosCxCPR, List <FolioCxCCancellation> lstFoliosCancell)
{
int nRes = await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
lstFoliosCxCPR.ForEach(fcp =>
{
fcp.fcppe = personnel.peID;
dbContext.Entry(fcp).State = (fcp.fcpID > 0) ? EntityState.Modified : EntityState.Added;
});
lstFoliosCancell.ForEach(fcc =>
{
fcc.fccpe = personnel.peID;
dbContext.Entry(fcc).State = (fcc.fccID > 0) ? EntityState.Modified : EntityState.Added;
});
int nSave = dbContext.SaveChanges();
transacction.Commit();
return(nSave);
}
catch
{
transacction.Rollback();
return(0);
}
}
}
});
return(nRes);
}
public void UpdateUsername(User ToChange)
{
using (IMEntities context = new IMEntities())
{
Console.Clear();
Console.Write("\n\n\n\n\tNew Username: "******"Username updated Succesfully \n Press any key to continue");
Console.ReadKey();
}
}
public void UpdatePassword(User ToChange)
{
using (var context = new IMEntities())
{
Console.Clear();
Console.Write("\n\n\n\n\tNew Password: "******"Password Updated Succesfully \n Press any key to continue");
Console.ReadKey();
}
}
public void UpdateRole(User ToChange)
{
using (var context = new IMEntities())
{
Console.WriteLine("\n\n\n\n\tNew Role: ");
User WithnewRole = context.Users.Single(ThisUser => ThisUser.Id == ToChange.Id);
WithnewRole.Role = (UserAccess)ConsoleMenu.GetUserChoice(new List <string> {
"Super Admin", "Moderator", "User"
}).IndexOfChoice;
context.Entry(WithnewRole).State = EntityState.Modified;
context.SaveChanges();
Console.WriteLine($"New User Role is: {WithnewRole.Role}");
Console.WriteLine("Role Updated Succesfully \n Press any key to continue");
Console.ReadKey();
}
}