private bool UpdateAnular(ref Transferencia Item)
{
try
{
if (Item.Instance == Infrastructure.Aspect.BusinessEntity.InstanceEntity.Modified)
{
DataAccessEnterpriseSQL.DAAsignarProcedure("CAJ_TRANSU_UnRegAnular");
DataAccessEnterpriseSQL.DAAgregarParametro("@psinEMPR_Codigo", Item.EMPR_Codigo, SqlDbType.SmallInt, 2, ParameterDirection.Input);
DataAccessEnterpriseSQL.DAAgregarParametro("@pintTRAN_Codigo", Item.TRAN_Codigo, SqlDbType.Int, 4, ParameterDirection.Input);
DataAccessEnterpriseSQL.DAAgregarParametro("@pchrTRAN_Estado", Item.TRAN_Estado, SqlDbType.Char, 1, ParameterDirection.Input);
DataAccessEnterpriseSQL.DAAgregarParametro("@pvchAUDI_UsrMod", Item.AUDI_UsrMod, SqlDbType.VarChar, 20, ParameterDirection.Input);
if (DataAccessEnterpriseSQL.DAExecuteNonQuery() > 0)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(true);
}
}
catch (Exception)
{ throw; }
}
private void btnGuardar_Click(object sender, EventArgs e)
{
try
{
this.txtMensajeError.Visible = false;
List <Error> Errores = this.ValidarErrores();
if (Errores.Count == 0)
{
Transferencia Datos = this.ObtenerDatos();
Inventario_Negocio IN = new Inventario_Negocio();
IN.TransferenciaInventario(Datos);
if (Datos.Completado)
{
MessageBox.Show("Datos guardados correctamente.", Comun.Sistema, MessageBoxButtons.OK, MessageBoxIcon.Information);
this.DialogResult = DialogResult.OK;
}
else
{
MessageBox.Show("Ocurrió un error al guardar los datos. Intente nuevamente.", Comun.Sistema, MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
}
else
{
this.MostrarMensajeError(Errores);
}
}
catch (Exception ex)
{
LogError.AddExcFileTxt(ex, "frmInventarioTransferencia ~ btnCancelar_Click");
MessageBox.Show(Comun.MensajeError, Comun.Sistema, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
}
/// <summary>
/// Save Transferencia
/// </summary>
/// <param name="transferencia"></param>
/// <param name="transaction"></param>
public void SaveTransferencia(Transferencia transferencia, out TransactionalInformation transaction)
{
transaction = new TransactionalInformation();
try
{
TransferenciaBusinessRules transferenciaBusinessRules = new TransferenciaBusinessRules(transferencia);
ValidationResult results = transferenciaBusinessRules.Validate(transferencia);
bool validationSucceeded = results.IsValid;
IList <ValidationFailure> failures = results.Errors;
if (validationSucceeded == false)
{
transaction = ValidationErrors.PopulateValidationErrors(failures);
}
else
{
ITransferenciaDataService iTransferenciaDataService = new TransferenciaDataService();
iTransferenciaDataService.SaveTransferencia(transferencia);
transaction.ReturnMessage.Add("Transferencia realizada con éxito.");
transaction.ReturnStatus = true;
}
}
catch (Exception ex)
{
string errorMessage = ex.Message;
transaction.ReturnMessage.Add(errorMessage);
transaction.ReturnStatus = false;
}
}
public void FazerOperacaoCorretamente()
{
var movimentacao = new Transferencia(100, "000.000.000-00");
Assert.AreEqual(movimentacao.Valor, 100);
Assert.AreEqual(movimentacao.TipoEvento, TipoMovimentacao.Transferencia);
}
public List <Transferencia> listarTransferencias(metodoPago p)
{
List <Transferencia> listado = new List <Transferencia>();
AccesoDatosManager accesoDatos = new AccesoDatosManager();
Transferencia t;
try
{
accesoDatos.setearConsulta("select t.importe,c.nombre,t.id,t.banco,t.numeroTransferencia from transferencias as t inner join clientes c on c.id=t.idCliente where t.id=" + p.id);
accesoDatos.abrirConexion();
accesoDatos.ejecutarConsulta();
while (accesoDatos.Lector.Read())
{
t = new Transferencia();
t.cliente = new Cliente();
t.cliente.nombre = accesoDatos.Lector["nombre"].ToString();
t.id = (long)accesoDatos.Lector["id"];
t.importe = (decimal)accesoDatos.Lector["importe"];
t.Banco = accesoDatos.Lector["banco"].ToString();
t.numeroTransferencia = accesoDatos.Lector["numeroTransferencia"].ToString();
listado.Add(t);
}
return(listado);
}
catch (Exception ex)
{
throw ex;
}
finally
{
accesoDatos.cerrarConexion();
}
}
public IHttpActionResult PostTransferencia(Transferencia transferencia)
{
int idUser = Convert.ToInt32(Thread.CurrentPrincipal.Identity.Name);
//Encontra a conta do usuário autor da transferência
Conta contaOrigem = db.Contas.AsNoTracking().Where(a => a.UsuarioId == idUser).FirstOrDefault();
if (contaOrigem.Saldo < transferencia.Valor)
{
return(BadRequest("Saldo Insuficiente para Transferência"));
}
transferencia.ContaOrigemId = contaOrigem.Id;
transferencia.Data = DateTime.Now;
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Transferencias.Add(transferencia);
db.SaveChanges();
AtualizaSaldo(transferencia.ContaOrigemId, transferencia.ContaDestinoId, transferencia.Valor);
return(CreatedAtRoute("DefaultApi", new { id = transferencia.Id }, transferencia));
}
private void button2_Click(object sender, EventArgs e)
{
int id_cliente = Convert.ToInt32(gridClientesDisponibles.CurrentRow.Cells[0].Value);
Cliente cliente = d.getClientePorID(id_cliente);
//adjudicar
Cuenta cuenta = new Cuenta();
cuenta.Cliente = id_cliente;
cuenta.Ejecutivo = ejec.Id;
cuenta.NumCuenta = d.generarNumeroCuenta();
cuenta.Saldo = "0";
d.registrarCuenta(cuenta);
cuenta.Id = d.getIDCuenta();
//d.RegistrarTarjetaTranferenciaCliente
Transferencia trans = new Transferencia();
trans.Monto = d.generarSaldo(cliente); //definir segun edad
trans.CuentaOrigen = Cuenta.ADMIN;
trans.CuentaDestino = cuenta.Id;
trans.Comentario = "Abono inicial";
trans.Tipo = Transferencia.ABONO;
d.realizarTransferencia(trans);
//d.enviarMensaje();
cargarClientesDisponibles();
cargarClientes(ejec);
}
public string add_Transferencia(Int32 id_solicitud,
double rut_vendedor,
double rut_comprador,
double rut_compra_para,
Int32 id_sucursal,
string tag,
string tipo_transferencia,
string financiamiento = "0",
string forma_pago = "0"
)
{
Transferencia mtran = new Transferencia();
mtran.Vendedor = new PersonaDAC().getpersonabyrut(rut_vendedor);
mtran.Comprador = new PersonaDAC().getpersonabyrut(rut_comprador);
mtran.Compra_para = new PersonaDAC().getpersonabyrut(rut_compra_para);
mtran.Id_sucursal = id_sucursal;
mtran.Banco_financiera = new BancofinancieraBC().getBancofinanciera(financiamiento);
mtran.Forma_pago = forma_pago;
mtran.Tag = tag;
mtran.Tipo_Transferencia = tipo_transferencia;
string add = new TransferenciaDAC().add_Transferencia(mtran, id_solicitud);
return(add);
}
public bool AprobarTransferencia(Transferencia transferencia)
{
using (LealtadEntities db = new LealtadEntities())
{
db.Database.Connection.ConnectionString = AppModule.ConnectionString("SumaLealtad");
Order orden = db.Orders.Find(transferencia.id);
List<OrdersDetail> ordersdetails = db.OrdersDetails.Where(x => x.orderid == orden.id).ToList();
foreach (OrdersDetail od in ordersdetails)
{
OrdersDetail od2 = db.OrdersDetails.Find(od.id, od.orderid);
od2.sumastatusid = db.SumaStatuses.FirstOrDefault(s => (s.value == Globals.ID_ESTATUS_DETALLEORDEN_APROBADO) && (s.tablename == "OrdersDetail")).id;
}
//Actualizar estatus y monto de la Orden
orden.sumastatusid = db.SumaStatuses.FirstOrDefault(s => (s.value == Globals.ID_ESTATUS_ORDEN_APROBADA) && (s.tablename == "Orders")).id;
orden.totalamount = 0;
orden.processdate = DateTime.Now;
//Entidad OrderHistory
int idOrderHistory = repOrden.OrdersHistoryId();
OrdersHistory orderhistory = new OrdersHistory()
{
id = idOrderHistory,
orderid = orden.id,
estatusid = orden.sumastatusid,
userid = (int)HttpContext.Current.Session["userid"],
creationdate = orden.processdate,
comments = "orden aprobada"
};
db.OrdersHistories.Add(orderhistory);
db.SaveChanges();
return true;
}
}
public HttpResponseMessage Delete([FromUri] Transferencia t)
{
TransferenciaDAO dao = new TransferenciaDAO();
dao.Remover(t);
return(Request.CreateResponse(HttpStatusCode.OK, "Transferencia Excluida!"));
}
public HttpResponseMessage Put([FromBody] Transferencia t)
{
TransferenciaDAO dao = new TransferenciaDAO();
string valida = t.ValidaCampoDt();
if (valida != "")
{
ModelState.AddModelError("Transferencia", valida);
}
if (ModelState.IsValid)
{
var i = dao.Atualizar(t);
if (i > 0)
{
return(Request.CreateResponse(HttpStatusCode.OK, i));
}
else
{
return(Request.CreateResponse(HttpStatusCode.OK, "Nenhuma linha foi alterada!"));
}
}
else
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public CorreoTransferencia getCorreoTransferencia(Transferencia trans)
{
CorreoTransferencia correo = new CorreoTransferencia();
query = "exec correoTransferencia " + trans.Id;
conexion.ejecutar(query);
Cliente clienteOrigen = new Cliente();
Cliente clienteDestino = new Cliente();
if (conexion.rs.Read())
{
clienteOrigen = getClientePorID(Convert.ToInt32(conexion.rs[1]));
clienteDestino = getClientePorID(Convert.ToInt32(conexion.rs[2]));
correo.MontoTransferencia = conexion.rs[3].ToString();
correo.NumeroCuenta_origen = conexion.rs[4].ToString();
correo.NumeroCuenta_destino = conexion.rs[4].ToString();
correo.Comentario_Transferencia = conexion.rs[5].ToString();
correo.NombreCliente_origen = clienteOrigen.NombreCompleto;
correo.NombreCliente_destino = clienteDestino.NombreCompleto;
correo.RutCliente_origen = clienteOrigen.Rut;
correo.RutCliente_destino = clienteDestino.Rut;
correo.DireccionCliente_origen = clienteOrigen.Correo;
correo.DireccionCliente_destino = clienteDestino.Correo;
}
conexion.cerrar();
return(correo);
}
//realizar transferencia
public void realizarTransferencia(Transferencia trans)
{
//query = "insert into transferencia values('"+trans.Monto+"', getDate(), "+trans.CuentaOrigen+", "+trans.CuentaDestino+", "+trans.Tipo+", '"+trans.Comentario+"')";
query = "exec realizarTransferencia '" + trans.Monto + "' , " + trans.CuentaOrigen + " ," + trans.CuentaDestino + " , " + trans.Tipo + " , '" + trans.Comentario + "'";
Console.WriteLine(query);
conexion.ejecutar(query);
}
public void FazerTransferencia([FromBody] TransferenciaPost transrefenciaPost)
{
Transferencia.FazerTranferecia(
transrefenciaPost.clienteRemetenteId,
transrefenciaPost.clienteDestinatarioId,
transrefenciaPost.valor);
}
public ActionResult InserirTransferencia()
{
var contas = _contaService.ObterContas().Result;
ViewData["Transferencia"] = new Transferencia().SetarContas(contas);
return(ViewComponent("MovimentacaoTransferenciaFicha", new { maxPriority = 3, isDone = false }));
}
public ActionResult Create(Transferencia transferencia, int IDContaOrigem, int IDContaDestino)
{
if (ModelState.IsValid)
{
if (transferenciaBusiness.VerificaSaldo(IDContaOrigem) >= transferencia.Valor)
{
transferenciaBusiness.Debitar(IDContaOrigem, transferencia.Valor);
transferenciaBusiness.Creditar(IDContaDestino, transferencia.Valor);
transferencia.UserId = User.Identity.Name;
transferencia.IDOrigem = IDContaOrigem;
transferencia.IDDestino = IDContaDestino;
transferenciaBusiness.Salvar(transferencia);
}
else
{
ViewBag.SaldoInsuficiente = "Saldo Insuficiente";
ViewBag.IDContaOrigem = new SelectList(transferenciaBusiness.ListarContas(User.Identity.Name), "IDConta", "Nome", IDContaOrigem);
ViewBag.IDContaDestino = new SelectList(transferenciaBusiness.ListarContas(User.Identity.Name), "IDConta", "Nome", IDContaDestino);
//return View(transferencia);
return(RedirectToAction("../Dashboard/Transferencias"));
}
return(RedirectToAction("../Dashboard/Transferencias"));
}
ViewBag.IDContaOrigem = new SelectList(transferenciaBusiness.ListarContas(User.Identity.Name), "IDConta", "Nome", IDContaOrigem);
ViewBag.IDContaDestino = new SelectList(transferenciaBusiness.ListarContas(User.Identity.Name), "IDConta", "Nome", IDContaDestino);
return(View(transferencia));
}
public IHttpActionResult PutTransferencia(int id, Transferencia transferencia)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != transferencia.Id)
{
return(BadRequest());
}
db.Entry(transferencia).State = EntityState.Modified;
try
{
db.SaveChanges();
}
catch (DbUpdateConcurrencyException)
{
if (!TransferenciaExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(StatusCode(HttpStatusCode.NoContent));
}
public Boolean Save(ref Transferencia Item, Transferencia.TOperacion x_opcion)
{
try
{
Boolean m_isCorrect = true;
switch (x_opcion)
{
case Transferencia.TOperacion.Normal:
m_isCorrect = Save(ref Item);
break;
case Transferencia.TOperacion.Eliminar:
m_isCorrect = SaveEliminar(ref Item);
break;
case Transferencia.TOperacion.Anular:
m_isCorrect = SaveAnular(ref Item);
break;
default:
break;
}
return(m_isCorrect);
}
catch (Exception)
{ throw; }
}
public async void Salvar(Transferencia transferencia)
{
var empresa = _empresaService.ObterEmpresas().Result.FirstOrDefault();
var lancamentoCaixaOrigem = await _caixaService.ObterPorId(transferencia.TransferenciaOrigem.IdCaixa) ?? new Caixa();
lancamentoCaixaOrigem.DataCompetencia = transferencia.DataTransferencia;
lancamentoCaixaOrigem.IdConta = transferencia.TransferenciaOrigem.IdConta;
lancamentoCaixaOrigem.NomeConta = transferencia.TransferenciaOrigem.NomeConta;
lancamentoCaixaOrigem.IdEmpresa = empresa.Id;
lancamentoCaixaOrigem.Descricao = "Transferência entre contas";
lancamentoCaixaOrigem.Debito = transferencia.Valor;
_caixaService.Salvar(lancamentoCaixaOrigem);
transferencia.TransferenciaOrigem.IdCaixa = lancamentoCaixaOrigem.Id;
var lancamentoCaixaDestino = await _caixaService.ObterPorId(transferencia.TransferenciaDestino.IdCaixa) ?? new Caixa();
lancamentoCaixaDestino.DataCompetencia = transferencia.DataTransferencia;
lancamentoCaixaDestino.IdConta = transferencia.TransferenciaDestino.IdConta;
lancamentoCaixaDestino.NomeConta = transferencia.TransferenciaDestino.NomeConta;
lancamentoCaixaDestino.IdEmpresa = empresa.Id;
lancamentoCaixaDestino.Descricao = "Transferência entre contas";
lancamentoCaixaDestino.Credito = transferencia.Valor;
_caixaService.Salvar(lancamentoCaixaDestino);
transferencia.TransferenciaDestino.IdCaixa = lancamentoCaixaDestino.Id;
SalvarTransferencia(transferencia);
}
public IHttpActionResult PostTransferencia(Transferencia transferencia)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
db.Transferencia.Add(transferencia);
try
{
db.SaveChanges();
}
catch (DbUpdateException e)
{
if (TransferenciaExists(transferencia.CRDestino, transferencia.FuncionarioMatricula))
{
return(Conflict());
}
else
{
throw e;
}
}
return(CreatedAtRoute("DefaultApi", new { id = transferencia.CRDestino }, new TransferenciaDTO(transferencia)));
}
public async Task <Transferencia> Ingresar(int cli_cod_cliente, int cuentaOrigen, int cuentaDestino, string descripcion, string estado,
DateTime fecha, decimal monto)
{
Transferencia transferencia = new Transferencia()
{
tra_cod_transferencia = 0,
cli_cod_cliente = cli_cod_cliente,
tra_cuenta_origen = cuentaOrigen,
tra_cuenta_destino = cuentaDestino,
tra_descripcion = descripcion,
tra_estado = "A",
tra_fecha = fecha,
tra_monto = monto
};
ServicePointManager.ServerCertificateValidationCallback = delegate { return(true); };
HttpClient client = GetClient();
var response = await client.PostAsync(Url,
new StringContent(
JsonConvert.SerializeObject(transferencia),
Encoding.UTF8, "application/json"));
return(JsonConvert.DeserializeObject <Transferencia>(
await response.Content.ReadAsStringAsync()));
}
protected void dgTransferencias_ItemCommand(object sender, DataGridCommandEventArgs e)
{
if (e.CommandName == "Viu")
{
Label lbltransId = (Label)e.Item.FindControl("lblTransId");
Guid transId = new Guid(lbltransId.Text);
try
{
Calendario cal = (Calendario)Session["Calendario"];
Transferencia trans = transBO.GetTransferencia(transId, cal);
trans.FoiVisualizada = true;
transBO.TransferenciaUpdate(trans);
VerificaTransferencias();
}
catch (Exception)
{
Response.Redirect("~/Default/Erro.aspx?Erro=Erro ao visualizar uma transferência.");
}
}
}
public Transferencia ValidarTransferencia(Int32 rut_comprador, string patente)
{
try
{
using (SqlConnection sqlConn = new SqlConnection(this.strConn))
{
sqlConn.Open();
SqlCommand cmd = new SqlCommand(strConn, sqlConn);
cmd.CommandType = System.Data.CommandType.StoredProcedure;
cmd.CommandText = "sp_r_validar_transferencia";
cmd.Parameters.AddWithValue("@rut_comprador", rut_comprador);
cmd.Parameters.AddWithValue("@patente", patente);
SqlDataReader reader = cmd.ExecuteReader();
Transferencia mtransferencia = new Transferencia();
if (reader.Read())
{
mtransferencia.Validacion = reader["validacion"].ToString();
}
else
{
mtransferencia = null;
}
return(mtransferencia);
}
}
catch (Exception ex)
{
throw ex;
}
}
public void Efetivar(Transferencia transferencia)
{
var conta = contaServico.ObterConta(transferencia.ContaId);
realizarOperacaoPeloTipo[(int)transferencia.TipoMovimentacao](conta, transferencia.Valor);
operacaoServico.MarcarEfetivada(transferencia);
}
public async Task RealizarTransferenciaAsync(RealizarTransferenciaViewModel model)
{
var transferencia = new Transferencia(model.Origem, model.Destino, model.Valor);
transferencia.Validar();
await repositorioTransferencia.TransferirAsync(transferencia);
}
public TransferenciaDTO(Transferencia t)
{
if (t == null)
{
return;
}
CRDestino = t.CRDestino;
FuncionarioMatricula = t.FuncionarioMatricula;
MesTransferencia = t.MesTransferencia;
DataSolicitacao = t.DataSolicitacao;
Status = t.Status;
Aprovado = t.Aprovado;
Resposta = t.Resposta;
CROrigem = t.CROrigem;
if (t.Funcionario != null)
{
Cargo = t.Funcionario.Variaveis.Cargo.NomeCargo;
NomeFuncionario = t.Funcionario.Nome;
Salario = t.Funcionario.Salario;
}
if (t.MesOrcamento != null)
{
MesTransferenciaData = t.MesOrcamento.Mes;
}
}
public List <Ativo> BuscarAtivos(Transferencia t)
{
b.getComandoSQL().Parameters.Clear();
b.getComandoSQL().CommandText = @"select a.ati_codigo, a.ati_placa, a.ati_descricao, a.ati_estado, a.ati_observacao, a.ati_tag, a.ati_marca,
a.ati_modelo, a.ati_numeroserie, a.ati_stativo, a.ati_valor, tp.tpa_codigo, tp.tpa_descricao, tp.tpa_valor, s.sal_codigo, s.sal_descricao, a.nt_codigo, a.ve_codigo
from Ativos a
inner join Tipo_Ativo tp on tp.tpa_codigo = a.tpa_codigo
left outer join Sala s on s.sal_codigo = a.sal_codigo
inner join itens_ativos ia on a.ati_codigo = ia.ati_codigo
left outer join veiculos v on v.ve_codigo = a.ve_codigo
where ia.transf_codigo = @transf;";
b.getComandoSQL().Parameters.AddWithValue("@transf", t.GetCodigo());
DataTable dt = b.ExecutaSelect();
if (dt.Rows.Count > 0)
{
return(TableToList(dt));
}
else
{
return(null);
}
}
public ActionResult Transferencia(Transferencia transferencia)
{
try
{
Conta contaDebito = new Conta()
{
Agencia = transferencia.AgenciaDebito,
Numero = transferencia.NumeroDebito
};
Conta contaCredito = new Conta()
{
Agencia = transferencia.AgenciaCredito,
Numero = transferencia.NumeroCredito
};
DBHelper Helper = new DBHelper();
contaDebito = Helper.ObterConta(contaDebito);
contaCredito = Helper.ObterConta(contaCredito);
if (Helper.ValidarTransferenciaSaldo(contaDebito, transferencia.ValorTransferencia))
{
Helper.RealizarDebito(contaDebito, transferencia.ValorTransferencia);
Helper.RealizarCredito(contaCredito, transferencia.ValorTransferencia);
}
}
catch (Exception ex)
{
return(View());
}
return(View());
}
public void agregarTransferencia(Transferencia transferencia, Cliente cliente, int idpago)
{
SqlConnection conexion = new SqlConnection();
SqlCommand comando = new SqlCommand();
try
{
conexion.ConnectionString = AccesoDatosManager.cadenaConexion;
comando.CommandType = System.Data.CommandType.Text;
//MSF-20190420: le agregué todas las columnas. Teniendo en cuenta inclusive lo que elegimos en el combo de selección..
comando.CommandText = "insert into TRANSFERENCIAS (importe,idCliente,idPago,banco,numeroTransferencia,activo) values";
comando.CommandText += "('" + transferencia.importe.ToString().Replace(",", ".") + "','" + cliente.id + "','" + idpago + "','" + transferencia.Banco + "','" + transferencia.numeroTransferencia + "', '" + "1" + "')";
comando.Connection = conexion;
conexion.Open();
comando.ExecuteNonQuery();
}
catch (Exception ex)
{
throw ex;
}
finally
{
conexion.Close();
}
}
public bool Receber(int Codigo, string Obs, int[] Ativos, string[] Imgs, int pessoa, string Latitude, string Longitude, int[] Salas)
{
Localizacao loc = new Localizacao(Latitude, Longitude, 0);
Transferencia transf = new Transferencia()
{
AprovacaoDestino = new Aprovacao()
{
Observacao = Obs, Responsável = new Pessoa(pessoa)
},
AprovacaoGerente = null
};
transf.SetCodigo(Codigo);
transf.AprovacaoDestino.Status = true;
transf.AprovacaoDestino.DataInsercao = DateTime.Now;
List <Ativo> Atvs = new List <Ativo>();
for (int i = 0; i < Ativos.Length; i++)
{
Atvs.Add(new Ativo(Ativos[i]));
Atvs[i].Imagens.Add(new Imagem(0, Imgs[i], Ativos[i]));
Atvs[i].SetSala(new Sala(Salas[i]));
}
transf.AprovacaoDestino.Ativos = Atvs;
return(transf.Receber(loc));
}
public void CalcularSaldoDeListaDeMovimentacoes()
{
var listaMovimentacoes = new List <Movimentacao>();
var numeroDeDepositos = 5;
var numeroDeSaques = 3;
var numeroDeTransferencias = 4;
var deposito = new Deposito(500.50);
for (var i = 0; i < numeroDeDepositos; i++)
{
listaMovimentacoes.Add(deposito);
}
var saque = new Saque(10.82);
for (var i = 0; i < numeroDeSaques; i++)
{
listaMovimentacoes.Add(saque);
}
var transferencia = new Transferencia(50.32, "000.000.000-00");
for (var i = 0; i < numeroDeTransferencias; i++)
{
listaMovimentacoes.Add(transferencia);
}
var valorSaldoTeste =
(deposito.Valor - deposito.CustoTaxaDeMovimentacao) * numeroDeDepositos +
(-1 * (saque.Valor + saque.CustoTaxaDeMovimentacao)) * numeroDeSaques +
(-1 * (transferencia.Valor + transferencia.CustoTaxaDeMovimentacao)) * numeroDeTransferencias;
Assert.AreEqual(new CalculadoraSaldo(listaMovimentacoes).ObterSaldo(), valorSaldoTeste);
}
public static Transferencia ExecutarTransferencia(ContaCorrente contaOrigem, ContaCorrente contaDestino, decimal valor)
{
Transferencia transacao;
if (contaOrigem.Ativa && contaDestino.Ativa)
{
transacao = new Transferencia(contaOrigem, contaDestino, valor);
transacao.Executa();
RepositorioTransacaoBancaria.Adicionar(transacao);
}
else
{
throw new InvalidOperationException("Conta bloqueada ou saldo insuficiente!");
}
return transacao;
}
public void InsereTransferencia(Transferencia trans)
{
try
{
dao.InsereTransferencia(trans);
//MembershipUser user = Membership.GetUser();
//LogEntry log = new LogEntry();
//log.Message = "; Id: " + trans.Id + "; Usuário: " + user.UserName;
//log.TimeStamp = DateTime.Now;
//log.Severity = TraceEventType.Information;
//log.Title = "Insert Transferência";
//log.MachineName = Dns.GetHostName();
//Logger.Write(log);
}
catch (DataAccessException)
{
throw;
}
}
public Transferencia DetalleParaOrdenAnulacionTransferencia(int orden)
{
Transferencia transferencia = new Transferencia();
using (LealtadEntities db = new LealtadEntities())
{
db.Database.Connection.ConnectionString = AppModule.ConnectionString("SumaLealtad");
//verificar que es orden de transferencia
Order order = db.Orders.Find(orden);
//orden no encontrada
if (order == null)
{
return null;
}
//orden no es de transferencia
if (order.comments != "Orden de Transferencia")
{
return null;
}
//verificar que la orden de transferencia este procesada
if (order.sumastatusid != db.SumaStatuses.FirstOrDefault(s => (s.value == Globals.ID_ESTATUS_ORDEN_PROCESADA) && (s.tablename == "Orders")).id)
{
transferencia.tipoOrden = "No ha sido procesada";
return transferencia;
}
//verificar que esa orden no tenga anulación
var q = (from od in db.OrdersDetails
where od.orderid.Equals(orden)
select od).ToList();
foreach (var o in q)
{
var query = (from od in db.OrdersDetails
join or in db.Orders on od.orderid equals or.id
where (od.comments.Equals(o.cardsresponse) || od.comments.Equals("Anulación efectiva " + o.cardsresponse))
&& or.comments == "Orden de Anulación de Transferencia"
&& od.amount != 0
select od).ToList();
if (query.Count > 0)
{
transferencia.tipoOrden = "Ya tiene Anulación";
return transferencia;
}
}
//buscar detalle para crear orden de anulación
{
transferencia = FindTransferencia(orden);
return transferencia;
}
}
}
public void InsereTransferencia(Transferencia trans)
{
try
{
DbCommand cmd = baseDados.GetStoredProcCommand("TransfereciaInsert");
baseDados.AddInParameter(cmd, "@Id", DbType.Guid, trans.Id);
baseDados.AddInParameter(cmd, "@RecursoId", DbType.Guid, trans.Recurso.Id);
baseDados.AddInParameter(cmd, "@Data", DbType.DateTime, trans.Data);
baseDados.AddInParameter(cmd, "@Horario", DbType.String, trans.Horario);
if (trans.TurmaRecebeu != null)
baseDados.AddInParameter(cmd, "@TurmaRecebeu", DbType.Guid, trans.TurmaRecebeu.Id);
else
baseDados.AddInParameter(cmd, "@TurmaRecebeu", DbType.Guid, DBNull.Value);
if (trans.TurmaTransferiu != null)
baseDados.AddInParameter(cmd, "@TurmaTransferiu", DbType.Guid, trans.TurmaTransferiu.Id);
else
baseDados.AddInParameter(cmd, "@TurmaTransferiu", DbType.Guid, DBNull.Value);
if (trans.EventoRecebeu != null)
baseDados.AddInParameter(cmd, "@EventoRecebeu", DbType.Guid, trans.EventoRecebeu.EventoId);
else
baseDados.AddInParameter(cmd, "@EventoRecebeu", DbType.Guid, DBNull.Value);
if (trans.EventoTransferiu != null)
baseDados.AddInParameter(cmd, "@EventoTransferiu", DbType.Guid, trans.EventoTransferiu.EventoId);
else
baseDados.AddInParameter(cmd, "@EventoTransferiu", DbType.Guid, DBNull.Value);
baseDados.ExecuteNonQuery(cmd);
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public void TranferenciaTest()
{
Agencia ag = Fabrica.CriaAgencia();
Cliente cliente = Fabrica.CriaCliente(false);
int numConta1 = ag.CriarConta(new Cliente[] { cliente });
int numConta2 = ag.CriarConta(new Cliente[] { cliente });
IConta conta1 = ag.RetornaConta(numConta1);
IConta conta2 = ag.RetornaConta(numConta2);
double saldoEsperado1 = conta1.Saldo - 100;
Transferencia transferencia = new Transferencia(conta1, conta2, 100);
transferencia.Executa();
Assert.AreEqual(saldoEsperado1, conta1.Saldo);
}
public void TransferenciaUpdate(Transferencia trans)
{
try
{
DbCommand cmd = baseDados.GetStoredProcCommand("TransferenciaUpdate");
baseDados.AddInParameter(cmd, "@Id", DbType.Guid, trans.Id);
baseDados.AddInParameter(cmd, "@FoiVisualizada", DbType.Boolean, trans.FoiVisualizada);
baseDados.ExecuteNonQuery(cmd);
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public Transferencia GetTransferencia(Guid id, Calendario cal)
{
try
{
DbCommand cmd = baseDados.GetStoredProcCommand("TransferenciaSelectById");
baseDados.AddInParameter(cmd, "@Id", DbType.Guid, id);
Transferencia trans = null;
TurmaDAO turmaDAO = new TurmaDAO();
RecursosDAO recDAO = new RecursosDAO();
EventoDAO eventoDAO = new EventoDAO();
using (IDataReader leitor = baseDados.ExecuteReader(cmd))
{
leitor.Read();
Guid transId = leitor.GetGuid(leitor.GetOrdinal("Id"));
Recurso rec = recDAO.GetRecurso(leitor.GetGuid(leitor.GetOrdinal("RecursoId")));
string hora = leitor.GetString(leitor.GetOrdinal("Horario"));
DateTime data = leitor.GetDateTime(leitor.GetOrdinal("Data"));
Turma turmaRecebeu = null;
Turma turmaTransferiu = null;
Evento eventoRecebeu = null;
Evento eventoTransferiu = null;
Guid? turmaRecId = leitor["TurmaRecebeu"] as Guid?;
if (turmaRecId.HasValue)
turmaRecebeu = turmaDAO.GetTurma(turmaRecId.Value, cal);
else turmaRecebeu = null;
Guid? turmaTransId = leitor["TurmaTransferiu"] as Guid?;
if (turmaTransId.HasValue)
turmaTransferiu = turmaDAO.GetTurma(turmaTransId.Value, cal);
else eventoTransferiu = null;
Guid? eventoRecId = leitor["EventoRecebeu"] as Guid?;
if (eventoRecId.HasValue)
eventoRecebeu = eventoDAO.GetEvento(eventoRecId.Value);
else eventoRecebeu = null;
Guid? eventoTransId = leitor["EventoTransferiu"] as Guid?;
if (eventoTransId.HasValue)
eventoTransferiu = eventoDAO.GetEvento(eventoTransId.Value);
else eventoTransferiu = null;
bool foiVisualizada = leitor.GetBoolean(leitor.GetOrdinal("FoiVisualizada"));
trans = new Transferencia(transId, rec, data, hora, turmaRecebeu, turmaTransferiu, foiVisualizada, eventoRecebeu, eventoTransferiu);
}
return trans;
}
catch (SqlException ex)
{
throw new DataAccessException(ErroMessages.GetErrorMessage(ex.Number), ex);
}
}
public bool insertarTransferencia(Transferencia pTransferencia)
{
return _CSC.insertarTransferencia(pTransferencia);
}
protected void dgEventos_ItemCommand(object sender, DataGridCommandEventArgs e)
{
if (e.CommandName == "Transferir")
{
if (rblRecursos.SelectedValue != "")
{
DateTime data = Convert.ToDateTime(Session["Data"]);
Guid aulaId = new Guid(Session["EventoId"].ToString());
string horario = (string)Session["Horario"];
Guid recId = new Guid(rblRecursos.SelectedValue);
List<Troca> listaTrocas = trocaBO.GetNaoVisualizadasByEvento(aulaId, data, horario);
bool controle = false;
//verifica se o recurso n esta envolvido em alguma troca
if (listaTrocas.Count != 0)
{
foreach (Troca t in listaTrocas)
{
if (t.AlocacaoAtual.Recurso.Id == recId || t.AlocacaoDesejada.Recurso.Id == recId)
controle = true;
}
}
if (!controle)
{
Alocacao aloc = alocBO.GetAlocacao(recId, data, horario);
Label lblEventoId = (Label)e.Item.FindControl("lblEventoId");
Turma turmaRecebeu = null;
Turma turmaTrans = null;
Guid eventoTransId = new Guid(Session["EventoId"].ToString());
Evento eventoTrans = eventoBO.GetEventoById(eventoTransId);
Evento eventoRec = eventoBO.GetEventoById(new Guid(lblEventoId.Text));
Transferencia trans = new Transferencia(Guid.NewGuid(), aloc.Recurso, data, horario, turmaRecebeu, turmaTrans, false, eventoRec, eventoTrans);
aloc.Horario = horario;
aloc.Evento = eventoRec;
alocBO.UpdateAlocacao(aloc);
transBO.InsereTransferencia(trans);
FechaJanela();
}
else
{
lblStatus.Text = "Este recurso não pode ser transferido por estar envolvido numa troca.";
ddlResponsavel.SelectedIndex = 0;
dgEventos.Visible = false;
}
}
else
{
lblStatus.Text = "Selecione um recurso para efetuar a transferência";
}
}
}
private Transferencia CreateTransferencia(Cuenta destino)
{
Transferencia trans = new Transferencia();
trans.tipo_moneda = Convert.ToInt32(cmbMoneda.SelectedValue);
trans.fecha = Utils.fechaSistema;
trans.cuenta_origen = Convert.ToInt64(cmbCuentaOrigen.SelectedValue);
trans.cuenta_destino = (long)destino.id;
trans.costo = (destino.codigoCliente == cliente.id) ? 0 :new DAOTipoCuenta().costo_transaccion(Convert.ToInt64(cmbCuentaOrigen.SelectedValue));
trans.importe = Convert.ToDouble(txtImporte.Text);
return trans;
}
private void button1_Click(object sender, RoutedEventArgs e)
{
if (listBoxFacturas.SelectedItems.Count == 0 || comboBoxBancos.SelectedIndex == -1 || textBoxNumTransferencia.Text.Length==0)
{
MessageBox.Show("Debe completar todos los datos.", "Error", MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
List<Documento> facturasList = new List<Documento>();
for (int i = 0; i < listBoxFacturas.SelectedItems.Count; i++)
{
Documento fact = (Documento)listBoxFacturas.SelectedItems[i];
facturasList.Add(fact);
}
//var facturasList = (List<Documento>)listBoxFacturas.SelectedItems;
var bancoDep = (Banco)comboBoxBancos.SelectedItem;
var proveedor = (SocNegocio)comboBoxProveedores.SelectedItem;
double factor = Math.Pow(10, 2);
string message = "Desea resgitrar el pago?";
string caption = "Confirmación";
bool completo = true;
MessageBoxButton buttons = MessageBoxButton.YesNo;
MessageBoxImage icon = MessageBoxImage.Question;
if (MessageBox.Show(message, caption, buttons, icon) == MessageBoxResult.Yes)
{
var monedaSistema = ServicioFinanzas.Instancia.ObtenerMonedasSistema("Sistema");
var monedaLocal = ServicioFinanzas.Instancia.ObtenerMonedasSistema("Local");
string xml = "<Cuentas>";
double montoDebe = 0, montoHaber = 0;
foreach (var factura in facturasList)
{
/* <Cuentas>
-- <Cuenta monto="10000.00" moneda="CRC" cuenta="" debe="0"/>
-- <Cuenta monto="5490.98" moneda="CRC" cuenta="" debe="1"/>
-- </Cuentas>*/
xml += string.Format("<Cuenta monto=\"{0}\" moneda=\"{1}\" cuenta=\"{2}\" debe=\"{3}\" />",
factura.Total, monedaSistema.Acronimo, factura.SocioNegocio.Codigo, "1");
montoDebe += factura.Total;
xml += string.Format("<Cuenta monto=\"{0}\" moneda=\"{1}\" cuenta=\"{2}\" debe=\"{3}\" />",
factura.Total, monedaSistema.Acronimo, bancoDep.CuentaMayor, "0");
montoHaber += factura.Total;
xml += string.Format("<Cuenta monto=\"{0}\" moneda=\"{1}\" cuenta=\"{2}\" debe=\"{3}\" />",
factura.Total, monedaLocal.Acronimo, factura.SocioNegocio.Codigo, "1");
xml += string.Format("<Cuenta monto=\"{0}\" moneda=\"{1}\" cuenta=\"{2}\" debe=\"{3}\" />",
factura.Total, monedaLocal.Acronimo, bancoDep.CuentaMayor, "0");
xml += "</Cuentas>";
if (ServicioFinanzas.Instancia.InsertarAsiento(DateTime.Now.Month.ToString() + "/" + DateTime.Now.Day.ToString() + "/" + DateTime.Now.Year.ToString(), montoDebe, montoHaber, xml, "PR"))
{
if (!(ServicioFinanzas.Instancia.setearFacturas(factura.IdDocumento, "Cancelado")))
completo = false;
Transferencia transferencia = new Transferencia()
{
TipoTransferencia = "Efectuado",
Socio = proveedor,
banco = bancoDep,
Monto = factura.Total,
Fecha = DateTime.Now,
NumTranseferencia = textBoxNumTransferencia.Text
};
if (!(ServicioFinanzas.Instancia.insertarTransferencia(transferencia)))
completo = false;
}
else
completo = false;
xml = "<Cuentas>";
montoDebe = 0;
montoHaber = 0;
}
if (completo)
MessageBox.Show("Pagos registrados!", "SIA", MessageBoxButton.OK, MessageBoxImage.Information);
textBoxNumTransferencia.Text = "";
comboBoxBancos.SelectedIndex = -1;
var facturas = ServicioFinanzas.Instancia.ObtenerFacturasXEstadoXSocioNegocio(((SocNegocio)comboBoxProveedores.SelectedItem).Codigo, "Pendiente");
listBoxFacturas.ItemsSource = facturas;
listBoxFacturas.Items.Refresh();
}
}
}
public Transferencia FindTransferencia(int id)
{
//llenar modelo transferencia desde los datos de la orden
List<DetalleOrdenRecargaPrepago> detalleOrden = repOrden.FindDetalleOrden(id);
Transferencia transferencia = new Transferencia();
AfiliadoSuma afiliadoOrigen = repAfiliado.Find(detalleOrden.First().idAfiliado);
SaldosMovimientos SaldosMovimientos = repAfiliado.FindSaldosMovimientos(afiliadoOrigen);
transferencia.docnumberAfiliadoOrigen = afiliadoOrigen.docnumber;
transferencia.idAfiliadoOrigen = afiliadoOrigen.id;
transferencia.nameAfiliadoOrigen = afiliadoOrigen.name;
transferencia.lastname1AfiliadoOrigen = afiliadoOrigen.lastname1;
transferencia.typeAfiliadoOrigen = afiliadoOrigen.type;
transferencia.datosCuentaSumaOrigen = SaldosMovimientos.Saldos.First(x => x.accounttype.Equals(Globals.TIPO_CUENTA_SUMA));
transferencia.DenominacionCuentaOrigenSuma = "Más";
transferencia.datosCuentaPrepagoOrigen = SaldosMovimientos.Saldos.First(x => x.accounttype.Equals(Globals.TIPO_CUENTA_PREPAGO));
transferencia.DenominacionCuentaOrigenPrepago = "Bs.";
transferencia.statusDetalleOrdenOrigenSuma = detalleOrden.First().statusDetalleOrden;
transferencia.resultadoTransferenciaOrigenSuma = detalleOrden.First().observacionesExclusion + " (" + detalleOrden.First().resultadoRecarga + ")";
transferencia.statusDetalleOrdenOrigenPrepago = detalleOrden.Skip(1).First().statusDetalleOrden;
transferencia.resultadoTransferenciaOrigenPrepago = detalleOrden.Skip(1).First().observacionesExclusion + " (" + detalleOrden.Skip(1).First().resultadoRecarga + ")";
AfiliadoSuma afiliadoDestino = repAfiliado.Find(detalleOrden.SkipWhile(x => x.idAfiliado == afiliadoOrigen.id).First().idAfiliado);
SaldosMovimientos = repAfiliado.FindSaldosMovimientos(afiliadoDestino);
transferencia.docnumberAfiliadoDestino = afiliadoDestino.docnumber;
transferencia.idAfiliadoDestino = afiliadoDestino.id;
transferencia.nameAfiliadoDestino = afiliadoDestino.name;
transferencia.lastname1AfiliadoDestino = afiliadoDestino.lastname1;
transferencia.datosCuentaSumaDestino = SaldosMovimientos.Saldos.First(x => x.accounttype.Equals(Globals.TIPO_CUENTA_SUMA));
transferencia.datosCuentaPrepagoDestino = SaldosMovimientos.Saldos.First(x => x.accounttype.Equals(Globals.TIPO_CUENTA_PREPAGO));
transferencia.statusDetalleOrdenDestinoSuma = detalleOrden.Skip(2).First().statusDetalleOrden;
transferencia.resultadoTransferenciaDestinoSuma = detalleOrden.Skip(2).First().observacionesExclusion + " (" + detalleOrden.Skip(2).First().resultadoRecarga + ")";
transferencia.statusDetalleOrdenDestinoPrepago = detalleOrden.Skip(3).First().statusDetalleOrden;
transferencia.resultadoTransferenciaDestinoPrepago = detalleOrden.Skip(3).First().observacionesExclusion + " (" + detalleOrden.Skip(3).First().resultadoRecarga + ")";
transferencia.ResumenTransferenciaSuma = Math.Truncate(detalleOrden.First().montoRecarga).ToString();
transferencia.ResumenTransferenciaPrepago = detalleOrden.Skip(1).First().montoRecarga.ToString("N2");
OrdenRecargaPrepago orden = repOrden.Find(id);
transferencia.id = orden.id;
transferencia.creationdateOrden = orden.creationdateOrden;
transferencia.montoOrden = orden.montoOrden;
transferencia.statusOrden = orden.statusOrden;
transferencia.tipoOrden = orden.tipoOrden;
return transferencia;
}
