private void CargarGridsConceptos()
{
try
{
Nomina Datos = new Nomina {
Conexion = Comun.Conexion, IDEmpleado = this.IDEmpleado, IDTipoNomina = this.IDTipoNomina
};
Nomina_Negocio NN = new Nomina_Negocio();
NN.ObtenerConceptosNominaXIDEmpleado(Datos);
this.dgvConceptosFijos.AutoGenerateColumns = false;
this.dgvConceptosVariables.AutoGenerateColumns = false;
this.dgvConceptosFijos.DataSource = Datos.TablaConceptosFijos;
this.dgvConceptosVariables.DataSource = Datos.TablaConceptosVariables;
}
catch (Exception ex)
{
throw ex;
}
}
private Nomina ObtenerConceptoCombo()
{
try
{
Nomina DatosAux = new Nomina();
if (this.cmbConceptos.Items.Count > 0)
{
if (this.cmbConceptos.SelectedIndex != -1)
{
DatosAux = (Nomina)this.cmbConceptos.SelectedItem;
}
}
return(DatosAux);
}
catch (Exception ex)
{
throw ex;
}
}
private void dataGridView1_CellContentDoubleClick(object sender, DataGridViewCellEventArgs e)
{
try
{
Nomina n = new Nomina();
n.IdNomina = Convert.ToInt32(dataGridView1.CurrentRow.Cells["Codigo"].Value.ToString());
DataSet ds = Datos.ProNomina.VerNomina(n);
dt = ds.Tables[0];
dataGridView1.DataSource = dt;
GrupoMostrarNomina.Show();
B_Volver.Visible = true;
}
catch (Exception error)
{
MessageBox.Show(error.Message + error.StackTrace);
}
}
private Nomina ObtenerDatos()
{
try
{
Nomina DatosAux = new Nomina();
DatosAux.IDTipoNomina = this.Datos.IDTipoNomina;
DatosAux.EsFijo = this.Datos.EsFijo;
DatosAux.IDEmpleado = this.Datos.IDEmpleado;
DatosAux.IDConcepto = this.ObtenerConceptoCombo().IDConcepto;
DatosAux.Monto = this.ObtenerMonto();
DatosAux.Conexion = Comun.Conexion;
DatosAux.IDUsuario = Comun.IDUsuario;
return(DatosAux);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
Nomina nomina = db.Nomina.Find(id);
if (nomina == null)
{
return(HttpNotFound());
}
// Initialize a ViewModel with the Nomina from DB
var viewModel = new NewNominaViewModel
{
Nomina = nomina
};
// Set ViewModels Retenciones based on the values from DB (nombre)
foreach (var retencion in nomina.Retencion)
{
if (retencion.Nombre == "AFP")
{
viewModel.Afp = retencion;
}
else if (retencion.Nombre == "SFS")
{
viewModel.Sfs = retencion;
}
else if (retencion.Nombre == "ISR")
{
viewModel.Isr = retencion;
}
else if (retencion.Nombre == "Seguro Medico")
{
viewModel.SeguroMedico = retencion;
}
}
return(View(viewModel));
}
public void ObtenerConceptosVariablesXIDEmpleado(Nomina Datos)
{
try
{
DataSet ds = SqlHelper.ExecuteDataset(Datos.Conexion, "spCSLDB_get_ConceptosVariablesNomina", Datos.IDEmpleado, Datos.IDTipoNomina);
Datos.TablaDatos = new DataTable();
if (ds != null)
{
if (ds.Tables.Count == 1)
{
Datos.TablaConceptosVariables = ds.Tables[0];
}
}
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult Realizar_Nomina()
{
try
{
using (var Db = new Empresa.Models.EmpresaConexionString())
{
List <VentasDeVendedoresPorMes2_Result> lis = Db.VentasDeVendedoresPorMes2().ToList();
List <Nomina> nom = Db.Nomina.ToList();
foreach (var item in lis)
{
Vendedor ven = Db.Vendedor.FirstOrDefault(v => v.Id_Vendedor == item.Id_Vendedor);
if (Db.Nomina.FirstOrDefault(n => n.Fecha_Nomina.Month == item.Mes && n.Fecha_Nomina.Year == item.Anho && n.Id_Vendedor == item.Id_Vendedor) != null)
{
int cantidadDias = (int)(DateTime.Now.Date - ven.Fecha_Registro.Date).TotalDays;
if (cantidadDias >= 60)
{
Nomina nomina = new Nomina()
{
Id_Vendedor = item.Id_Vendedor,
Fecha_Nomina = DateTime.Now,
Salario_Basico = (decimal)item.SB,
Auxilio_Transporte = item.AT,
Auxilio_Alimentacion = item.AA,
Id_Rango = (int)item.Id_Rango,
Valor_Sueldo = item.Valor_Sueldo,
SumaVentas = item.SumaVentas
};
Db.Nomina.Add(nomina);
Db.SaveChanges();
return(RedirectToAction("Index"));
}
}
}
}
return(RedirectToAction("Index"));
}
catch (Exception ex)
{
return(RedirectToAction("Index"));
}
}
public void ObtenerNominas(Nomina Datos)
{
try
{
object[] Parametros = { Datos.EsBusqueda, Datos.BandBusqFechas, Datos.ClaveNomina, Datos.FechaInicio, Datos.FechaFin };
DataSet Ds = SqlHelper.ExecuteDataset(Datos.Conexion, "spCSLDB_get_ObtenerNominas", Parametros);
if (Ds != null)
{
if (Ds.Tables.Count > 0)
{
Datos.TablaDatos = Ds.Tables[0];
Datos.Completado = true;
}
}
}
catch (Exception ex)
{
throw ex;
}
}
private void Mantenimiento_de__nomina_Load(object sender, EventArgs e)
{
Nomina n = new Nomina();
string dc="Nomina";
try
{
DataSet ds = ProNomina.SeleccionarIdNomina();
dc = ds.Tables[0].Rows[0][0].ToString();
t_IdNomina.Text=dc;
}
catch (Exception error)
{
MessageBox.Show(error.Message + error.StackTrace);
}
}
private Comprobante agregarComplementoNomina(Comprobante comprobante, Nomina nomina)
{
XmlDocument docNomina = new XmlDocument();
XmlSerializerNamespaces xmlSerializerNamespaces = new XmlSerializerNamespaces();
xmlSerializerNamespaces.Add("nomina12", "http://www.sat.gob.mx/nomina12");
XmlSerializer oXmlSerializar = new XmlSerializer(typeof(Nomina));
using (XmlWriter writer = docNomina.CreateNavigator().AppendChild())
{
oXmlSerializar.Serialize(writer, nomina, xmlSerializerNamespaces);
}
comprobante.Complemento = new ComprobanteComplemento[1];
comprobante.Complemento[0] = new ComprobanteComplemento();
comprobante.Complemento[0].Any = new XmlElement[1];
comprobante.Complemento[0].Any[0] = docNomina.DocumentElement;
return(comprobante);
}
// METODO QUE RECIBE EL TRABAJADOR POR REFERENCIA PARA AÑADIRLE UNA NÓMINA
public static void pedirNomina(ref Trabajador trabajador)
{
Nomina nomina;
DatosBase datos;
bool salir;
salir = false;
datos = ControlerAdministracion.cargarDatos();
nomina = new Nomina();
do
{
try
{
nomina.nombre = trabajador.nombre;
nomina.apellidos = trabajador.apellidos;
InterfazNomina.pedirDatosNomina(ref nomina);
nomina.eurosHoras = datos.preciojoranda; // ESTA CONSTANTE ESTA EN CONTROLER GESTORIA, PERO ¿COMO SE LLEGA DE AQUI ALLI?
nomina.calcularBruto(datos.horasbase, datos.incrementoextra); // HAY QUE PASARLE EL MAX. DE HORAS NORMALES (EL RESTO SON EXTRAS) Y EL FACTOR DE INCREMENTO
nomina.calcularImpuestos(datos.impuestos); // EL PORCENTAJE DE LA TASA DE IMPUESTOS
if (trabajador.AgregarNomina(nomina))
{
CH.lcdColor("\ni> NÓMINA REGISTRADA CORRECTAMENTE!!\n", ConsoleColor.Green);
Console.WriteLine(nomina.ToString());
ConsoleHelper.pausa();
salir = true;
}
else
{
CH.lcdColor("!> ERROR REGISTRANDO LA NÓMINA!!", ConsoleColor.Red);
CH.pausa();
};
}
catch (Exception ex)
{
CH.lcdColor("\n!> CLASS ERR: " + ex.Message.ToUpper(), ConsoleColor.Red);
CH.pausa();
salir = true;
}
} while (!salir);
}
private void B_GenerarNomina_Click(object sender, EventArgs e)
{
Nomina n = new Nomina();
if (T_Dollar.Text != "")
{
n.Dollar = Convert.ToDecimal(T_Dollar.Text);
try
{
DataSet ds = ProNomina.VistaDeNomina(n);
dt = ds.Tables[0];
dataGridView1.DataSource = dt;
}
catch (Exception error)
{
MessageBox.Show(error.Message + error.StackTrace);
}
}
else
MessageBox.Show("Por favor ingrese la tasa de cambio para calcular la nomina");
foreach(DataGridViewRow row in dataGridView1.Rows)
{
count_Afp += Convert.ToDecimal(row.Cells["AFP"].Value);
count_ISR += Convert.ToDecimal(row.Cells["Impuesto sobre la renta"].Value);
count_Seg += Convert.ToDecimal(row.Cells["Seguro social"].Value);
count_Sueldo += Convert.ToDecimal(row.Cells["Sueldo Neto"].Value);
}
label5.Text = " Fondo de pensiones $$ " + count_Afp.ToString();
label2.Text = " Seguridad Social $$ " + count_Seg.ToString();
label6.Text = " Impuesto sobre la renta $$ " + count_ISR.ToString();
label7.Text = "Total a Pagar $$ " + count_Sueldo.ToString();
}
private void B_Guardar_Click(object sender, EventArgs e)
{
Nomina n = new Nomina();
n.Dollar = Convert.ToDecimal(T_Dollar.Text);
n.Usuario1 = Convert.ToInt32(T_Usuario.Text);
n.Estatus1 = CBX_Estatus.Text;
n.Fecha1 = DateTime.Today;
ProNomina.GuardarNomina(n);
try
{
if( ProNomina.GuardarNomina(n)>0 )
MessageBox.Show("la nomina se ha registrado correctamente");
}
catch
{
}
foreach (DataGridViewRow row in dataGridView1.Rows)
{
DetalleNomina dn = new DetalleNomina();
dn.Cedula = row.Cells["Cedula"].Value.ToString();
dn.IdNomina = Convert.ToInt32(t_IdNomina.Text);
dn.AFP = Convert.ToDecimal(row.Cells["AFP"].Value.ToString());
dn.Seg_Med = Convert.ToDecimal(row.Cells["Seguro social"].Value.ToString());
dn.Sueldo_neto = Convert.ToDecimal(row.Cells["Sueldo neto"].Value.ToString());
dn.ISR = Convert.ToDecimal(row.Cells["Impuesto sobre la renta"].Value.ToString());
if (ProNomina.GuardarDetalleNomina(dn) > 0)
MessageBox.Show("la nomina se ha registrado correctamente");
}
}
public static string SerializeNomina(Nomina NominaComplemento)
{
MemoryStream stream = null;
TextWriter writer = null;
try
{
UTF8Encoding encoding = new UTF8Encoding();
stream = new MemoryStream(); // read xml in memory
writer = new StreamWriter(stream, encoding);
XmlSerializer serializer = new XmlSerializer(typeof(Nomina));
serializer.Serialize(writer, NominaComplemento); // read object
int count = (int)stream.Length; // saves object in memory stream
byte[] arr = new byte[count];
stream.Seek(0, SeekOrigin.Begin);
stream.Read(arr, 0, count);
//return encoding.GetString(arr).Trim();
string xml = encoding.GetString(arr).Trim();
xml = Util.removeInvalidCharacters(xml);
XmlDocument doc = new XmlDocument();
//XmlSchema sh = XmlSchema.Read(new StreamReader(HttpContext.Current.Request.PhysicalApplicationPath + @"files SAT\cfdv3.xsd"), null);
doc.LoadXml(xml);
return doc.OuterXml;
}
catch (Exception e)
{
throw new Exception(e.Message);
}
finally
{
if (stream != null) stream.Close();
if (writer != null) writer.Close();
}
}
public ActionResult Validar(Nomina nomina)
{
try {
if (nomina.Age == null)
{
ModelState.AddModelError("", "Debe ingresar el año de la nonima.");
return(View(nomina));
}
if (nomina.Mes == null)
{
ModelState.AddModelError("", "Debe ingresar el mes de la nomina.");
return(View(nomina));
}
nomina1 = nomina;
return(RedirectToAction("Crear"));
} catch {
ModelState.AddModelError("", "Ocurrió un error al validar la nonima");
return(View(nomina));
}
}
private Nomina ObtenerCVSeleccionado()
{
try
{
Nomina DatosAux = new Nomina();
int RowSelected = this.dgvConceptosVariables.Rows.GetFirstRow(DataGridViewElementStates.Selected);
if (RowSelected >= 0)
{
DataGridViewRow Fila = this.dgvConceptosVariables.Rows[RowSelected];
DatosAux.IDConceptoNomina = Fila.Cells["IDConceptoVariable"].Value.ToString();
DatosAux.EsFijo = false;
DatosAux.IDUsuario = Comun.IDUsuario;
DatosAux.Conexion = Comun.Conexion;
}
return(DatosAux);
}
catch (Exception ex)
{
throw ex;
}
}
public ActionResult calcuNomina()
{
var aux = db.Empleados.Where(x => x.status == true).Sum(x => x.Salario);
Nomina nomina = new Nomina {
Mes = DateTime.Now.Month,
Año = DateTime.Now.Year,
Monto_Total = aux
};
if (db.GetNominas.FirstOrDefault(x => x.Año == nomina.Año && x.Mes == nomina.Mes) != null)
{
return(View());
}
else
{
db.GetNominas.Add(nomina);
db.SaveChanges();
//nomina.Monto_Total = aux;
return(RedirectToAction("Index"));
}
}
public void QuitarConceptoNomina(Nomina Datos)
{
try
{
object[] Parametros = { Datos.IDConceptoNomina, Datos.EsFijo, Datos.IDUsuario };
object Result = SqlHelper.ExecuteScalar(Datos.Conexion, "spCSLDB_set_QuitarConceptoNomina", Parametros);
if (Result != null)
{
int Resultado = 0;
int.TryParse(Result.ToString(), out Resultado);
if (Resultado == 1)
{
Datos.Completado = true;
}
}
}
catch (Exception ex)
{
throw ex;
}
}
private void btnAgregarCV_Click(object sender, EventArgs e)
{
try
{
Nomina DatosAux = new Nomina {
IDEmpleado = this.IDEmpleado, IDTipoNomina = this.IDTipoNomina, EsFijo = false
};
frmNominaAgregarConcepto AgregarConcepto = new frmNominaAgregarConcepto(DatosAux);
AgregarConcepto.ShowDialog();
AgregarConcepto.Dispose();
if (AgregarConcepto.DialogResult == DialogResult.OK)
{
this.CargarGridConceptosVariables();
}
}
catch (Exception ex)
{
LogError.AddExcFileTxt(ex, "frmNominaConceptos ~ btnAgregarCV_Click");
MessageBox.Show(Comun.MensajeError, Comun.Sistema, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public ActionResult Delete(int?id, bool?saveChangesError = false)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
if (saveChangesError.GetValueOrDefault())
{
ViewBag.ErrorMessage = "Delete failed. Try again, and if the problem persists see your system administrator.";
}
Nomina nomina = db.Nomina.Find(id);
if (nomina == null)
{
return(HttpNotFound());
}
return(View(nomina));
}
private void btnGuardar_Click(object sender, EventArgs e)
{
try
{
List <Error> Errores = this.ValidarDatos();
if (Errores.Count == 0)
{
Nomina DatosAux = this.ObtenerDatos();
Nomina_Negocio NN = new Nomina_Negocio();
NN.AgregarConceptoNomina(DatosAux);
if (DatosAux.Completado)
{
this.DialogResult = DialogResult.OK;
}
else
{
if (DatosAux.Resultado == -1)
{
Error ErrorAux = new Error {
Numero = 1, Descripcion = "El concepto ya está agregado.", ControlSender = this.cmbConceptos
};
}
else
{
MessageBox.Show(Comun.MensajeError + " Código: " + Datos.Resultado, Comun.Sistema, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
}
else
{
this.MostrarMensajeError(Errores);
}
}
catch (Exception ex)
{
LogError.AddExcFileTxt(ex, "frmNominaAgregarConcepto ~ btnGuardar_Click");
MessageBox.Show(Comun.MensajeError, Comun.Sistema, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public List <Nomina> ObtenerComboConceptosNomina(Nomina Datos)
{
try
{
SqlDataReader Dr = SqlHelper.ExecuteReader(Datos.Conexion, "spCSLDB_get_ComboConceptosNomina", Datos.IncluirSelect);
List <Nomina> Lista = new List <Nomina>();
Nomina Item;
while (Dr.Read())
{
Item = new Nomina();
Item.IDConcepto = Dr.GetInt32(Dr.GetOrdinal("IDConcepto"));
Item.ConceptoNomina = Dr.GetString(Dr.GetOrdinal("Concepto"));
Lista.Add(Item);
}
Dr.Close();
return(Lista);
}
catch (Exception ex)
{
throw ex;
}
}
// GET: Nomina
public async Task <ActionResult> Index()
{
var httpClient = new HttpClient();
var json = await httpClient.GetStringAsync("http://localhost:53231/empleado");
ClaseEsquema clase = JsonConvert.DeserializeObject <ClaseEsquema>(json);
Nomina cabecera = new Nomina
{
Periodo = Convert.ToDateTime(clase.Periodo),
Rnc = clase.Rnc,
Nomina_Detalle = clase.Empleados
};
db.Nomina.Add(cabecera);
db.SaveChanges();
return(Content("Datos guardados correctamente"));
}
/// <summary>
/// METODO PARA CAMBIAR UNA NÓMINA POR OTRA
/// RECIBE EL TRABAJADOR POR REFERENCIA Y LA NOMINA A CAMBIAR.
/// CREA UNA NUEVA Y LA CAMBIA
/// <paramref name="nomina">La nomina a sustituir</paramref>
/// <paramref name="trabajador">El trabajador de la nómina en cuestion</paramref>
/// </summary>
public static void pedirNuevaNomina(ref Trabajador trabajador, Nomina nomina)
{
Nomina nueva_nomina = new Nomina();
bool salir = false;
DatosBase datos;
datos = ControlerAdministracion.cargarDatos();
do
{
try
{
nueva_nomina.nombre = trabajador.nombre;
nueva_nomina.apellidos = trabajador.apellidos;
Console.WriteLine("i> OK, AMO... VAMOS A CREAR UNA NUEVA NÓMINA PARA SUSTITUIRLA");
pedirDatosNomina(ref nueva_nomina);
nueva_nomina.eurosHoras = datos.preciojoranda; // ESTA CONSTANTE ESTA EN CONTROLER GESTORIA, PERO ¿COMO SE LLEGA DE AQUI ALLI?
nueva_nomina.calcularBruto(datos.horasbase, datos.incrementoextra); // HAY QUE PASARLE EL MAX. DE HORAS NORMALES (EL RESTO SON EXTRAS) Y EL FACTOR DE INCREMENTO
nueva_nomina.calcularImpuestos(datos.impuestos); // EL PORCENTAJE DE LA TASA DE IMPUESTOS
Console.WriteLine("\n" + nueva_nomina.ToString());
if (trabajador.modificarNomina(nomina, nueva_nomina))
{
CH.lcdColor("i> NÓMINA MODIFICADA CORRECTAMENTE", ConsoleColor.Green);
salir = true;
//ConsoleHelper.pausa();
}
else
{
CH.lcdColor("\n!> ERROR MODIFICANDO LA NÓMINA", ConsoleColor.Red);
};
}
catch (Exception ex)
{
CH.lcdColor("!> ERR: " + ex.Message.ToUpper(), ConsoleColor.Red);
}
} while (!salir);
}
public async static void ReadNomina()
{
CsvParserOptions _options = new CsvParserOptions(false, '|');
CsvParserNomina _mapper = new CsvParserNomina();
CsvParser <Nomina> parser = new CsvParser <Nomina>(_options, _mapper);
try
{
var result = parser.ReadFromFile(FileName, Encoding.UTF8);
using (var apapDbContext = new ApapDbContext())
{
foreach (var item in result)
{
var nomina = new Nomina
{
TipoRegistro = item.Result.TipoRegistro,
ClaveNomina = item.Result.ClaveNomina,
TipoDocumento = item.Result.TipoDocumento,
NoDocumento = item.Result.NoDocumento,
MontoPagar = item.Result.MontoPagar,
Cuenta = item.Result.Cuenta
};
await apapDbContext.Nominas.AddAsync(nomina);
}
await apapDbContext.SaveChangesAsync();
apapDbContext.Dispose();
Console.WriteLine("Data Loaded");
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
}
public ActionResult Create(Nomina nomina, NominaDiaLibre[] diasLibres)
{
NominaDiaLibre nominadiaLibre;
try
{
if (nomina.IdNomina == 0)
{
IdNomina = db.Nomina.Max(w => w.IdNomina) + 1;
}
else
{
IdNomina = nomina.IdNomina;
}
List <NominaDiaLibre> dias = db.NominaDiaLibre.Where(w => w.IdNomina == IdNomina).ToList();
using (var dbContext = new ConfortexEntities())
{
if (nomina.IdNomina == 0)
{
dbContext.sp_GestionarNomina(IdNomina, nomina.NombreReferencia, nomina.FechaInicio, nomina.FechaFin, clsReferencias.EnBorrador, nomina.Observaciones, clsReferencias.INSERT);
}
else
{
dbContext.sp_GestionarNomina(IdNomina, nomina.NombreReferencia, nomina.FechaInicio, nomina.FechaFin, 0, nomina.Observaciones, clsReferencias.UPDATE);
}
}
if (diasLibres != null)
{
for (int i = 0; i < diasLibres.Length; i++)
{
if (diasLibres[i].FechaLibre <nomina.FechaInicio || diasLibres[i].FechaLibre> nomina.FechaFin)
{
return(Json(new { Message = "El día libre " + diasLibres[i].FechaLibre.Date.ToShortDateString() + " se encuentra fuera de los limites de pago de la Nómina, por lo tanto no puede ser agregado, debe corregir este error para continuar." }));
}
if (diasLibres[i].IdNominaDiaLibre == 0)
{
diasLibres[i].IdNomina = IdNomina;
diasLibres[i].FechaCreacion = System.DateTime.Now;
db.NominaDiaLibre.Add(diasLibres[i]);
}
else
{
nominadiaLibre = db.NominaDiaLibre.Find(diasLibres[i].IdNominaDiaLibre);
nominadiaLibre.Concepto = diasLibres[i].Concepto;
db.Entry(nominadiaLibre).State = EntityState.Modified;
dias = dias.Where(w => w.IdNominaDiaLibre != diasLibres[i].IdNominaDiaLibre).ToList();
}
}
db.NominaDiaLibre.RemoveRange(dias.ToArray());
}
else
{
IEnumerable <NominaDiaLibre> diasT = db.NominaDiaLibre.Where(w => w.IdNomina == IdNomina);
db.NominaDiaLibre.RemoveRange(diasT);
}
db.SaveChanges();
return(Json(new { Message = clsReferencias.Exito, IdNomina = IdNomina }));
}
catch (Exception ex)
{
return(Json(new { Message = new clsException(ex).Message() }));
}
}
public static Response Procesar(Nomina obj)
{
try
{
var comando = new SqlCommand();
_conexion = AccesoDatos.Validar_Conexion("SisAsepba", ref _mensaje);
if (_conexion == null)
{
// mensaje = "Error al encontrar la conexion proporcionada";
return(new Response
{
IsSuccess = false,
Message = "Error al encontrar la conexion proporcionada"
});
}
else
{
AccesoDatos.Conectar(_conexion, ref _mensaje);
comando.Connection = _conexion;
comando.CommandText = SpConexion;
comando.Parameters.AddWithValue("@@Accion", obj.Accion);
comando.Parameters.AddWithValue("@@IdNomina", obj.IdNomina);
comando.Parameters.AddWithValue("@@Alias", obj.Alias);
comando.Parameters.AddWithValue("@@Descripcion", obj.Descripcion);
comando.Parameters.AddWithValue("@@TipoNomina", obj.TipoNomina);
comando.Parameters.AddWithValue("@@Consecutivo", obj.Consecutivo);
comando.Parameters.AddWithValue("@@Estado", obj.Estado);
comando.Parameters.AddWithValue("@@UsuarioCreacion", obj.UsuarioCreacion);
comando.Parameters.AddWithValue("@@FechaCreacion", obj.FechaCreacion);
comando.Parameters.AddWithValue("@@UsuarioModificacion", obj.UsuarioModificacion);
comando.Parameters.AddWithValue("@@FechaModificacion", obj.FechaModificacion);
var resultado = AccesoDatos.LlenarDataTable(comando, ref _mensaje);
//return string.IsNullOrEmpty(mensaje) ? Convert.ToBoolean(resultado.Rows[0][0] ) : false;
if (resultado == null || resultado.Rows.Count < 0)
{
return(new Response
{
IsSuccess = false,
Message = "Error a la hora de realizar la consulta"
});
}
return(new Response
{
IsSuccess = true,
Result = resultado.Rows[0][0]
});
}
}
catch (Exception ex)
{
_mensaje = ex.Message;
return(new Response
{
IsSuccess = false,
Message = "Error a la hora de realizar la consulta, detalle del error: " + ex.Message
});
}
finally
{
AccesoDatos.Desconectar(_conexion, ref _mensaje);
}
}
// generamos el CFDI
public NominaTimbrada generarCFDI(NominaCFDI nominacfdi, string Password, Empresa empresa, Empleado empleado)
{
DateTime FechaPago = DateTime.Now;
DateTime FechaPagoInicial = DateTime.Now;
DateTime FechaPagoFinal = DateTime.Now;
DateTime FechaComprobante = DateTime.Parse(String.Format("{0:s}", DateTime.Now), CultureInfo.InvariantCulture);
int AntiguedadEmpleado = 1; // pendiente debemos de calcular la antiguedad en numero de años basado en el inicio de la relación laboral del objeyo empleado
// creamos el objecto CFDI
comprobante CFDI = new comprobante();
// datos generales del comprobante
CFDI.version = VersionCFDI.V_2012;
CFDI.fecha = FechaComprobante;
CFDI.folio = nominacfdi.NominaID.ToString();
CFDI.serie = "nomina";
CFDI.LugarExpedicion = empresa.LugarExpedicion;
CFDI.TipoCambio = "1";
CFDI.Moneda = "MXN";
CFDI.noCertificado = "";
CFDI.certificado = "";
CFDI.subTotal = ShowDecimalRound(nominacfdi.SalarioNeto);
CFDI.tipoDeComprobante = MasFacturacion.StampingConnector.StampingService.comprobanteTipoDeComprobante.ingreso;
CFDI.condicionesDePago = "Pago en una sola exhibición";
CFDI.sello = "";
CFDI.metodoDePago ="NA";
CFDI.formaDePago = "Pago en una sola exhibición";
CFDI.total = ShowDecimalRound(nominacfdi.SalarioNeto);
CFDI.Emisor = new comprobanteEmisor();
CFDI.Emisor.rfc = empresa.RFC.ToUpper();
CFDI.Emisor.ExpedidoEn = new MasFacturacion.StampingConnector.StampingService.t_Ubicacion();
CFDI.Emisor.ExpedidoEn.pais = empresa.Pais;
CFDI.Emisor.ExpedidoEn.estado = empresa.Estado;
CFDI.Emisor.ExpedidoEn.localidad = empresa.Localidad;
CFDI.Emisor.ExpedidoEn.municipio = empresa.Municipio;
CFDI.Emisor.ExpedidoEn.colonia = empresa.Colonia;
CFDI.Emisor.ExpedidoEn.calle = empresa.Calle;
CFDI.Emisor.ExpedidoEn.noExterior = empresa.NumeroExterior;
CFDI.Emisor.ExpedidoEn.noInterior = empresa.NumeroInterior;
CFDI.Emisor.ExpedidoEn.codigoPostal = empresa.CP;
CFDI.Emisor.nombre = empresa.Nombre;
CFDI.Emisor.RegimenFiscal = new comprobanteEmisorRegimenFiscal[1];
CFDI.Emisor.RegimenFiscal[0] = new comprobanteEmisorRegimenFiscal();
CFDI.Emisor.RegimenFiscal[0].Regimen = empresa.Regimen;
CFDI.Emisor.DomicilioFiscal = new t_UbicacionFiscal();
CFDI.Emisor.DomicilioFiscal.pais = empresa.Pais;
CFDI.Emisor.DomicilioFiscal.estado = empresa.Estado;
CFDI.Emisor.DomicilioFiscal.localidad = empresa.Localidad;
CFDI.Emisor.DomicilioFiscal.municipio = empresa.Municipio;
CFDI.Emisor.DomicilioFiscal.colonia = empresa.Colonia;
CFDI.Emisor.DomicilioFiscal.calle = empresa.Calle;
CFDI.Emisor.DomicilioFiscal.noExterior = empresa.NumeroExterior;
CFDI.Emisor.DomicilioFiscal.noInterior = empresa.NumeroInterior;
CFDI.Emisor.DomicilioFiscal.codigoPostal = empresa.CP;
CFDI.Receptor = new comprobanteReceptor();
CFDI.Receptor.rfc = nominacfdi.RFC.ToUpper();
CFDI.Receptor.nombre = empleado.Nombre;
CFDI.Receptor.Domicilio = new t_Ubicacion();
CFDI.Receptor.Domicilio.pais = String.IsNullOrEmpty(empleado.Pais) ? "México" : empleado.Pais;
CFDI.Receptor.Domicilio.estado = empleado.Estado;
CFDI.Receptor.Domicilio.localidad = empleado.Localidad;
CFDI.Receptor.Domicilio.municipio = empleado.Municipio;
CFDI.Receptor.Domicilio.colonia = empleado.Colonia;
CFDI.Receptor.Domicilio.calle = empleado.Calle;
CFDI.Receptor.Domicilio.noExterior = empleado.NumeroExterior;
CFDI.Receptor.Domicilio.noInterior = empleado.NumeroInterior;
CFDI.Receptor.Domicilio.codigoPostal = String.IsNullOrEmpty(empleado.CP) ? "00000" : empleado.CP;
CFDI.Conceptos = new ArrayOfComprobanteConceptoConcepto[1];
CFDI.Conceptos[0] = new ArrayOfComprobanteConceptoConcepto();
CFDI.Conceptos[0].cantidad = 1;
CFDI.Conceptos[0].unidad = "Unidad";
CFDI.Conceptos[0].descripcion = "Descripcion";
CFDI.Conceptos[0].noIdentificacion ="Num. Identificacion";
CFDI.Conceptos[0].valorUnitario = 1;
CFDI.Conceptos[0].importe = 1;
CFDI.Impuestos = new MasFacturacion.StampingConnector.StampingService.comprobanteImpuestos();
CFDI.Impuestos.totalImpuestosRetenidos=1;
CFDI.Impuestos.totalImpuestosTrasladados=1;
CFDI.Impuestos.Retenciones = new ArrayOfComprobanteImpuestosRetencionRetencion[2];
CFDI.Impuestos.Retenciones[0] = new ArrayOfComprobanteImpuestosRetencionRetencion();
CFDI.Impuestos.Retenciones[0].impuesto = ArrayOfComprobanteImpuestosRetencionRetencionImpuesto.ISR;
CFDI.Impuestos.Retenciones[0].importe = 15;
CFDI.Impuestos.Retenciones[1] = new ArrayOfComprobanteImpuestosRetencionRetencion();
CFDI.Impuestos.Retenciones[1].impuesto = ArrayOfComprobanteImpuestosRetencionRetencionImpuesto.IVA;
CFDI.Impuestos.Retenciones[1].importe = 15;
CFDI.Impuestos.Traslados = new ArrayOfComprobanteImpuestosTrasladoTraslado[2];
CFDI.Impuestos.Traslados[0] = new ArrayOfComprobanteImpuestosTrasladoTraslado();
CFDI.Impuestos.Traslados[0].impuesto = ArrayOfComprobanteImpuestosTrasladoTrasladoImpuesto.IVA;
CFDI.Impuestos.Traslados[0].tasa = 16;
CFDI.Impuestos.Traslados[0].importe = new decimal(0.16);
CFDI.Impuestos.Traslados[1] = new ArrayOfComprobanteImpuestosTrasladoTraslado();
CFDI.Impuestos.Traslados[1].impuesto = ArrayOfComprobanteImpuestosTrasladoTrasladoImpuesto.IEPS;
CFDI.Impuestos.Traslados[1].tasa = 10;
CFDI.Impuestos.Traslados[1].importe = new decimal(0.15);
// creamos el complemento nomina basado en la clase nomina
Nomina NominaComplemento = new Nomina();
NominaComplemento.RegistroPatronal = empresa.RegistroPatronal;
NominaComplemento.NumEmpleado = String.IsNullOrEmpty(empleado.NumdeEmpleado) ? "0" : empleado.NumdeEmpleado;
NominaComplemento.CURP = empleado.CURP.ToUpper();
NominaComplemento.TipoRegimen = empleado.Regimen.GetValueOrDefault(2);
NominaComplemento.NumSeguridadSocial = empleado.NumSeguroSocial;
NominaComplemento.FechaPago = FechaPago;
NominaComplemento.FechaInicialPago = FechaPagoInicial;
NominaComplemento.FechaFinalPago = FechaPagoFinal;
NominaComplemento.NumDiasPagados = ShowDecimalRound(nominacfdi.DiasPagar);
NominaComplemento.Departamento = empleado.Departamento;
NominaComplemento.CLABE = empleado.CLABE;
NominaComplemento.Banco = empleado.Banco.GetValueOrDefault(1);
NominaComplemento.FechaInicioRelLaboral = empleado.FechaInicioLaboral;
NominaComplemento.Antiguedad = AntiguedadEmpleado;
NominaComplemento.Puesto = empleado.Puesto;
NominaComplemento.TipoContrato = empleado.TipoContrato;
NominaComplemento.TipoJornada = empleado.TipoJornada;
NominaComplemento.PeriodicidadPago = String.IsNullOrEmpty(empleado.PeriodicidadPago) ? "0" : empleado.PeriodicidadPago;
NominaComplemento.SalarioBaseCotApor = ShowDecimalRound(empleado.SalarioDiario);
NominaComplemento.RiesgoPuesto = empleado.RiesgoPuesto.GetValueOrDefault(1);
NominaComplemento.SalarioDiarioIntegrado = ShowDecimalRound(empleado.SBC);
NominaComplemento.Percepciones = new NominaPercepciones();
NominaComplemento.Percepciones.Percepcion = new NominaPercepcionesPercepcion[1];
NominaComplemento.Percepciones.Percepcion[0] = new NominaPercepcionesPercepcion();
NominaComplemento.Percepciones.Percepcion[0].Clave="001";
NominaComplemento.Percepciones.Percepcion[0].Concepto="percepcion";
NominaComplemento.Percepciones.Percepcion[0].ImporteExento=1;
NominaComplemento.Percepciones.Percepcion[0].ImporteGravado=1;
NominaComplemento.Percepciones.Percepcion[0].TipoPercepcion="001";
NominaComplemento.Deducciones = new NominaDeducciones();
NominaComplemento.Deducciones.Deduccion = new NominaDeduccionesDeduccion[1];
NominaComplemento.Deducciones.Deduccion[0] = new NominaDeduccionesDeduccion();
NominaComplemento.Deducciones.Deduccion[0].Clave="001";
NominaComplemento.Deducciones.Deduccion[0].Concepto="Deduccion";
NominaComplemento.Deducciones.Deduccion[0].ImporteExento=1;
NominaComplemento.Deducciones.Deduccion[0].ImporteGravado=1;
NominaComplemento.Deducciones.Deduccion[0].TipoDeduccion = "001";
NominaComplemento.Version = "1.1";
//creamos una lista de elementos XML
List<XmlElement> nominaXMLElement = new List<XmlElement>();
// creamos un documento de XML
XmlDocument doc = new XmlDocument();
// leemos el complemento de nomina en el objecto de xml
doc.LoadXml(SerializeNomina(NominaComplemento));
doc.DocumentElement.RemoveAttribute("xmlns:xsi"); // le quitamos estos namespaces porque ya se los pusimos al comprobante CFDI
doc.DocumentElement.RemoveAttribute("xmlns:xsd");
doc.DocumentElement.RemoveAttribute("nomina:xsd");
//creamos un elemento de XML
XmlElement elementoNomina = doc.DocumentElement;
elementoNomina.RemoveAttribute("xmlns");
elementoNomina.Prefix = "nomina";
for (int i=0; elementoNomina.ChildNodes.Count>i;i++){
elementoNomina.ChildNodes[i].Prefix = "nomina";
for (int j = 0; elementoNomina.ChildNodes[i].ChildNodes.Count > j; j++)
{
elementoNomina.ChildNodes[i].ChildNodes[j].Prefix = "nomina";
}
}
// le agregamos el elemento nomina al arreglo de elementos
nominaXMLElement.Add(elementoNomina);
// creamos el complemento
if (CFDI.Complemento == null)
{
CFDI.Complemento = new MasFacturacion.StampingConnector.StampingService.comprobanteComplemento();
}
// vaciamos el arreglo de elementos al nodo de complemento del comprobante
CFDI.Complemento.Any = nominaXMLElement.ToArray();
CFDI = EncryptPFX(CFDI,TypeCryptoServiceProvider.SHA1, empresa.PFX, Password);
var xml = Serializer.SerializeComprobante(CFDI);
// ya tememos el objeto que vamos a timbrar
XmlDocument xmld = new XmlDocument();
xmld.LoadXml(xml);
xmld.Schemas.Add(null, ConfigurationManager.AppSettings["pathSATFiles"] + @"files SAT/localxsd/cfdv32.xsd");
xmld.Schemas.Add(null, ConfigurationManager.AppSettings["pathSATFiles"] + @"files SAT/localxsd/nomina11.xsd");
// validamos el esquema
xmld.Validate(ValidationCallBack);
string serialNumber = null;
TimbreFiscalDigital timbreFiscalTemp = new StampingMasFacturacion().getStamp(CFDI, serialNumber);
XmlDocument docTimbre = new XmlDocument();
// leemos el complemento de nomina en el objecto de xml
docTimbre.LoadXml(SerializeTimbreFiscalDigital(timbreFiscalTemp));
XmlElement elementoTimbre = docTimbre.DocumentElement;
nominaXMLElement.Add(elementoTimbre);
CFDI.Complemento.Any = nominaXMLElement.ToArray();
NominaTimbrada respuesta = new NominaTimbrada();
respuesta.xml = Serializer.SerializeComprobante(CFDI);
respuesta.uuid = timbreFiscalTemp.UUID.ToString();
return respuesta;
}
public NominaDAO()
{
conexion = new AccesoBD();
nomina = new Nomina();
}
static void Main(string[] args)
{
Console.WriteLine("Calculadora Impuesto Sobre la Renta");
var conexionNomina = new Conexion <Nomina>();
var conexionExcluyentes = new Conexion <Excluyentes>();
var conexionRango1 = new Conexion <Rango1>();
var conexionRango2 = new Conexion <Rango2>();
var conexionRango3 = new Conexion <Rango3>();
bool continuar = true;
string respuesta;
for (bool i = true; i == continuar;)
{
Nomina ListaN = new Nomina();
Console.WriteLine("Inserte el nombre del empleado");
ListaN.Nombre = Console.ReadLine();
Console.WriteLine("Inserte los Apellidos del empleado");
ListaN.Apellido = Console.ReadLine();
Console.WriteLine("Inserte el Sueldo Neto del empleado");
ListaN.SueldoBruto = Convert.ToDecimal(Console.ReadLine());
conexionNomina.Create(ListaN);
Console.WriteLine("Desea Agregar otro empleado (S/N)");
respuesta = Console.ReadLine();
respuesta = respuesta.ToUpper();
if (respuesta == "S")
{
continuar = true;
}
else
{
continuar = false;
}
if ((ListaN.SueldoBruto * 12) <= 416220)
{
Excluyentes ForExclu = new Excluyentes();
ForExclu.Nombre = ListaN.Nombre;
ForExclu.Apellido = ListaN.Apellido;
ForExclu.SueldoBruto = ListaN.SueldoBruto;
ForExclu.Afp = ForExclu.SueldoBruto * (decimal)2.87 / 100;
ForExclu.Ars = ForExclu.SueldoBruto * (decimal)3.04 / 100;
ForExclu.Sip = ForExclu.SueldoBruto - (ForExclu.Afp + ForExclu.Ars);
ForExclu.Irs = 0;
ForExclu.TotalRetencion = ForExclu.Irs + ForExclu.Ars + ForExclu.Afp;
ForExclu.SueldoNeto = ForExclu.SueldoBruto - ForExclu.TotalRetencion;
conexionExcluyentes.Create(ForExclu);
}
else if ((ListaN.SueldoBruto * 12) >= 416221 && (ListaN.SueldoBruto * 12) <= 624329)
{
Rango1 Forrango1 = new Rango1();
Forrango1.Nombre = ListaN.Nombre;
Forrango1.Apellido = ListaN.Apellido;
Forrango1.SueldoBruto = ListaN.SueldoBruto;
Forrango1.Afp = Forrango1.SueldoBruto * (decimal)2.87 / 100;
Forrango1.Ars = Forrango1.SueldoBruto * (decimal)3.04 / 100;
Forrango1.Sip = Forrango1.SueldoBruto - (Forrango1.Afp + Forrango1.Ars);
Forrango1.Irs = (Forrango1.SueldoBruto * 12 - 416220);
Forrango1.Irs = Forrango1.Irs / 12 * (decimal)0.15;
Forrango1.TotalRetencion = Forrango1.Irs + Forrango1.Ars + Forrango1.Afp;
Forrango1.SueldoNeto = Forrango1.SueldoBruto - Forrango1.TotalRetencion;
conexionRango1.Create(Forrango1);
}
else if (ListaN.SueldoBruto * 12 >= 624330 && ListaN.SueldoBruto * 12 <= 867123)
{
Rango2 Forrango2 = new Rango2();
Forrango2.Nombre = ListaN.Nombre;
Forrango2.Apellido = ListaN.Apellido;
Forrango2.SueldoBruto = ListaN.SueldoBruto;
Forrango2.Afp = Forrango2.SueldoBruto * (decimal)2.87 / 100;
Forrango2.Ars = Forrango2.SueldoBruto * (decimal)3.04 / 100;
Forrango2.Sip = Forrango2.SueldoBruto - (Forrango2.Afp + Forrango2.Ars);
Forrango2.Irs = (Forrango2.SueldoBruto * 12 - 624329);
Forrango2.Irs = Forrango2.Irs / 12 * (decimal)0.20;
Forrango2.TotalRetencion = Forrango2.Irs + Forrango2.Ars + Forrango2.Afp;
Forrango2.SueldoNeto = Forrango2.SueldoBruto - Forrango2.TotalRetencion;
conexionRango2.Create(Forrango2);
}
else if (ListaN.SueldoBruto * 12 >= 867124)
{
Rango3 Forrango3 = new Rango3();
Forrango3.Nombre = ListaN.Nombre;
Forrango3.Apellido = ListaN.Apellido;
Forrango3.SueldoBruto = ListaN.SueldoBruto;
Forrango3.Afp = Forrango3.SueldoBruto * (decimal)2.87 / 100;
Forrango3.Ars = Forrango3.SueldoBruto * (decimal)3.04 / 100;
Forrango3.Sip = Forrango3.SueldoBruto - (Forrango3.Afp + Forrango3.Ars);
Forrango3.Irs = (Forrango3.SueldoBruto * 12 - 867123);
Forrango3.Irs = Forrango3.Irs / 12 * (decimal)0.25;
Forrango3.TotalRetencion = Forrango3.Irs + Forrango3.Ars + Forrango3.Afp;
Forrango3.SueldoNeto = Forrango3.SueldoBruto - Forrango3.TotalRetencion;
conexionRango3.Create(Forrango3);
}
}
Console.Clear();
{
foreach (var Impri in conexionExcluyentes.GetAll())
{
Console.WriteLine("--------------------------------------------------------------------------------------------------------------------------------------");
Console.WriteLine("--------------------------------------------Lista Excluyentes-------------------------------------------------------------------------");
Console.WriteLine("--------------------------------------------------------------------------------------------------------------------------------------");
Console.WriteLine(" ");
Console.WriteLine(" ");
Console.WriteLine(" Nombre " + " Apellido " + " Sueldo Bruto " + " AFP " + " ARS " + " SIP " + " ISR " + " TOTALR " + " NETO ");
Console.WriteLine(" " + Impri.Nombre + " " + Impri.Apellido + " " + Impri.SueldoBruto + " " + Impri.Afp + " " + Impri.Ars + " " + Impri.Sip + " " + Impri.Irs + " " + Impri.TotalRetencion + " " + Impri.SueldoNeto + " "
);
}
foreach (var Impri in conexionRango1.GetAll())
{
Console.WriteLine("****--------------------------------------------------------------------------------------------------------------------------------------****");
Console.WriteLine("****--------------------------------------------Lista Rango 15%---------------------------------------------------------------------------****");
Console.WriteLine("****--------------------------------------------------------------------------------------------------------------------------------------****");
Console.WriteLine(" ");
Console.WriteLine(" ");
Console.WriteLine(" Nombre " + " Apellido " + " Sueldo Bruto " + " AFP " + " ARS " + " SIP " + " ISR " + " TOTALR " + " NETO ");
Console.WriteLine(" " + Impri.Nombre + " " + Impri.Apellido + " " + Impri.SueldoBruto + " " + Impri.Afp + " " + Impri.Ars + " " + Impri.Sip + " " + Impri.Irs + " " + Impri.TotalRetencion + " " + Impri.SueldoNeto + " "
);
}
foreach (var Impri in conexionRango2.GetAll())
{
Console.WriteLine("****--------------------------------------------------------------------------------------------------------------------------------------****");
Console.WriteLine("****--------------------------------------------Lista Rango 20%---------------------------------------------------------------------------****");
Console.WriteLine("****--------------------------------------------------------------------------------------------------------------------------------------****");
Console.WriteLine(" ");
Console.WriteLine(" ");
Console.WriteLine(" Nombre " + " Apellido " + " Sueldo Bruto " + " AFP " + " ARS " + " SIP " + " ISR " + " TOTALR " + " NETO ");
Console.WriteLine(" " + Impri.Nombre + " " + Impri.Apellido + " " + Impri.SueldoBruto + " " + Impri.Afp + " " + Impri.Ars + " " + Impri.Sip + " " + Impri.Irs + " " + Impri.TotalRetencion + " " + Impri.SueldoNeto + " "
);
}
foreach (var Impri in conexionRango3.GetAll())
{
Console.WriteLine("****--------------------------------------------------------------------------------------------------------------------------------------****");
Console.WriteLine("****--------------------------------------------Lista Rango 30%---------------------------------------------------------------------------****");
Console.WriteLine("****--------------------------------------------------------------------------------------------------------------------------------------*****");
Console.WriteLine(" ");
Console.WriteLine(" ");
Console.WriteLine(" Nombre " + " Apellido " + " Sueldo Bruto " + " AFP " + " ARS " + " SIP " + " ISR " + " TOTALR " + " NETO ");
Console.WriteLine(" " + Impri.Nombre + " " + Impri.Apellido + " " + Impri.SueldoBruto + " " + Impri.Afp + " " + Impri.Ars + " " + Impri.Sip + " " + Impri.Irs + " " + Impri.TotalRetencion + " " + Impri.SueldoNeto + " "
);
}
}
}
public ActionResult <GenericApiResponse <object> > GuardarNomina(int tipo, [FromBody] DateTime date)
{
if (date == null)
{
return(this.HandleBadRequest("Fecha invalida", ""));
}
var nominas = Nomina(date, tipo);
var culture = new CultureInfo("es-GT");
var mes = date.ToString("MMMM", culture);
var nomina = new Nomina {
Fecha = date, Mes = char.ToUpper(mes[0]) + mes.Substring(1)
};
nomina.DetallesNomina = new Collection <DetalleNomina>();
switch (tipo)
{
case 0:
nomina.Descripcion = "Mensual";
break;
case 1:
nomina.Descripcion = "Bono 14";
break;
case 2:
nomina.Descripcion = "Aguinaldo";
break;
}
int i = 0;
foreach (var n in nominas)
{
i++;
var detalle = new DetalleNomina();
detalle.Id = i;
detalle.Nomina = nomina;
detalle.SueldoBruto = n.SueldoBruto;
detalle.SueldoLiquido = n.SueldoNeto;
detalle.SueldoExtraordinario = n.HorasExtras;
detalle.Id_Empleado = n.IdEmpleado;
detalle.Detalles_Descuento = new Collection <Detalle_Descuento>();
int j = 0;
foreach (var d in n.Descuentos)
{
j++;
var descuento = new Detalle_Descuento();
descuento.Id = j;
descuento.DetalleNomina = detalle;
descuento.Id_Descuento = d.Id;
descuento.Monto = d.Valor;
detalle.Detalles_Descuento.Add(descuento);
}
nomina.DetallesNomina.Add(detalle);
}
contexto.Nomina.Add(nomina);
contexto.SaveChanges();
return(this.HandleOKNoData());
}
public List <Nomina> GetAccounts(string pStrYear, string pStrPeriodo, string pStrNo, string pStrServer, string pStrDBName, string pStrUser, string pStrPassword)
{
Recordset lObjRecordset = null;
//se asigna el valor desde aqui para que mas adelante no ocurra excepcion de referencia no establecida: 15/11/2018
//List<Nomina> lLstNomina = null;
List <Nomina> lLstNomina = new List <Nomina>();
try {
Dictionary <string, string> lLstStrParameters = new Dictionary <string, string>();
lLstStrParameters.Add("ServerName", pStrServer);
lLstStrParameters.Add("DBName", pStrDBName);
lLstStrParameters.Add("User", pStrUser);
lLstStrParameters.Add("Password", pStrPassword);
lLstStrParameters.Add("Year", pStrYear);
lLstStrParameters.Add("Tipo", pStrPeriodo);
lLstStrParameters.Add("Ipno", pStrNo);
//lLstStrParameters.Add("IdEmp", pIntIdEmp.ToString());
//SqlConnection conn = new SqlConnection(conecctionString);
string lStrQuery = this.GetSQL("GetAccounts").Inject(lLstStrParameters);
lObjRecordset = (SAPbobsCOM.Recordset)DIApplication.Company.GetBusinessObject(SAPbobsCOM.BoObjectTypes.BoRecordset);
lObjRecordset.DoQuery(lStrQuery);
if (lObjRecordset.RecordCount > 0)
{
for (int i = 0; i < lObjRecordset.RecordCount; i++)
{
Nomina lObjNomina = new Nomina();
lObjNomina.ACONS = int.Parse(lObjRecordset.Fields.Item("ACONS").Value.ToString());
lObjNomina.IPYEAR = int.Parse(lObjRecordset.Fields.Item("IPYEAR").Value.ToString());
lObjNomina.IPMES = int.Parse(lObjRecordset.Fields.Item("IPMES").Value.ToString());
lObjNomina.IPTIPO = int.Parse(lObjRecordset.Fields.Item("IPTIPO").Value.ToString());
lObjNomina.IPNO = int.Parse(lObjRecordset.Fields.Item("IPNO").Value.ToString());
lObjNomina.ATRAB = int.Parse(lObjRecordset.Fields.Item("ATRAB").Value.ToString());
lObjNomina.ACONC = int.Parse(lObjRecordset.Fields.Item("ACONC").Value.ToString());
lObjNomina.ICNOM = lObjRecordset.Fields.Item("ICNOM").Value.ToString();
lObjNomina.AIMPO = lObjRecordset.Fields.Item("AIMPO").Value.ToString();
lObjNomina.ACCTO_HN = lObjRecordset.Fields.Item("ACCTO_HN").Value.ToString();
lObjNomina.ICDNOM = lObjRecordset.Fields.Item("ICDNOM").Value.ToString();
lObjNomina.ADEP_HN = lObjRecordset.Fields.Item("ADEP_HN").Value.ToString();
lObjNomina.ICCTAC = lObjRecordset.Fields.Item("ICCTAC").Value.ToString();
lObjNomina.ICCTAA = lObjRecordset.Fields.Item("ICCTAA").Value.ToString();
lObjNomina.NIVEL = lObjRecordset.Fields.Item("NIVEL").Value.ToString();
lObjNomina.CUENTA = lObjRecordset.Fields.Item("CUENTA").Value.ToString();
lObjNomina.ACCTO = lObjRecordset.Fields.Item("ACCTO").Value.ToString();
lObjNomina.ADEP = lObjRecordset.Fields.Item("ADEP").Value.ToString();
lObjNomina.CUENTA1 = lObjRecordset.Fields.Item("CUENTA1").Value.ToString();
lObjNomina.CCTO_ID = lObjRecordset.Fields.Item("CCTO_ID").Value.ToString();
lObjNomina.UUID = lObjRecordset.Fields.Item("UUID").Value.ToString();
lObjNomina.CUENTA2 = lObjRecordset.Fields.Item("CUENTA2").Value.ToString();
lObjNomina.NNOM = lObjRecordset.Fields.Item("NNOM").Value.ToString();
lObjNomina.NRFC = lObjRecordset.Fields.Item("NRFC").Value.ToString();
//toma ligeramente mas tiempo
//foreach(Field field in lObjRecordset.Fields) {
// lObjNomina.GetType().GetProperty(field.Name).SetValue(lObjNomina, field.Value);
//}
lLstNomina.Add(lObjNomina);
lObjRecordset.MoveNext();
}
}
}
catch (Exception lObjException) {
throw new DAOException(lObjException.Message, lObjException);
}
finally {
MemoryUtility.ReleaseComObject(lObjRecordset);
}
return(lLstNomina);
}
private bool GuardarDomingo()
{
Cargando.Mostrar();
// Se guarda la nómina
int iBancoCuentaID = Util.Entero(this.cmbCuentaBancaria.SelectedValue);
string sDia = DateTime.Now.ToString("yyMMdd");
var oNomina = new Nomina()
{
Semana = DateTime.Now,
Fecha = DateTime.Now,
BancoCuentaID = iBancoCuentaID,
Domingo = true
};
Datos.Guardar<Nomina>(oNomina);
// Se guarda el detalle
foreach (DataGridViewRow oFila in this.dgvDatos.Rows)
{
if (!Util.Logico(oFila.Cells["Sel"].Value))
continue;
int iUsuarioID = Util.Entero(oFila.Cells["UsuarioID"].Value);
int iSucursalID = Util.Entero(oFila.Cells["SucursalID"].Value);
// Se guardan los datos
var oNominaFijo = new NominaUsuario()
{
NominaID = oNomina.NominaID,
IdUsuario = iUsuarioID,
SucursalID = Util.Entero(oFila.Cells["SucursalID"].Value),
Adicional = Util.Decimal(oFila.Cells["Adicional"].Value),
Tickets = Util.Decimal(oFila.Cells["Tickets"].Value),
Adelanto = Util.Decimal(oFila.Cells["Adelanto"].Value),
MinutosTarde = Util.Decimal(oFila.Cells["MinutosTarde"].Value),
Otros = Util.Decimal(oFila.Cells["Otros"].Value)
};
Datos.Guardar<NominaUsuario>(oNominaFijo);
// Se genera el gasto contable por la diferencia, si aplica
decimal mDiferencia = Util.Decimal(oFila.Cells["Diferencia"].Value);
if (mDiferencia != 0)
{
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios && c.RelacionID == iUsuarioID);
if (oCuentaAux != null)
{
var oGasto = new ContaEgreso()
{
ContaCuentaAuxiliarID = oCuentaAux.ContaCuentaAuxiliarID,
Fecha = DateTime.Now,
Importe = mDiferencia,
TipoFormaPagoID = Cat.FormasDePago.Efectivo,
TipoDocumentoID = Cat.TiposDeDocumento.Nota,
EsFiscal = false,
Observaciones = "NÓMINA DOMINGO",
SucursalID = iSucursalID,
RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID,
FolioFactura = sDia,
};
ContaProc.GastoCrear(oGasto);
}
}
}
// Se generan las pólizas contables correspondientes (AfeConta)
var oNominaUsuariosV = Datos.GetListOf<NominaUsuariosView>(c => c.NominaID == oNomina.NominaID);
foreach (var oReg in oNominaUsuariosV)
{
// Se crea la póliza de la diferencia, si aplica
if (oReg.Diferencia != 0)
{
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios && c.RelacionID == oReg.UsuarioID);
if (oCuentaAux == null)
{
UtilLocal.MensajeAdvertencia("No se encontró la cuenta auxiliar: Salarios -> " + oReg.Usuario + ". No se creará la póliza de Complemento Nómina.");
continue;
}
ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, "NÓMINA DOMINGO"
, oCuentaAux.ContaCuentaAuxiliarID, Cat.ContaCuentasAuxiliares.ReservaNomina, oReg.Diferencia.Valor(), oReg.Usuario
, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
}
// Se crea la póliza del adelanto, si aplica
DateTime dAhora = DateTime.Now;
if (oReg.Adelanto > 0)
{
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.DeudoresDiversos
&& c.RelacionID == oReg.UsuarioID);
if (oCuentaAux != null)
{
ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, "ADELANTO", Cat.ContaCuentasAuxiliares.Caja, oCuentaAux.ContaCuentaAuxiliarID
, oReg.Adelanto, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor(), oReg.SucursalID);
// Se crea adicionalmente, un ingreso de caja por el importe del adelanto
var oIngreso = new CajaIngreso()
{
CajaTipoIngresoID = Cat.CajaTiposDeIngreso.Otros,
Concepto = ("PAGO ADELANTO " + oReg.Usuario),
Importe = oReg.Adelanto,
Fecha = dAhora,
SucursalID = oReg.SucursalID,
RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID
};
Datos.Guardar<CajaIngreso>(oIngreso);
}
}
// Se crea la póliza de minutos tarde y otros, si aplica
if (oReg.MinutosTarde > 0 || oReg.Otros > 0)
{
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios
&& c.RelacionID == oReg.UsuarioID);
if (oCuentaAux != null)
{
if (oReg.MinutosTarde > 0)
ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, "MINUTOS TARDE", Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID
, oReg.MinutosTarde, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
if (oReg.Otros > 0)
ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, "OTROS DESCUENTOS", Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID
, oReg.Otros, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
}
}
}
// Se manda a imprimir la nómina de cada usuario
var oRep = new Report();
oRep.Load(UtilLocal.RutaReportes("NominaDomingo.frx"));
oRep.RegisterData(new List<Nomina>() { oNomina }, "Nomina");
oRep.RegisterData(oNominaUsuariosV, "Usuarios");
Cargando.Cerrar();
UtilLocal.EnviarReporteASalida("Reportes.NominaDomingo.Salida", oRep);
UtilLocal.MostrarNotificacion("Proceso completado.");
this.btnDomingo_Click(this, null);
return true;
}
private bool AccionGuardar()
{
if (!this.Validar())
return false;
if (this.bDomingo)
return this.GuardarDomingo();
Cargando.Mostrar();
// Se guarda la nómina
int iBancoCuentaID = Util.Entero(this.cmbCuentaBancaria.SelectedValue);
DateTime dAhora = DateTime.Now;
DateTime dOficial = this.dtpOficial.Value;
DateTime dComplementaria = this.dtpComplementaria.Value;
string sDiaOficial = dOficial.ToString("yyMMdd");
string sDiaComplementaria = dComplementaria.ToString("yyMMdd");
DateTime dSemana = Util.FechaHora(this.cmbSemana.SelectedValue);
bool bEsAguinaldo = (this.cmbSemana.Text == "AGUINALDO");
var oNomina = new Nomina()
{
Semana = dSemana,
Fecha = dAhora,
BancoCuentaID = iBancoCuentaID,
EsAguinaldo = bEsAguinaldo
};
Datos.Guardar<Nomina>(oNomina);
// Se guarda el detalle
decimal mTotalOficial = 0;
foreach (DataGridViewRow oFila in this.dgvDatos.Rows)
{
if (!Util.Logico(oFila.Cells["Sel"].Value))
continue;
int iUsuarioID = Util.Entero(oFila.Cells["UsuarioID"].Value);
int iSucursalID = Util.Entero(oFila.Cells["SucursalID"].Value);
// Se llenan los datos de la nómina oficial (dinámico)
for (int iCol = this.iColumnasFijas; iCol < this.dgvDatos.Columns.Count; iCol++)
{
var oNominaOfCuentaV = (this.dgvDatos.Columns[iCol].Tag as NominaOficialCuentasView);
var oNominaOf = new NominaUsuarioOficial()
{
NominaID = oNomina.NominaID,
IdUsuario = iUsuarioID,
ContaCuentaDeMayorID = oNominaOfCuentaV.ContaCuentaDeMayorID,
Importe = Util.Decimal(oFila.Cells[iCol].Value),
Suma = oNominaOfCuentaV.Suma
};
Datos.Guardar<NominaUsuarioOficial>(oNominaOf);
}
// Se guardan los datos no dinámicos
var oNominaFijo = new NominaUsuario()
{
NominaID = oNomina.NominaID,
IdUsuario = iUsuarioID,
SucursalID = Util.Entero(oFila.Cells["SucursalID"].Value),
SuperoMinimo = (oFila.Cells["SueldoMinimo"].Style.ForeColor == Color.Gray),
SueldoFijo = Util.Decimal(oFila.Cells["SueldoFijo"].Value),
SueldoVariable = Util.Decimal(oFila.Cells["SueldoVariable"].Value),
Sueldo9500 = Util.Decimal(oFila.Cells["Sueldo9500"].Value),
SueldoMinimo = Util.Decimal(oFila.Cells["SueldoMinimo"].Value),
Bono = Util.Decimal(oFila.Cells["Bono"].Value),
Adicional = Util.Decimal(oFila.Cells["Adicional"].Value),
Tickets = Util.Decimal(oFila.Cells["Tickets"].Value),
Adelanto = Util.Decimal(oFila.Cells["Adelanto"].Value),
MinutosTarde = Util.Decimal(oFila.Cells["MinutosTarde"].Value),
Otros = Util.Decimal(oFila.Cells["Otros"].Value)
};
Datos.Guardar<NominaUsuario>(oNominaFijo);
// Se generan los gastos contables correspondientes, de lo oficial
for (int iCol = this.iColumnasFijas; iCol < this.dgvDatos.Columns.Count; iCol++)
{
decimal mImporte = Util.Decimal(oFila.Cells[iCol].Value);
var oNominaOfCuentaV = (this.dgvDatos.Columns[iCol].Tag as NominaOficialCuentasView);
int iCuentaDeMayorID = oNominaOfCuentaV.ContaCuentaDeMayorID;
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == iCuentaDeMayorID && c.RelacionID == iUsuarioID);
if (oCuentaAux == null)
continue;
var oGasto = new ContaEgreso()
{
ContaCuentaAuxiliarID = oCuentaAux.ContaCuentaAuxiliarID,
Fecha = dOficial,
Importe = mImporte,
TipoFormaPagoID = Cat.FormasDePago.Transferencia,
FolioDePago = sDiaOficial,
TipoDocumentoID = Cat.TiposDeDocumento.Factura,
EsFiscal = true,
Observaciones = ("NÓMINA " + this.cmbSemana.Text),
SucursalID = iSucursalID,
RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID,
FolioFactura = sDiaOficial,
BancoCuentaID = iBancoCuentaID
};
ContaProc.GastoCrear(oGasto);
}
// Se genera el gasto contable por la diferencia, si aplica
decimal mDiferencia = Util.Decimal(oFila.Cells["Diferencia"].Value);
if (mDiferencia != 0)
{
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios && c.RelacionID == iUsuarioID);
if (oCuentaAux != null)
{
var oGasto = new ContaEgreso()
{
ContaCuentaAuxiliarID = oCuentaAux.ContaCuentaAuxiliarID,
Fecha = dComplementaria,
Importe = mDiferencia,
TipoFormaPagoID = Cat.FormasDePago.Efectivo,
TipoDocumentoID = Cat.TiposDeDocumento.Nota,
EsFiscal = false,
Observaciones = ("CN " + this.cmbSemana.Text),
SucursalID = iSucursalID,
RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID,
FolioFactura = sDiaComplementaria,
};
ContaProc.GastoCrear(oGasto);
}
}
mTotalOficial += Util.Decimal(oFila.Cells["TotalOficial"].Value);
}
// Se genera el moviemiento bancario, con lo oficial
var oMov = new BancoCuentaMovimiento()
{
BancoCuentaID = iBancoCuentaID,
EsIngreso = false,
Fecha = dOficial,
FechaAsignado = dAhora,
SucursalID = GlobalClass.SucursalID,
Importe = mTotalOficial,
Concepto = "NÓMINA BANCARIA",
Referencia = GlobalClass.UsuarioGlobal.NombreUsuario,
TipoFormaPagoID = Cat.FormasDePago.Transferencia,
RelacionTabla = Cat.Tablas.Nomina,
RelacionID = oNomina.NominaID
};
ContaProc.RegistrarMovimientoBancario(oMov);
// Se generan las pólizas contables correspondientes (AfeConta)
var oNominaUsuariosV = Datos.GetListOf<NominaUsuariosView>(c => c.NominaID == oNomina.NominaID);
var oPolizaBase = new ContaPoliza()
{
ContaTipoPolizaID = Cat.ContaTiposDePoliza.Egreso,
Fecha = dComplementaria,
Concepto = "",
RelacionTabla = Cat.Tablas.NominaUsuario,
RelacionID = oNomina.NominaID
};
foreach (var oReg in oNominaUsuariosV)
{
// Se crea la póliza de lo oficial
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.NominaOficial, oReg.NominaUsuarioID, this.cmbSemana.Text, ("NÓMINA " + this.cmbSemana.Text)
, oReg.SucursalID, dOficial);
// Se crea la póliza de la diferencia, si aplica
if (oReg.Diferencia != 0)
{
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios && c.RelacionID == oReg.UsuarioID);
if (oCuentaAux == null)
{
UtilLocal.MensajeAdvertencia("No se encontró la cuenta auxiliar: Salarios -> " + oReg.Usuario + ". No se creará la póliza de Complemento Nómina.");
continue;
}
var oPoliza = Util.CrearCopia<ContaPoliza>(oPolizaBase);
oPoliza.Concepto = ("COMPLEMENTO NÓMINA " + this.cmbSemana.Text);
ContaProc.CrearPoliza(oPoliza, oCuentaAux.ContaCuentaAuxiliarID, Cat.ContaCuentasAuxiliares.ReservaNomina, oReg.Diferencia.Valor(), oReg.Usuario
, oReg.SucursalID, Cat.Sucursales.Matriz);
/* ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, ("COMPLEMENTO NÓMINA " + this.cmbSemana.Text)
, oCuentaAux.ContaCuentaAuxiliarID, Cat.ContaCuentasAuxiliares.ReservaNomina, oReg.Diferencia.Valor(), oReg.Usuario
, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
*/
}
// Se crea la póliza del adelanto, si aplica
if (oReg.Adelanto > 0)
{
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.DeudoresDiversos
&& c.RelacionID == oReg.UsuarioID);
if (oCuentaAux != null)
{
// ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Ingreso, "ADELANTO", Cat.ContaCuentasAuxiliares.Caja, oCuentaAux.ContaCuentaAuxiliarID
// , oReg.Adelanto, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor(), oReg.SucursalID);
var oPoliza = Util.CrearCopia<ContaPoliza>(oPolizaBase);
oPoliza.ContaTipoPolizaID = Cat.ContaTiposDePoliza.Ingreso;
oPoliza.Concepto = "ADELANTO";
oPoliza.SucursalID = oReg.SucursalID;
ContaProc.CrearPoliza(oPoliza, Cat.ContaCuentasAuxiliares.Caja, oCuentaAux.ContaCuentaAuxiliarID, oReg.Adelanto, oReg.Usuario
, Cat.Sucursales.Matriz, oReg.SucursalID);
// Se crea adicionalmente, un ingreso de caja por el importe del adelanto
var oIngreso = new CajaIngreso()
{
CajaTipoIngresoID = Cat.CajaTiposDeIngreso.Otros,
Concepto = ("PAGO ADELANTO " + oReg.Usuario),
Importe = oReg.Adelanto,
Fecha = dAhora,
SucursalID = oReg.SucursalID,
RealizoUsuarioID = GlobalClass.UsuarioGlobal.UsuarioID
};
Datos.Guardar<CajaIngreso>(oIngreso);
}
}
// Se crea la póliza de minutos tarde y otros, si aplica
if (oReg.MinutosTarde > 0 || oReg.Otros > 0)
{
var oCuentaAux = Datos.GetEntity<ContaCuentaAuxiliar>(c => c.ContaCuentaDeMayorID == Cat.ContaCuentasDeMayor.Salarios
&& c.RelacionID == oReg.UsuarioID);
if (oCuentaAux != null)
{
if (oReg.MinutosTarde > 0)
{
// ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, "MINUTOS TARDE", Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID
// , oReg.MinutosTarde, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
var oPoliza = Util.CrearCopia<ContaPoliza>(oPolizaBase);
oPoliza.Concepto = "MINUTOS TARDE";
ContaProc.CrearPoliza(oPoliza, Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID, oReg.MinutosTarde, oReg.Usuario
, Cat.Sucursales.Matriz, oReg.SucursalID);
}
if (oReg.Otros > 0)
{
// ContaProc.CrearPoliza(Cat.ContaTiposDePoliza.Egreso, "OTROS DESCUENTOS", Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID
// , oReg.Otros, oReg.Usuario, Cat.Tablas.NominaUsuario, oReg.NominaID.Valor());
var oPoliza = Util.CrearCopia<ContaPoliza>(oPolizaBase);
oPoliza.Concepto = "OTROS DESCUENTOS";
ContaProc.CrearPoliza(oPoliza, Cat.ContaCuentasAuxiliares.ReservaNomina, oCuentaAux.ContaCuentaAuxiliarID, oReg.Otros, oReg.Usuario
, Cat.Sucursales.Matriz, oReg.SucursalID);
}
}
}
}
// Se genera el resguardo y refuerzo especiales
/* Este procedimiento hacía crecer el Resguardo, porque el dinero no se tomaba de ReservaNómina y se
* mandaba a Resguardo cuando en realidad quedaba en el salario de los usuarios 17/11/2015
var oResguardos = new Dictionary<int, decimal>();
var oRefuerzos = new Dictionary<int, decimal>();
foreach (DataGridViewRow oFila in this.dgvDatos.Rows)
{
if (!Util.ConvertirBool(oFila.Cells["Sel"].Value))
continue;
int iSucursalID = Util.ConvertirEntero(oFila.Cells["SucursalID"].Value);
if (!oResguardos.ContainsKey(iSucursalID))
oResguardos.Add(iSucursalID, 0);
if (!oRefuerzos.ContainsKey(iSucursalID))
oRefuerzos.Add(iSucursalID, 0);
decimal mDiferencia = Util.ConvertirDecimal(oFila.Cells["Diferencia"].Value);
decimal mTickets = Util.ConvertirDecimal(oFila.Cells["Tickets"].Value);
decimal mMinutosTarde = Util.ConvertirDecimal(oFila.Cells["MinutosTarde"].Value);
decimal mOtros = Util.ConvertirDecimal(oFila.Cells["Otros"].Value);
decimal mAdelanto = Util.ConvertirDecimal(oFila.Cells["Adelanto"].Value);
oRefuerzos[iSucursalID] += (mDiferencia - mMinutosTarde - mOtros);
// Se quita el adelanto a los resguardos de acuerdo a una nueva petición - Moi 03/08/2015
// oResguardos[iSucursalID] += (mDiferencia - mMinutosTarde - mOtros + mAdelanto);
// Se suman ahora los tickets a los resguardos porque no están seguros y están haciendo pruebas - Moi 08/08/2015
oResguardos[iSucursalID] += (mDiferencia - mMinutosTarde - mOtros + mTickets);
}
// Se crean los resguardos / refuerzos y las pólizas correspondientes (AfeConta)
foreach (var oReg in oResguardos)
{
var oResguardo = VentasProc.GenerarResguardo(oReg.Value, oReg.Key);
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.Resguardo, oResguardo.CajaEgresoID, "NO MOVER", "NO MOVER DE TIENDA / RESGUARDO", oReg.Key);
}
foreach (var oReg in oRefuerzos)
{
var oRefuerzo = VentasProc.GenerarRefuerzo(oReg.Value, oReg.Key);
ContaProc.CrearPolizaAfectacion(Cat.ContaAfectaciones.Refuerzo, oRefuerzo.CajaIngresoID, "REFUERZO", "REFUERZO NÓMINA", oReg.Key);
}
*/
// Se manda a imprimir la nómina de cada usuario
var oNominaUsuariosOfV = Datos.GetListOf<NominaUsuariosOficialView>(c => c.NominaID == oNomina.NominaID);
var oNominaOficialTotales = oNominaUsuariosOfV.GroupBy(c => c.UsuarioID).Select(c => new
{
UsuarioID = c.Key,
Ingreso = c.Where(s => s.Suma).Sum(s => s.Importe),
Egreso = c.Where(s => !s.Suma).Sum(s => s.Importe)
});
var oRep = new Report();
oRep.Load(UtilLocal.RutaReportes("Nomina.frx"));
oRep.RegisterData(new List<Nomina>() { oNomina }, "Nomina");
oRep.RegisterData(oNominaUsuariosV, "Usuarios");
oRep.RegisterData(oNominaUsuariosOfV, "UsuariosOficial");
oRep.RegisterData(oNominaOficialTotales, "UsuariosOficialTotales");
Cargando.Cerrar();
UtilLocal.EnviarReporteASalida("Reportes.Nomina.Salida", oRep);
this.LlenarNomina();
return true;
}
