public List <Models.DocType> GetDocsType(string idItemGroup)
{
try
{
using (var db = new HKSupplyContext())
{
return(db.DocsType.Where(a => a.IdItemGroup.Equals(idItemGroup)).ToList());
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
/// <summary>
/// Modificar una funcionalidad
/// </summary>
/// <param name="modFunctionality"></param>
/// <returns>Objeto Functionality con la funcioliadad modificada</returns>
/// <remarks>
/// Modifica los campos:
/// - Category
/// - FormName
/// </remarks>
public Functionality ModifyFunctionality(Functionality modFunctionality)
{
try
{
if (modFunctionality == null)
{
throw new ArgumentNullException();
}
using (var db = new HKSupplyContext())
{
var functionality = db.Functionalities.FirstOrDefault(f => f.FunctionalityId.Equals(modFunctionality.FunctionalityId));
if (functionality == null)
{
throw new NonexistentFunctionalityException(GlobalSetting.ResManager.GetString("NoFunctionalityExist"));
}
functionality.Category = modFunctionality.Category;
functionality.FormName = modFunctionality.FormName;
db.SaveChanges();
return(functionality);
}
}
catch (ArgumentNullException anex)
{
_log.Error(anex.Message, anex);
throw anex;
}
catch (NonexistentFunctionalityException nefex)
{
_log.Error(nefex.Message, nefex);
throw nefex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public List <FamilyHK> GetFamiliesHK()
{
try
{
using (var db = new HKSupplyContext())
{
return(db.FamiliesHK.ToList());
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
/// <summary>
/// Obtener un usuario dado su id
/// </summary>
/// <param name="userId"></param>
/// <returns></returns>
public User GetUserById(int userId)
{
try
{
if (userId == 0)
{
throw new ArgumentNullException("userId");
}
using (var db = new HKSupplyContext())
{
var user = db.Users
.Include(r => r.UserRole)
.Where(u => u.Id.Equals(userId))
.FirstOrDefault();
if (user == null)
{
throw new NonexistentUserException(GlobalSetting.ResManager.GetString("InvalidUser"));
}
return(user);
}
}
catch (ArgumentNullException anex)
{
_log.Error(anex.Message, anex);
throw anex;
}
catch (NonexistentUserException neuex)
{
_log.Info(neuex.Message, neuex);
throw neuex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public void GetFunctionalitiesRole()
{
try
{
var functionalities = GlobalSetting.FunctionalityRoleService.GetFunctionalitiesRole(null); //ArgumentNullException
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
try
{
using (var db = new HKSupplyContext())
{
var expectedValue = db.FunctionalitiesRole.Where(f => f.RoleId.Equals("ADMIN")).ToList();
var functionalities = GlobalSetting.FunctionalityRoleService.GetFunctionalitiesRole("ADMIN"); //ok
Assert.IsTrue(expectedValue.Count() == functionalities.Count());
}
}
catch (Exception)
{
throw;
}
}
public void GetFunctionalitiesCategoriesRole()
{
try
{
var functionalities = GlobalSetting.FunctionalityRoleService.GetFunctionalitiesCategoriesRole(null); //ArgumentNullException
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
try
{
using (var db = new HKSupplyContext())
{
var functionalities = GlobalSetting.FunctionalityRoleService.GetFunctionalitiesCategoriesRole("ADMIN"); //ok
Assert.IsTrue(true);
}
}
catch (Exception)
{
throw;
}
}
public FamilyHK GetFamilyHKById(string idFamilyHk)
{
try
{
if (idFamilyHk == null)
{
throw new ArgumentNullException("idFamilyHk");
}
using (var db = new HKSupplyContext())
{
var familyHk = db.FamiliesHK.FirstOrDefault(a => a.IdFamilyHk.Equals(idFamilyHk));
if (familyHk == null)
{
//throw new NonexistentRoleException(GlobalSetting.ResManager.GetString("NoRoleExist"));
throw new Exception("No family HK Exist");
}
return(familyHk);
}
}
catch (ArgumentNullException nrex)
{
_log.Error(nrex.Message, nrex);
throw nrex;
}
catch (NonexistentRoleException nerex)
{
_log.Error(nerex.Message, nerex);
throw nerex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
/// <summary>
/// Obtener un rol dado su Id
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public Role GetRoleById(string roleId)
{
try
{
if (roleId == null)
{
//throw new ArgumentNullException(nameof(rolId)); //No existe el nameof hasta c# 6 y VS2015
throw new ArgumentNullException("roleId");
}
using (var db = new HKSupplyContext())
{
var role = db.Roles.FirstOrDefault(r => r.RoleId.Equals(roleId));
if (role == null)
{
throw new NonexistentRoleException(GlobalSetting.ResManager.GetString("NoRoleExist"));
}
return(role);
}
}
catch (ArgumentNullException nrex)
{
_log.Error(nrex.Message, nrex);
throw nrex;
}
catch (NonexistentRoleException nerex)
{
_log.Error(nerex.Message, nerex);
throw nerex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public Models.Store GetStoreById(string idStore)
{
try
{
if (idStore == null)
{
throw new ArgumentNullException("idStore");
}
using (var db = new HKSupplyContext())
{
var store = db.Stores.FirstOrDefault(s => s.IdStore.Equals(idStore));
if (store == null)
{
throw new NonexistentStoreException(GlobalSetting.ResManager.GetString("NoStoreExist"));
}
return(store);
}
}
catch (ArgumentNullException nrex)
{
_log.Error(nrex.Message, nrex);
throw nrex;
}
catch (NonexistentRoleException nerex)
{
_log.Error(nerex.Message, nerex);
throw nerex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public void NewUser()
{
try
{
GlobalSetting.UserService.NewUser(null);
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
catch (Exception)
{
throw;
}
try
{
using (var db = new HKSupplyContext())
{
var user = db.Users.FirstOrDefault(u => u.UserLogin.Equals("admin"));
GlobalSetting.UserService.NewUser(user); //NewExistingUserException
Assert.Fail("Expected exception");
}
}
catch (NewExistingUserException)
{
Assert.IsTrue(true);
}
catch (Exception)
{
throw;
}
try
{
var newuser = new User
{
UserLogin = "******",
Name = "Test User",
Password = PasswordHelper.GetHash("usutestpwd"),
RoleId = "OPERATOR",
Enabled = true,
LastLogout = null,
Remarks = "Test user remarks"
};
var user = GlobalSetting.UserService.NewUser(newuser);
Assert.AreEqual(true, user.Equals(newuser));
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Obtener la colección de todos las cartegorías de un rol en concreto
/// </summary>
/// <param name="roleId"></param>
/// <returns></returns>
public IEnumerable <string> GetFunctionalitiesCategoriesRole(string roleId)
{
try
{
if (roleId == null)
{
throw new ArgumentNullException("roleId");
}
using (var db = new HKSupplyContext())
{
var categories = db.FunctionalitiesRole
.Join(
db.Functionalities,
fr => fr.FunctionalityId,
f => f.FunctionalityId,
(fr, f) => new { FunctionalitiesRole = fr, Functionalities = f })
.Select(f => f.Functionalities.Category)
.Distinct()
.ToList();
return(categories);
}
}
catch (ArgumentNullException anex)
{
_log.Error(anex.Message, anex);
throw anex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public ItemMt GetItem(string idItemBcn)
{
try
{
if (idItemBcn == null)
{
throw new ArgumentNullException("idItemBcn");
}
using (var db = new HKSupplyContext())
{
var item = db.ItemsMt
.Where(i => i.IdItemBcn.Equals(idItemBcn))
.Include(i => i.Model)
.Include(i => i.Prototype)
.Include(i => i.FamilyHK)
.Include(i => i.StatusCial)
.Include(i => i.StatusProd)
.SingleOrDefault();
return(item);
}
}
catch (ArgumentNullException anex)
{
_log.Error(anex.Message, anex);
throw anex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public IEnumerable <FunctionalityRole> GetFunctionalitiesRole(string roleId)
{
try
{
if (roleId == null)
{
throw new ArgumentNullException("roleId");
}
using (var db = new HKSupplyContext())
{
var functionalitiesList = db.FunctionalitiesRole
.Include(r => r.Role)
.Include(f => f.Functionality)
.Where(fr => fr.RoleId.Equals(roleId) && fr.Role.Enabled.Equals(true))
.OrderBy(a => a.Functionality.FunctionalityName)
.ToList();
return(functionalitiesList);
}
}
catch (ArgumentNullException anex)
{
_log.Error(anex.Message, anex);
throw anex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public SupplierPriceList GetSupplierPriceList(string idItemBcn, string idSupplier)
{
try
{
if (string.IsNullOrEmpty(idItemBcn))
{
throw new ArgumentNullException("idItemBcn");
}
if (string.IsNullOrEmpty(idSupplier))
{
throw new ArgumentNullException("idSupplier");
}
using (var db = new HKSupplyContext())
{
var supplierPriceList = db.SuppliersPriceList.Where(s => s.IdItemBcn.Equals(idItemBcn) && s.IdSupplier.Equals(idSupplier)).SingleOrDefault();
return(supplierPriceList);
}
}
catch (ArgumentNullException anex)
{
_log.Error(anex.Message, anex);
throw anex;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public void ModifyFunctionalityRole()
{
try
{
var func = GlobalSetting.FunctionalityRoleService.ModifyFunctionalityRole(null);
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
try
{
var fr = new FunctionalityRole
{
RoleId = "XXXXXX",
FunctionalityId = 1,
Read = false,
New = false,
Modify = false,
};
var func = GlobalSetting.FunctionalityRoleService.ModifyFunctionalityRole(fr);
Assert.Fail("Expected exception");
}
catch (NonexistentFunctionalityRoleException)
{
Assert.IsTrue(true);
}
try
{
using (var db = new HKSupplyContext())
{
var funcMatManagement = GlobalSetting.FunctionalityService.GetFunctionalityByName("Materials Management");
var fr = GlobalSetting.FunctionalityRoleService.GetFunctionalityRole(funcMatManagement.FunctionalityId, "OPERATOR");
fr.Read = true;
fr.New = false;
fr.Modify = true;
var func = GlobalSetting.FunctionalityRoleService.ModifyFunctionalityRole(fr); //OK
Assert.AreEqual(true, func.Equals(fr));
}
}
catch (Exception ex)
{
throw ex;
}
}
public List <SupplierPriceList> GetSuppliersPriceList(string idItemBcn = null, string idSupplier = null)
{
try
{
using (var db = new HKSupplyContext())
{
if (idItemBcn != null && idSupplier != null)
{
return(db.SuppliersPriceList.Where(a => a.IdItemBcn.Equals(idItemBcn) && a.IdSupplier.Equals(idSupplier)).ToList());
}
else if (idItemBcn != null && idSupplier == null)
{
return(db.SuppliersPriceList.Where(a => a.IdItemBcn.Equals(idItemBcn)).ToList());
}
else if (idItemBcn == null && idSupplier != null)
{
return(db.SuppliersPriceList.Where(a => a.IdSupplier.Equals(idSupplier)).ToList());
}
else
{
return(db.SuppliersPriceList.ToList());
}
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public void NewFunctionalityRole()
{
try
{
var functionalityRole = GlobalSetting.FunctionalityRoleService.NewFunctionalityRole(null); //ArgumentNullException
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
try
{
var existing = GlobalSetting.FunctionalityRoleService.GetFunctionalityRole(1, "ADMIN");
var functionalityRole = GlobalSetting.FunctionalityRoleService.NewFunctionalityRole(existing); //NewExistingFunctionalityRoleException
Assert.Fail("Expected exception");
}
catch (NewExistingFunctionalityRoleException)
{
Assert.IsTrue(true);
}
try
{
using (var db = new HKSupplyContext())
{
var opRole = db.Roles.FirstOrDefault(r => r.RoleId.Equals("OPERATOR"));
var funcUserManagement = db.Functionalities.FirstOrDefault(f => f.FunctionalityName.Equals("UserManagement"));
var fr = new FunctionalityRole
{
RoleId = opRole.RoleId,
FunctionalityId = funcUserManagement.FunctionalityId,
Read = false,
New = false,
Modify = false,
};
var functionalityRole = GlobalSetting.FunctionalityRoleService.NewFunctionalityRole(fr);
Assert.AreEqual(true, functionalityRole.Equals(fr));
}
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Obtener la colección de usuarios del sistema
/// </summary>
/// <returns></returns>
public IEnumerable <User> GetAllUsers()
{
try
{
using (var db = new HKSupplyContext())
{
return(db.Users.Include(r => r.UserRole).ToList());
}
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public List <CustomerPriceListHistory> GetCustomerPriceListHistory(string idItemBcn, string idCustomer)
{
if (idItemBcn == null)
{
throw new ArgumentNullException("idItemBcn");
}
if (idCustomer == null)
{
throw new ArgumentNullException("idCustomer");
}
try
{
using (var db = new HKSupplyContext())
{
return(db.CustomersPriceListHistory
.Where(a => a.IdItemBcn.Equals(idItemBcn) && a.IdCustomer.Equals(idCustomer))
.OrderBy(b => b.Timestamp)
.ToList());
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public List <PrototypeDoc> GetLastPrototypeDocs(string idPrototype)
{
try
{
using (var db = new HKSupplyContext())
{
//TODO: intentar unificar esto en una sola consulta
var idDocs = db.PrototypesDocs
.Where(a => a.IdPrototype.Equals(idPrototype))
.GroupBy(a => a.IdDocType)
.Select(i => i.Max(a => a.IdDoc))
.ToList();
var docs = db.PrototypesDocs
.Where(a => idDocs.Contains(a.IdDoc))
.Include(b => b.DocType)
.ToList();
return(docs);
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
/// <summary>
/// Obtener un FunctionalityRole dado una funciolidad y un rol
/// </summary>
/// <param name="functionalityId"></param>
/// <param name="roleId"></param>
/// <returns></returns>
public FunctionalityRole GetFunctionalityRole(int functionalityId, string roleId)
{
try
{
if (functionalityId == 0)
{
throw new ArgumentNullException("functionalityId");
}
if (roleId == null)
{
throw new ArgumentNullException("roleId");
}
using (var db = new HKSupplyContext())
{
var functionalityRole = db.FunctionalitiesRole
.Include(r => r.Role)
.Include(f => f.Functionality)
.Where(fr => fr.FunctionalityId.Equals(functionalityId) && fr.RoleId.Equals(roleId) && fr.Role.Enabled.Equals(true))
.FirstOrDefault();
if (functionalityRole == null)
{
throw new NonexistentFunctionalityRoleException();
}
return(functionalityRole);
}
}
catch (ArgumentNullException anex)
{
_log.Error(anex.Message, anex);
throw anex;
}
catch (NonexistentFunctionalityRoleException nfrex)
{
_log.Error(nfrex.Message, nfrex);
throw nfrex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public void GetFunctionalityRole()
{
try
{
var functionalityRole = GlobalSetting.FunctionalityRoleService.GetFunctionalityRole(0, "XX"); //ArgumentNullException
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
try
{
var functionalityRole = GlobalSetting.FunctionalityRoleService.GetFunctionalityRole(1, null); //ArgumentNullException
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
try
{
var functionalityRole = GlobalSetting.FunctionalityRoleService.GetFunctionalityRole(1, "XX"); //NonexistentFunctionalityRoleException
Assert.Fail("Expected exception");
}
catch (NonexistentFunctionalityRoleException)
{
Assert.IsTrue(true);
}
try
{
using (var db = new HKSupplyContext())
{
var expectedValue = db.FunctionalitiesRole.FirstOrDefault(f => f.FunctionalityId.Equals(1) && f.RoleId.Equals("ADMIN"));
var functionalityRole = GlobalSetting.FunctionalityRoleService.GetFunctionalityRole(expectedValue.FunctionalityId, expectedValue.RoleId); //OK
Assert.AreEqual(true, functionalityRole.Equals(expectedValue));
}
}
catch (Exception)
{
throw;
}
}
public void GetRole()
{
try
{
var rol = GlobalSetting.RoleService.GetRoleById(null); //ArgumentNullException
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
catch (Exception)
{
throw;
}
try
{
var rol = GlobalSetting.RoleService.GetRoleById("XXXXXXXX"); //NonexistentRoleException
Assert.Fail("Expected exception");
}
catch (NonexistentRoleException)
{
Assert.IsTrue(true);
}
catch (Exception)
{
throw;
}
try
{
using (var db = new HKSupplyContext())
{
var expectedValue = db.Roles.FirstOrDefault(r => r.RoleId.Equals("ADMIN"));
var rol = GlobalSetting.RoleService.GetRoleById("ADMIN");
Assert.AreEqual(true, rol.Equals(expectedValue));
}
}
catch (Exception)
{
throw;
}
}
public void NewFunctionality()
{
try
{
var functionality = GlobalSetting.FunctionalityService.NewFunctionality(null); //ArgumentNullException
Assert.Fail("Expected exception");
}
catch (ArgumentNullException)
{
Assert.IsTrue(true);
}
try
{
var functionality = GlobalSetting.FunctionalityService.GetFunctionalityById(1);
var newFunc = GlobalSetting.FunctionalityService.NewFunctionality(functionality); //NewExistingFunctionalityException
Assert.Fail("Expected exception");
}
catch (NewExistingFunctionalityException)
{
Assert.IsTrue(true);
}
try
{
using (var db = new HKSupplyContext())
{
var func = new Functionality
{
FunctionalityName = "TestFunctionality",
Category = "TEST",
FormName = "frmTest"
};
var newFunc = GlobalSetting.FunctionalityService.NewFunctionality(func); //ok
Assert.AreEqual(true, newFunc.Equals(func));
}
}
catch (Exception ex)
{
throw ex;
}
}
public List <ItemEy> GetItems()
{
try
{
using (var db = new HKSupplyContext())
{
return(db.ItemsEy
.Include(i => i.Model)
.Include(i => i.Prototype)
.Include(i => i.FamilyHK)
.Include(i => i.StatusCial)
.Include(i => i.StatusProd)
.OrderBy(i => i.IdItemBcn)
.ToList());
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
/// <summary>
/// Obtener la colección de roles del sistema.
/// </summary>
/// <param name="all">Para indicar si se quieren todos o sólo los activos</param>
/// <returns></returns>
public IEnumerable <Role> GetRoles(bool all = true)
{
try
{
using (var db = new HKSupplyContext())
{
if (all)
{
return(db.Roles.ToList());
}
else
{
return(db.Roles.Where(r => r.Enabled.Equals(true)).ToList());
}
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
/// <summary>
/// Obtener todas las funcionalidades-roles de la base de datos
/// </summary>
/// <returns></returns>
public IEnumerable <FunctionalityRole> GetAllFunctionalitiesRole()
{
try
{
using (var db = new HKSupplyContext())
{
var functionalitiesList = db.FunctionalitiesRole
.Include(r => r.Role)
.Include(f => f.Functionality)
.ToList();
return(functionalitiesList);
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
public List <PrototypeDoc> GetPrototypeDocs(string idPrototype)
{
try
{
using (var db = new HKSupplyContext())
{
return(db.PrototypesDocs
.Where(a => a.IdPrototype.Equals(idPrototype))
.Include(b => b.DocType)
.OrderBy(c => c.CreateDate)
.ToList());
}
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
/// <summary>
/// Modificar una colección de FunctionalityRole
/// </summary>
/// <param name="functionalitiesRolesToUpdate"></param>
/// <returns></returns>
public bool UpdateFunctionalitiesRoles(IEnumerable <FunctionalityRole> functionalitiesRolesToUpdate)
{
try
{
if (functionalitiesRolesToUpdate == null)
{
throw new ArgumentNullException("functionalitiesRolesToUpdate");
}
using (var db = new HKSupplyContext())
{
using (var dbTran = db.Database.BeginTransaction())
{
try
{
foreach (var funcRole in functionalitiesRolesToUpdate)
{
var funcRoleToUpdate = db.FunctionalitiesRole.FirstOrDefault(fr => fr.FunctionalityId.Equals(funcRole.FunctionalityId) &&
fr.RoleId.Equals(funcRole.RoleId));
if (funcRoleToUpdate != null)
{
funcRoleToUpdate.Read = funcRole.Read;
funcRoleToUpdate.New = funcRole.New;
funcRoleToUpdate.Modify = funcRole.Modify;
}
}
db.SaveChanges();
dbTran.Commit();
return(true);
}
catch (SqlException sqlex)
{
dbTran.Rollback();
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (DbEntityValidationException e)
{
dbTran.Rollback();
_log.Error(e.Message, e);
throw e;
}
catch (Exception ex)
{
dbTran.Rollback();
_log.Error(ex.Message, ex);
throw ex;
}
}
}
}
catch (ArgumentNullException nrex)
{
_log.Error(nrex.Message, nrex);
throw nrex;
}
}
/// <summary>
/// Modificar un FunctionalityRole
/// </summary>
/// <param name="modFunctionalityRole"></param>
/// <returns></returns>
/// <remarks>
/// Los campos que se actualizan son los siguientes:
/// - Read
/// - New
/// - Modify
/// </remarks>
public FunctionalityRole ModifyFunctionalityRole(FunctionalityRole modFunctionalityRole)
{
try
{
if (modFunctionalityRole == null)
{
throw new ArgumentNullException("modFunctionalityRole");
}
using (var db = new HKSupplyContext())
{
var functionalityRole = db.FunctionalitiesRole
.Where(fr => fr.FunctionalityId.Equals(modFunctionalityRole.FunctionalityId) && fr.RoleId.Equals(modFunctionalityRole.RoleId))
.FirstOrDefault();
if (functionalityRole == null)
{
throw new NonexistentFunctionalityRoleException(GlobalSetting.ResManager.GetString("NoFunctionalityRoleExist"));
}
functionalityRole.Read = modFunctionalityRole.Read;
functionalityRole.New = modFunctionalityRole.New;
functionalityRole.Modify = modFunctionalityRole.Modify;
db.SaveChanges();
return(GetFunctionalityRole(modFunctionalityRole.FunctionalityId, modFunctionalityRole.RoleId));
//return db.FunctionalitiesRole
// .Where(fr => fr.FunctionalityId.Equals(modFunctionalityRole.FunctionalityId) && fr.RoleId.Equals(modFunctionalityRole.RoleId))
// .FirstOrDefault();
}
}
catch (ArgumentNullException anex)
{
_log.Error(anex.Message, anex);
throw anex;
}
catch (NonexistentFunctionalityRoleException nfre)
{
_log.Error(nfre.Message, nfre);
throw nfre;
}
catch (SqlException sqlex)
{
for (int i = 0; i < sqlex.Errors.Count; i++)
{
_log.Error("Index #" + i + "\n" +
"Message: " + sqlex.Errors[i].Message + "\n" +
"Error Number: " + sqlex.Errors[i].Number + "\n" +
"LineNumber: " + sqlex.Errors[i].LineNumber + "\n" +
"Source: " + sqlex.Errors[i].Source + "\n" +
"Procedure: " + sqlex.Errors[i].Procedure + "\n");
switch (sqlex.Errors[i].Number)
{
case -1: //connection broken
case -2: //timeout
throw new DBServerConnectionException(GlobalSetting.ResManager.GetString("DBServerConnectionError"));
}
}
throw sqlex;
}
catch (DbEntityValidationException e)
{
_log.Error(e.Message, e);
throw e;
}
catch (Exception ex)
{
_log.Error(ex.Message, ex);
throw ex;
}
}
