public ActionResult Delete(Cuota cuota)
{
try
{
cuota.Motivo = "Delete Cuota";
CuotaData.bajaCuota(cuota);
return(Json(new { ok = true }));
}
catch (Exception e)
{
while (e.InnerException != null)
{
e = e.InnerException;
}
ViewBag.ErrorMessage = string.Format(Strings.ErrorEliminarRegistroPorIntegridad);
}
ViewBag.modo = "Delete";
string callback = Request.Params["callback"];
if (string.IsNullOrEmpty(callback))
{
callback = "AjaxOk";
}
ViewBag.Callback = callback;
PrepararViewBag(false, cuota);
return(PartialView("Cuota", cuota));
}
public ActionResult Delete(int?id)
{
if (id == null || !id.HasValue)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
string callback = Request.Params["callback"];
if (string.IsNullOrEmpty(callback))
{
callback = "AjaxOk";
}
ViewBag.Callback = callback;
ViewBag.modo = "Delete";
Cuota cuota = CuotaData.consultarCuota(id.Value);
if (cuota == null)
{
return(HttpNotFound());
}
PrepararViewBag(false, cuota);
return(View("Cuota", cuota));
}
/// <summary>
/// Alta de una nueva Cuota
/// </summary>
/// <param name="pFechaEmision"></param>
/// <param name="pMes"></param>
/// <param name="pAño"></param>
/// <param name="pDescripcion"></param>
/// <param name="pMonto"></param>
public void AltaCuota(string pMes, int pAño, string pDescripcion, float pMonto, int dniSocio)
{
var unSocio = this.iUnitOfWork.SocioRepository.Get(dniSocio);
var unaCuota = new Cuota(DateTime.Today.Date, pDescripcion, pMonto, pMes, pAño, unSocio);
unSocio.Cuotas.Add(unaCuota);
}
public Cuota ObtenerCuota(SqlDataReader resultadoConsultaSQL)
{
Cuota cuota;
//Creando variables locales para leer la cuota
string cuotaID, estado;
int periodo;
double saldo, amortizacion, interes;
DateTime fecha, fechaLimite;
//Asignando los valores de la cuota
cuotaID = resultadoConsultaSQL.GetString(0);
periodo = int.Parse(resultadoConsultaSQL.GetString(1));
saldo = resultadoConsultaSQL.GetDouble(2);
fecha = resultadoConsultaSQL.GetDateTime(3);
amortizacion = resultadoConsultaSQL.GetDouble(4);
interes = resultadoConsultaSQL.GetDouble(5);
fechaLimite = resultadoConsultaSQL.GetDateTime(6);
estado = resultadoConsultaSQL.GetString(7);
cuota = new Cuota(cuotaID, periodo, saldo, fecha, amortizacion, interes, fechaLimite, estado);
return cuota;
}
internal void ValidarCobroCuota(Cuota cuota)
{
if (cuota.MontoPagado < cuota.ValorCuota)
{
throw new FunctionalException("El valor pagado no puede ser menor al valor de la cuota.");
}
}
public List <Cuota> ObtenerCuotas()
{
string spName = "[Cuota_GetAll]";
List <Cuota> Cuotas = new List <Cuota>();
using (SqlConnection con = new SqlConnection(ConnectionString))
{
con.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandText = spName;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Connection = con;
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var Cuota = new Cuota
{
IdCuota = Convert.ToInt32(reader["IdCuota"]),
NroCuota = Convert.ToInt32(reader["NroCuota"]),
Descripcion = reader["Descripcion"].ToString(),
};
Cuotas.Add(Cuota);
}
}
}
return(Cuotas);
}
public void ProcesarCobro(Cuota cuota)
{
//Realizar Validacion
this.ValidarCobroCuota(cuota);
//Registra pago en CuotaCobrada
_cuotaCobradaService.RegistrarCobro(ref cuota);
}
private string reemplazarVariablesCuota(string texto, Cuota cuota)
{
if (!string.IsNullOrEmpty(texto))
{
if (texto.Contains("%NRO_CUOTA%"))
{
texto = texto.Replace("%NRO_CUOTA%", cuota.NroCuota.ToString());
}
if (texto.Contains("%TOTAL_CUOTAS%"))
{
texto = texto.Replace("%TOTAL_CUOTAS%", cuota.TotalCuota.ToString());
}
if (texto.Contains("%IMPORTE%"))
{
texto = texto.Replace("%IMPORTE%", cuota.Importe.ToString());
}
if (texto.Contains("%IMPORTE2%"))
{
texto = texto.Replace("%IMPORTE2%", cuota.Importe2.ToString());
}
if (texto.Contains("%FECHA_VENCIMIENTO%") && cuota.fechavto.HasValue)
{
texto = texto.Replace("%FECHA_VENCIMIENTO%", cuota.fechavto.Value.ToString("dd/MM/yyyy"));
}
if (texto.Contains("%FECHA_VENCIMIENTO2%") && cuota.fechavto2.HasValue)
{
texto = texto.Replace("%FECHA_VENCIMIENTO2%", cuota.fechavto2.Value.ToString("dd/MM/yyyy"));
}
}
return(texto);
}
public string insertar(Cuota oC)
{
try
{
comm = new SqlCommand("spInsertaCuota", con);
comm.CommandType = CommandType.StoredProcedure;
comm.Parameters.AddWithValue("@CodigoPrestamo", oC.Prestamo_Codigo1);
comm.Parameters.AddWithValue("@FechaCuota", oC.Cuota_Fecha1);
comm.Parameters.AddWithValue("@MontoCapital", oC.Cuota_MontoCap1);
comm.Parameters.AddWithValue("@InteresMensual", oC.Cuota_InteresMensual1);
comm.Parameters.AddWithValue("@ITF", oC.Cuota_Itf1);
comm.Parameters.AddWithValue("@ImporteTotalCuota", oC.Cuota_ImpTotalCuota1);
comm.Parameters.AddWithValue("@Cancelado", oC.Cuota_Cancelado1);
comm.Connection.Open();
comm.ExecuteNonQuery();
if (comm.Connection.State == ConnectionState.Open)
{
comm.Connection.Close();
}
return("OK");
}
catch (Exception ex)
{
return(ex.Message);
}
}
public void BajasCuotas(List <Cuota> cuotas)
{
Cuota cuota = new Cuota();
string motivo = "Baja Cursada - " + ApplicationUser.GetApellidoYNombre();
cuota.Motivo = motivo;
string[] nrof;
var httpClient = new HttpClient();
httpClient.BaseAddress = new Uri(ConfigurationManager.AppSettings["ServicioTeso"]);
httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
Convert.ToBase64String(System.Text.ASCIIEncoding.ASCII.GetBytes(ConfigurationManager.AppSettings["ServicioTesoUsuario"])));
List <KeyValuePair <string, object> > parametros = new List <KeyValuePair <string, object> >();
foreach (Cuota parcial in cuotas)
{
nrof = parcial.NroFactura.Split('_');
parametros.Add(new KeyValuePair <string, object>("origen", parcial.Origen.ToString()));
parametros.Add(new KeyValuePair <string, object>("id", int.Parse(nrof[0])));
parametros.Add(new KeyValuePair <string, object>("motivo", motivo));
var responseGet = httpClient.GetAsync("Cuota/BajaCuotaPorCursada" + Constantes.AsQueryString(parametros)).Result;
var respuesta = responseGet.Content.ReadAsAsync <bool>().Result;
if (responseGet.IsSuccessStatusCode == false)
{
throw new Exception("Error en servicio Tesoreria");
}
parametros.Clear();
}
}
public bool SaveCuota(Cuota Cuota)
{
string spName = "[Cuota_Save]";
bool respuesta = false;
try
{
using (SqlConnection con = new SqlConnection(ConnectionString))
{
con.Open();
SqlCommand cmd = new SqlCommand();
cmd.CommandText = spName;
cmd.CommandType = CommandType.StoredProcedure;
cmd.Connection = con;
cmd.Parameters.AddWithValue("@IdCuota", Cuota.IdCuota);
cmd.Parameters.AddWithValue("@NroCuota", Cuota.NroCuota);
cmd.Parameters.AddWithValue("@Descripcion", Cuota.Descripcion);
cmd.ExecuteNonQuery();
respuesta = true;
}
}
catch (Exception)
{
throw;
}
return(respuesta);
}
/// <summary>
/// Inserta las cuotas correspondiente al un prestamo
/// </summary>
/// <param name="oldcodigo">codigo de prestamo del archivo acces</param>
/// <param name="newcodigo">codigo de prestamo</param>
private void InsertarCuotasPrestamo(string oldcodigo, string newcodigo)
{
string sql = "SELECT codigo_prestamo, abono, fecha FROM T_Cuotas";
sql += " WHERE codigo_prestamo = '" + oldcodigo + "'";
OleDbDataReader dr = new OleDbCommand(sql, conex).ExecuteReader();
try
{
ConexionDB con = new ConexionDB();
if (dr.HasRows)
{
while (dr.Read())
{
double abono = Convert.ToDouble(dr.GetValue(1));
string codigo = newcodigo;
string fecha = dr.GetDateTime(2).ToShortDateString();
int numero = new Cuota().MaximaCuota() + 1;
string sql2 = " INSERT INTO tcuotas(abono, codigo_prestamo, fecha, numero)";
sql2 += " VALUES (" + abono + ", '" + codigo + "', '" + fecha + "', " + numero + ");";
con.Ejecutar(sql2);
}
}
}
catch (Exception ex)
{
MessageBox.Show("Error al momento de insertar una cuota: " + ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
public ActionResult Edit(int?id)
{
if (id == null || !id.HasValue)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
string callback = Request.Params["callback"];
if (string.IsNullOrEmpty(callback))
{
callback = "AjaxOk";
}
//var curso = new curso();
ViewBag.modo = "Edit";
ViewBag.Callback = callback;
Cuota cuota = CuotaData.consultarCuota(id.Value);
if (cuota == null)
{
return(HttpNotFound());
}
Session.Add("cuota_" + cuota.Id.ToString(), cuota);
PrepararViewBag(false, cuota);
return(View("Cuota", cuota));
}
public Cuota Buscar(string prm_C_Periodo, int prm_N_IdVivienda)
{
Cuota cuota = null;
try
{
using (DBMLPagosDataContext SQLDC = new DBMLPagosDataContext(conexion))
{
var resul = SQLDC.dsd_mnt_S_CuotaIdPeriodo(prm_C_Periodo, prm_N_IdVivienda);
foreach (var item in resul)
{
cuota = new Cuota()
{
N_IdCuota = item.N_IdCuota,
C_Periodo = item.C_Periodo,
N_IdVivienda = item.N_IdVivienda,
N_IdTipoPago = item.N_IdTipoPago,
N_Importe = item.N_Importe,
D_FecVncto = item.D_FecVncto,
D_FecPago = item.D_FecPago,
C_NumDeposito = item.C_NumDeposito
};
}
}
}
catch (Exception ex)
{
throw ex;
}
return(cuota);
}
public frmEdición(Cuota cuota) : this()
{
this.Text = "Edición de cuota";
txtNroCuota.Text = cuota.NroCuota.ToString();
dtVtoCuota.Value = cuota.VtoCuota;
txtPeríodo.Text = cuota.CicloLectivo.ToString();
}
private void btnRegistrar_Click(object sender, EventArgs e)
{
DialogResult resultado = MessageBox.Show("Desea Registrar el Prestamo", "", MessageBoxButtons.YesNo, MessageBoxIcon.Question);
if (resultado == DialogResult.Yes)
{
Prestamo oPrestamo = new Prestamo();
oPrestamo.CliDNI = (string)cmbClientes.SelectedValue;
oPrestamo.DesCodigo = (int)cmbDestinos.SelectedValue;
oPrestamo.PerCodigo = (int)cmbPeriodos.SelectedValue;
oPrestamo.PreFecha = dtpfecha.Value;
oPrestamo.PreImporte = Convert.ToDecimal(txtImporte.Text);
oPrestamo.PreCantidadCuotas = Convert.ToInt32(txtCantidadCuotas.Text);
oPrestamo.PreTasaInteres = Convert.ToDouble(txtTasaInteres.Text);
oPrestamo.PreEstado = "Iniciado";
TrabajarPrestamos.InsertarPrestamo(oPrestamo);
Cuota oCuota = new Cuota();
oCuota.CuoImporte = (oPrestamo.PreImporte * Convert.ToDecimal(oPrestamo.PreTasaInteres) / 100) + (oPrestamo.PreImporte / oPrestamo.PreCantidadCuotas);
oCuota.CuoEstado = "No Pagada";
DateTime fechaActual = oPrestamo.PreFecha;
for (int i = 0; i < oPrestamo.PreCantidadCuotas; i++)
{
oCuota.CuoNumero = i;
fechaActual.AddMonths(i);
oCuota.CuoVencimiento = fechaActual;
TrabajarCuotas.insertarCuota(oCuota);
}
MessageBox.Show("Prestamo Registrado", "", MessageBoxButtons.OK, MessageBoxIcon.Information);
this.Dispose();
}
}
public Cuota ColocarCuota(Cuota cuota)
{
// Validación de existencia de la vivienda
Vivienda vivienda = ViviendaDAO.Obtener(cuota.Vivienda.NumVivienda);
if (vivienda == null)
{
throw new Exception("Vivienda inexistente");
}
// Validación de existencia de una vivienda
ICollection <Cuota> cuotaExistente = CuotaDAO.obtenerCuotaPorViviendaPeriodo(cuota.Vivienda.NumVivienda, cuota.Anio, cuota.Mes);
if (cuotaExistente.Count > 0)
{
throw new Exception("Ya existe la Cuota");
}
Cuota cuotaACrear = new Cuota();
cuotaACrear.IdCuota = cuota.IdCuota;
cuotaACrear.Vivienda = cuota.Vivienda;
cuotaACrear.Mes = cuota.Mes;
cuotaACrear.Anio = cuota.Anio;
cuotaACrear.Importe = cuota.Importe;
cuotaACrear.FechaVencimiento = cuota.FechaVencimiento;
cuotaACrear.Estado = cuota.Estado;
return(CuotaDAO.Crear(cuotaACrear));
}
// Lógica de negocio
public Cuota PagarCuota(int numCuota, String tipoPago)
{
Cuota cuota = CuotaDAO.Obtener(numCuota);
if (cuota == null)
{
throw new Exception("La cuota no existe");
}
if (cuota.Estado.Equals("C"))
{
throw new Exception("La cuota ya se encuentra cancelada");
}
TransaccionPago transaccion = new TransaccionPago();
transaccion.Cuota = cuota;
transaccion.FechaOperacion = DateTime.Now;
transaccion.TipoPago = tipoPago;
transaccionPagoDAO.Crear(transaccion);
cuota.Estado = "C";
cuota = CuotaDAO.Modificar(cuota);
return(cuota);
}
public void Fill(CargarDatosContext datacontext)
{
baseFill(datacontext);
Departamento = datacontext.context.Departamento.FirstOrDefault(x => x.DepartamentoId == DepartamentoId);
Edificio = datacontext.context.Edificio.FirstOrDefault(x => x.EdificioId == EdificioId);
var cuotaAnterior = datacontext.context.Cuota.OrderByDescending(x => x.FechaRegistro).FirstOrDefault(x => x.DepartamentoId == DepartamentoId);
this.LecturaAguaAnterior = cuotaAnterior != null ? cuotaAnterior.LecturaAgua : 0;
if (CuotaId.HasValue)
{
Cuota cuota = datacontext.context.Cuota.FirstOrDefault(x => x.CuotaId == CuotaId.Value);
this.LecturaAgua = cuota.LecturaAgua;
this.ConsumoAgua = cuota.ConsumoAgua;
this.Monto = cuota.ConsumoMes;
this.Estado = cuota.Estado;
this.Monto = cuota.Monto;
this.Mora = cuota.Mora;
this.Total = cuota.Total;
this.Estado = cuota.Estado;
this.UnidadTiempoId = cuota.UnidadTiempoId;
this.FechaRegistro = cuota.FechaRegistro;
this.ConsumoSoles = cuota.ConsumoSoles;
this.AreaComun = cuota.AreaComun;
this.Alcantarillado = cuota.Alcantarillado;
this.CargoFijo = cuota.CargoFijo;
this.IGV = cuota.IGV;
this.ConsumoAguaTotal = cuota.ConsumoAguaTotal;
}
}
private void changeDets(Producto producto)
{
switch (opc)
{
case "Mensualidad":
lblPrecio.Text = "$" + producto.Precio;
Cuota cuota = CuotaDAL.getCuotaById((Int64)dgvProductos.CurrentRow.Cells[0].Value);
txtAporte.Text = (cuota.Precio - cuota.Total).ToString();
break;
case "Cancelacion":
if (dgvProductos.CurrentRow != null)
{
decimal totaldebe = DetFacturaDAL.getTotalDebeReserva((Int64)dgvProductos.CurrentRow.Cells[0].Value, IdPersona);
lblPrecio.Text = "$" + producto.Precio.ToString() + " - Pendiente $" + Decimal.Round(totaldebe, 2);
txtAporte.Text = Decimal.Round(totaldebe, 2).ToString();
txtDescuento.Text = "0.00";
}
break;
case "Contado":
lblPrecio.Text = "$" + producto.Precio;
txtAporte.Text = (producto.Precio).ToString();
break;
default: break;
}
}
private void button2_Click(object sender, EventArgs e)
{
if (this.checkBox1.Checked == false)
{
this.button3.Enabled = true;
this.textBox4.Enabled = true;
this._cuotasSeleccionadas.Clear();
bool band = false;
foreach (DataGridViewRow row in this.dataGridView1.SelectedRows)
{
Cuota c = (Cuota)row.DataBoundItem;
if (!c.Pagada)
{
_cuotasSeleccionadas.Add((Cuota)row.DataBoundItem);
}
else
{
band = true;
}
}
if (band)
{
MessageBox.Show("Se han omitido las cuotas pagadas");
}
this.presentador.calcularCuotasSeleccionadas();
}
}
private List <Cuota> listarCuotas(long numero)
{
Cuota pr = null;
List <Cuota> list = new List <Cuota>();
using (ProyectoEntities db = new ProyectoEntities())
{
var query = (from p in db.Cuota
where p.NumeroTCU == numero
select new
{
IDCu = p.IDCu,
ImporteCu = p.ImporteCu,
NumeroTCU = p.NumeroTCU,
}).ToList();
if (query != null)
{
foreach (var r in query)
{
pr = new Cuota();
pr.IDCu = r.IDCu;
pr.ImporteCu = r.ImporteCu;
pr.NumeroTCU = r.NumeroTCU;
list.Add(pr);
}
}
}
return(list);
}
public async Task <Cuota> CreateCuota(Cuota newCuota)
{
await _unitOfWork.Cuotas.AddAsync(newCuota);
await _unitOfWork.CommitAsync();
return(newCuota);
}
public ActionResult DeleteConfirmed(DateTime id)
{
Cuota cuota = db.Cuota.Find(id);
db.Cuota.Remove(cuota);
db.SaveChanges();
return(RedirectToAction("Index"));
}
public Cuota ActualizarCuota(Cuota cuota)
{
var cuotaAGuardar = _context.Cuotas.Where(c => c.CuotaId == cuota.CuotaId && c.PlanPagoId == cuota.PlanPagoId)
.FirstOrDefault();
cuotaAGuardar.EstadoCuota = cuota.EstadoCuota;
return(cuota);
}
public void RegistrarCobro(ref Cuota cuota)
{
//builder de objetos y llamada al servicio
var rq = Mapper.Map <RegistrarCobroCuotaRq>(cuota);
var rs = _cuotaCobradaService.RegistrarCobroCuota(rq);
Mapper.Map(rs, cuota);
}
private void txtAporte_Leave(object sender, EventArgs e)
{
txtAporte.Text = txtAporte.Text == "" || txtAporte.Text == "." || txtAporte.Text == "-0" ? "0.00" : txtAporte.Text;
if (Validation.Validation.Val_DecimalFormat(txtAporte.Text))
{
if (dgvProductos.CurrentRow != null)
{
switch (opc)
{
case "Mensualidad":
Cuota cuota = CuotaDAL.getCuotaById((Int64)dgvProductos.CurrentRow.Cells[0].Value);
if (Convert.ToDecimal(txtAporte.Text) > (cuota.Precio - cuota.Total))
{
txtAporte.Text = (cuota.Precio - cuota.Total).ToString();
}
if (Convert.ToDecimal(txtAporte.Text) < 0)
{
txtAporte.Text = "0.00";
}
break;
case "Cancelacion":
decimal totaldebe = DetFacturaDAL.getTotalDebeReserva((Int64)dgvProductos.CurrentRow.Cells[0].Value, IdPersona);
if (Convert.ToDecimal(txtAporte.Text) < 0)
{
txtAporte.Text = "0.00";
}
if (Convert.ToDecimal(txtAporte.Text) > totaldebe)
{
txtAporte.Text = Decimal.Round(totaldebe, 2).ToString();
}
break;
case "Contado":
Producto producto = ProductoDAL.getProductoById((Int64)dgvProductos.CurrentRow.Cells[0].Value);
txtAporte.Text = Convert.ToDecimal(txtAporte.Text) > producto.Precio ? (producto.Precio).ToString() : txtAporte.Text;;
if (Convert.ToDecimal(txtAporte.Text) < 0)
{
txtAporte.Text = "0.00";
}
break;
default: break;
}
}
valAporte.BackColor = Color.FromArgb(0, 100, 182);
errAporte.Clear();
}
else
{
errAporte.SetError(txtAporte, "El aporte no tiene un formato adecuado,\npor favor ingrese un numero entero o decimal.");
valAporte.BackColor = Color.Red;
}
}
//private IList<Persona> lClientes = new List<Persona>();
// private Persona iPersona;
// public GestorCliente()
// public DataSet pListaCliente = new DataSet();
public void AgregarCuota(string pEstado, int pNumeroCuota, DateTime pFechaPago, int pIdCuota, double pMonto)
{
/*/Persona Cliente = new Persona(pNombre,pApellido, pDni,pFechaNacimiento, pFechaIngreso,
* pAltura,pPeso, pEmail, pDireccion, pTelefono,pNumeroContacto,
* pTipoExperiencia,pHuellaDigital);
* lClientes.Add(Cliente);*/
Cuota.AgregarCuota(pEstado, pNumeroCuota, pFechaPago, pIdCuota, pMonto);
}
public void Test02MostrarCuota()
{
TransaccionService transaccionService = (TransaccionService)Spring.GetObject("transaccionService");
Cuota cuotaObtenida = transaccionService.MostrarCuota(1);
Assert.NotNull(cuotaObtenida);
Assert.AreEqual(cuotaObtenida.IdCuota, 1);
Assert.NotNull(cuotaObtenida.Mes);
}
public ActionResult Edit([Bind(Include = "FechaDelMes,Monto")] Cuota cuota)
{
if (ModelState.IsValid)
{
db.Entry(cuota).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(cuota));
}
//[TestMethod]
public void EliminarCuotaTest()
{
PagosServiceClient proxy = new PagosServiceClient();
RetornaMensaje retornaMensaje = null;
try
{
int pIdCuota = 6;
retornaMensaje = proxy.EliminarCuota(pIdCuota);
Assert.AreNotEqual(-1, retornaMensaje.CodigoRetorno);
Cuota cuotaEliminada = new Cuota();
cuotaEliminada = proxy.BuscarCuota(pIdCuota);
Assert.AreNotEqual(pIdCuota, cuotaEliminada.N_IdCuota);
}
catch (FaultException<RetornaMensajeT> exception)
{
Console.WriteLine("Error : {0}", exception.Detail.Mensage);
}
}
/// <summary>
/// Almacena el registro de una ENTIDAD de registro de Tipo Cuota
/// En la BASE de DATO la Tabla : [Gestion.Cuota]
/// <summary>
/// <param name = >itemCuota</param>
public int Actualizar(Cuota pcuota)
{
int codigoRetorno = -1;
try
{
using (DBMLPagosDataContext SQLDC = new DBMLPagosDataContext(conexion))
{
codigoRetorno = SQLDC.dsd_mnt_U_Cuota(
pcuota.N_IdCuota,
pcuota.N_Importe,
pcuota.D_FecVncto);
}
}
catch (Exception ex)
{
throw ex;
}
return codigoRetorno;
}
/// <summary>
/// Actualiza un registro de cuota de una vivienda del Condominio
/// </summary>
/// <param name="pIdCuota"></param>
/// <param name="pPeriodo"></param>
/// <param name="pIdVivienda"></param>
/// <param name="pIdTipoPago"></param>
/// <param name="pImporte"></param>
/// <param name="pFecVncto"></param>
/// <returns></returns>
public RetornaMensaje ActualizarCuota(int pIdCuota, string pPeriodo, int pIdVivienda, double pImporte, string pFecVncto)
{
try
{
retornaMensaje = new RetornaMensaje();
cuotaDAO = new CuotaDAO();
Cuota cuotaBuscar = null;
cuotaBuscar = cuotaDAO.Buscar(pPeriodo, pIdVivienda);
if (cuotaBuscar != null)
{
Cuota cuota = new Cuota
{
N_IdCuota = pIdCuota,
C_Periodo = pPeriodo,
N_IdVivienda = pIdVivienda,
N_Importe = Convert.ToDecimal(pImporte),
D_FecVncto = Convert.ToDateTime(pFecVncto)
};
retornaMensaje.CodigoRetorno = cuotaDAO.Actualizar(cuota);
retornaMensaje.Mensage = string.Format(resMensajes.msjGuardadoOK, "Cuota");
retornaMensaje.Exito = true;
}
else
{
retornaMensaje.CodigoRetorno = -1;
retornaMensaje.Mensage = string.Format(resMensajes.msjYaExiste, "Cuota");
retornaMensaje.Exito = false;
}
}
catch (Exception exception)
{
throw new FaultException<RetornaMensaje>
(new RetornaMensaje
{
Mensage = string.Format(resMensajes.msjNoRegistrado, "Cuota"),
CodigoError = exception.GetHashCode().ToString(),
Exito = false
}
, new FaultReason(exception.Message));
}
return retornaMensaje;
}
public void ActualizarCuotaTest()
{
PagosServiceClient proxy = new PagosServiceClient();
RetornaMensaje retornaMensaje = null;
Cuota cuotaRegistrada = new Cuota();
int pIdCuota = 24;
string pPeriodo = "201401";
int pIdVivienda = 2;
double pImporte = 150;
string pFecVncto = DateTime.Now.ToShortDateString();
try
{
retornaMensaje = proxy.ActualizarCuota(pIdCuota, pPeriodo, pIdVivienda, pImporte, pFecVncto);
Assert.AreNotEqual(1, retornaMensaje.CodigoRetorno);
}
catch (FaultException<RetornaMensajeT> exception)
{
Console.WriteLine("Error : {0}", exception.Detail.Mensage);
}
}
/// <summary>
/// Retorna una ENTIDAD de registro de la Entidad Gestion.Cuota
/// En la BASE de DATO la Tabla : [Gestion.Cuota]
/// <summary>
/// <returns>Entidad</returns>
public Cuota Buscar(int prm_N_IdCuota)
{
Cuota cuota = new Cuota();
try
{
using (DBMLPagosDataContext SQLDC = new DBMLPagosDataContext(conexion))
{
var resul = SQLDC.dsd_mnt_S_CuotaId(prm_N_IdCuota);
foreach (var item in resul)
{
cuota = new Cuota() { };
cuota.N_IdCuota = item.N_IdCuota;
cuota.C_Periodo = item.C_Periodo;
cuota.N_IdVivienda = item.N_IdVivienda;
cuota.objVivienda.C_NumDpto = item.C_NumDpto;
cuota.objVivienda.C_NumEdificio = item.C_NumEdificio;
cuota.objVivienda.objResidente.C_Apellidos = item.C_Propietario;
cuota.N_IdTipoPago = item.N_IdTipoPago;
cuota.N_Importe = item.N_Importe;
cuota.D_FecVncto = item.D_FecVncto;
cuota.D_FecPago = item.D_FecPago;
cuota.objTipoPago.C_Descripcion = item.V_IdTipoPago;
cuota.objVivienda.C_NumDpto = item.C_NumDpto;
cuota.objVivienda.C_NumEdificio = item.C_NumEdificio;
cuota.C_NumDeposito = item.C_NumDeposito;
}
}
}
catch (Exception ex)
{
throw ex;
}
return cuota;
}
/// <summary>
/// Permite buscar cuota por Id de registro
/// </summary>
/// <param name="pIdCuota"></param>
/// <returns></returns>
public Cuota BuscarCuota(int pIdCuota)
{
Cuota cuota = new Cuota();
try
{
cuotaDAO = new CuotaDAO();
cuota = cuotaDAO.Buscar(pIdCuota);
}
catch (Exception exception)
{
throw new FaultException<RetornaMensaje>
(new RetornaMensaje
{
Mensage = string.Format(resMensajes.msjNoBuscado, "Cuota"),
CodigoError = exception.GetHashCode().ToString(),
Exito = false
}
, new FaultReason(exception.Message));
}
return cuota;
}
/// <summary>
/// Permite eliminar Cuota por Id de Registro
/// </summary>
/// <param name="pIdCuota"></param>
/// <returns></returns>
public RetornaMensaje EliminarCuota(int pIdCuota)
{
retornaMensaje = new RetornaMensaje();
try
{
cuotaDAO = new CuotaDAO();
Cuota cuotaEliminar = new Cuota();
cuotaEliminar = cuotaDAO.Buscar(pIdCuota);
if (cuotaEliminar.N_IdCuota > 0)
{
cuotaDAO.Eliminar(pIdCuota);
retornaMensaje.CodigoRetorno = 0;
retornaMensaje.Mensage = string.Format(resMensajes.msjEliminadoOK, "Cuota");
retornaMensaje.Exito = true;
}
else
{
retornaMensaje.CodigoRetorno = -1;
retornaMensaje.Mensage = string.Format(resMensajes.msjNoBuscado, "Cuota");
retornaMensaje.Exito = false;
}
}
catch (Exception exception)
{
throw new FaultException<RetornaMensaje>
(new RetornaMensaje
{
Mensage = string.Format(resMensajes.msjNoEliminado, "Cuota"),
CodigoError = exception.GetHashCode().ToString(),
Exito = false
}
, new FaultReason(exception.Message));
}
return retornaMensaje;
}
public List<Cuota> ListarPorResidente(string pCorreoResidente)
{
List<Cuota> lstCuota = new List<Cuota>();
try
{
using (DBMLPagosDataContext SQLDC = new DBMLPagosDataContext(conexion))
{
var resul = SQLDC.dsd_mnt_S_CuotaPorResidente(pCorreoResidente);
foreach (var item in resul)
{
Cuota cuota = new Cuota();
cuota.N_IdCuota = item.N_IdCuota;
cuota.C_Periodo = item.C_Periodo;
cuota.N_IdVivienda = item.N_IdVivienda;
cuota.objVivienda.C_NumDpto = item.C_NumDpto;
cuota.objVivienda.C_NumEdificio = item.C_NumEdificio;
cuota.objVivienda.objResidente.C_Apellidos = item.C_Propietario;
cuota.N_IdTipoPago = item.N_IdTipoPago;
cuota.N_Importe = item.N_Importe;
cuota.D_FecVncto = item.D_FecVncto;
cuota.D_FecPago = item.D_FecPago;
cuota.objTipoPago.C_Descripcion = item.V_IdTipoPago;
cuota.objVivienda.C_NumDpto = item.C_NumDpto;
cuota.objVivienda.C_NumEdificio = item.C_NumEdificio;
cuota.C_NumDeposito = item.C_NumDeposito;
lstCuota.Add(cuota);
}
}
}
catch (Exception ex)
{
throw ex;
}
return lstCuota;
}
public int PagarCuota(Cuota pcuota)
{
int codigoRetorno = -1;
try
{
using (DBMLPagosDataContext SQLDC = new DBMLPagosDataContext(conexion))
{
codigoRetorno = SQLDC.dsd_mnt_U_CuotaPago(
pcuota.N_IdCuota,
pcuota.D_FecPago,
pcuota.N_IdTipoPago,
pcuota.C_NumDeposito);
}
}
catch (Exception ex)
{
throw ex;
}
return codigoRetorno;
}
public void RegistrarCuotaTest()
{
PagosServiceClient proxy = new PagosServiceClient();
RetornaMensaje retornaMensaje = null;
Cuota cuotaRegistrada = new Cuota();
string C_Periodo = "201402";
int N_IdVivienda = 3;
decimal N_Importe = 120;
string D_FecVncto = DateTime.Now.ToShortDateString();
try
{
retornaMensaje = proxy.RegistrarCuota(C_Periodo, N_IdVivienda, Convert.ToDouble(N_Importe), D_FecVncto);
Assert.AreNotEqual(0, retornaMensaje.CodigoRetorno);
}
catch (FaultException<RetornaMensajeT> exception)
{
Console.WriteLine("Error : {0}", exception.Detail.Mensage);
}
}
public Cuota Buscar(string prm_C_Periodo, int prm_N_IdVivienda)
{
Cuota cuota = null;
try
{
using (DBMLPagosDataContext SQLDC = new DBMLPagosDataContext(conexion))
{
var resul = SQLDC.dsd_mnt_S_CuotaIdPeriodo(prm_C_Periodo, prm_N_IdVivienda);
foreach (var item in resul)
{
cuota = new Cuota()
{
N_IdCuota = item.N_IdCuota,
C_Periodo = item.C_Periodo,
N_IdVivienda = item.N_IdVivienda,
N_IdTipoPago = item.N_IdTipoPago,
N_Importe = item.N_Importe,
D_FecVncto = item.D_FecVncto,
D_FecPago = item.D_FecPago,
C_NumDeposito = item.C_NumDeposito
};
}
}
}
catch (Exception ex)
{
throw ex;
}
return cuota;
}
/// <summary>
/// Almacena el registro de una ENTIDAD de registro de Tipo Cuota
/// En la BASE de DATO la Tabla : [Gestion.Cuota]
/// <summary>
/// <param name = >pcuota</param>
public int Registrar(Cuota pcuota)
{
int? codigoRetorno = -1;
try
{
using (DBMLPagosDataContext SQLDC = new DBMLPagosDataContext(conexion))
{
SQLDC.dsd_mnt_I_Cuota(
ref codigoRetorno,
pcuota.C_Periodo,
pcuota.N_IdVivienda,
pcuota.N_Importe,
pcuota.D_FecVncto);
}
}
catch (Exception ex)
{
throw ex;
}
return codigoRetorno == null ? 0 : codigoRetorno.Value;
}