public bool Existeusuarioactivo(string basedatos, Guid idconexion)
{
using (var db = MarfilEntities.ConnectToSqlServer(basedatos))
{
return(db.Usuariosactivos.Any(f => f.idconexion == idconexion));
}
}
private DataTable Query(IContextService context, string select, Dictionary <string, object> parametros)
{
var result = new DataTable();
var dbconnection = "";
using (var db = MarfilEntities.ConnectToSqlServer(context.BaseDatos))
{
dbconnection = db.Database.Connection.ConnectionString;
}
using (var con = new SqlConnection(dbconnection))
{
using (var cmd = new SqlCommand(select, con))
{
cmd.CommandTimeout = 500;
foreach (var item in parametros)
{
cmd.Parameters.AddWithValue(item.Key, item.Value);
}
using (var ad = new SqlDataAdapter(cmd))
{
ad.Fill(result);
}
}
}
return(result);
}
public JsonResult SaveReport()
{
//string usuario,string tipodocumento,string tiporeport,string tipoprivacidad,string nombre
var jsonSerializer = new JavaScriptSerializer();
dynamic parametros = jsonSerializer.DeserializeObject(Request.Params["args"]);
var reportByteVector = ReportDesignerExtension.GetReportXml("Reportdesigner");
var service = new DocumentosUsuarioService(MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos));
var tipoDocumento = (TipoDocumentoImpresion)Enum.Parse(typeof(TipoDocumentoImpresion), parametros["tipodocumento"]);
var tipoprivacidad = (TipoPrivacidadDocumento)Enum.Parse(typeof(TipoPrivacidadDocumento), parametros["tipoprivacidad"]);
var tiporeport = (TipoReport)Enum.Parse(typeof(TipoReport), parametros["tiporeport"]);
var defecto = Funciones.Qbool(parametros["defecto"]);
// Write a report to the storage under the specified URL.
using (var stream = new MemoryStream(reportByteVector))
{
using (var streamReportToSave = new MemoryStream())
{
var url = DocumentosUsuarioService.CreateCustomId(tipoDocumento, new Guid(parametros["usuario"]), parametros["nombre"]);
var report = XtraReport.FromStream(stream, true);
report.Name = url;
report.DisplayName = parametros["nombre"];
report.SaveLayout(streamReportToSave);
service.SetPreferencia(tipoDocumento, new Guid(parametros["usuario"]), tipoprivacidad, tiporeport, parametros["nombre"], streamReportToSave.ToArray(), defecto);
}
}
return(Json(new { success = true, error = "none", Result = string.Format("{0}", DocumentosUsuarioService.CreateCustomId(tipoDocumento, new Guid(parametros["usuario"]), parametros["nombre"])) }));
}
public ActionResult Descargar(string tipo, string reportId, string primarykey)
{
var service = new DocumentosUsuarioService(MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos));
var tipoDocumento = (TipoDocumentoImpresion)Enum.Parse(typeof(TipoDocumentoImpresion), tipo);
Guid usuario = ContextService.Id;
string name = reportId;
ViewBag.Tipo = (int)tipoDocumento;
ViewBag.Usuario = usuario.ToString();
var model = new DesignModel
{
Url = reportId,
Report = service.GetDocumentoParaImprimir(tipoDocumento, usuario, name)?.Datos,
DataSource = FDocumentosDatasourceReport.CreateReport(tipoDocumento, ContextService, primarykey).DataSource,
Name = name
};
var report = new XtraReport();
using (var ms = new MemoryStream(model.Report))
{
report.LoadLayout(ms);
report.DataSource = model.DataSource;
report.Name = model.Name;
using (var stream = new MemoryStream())
{
report.ExportToPdf(stream);
return(File(stream.GetBuffer(), "application/pdf"));
}
}
}
public ActionResult Index(string reportId, string returnUrl, bool nuevo)
{
var service = new DocumentosUsuarioService(MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos));
var userService = FService.Instance.GetService(typeof(UsuariosModel), ContextService) as UsuariosService;
TipoDocumentoImpresion tipoDocumento;
Guid usuario;
string name;
DocumentosUsuarioService.GetFromCustomId(reportId, out tipoDocumento, out usuario, out name);
ViewBag.Tipo = (int)tipoDocumento;
ViewBag.Usuario = usuario.ToString();
var usuarioObj = usuario == Guid.Empty ? "Admin" : ((UsuariosModel)userService.get(usuario.ToString())).Usuario;
var documentoModel = service.GetDocumento(tipoDocumento, usuario, name);
return(View(new DesignModel
{
Nuevo = nuevo,
Tiporeport = documentoModel?.Tiporeport ?? TipoReport.Report,
Tipodocumento = tipoDocumento,
Tipoprivacidad = documentoModel?.Tipoprivacidad ?? TipoPrivacidadDocumento.Publico,
UsuarioId = usuario,
Usuarionombre = usuarioObj,
ReturnUrl = returnUrl,
Url = reportId,
Report = documentoModel?.Datos,
DataSource = FDocumentosDatasourceReport.CreateReport(tipoDocumento, ContextService).DataSource,
Name = name
}));
}
//Rai
public ActionResult CambioEmpresa(string id)
{
var model = new PanelcontrolModel();
try
{
using (var db = MarfilEntities.ConnectToSqlServer(_context.BaseDatos))
{
using (var service = new PreferenciasUsuarioService(db))
{
LoginService _serviceLogin = new LoginService();
var dominio = System.Web.HttpContext.Current.Request.Url.DnsSafeHost;
if (_serviceLogin.puedeCambiarEmpresa(_context.BaseDatos, _context.Usuario, id, dominio))
{
return(RedirectToAction("Index", "CambioEmpresa", new { id = id }));
}
}
}
}
catch (Exception ex)
{
TempData["errors"] = ex.Message;
}
return(RedirectToAction("Index"));
}
public ActionResult Visualizar(string tipo, string reportId, string primarykey)
{
var service = new DocumentosUsuarioService(MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos));
TipoDocumentoImpresion tipoDocumento = (TipoDocumentoImpresion)Enum.Parse(typeof(TipoDocumentoImpresion), tipo);
Guid usuario = ContextService.Id;
string name = reportId;
Dictionary <string, object> dictionary = null;
if (primarykey.IsValidJson())
{
dictionary = JsonConvert.DeserializeObject <Dictionary <string, object> >(primarykey);
}
ViewBag.Tipo = (int)tipoDocumento;
ViewBag.Usuario = usuario.ToString();
var model = new DesignModel
{
Url = reportId,
Report = service.GetDocumentoParaImprimir(tipoDocumento, usuario, name)?.Datos,
DataSource = FDocumentosDatasourceReport.CreateReport(tipoDocumento, ContextService, primarykey).DataSource,
Parameters = dictionary,
Name = name
};
Session["ReportViewer"] = model;
return(View(model));
}
public ActionResult Index()
{
//Rai- errores permisos niveles
if (TempData["errors"] != null)
{
ModelState.AddModelError("", TempData["errors"].ToString());
}
var model = new PanelcontrolModel();
try
{
using (var db = MarfilEntities.ConnectToSqlServer(_context.BaseDatos))
{
using (var service = new PreferenciasUsuarioService(db))
{
var serviceGraficas = new ConfiguraciongraficasService(_context, db);
var preferencias = service.GePreferencia(TiposPreferencias.PanelControlDefecto, _context.Id, "1", "Defecto") as PreferenciaPanelControlDefecto;
model.Paneles = preferencias != null?preferencias.GetPanelesControl(_context.Empresa).Select(f => serviceGraficas.get(f) as ConfiguraciongraficasModel).ToList() : Enumerable.Empty <ConfiguraciongraficasModel>().ToList();
}
}
}
catch (Exception ex)
{
ModelState.AddModelError("", ex.Message);
}
return(View(model));
}
public StartupService(IContextService context, string database)
{
_database = database;
_context = context;
_db = MarfilEntities.ConnectToSqlServer(database);
//_azureblob = context.Azureblob;
}
public void Editar(string id, string razonsocial, string dni, string fkpais, string razonsocial2, string dni2, string fkpais2, bool result)
{
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(CuentasModel), _fixture.Context, db))
{
try
{
var model = new CuentasModel()
{
Empresa = _fixture.Empresa,
Id = id,
Descripcion = razonsocial,
Nif = new NifCifModel()
{
Nif = dni, TipoNif = "1"
},
FkPais = fkpais,
UsuarioId = Guid.Empty.ToString()
};
service.create(model);
}
catch (Exception ex)
{
Assert.False(result);
}
}
}
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
using (var service = FService.Instance.GetService(typeof(CuentasModel), _fixture.Context, db))
{
try
{
var cuenta = service.get(id) as CuentasModel;
cuenta.Descripcion = razonsocial2;
cuenta.Nif.Nif = dni2;
cuenta.FkPais = fkpais2;
service.edit(cuenta);
}
catch (Exception ex)
{
Assert.False(result);
}
}
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
using (var service = FService.Instance.GetService(typeof(CuentasModel), _fixture.Context, db))
{
try
{
var cuenta = service.get(id) as CuentasModel;
Assert.True(razonsocial2 == cuenta.Descripcion && dni2 == cuenta.Nif.Nif && fkpais2 == cuenta.FkPais);
}
catch (Exception ex)
{
Assert.False(result);
}
}
}
//Rai - Devuelve el coste del CRM en funcion de la accion y de la fecha
public int getCosteCRM(string accion, string fecha)
{
var coste = 0;
DateTime?dt = DateTime.ParseExact(fecha, "dd/MM/yyyy", CultureInfo.InvariantCulture);
if (dt.HasValue)
{
var ejercicioId = _db.Ejercicios.Where(f => f.empresa == Empresa && f.desde <= dt && dt <= f.hasta).SingleOrDefault();
var serviceCostesVariablePeriodo = FService.Instance.GetService(typeof(CostesVariablesPeriodoModel), _context);
//Es posible que no se ha creado ningun coste variable con un ejercicio correspondiente a la fecha del seguimiento
if (ejercicioId != null)
{
var modelCostes = serviceCostesVariablePeriodo.get(ejercicioId.id.ToString()) as CostesVariablesPeriodoModel;
var service = new TablasVariasService(_context, MarfilEntities.ConnectToSqlServer(_context.BaseDatos));
var descripcionaccion = service.GetListAcciones().Where(f => f.Valor == accion).Select(f => f.Descripcion).SingleOrDefault().ToString();
foreach (var linea in modelCostes._costes)
{
if (linea.Descripcion == descripcionaccion)
{
coste = (int)linea.Precio;
}
}
}
}
return(coste);
}
public bool checkPassword(string dominio, string usuario, string password, out string basedatos)
{
bool retorno = false;
var licenciaModel = new LicenciasaplicacionService(dominio);
if (!licenciaModel.Activado)
{
throw new LicenciaException("No tiene activada ninguna licencia. Consulte a su administrador.");
}
basedatos = licenciaModel.Basedatos;
using (var db = MarfilEntities.ConnectToSqlServer(basedatos))
{
if (usuario.Equals(ApplicationHelper.UsuariosAdministrador))
{
var admin = db.Administrador.FirstOrDefault(u => u.password == password);
if (admin != null)
{
return(true);
}
}
else
{
var objUser = db.Usuarios.FirstOrDefault(u => u.usuario == usuario && u.password == password);
if (objUser != null)
{
return(true);
}
}
return(retorno);
}
}
public void Alta(string descripcion, string descripcioncorta, DateTime?desde, DateTime?hasta,
EstadoEjercicio estado, DateTime?contacerradahasta, DateTime?registrocerradahasta,
CriterioIVA?customCriterioIva, int?fkejercicios, bool result)
{
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(EjerciciosModel), _fixture.Context, db))
{
var obj = new EjerciciosModel
{
Empresa = _fixture.Context.Empresa,
Descripcion = descripcion,
Descripcioncorta = descripcioncorta,
Desde = desde,
Hasta = hasta,
Estado = estado,
Contabilidadcerradahasta = contacerradahasta,
Registroivacerradohasta = registrocerradahasta,
CustomCriterioIva = customCriterioIva,
Fkejercicios = fkejercicios
};
try
{
service.create(obj);
Assert.True((db.Ejercicios.SingleOrDefault(f => f.descripcioncorta == descripcioncorta) != null) ==
result);
}
catch (Exception ex)
{
Assert.False(result);
}
}
}
}
public void Alta(string codigo, string descripcion, bool ordenaralbaranes, IEnumerable <CriteriosagrupacionLinModel> lineas, bool result)
{
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(CriteriosagrupacionModel), _fixture.Context, db))
{
var obj = new CriteriosagrupacionModel()
{
Id = codigo,
Nombre = descripcion,
Ordenaralbaranes = ordenaralbaranes,
Lineas = lineas.ToList()
};
try
{
service.create(obj);
}
catch (Exception ex)
{
Assert.False(result);
return;
}
Assert.True((db.Criteriosagrupacion.SingleOrDefault(f => f.id == codigo) != null) == result);
}
}
}
public void Alta(DocumentoEstado documento, string id, string descripcion, bool imputariesgo, TipoEstado tipoestado, TipoMovimiento tipomovimiento, bool result)
{
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(EstadosModel), _fixture.Context, db))
{
var obj = new EstadosModel()
{
Documento = documento,
Id = id,
Descripcion = descripcion,
Imputariesgo = imputariesgo,
Tipoestado = tipoestado,
Tipomovimiento = tipomovimiento
};
try
{
service.create(obj);
}
catch (Exception ex)
{
Assert.False(result);
return;
}
Assert.True((db.Estados.SingleOrDefault(f => f.id == id && f.documento == (int)documento) != null) == result);
}
}
}
public ActionResult Delete(string id)
{
if (TempData["errors"] != null)
{
ModelState.AddModelError("", TempData["errors"].ToString());
}
using (var db = MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos))
using (var service = new DocumentosUsuarioService(db))
{
TipoDocumentoImpresion tipoDocumento;
Guid usuario;
string name;
DocumentosUsuarioService.GetFromCustomId(id, out tipoDocumento, out usuario, out name);
ViewBag.TituloMantenimiento = string.Format(General.ConfiguradorDocumentos, Funciones.GetEnumByStringValueAttribute(tipoDocumento));
var model = new DocumentosDeleteModel()
{
CustomId = id,
Nombre = name,
Tipo = tipoDocumento,
Titulo = string.Format(General.ConfiguradorDocumentos, Funciones.GetEnumByStringValueAttribute(tipoDocumento)),
Toolbar = new ToolbarModel()
{
Titulo = string.Format(General.ConfiguradorDocumentos, Funciones.GetEnumByStringValueAttribute(tipoDocumento)),
Operacion = TipoOperacion.Baja,
Acciones = new IToolbaritem[] {}
}
};
return(View(model));
}
}
private bool ExisteAlgunTipoDeTercero(Tiposcuentas model)
{
using (var dbnew = MarfilEntities.ConnectToSqlServer(_db.Database.Connection.Database))
{
return(dbnew.Cuentas.Any(f => f.tipocuenta == model.tipos));
}
}
//Rai ---> puedeEntrarEempresa para el botón de arriba del header, NO se tienen en cuenta el check de poder cambiar de empresa
public bool puedeEntrarEmpresa(string basedatos, string user, string empresa, string dominio)
{
var result = true;
try
{
var licenciaModel = new LicenciasaplicacionService(dominio);
using (var db = MarfilEntities.ConnectToSqlServer(licenciaModel.Basedatos))
{
var descripcionempresa = db.Empresas.Where(f => f.id == empresa).Select(f => f.nombre).SingleOrDefault();
var usuariodb = db.Usuarios.Where(f => f.usuario == user).Single();
var empresadb = db.Empresas.Where(f => f.id == empresa).Single();
if (!(ApplicationHelper.UsuariosAdministrador == user || (usuariodb.nivel >= empresadb.nivel) || (usuariodb.nivel == null && empresadb.nivel == 0)))
{
throw new CambiarEmpresaException("No tiene permisos sobre la empresa " + descripcionempresa + " Consulte con su administrador");
}
}
}
catch (Exception ex)
{
if (ex is CambiarEmpresaException)
{
throw;
}
result = false;
}
return(result);
}
public override Dictionary <string, string> GetUrls()
{
_user = GetCustomPrincipal();
_service = new DocumentosUsuarioService(MarfilEntities.ConnectToSqlServer(_user.BaseDatos));
// Get URLs and display names for all reports available in the storage.
var result = new Dictionary <string, string>();
try
{
var reportId = HttpUtility.ParseQueryString(HttpContext.Current.Request.UrlReferrer.PathAndQuery).GetValues("reportId")[0];
TipoDocumentoImpresion TipoDocumentoImpresion;
Guid usuario;
string name;
DocumentosUsuarioService.GetFromCustomId(reportId, out TipoDocumentoImpresion, out usuario, out name);
var items = _service.GetDocumentos(TipoDocumentoImpresion, _user.Id);
foreach (var item in items)
{
result.Add(item.CustomId, item.Nombre);
}
}
catch (Exception ex)
{
string errores = ex.Message;
}
return(result);
}
public virtual ActionResult Result()
{
if (Session["datalistados"] == null)
{
return(RedirectToAction("Index", "Home"));
}
var service = new ListadosService();
var model = Session["datalistados"] as ListadosModel;
model.Context = _context;
var listadomodel = service.Listar(model);
Session[listadomodel.IdListado + "_resultado"] = listadomodel;
using (var db = MarfilEntities.ConnectToSqlServer(_context.BaseDatos))
{
using (var servicePreferencias = new PreferenciasUsuarioService(db))
{
var result = servicePreferencias.GePreferencia(TiposPreferencias.ConfiguracionListado, _context.Id, listadomodel.IdListado, "Defecto") as PreferenciaConfiguracionListado;
if (result != null)
{
Session[listadomodel.IdListado + "UserSettings"] = result.SettingsDevexpress;
}
}
}
return(View(Session[listadomodel.IdListado + "_resultado"] as ListadoResultado));
}
public void Alta(string nombre, string password, string confirmacion, bool result)
{
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var usuariosService = FService.Instance.GetService(typeof(UsuariosModel), _fixture.Context, db))
{
var usuario = new UsuariosModel
{
Usuario = nombre,
Password = password,
Confirmacionpassword = password
};
try
{
usuariosService.create(usuario);
Assert.True((db.Usuarios.SingleOrDefault(f => f.usuario == usuario.Usuario) != null) == result);
}
catch (Exception)
{
Assert.False(result);
}
}
}
}
public HttpResponseMessage Get(string id)
{
ApplicationHelper app = new ApplicationHelper(ContextService);
var tiposAlbaranes = app.GetListTiposAlbaranes();
var result = app.GetListTiposAlbaranes().Where(f => !f.Salidas && !f.Entradas);
result.OrderBy(f => f.Defecto);
var db = MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos);
var tipoSalidasVarias = db.Series.Where(f => f.empresa == ContextService.Empresa && f.salidasvarias == true).Select(f => f.id).SingleOrDefault();
var tipoEntradasVarias = db.Series.Where(f => f.empresa == ContextService.Empresa && f.entradasvarias == true).Select(f => f.id).SingleOrDefault();
if (id == tipoSalidasVarias)
{
result = tiposAlbaranes.Where(f => f.Salidas == true);
}
else if (id == tipoEntradasVarias)
{
result = tiposAlbaranes.Where(f => f.Entradas == true);
}
var response = Request.CreateResponse(HttpStatusCode.OK);
response.Content = new StringContent(JsonConvert.SerializeObject(result), Encoding.UTF8, "application/json");
return(response);
}
public ActionResult ImportarStock()
{
ImportarModel model = new ImportarModel();
using (var db = MarfilEntities.ConnectToSqlServer(ContextService.BaseDatos))
{
model.Serie = db.Series.Where(f => f.empresa == Empresa && f.entradasvarias == true)
.Select(f => new SelectListItem()
{
Value = f.id, Text = f.descripcion
}).ToList();
}
model.TipoLote = new List <SelectListItem> {
new SelectListItem {
Text = Enum.GetName(typeof(TipoAlmacenlote), TipoAlmacenlote.Mercaderia), Value = TipoAlmacenlote.Mercaderia.ToString()
},
new SelectListItem {
Text = Enum.GetName(typeof(TipoAlmacenlote), TipoAlmacenlote.Propio), Value = TipoAlmacenlote.Propio.ToString()
},
new SelectListItem {
Text = Enum.GetName(typeof(TipoAlmacenlote), TipoAlmacenlote.Gestionado), Value = TipoAlmacenlote.Gestionado.ToString()
}
};
return(View("ImportarStock", model));
}
public static MarfilEntities DB(IContextService context)
{
if (context.GetItem(LargeDatabaseDataContextKey) == null)
{
context.SetItem(LargeDatabaseDataContextKey, MarfilEntities.ConnectToSqlServer(context.BaseDatos));
}
return((MarfilEntities)context.GetItem(LargeDatabaseDataContextKey));
}
public UltimospreciosService(IContextService context)
{
if (context.IsAuthenticated())
{
_empresa = context.Empresa;
_db = MarfilEntities.ConnectToSqlServer(context.BaseDatos);
}
}
public ListadosDiarioContable(IContextService context) : base(context)
{
using (var db = MarfilEntities.ConnectToSqlServer(context.BaseDatos))
{
Fkseriescontables = db.SeriesContables.Where(f => f.empresa == context.Empresa && f.tipodocumento == "AST" && f.fkejercicios == context.Ejercicio).Select(f => f.id).SingleOrDefault();
}
FechaInforme = DateTime.Today;
}
public void Eliminar(int codigo, string descripcion, string descripcion2, bool imprimirVencimientoFacturas, bool excluirFestivos, double recargoFinanciero, bool efectivo, bool remesable, bool mandato, string modopago, bool bloqueado, string fkgruposformaspago, int codigoborrar, bool result)
{
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(FormasPagoModel), _fixture.Context, db))
{
var obj = new FormasPagoModel
{
Id = codigo,
Nombre = descripcion,
Nombre2 = descripcion2,
ImprimirVencimientoFacturas = imprimirVencimientoFacturas,
ExcluirFestivos = excluirFestivos,
RecargoFinanciero = recargoFinanciero,
Efectivo = efectivo,
Remesable = remesable,
Mandato = mandato,
ModoPago = modopago,
BloqueoModel = new BloqueoEntidadModel()
{
Bloqueada = false
},
FkGruposformaspago = fkgruposformaspago
};
try
{
service.create(obj);
}
catch (Exception)
{
Assert.False(result);
return;
}
}
}
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(FormasPagoModel), _fixture.Context, db))
{
try
{
service.delete(service.get(codigoborrar.ToString()));
}
catch (Exception ex)
{
Assert.False(result);
return;
}
}
}
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
Assert.True(!db.FormasPago.Any(f => f.id == codigoborrar));
}
}
public void Eliminar(string codigo, string descripcion, bool ordenaralbaranes, IEnumerable <CriteriosagrupacionLinModel> lineas, string codigoborrar, bool result)
{
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(CriteriosagrupacionModel), _fixture.Context, db))
{
var obj = new CriteriosagrupacionModel()
{
Id = codigo,
Nombre = descripcion,
Ordenaralbaranes = ordenaralbaranes,
Lineas = lineas.ToList()
};
try
{
service.create(obj);
}
catch (Exception ex)
{
Assert.False(result);
return;
}
}
}
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(CriteriosagrupacionModel), _fixture.Context, db))
{
try
{
service.delete(service.get(codigoborrar));
}
catch (Exception ex)
{
Assert.False(result);
return;
}
}
}
using (var db = MarfilEntities.ConnectToSqlServer(_fixture.DbName))
{
using (var service = FService.Instance.GetService(typeof(CriteriosagrupacionModel), _fixture.Context, db))
{
try
{
Assert.True(!service.exists(codigoborrar));
}
catch (Exception ex)
{
Assert.False(result);
return;
}
}
}
}
public ListadosBalanceSumasYSaldos(IContextService context) : base(context)
{
using (var db = MarfilEntities.ConnectToSqlServer(context.BaseDatos))
{
var idEjercicio = Convert.ToInt32(context.Ejercicio);
InicioEjercicio = db.Ejercicios.Where(f => f.empresa == context.Empresa && f.id == idEjercicio).Select(f => f.desde).SingleOrDefault();
}
FechaInforme = DateTime.Today;
}
public ListadosBalancePedidos(IContextService context)
{
Context = context;
_db = MarfilEntities.ConnectToSqlServer(context.BaseDatos);
System.DateTime moment = new System.DateTime();
FechaInforme = DateTime.Today;
FechaDesde = new DateTime(FechaInforme.Value.Year, 1, 1);
FechaHasta = new DateTime(FechaInforme.Value.Year, FechaInforme.Value.Month + 1, 1).AddDays(-1);
}