public void DeleteMessage(MenuManager menu)
{
List <string> DeleteMenuOptions = new List <string>
{
"Delete All",
"Delete From Recieved",
"Delete From Sent",
};
int option = ConsoleMenu.GetUserChoice(DeleteMenuOptions, DesignedStrings.DeleteMsg).IndexOfChoice;
using (var context = new IMEntities())
{
if (option > 0)
{
Message ToDelete = menu.ShowMessages(option > 1);
context.Messages.Attach(ToDelete);
context.Messages.Remove(ToDelete);
context.SaveChanges();
}
else
{
Console.WriteLine("\n\n\tWARNING!!!\n\n\tAre you sure you would like to delete EVERYTHING???");
Console.ReadKey();
context.Messages.RemoveRange(context.Messages
.Where(msg => msg.SenderId == LoggedIn.Id || msg.RecieverId == LoggedIn.Id));
context.SaveChanges();
}
}
}
/// <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);
}
}
public void RegisterUser()
{
Console.Clear();
Console.WriteLine(DesignedStrings.CreateUsr);
Console.WriteLine("\nRegister user");
Console.WriteLine("-------------");
Console.Write("\nEnter username:"******"Enter password:"******"admin" && password == "admin1")
{
var checkUser = context.Users.SingleOrDefault(c => c.Username == username);
if (checkUser == null)
{
User ToRegister = new User
{
Username = username,
Password = password,
Role = UserAccess.SuperAdministrator,
RegisterDate = DateTime.Now,
IsUserActive = true
};
context.Users.Add(ToRegister);
context.SaveChanges();
}
}
else
{
User ToRegister = new User
{
Username = username,
Password = password,
Role = UserAccess.User,
RegisterDate = DateTime.Now,
IsUserActive = true
};
context.Users.Add(ToRegister);
context.SaveChanges();
Console.WriteLine("Registration Successful!");
CreatingLogs.LogUser(ToRegister);
Console.ReadLine();
}
}
}
/// <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>
/// 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>
/// 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>
/// 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 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 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>
/// Actualiza el orden de los registros de segmentByAgency y SegmentByLeadSource
/// </summary>
/// <param name="lstAgency">Lista de segmentByAgency</param>
/// <param name="lstLeadSource">Lista de LeadSource</param>
/// <returns>0. No se guardó | >0. Se guardó correctamente</returns>
/// <history>
/// [emoguel] created 01/06/2016
/// </history>
public async static Task <int> SaveSegmentsOrder(List <Item> lstAgency, List <Item> lstLeadSource)
{
int nRes = await Task.Run(() => {
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
lstAgency.ForEach(it => {
var segmentA = dbContext.SegmentsByAgencies.Where(se => se.seID == it.UserId).FirstOrDefault();
segmentA.seO = Convert.ToInt32(it.Id);
});
lstLeadSource.ForEach(it =>
{
var segmentLS = dbContext.SegmentsByLeadSources.Where(so => so.soID == it.UserId).FirstOrDefault();
segmentLS.soO = Convert.ToInt32(it.Id);
});
int nSave = dbContext.SaveChanges();
transacction.Commit();
return(nSave);
}
catch
{
transacction.Rollback();
return(0);
}
}
}
});
return(nRes);
}
public void MessageSend(User Sender)
{
User Receiver;
do
{
Receiver = SelectUser();
}while (Receiver is null);
Console.WriteLine(DesignedStrings.Messagestring + "\nPlease write the subject of your Message :");
string Subject = IC.InputSubject();
Console.WriteLine("What you wanna send");
Message ToSend = new Message
{
SenderId = Sender.Id,
RecieverId = Receiver.Id,
Subject = Subject,
Data = IC.InputMessage(),
Date = DateTime.Now
};
using (var context = new IMEntities())
{
context.Messages.Add(ToSend);
context.SaveChanges();
}
Console.WriteLine("Message sent! Press any key to continue");
CreatingLogs.LogMessage(ToSend);
Console.ReadKey();
}
/// <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>
/// 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>
/// Elimina Personnels de la BD
/// </summary>
/// <param name="lstPersonnels"></param>
/// <returns>0. No se pudo eliminar | >0. Se eliminarion correctamente</returns>
/// <history>
/// [emoguel] created 14/06/2016
/// </history>
public static async Task <int> DeletePersonnels(List <PersonnelShort> lstPersonnels)
{
int nRes = await Task.Run(() =>
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
using (var transacction = dbContext.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
dbContext.Database.CommandTimeout = Settings.Default.USP_OR_DeletePersonnel;
lstPersonnels.ForEach(pe =>
{
dbContext.USP_OR_DeletePersonnel(pe.peID);
});
int nSave = dbContext.SaveChanges();
transacction.Commit();
return(1);
}
catch
{
transacction.Rollback();
throw;
}
}
}
});
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;
}
}
}
}));
}
public void DeleteUser(int id)
{
Console.WriteLine(DesignedStrings.DeleteUsr);
List <User> UsersList = DB.GetAllUsers();
UserChoice Choice = ConsoleMenu.GetUserChoice(UsersList.Select(usr => usr.Username).ToList(), "Choose the right User for you ");
string usernameForDelete;
//Console.WriteLine("Choose the username of the user you would like to delete:");
usernameForDelete = Console.ReadLine();
if (usernameForDelete is null)
{
return;
}
if (!DoesUsernameExist(usernameForDelete)) // Check if username already exists in database
{
Console.WriteLine("We are so sorry but the username you entered does not exist.\nPlease choose another user to delete.");
Console.ReadKey();
}
else
{
User ToBeDeleted = FindUserViaUsername(usernameForDelete);
if (ToBeDeleted.Role == UserAccess.SuperAdministrator)
{
Console.WriteLine("\n\nPress any key to go back to Super Admin Menu.");
Console.ReadKey();
return;
}
bool userActive = IsUserActive(usernameForDelete);
if (!userActive)
{
Console.WriteLine($"\nThe user with username '{usernameForDelete}' is no longer active.");
Console.WriteLine("\n\nPress any key to go back to Menu.");
Console.ReadKey();
}
else
{
using (var context = new IMEntities())
{
User ToDelete = context.Users.FirstOrDefault(usr => usr.Id == ToBeDeleted.Id);
context.Users.Remove(ToDelete);
context.SaveChanges();
}
Console.WriteLine($"\nUser '{usernameForDelete}' is no longer active .");
Console.WriteLine("\n\nPress any key to go back to Menu.");
Console.ReadKey();
}
}
}
public void AddUser(string username, string password, UserAccess Role = UserAccess.User)
{
using (var context = new IMEntities())
{
Console.Clear();
Console.WriteLine(DesignedStrings.CreateUsr);
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.DarkGreen;
Console.WriteLine("Creating new user profile.....Please wait...");
context.Users.Add(new User
{
Username = username,
Password = password,
Role = UserAccess.User,
RegisterDate = DateTime.Now,
IsUserActive = true
});
context.SaveChanges();
Console.ReadLine();
Console.WriteLine($"\nNew user profile with username '{username}' has been created!");
Console.WriteLine($"\n Press any key to continue");
Console.ReadKey();
Console.ResetColor();
}
}
/// <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 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 agrega un nuevo Meal Ticket
/// </summary>
/// <param name="pMealTicket"></param>
/// <history>
/// [vipacheco] 01/04/2016 Created
/// </history>
public static void InsertNewMealTicket(MealTicket pMealTicket)
{
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
dbContext.MealTickets.Add(pMealTicket);
dbContext.SaveChanges();
}
}
/// <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>
/// Método para guardar nuevos movimientos en un almacén.
/// </summary>
/// <param name="lstWhsMovs">Lista de movimientos para agregar.</param>
/// <history>
/// [edgrodriguez] 22/Feb/2016 Created
/// </history>
public static void SaveWarehouseMovements(ref List <WarehouseMovement> lstWhsMovs)
{
IEnumerable <WarehouseMovement> lstResult;
using (var dbContext = new IMEntities(ConnectionHelper.ConnectionString()))
{
lstResult = dbContext.WarehouseMovements.AddRange(lstWhsMovs);
dbContext.SaveChanges();
}
lstWhsMovs = lstResult.ToList();
}
/// <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 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;
}
}
}
}));
}