PrevisionCobro.cs
1 using System;
2 using System.Collections.Generic;
3 using System.Linq;
4 using System.Text;
5 using System.ComponentModel;
6 using System.Windows.Forms;
7 using System.Data;
8 
9 using sage.ew.global;
10 using sage.ew.db;
11 using sage.ew.functions;
12 using sage.ew.ewbase;
13 using sage.ew.netvfp;
14 using sage.ew.formul;
15 using sage.ew.objetos;
16 using sage.ew.formul.Forms;
17 using sage.ew.cliente.Forms;
18 using sage.ew.contabilidad;
19 using sage.ew.interficies;
20 using sage.ew.usuario;
21 using System.IO;
22 using sage.ew.reports;
23 using sage.ew.enumerations;
25 using System.Collections;
26 using sage.ew.ewbase.Clases;
27 using sage.ew.docscompra;
28 using System.Linq.Expressions;
29 
30 namespace sage.ew.cliente
31 {
36  {
37  #region ENUMERACIONES
38 
39 
43  public enum EstadoPrevisiones
44  {
48  Cobradas,
52  Pendientes,
56  Impagadas,
60  Todas
61  }
62 
63 
64  #endregion
65 
66 
67  #region PROPIEDADES PRIVADAS
68 
69 
70  private bool _llNumasiref = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_numasiref")); //COPIAR NÚMERO DE ASIENTO EN EL CAMPO REFERENCIA
71 
75  internal string _lcUsuario = Convert.ToString(EW_GLOBAL._GetVariable("wc_usuario")).Trim().ToUpper() + "#" + Environment.MachineName.Trim().ToUpper() + "#" + Environment.UserName.Trim();
76 
77 
81  internal string _lcEmpresa = EW_GLOBAL._GetVariable("wc_empresa").ToString().Trim();
82 
83 
87  internal string _lcMonedaEmpresa = Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda"));
88 
89 
93  internal string _lcAny = EW_GLOBAL._GetVariable("wc_any").ToString().Trim();
94 
95 
99  internal string _lcGrupo = EW_GLOBAL._GetVariable("wc_Grupo").ToString().Trim();
100 
101 
105  internal int _nDigitos = Convert.ToInt32(EW_GLOBAL._GetLenCampo(KeyDiccionarioLenCampos.wn_digitos));
106 
107 
111  private bool _llDivisaVentas = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_divisaventa"));
112 
113 
117  Divisa _loDivMonedaEmpresa = null;
118 
119 
123  private string _cBanco = EW_GLOBAL._GetVariable("wc_banco").ToString();
124 
128  private string _cEfec_dto = EW_GLOBAL._GetVariable("wc_efec_dto").ToString();
129 
130 
134  private string _cEntrega = Convert.ToString(EW_GLOBAL._GetVariable("wc_CtaEnt").ToString());
135 
136 
140  internal string _cBancoIni = string.Empty;
141 
142 
146  internal string _cBancoFin = string.Empty;
147 
148 
152  private Cliente _oCli = null;
153 
154 
158  private bool _lSel = false;
159 
160 
164  private string _cNombre = "NOMBRE"; // Para saltar el control del nombre obligatorio en la base
165 
166 
170  private string _cObservacion = "";
171 
172 
176  private string _cOldAsi = String.Empty;
177 
178 
182  private bool _lCobroParcial = false;
183 
184 
188  internal DateTime? _dFechaIni = null;
189 
190 
194  internal DateTime? _dFechaFin = null;
195 
196 
200  private DocPrintPrevisionCobro _oDocPrint;
201 
202 
207  {
208  get
209  {
210  return ((DocPrintPrevisionCobro)_DocPrint)._Recibo._Nombre;
211  }
212  }
213 
214 
219  {
220  get
221  {
222  return _Fecha.ToString(EW_GLOBAL._CustomFormatDate);
223  }
224  }
225 
226 
231  protected internal string lcCampoMoneda = string.Empty;
232 
233 
238  protected internal string lcCamposMoneda = string.Empty;
239 
240 
245  protected internal string lcEstado = string.Empty;
246 
247 
252  protected internal string lcDevuelta = string.Empty;
253 
254 
259  protected internal string lcAgrupacion = string.Empty;
260 
261 
266  protected internal string lcRemesa = string.Empty;
267 
268 
269  #endregion PROPIEDADES PRIVADAS
270 
271 
272  #region PROPIEDADES PUBLICAS
273 
274 
275  // Per defecte la clase en mode no mostrar missatges, i quan hi ha algo s'informa a la propietat _Message_Error, excepte quan pasa en un metode que es del tipus Mostrar algo per pantalla
276  // com p.e. mostrar l'assentament de la previsió o la remesa, o la factura, etc.
280  public bool _Mostrar_Mensajes = false;
281 
282 
286  public bool _GenerarDiferenciasCobro
287  {
288  get { return _lForzarDiferenciasCobro; }
289  set { _lForzarDiferenciasCobro = value; }
290  }
291  private bool _lForzarDiferenciasCobro = false;
292 
293 
297  public bool _Linkado = false;
298 
299 
303  [DefaultValue("")]
304  public string _Usuario
305  {
306  get { return Convert.ToString(_Campo("USUARIO")); }
307  set { _Campo("USUARIO", value); }
308  }
309 
310 
314  [DefaultValue("")]
315  public string _Empresa
316  {
317  get { return Convert.ToString(_Campo("EMPRESA")); }
318  set { _Campo("EMPRESA", value); }
319  }
320 
321 
325  [DefaultValue("")]
326  public string _Factura
327  {
328  get
329  {
330  return Convert.ToString(_Campo("FACTURA"));
331  }
332  set
333  {
334  _Campo("FACTURA", value);
335  _Campo("EMPRESA", _lcEmpresa);
336  }
337  }
338 
339 
343  public Cliente _oCliente
344  {
345  get
346  {
347  return _oCli;
348  }
349  set
350  {
351  _oCli = value;
352  }
353  }
354 
355 
359  [DefaultValue("")]
360  public string _Cliente
361  {
362  get
363  {
364  return Convert.ToString(_Campo("CLIENTE"));
365  }
366  set
367  {
368  _Campo("CLIENTE", value);
369 
370  string lcCliente = "";
371 
372  lcCliente = FUNCTIONS._Punto_Por_Ceros(value);
373  if (this._oCliente == null)
374  {
375  this._oCliente = new Cliente(lcCliente);
376  }
377  else if (lcCliente != this._oCliente._Codigo)
378  {
379  this._oCliente._Codigo = lcCliente;
380  }
381  }
382  }
383 
384 
388  [DefaultValue("")]
389  public string _ClienteERP
390  {
391  get
392  {
393 
394  if ((this._oCliente == null || this._oCliente._Codigo != _Cliente))
395  {
396  this._oCliente = new Cliente(_Cliente);
397  }
398 
399  return Convert.ToString(this._oCliente._ClienteERP);
400  }
401  }
402 
403 
407  [DefaultValue("")]
408  public string _Banco
409  {
410  get { return Convert.ToString(_Campo("BANCO")); }
411  set { _Campo("BANCO", value); }
412  }
413 
414 
418  [DefaultValue("")]
419  public string _BancoPrevisto
420  {
421  get { return Convert.ToString(_Campo("BANCO_PREV")); }
422  set { _Campo("BANCO_PREV", value); }
423  }
424 
425 
429  [DefaultValue("")]
430  public string _Forma_Pago
431  {
432  get { return Convert.ToString(_Campo("F_PAGO")); }
433  set { _Campo("F_PAGO", value); }
434  }
435 
436 
440  [DefaultValue("")]
441  public string _Pagare
442  {
443  get { return Convert.ToString(_Campo("PAGARE")); }
444  set { _Campo("PAGARE", value); }
445  }
446 
447 
451  [DefaultValue("")]
452  public string _Concepto
453  {
454  get { return Convert.ToString(_Campo("CONCEPTO")); }
455  set { _Campo("CONCEPTO", value); }
456  }
457 
458 
462  [DefaultValue("")]
463  public string _Refundir
464  {
465  get { return Convert.ToString(_Campo("REFUNDIR")); }
466  set { _Campo("REFUNDIR", value); }
467  }
468 
469 
473  [DefaultValue("")]
474  public string _Divisa
475  {
476  get
477  {
478  return Convert.ToString(_Campo("DIVISA"));
479  }
480  set
481  {
482  if (string.IsNullOrWhiteSpace(value)) //Bug 182452 => Divisa inexistente => no permito que modifique el valor . Siempre ha de haber una.
483  return;
484 
485  _Campo("DIVISA", value);
486  _loDivisa._Codigo = value;
487  if (_Cambio == 0)
488  {
489  if (_oCli != null)
490  {
491  //Task 107145
492  eTipoCambio leTipoCambio = eTipoCambio.Indeterminado;
493  decimal lnCambio = _oCli._CambioPactado(_Divisa, (_Fecha_Emision.HasValue ? _Fecha_Emision.Value : DateTime.Today), out leTipoCambio);
494  _TipoCambio = leTipoCambio;
495  this._Cambio = lnCambio;
496  }
497  }
498  }
499  }
500 
501 
505  [DefaultValue("")]
506  public string _Vendedor
507  {
508  get { return Convert.ToString(_Campo("VENDEDOR")); }
509  set { _Campo("VENDEDOR", value); }
510  }
511 
512 
516  [DefaultValue("")]
517  public string _Cobrador
518  {
519  get { return Convert.ToString(_Campo("COBRADOR")); }
520  set { _Campo("COBRADOR", value); }
521  }
522 
523 
527  [DefaultValue("")]
528  public string _Asi
529  {
530  get { return Convert.ToString(_Campo("ASI")); }
531  set { _Campo("ASI", value); }
532  }
533 
534 
538  [DefaultValue("")]
539  public string _Mandato
540  {
541  get { return Convert.ToString(_Campo("MANDATO")); }
542  set { _Campo("MANDATO", value); }
543  }
544 
545 
549  [DefaultValue("")]
550  public string _Tipade19
551  {
552  get { return Convert.ToString(_Campo("TIPADE19")); }
553  set { _Campo("TIPADE19", value); }
554  }
555 
556 
560  [DefaultValue("")]
561  public string _Impreso
562  {
563  get { return Convert.ToString(_Campo("IMPRESO")); }
564  set { _Campo("IMPRESO", value); }
565  }
566 
567 
571  [DefaultValue("")]
572  public string _Impago
573  {
574  get { return Convert.ToString(_Campo("IMPAGO")); }
575  set { _Campo("IMPAGO", value); }
576  }
577 
578 
582  [DefaultValue(false)]
583  public bool _lImpago
584  {
585  get { return _Impago.ToUpper() == "S" ? true : false; }
586 
587  }
588 
589 
593  [DefaultValue(0)]
594  public new int _Ejercicio
595  {
596  get { return Convert.ToInt32(_Campo("PERIODO")); }
597  set { _Campo("PERIODO", value); }
598  }
599 
600 
604  [DefaultValue(2)]
605  public int _TipoGasto
606  {
607  get { return Convert.ToInt32(_Campo("TIPOGASTO")); }
608  set { _Campo("TIPOGASTO", value); }
609  }
610 
611 
615  [DefaultValue(0)]
616  public int _Orden
617  {
618  get { return Convert.ToInt32(_Campo("ORDEN")); }
619  set { _Campo("ORDEN", value); }
620  }
621 
622 
626  [DefaultValue(0)]
627  public int _Impagado
628  {
629  get { return Convert.ToInt32(_Campo("IMPAGADO")); }
630  set { _Campo("IMPAGADO", value); }
631  }
632 
633 
637  [DefaultValue(0)]
638  public int _Pendiente
639  {
640  get { return Convert.ToInt32(_Campo("PENDIENTE")); }
641  set { _Campo("PENDIENTE", value); }
642  }
643 
644 
648  [DefaultValue(0)]
649  public int _Remesa
650  {
651  get { return Convert.ToInt32(_Campo("REMESA")); }
652  set { _Campo("REMESA", value); }
653  }
654 
655 
659  [DefaultValue(0)]
660  public int _Num_Banco
661  {
662  get { return Convert.ToInt32(_Campo("NUM_BANCO")); }
663  set { _Campo("NUM_BANCO", value); }
664  }
665 
666 
670  public Divisa _oDivisa
671  {
672  get
673  {
674  return _loDivisa;
675  }
676  set
677  {
678  _loDivisa = value;
679  }
680  }
681  private Divisa _loDivisa = new Divisa();
682 
683 
687  [DefaultValue(0.0)]
688  public decimal _Cambio
689  {
690  get { return Convert.ToDecimal(_Campo("CAMBIO")); }
691  set { _Campo("CAMBIO", value); }
692  }
693 
694 
695  //Task 107145
699  public eTipoCambio _TipoCambio
700  {
701  get { return leTipoCambio; }
702  set { leTipoCambio = value; }
703  }
704  private eTipoCambio leTipoCambio = eTipoCambio.Indeterminado;
705 
706 
710  [DefaultValue(0.0)]
711  public decimal _Imppagare
712  {
713  get { return Convert.ToDecimal(_Campo("IMPPAGARE")); }
714  set { _Campo("IMPPAGARE", value); }
715  }
716 
717 
721  [DefaultValue(0.0)]
722  public decimal _Importe
723  {
724  get { return Convert.ToDecimal(_Campo("IMPORTE")); }
725  set
726  {
727  if (this._llDivisaVentas == false || string.IsNullOrWhiteSpace(this._Divisa) || this._Divisa == this._lcMonedaEmpresa)
728  {
729  // No trabajo con multidivisa en ventas, o trabajo con multidivsa en venta pero la moneda de la prevision es la de la empresa, actualizo los dos importes de forma idéntica.
730  _Campo("IMPORTE", value);
731  _Campo("IMPORTEDIV", value);
732  }
733  else
734  {
735  // Trabajo con multidivisa en ventas y la moneda de la prevision es diferente de la moneda de la empresa y estoy seteando el campo IMPORTE en moneda de la empresa, OJO !
736 
737  // Si la prevision está en moneda diferente de la empresa no podemos actualizar el campo IMPORTEDIV mediante una conversión a partir del importe en la moneda de la empresa !!
738  // No se le ocurra a nadie poner aquí el recalculo de IMPORTEDIV a partir de IMPORTE pues será contrario a la política de trabajo establecida para multivisa, los importes en divisa
739  // no se recalculan nunca a partir de los importes en moneda de empresaa, cualquier duda hablar con J.Suñé (12/06/2017)
740  if (value != Convert.ToDecimal(_Campo("IMPORTE")))
741  {
742  this._Error_Message = "La previsión se generó en moneda diferente a la de la empresa, imposible modificar el importe en moneda de la empresa directamente, debe modificar el importe en divisa.";
743  _Campo("IMPORTE", value);
744  }
745  }
746  }
747  }
748 
749 
753  [DefaultValue(0.0)]
754  public decimal _ImporteDiv
755  {
756  get { return Convert.ToDecimal(_Campo("IMPORTEDIV")); }
757  set
758  {
759  if (this._llDivisaVentas == false || string.IsNullOrWhiteSpace(this._Divisa) || this._Divisa == this._lcMonedaEmpresa)
760  {
761  // No trabajo con multidivisa en ventas, o trabajo con multidivsa en compras pero la moneda de la prevision es la de la empresa, puedo actualizar los 2 campos de importe de forma idéntica.
762  _Campo("IMPORTEDIV", value);
763  _Campo("IMPORTE", value);
764  }
765  else
766  {
767  // Trabajo con multidivisa en ventas y la moneda de la prevision es diferente de la moneda de la empresa, actualizo el importe en divisa y calculo el importe respectivo en la moneda de la empresa.
768  _Campo("IMPORTEDIV", value);
769 
770  decimal lnImporteMonEmpresa = Divisa._Convertir_Importe_Moneda(value, this._Divisa, this._lcMonedaEmpresa, this._Cambio, this._loDivMonedaEmpresa._MascaraImporte._Num_Decimales);
771  _Campo("IMPORTE", lnImporteMonEmpresa);
772  }
773  }
774  }
775 
776 
780  [DefaultValue(null)]
781  public DateTime _Fecha
782  {
783  get
784  {
785  return (_Fecha_Emision != null ? _Fecha_Emision.Value : DateTime.Today);
786  }
787  set
788  {
789  _Fecha_Emision = value;
790  }
791  }
792 
793 
797  [DefaultValue(0.0)]
798  public decimal _Entrega
799  {
800  get
801  {
802  return _nEntrega;
803  }
804  set
805  {
806  _nEntrega = value;
807  }
808  }
809  decimal _nEntrega = 0;
810 
811 
815  [DefaultValue(0.0)]
816  public decimal _EntregaDiv
817  {
818  get
819  {
820  if (_Divisa == EW_GLOBAL._Empresa._Moneda) _nEntregaDiv = _nEntrega;
821  return _nEntregaDiv;
822  }
823  set
824  {
825  _nEntregaDiv = value;
826  if (_Divisa == EW_GLOBAL._Empresa._Moneda) _nEntrega = value;
827  }
828  }
829  private decimal _nEntregaDiv = 0;
830 
831 
832  //Task 113371
836  public string _Mensaje_Info_Cambio
837  {
838  get { return _cMensaje_Info_Cambio; }
839  set { _cMensaje_Info_Cambio = value; }
840  }
841  private string _cMensaje_Info_Cambio = String.Empty;
842 
843 
847  [DefaultValue(false)]
848  public bool _Asiento
849  {
850  get { return Convert.ToBoolean(_Campo("ASIENTO")); }
851  set { _Campo("ASIENTO", value); }
852  }
853 
854 
858  [DefaultValue(false)]
859  public bool _Recc
860  {
861  get { return Convert.ToBoolean(_Campo("RECC")); }
862  set { _Campo("RECC", value); }
863  }
864 
865 
869  [DefaultValue(false)]
870  public bool _Cheque
871  {
872  get { return Convert.ToBoolean(_Campo("CHEQUE")); }
873  set { _Campo("CHEQUE", value); }
874  }
875 
876 
880  [DefaultValue(false)]
881  public bool _CobroAgrup
882  {
883  get { return Convert.ToBoolean(_Campo("COBROAGRUP")); }
884  set { _Campo("COBROAGRUP", value); }
885  }
886 
887 
891  [DefaultValue(false)]
892  public bool _Sel
893  {
894  get { return _lSel; }
895  set { _lSel = value; }
896  }
897 
898 
902  [DefaultValue(null)]
903  public DateTime? _Fecha_Emision
904  {
905  get
906  {
907  object loFecha = _Campo("EMISION");
908  if (loFecha != DBNull.Value && loFecha != null)
909  {
910  _Campo("EMISION", ((DateTime)loFecha).Date);
911  return ((DateTime)loFecha).Date;
912  }
913  else
914  return null;
915  }
916  set { _Campo("EMISION", value); }
917  }
918 
919 
923  [DefaultValue(null)]
924  public DateTime? _Fecha_Vencim
925  {
926  get
927  {
928  object loFecha = _Campo("VENCIM");
929  if (loFecha != DBNull.Value && loFecha != null)
930  {
931  _Campo("VENCIM", ((DateTime)loFecha).Date);
932  return ((DateTime)loFecha).Date;
933  }
934  else
935  return null;
936  }
937  set { _Campo("VENCIM", value); }
938  }
939 
940 
944  [DefaultValue(null)]
945  public DateTime? _Fecha_Remesa
946  {
947  get
948  {
949  object loFecha = _Campo("FECREME");
950  if (loFecha != DBNull.Value && loFecha != null)
951  {
952  _Campo("FECREME", ((DateTime)loFecha).Date);
953  return ((DateTime)loFecha).Date;
954  }
955  else
956  return null;
957  }
958  set { _Campo("FECREME", value); }
959  }
960 
961 
965  [DefaultValue(null)]
966  public DateTime? _Fecha_Operacion
967  {
968  get
969  {
970  object loFecha = _Campo("FEC_OPER");
971  if (loFecha != DBNull.Value && loFecha != null)
972  {
973  _Campo("FEC_OPER", ((DateTime)loFecha).Date);
974  return ((DateTime)loFecha).Date;
975  }
976  else
977  return null;
978  }
979  set { _Campo("FEC_OPER", value); }
980  }
981 
982 
986  [DefaultValue(null)]
987  public DateTime? _Fecha_Vencim2
988  {
989  get
990  {
991  object loFecha = _Campo("VENCIM2");
992  if (loFecha != DBNull.Value && loFecha != null)
993  {
994  _Campo("VENCIM2", ((DateTime)loFecha).Date);
995  return ((DateTime)loFecha).Date;
996  }
997  else
998  return null;
999  }
1000  set { _Campo("VENCIM2", value); }
1001  }
1002 
1003 
1007  [DefaultValue(null)]
1008  public DateTime? _Fecha_Descuento
1009  {
1010  get
1011  {
1012  object loFecha = _Campo("FECHADES");
1013  if (loFecha != DBNull.Value && loFecha != null)
1014  {
1015  _Campo("FECHADES", ((DateTime)loFecha).Date);
1016  return ((DateTime)loFecha).Date;
1017  }
1018  else
1019  return null;
1020  }
1021  set { _Campo("FECHADES", value); }
1022  }
1023 
1024 
1028  [DefaultValue(null)]
1029  public DateTime? _Fecha_Cobro
1030  {
1031  get
1032  {
1033  object loFecha = _Campo("COBRO");
1034  if (loFecha != DBNull.Value && loFecha != null)
1035  {
1036  _Campo("COBRO", ((DateTime)loFecha).Date);
1037  return ((DateTime)loFecha).Date;
1038  }
1039  else
1040  return null;
1041  }
1042  set { _Campo("COBRO", value); }
1043  }
1044 
1045 
1046  #region PROPIEDADES_IMPAGO
1047 
1048 
1052  [DefaultValue(false)]
1053  public bool _ImpagoGastosBancariosContabilizar
1054  {
1055  get { return Convert.ToBoolean(_Campo("CONTGASTOS")); }
1056  set { _Campo("CONTGASTOS", value); }
1057  }
1058 
1059 
1063  [DefaultValue(null)]
1064  public DateTime? _ImpagoGastosBancariosFecha
1065  {
1066  get
1067  {
1068  object loFecha = _Campo("FEC_GAS");
1069  if (loFecha != DBNull.Value && loFecha != null)
1070  {
1071  //_Campo("FEC_GAS", ((DateTime)loFecha).Date);
1072  return ((DateTime)loFecha).Date;
1073  }
1074  else
1075  return null;
1076  }
1077  set { _Campo("FEC_GAS", value); }
1078  }
1079 
1080 
1084  [DefaultValue("Text")]
1085  public string _ImpagoGastosBancariosDivisa
1086  {
1087  get
1088  {
1089  return Convert.ToString(_Campo("DIV_GAS"));
1090  }
1091  set
1092  {
1093  _Campo("DIV_GAS", value);
1094  }
1095  }
1096 
1097 
1101  [DefaultValue(0.0)]
1102  public decimal _ImpagoGastosBancariosCambio
1103  {
1104  get { return Convert.ToDecimal(_Campo("CAMBIO_GAS")); }
1105  set { _Campo("CAMBIO_GAS", value); }
1106  }
1107 
1108 
1112  [DefaultValue(0.0)]
1113  public decimal _ImpagoGastosBancariosImporte
1114  {
1115  get { return Convert.ToDecimal(_Campo("GASTOS")); }
1116  set { _Campo("GASTOS", value); }
1117  }
1118 
1119 
1123  [DefaultValue("")]
1124  public string _ImpagoGastosBancariosCuenta
1125  {
1126  get { return Convert.ToString(_Campo("CTA_IMPAGO")); }
1127  set { _Campo("CTA_IMPAGO", value); }
1128  }
1129 
1130 
1134  [DefaultValue(false)]
1135  public bool _ImpagoNuevaFacturaGenerar
1136  {
1137  get { return Convert.ToBoolean(_Campo("GENFACTURA")); }
1138  set { _Campo("GENFACTURA", value); }
1139  }
1140 
1141 
1145  [DefaultValue("")]
1146  public string _ImpagoNuevaFacturaNumero
1147  {
1148  get { return Convert.ToString(_Campo("FACGASTOS")); }
1149  set { _Campo("FACGASTOS", value); }
1150  }
1151 
1152 
1156  [DefaultValue("")]
1157  public string _ImpagoNuevaFacturaCuenta
1158  {
1159  get { return Convert.ToString(_Campo("CTAFACTURA")); }
1160  set { _Campo("CTAFACTURA", value); }
1161  }
1162 
1163 
1167  [DefaultValue("")]
1168  public string _ImpagoNuevaFacturaTipoIva
1169  {
1170  get { return Convert.ToString(_Campo("IVAFACTURA")); }
1171  set { _Campo("IVAFACTURA", value); }
1172  }
1173 
1174 
1178  [DefaultValue(false)]
1179  public bool _ImpagoNuevaFacturaContabilizar
1180  {
1181  get { return Convert.ToBoolean(_Campo("CONT_FACT")); }
1182  set { _Campo("CONT_FACT", value); }
1183  }
1184 
1185 
1189  [DefaultValue(false)]
1190  public bool _ImpagoRepercutirGastos
1191  {
1192  get { return Convert.ToBoolean(_Campo("REPGASTOS")); }
1193  set { _Campo("REPGASTOS", value); }
1194  }
1195 
1196 
1200  [DefaultValue(0.0)]
1201  public decimal _ImpagoRepercutirImporte
1202  {
1203  get { return Convert.ToDecimal(_Campo("REPIMPORTE")); }
1204  set { _Campo("REPIMPORTE", value); }
1205  }
1206 
1207 
1211  [DefaultValue(false)]
1212  public bool _ImpagoRepercutirFacturaGenerar
1213  {
1214  get { return Convert.ToBoolean(_Campo("GENREPFACT")); }
1215  set { _Campo("GENREPFACT", value); }
1216  }
1217 
1218 
1222  [DefaultValue("")]
1223  public string _ImpagoRepercutirTipoIva
1224  {
1225  get { return Convert.ToString(_Campo("IVAREPFACT")); }
1226  set { _Campo("IVAREPFACT", value); }
1227  }
1228 
1229 
1233  [DefaultValue("")]
1234  public string _ImpagoRepercutirCuenta
1235  {
1236  get { return Convert.ToString(_Campo("CTAREPFACT")); }
1237  set { _Campo("CTAREPFACT", value); }
1238  }
1239 
1240 
1241  #endregion PROPIEDADES_IMPAGO
1242 
1243 
1247  [DefaultValue("")]
1248  public string _Observacion
1249  {
1250  get { return _cObservacion; }
1251  set { _cObservacion = value; }
1252  }
1253 
1254 
1258  public bool _Cobrada
1259  {
1260  get
1261  {
1262  return _Banco != "";
1263  }
1264  }
1265 
1269  [DefaultValue(0.0)]
1270  public decimal _CambioDivisaCobro
1271  {
1272  get
1273  {
1274  decimal lnCambio = 0M;
1275 
1276  if (_Cobrada)
1277  {
1278  Asientos loAsiento = new Asientos(_Asi);
1279 
1280  if (loAsiento != null)
1281  {
1282  lnCambio = loAsiento._Cambio;
1283  }
1284 
1285  loAsiento.Dispose();
1286  }
1287 
1288  return lnCambio;
1289  }
1290  }
1291 
1292 
1296  public IDocPrint _DocPrint
1297  {
1298  get
1299  {
1300  if (_oDocPrint == null)
1301  {
1302  _oDocPrint = new DocPrintPrevisionCobro((IDocumentoImprimible)this);
1303  _oDocPrint._Numero_Copias = Convert.ToInt32(EW_GLOBAL._diccionarioCfgFact.GetValue("recibos")); //ha d'agafar el nou camp de numero de copies, no es necessari q depengui del TPV// EW_GLOBAL._Empresa._ConfigTPV._NumImpresionComprobantes;
1304  }
1305  return _oDocPrint;
1306  }
1307  set
1308  {
1309  if (value is DocPrintPrevisionCobro)
1310  {
1311  _oDocPrint = (DocPrintPrevisionCobro)value;
1312  _oDocPrint._Numero_Copias = Convert.ToInt32(EW_GLOBAL._diccionarioCfgFact.GetValue("recibos"));
1313  }
1314  }
1315  }
1316 
1317 
1321  public string _ReportBase
1322  {
1323  get
1324  {
1325  return ((DocPrintPrevisionCobro)_DocPrint)._Recibo._ReportBase;
1326  }
1327  set
1328  {
1329  ;
1330  }
1331  }
1332 
1333 
1337  public string _ReportTitlePreview
1338  {
1339  get
1340  {
1341  return ((DocPrintPrevisionCobro)_DocPrint)._Recibo._ReportTitlePreview;
1342  }
1343  set
1344  {
1345  ;
1346  }
1347  }
1348 
1349 
1353  public object _Numereb { get; private set; }
1354 
1355 
1359  [DefaultValue("")]
1360  public string _Referencia
1361  {
1362  get { return Convert.ToString(_Campo("REFERENCIA")); }
1363  set { _Campo("REFERENCIA", value); }
1364  }
1365 
1366 
1370  [DefaultValue("")]
1371  public string _SIIFraMod
1372  {
1373  get { return Convert.ToString(_Campo("SIIFRAMOD")); }
1374  set { _Campo("SIIFRAMOD", value); }
1375  }
1376 
1377 
1378  #endregion PROPIEDADES PUBLICAS
1379 
1380 
1381  #region PROPIEDADES PUBLIC OVERRIDE
1382 
1383 
1387  public override string _Nombre
1388  {
1389  get { return this._cNombre; }
1390  set
1391  {
1392  this._cNombre = value;
1393  }
1394  }
1395 
1396 
1397  #endregion PROPIEDADES PUBLIC OVERRIDE
1398 
1399 
1400  #region CONSTRUCTORES
1401 
1402 
1407  {
1408  // Task 130919, optimización, intento aprovechar el objeto EW_GLOBAL._Moneda si existe para no crear un nuevo objeto Divisa y ahorrar así alguna consulta.
1409  if (EW_GLOBAL._Moneda != null)
1410  this._loDivMonedaEmpresa = EW_GLOBAL._Moneda;
1411  else
1412  this._loDivMonedaEmpresa = new Divisa(Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda")));
1413 
1414 
1415  // Redefino el browser ya que no dispongo de campo código
1416  if (_Hera)
1417  {
1418  this._Browser_Titulos_Campos = "Ejercicio, Factura, Orden, Emisión, Importe, Importe divisa, Divisa, Remesa, Pagaré, Cliente, Nombre";
1419  }
1420  else
1421  {
1422  this._Browser_Titulos_Campos = "Ejercicio, Estado, Devuelta, Factura, Orden, F.Emisión, F.Vencimiento, F.Cobro, Importe, Importe divisa, Divisa, Cliente, Nombre, Remesa, Pagaré, Agrupación, F.Pago, Nombre F.Pago, Banco previsto, Banco cobro, Concepto, Referencia, Nº Fra. Expedición";
1423  }
1424 
1425  lcCampoMoneda = "RTRIM(LTRIM(m.nombre)) + (case when m.SIMBOLO <> '' then ' (' + RTRIM(LTRIM(m.SIMBOLO)) + ')' else (case when m.ABREV <> '' then ' (' + RTRIM(LTRIM(m.ABREV)) + ')' else '' end) end) as DIVISA";
1426  lcCamposMoneda = " p.IMPORTEDIV, " + lcCampoMoneda;
1427 
1428 
1429  if (!_Hera)
1430  {
1431  // Estado: Nueva columna, mostrará los siguientes estados de la previsión:
1432  // - Pendiente: cuando el valor previ_cl.cobro es igual a Null y previ_cl.banco y previ_cl.refundir están vacíos mostrará este estado
1433  // - Cobrada: cuando el valor previ_cl.cobro es distinto de Null, previ_cl.impagado = 0 y previ_cl.banco es distinto de vacío y previ_cl.refundir está vacío vacío o
1434  // cuando previ_cl.cobro es Null, previ_cl.impagado = 0 y previ_cl.banco es distinto de vacío y previ_cl.refundir está vacío mostrará este estado
1435  // (Nota este ultimo caso cuando desde DTS no se pasaba fecha de cobro)
1436  // - Agrupada: cuando el valor previ_cl.refundir no está vacío mostrará este estado.
1437  lcEstado = DB.SQLIif("p.refundir != ''",
1438  "'Agrupada'",
1439  DB.SQLIif("p.cobro IS NULL AND p.banco = '' AND p.refundir = ''",
1440  "'Pendiente'",
1441  DB.SQLIif("((p.cobro IS NOT NULL AND p.impagado = 0 AND p.banco != '' AND p.refundir = '') OR " +
1442  "(p.cobro IS NULL AND p.impagado = 0 AND p.banco != '' AND p.refundir = ''))",
1443  "'Cobrada'",
1444  "''"))
1445  ) + "as estado, ";
1446 
1447  // Devuelta: Nueva columna, si la previsión está devuelta mostrará un Si(previ_cl.Impagado = 0 y previ_cl.Impago = S), en caso contrario se mostrará la columna vacía
1448  lcDevuelta = DB.SQLIif("p.impagado = '0' AND p.impago = 'S'", "'Sí'", "''") + " as devuelta, ";
1449 
1450  // Agrupación: Nueva columna, mostrará el valor de la columna Factura de la previsión donde esta agrupado dicha previsión(previs.refundir),
1451  // si la previsión no ha sido agrupada se mostrará la columna vacía.
1452  lcAgrupacion = DB.SQLNvl("p.refundir", "''") + " as agrupacion, ";
1453  }
1454 
1455  string lcColumnaEsquema = DB.SQLIif("max(c.tiporemesa)=0", "'Ninguno'", DB.SQLIif("max(c.tiporemesa)=1", "'Core'", DB.SQLIif("max(c.tiporemesa)=2", "'B2b'", "'Cor1'"))) + " as esquema, ";
1456 
1457  lcRemesa = DB.SQLIif("p.REMESA= 0", "CAST('' AS nvarchar)", "CAST(" + "p.remesa" + " AS nvarchar)") + " as remesa, ";
1458 
1459 
1460  if (_Hera)
1461  {
1462  _Browser_Campos = "p.PERIODO,p.FACTURA,p.ORDEN,p.EMISION,p.IMPORTE, " + lcCamposMoneda + lcRemesa + " ,p.PAGARE, c.CLIENTEERP," + DB.SQLNvl("c.nombre", "''") + " as nombre , p.CLIENTE";
1463  _Browser_Campos_No_Visibles = "EMPRESA,IMPAGADO,PENDIENTE,CLIENTE,m.codigo as ___divisa_codigo, m.grantotal as ___divisa_mascara ";
1464  }
1465  else
1466  {
1467  _Browser_Campos = "p.PERIODO, " + lcEstado + lcDevuelta + "p.FACTURA,p.ORDEN, CAST(p.EMISION as date) as emision, CAST(p.vencim as date) as vencim, CAST(p.cobro as date) as cobro, p.IMPORTE, " + lcCamposMoneda + ", p.CLIENTE," + DB.SQLNvl("c.nombre", "''") + " as nombre, " + lcRemesa + "p.PAGARE, " + lcAgrupacion + " p.f_pago," + DB.SQLNvl("f.nombre", "''") + " as nomfpag, p.banco_prev, p.banco, p.concepto, p.referencia, p.siiframod";
1468  _Browser_Campos_No_Visibles = "EMPRESA,IMPAGADO,PENDIENTE,m.codigo as ___divisa_codigo, m.grantotal as ___divisa_mascara ";
1469  }
1470  _Browser_Campo_Predet = "FACTURA";
1471  _Browser_Tabla = "previ_cl p left join " + DB.SQLDatabase("gestion", "clientes") + " c on p.cliente = c.codigo " + "LEFT JOIN " + DB.SQLDatabase("gestion", "moneda") + " m ON p.divisa=m.codigo " + " LEFT JOIN " + DB.SQLDatabase("GESTION", "FPAG") + " f ON p.f_pago = f.codigo ";
1472  _Browser_Clave = "EMPRESA,PERIODO,FACTURA,ORDEN,IMPAGADO,PENDIENTE";
1473  _Browser_Condicion = "EMPRESA = '" + Convert.ToString(_lcEmpresa) + "' AND IMPAGADO = 0 ";
1474 
1475  Establecer_Clave();
1476 
1477  _Load();
1478  }
1479 
1480 
1484  public PrevisionCobro(string tcEmpresa = "", int tnEjercicio = 0, string tcFactura = "", int tnOrden = 0, int tnImpagado = 0, int tnPendiente = 0)
1485  {
1486  if (string.IsNullOrWhiteSpace(tcEmpresa) || tnEjercicio == 0 || string.IsNullOrWhiteSpace(tcFactura))
1487  {
1488  this.Gestionar_Mensaje("Parámetros incorrectos.", "Constructor");
1489  return;
1490  }
1491 
1492  // Task 130919, optimización, intento aprovechar el objeto EW_GLOBAL._Moneda si existe para no crear un nuevo objeto Divisa y ahorrar así alguna consulta.
1493  if (EW_GLOBAL._Moneda != null)
1494  this._loDivMonedaEmpresa = EW_GLOBAL._Moneda;
1495  else
1496  this._loDivMonedaEmpresa = new Divisa(Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda")));
1497 
1498  this.Establecer_Clave(); // PE-84040
1499 
1500  // PE - 89350
1501  // Ho he tingut que ficar al davant, pq després d'assignar el _Orden, es dispara algo, i ja no ho agafa
1502  this._Impagado = tnImpagado;
1503  this._Pendiente = tnPendiente;
1504  // fi PE - 89350
1505 
1506  this._Empresa = tcEmpresa;
1507  this._Ejercicio = tnEjercicio;
1508  this._Orden = tnOrden;
1509 
1510  // Como funciona en modo multiclave, el orden de declaracion de los campos es importante, y si en particular queremos que nos cargue correctamente
1511  // todas las previsiones (las que tienen orden 0 concretamente también (son las que viene de retencion no fiscal, es el importe de lo que se retiene)) lo último
1512  // que hay que cargar es el nº de factura. (mirar método _Multiclave_Completa() de esta misma clase)
1513  this._Factura = tcFactura;
1514 
1515  this._Load();
1516  }
1517 
1518 
1522  public PrevisionCobro(DataRow loRow)
1523  {
1524  string lcEmpresa = Convert.ToString(loRow["empresa"]);
1525  string lcFactura = Convert.ToString(loRow["factura"]);
1526  int lnEjercicio = Convert.ToInt32(loRow["periodo"]);
1527  int lnOrden = Convert.ToInt32(loRow["orden"]);
1528  int lnImpagado = Convert.ToInt32(loRow["impagado"]);
1529  int lnPendiente = Convert.ToInt32(loRow["pendiente"]);
1530 
1531  if (string.IsNullOrWhiteSpace(lcEmpresa) || lnEjercicio == 0 || string.IsNullOrWhiteSpace(lcFactura))
1532  {
1533  this.Gestionar_Mensaje("Parámetros incorrectos.", "Constructor");
1534  return;
1535  }
1536 
1537 
1538  // Task 130919, optimización, intento aprovechar el objeto EW_GLOBAL._Moneda si existe para no crear un nuevo objeto Divisa y ahorrar así alguna consulta.
1539  if (EW_GLOBAL._Moneda != null)
1540  this._loDivMonedaEmpresa = EW_GLOBAL._Moneda;
1541  else
1542  this._loDivMonedaEmpresa = new Divisa(Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda")));
1543 
1544 
1545  this.Establecer_Clave(); // PE-84040
1546 
1547  // PE - 89350
1548  // Ho he tingut que ficar al davant, pq després d'assignar el _Orden, es dispara algo, i ja no ho agafa
1549  this._Impagado = lnImpagado;
1550  this._Pendiente = lnPendiente;
1551  // fi PE - 89350
1552 
1553  this._Empresa = lcEmpresa;
1554  this._Ejercicio = lnEjercicio;
1555  this._Orden = lnOrden;
1556 
1557  // Como funciona en modo multiclave, el orden de declaracion de los campos es importante, y si en particular queremos que nos cargue correctamente
1558  // todas las previsiones (las que tienen orden 0 concretamente también (son las que viene de retencion no fiscal es el importe de lo que se retiene)) lo último
1559  // que hay que cargar es el nº de factura. (mirar método _Multiclave_Completa() de esta misma clase)
1560  this._Factura = lcFactura;
1561 
1562  this._Load();
1563  }
1564 
1565 
1566  #endregion CONSTRUCTORES
1567 
1568 
1569  #region MÉTODOS PROTECTED OVERRIDE
1570 
1571 
1575  protected override void _DescargarDatos()
1576  {
1577  this._oCli = null;
1578  base._DescargarDatos();
1579  }
1580 
1581 
1582  #endregion MÉTODOS PROTECTED OVERRIDE
1583 
1584 
1585  #region METODOS PUBLICOS
1586 
1587 
1592  public bool _Printed()
1593  {
1594  return _SetImpreso("S");
1595  }
1596 
1597 
1602  public bool _UnPrinted()
1603  {
1604  return _SetImpreso("N");
1605  }
1606 
1607 
1611  public void _Print(Boolean tlPresentarPantalla = false)
1612  {
1613  ((DocPrintPrevisionCobro)_DocPrint)._PresentarPantallaImpresion = tlPresentarPantalla;
1614  if (_Show_Print()) _DocPrint._Print();
1615  }
1616 
1617 
1623  public bool _Show_Print(int tnAbrirEn = 1)
1624  {
1625  frmReportAction loForm;
1626  DocPrintPrevisionCobro loDocPrint = (DocPrintPrevisionCobro)_DocPrint;
1627 
1628  if (loDocPrint._PresentarPantallaImpresion)
1629  {
1630 
1631  Recibo loRecibo = _GetRecibo(((DocPrintRecibo)_DocPrint)._TipoRecibo);
1632 
1633  if (!String.IsNullOrEmpty(loRecibo._ReportBase))
1634  {
1635  loForm = new frmReportAction();
1636  loForm._ReportBase = loRecibo._ReportBase;
1637  loForm._Nombre = loRecibo._Nombre;
1638  loForm._Printer = loRecibo._Printer;
1640  loForm._UserControlAdicional = loDocPrint._UserControlAdicional;
1641  loForm._PrinterCopies = Convert.ToInt16(loDocPrint._Numero_Copias);
1642  loForm._MostrarExportacionCSV = false;
1643  loForm._MostrarOpcionColores = false;
1644  loForm._ShowEditMode = loDocPrint._AllowEditMode;
1645  loForm._ShowVistaPreliminar = true;
1646  loForm._ShowDialog(); //Bug 114218 Cambiar .ShowDialog() por ._ShowDialog()
1647 
1648  if (loForm.DialogResult == DialogResult.OK)
1649  {
1650  loDocPrint._TipoRecibo = ((UserControls.OpcionesImpresionRecibos)loForm._UserControlAdicional)._TipoRecibo;
1651  loDocPrint._Numero_Copias = ((UserControls.OpcionesImpresionRecibos)loForm._UserControlAdicional)._Copias;
1652  loDocPrint._ImpresionNormalMultiple = ((UserControls.OpcionesImpresionRecibos)loForm._UserControlAdicional)._UnReciboPorHoja || loForm._VistaPreliminar ? enumerations.ImpresionNormalMultiple.Normal : enumerations.ImpresionNormalMultiple.Multiple;
1653 
1654  loDocPrint._Vista_Preliminar = loForm._VistaPreliminar;
1655  loDocPrint._Ruta_Fichero = loForm._FilePath;
1656  loDocPrint._Printer = loForm._Printer;
1657  loDocPrint._Exportar = loForm._Exportar;
1658  loDocPrint._EditMode = loForm._EditMode;
1659  loDocPrint._FieldRandomBackColor = loForm._FieldRandomBackColor;
1660  loDocPrint._Formato_exportacion = loForm._FormatoExportacion;
1661 
1662  return true;
1663  }
1664  }
1665  else
1666  {
1667  FUNCTIONS._MessageBox("No se ha establecido el fichero del Report", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1, DialogResult.OK);
1668  }
1669 
1670  return false;
1671  }
1672 
1673  return true;
1674  }
1675 
1676 
1682  public Dictionary<string, object> _Obtener_Filtros_SageReports(Dictionary<string, object> tdicParametros = null)
1683  {
1684  return new Dictionary<string, object>();
1685  }
1686 
1687 
1693  public DataTable _Obtener_Datos_SageReports(Dictionary<string, object> tdicParametros = null)
1694  {
1695  Recibo loRecibo = ((DocPrintPrevisionCobro)_DocPrint)._Recibo;
1696 
1697  return loRecibo._Obtener_Datos_SageReports(tdicParametros);
1698  }
1699 
1700 
1706  {
1707  bool llRetorno = true;
1708  string lcEmpresa = _lcEmpresa;
1709  string lcRemeEmitida = "";
1710  bool llOk = false;
1711  DataTable ldtResul = new DataTable();
1712 
1713  this._Addons_Permite_Delete_Prevision(TipoExecute.Before);
1714 
1715  // Mirar si está remesada y en una remesa cerrada ...
1716  if (_Remesa != 0)
1717  {
1718  string[] laCampos = new string[2] { "empresa", "numero" };
1719  object[] laValores = new object[2] { lcEmpresa, _Remesa };
1720 
1721  lcRemeEmitida = Convert.ToString(DB.SQLValor("remesa", laCampos, laValores, "emesa", "gestion"));
1722 
1723  if (lcRemeEmitida == "S")
1724  {
1725  _Mostrar_Mensajes = true;
1726  Gestionar_Mensaje("La previsión seleccionada esta incluida en la remesa " + Convert.ToString(_Remesa).Trim() + " que ya está cerrada y no puede borrarse.", "_Permite_Delete_Prevision");
1727  _Mostrar_Mensajes = false;
1728  llRetorno = false;
1729  }
1730  else
1731  {
1732  _Mostrar_Mensajes = true;
1733  Gestionar_Mensaje("La previsión seleccionada esta incluida en la remesa " + Convert.ToString(_Remesa).Trim() + " y no puede borrarse.", "_Permite_Delete_Prevision");
1734  _Mostrar_Mensajes = false;
1735  llRetorno = false;
1736  }
1737  }
1738 
1739  // Mirar si está en pagaré
1740  if (llRetorno)
1741  {
1742  if (!string.IsNullOrWhiteSpace(_Pagare))
1743  {
1744  _Mostrar_Mensajes = true;
1745  Gestionar_Mensaje("La previsión seleccionada esta incluida en el pagaré " + _Pagare.Trim() + " y no puede borrarse.", "_Permite_Delete_Prevision");
1746  _Mostrar_Mensajes = false;
1747  llRetorno = false;
1748  }
1749  }
1750 
1751  // Mirar si está en régimen de criterio caja
1752  if (llRetorno)
1753  {
1754  if (_Recc)
1755  {
1756  _Mostrar_Mensajes = true;
1757  Gestionar_Mensaje("Esta previsión procede de una factura acogida al Régimen Especial de Criterio de Caja y no se podrá eliminar.", "_Permite_Delete_Prevision");
1758  _Mostrar_Mensajes = false;
1759  llRetorno = false;
1760  }
1761  }
1762 
1763  if (llRetorno)
1764  {
1765  // Mirar si la previsión está refundida con otras previsiones ...
1766  if (_Refundir != "")
1767  {
1768  _Mostrar_Mensajes = true;
1769  Gestionar_Mensaje("La previsión que intenta borrar está incluida de una agrupación de previsiones. Para eliminarla, debe ir a la pantalla de agrupación manual de previsiones, " +
1770  "seleccionarla, y anular la agrupación.", "_Permite_Delete_Prevision");
1771  _Mostrar_Mensajes = false;
1772  llRetorno = false;
1773  }
1774 
1775  bool llAgrup = false;
1776  string lcConcepto = _Concepto.Trim();
1777  if (!string.IsNullOrWhiteSpace(lcConcepto))
1778  llAgrup = lcConcepto.IndexOf("FRAS") >= 0;
1779 
1780  if (!llAgrup)
1781  {
1782  bool llSerfact = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_serfact"));
1783  if (llSerfact)
1784  {
1785  if (_Factura.Substring(0, 2) == "A0") //Bug 183174
1786  llAgrup = true;
1787  }
1788  else
1789  {
1790  if (_Factura.ToString().Trim().Substring(0, 1) == "A") //Bug 183174
1791  llAgrup = true;
1792  }
1793  }
1794 
1795  // Mirar si la previsión es un refundido de otras previsiones ...
1796  if (_Factura.Trim().Substring(0, 1) == "A" && llAgrup)
1797  {
1798  string lcSql = "select factura " +
1799  "from " + DB.SQLDatabase("comunes", "previ_cl") + " " +
1800  "where empresa = " + DB.SQLString(lcEmpresa) + " " +
1801  "and refundir = " + DB.SQLString(_Factura);
1802  llOk = DB.SQLExec(lcSql, ref ldtResul);
1803 
1804  if (llOk && ldtResul.Rows.Count > 0)
1805  {
1806  _Mostrar_Mensajes = true;
1807  Gestionar_Mensaje("La previsión que intenta borrar es una agrupación de previsiones. Para eliminarla, debe ir a la pantalla de agrupación manual de previsiones, " +
1808  "seleccionarla y anular la agrupación.", "_Permite_Delete_Prevision");
1809  _Mostrar_Mensajes = false;
1810  llRetorno = false;
1811  }
1812 
1813  }
1814  }
1815 
1816  // Mirar si la previsión está asentada.
1817  if (llRetorno)
1818  {
1819  if (_Asiento && !string.IsNullOrWhiteSpace(_Asi))
1820  {
1821  ldtResul.Reset();
1822 
1823  string lcSql = "select numero " +
1824  "from " + DB.SQLDatabase("gestion", "asientos") + " " +
1825  "where empresa = " + DB.SQLString(lcEmpresa) + " " +
1826  "and asi = " + DB.SQLString(_Asi);
1827  llOk = DB.SQLExec(lcSql, ref ldtResul);
1828 
1829  if (llOk && ldtResul.Rows.Count > 0)
1830  {
1831  _Mostrar_Mensajes = true;
1832  Gestionar_Mensaje("La previsión que intenta borrar está contabilizada en el asiento " + ldtResul.Rows[0]["numero"].ToString().Trim(), "_Permite_Delete_Prevision");
1833  _Mostrar_Mensajes = false;
1834  llRetorno = false;
1835  }
1836  }
1837  }
1838 
1839  // Mirar si está cobrada o impagada
1840  if (llRetorno)
1841  {
1842  if (_Cobrada)
1843  {
1844  if (_Impagado == 'S')
1845  {
1846  _Mostrar_Mensajes = true;
1847  Gestionar_Mensaje("No se puede borrar la previsión por que está cobrada e impagada.", "_Permite_Delete_Prevision");
1848  _Mostrar_Mensajes = false;
1849  llRetorno = false;
1850  }
1851 
1852  if (llRetorno && _Fecha_Cobro != null && Convert.ToDateTime(_Fecha_Cobro).Year != Convert.ToInt16(_lcAny))
1853  {
1854  _Mostrar_Mensajes = true;
1855  Gestionar_Mensaje("No se puede borrar la previsión por que está cobrada y pertenece a otro ejercicio.", "_Permite_Delete_Prevision");
1856  _Mostrar_Mensajes = false;
1857  llRetorno = false;
1858  }
1859  }
1860  }
1861 
1862  FUNCTIONS._DisposeDatatable(ldtResul);
1863 
1864  this._Addons_Permite_Delete_Prevision(TipoExecute.After);
1865 
1866  return llRetorno;
1867  }
1868 
1869 
1877  public bool _PermitirCambioValor(object sender, string tcValorCandidato, out string tcMensaje)
1878  {
1879  tcMensaje = "";
1880 
1881  if ((this._Estado != sage.ew.ewbase.ewMante._EstadosMantenimiento.EsperandoCodigo) && (this._Estado != sage.ew.ewbase.ewMante._EstadosMantenimiento.EditandoRegistro) && (this._Estado != sage.ew.ewbase.ewMante._EstadosMantenimiento.MostrandoRegistro))
1882  {
1883  // Comprobamos si la divisa candidata es distinta de Euros y si este tiene Mandado indicado mostramos mensaje y no dejamos cambiar divisa
1885  if ((cmb._Codigo != tcValorCandidato) && (cmb._Codigo == EW_GLOBAL._Moneda._Codigo) && (tcValorCandidato != EW_GLOBAL._Moneda._Codigo) && (!String.IsNullOrWhiteSpace(_Mandato.ToString())))
1886  {
1887  tcMensaje = "Para modificar la divisa de la previsión se debe desasignar el mandato asignado";
1888  return false;
1889  }
1890  }
1891 
1892  return true;
1893  }
1894 
1895 
1907  public void _Clonar(PrevisionCobro toPrevision, string tcEmpresa, int tnEjercicio, string tcFactura, int tnOrden, int tnImpagado = 0, int tnPendiente = 0)
1908  {
1909  try
1910  {
1911  this._Addons_Clonar(TipoExecute.Before, toPrevision, tcEmpresa, tnEjercicio, tcFactura, tnOrden, tnImpagado, tnPendiente);
1912 
1913  if (toPrevision._oCli != null)
1914  this._oCli = toPrevision._oCli._Clonar();
1915 
1916  // Hay que establecer los campos de la clave principal primero y en este orden (PE-103582)
1917  this._Impagado = tnImpagado;
1918  this._Pendiente = tnPendiente;
1919  this._Empresa = tcEmpresa;
1920  this._Factura = tcFactura;
1921  this._Orden = tnOrden;
1922  this._Ejercicio = tnEjercicio;
1923 
1924  this._Cliente = toPrevision._Cliente;
1925  this._Banco = toPrevision._Banco;
1926  this._BancoPrevisto = toPrevision._BancoPrevisto;
1927  this._Forma_Pago = toPrevision._Forma_Pago;
1928  this._Pagare = toPrevision._Pagare;
1929  this._Refundir = toPrevision._Refundir;
1930  this._Divisa = toPrevision._Divisa;
1931  this._Vendedor = toPrevision._Vendedor;
1932  this._Cobrador = toPrevision._Cobrador;
1933  this._Referencia = toPrevision._Referencia;
1934  this._SIIFraMod = toPrevision._SIIFraMod;
1935 
1936  this._Asi = toPrevision._Asi;
1937  this._Mandato = toPrevision._Mandato;
1938  this._Impreso = toPrevision._Impreso;
1939  this._Impago = toPrevision._Impago;
1940  this._Concepto = toPrevision._Concepto;
1941  this._TipoGasto = toPrevision._TipoGasto;
1942  this._Remesa = toPrevision._Remesa;
1943  this._Num_Banco = toPrevision._Num_Banco;
1944  this._Asiento = toPrevision._Asiento;
1945  this._Recc = toPrevision._Recc;
1946  this._Sel = toPrevision._Sel;
1947 
1948  this._Fecha_Emision = toPrevision._Fecha_Emision;
1949  this._Fecha_Vencim = toPrevision._Fecha_Vencim;
1950  this._Fecha_Descuento = toPrevision._Fecha_Descuento;
1951  this._Fecha_Vencim2 = toPrevision._Fecha_Vencim2;
1952  this._Fecha_Operacion = toPrevision._Fecha_Operacion;
1953  this._Fecha_Remesa = toPrevision._Fecha_Remesa;
1954  this._Fecha_Cobro = toPrevision._Fecha_Cobro;
1955 
1956  this._Cambio = toPrevision._Cambio;
1957  this._Imppagare = toPrevision._Imppagare;
1958  this._Importe = toPrevision._Importe;
1959  this._ImporteDiv = toPrevision._ImporteDiv;
1960  this._Usuario = toPrevision._Usuario;
1961 
1962  this._Guid_Id = Guid.NewGuid().ToString().ToUpper();
1963 
1964 
1965  this._ImpagoGastosBancariosContabilizar = toPrevision._ImpagoGastosBancariosContabilizar;
1966  this._ImpagoGastosBancariosFecha = toPrevision._ImpagoGastosBancariosFecha;
1967  this._ImpagoGastosBancariosDivisa = toPrevision._ImpagoGastosBancariosDivisa;
1968  this._ImpagoGastosBancariosCambio = toPrevision._ImpagoGastosBancariosCambio;
1969  this._ImpagoGastosBancariosImporte = toPrevision._ImpagoGastosBancariosImporte;
1970  this._ImpagoGastosBancariosCuenta = toPrevision._ImpagoGastosBancariosCuenta;
1971 
1972  this._ImpagoNuevaFacturaGenerar = toPrevision._ImpagoNuevaFacturaGenerar;
1973  this._ImpagoNuevaFacturaNumero = toPrevision._ImpagoNuevaFacturaNumero;
1974  this._ImpagoNuevaFacturaCuenta = toPrevision._ImpagoNuevaFacturaCuenta;
1975  this._ImpagoNuevaFacturaTipoIva = toPrevision._ImpagoNuevaFacturaTipoIva;
1976  this._ImpagoNuevaFacturaContabilizar = toPrevision._ImpagoNuevaFacturaContabilizar;
1977 
1978  this._ImpagoRepercutirGastos = toPrevision._ImpagoRepercutirGastos;
1979  this._ImpagoRepercutirImporte = toPrevision._ImpagoRepercutirImporte;
1980  this._ImpagoRepercutirFacturaGenerar = toPrevision._ImpagoRepercutirFacturaGenerar;
1981  this._ImpagoRepercutirTipoIva = toPrevision._ImpagoRepercutirTipoIva;
1982  this._ImpagoRepercutirCuenta = toPrevision._ImpagoRepercutirCuenta;
1983 
1984  this._Addons_Clonar(TipoExecute.After, toPrevision, tcEmpresa, tnEjercicio, tcFactura, tnOrden, tnImpagado, tnPendiente);
1985  }
1986  catch (Exception loEx)
1987  {
1988  DB.Registrar_Error(loEx);
1989  }
1990 
1991  return;
1992  }
1993 
1994 
2003  public bool _Contabilizar(Dictionary<string, decimal> tdicCobros, DateTime tdFecha, decimal tnCambio, Asientos toAsiento = null)
2004  {
2005  this._Addons_Contabilizar(TipoExecute.Before, tdicCobros, tdFecha, tnCambio, toAsiento);
2006 
2007  Dictionary<string, Tuple<decimal, List<Tuple<decimal, string, string>>>> lDicCobrosComisiones = new Dictionary<string, Tuple<decimal, List<Tuple<decimal, string, string>>>>();
2008 
2009  foreach (KeyValuePair<string, decimal> loItem in tdicCobros)
2010  {
2011  var loListComisiones = new List<Tuple<decimal, string, string>>();
2012  var loTupleValor = new Tuple<decimal, List<Tuple<decimal, string, string>>>(loItem.Value, loListComisiones);
2013  lDicCobrosComisiones.Add(loItem.Key, loTupleValor);
2014  }
2015 
2016  bool llOk = _Contabilizar(lDicCobrosComisiones, tdFecha, tnCambio, toAsiento);
2017 
2018  this._Addons_Contabilizar(TipoExecute.After, tdicCobros, tdFecha, tnCambio, toAsiento);
2019 
2020  return llOk;
2021  }
2022 
2023 
2032  public bool _Contabilizar(Dictionary<string, Tuple<decimal, List<Tuple<decimal, string, string>>>> tdicCobros, DateTime tdFecha, decimal tnCambio, Asientos toAsiento = null)
2033  {
2034  bool llOk = true;
2035  Asientos loAsiento;
2036  decimal lnImporteEntrega = 0;
2037 
2038  this._Addons_Contabilizar(TipoExecute.Before, tdicCobros, tdFecha, tnCambio, toAsiento);
2039 
2040  foreach (KeyValuePair<string, Tuple<decimal, List<Tuple<decimal, string, string>>>> loItem in tdicCobros)
2041  {
2042  lnImporteEntrega = lnImporteEntrega + loItem.Value.Item1;
2043  }
2044 
2045  llOk = Contabilizar_Comprobacion(tdFecha, lnImporteEntrega);
2046 
2047  if (!llOk)
2048  return false;
2049 
2050  if (toAsiento == null)
2051  {
2052  loAsiento = new Asientos
2053  {
2054  _Fecha = tdFecha,
2055  _Divisa = _Divisa, //Asigno la divisa
2056  _Cambio = _Cambio
2057  };
2058  }
2059  else
2060  {
2061  loAsiento = toAsiento;
2062  }
2063 
2064  //T115472 No tiene en cuenta la multidivisa
2066  //loAsiento._Add(this._Cliente, "Cobro FRA. " + this._Factura.Trim() + "/" + this._Orden.ToString().Trim(), Asientos.DebeHaber.Haber, lnImporteEntrega);
2067 
2069  //foreach (KeyValuePair<string, decimal> loItem in tdicCobros)
2070  //{
2071  // // Guardo com a banc el de la primera forma de cobro
2072  // if (string.IsNullOrWhiteSpace(this._Banco))
2073  // this._Banco = loItem.Key;
2074 
2075  // loAsiento._Add(loItem.Key, "Cobro FRA. " + this._Factura.Trim() + "/" + this._Orden.ToString().Trim(), Asientos.DebeHaber.Debe, loItem.Value);
2076  //}
2077 
2078  //T115472 Se cambia para que tenga en cuenta la multidivisa
2079  IAsientosLinea loLineaAsiento1;
2080  if (loAsiento._Lineas.Count <= 0)
2081  {
2082  loLineaAsiento1 = loAsiento._AddLinea();
2083 
2084  loLineaAsiento1._Cuenta = _Cliente;
2085  loLineaAsiento1._Definicion = "Cobro FRA. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
2086 
2087  if (!string.IsNullOrWhiteSpace(this._Referencia))
2088  loLineaAsiento1._Referencia = this._Referencia;
2089  }
2090  else
2091  {
2092  loLineaAsiento1 = loAsiento._Lineas.First();
2093  }
2094 
2095  if (loAsiento._Divisa == EW_GLOBAL._Empresa._Moneda)
2096  {
2097  // Ya hemos añadido la línea del banco anteriormente, actualizamos importes
2098  loLineaAsiento1._Haber += lnImporteEntrega;
2099  }
2100  else
2101  {
2102  loLineaAsiento1._HaberDiv += lnImporteEntrega;
2103  }
2104 
2105  foreach (KeyValuePair<string, Tuple<decimal, List<Tuple<decimal, string, string>>>> loItem in tdicCobros)
2106  {
2107  decimal lnImporteCuenta = loItem.Value.Item1;
2108  //CCR 185453: foreach de las comisiones si las tiene
2109  if (loItem.Value.Item2 != null && loItem.Value.Item2.Count > 0)
2110  {
2111  foreach (Tuple<decimal, string, string> loComision in loItem.Value.Item2)
2112  {
2113  //Para cada comision insertar una linea (apunte de asiento) y restar el importe del total del banco
2114  IAsientosLinea loLineaAsientoComis = loAsiento._AddLinea();
2115  loLineaAsientoComis._Cuenta = loComision.Item3; //Cuenta comision
2116  loLineaAsientoComis._Definicion = "COMISIONES " + loComision.Item3; //Forma cobro
2117  if (loAsiento._Divisa == EW_GLOBAL._Empresa._Moneda)
2118  {
2119  loLineaAsientoComis._Debe = loComision.Item1;
2120  loLineaAsientoComis._Cambio = 1;
2121  }
2122  else
2123  {
2124  loLineaAsientoComis._Debe = FUNCTIONS._Round(loComision.Item1 * _Cambio, _loDivMonedaEmpresa._MascaraImporte._Num_Decimales);
2125  loLineaAsientoComis._Cambio = _Cambio;
2126  }
2127  lnImporteCuenta = lnImporteCuenta - loComision.Item1;
2128 
2129  if (!string.IsNullOrWhiteSpace(this._Referencia))
2130  loLineaAsientoComis._Referencia = this._Referencia;
2131  }
2132  }
2133 
2134  if (string.IsNullOrWhiteSpace(_Banco)) _Banco = loItem.Key;
2135 
2136  IAsientosLinea loLineaAsiento2 = loAsiento._AddLinea();
2137 
2138  loLineaAsiento2._Cuenta = loItem.Key;
2139  loLineaAsiento2._Definicion = "Cobro FRA. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
2140 
2141  if (loAsiento._Divisa == EW_GLOBAL._Empresa._Moneda)
2142  {
2143  loLineaAsiento2._Debe = lnImporteCuenta;
2144  loLineaAsiento2._Cambio = 1;
2145  }
2146  else
2147  {
2148  // loLineaAsiento2._Debe = loItem.Value * _Cambio;
2149  loLineaAsiento2._Debe = FUNCTIONS._Round(lnImporteCuenta * _Cambio, _loDivMonedaEmpresa._MascaraImporte._Num_Decimales);
2150  loLineaAsiento2._Cambio = _Cambio;
2151  }
2152  loLineaAsiento2._DebeDiv = lnImporteCuenta;
2153  loLineaAsiento2._Cambio = _Cambio;
2154 
2155  if (!string.IsNullOrWhiteSpace(this._Referencia))
2156  loLineaAsiento2._Referencia = this._Referencia;
2157  }
2158 
2159  // Grabo el asiento que he creado
2160  if (toAsiento == null)
2161  {
2162  if (!loAsiento._Save()) //Bug 124235 - si no es pot generar l'assentament que no continui i q avisi
2163  {
2164  string lcMensaje = loAsiento._Mensaje_Error.Substring(loAsiento._Mensaje_Error.Trim().Length - 1, 1) == "." ? "" : ".";
2165  lcMensaje = loAsiento._Mensaje_Error + lcMensaje;
2166 
2167  if (_LinkForm)
2168  FUNCTIONS._MessageBox("No se ha contabilizado la previsión. " + Environment.NewLine + lcMensaje, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
2169  else
2170  _Error_Message = "No se ha contabilizado la previsión. " + lcMensaje;
2171 
2172  return false;
2173  }
2174 
2175  //T115472
2176  _GeneraDiferenciasCambio(tdFecha, lnImporteEntrega, tnCambio, _GenerarDiferenciasCobro);
2177 
2178  }
2179 
2181 
2182  // PARTE 92883. Actualizamos primero la previsión como cobrada, posteriormente ya vaciaremos los campos si es necesario
2183  _Asiento = true;
2184  _Fecha_Cobro = tdFecha;
2185  _Asi = loAsiento._Lineas[0]._Asi.Trim();
2186 
2187  // Ahora dentro del procedimiento realizaremos el "Save", pues antes de guardar el nuevo vencimiento con "Pendiente 0" tenemos de gaurdar la previsión original con "Pendiente 1"
2188  llOk = Contabilizar_Duplicar_Prevision(lnImporteEntrega);
2189 
2190  this._Addons_Contabilizar(TipoExecute.After, tdicCobros, tdFecha, tnCambio, toAsiento);
2191 
2192  return llOk;
2193  }
2194 
2195 
2203  public void _GeneraDiferenciasCambio(DateTime tdFecha, decimal lnImporteEntrega, decimal tnCambio, bool tlForzar = false)
2204  {
2205  if (tnCambio != _Cambio && (tlForzar || DialogResult.Yes == Gestionar_Pregunta(string.Format("Se han detectado diferencias de cambio.{0}¿Desea contabilizar dichas diferencias?", Environment.NewLine), MessageBoxButtons.YesNo, DialogResult.No)))
2206  {
2208  {
2209  _Fecha = tdFecha
2210  };
2211 
2212  List<IAsientosPrevisionesGeneradorLinea> loList = new List<IAsientosPrevisionesGeneradorLinea>();
2214  {
2215  _Automatico = true,
2216  _Cuenta = _Cliente,
2217  _CuentaBancaria = _Banco, //Bug 116312
2218  _DefinicionAsiento = "DIFERENCIAS DE CAMBIO COBRO FRA. " + _Factura.Trim() + "/" + _Orden.ToString(),
2219 
2220  _Factura = _Factura,
2221  _Orden_Numereb = _Orden,
2222  _Entrega = lnImporteEntrega,
2223  _Cambio = tnCambio,
2224  _Importe = _Importe,
2225  _Emision = _Fecha_Emision,
2226  _Prevision = true,
2227  _Periodo = _Ejercicio,
2228  _Pendiente = _Pendiente,
2229  _Vencimiento = _Fecha_Vencim,
2230  _Divisa = _Divisa,
2231  _CambioPrevision = _Cambio,
2232  _Referencia = _Referencia
2233  };
2234 
2235  loList.Add(loLin);
2236 
2237  Asientos loAsientoDif = CONTABILIDAD._AsientoDiferenciasCambio(loList);
2238  loAsientoDif._Fecha = tdFecha;
2239  loAsientoDif._Save();
2240  }
2241  }
2242 
2243 
2254  public void _GeneraDiferenciasCambio(DateTime tdFecha, decimal lnImporteEntrega, decimal tnCambio, AsientosCobrosGeneradorLinea loLin, List<IAsientosPrevisionesGeneradorLinea> loList, bool tlForzar = false, bool tlFinal = false)
2255  {
2256  if (tnCambio != _Cambio && (tlForzar || DialogResult.Yes == Gestionar_Pregunta(string.Format("Se han detectado diferencias de cambio.{0}¿Desea contabilizar dichas diferencias?", Environment.NewLine), MessageBoxButtons.YesNo, DialogResult.No)))
2257  {
2258  loLin._Automatico = true;
2259  loLin._Cuenta = _Cliente;
2260  loLin._CuentaBancaria = _Banco; //Bug 116312
2261  loLin._DefinicionAsiento = "DIFERENCIAS DE CAMBIO COBRO FRA. " + _Factura.Trim() + "/" + _Orden.ToString();
2262 
2263  loLin._Factura = _Factura;
2264  loLin._Orden_Numereb = _Orden;
2265  loLin._Entrega = lnImporteEntrega;
2266  loLin._Cambio = tnCambio;
2267  loLin._Importe = _Importe;
2268  loLin._Emision = _Fecha_Emision;
2269  loLin._Prevision = true;
2270  loLin._Periodo = _Ejercicio;
2271  loLin._Pendiente = _Pendiente;
2272  loLin._Vencimiento = _Fecha_Vencim;
2273  loLin._Divisa = _Divisa;
2274  loLin._CambioPrevision = _Cambio;
2275  loLin._Referencia = _Referencia;
2276 
2277  loList.Add(loLin);
2278  }
2279  }
2280 
2286  public bool _ExisteCuenta(string Cliente)
2287  {
2288  string CuentaCliente = string.Empty;
2289 
2290  CuentaCliente = Convert.ToString(DB.SQLValor("CUENTAS", "CODIGO", Cliente, "CODIGO"));
2291 
2292  if (string.IsNullOrWhiteSpace(CuentaCliente))
2293  {
2294  _Error_Message = "No se ha contabilizado la previsión porque no existe la cuenta contable: " + Cliente.ToString();
2295  return false;
2296  }
2297 
2298  return true;
2299  }
2300 
2309  public bool _Contabilizar(string tcBanco, DateTime tdFecha, decimal tnImporteEntrega, Asientos toAsiento = null)
2310  {
2311  this._Addons_Contabilizar(TipoExecute.Before, tcBanco, tdFecha, tnImporteEntrega, toAsiento);
2312 
2313  bool llOk = _Contabilizar(tcBanco, tdFecha, tnImporteEntrega, _Cambio, toAsiento);
2314 
2315  this._Addons_Contabilizar(TipoExecute.After, tcBanco, tdFecha, tnImporteEntrega, toAsiento);
2316 
2317  return llOk;
2318 
2319  }
2320 
2321 
2334  public bool _Contabilizar(string tcBanco, DateTime tdFecha, decimal tnImporteEntrega, decimal tnCambio, Asientos toAsiento = null, bool tlGroup = false, bool tlIdenticoClien = false)
2335  {
2336  bool llOk = true;
2337  string lcSql = string.Empty;
2338  Asientos loAsiento;
2339 
2340  this._Addons_Contabilizar(TipoExecute.Before, tcBanco, tdFecha, tnImporteEntrega, tnCambio, toAsiento, tlGroup);
2341 
2342  llOk = Contabilizar_Comprobacion(tdFecha, tnImporteEntrega); // 85029
2343 
2344  if (!llOk)
2345  return false;
2346 
2347  string lcNomCliente = string.Empty;
2348  if (_oCliente == null)
2349  lcNomCliente = Convert.ToString(DB.SQLValor("CLIENTES", "CODIGO", _Cliente, "NOMBRE"));
2350  else
2351  lcNomCliente = Convert.ToString(_oCliente._Campo("nombre"));
2352 
2353  if (toAsiento == null)
2354  {
2355  loAsiento = new Asientos
2356  {
2357  _Fecha = tdFecha,
2358  _Divisa = _Divisa
2359  };
2360  }
2361  else
2362  loAsiento = toAsiento;
2363 
2364  _Banco = tcBanco;
2365 
2366  #region Linea 1
2367 
2368  // Primera línea del asiento (CUENTA BANCO DONDE COBRAMOS)
2369  IAsientosLinea loLineaAsiento1;
2370  if (loAsiento._Lineas.Count <= 0)
2371  {
2372  loLineaAsiento1 = loAsiento._AddLinea();
2373 
2374  loLineaAsiento1._Cuenta = tcBanco;
2375  if (!tlGroup)
2376  loLineaAsiento1._Definicion = "Cobro FRA. " + _Factura.Trim() + "/" + _Orden.ToString().Trim() + " " + lcNomCliente;
2377  else
2378  loLineaAsiento1._Definicion = (tlIdenticoClien ? "COBROS DE " + lcNomCliente : "COBROS DEL DIA");
2379 
2380  loLineaAsiento1._Cambio = tnCambio;
2381  loLineaAsiento1._Haber = decimal.Zero;
2382  loLineaAsiento1._HaberDiv = decimal.Zero;
2383 
2384  if (tlIdenticoClien)
2385  loLineaAsiento1._ContrapartidaAsiento = _Cliente;
2386 
2387  // Si la previsión llega con nº de referencia, anoto este nº de referencia en la partida del asietno de cobro de la
2388  // previsión.
2389  //
2390  if (!string.IsNullOrWhiteSpace(_Referencia))
2391  loLineaAsiento1._Referencia = _Referencia;
2392  }
2393  else
2394  {
2395  loLineaAsiento1 = loAsiento._Lineas.First();
2396  }
2397 
2398  if (loAsiento._Divisa == EW_GLOBAL._Empresa._Moneda)
2399  {
2400  loLineaAsiento1._Debe += tnImporteEntrega;
2401  }
2402  else
2403  {
2404  loLineaAsiento1._DebeDiv += tnImporteEntrega;
2405  }
2406 
2407  #endregion Linea 1
2408 
2409  #region Linea 2
2410 
2411  // Resta de líneas del asiento (COBROS DE CADA FACTURA DEL CLIENTE)
2412  IAsientosLinea loLineaAsiento2 = loAsiento._AddLinea();
2413 
2414  loLineaAsiento2._Cuenta = _Cliente;
2415  loLineaAsiento2._Definicion = "Cobro FRA. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
2416  loLineaAsiento2._Cambio = tnCambio;
2417  loLineaAsiento2._Debe = decimal.Zero;
2418  loLineaAsiento2._DebeDiv = decimal.Zero;
2419 
2420  if (loAsiento._Divisa == EW_GLOBAL._Empresa._Moneda)
2421  {
2422  loLineaAsiento2._Haber = tnImporteEntrega;
2423  }
2424  else
2425  {
2426  loLineaAsiento2._HaberDiv = tnImporteEntrega;
2427  }
2428 
2429  // Si la previsión llega con nº de referencia, anoto este nº de referencia en la partida del asietno de cobro de la
2430  // previsión.
2431  //
2432  if (!string.IsNullOrWhiteSpace(_Referencia))
2433  loLineaAsiento2._Referencia = _Referencia;
2434 
2435  #endregion Linea 2
2436 
2437  if (toAsiento == null) // Grabo el asiento que he creado
2438  {
2439  if (!loAsiento._Save()) //Bug 124235 - si no es pot generar l'assentament que no continui i q avisi
2440  {
2441  string lcMensaje = loAsiento._Mensaje_Error.Substring(loAsiento._Mensaje_Error.Trim().Length - 1, 1) == "." ? "" : ".";
2442  lcMensaje = loAsiento._Mensaje_Error + lcMensaje;
2443 
2444  if (_LinkForm)
2445  FUNCTIONS._MessageBox("No se ha contabilizado la previsión. " + Environment.NewLine + lcMensaje, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
2446  else
2447  _Error_Message = "No se ha contabilizado la previsión. " + lcMensaje;
2448 
2449  return false;
2450  }
2451 
2452  _GeneraDiferenciasCambio(tdFecha, tnImporteEntrega, tnCambio, _GenerarDiferenciasCobro); //T11293 Diferencias de cambio
2453  }
2454 
2455  // PARTE 92883. Actualizamos primero la previsión como cobrada, posteriormente ya vaciaremos los campos si es necesario
2456  _Asiento = true;
2457  _Fecha_Cobro = tdFecha;
2458  _Asi = loAsiento._Lineas.First()._Asi.Trim(); // Compte que aqui el [1] no es el nº de element de la colecció sino el camp LINEA
2459 
2460  llOk = Contabilizar_Duplicar_Prevision(tnImporteEntrega); // Ahora dentro del procedimiento realizaremos el "Save", pues antes de guardar el nuevo vencimiento con "Pendiente 0" tenemos de gaurdar la previsión original con "Pendiente 1"
2461 
2462  _Addons_Contabilizar(TipoExecute.After, tcBanco, tdFecha, tnImporteEntrega, tnCambio, toAsiento, tlGroup);
2463 
2464  return llOk;
2465  }
2466 
2467 
2477  public bool _Contbilizar_VincularPrevisionConAsiento(DateTime tdFecha, string tcAsi, string tcBanco)
2478  {
2479  _Asiento = true;
2480  _Fecha_Cobro = tdFecha;
2481  _Asi = tcAsi;
2482  _Banco = tcBanco;
2483  return _Save();
2484  }
2485 
2486 
2497  public bool _Contabilizar(string tcBanco, DateTime tdFecha, decimal tnImporteEntrega, string tcAsi)
2498  {
2499  if (!Contabilizar_Comprobacion(tdFecha, tnImporteEntrega))
2500  return false;
2501 
2502  this._Addons_Contabilizar(TipoExecute.Before, tcBanco, tdFecha, tnImporteEntrega, tcAsi);
2503 
2504  // Actualizamos primero la previsión como cobrada, posteriormente ya vaciaremos los campos si es necesario
2505  _Banco = tcBanco;
2506  _Asiento = true;
2507  _Fecha_Cobro = tdFecha;
2508  _Asi = tcAsi;
2509 
2510  // Ahora dentro del procedimiento realizaremos el "Save", pues antes de guardar el nuevo vencimiento con "Pendiente 0" tenemos de gaurdar la previsión original con "Pendiente 1"
2511  //
2512  bool llOk = Contabilizar_Duplicar_Prevision(tnImporteEntrega);
2513 
2514  this._Addons_Contabilizar(TipoExecute.After, tcBanco, tdFecha, tnImporteEntrega, tcAsi);
2515 
2516  return llOk;
2517  }
2518 
2519 
2524  public DataTable _HistoricoRecibos()
2525  {
2526  DataTable ldtHistorico = new DataTable();
2527  DataTable ldtHistorico1 = new DataTable();
2528  DataTable ldtHistorico2 = new DataTable();
2529  DataTable ldtHistorico3 = new DataTable();
2530 
2531  string lcSql = string.Empty;
2532  string lcCondicion = string.Empty;
2533  bool llTrobat = false;
2534  string lcGuid_Id = string.Empty;
2535 
2536  lcSql = " SELECT guid_idori as GUID_ID, tipo, 2 as origen FROM " + DB.SQLDatabase("COMUNES", "IMPAGOS");
2537  lcSql += " WHERE guid_iddes = " + DB.SQLString(_Guid_Id) + " ";
2538  DB.SQLExec(lcSql, ref ldtHistorico);
2539 
2540  lcGuid_Id = _Guid_Id;
2541  if (ldtHistorico != null && ldtHistorico.Rows.Count == 1)
2542  {
2543  lcGuid_Id = Convert.ToString(ldtHistorico.Rows[0]["guid_id"]);
2544  }
2545 
2546 
2547  lcSql = " SELECT guid_iddes as GUID_ID, tipo, 1 as origen FROM " + DB.SQLDatabase("COMUNES", "IMPAGOS");
2548  lcSql += " WHERE guid_idori = " + DB.SQLString(lcGuid_Id) + " ";
2549  DB.SQLExec(lcSql, ref ldtHistorico);
2550 
2551 
2552  if (ldtHistorico != null)
2553  {
2554  lcCondicion = " p.guid_id = " + DB.SQLString(lcGuid_Id) + " ";
2555 
2556  foreach (DataRow ldrItem in ldtHistorico.Rows)
2557  {
2558  lcCondicion += " OR " + " p.guid_id = " + DB.SQLString(ldrItem["GUID_ID"].ToString().Trim()) + " ";
2559  llTrobat = true;
2560  }
2561 
2562  // Montamos la consulta de las previsiones
2563 
2564  lcSql = "SELECT p.Empresa,p.periodo,p.cliente as cuenta,c.nombre as nombre_cuenta,p.factura,p.orden,p.divisa,p.emision,p.vencim,'PC' as tipo,p.guid_id, " +
2565  "p.impagado as num_impago,p.pendiente,p.importe,p.ImporteDiv, " + Divisa._ObtenerSqlDivisa("MONEDA", "divisa") + ", " +
2566  "p.asi,p.concepto,(CASE WHEN impago='S' THEN cast(1 as bit) ELSE cast(0 as bit) END) AS impagado,(CASE WHEN banco<>'' THEN cast(1 as bit) ELSE cast(0 as bit) END) AS cobrada " +
2567  "FROM " + DB.SQLDatabase("COMUNES", "PREVI_CL") + " p " +
2568  "LEFT JOIN " + DB.SQLDatabase("GESTION", "CLIENTES") + " c ON p.cliente=c.codigo " +
2569  "LEFT JOIN " + DB.SQLDatabase("gestion", "moneda") + " MONEDA ON p.divisa=MONEDA.codigo ";
2570 
2571 
2572  if (!string.IsNullOrWhiteSpace(lcCondicion) && llTrobat)
2573  lcSql += " WHERE ( " + lcCondicion + " )" + " And " + "p.EMPRESA = " + DB.SQLString(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
2574  else
2575  lcSql += " WHERE 1=2 " + " And " + "p.EMPRESA = " + DB.SQLString(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
2576 
2577 
2578 
2579  DB.SQLExec(lcSql, ref ldtHistorico1);
2580 
2581 
2582  // Montamos la consulta de las previsiones
2583 
2584  lcSql = "SELECT p.Empresa,p.periodo,p.proveedor as cuenta,c.nombre as nombre_cuenta,p.factura,p.numereb as orden,p.divisa,p.emision,p.vencim,'PP' as tipo,p.guid_id, " +
2585  "0 AS num_impago,p.pendiente,p.importe,p.ImporteDiv, " + Divisa._ObtenerSqlDivisa("MONEDA", "divisa") + ", " +
2586  "p.asi,p.concepto," + DB.SQLFalse() + " as impagado,(CASE WHEN pagada='S' THEN cast(1 as bit) ELSE cast(0 as bit) END) as cobrada " +
2587  "FROM " + DB.SQLDatabase("COMUNES", "PREVIS") + " p " +
2588  "LEFT JOIN " + DB.SQLDatabase("GESTION", "PROVEED") + " c ON p.proveedor=c.codigo " +
2589  "LEFT JOIN " + DB.SQLDatabase("gestion", "moneda") + " MONEDA ON p.divisa=MONEDA.codigo ";
2590 
2591 
2592  if (!string.IsNullOrWhiteSpace(lcCondicion) && llTrobat)
2593  lcSql += " WHERE ( " + lcCondicion + " ) " + " And " + "p.EMPRESA = " + DB.SQLString(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
2594  else
2595  lcSql += " WHERE 1=2 " + " And " + "p.EMPRESA = " + DB.SQLString(Convert.ToString(EW_GLOBAL._GetVariable("wc_empresa")));
2596 
2597  DB.SQLExec(lcSql, ref ldtHistorico2);
2598 
2599  ldtHistorico = ldtHistorico1;
2600  if (ldtHistorico2 != null && ldtHistorico2.Rows.Count > 0)
2601  DBfunctions.SQLUnionDatatable(ref ldtHistorico, ldtHistorico2);
2602  }
2603 
2604  return ldtHistorico;
2605  }
2606 
2607 
2613  public bool _Impagar(DateTime tdFechaAsientoImpago)
2614  {
2615  bool llOk = false;
2616 
2617  this._Addons_Impagar(TipoExecute.Before, tdFechaAsientoImpago);
2618 
2619  // No tenemos cargado objeto de prevision de cobro, no permitimos realizar operación.
2620  if (string.IsNullOrWhiteSpace(_Factura) || string.IsNullOrWhiteSpace(_Empresa))
2621  {
2622  Gestionar_Mensaje("El objeto PrevisionCobro no está cargado.", "_Impagar");
2623  return false;
2624  }
2625 
2626  // La previsión de cobro en la que estamos ya es un impagado ...
2627  if (_Impagado != 0)
2628  {
2629  Gestionar_Mensaje("La previsión de cobro " + _Factura.Trim() + "/" + _Orden.ToString().Trim() + " ya es un impagado.", "_Impagar");
2630  return false;
2631  }
2632 
2633  // La previsión de cobro en la que estamos no ha sido asentada ...
2634  if (!_Asiento)
2635  {
2636  Gestionar_Mensaje("La previsión de cobro " + _Factura.Trim() + "/" + _Orden.ToString().Trim() + " no ha sido contabilizada.", "_Impagar");
2637  return false;
2638  }
2639 
2640  int lnOtroImp = _Obtener_Numero_Impagos() + 1;
2641 
2642  Revisar_Tpv_Tikets(lnOtroImp);
2643 
2644  llOk = _Save();
2645 
2646  if (llOk)
2647  {
2648  PrevisionCobro loPrevisionNueva = Generar_Prevision_Impago(lnOtroImp);
2649 
2650  // Asiento de impago
2651 
2652  if (!loPrevisionNueva._ImpagoNuevaFacturaGenerar)
2653  {
2654  llOk = Impago_Cargo_Empresa(loPrevisionNueva, tdFechaAsientoImpago);
2655  }
2656  else
2657  {
2658  llOk = Impago_Gastos_Nueva_Factura(loPrevisionNueva, tdFechaAsientoImpago);
2659  }
2660 
2661  if (loPrevisionNueva._ImpagoRepercutirGastos)
2662  {
2663  if (!loPrevisionNueva._ImpagoRepercutirFacturaGenerar)
2664  {
2665  llOk = Repercutir_Gastos_Cliente(loPrevisionNueva, tdFechaAsientoImpago);
2666  }
2667  else
2668  {
2669  llOk = Repercutir_Gastos_Nueva_Factura(loPrevisionNueva, tdFechaAsientoImpago);
2670  }
2671  }
2672  }
2673 
2674  this._Addons_Impagar(TipoExecute.After, tdFechaAsientoImpago);
2675 
2676  return llOk;
2677  }
2678 
2679 
2685  public ArrayList FechasEjercicio(string ejercicio)
2686  {
2687  ArrayList ret = new ArrayList();
2688  DataTable dt = new DataTable();
2689  string lcSql = "SELECT PERIODOINI, PERIODOFIN FROM " + DB.SQLDatabase("COMUNES", "EJERCICI") + " WHERE [ANY]=" + DB.SQLString(ejercicio);
2690  DB.SQLExec(lcSql, ref dt);
2691  if (dt != null && dt.Rows.Count > 0)
2692  {
2693  ret.Add(dt.Rows[0]["PERIODOINI"]);
2694  ret.Add(dt.Rows[0]["PERIODOFIN"]);
2695  }
2696  return ret;
2697  }
2698 
2699 
2704  public bool _Perdonar()
2705  {
2706  string lcMsg = string.Empty;
2707 
2708  this._Addons_Perdonar(TipoExecute.Before);
2709 
2710  // si la previsió està cobrada, no faig res
2711  if (_Cobrada)
2712  {
2713  Gestionar_Mensaje("La previsión ya está cobrada.", "_Perdonar");
2714  return false;
2715  }
2716 
2717  if (_Recc)
2718  {
2719  Gestionar_Mensaje("Esta previsión corresponde a una factura acogida a RECC. No es posible marcarla como cobrada sin contabilizarla.", "_Perdonar");
2720  return true;
2721  }
2722 
2723  // paguem la previsió
2724 
2725  if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_Contaplus")))
2726  {
2727  if (!string.IsNullOrWhiteSpace(_Pagare))
2728  {
2729  lcMsg = "La previsión está incluida en el pagaré nº " + _Pagare.Trim() +
2730  Environment.NewLine + Environment.NewLine +
2731  "¿ Desea dar como cobrada esta previsión ?";
2732  }
2733  }
2734  else
2735  {
2736  if (!string.IsNullOrWhiteSpace(_Pagare))
2737  {
2738  lcMsg = "La previsión está incluida en el pagaré nº " + _Pagare.Trim() +
2739  Environment.NewLine + Environment.NewLine +
2740  "IMPORTANTE: la previsión no se contabilizará. " + Environment.NewLine +
2741  "Por tanto no se tendrá registro de esta previsión " + Environment.NewLine +
2742  "en asientos ni en el extracto para este cliente " + Environment.NewLine + Environment.NewLine +
2743  "¿ Desea dar como cobrada esta previsión ?";
2744  }
2745  }
2746 
2747  // Bug 108034
2748  if (string.IsNullOrWhiteSpace(lcMsg))
2749  {
2750  lcMsg = "IMPORTANTE: La previsión no se contabilizará. " + Environment.NewLine +
2751  "Por tanto no se tendrá registro de esta previsión en asientos ni en el extracto para este cliente. " + Environment.NewLine +
2752  "¿ Desea dar como cobrada esta previsión ? ";
2753  }
2754  // fi Bug 108034
2755 
2756 
2757 
2758  if (string.IsNullOrWhiteSpace(lcMsg) || DialogResult.Yes == FUNCTIONS._MessageBox(lcMsg, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2, DialogResult.No))
2759  {
2760 
2761  string cBancoTemp = string.Empty;
2762 
2763  // Por defecto en dicha casilla se propondrá el primer valor informado de los siguientes siguiendo el orden indicado:
2764  // 1 - Banco informado en la ficha del cliente de la previsión. (CLIENTES.BANCO)
2765  cBancoTemp = _oCliente._BancoPrevisto;
2766 
2767  if (string.IsNullOrWhiteSpace(cBancoTemp))
2768  {
2769  // 2 - Banco previsto de la previsión. (PREVI_CL.BANCO_PREV)
2770  cBancoTemp = _BancoPrevisto;
2771  }
2772 
2773  if (string.IsNullOrWhiteSpace(cBancoTemp))
2774  {
2775  // 3 - Cuenta contable estándar de banco.  (CODCOM.BANCO)
2776  cBancoTemp = Convert.ToString(EW_GLOBAL._GetVariable("wc_banco"));
2777  }
2778 
2779  frmCobros lofrmCobros = new frmCobros(_Cliente, false, this, cBancoTemp, true, _Fecha_Vencim);
2780  lofrmCobros._SoloBanco = true;
2781  lofrmCobros.ShowDialog();
2782 
2783  if (lofrmCobros.DialogResult == DialogResult.OK)
2784  {
2785  // Obtener banco seleccionado
2786  _Banco = lofrmCobros._Banco;
2787  _Fecha_Cobro = lofrmCobros._FechaCobro;
2788  _Save();
2789  }
2790  }
2791 
2792  this._Addons_Perdonar(TipoExecute.After);
2793 
2794  return true;
2795  }
2796 
2797 
2802  public String _Validar_Cuentas_Bancarias(string tcCuenta)
2803  {
2804  String lcError = "";
2805  bool llOk = false;
2806 
2807  // Busco els comptes de puente de la caixa
2808  string _cCuentaPuenteCobro = string.Empty;
2809  string _cCuentaPuentePago = string.Empty;
2810  string _cCuentaPuenteReposicion = string.Empty;
2811  string _cCuentaPuenteRetirada = string.Empty;
2812  string _cCuentaPuente = string.Empty;
2813 
2814  string lcCajaActiva = Convert.ToString(EW_GLOBAL._GetVariable("wc_cajatpv"));
2815  string lcCuenta = tcCuenta.ToString().Substring(0, 2);
2816 
2817  if (!string.IsNullOrWhiteSpace(lcCajaActiva))
2818  {
2819  _cCuentaPuenteCobro = Convert.ToString(DB.SQLValor("CAJAS", "CODIGO", lcCajaActiva, "COBRO", "TPV"));
2820  if (!string.IsNullOrWhiteSpace(_cCuentaPuenteCobro))
2821  {
2822  _cCuentaPuenteCobro = _cCuentaPuenteCobro.ToString().Substring(0, 2);
2823  if (lcCuenta.Contains(_cCuentaPuenteCobro))
2824  llOk = true;
2825  }
2826 
2827  _cCuentaPuentePago = Convert.ToString(DB.SQLValor("CAJAS", "CODIGO", lcCajaActiva, "PAGO", "TPV"));
2828  if (!string.IsNullOrWhiteSpace(_cCuentaPuentePago))
2829  {
2830  _cCuentaPuentePago = _cCuentaPuentePago.ToString().Substring(0, 2);
2831  if (lcCuenta.Contains(_cCuentaPuentePago))
2832  llOk = true;
2833  }
2834 
2835  _cCuentaPuenteReposicion = Convert.ToString(DB.SQLValor("CAJAS", "CODIGO", lcCajaActiva, "COBRO", "TPV"));
2836  if (!string.IsNullOrWhiteSpace(_cCuentaPuenteReposicion))
2837  {
2838  _cCuentaPuenteReposicion = _cCuentaPuenteReposicion.ToString().Substring(0, 2);
2839  if (lcCuenta.Contains(_cCuentaPuenteReposicion))
2840  llOk = true;
2841 
2842  }
2843 
2844  _cCuentaPuenteRetirada = Convert.ToString(DB.SQLValor("CAJAS", "CODIGO", lcCajaActiva, "PAGO", "TPV"));
2845  if (!string.IsNullOrWhiteSpace(_cCuentaPuenteRetirada))
2846  {
2847  _cCuentaPuenteRetirada = _cCuentaPuenteRetirada.ToString().Substring(0, 2);
2848  if (lcCuenta.Contains(_cCuentaPuenteRetirada))
2849  llOk = true;
2850 
2851  }
2852 
2853  }
2854 
2855  if (!string.IsNullOrWhiteSpace(_cEntrega))
2856  {
2857  _cEntrega = _cEntrega.ToString().Substring(0, 3);
2858  if (tcCuenta.ToString().Substring(0, 3).Contains(_cEntrega))
2859  llOk = true;
2860  }
2861 
2862  if (!string.IsNullOrWhiteSpace(_cBanco))
2863  {
2864  _cBanco = _cBanco.ToString().Substring(0, 2);
2865  if (lcCuenta.Contains(_cBanco))
2866  llOk = true;
2867  }
2868 
2869  if (!string.IsNullOrWhiteSpace(_cEfec_dto))
2870  {
2871  _cEfec_dto = _cEfec_dto.ToString().Substring(0, 2);
2872  if (lcCuenta.Contains(_cEfec_dto))
2873  llOk = true;
2874 
2875  }
2876 
2877 
2878  // Cuenta puente tabla CODCOM
2879  DataTable ldtCodCom = new DataTable();
2880  String lcSql;
2881  lcSql = String.Format("SELECT * FROM {0}", DB.SQLDatabase("COMUNES", "CODCOM"));
2882  DB.SQLExec(lcSql, ref ldtCodCom);
2883 
2884  _cCuentaPuente = ldtCodCom.Rows.Count > 0 ? Convert.ToString(ldtCodCom.Rows[0]["ctapuente"]) : "";
2885  if (!string.IsNullOrWhiteSpace(_cCuentaPuente))
2886  {
2887  _cCuentaPuente = _cCuentaPuente.ToString().Substring(0, 2);
2888  if (lcCuenta.Contains(_cCuentaPuente))
2889  llOk = true;
2890  }
2891 
2892  if (!llOk)
2893  lcError = "La cuenta no existe ";
2894 
2895 
2896  return lcError;
2897  }
2898 
2913  [Obsolete("Método obsoleto a partir de 1 de Octubre 2023, a raiz de las adaptaciones realizadas para poder aplicar % de reparto del importe de la factura entre los diferentes giros, permitiendo aplicar una distribución no proporcional entre los diferentes giros contrariamente a como hacía hasta ahora. Utilice la sobrecarga de este mismo método que utiliza como parámetro para recibir los giros una List<LineaGiro>.", false)]
2914  public List<PrevisionCobro> Generar_Vencimientos(List<int> tlisGiros, bool tlPrevRetNoFisc = false)
2915  {
2916  // Este método será obsoleto a partir del 1 de Octubre 2023, si se llama a él convertiremos la lista de giros en forma de List(int) que
2917  // llega por parámetro al nuevo formato de linea giro List(LineaGiro) sin declarar los % a aplicar a cada giro por que no los sabemos
2918  // puesto que no llegan en esta sobrecarga puesto que recibiso una List(int) en tlstGiros.
2919  //
2920  // Al no haver % de reparto declarados en los giros, más adelante en el momento de generar las previsiones se hará de forma proporcional
2921  // idéntica a como se ha hecho siempre en Sage50.
2922  //
2923  List<LineaGiro> lstGirosPrc = CONTABILIDAD._Giros2GirosPrc(tlisGiros);
2924 
2925  return this.generarVencimientos(lstGirosPrc, tlPrevRetNoFisc);
2926  }
2927 
2928 
2943  public List<PrevisionCobro> Generar_Vencimientos(List<LineaGiro> tlisGiros, bool tlPrevRetNoFisc = false, bool? tlMesesCompletos=null)
2944  {
2945  return this.generarVencimientos(tlisGiros, tlPrevRetNoFisc, tlMesesCompletos);
2946  }
2947 
2948 
2963  private List<PrevisionCobro> generarVencimientos(List<LineaGiro> tlisGiros, bool tlPrevRetNoFisc = false, bool? tlMesesCompletos = null)
2964  {
2965  // OPERATIVA DE GENERACION PREVISIONES EN FACTURAS EN MONEDA DIFERENTE DE LA MONEDA DE EMPRESA
2966  //
2967  // 1. Se parte del total factura en divisa y según este total se genera cada una de sus previsiones rellenando IMPORTEDIV (divisa) primero y IMPORTE (moneda empresa) convertido a partir de IMPORTEDIV
2968  // 2. Si es necesario se arregla el campo IMPORTEDIV de la ultima prevision para que quadre con el total factura divisa, como consecuencia de esto se recalcula tambien IMPORTE de la última previsión.
2969  // 3. Se coge el total factura en moneda empresa que será el resultado de convertir el total factura en divisa a la moneda de la empresa.
2970  // 4. Se suma el campo IMPORTE de todas las previsiones y si hay diferencia entre este acumulado y el total factura en moneda empresa se añade la diferencia al campo
2971  // IMPORTE de la última prevision, y muy importante, como consequencia de actualizar este IMPORTE, NO se actualiza IMPORTEDIV de la última previsión.
2972 
2973  List<PrevisionCobro> loLstPrevCob = new List<PrevisionCobro>();
2974 
2975  // OPCFLAG "NO COINCIDIR MÁS DE UNA PREVISIÓN EN EL MISMO DÍA DE VENCIM."
2976  //
2977  bool llDiasVencim = Convert.ToBoolean(EW_GLOBAL._GetVariable("WL_DIAVENCIM"));
2978 
2979  decimal lnTotalImportePrevisiones = 0, lnDiferenciaImporte = 0, lnImporteGiro = 0;
2980  int lnDiasIntento = 0;
2981  DateTime ldVencimiento = DateTime.Today, ldVencimientoAnterior = DateTime.Today, ldFechaIniVacaciones = DateTime.Today, ldFechaFinVacaciones = DateTime.Today;
2982  string lcFpag = this._Forma_Pago;
2983  PrevisionCobro loPrevisionNueva;
2984 
2985 
2986  // Verifica que en los giros lleguen los % de reparto declarados correctamente. Si no llega algún % de reparto en algún giro (no debería pasar
2987  // pero un partner podria haber realizado algun proceso que generase registros en GIRO_CLI/GIRO_PRO/ALB_FPAG/ALB_FPA2 y no estuviesen
2988  // declarados eso % de reparto en alguno o todos los giros), se aplicara reparto proporcional tal como hacía hasta ahora.
2989  //
2990  // Esta situación insistir en que no se debería dar desde el CORE de Sage50 pues al introducir los giros en clientes/provedores/
2991  // albarán de compra/albarán de venta, ya se controla que no pueda quedar la suma de % que no sume 100, o que el usuario no pueda
2992  // dejar algún giro con % = 0. Pero un partner sí podria realizar algun proceso que generase registros en estas tablas y no rellenase
2993  // el campo % de reparto en alguno o todos los giros.
2994  //
2995  // Por tanto, en cualquier situación que la suma de los % de reparto declarados en los giros no sumen 100, se aplicará un reparto del
2996  // importe de la factura proporcional al número de giros, tal como hacía hasta ahora Sage50. Y esto es lo que hace la llamada al método
2997  // confirmPrcRepartoDeclarados que sigue.
2998  //
3000 
3001 
3002  // Si la previsión está generada en moneda empresa.
3003  //
3004  bool llPreviEnMonedaEmpresa = this._llDivisaVentas == false || string.IsNullOrWhiteSpace(this._Divisa) || this._Divisa == this._lcMonedaEmpresa;
3005 
3006 
3007  // Dias de pago y forma de pago del cliente.
3008  //
3009  int lnDiaPago1 = 0, lnDiaPago2 = 0;
3010 
3011  // No vuelvo a crear un objeto Cliente para no crear consultas innecesarias puesto que ya tengo el objeto Cliente en la previsión en la que estoy.
3012  //
3013  Cliente loCliente = this._oCliente;
3014 
3015  lnDiaPago1 = loCliente._DiaPago1;
3016  lnDiaPago2 = loCliente._DiaPago2;
3017  if (string.IsNullOrWhiteSpace(lcFpag))
3018  lcFpag = loCliente._FormaPago;
3019 
3020  tlMesesCompletos = tlMesesCompletos == null ? loCliente._GirosMesesCompletos : tlMesesCompletos;
3021 
3022 
3023  // Importe total de las previsiones a generar, lo tenemos en el objeto PrevisionCobro en el que estamos, en función de si
3024  // se generan las previsiones en moneda diferente de la empresa escogemos un campo u otro.
3025  //
3026  decimal lnTotalImportePrevGenerar = llPreviEnMonedaEmpresa ? this._Importe : this._ImporteDiv;
3027 
3028  for (int lnReg = 0; lnReg < tlisGiros.Count; lnReg++)
3029  {
3030  if (llDiasVencim)
3031  lnDiasIntento = 0;
3032 
3033  if (!tlPrevRetNoFisc)
3034  ldVencimiento = CONTABILIDAD.Obtener_Fecha_Vencimiento(lnDiaPago1, lnDiaPago2, tlisGiros.Select(x => x._Giro).ToList(), lnReg, ref lnDiasIntento, this._oCliente, (DateTime)this._Fecha_Vencim, Convert.ToBoolean(tlMesesCompletos));
3035  else
3036  // Si es una previsión de retención no fiscal el vencimiento es a la vista, idéntica fecha de vencimiento que fecha de emisión.
3037  ldVencimiento = (DateTime)this._Fecha_Emision;
3038 
3039  if (lnReg < (tlisGiros.Count - 1))
3040  {
3041  // Si hay más de una previsión, el importe del giro lo decido en función del % de reparto que tenga asignado el giro.
3042  //
3043  // Si estamos generando previsiones de una factura hecha en divisa diferente de la moneda de la empresa, partimos del total factura
3044  // en divisa para generar los giros.
3045  // Si estamos generando previsiones de una factura hecha en moneda empresa, partimos del total factura en moneda empresa para
3046  // generar los giros.
3047  //
3048  lnImporteGiro = this._oDivisa._MascaraImporte.Redondeo(lnTotalImportePrevGenerar * tlisGiros[lnReg]._Porcentaje / 100);
3049  }
3050  else
3051  {
3052  // En la última previsión modifico el importe para que la suma de todas las previsiones de el importe total que se tenía que
3053  // generar, todo esto se gestiona en la moneda en que se se está generando la factura. Si la factura fuese en divisa
3054  // diferente de la empresa, luego al final cuando haya acabado también cuadrá el campo IMPORTE en moneda de la empresa de la
3055  // ultima previsión para que de el resultado de convertir el total factura en divisa a moneda empresa.
3056  //
3057  lnImporteGiro = lnTotalImportePrevGenerar - lnTotalImportePrevisiones;
3058  }
3059 
3060  loPrevisionNueva = new PrevisionCobro();
3061 
3062  loPrevisionNueva._oCli = this._oCli;
3063 
3064  decimal lnImporteGiroDiv = 0, lnImporteGiroMonEmp = 0;
3065  if (llPreviEnMonedaEmpresa)
3066  {
3067  lnImporteGiroDiv = lnImporteGiro;
3068  lnImporteGiroMonEmp = lnImporteGiro;
3069  }
3070  else
3071  {
3072  lnImporteGiroDiv = lnImporteGiro;
3073  lnImporteGiroMonEmp = Divisa._Convertir_Importe_Moneda(lnImporteGiroDiv, this._Divisa, this._lcMonedaEmpresa, this._Cambio, this._loDivMonedaEmpresa._MascaraImporte._Num_Decimales);
3074  }
3075 
3076  // Antes se hacia un clonar pero como no va bien lo hemos cambiado por un _New
3077  //
3078  loPrevisionNueva._New(this._Cliente, this._Empresa, this._Factura,
3079  (tlPrevRetNoFisc ? 0 : lnReg + 1), this._Impagado, this._Pendiente, lnImporteGiroMonEmp,
3080  Convert.ToDateTime(this._Fecha_Emision), ldVencimiento, this._Divisa, this._Num_Banco,
3081  this._Referencia, this._SIIFraMod,
3082  this._Fecha_Operacion, this._Vendedor, lcFpag, this._Mandato, this._Recc, this._Ejercicio,
3083  this._Vendedor, this._Cambio, lnImporteGiroDiv, this._Impreso, this._Impago, this._Concepto);
3084 
3085  loLstPrevCob.Add(loPrevisionNueva);
3086 
3087  loPrevisionNueva = null;
3088 
3089  lnTotalImportePrevisiones = lnTotalImportePrevisiones + (llPreviEnMonedaEmpresa ? lnImporteGiroMonEmp : lnImporteGiroDiv);
3090  }
3091 
3092 
3093  // SI GENERACION PREVISIONES EN DIVISA DIFERENTE A MONEDA EMPRESA, CUADRAR CAMPO IMPORTE EN MONEDA EMPRESA.
3094  //
3095  if (llPreviEnMonedaEmpresa == false)
3096  {
3097  // Si la moneda de la previsión es diferente de la moneda de empresa cuadraré el acumulado de importe moneda empresa de los
3098  // giros con el resultado de convertir el total factura divisa a moneda empresa.
3099  // Si hay diferencias las añado en el campo _Importe de la última prevision, y esto NO actualiza IMPORTEDIV por que la
3100  // previsión está hecha en Divisa.
3101  //
3102  decimal lnTotalImpPrevGenMonEmpresa = Divisa._Convertir_Importe_Moneda(lnTotalImportePrevGenerar, this._Divisa, this._lcMonedaEmpresa, this._Cambio);
3103 
3104  // Sumo el importe en moneda de la empresa de todos los giros generados.
3105  //
3106  decimal lnTotGirosMonEmpresa = loLstPrevCob.Sum(x => x._Importe);
3107  lnDiferenciaImporte = lnTotalImpPrevGenMonEmpresa - lnTotGirosMonEmpresa;
3108  if (lnDiferenciaImporte != 0 && loLstPrevCob.Count > 0)
3109  {
3110  decimal lnNuevoImporte = loLstPrevCob[loLstPrevCob.Count - 1]._Importe + lnDiferenciaImporte;
3111  loLstPrevCob[loLstPrevCob.Count - 1]._Importe = lnNuevoImporte;
3112 
3113  // Hago el _Save(), hay que reflejarlo inmediatamente en la bd, como el resto de previsiones.
3114  //
3115  loLstPrevCob[loLstPrevCob.Count - 1]._Save();
3116  }
3117  }
3118 
3119  return loLstPrevCob;
3120  }
3121 
3122 
3128  {
3129  int lnOrden = 0;
3130  DataTable ldtResul = new DataTable();
3131 
3132  // Montamos la consulta para buscar el máximo orden
3133  string lcSql = "select max(orden) as orden " +
3134  "from " + DB.SQLDatabase("comunes", "previ_cl") + " " +
3135  "where empresa = " + DB.SQLString(this._Empresa) + " " +
3136  "and periodo = " + DB.SQLString(this._Ejercicio) + " " +
3137  "and factura = " + DB.SQLString(this._Factura);
3138 
3139  DB.SQLExec(lcSql, ref ldtResul);
3140 
3141  // Si tenemos registros incrementamos el pendiente
3142  if (ldtResul != null && ldtResul.Rows.Count > 0)
3143  lnOrden = Convert.ToInt32(ldtResul.Rows[0]["orden"]);
3144 
3145  return lnOrden;
3146  }
3147 
3148 
3154  {
3155  int lnImpagado = 0;
3156  DataTable ldtResul = new DataTable();
3157 
3158  // Montamos la consulta para buscar el máximo impagado
3159  string lcSql = "select max(impagado) as impagado " +
3160  "from " + DB.SQLDatabase("comunes", "previ_cl") + " " +
3161  "where empresa = " + DB.SQLString(_Empresa) + " " +
3162  "and periodo = " + DB.SQLString(_Ejercicio) + " " +
3163  "and factura = " + DB.SQLString(_Factura) + " " +
3164  "and orden = " + DB.SQLString(_Orden);
3165 
3166  DB.SQLExec(lcSql, ref ldtResul);
3167 
3168  // Si tenemos registros incrementamos el impagado
3169  if (ldtResul != null && ldtResul.Rows.Count > 0)
3170  lnImpagado = Convert.ToInt32(ldtResul.Rows[0]["impagado"]);
3171 
3172  return lnImpagado;
3173  }
3174 
3175 
3182  public List<PrevisionCobro> _Dividir(DataTable tdtVencimientos)
3183  {
3184  bool llOk = false, llPrimera = true;
3185  int lnOrden = 0;
3186  List<PrevisionCobro> loListPrevCob = new List<PrevisionCobro>();
3187 
3188  this._Addons_Dividir(TipoExecute.Before, tdtVencimientos);
3189 
3190  llOk = (tdtVencimientos != null && tdtVencimientos.Rows.Count > 1);
3191  if (!llOk)
3192  return null;
3193 
3194  // Obtener siguiente orden
3195  lnOrden = this._Obtener_Orden_Maximo() + 1;
3196 
3197  // Creación de las nuevas previsiones
3198  foreach (DataRow loPrev in tdtVencimientos.Rows)
3199  {
3200  // La primera previsión es la que ya tenemos, sólo actualizamos el vencimiento y el importe
3201  if (llPrimera)
3202  {
3203  this._Fecha_Vencim = Convert.ToDateTime(loPrev["vencim"]);
3204  this._Importe = Convert.ToDecimal(loPrev["importe"]);
3205  this._ImporteDiv = Convert.ToDecimal(loPrev["importediv"]);
3206  this._Save();
3207 
3208  llPrimera = false;
3209  loListPrevCob.Add(this);
3210  }
3211  else
3212  {
3213  // Creo la nueva previsión a partir de la actual
3214  PrevisionCobro loPrevisionNueva = new PrevisionCobro();
3215  loPrevisionNueva._Clonar(this, _Empresa, _Ejercicio, _Factura, lnOrden, _Impagado, _Pendiente);
3216 
3217  // Modifico los campos que me interesa
3218  loPrevisionNueva._Fecha_Vencim = Convert.ToDateTime(loPrev["vencim"]);
3219  loPrevisionNueva._Importe = Convert.ToDecimal(loPrev["importe"]);
3220  loPrevisionNueva._ImporteDiv = Convert.ToDecimal(loPrev["importediv"]);
3221 
3222  // Generar previsión
3223  loPrevisionNueva._Save();
3224 
3225  lnOrden++;
3226  loListPrevCob.Add(loPrevisionNueva);
3227  }
3228  }
3229 
3230  this._Addons_Dividir(TipoExecute.After, tdtVencimientos);
3231 
3232  return loListPrevCob;
3233  }
3234 
3235 
3242  public List<PrevisionCobro> _Dividir(List<int> tlisDias)
3243  {
3244  List<PrevisionCobro> loLstPrevCob = new List<PrevisionCobro>();
3245  decimal lnImporte = 0.0M, lnSumaImporte = 0.0M, lnDiferencia = 0.0M;
3246  int lnNumeroPrevisiones = 0, ln_i = 0;
3247  int lnDecimalesMoneda = 2;
3248  bool llOk = false;
3249  DataTable ldtResul = new DataTable();
3250  string lcEmpresa = _lcEmpresa;
3251 
3252  this._Addons_Dividir(TipoExecute.Before, tlisDias);
3253 
3254  // No tenemos cargado objeto de prevision de cobro, salimos.
3255  if (string.IsNullOrWhiteSpace(this._Factura) || string.IsNullOrWhiteSpace(this._Empresa))
3256  {
3257  this.Gestionar_Mensaje("El objeto PrevisionCobro no está cargado.", "_Dividir");
3258  return loLstPrevCob;
3259  }
3260 
3261  lnDecimalesMoneda = Convert.ToInt32(DB.SQLValor("moneda", "codigo", this._Divisa, "decimales", "gestion"));
3262 
3263  // Si en la lista de dias no tenemos como mínimo 2 elementos, en la lista que devuelvo dejo solo la previsión en la que estoy y salgo.
3264  if (tlisDias.Count <= 1)
3265  {
3266  loLstPrevCob.Add(this);
3267  return loLstPrevCob;
3268  }
3269 
3270  string lcSql = "select max(pendiente) as pendiente " +
3271  "from " + DB.SQLDatabase("comunes", "previ_cl") + " " +
3272  "where empresa = " + DB.SQLString(this._Empresa) + " " +
3273  "and periodo = " + DB.SQLString(this._Ejercicio) + " " +
3274  "and factura = " + DB.SQLString(this._Factura) + " " +
3275  "and orden = " + DB.SQLString(this._Orden) + " " +
3276  "and impagado = " + DB.SQLString(this._Impagado);
3277 
3278  llOk = DB.SQLExec(lcSql, ref ldtResul);
3279 
3280  int lnOtroPend = 1;
3281  if (ldtResul.Rows.Count > 0)
3282  lnOtroPend = Convert.ToInt32(ldtResul.Rows[0]["pendiente"]) + 1;
3283 
3284  lnNumeroPrevisiones = tlisDias.Count;
3285 
3286  if (this._llDivisaVentas == false || string.IsNullOrWhiteSpace(this._Divisa) || this._Divisa == this._lcMonedaEmpresa)
3287  // Previsión en la moneda de la empresa.
3288  lnImporte = FUNCTIONS._Round(this._Importe / lnNumeroPrevisiones, lnDecimalesMoneda);
3289  else
3290  // Previsión en la moneda diferente a la moneda de la empresa.
3291  lnImporte = FUNCTIONS._Round(this._ImporteDiv / lnNumeroPrevisiones, lnDecimalesMoneda);
3292 
3293  lnSumaImporte = 0.0M;
3294 
3295  // Creo tantos objetos PrevisionCobro como me marque la lista de días que llega por parámetro ...
3296  for (ln_i = 1; ln_i <= lnNumeroPrevisiones; ln_i++)
3297  {
3298  // Creo la nueva previsión a partir de la actual, incremento el campo PENDIENTE, y pongo en el importe de la previsión la parte que resta por entregar.
3299  PrevisionCobro loPrevisionNueva = new PrevisionCobro();
3300 
3301  // PE-103582
3302  int lnOrden = this._Obtener_Orden_Maximo() + 1;
3303  loPrevisionNueva._Clonar(this, _Empresa, _Ejercicio, _Factura, lnOrden, 0, lnOtroPend);
3304 
3305  if (this._llDivisaVentas == false || string.IsNullOrWhiteSpace(this._Divisa) || this._Divisa == this._lcMonedaEmpresa)
3306  loPrevisionNueva._Importe = lnImporte; // Esto ya actualiza _ImporteDiv
3307  else
3308  loPrevisionNueva._ImporteDiv = lnImporte; // Esto ya actualiza _Importe
3309 
3310  //loPrevisionNueva._Pendiente = lnOtroPend;
3311 
3312  lnSumaImporte += lnImporte;
3313  lnOtroPend++;
3314 
3315  loLstPrevCob.Add(loPrevisionNueva);
3316  }
3317 
3318  lnDiferencia = (this._llDivisaVentas == false || string.IsNullOrWhiteSpace(this._Divisa) || this._Divisa == this._lcMonedaEmpresa ? this._Importe : this._ImporteDiv) - lnSumaImporte;
3319 
3320  // Arreglo el importe de la última previsión generada para que cuadre la suma de los importes de las previsiones con el importe de la previsión original ...
3321  if (this._llDivisaVentas == false || string.IsNullOrWhiteSpace(this._Divisa) || this._Divisa == this._lcMonedaEmpresa)
3322  loLstPrevCob[loLstPrevCob.Count - 1]._Importe += lnDiferencia; // Esto ya actualiza _ImporteDiv
3323  else
3324  loLstPrevCob[loLstPrevCob.Count - 1]._ImporteDiv += lnDiferencia; // Esto ya actualiza _Importe
3325 
3326  this._Addons_Dividir(TipoExecute.After, tlisDias);
3327 
3328  return loLstPrevCob;
3329  }
3330 
3331 
3337  public bool _Descontabilizar(bool tlForzarDesmarcarPrevision = false)
3338  {
3339  string lcMsg = string.Empty;
3340 
3341  bool llOk = false;
3342  string lcSql = string.Empty;
3343  Asientos loAsiento;
3344 
3345  this._Addons_Descontabilizar(TipoExecute.Before, tlForzarDesmarcarPrevision);
3346 
3347  // No tenemos cargado objeto de prevision de cobro, no permitimos realizar operación.
3348  if (string.IsNullOrWhiteSpace(_Factura) || string.IsNullOrWhiteSpace(_Empresa))
3349  {
3350  _Mostrar_Mensajes = true;
3351  Gestionar_Mensaje("El objeto PrevisionCobro no está cargado.", "_Descontabilizar");
3352  _Mostrar_Mensajes = false;
3353 
3354  return false;
3355  }
3356 
3357  if (_Remesa != 0)
3358  {
3359  _Mostrar_Mensajes = true;
3360  Gestionar_Mensaje($"La previsión de cobro {_Factura.Trim()}/{_Orden} está en la remesa número: {_Remesa}, no se puede anular el cobro.", "_Descontabilizar");
3361  _Mostrar_Mensajes = false;
3362 
3363  return false;
3364  }
3365 
3366  if (!string.IsNullOrWhiteSpace(_Pagare))
3367  {
3368  _Mostrar_Mensajes = true;
3369  Gestionar_Mensaje($"La previsión de cobro {_Factura.Trim()}/{_Orden} está incluida en el pagaré: {_Pagare.Trim()}, no se puede anular el cobro.", "_Descontabilizar");
3370  _Mostrar_Mensajes = false;
3371 
3372  return false;
3373  }
3374 
3375  // Comprobar si la previsión ya está contabilizada ...
3376  if (!string.IsNullOrWhiteSpace(_Asi))
3377  {
3378  // Revisamos a ver si el ASI existe en ASIENTOS ...
3379  int lnNumero_Asiento = FUNCTIONS._Numero_Asiento(_Asi);
3380 
3381  if (lnNumero_Asiento == 0)
3382  {
3383  if (_Asi == "FACTURAPLUS")
3384  {
3385  lcMsg = "¿ Desea anular el cobro de la previsión ?";
3386  }
3387  else
3388  {
3389  if (_Cobrada && _Fecha_Cobro != null && Convert.ToDateTime(_Fecha_Cobro.ToString()).Year != Convert.ToInt32(DB.Ejercicio_EW))
3390  {
3391  _Mostrar_Mensajes = true;
3392  Gestionar_Mensaje("No se ha detectado el asiento de cobro de la previsión del cliente " + _Cliente + ", factura núm. " + _Factura.Trim() + "/" + _Orden.ToString().Trim() +
3393  Environment.NewLine +
3394  " El asiento corresponde a otro ejercicio. ", "_Descontabilizar");
3395  _Mostrar_Mensajes = false;
3396  return false;
3397  }
3398 
3399  lcMsg = "La previsión de cobro del cliente " + _Cliente + ", factura núm. " + _Factura.Trim() + "/" + _Orden.ToString().Trim() + " no está contabilizada." +
3400  Environment.NewLine +
3401  "¿ Desea anular el cobro de la previsión ?";
3402  }
3403 
3404  if (DialogResult.Yes == FUNCTIONS._MessageBox(lcMsg, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2, DialogResult.No))
3405  {
3406  _Desasentar();
3407 
3408  this._Addons_Descontabilizar(TipoExecute.After, tlForzarDesmarcarPrevision);
3409 
3410  return true;
3411  }
3412  }
3413  else
3414  {
3415  lcMsg = "Si anula el cobro se descontabilizará el cobro de la previsión. " + Environment.NewLine + "¿ Desea anular el cobro de la previsión ?";
3416 
3417  if (DialogResult.Yes == FUNCTIONS._MessageBox(lcMsg, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2, DialogResult.No))
3418  {
3419  // Solo borraré el asiento si el asiento de cobro solo incluye esta previsión, es decir, los totales del asientos coincidan con el importe de la previsión
3420  loAsiento = new Asientos(_Asi);
3421 
3422  if (loAsiento._Lineas.Count > 0)
3423  {
3424  decimal lnSumaDebe = 0.0M, lnSumaHaber = 0.0M;
3425  bool llDiferencias = true;
3426 
3427  foreach (AsientosLinea loLineaAsiento in loAsiento._Lineas)
3428  {
3429  lnSumaDebe += loLineaAsiento._DebeDiv;
3430  lnSumaHaber += loLineaAsiento._HaberDiv;
3431  llDiferencias &= _Cambio == loLineaAsiento._Cambio;
3432  }
3433 
3434  if (_Divisa != EW_GLOBAL._Empresa._Moneda && !llDiferencias)
3435  {
3436  lcMsg = "Se han detectado diferencias de cambio, si se generó un asiento para contabilizar dichas diferencias deberá eliminarlo manualmente. ";
3437  FUNCTIONS._MessageBox(lcMsg, "Anular cobro", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1);
3438  }
3439 
3440  bool llDesmarcarPrevision = false;
3441 
3442  // Cuadra la suma de los debes i haberes con el importe de la previsión.
3443  if (lnSumaDebe == lnSumaHaber && lnSumaDebe == _ImporteDiv) //Bug 109973 Cambiamo Importe por ImporteDiv
3444  {
3445  // Borro el asiento ...
3446  llOk = loAsiento._Delete();
3447  if (llOk)
3448  llDesmarcarPrevision = true;
3449  else
3450  {
3451  llDesmarcarPrevision = tlForzarDesmarcarPrevision;
3452 
3453  // Si pasamos el parametro de forzar desmarcar prevision, independientemente de que haya pasado con el asiento, desmarcamos la previsión.
3454  _Mostrar_Mensajes = true;
3455  Gestionar_Mensaje("No se pudo borrar el asiento de cobro de la previsión " + _Factura.Trim() + "/" + _Orden.ToString().Trim() + ".", "_Descontabilizar");
3456  _Mostrar_Mensajes = false;
3457  }
3458  }
3459  else
3460  {
3461  _Mostrar_Mensajes = true;
3462  Gestionar_Mensaje("El asiento de cobro de la previsión " + _Factura.Trim() + "/" + _Orden.ToString().Trim() + " contiene más de un cobro." +
3463  "No se puede eliminar el asiento.", "_Descontabilizar");
3464  _Mostrar_Mensajes = false;
3465 
3466  // Si pasamos el parametro de forzar desmarcar prevision, independientemente de que haya pasado con el asiento, desmarcamos la previsión.
3467  llDesmarcarPrevision = tlForzarDesmarcarPrevision;
3468  }
3469 
3470  if (llDesmarcarPrevision)
3471  {
3472  _Desasentar();
3473  llOk = true;
3474  }
3475  }
3476  else
3477  {
3478  _Mostrar_Mensajes = true;
3479  Gestionar_Mensaje("El asiento de la previsión de cobro " + _Factura.Trim() + "/" + _Orden.ToString().Trim() + " no existe.", "_Descontabilizar");
3480  _Mostrar_Mensajes = false;
3481  }
3482  }
3483  }
3484  }
3485  else
3486  {
3487  // Bug 108039
3488  lcMsg = "La previsión de cobro del cliente " + _Cliente + ", factura núm. " + _Factura.Trim() + "/" + _Orden.ToString().Trim() + " no está contabilizada." +
3489  Environment.NewLine +
3490  "¿ Desea anular el cobro de la previsión ?";
3491 
3492  if (DialogResult.Yes == FUNCTIONS._MessageBox(lcMsg, MessageBoxButtons.YesNo, MessageBoxIcon.Question, MessageBoxDefaultButton.Button2, DialogResult.No))
3493  {
3494  _Desasentar();
3495 
3496  this._Addons_Descontabilizar(TipoExecute.After, tlForzarDesmarcarPrevision);
3497 
3498  return true;
3499  }
3500 
3501  // Fi Bug 108039
3502  }
3503 
3504  this._Addons_Descontabilizar(TipoExecute.After, tlForzarDesmarcarPrevision);
3505 
3506  return llOk;
3507  }
3508 
3509 
3514  public bool _Desasentar()
3515  {
3516  string lcOldAsi = _Asi;
3517 
3518  this._Addons_Desasentar(TipoExecute.Before);
3519 
3520  // Desmarco la previsión y la dejamos pendiente de cobro.
3521  _Asi = "";
3522  _Asiento = false;
3523  _Banco = "";
3524  _Fecha_Cobro = null;
3525  _Save();
3526 
3527  this._Addons_Desasentar(TipoExecute.After);
3528 
3529  return true;
3530  }
3531 
3532 
3538  public List<PrevisionCobro> _Lista_Previsiones(EstadoPrevisiones tcEstadoPrevision = EstadoPrevisiones.Todas)
3539  {
3540  DataTable ldtPrevisiones = new DataTable();
3541  List<PrevisionCobro> loLstPrevCob = new List<PrevisionCobro>();
3542 
3543  if (this.Consultar_Previsiones(tcEstadoPrevision, ref ldtPrevisiones))
3544  {
3545  foreach (DataRow loRow in ldtPrevisiones.Rows)
3546  {
3547  string lcEmpresa = Convert.ToString(loRow["empresa"]);
3548  int lnPeriodo = Convert.ToInt32(loRow["periodo"]);
3549  string lcFactura = Convert.ToString(loRow["factura"]);
3550  int lnOrden = Convert.ToInt32(loRow["orden"]);
3551  int lnImpagado = Convert.ToInt32(loRow["impagado"]);
3552  int lnPendiente = Convert.ToInt32(loRow["pendiente"]);
3553 
3554  PrevisionCobro loPrevision = new PrevisionCobro(lcEmpresa, lnPeriodo, lcFactura, lnOrden, lnImpagado, lnPendiente);
3555  loLstPrevCob.Add(loPrevision);
3556  }
3557  }
3558 
3559  return loLstPrevCob;
3560  }
3561 
3562 
3568  {
3569  String lcSql;
3570 
3571  lcSql = String.Format("INSERT INTO {0} ( TIPO, EMPRESA , PERIODO , FACTURA , ORDEN, IMPAGADO, PENDIENTE , DIVISA, PROVECLIEN, CAMBIO, IMPORTE) VALUES (0, {1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}); ", DB.SQLDatabase("GESTION", "PREVI_CIERRE"), DB.SQLString(this._Empresa) , this._Ejercicio, DB.SQLString(this._Factura), DB.SQLString(this._Orden), DB.SQLString(this._Impagado) , DB.SQLString(this._Pendiente), DB.SQLString(this._Divisa) , DB.SQLString(this._Cliente), DB.SQLString(_Cambio), DB.SQLString(_Importe));
3572  return DB.SQLExec(lcSql);
3573  }
3574 
3575 
3581  {
3582  String lcSql;
3583 
3584  lcSql = String.Format("DELETE FROM {0} WHERE TIPO = 0 AND PERIODO = {1} AND EMPRESA = {2} AND FACTURA = {3} AND ORDEN = {4} AND IMPAGADO = {5} AND PENDIENTE ={6}", DB.SQLDatabase("GESTION", "PREVI_CIERRE"), _Ejercicio, DB.SQLString(_Empresa), DB.SQLString(_Factura), DB.SQLString(_Orden), DB.SQLString(this._Impagado), DB.SQLString(this._Pendiente));
3585  return DB.SQLExec(lcSql);
3586  }
3587 
3588 
3615  public void _New(string tcCliente, string tcEmpresa, string tcFactura, int tnOrden, int tnImpagado, int tnPendiente, decimal tnImporte, DateTime tdEmision,
3616  DateTime tdVencim, string tcMoneda, int tnNum_Banco, DateTime? tdFecha_Oper, string tcVendedor = "", string tcFpago = "",
3617  string tcMandato = "", bool tlRecc = false, int tnPeriodo = 0, string tcCobrador = "", decimal tnCambio = 1, decimal tnImporteDiv = 0,
3618  string tcImpreso = "N", string tcImpago = "N", string tcConcepto = "")
3619  {
3620  // Pasamos "" en los dos nuevos parametros que se han creado tcReferencia y tcSIIFraMOd
3621  //
3622  this.newPrev(tcCliente, tcEmpresa, tcFactura, tnOrden, tnImpagado, tnPendiente, tnImporte, tdEmision,
3623  tdVencim, tcMoneda, tnNum_Banco, tdFecha_Oper, tcVendedor, tcFpago,
3624  tcMandato, tlRecc, tnPeriodo, tcCobrador, tnCambio, tnImporteDiv,
3625  tcImpreso, tcImpago, tcConcepto, "", "");
3626  }
3627 
3628 
3664  public void _New(string tcCliente, string tcEmpresa, string tcFactura, int tnOrden, int tnImpagado, int tnPendiente, decimal tnImporte, DateTime tdEmision,
3665  DateTime tdVencim, string tcMoneda, int tnNum_Banco, string tcReferencia, string tcSIIFraMod, DateTime? tdFecha_Oper,
3666  string tcVendedor = "", string tcFpago = "", string tcMandato = "", bool tlRecc = false, int tnPeriodo = 0,
3667  string tcCobrador = "", decimal tnCambio = 1, decimal tnImporteDiv = 0, string tcImpreso = "N", string tcImpago = "N",
3668  string tcConcepto = "")
3669  {
3670 
3671  this.newPrev(tcCliente, tcEmpresa, tcFactura, tnOrden, tnImpagado, tnPendiente, tnImporte, tdEmision,
3672  tdVencim, tcMoneda, tnNum_Banco, tdFecha_Oper, tcVendedor, tcFpago,
3673  tcMandato, tlRecc, tnPeriodo, tcCobrador, tnCambio, tnImporteDiv,
3674  tcImpreso, tcImpago, tcConcepto, tcReferencia, tcSIIFraMod);
3675  }
3676 
3705  private void newPrev(string tcCliente, string tcEmpresa, string tcFactura, int tnOrden, int tnImpagado, int tnPendiente, decimal tnImporte, DateTime tdEmision,
3706  DateTime tdVencim, string tcMoneda, int tnNum_Banco, DateTime? tdFecha_Oper, string tcVendedor = "", string tcFpago = "",
3707  string tcMandato = "", bool tlRecc = false, int tnPeriodo = 0, string tcCobrador = "", decimal tnCambio = 1, decimal tnImporteDiv = 0,
3708  string tcImpreso = "N", string tcImpago = "N", string tcConcepto = "", string tcReferencia="", string tcSIIFraMod="")
3709  {
3710  bool llRetorno = false;
3711  DataTable ldt_Cursor = new DataTable();
3712 
3713  this._Addons_New(TipoExecute.Before, tcCliente, tcEmpresa, tcFactura, tnOrden, tnImpagado, tnPendiente, tnImporte, tdEmision,
3714  tdVencim, tcMoneda, tnNum_Banco, tdFecha_Oper, tcVendedor, tcFpago,
3715  tcMandato, tlRecc, tnPeriodo, tcCobrador, tnCambio, tnImporteDiv,
3716  tcImpreso, tcImpago, tcConcepto);
3717 
3718  int lnPeriodo = tnPeriodo == 0 ? Convert.ToInt16(EW_GLOBAL._GetVariable("wc_any")) : tnPeriodo; // PARTE 93429
3719 
3720  string lcBanco_Prev = "";
3721 
3722  // Task 130919, si el objeto Prevision sobre el que hago el _New ya tiene objeto Cliente y el código del mismo coincide con el que llega por parámetro ya cojo el banco previsto del objeto
3723  // cliente, no hace falta en ese caso hacer consulta.
3724  if (_oCli != null && _oCli._Codigo == tcCliente)
3725  lcBanco_Prev = _oCli._BancoPrevisto;
3726  else
3727  lcBanco_Prev = DB.SQLValor("CLIENTES", "CODIGO", tcCliente, "BANCO_PREV", "GESTION").ToString(); // 105550
3728 
3729  _DescargarDatos();
3730 
3731  // Miramos si ya existe el registro en la base de datos ...
3732  llRetorno = DB.SQLExec("select empresa,periodo,factura from " + DB.SQLDatabase("comunes", "previ_cl") + " " +
3733  "where empresa=" + DB.SQLString(tcEmpresa) + " " +
3734  "and periodo=" + DB.SQLString(lnPeriodo) + " " +
3735  "and factura=" + DB.SQLString(tcFactura) + " " +
3736  "and orden=" + DB.SQLString(tnOrden) + " " +
3737  "and impagado=" + DB.SQLString(tnImpagado) + " " +
3738  "and pendiente=" + DB.SQLString(tnPendiente), ref ldt_Cursor);
3739 
3740 
3741  if (llRetorno)
3742  {
3743  if (ldt_Cursor.Rows.Count == 0)
3744  {
3745 
3746  // Comprobamos si la previsión origen tiene concepto para añadir el mismo a la nueva previsión
3747  DataTable dtOrigen = new DataTable();
3748  DB.SQLExec("select empresa,periodo,factura,concepto from " + DB.SQLDatabase("comunes", "previ_cl") + " " +
3749  "where empresa=" + DB.SQLString(tcEmpresa) + " " +
3750  "and periodo=" + DB.SQLString(lnPeriodo) + " " +
3751  "and factura=" + DB.SQLString(tcFactura) + " " +
3752  "and orden=" + DB.SQLString(1) + " " +
3753  "and impagado=" + DB.SQLString(tnImpagado) + " " +
3754  "and pendiente=" + DB.SQLString(tnPendiente), ref dtOrigen);
3755 
3756  // Si hay previsiones anteriores y la previsión no es por impago, hay que restaurar el estado anterior.
3757  if (dtOrigen != null && dtOrigen.Rows.Count > 0)
3758  {
3759  if (!string.IsNullOrWhiteSpace(dtOrigen.Rows[0]["Concepto"].ToString()))
3760  tcConcepto = dtOrigen.Rows[0]["Concepto"].ToString().Trim();
3761  }
3762 
3763 
3764  // No existe, lo creamos ...
3765  llRetorno = DB.SQLExec("insert into " + DB.SQLDatabase("comunes", "previ_cl") + " " +
3766  "(usuario,empresa,periodo,factura,orden,impagado,pendiente,cliente,f_pago,divisa,cambio,vendedor,cobrador, " + // PARTE 93429
3767  "impreso,impago,num_banco, importe,importediv,emision,vencim,fec_oper,mandato,banco_prev,recc, concepto, "+
3768  "referencia, siiframod)" +
3769  "values ( " +
3770  DB.SQLString(_lcUsuario) + ", " +
3771  DB.SQLString(tcEmpresa) + ", " +
3772  DB.SQLString(lnPeriodo) + ", " +
3773  DB.SQLString(tcFactura) + ", " +
3774  DB.SQLString(tnOrden) + ", " +
3775  DB.SQLString(tnImpagado) + ", " +
3776  DB.SQLString(tnPendiente) + ", " +
3777  DB.SQLString(tcCliente) + "," +
3778  DB.SQLString(tcFpago) + "," +
3779  DB.SQLString(tcMoneda) + "," +
3780  DB.SQLString(tnCambio) + "," +
3781  DB.SQLString(tcVendedor) + "," +
3782  DB.SQLString(tcCobrador) + "," + // PARTE 93429
3783  DB.SQLString(tcImpreso) + "," +
3784  DB.SQLString(tcImpago) + "," +
3785  DB.SQLString(tnNum_Banco) + "," +
3786  DB.SQLString(tnImporte) + "," +
3787  DB.SQLString(tnImporteDiv) + "," +
3788  DB.SQLString(tdEmision) + "," +
3789  DB.SQLString(tdVencim) + "," +
3790  (tdFecha_Oper != null ? DB.SQLString(tdFecha_Oper) : "null") + "," +
3791  DB.SQLString(tcMandato) + "," +
3792  DB.SQLString(lcBanco_Prev) + "," + // 105550
3793  DB.SQLString(tlRecc) + "," +
3794  DB.SQLString(tcConcepto) + "," +
3795  DB.SQLString(tcReferencia) + "," +
3796  DB.SQLString(tcSIIFraMod) + ")");
3797 
3798  if (!llRetorno)
3799  Gestionar_Mensaje("Error en la consulta INSERT para actualizar registro PREVI_CL.", "_New");
3800  }
3801  }
3802  else
3803  Gestionar_Mensaje("Error en la consulta SELECT para comprobar la existencia registro PREVI_CL.", "_New");
3804 
3805  if (llRetorno)
3806  {
3807  //_Orden = tnOrden;
3808  //_Impagado = tnImpagado;
3809  //_Pendiente = tnPendiente;
3810  //_Empresa = tcEmpresa;
3811  //_Ejercicio = lnPeriodo;
3812  //_Factura = tcFactura;
3813  _Codigo = tcEmpresa + "|" + lnPeriodo.ToString().Trim() + "|"+ tcFactura + "|"+tnOrden.ToString().Trim()+"|"+ tnImpagado.ToString().Trim() + "|"+tnPendiente.ToString().Trim();
3814  // Task 130919 optimizacion, la previsión seguro que existirá pues la acaba de grabar y el proceso de grabado no falló, y al declarar el campo _Factura ya desencadena el _Load(), no hace falta volver
3815  // a hacerlo, de todas formas por si algún dia alguien cambia dicho mecanismo, nos aseguramos haciendo la siguiente comprobación.
3816  if (string.IsNullOrWhiteSpace(_Cliente))
3817  _Load();
3818  }
3819 
3820  this._Addons_New(TipoExecute.After, tcCliente, tcEmpresa, tcFactura, tnOrden, tnImpagado, tnPendiente, tnImporte, tdEmision,
3821  tdVencim, tcMoneda, tnNum_Banco, tdFecha_Oper, tcVendedor, tcFpago,
3822  tcMandato, tlRecc, tnPeriodo, tcCobrador, tnCambio, tnImporteDiv,
3823  tcImpreso, tcImpago, tcConcepto);
3824 
3825  return;
3826  }
3827 
3828 
3833  public bool _Revisar_Exportar()
3834  {
3835  bool llOk = false;
3836  DataTable ldtDatosFactura = new DataTable();
3837  DataTable ldtUpdate = new DataTable();
3838 
3839  string[] lcArray = new string[1];
3840 
3841  string lcNumero = string.Empty;
3842  string lcLetra = string.Empty;
3843  DateTime ldExportar = new DateTime(1899, 1, 1);
3844 
3845 
3846  string lcSql = "select letra, numero, exportar " +
3847  "from " + DB.SQLDatabase("", "c_albven") + " " +
3848  "where empresa = " + DB.SQLString(this._Empresa) + " " +
3849  "and factura = " + DB.SQLString(this._Factura);
3850 
3851  lcArray[0] = Convert.ToString(this._Ejercicio).Trim();
3852 
3853  if (DB.SQLExecEjer(lcSql, ref ldtDatosFactura, lcArray))
3854  {
3855  foreach (DataRow ldrItem in ldtDatosFactura.Rows)
3856  {
3857  if (ldrItem["exportar"] != DBNull.Value)
3858  {
3859  lcNumero = Convert.ToString(ldrItem["numero"]);
3860  lcLetra = Convert.ToString(ldrItem["letra"]);
3861 
3862  // Actualitzo la data del camp exportar, amb una data molt petita
3863  lcSql = "update " + DB.SQLDatabase("", "c_albven") + " " +
3864  "set exportar = " + DB.SQLString(ldExportar) + " " +
3865  "where empresa = " + DB.SQLString(this._Empresa) + " " +
3866  "and numero = " + DB.SQLString(lcNumero) + " " +
3867  "and letra = " + DB.SQLString(lcLetra);
3868 
3869  llOk = DB.SQLExecEjer(lcSql, ref ldtUpdate, lcArray);
3870  }
3871  }
3872  }
3873 
3874 
3875  return llOk;
3876  }
3877 
3878 
3885  public bool _Actualizar_Asi_Ticket(string tcOldNumero = "")
3886  {
3887  bool llOk = false;
3888  DataTable ldtResul = new DataTable();
3889  string lcAnyPredet = "", lcSql = "", lcNumero = "", lcUpdateNumero = ""; // PARTE 93455
3890 
3891  bool llHay_Tpv = (Convert.ToString(DB.SQLValor("MODULOS", "NOMBRE", "TPV", "NOMBRE", "COMUNES")).Trim() == "TPV");
3892  if (!llHay_Tpv)
3893  return false;
3894 
3895  string lcCaja_Tpv = Convert.ToString(EW_GLOBAL._GetVariable("wc_cajatpv"));
3896  if (string.IsNullOrWhiteSpace(lcCaja_Tpv))
3897  return false;
3898 
3899  // Ejercicio activo ...
3900  lcAnyPredet = Convert.ToString(EW_GLOBAL._GetVariable("wc_any"));
3901 
3902  // Número de factura
3903  // PARTE 93455. Cuando realizamos un cobro parcial de una previsión nos modifica el campo pendiente, en tal caso ya nos vendrá por parámetro el número de factura que debe de actualizar por parámetro
3904  if (string.IsNullOrWhiteSpace(tcOldNumero))
3905  {
3906  // Cobro total de una previsión
3907  lcNumero = this._Factura.Trim() + "/" +
3908  Convert.ToString(this._Orden).Trim() + "/" +
3909  Convert.ToString(this._Pendiente).Trim() + "/" +
3910  Convert.ToString(this._Ejercicio).Substring(2); // PE-91476. Solo guardar 2 digitos del ejercicio (como en fox)
3911  }
3912  else
3913  {
3914  // Cobro parcial de una previsión, nos llega por parámetro el número de factura con el valor del campo pendiente original
3915  lcNumero = tcOldNumero;
3916 
3917  // Asignamos el nuevo número de factura con el valor actual del campo pendiente
3918  lcUpdateNumero = this._Factura.Trim() + "/" +
3919  Convert.ToString(this._Orden).Trim() + "/" +
3920  Convert.ToString(this._Pendiente).Trim() + "/" +
3921  Convert.ToString(this._Ejercicio).Substring(2); // PE-91476. Solo guardar 2 digitos del ejercicio (como en fox)
3922 
3923  // Alineamos el número de factura y añadimos el caracter ","
3924  lcUpdateNumero = ", numero = '" + lcUpdateNumero.PadLeft(20) + "' ";
3925  }
3926  // FPARTE 93455
3927 
3928  lcNumero = lcNumero.PadLeft(20);
3929 
3930  lcSql = "update " + DB.SQLDatabase("tpv", "tikets") +
3931  " set asi = " + DB.SQLString(this._Asi) + " " + lcUpdateNumero + // PARTE 93455. Al hacer un cobro parcial seguramente que tenemos de actualizar el número
3932  " where ejercicio = " + DB.SQLString(lcAnyPredet.PadRight(15, ' ')) +
3933  " and empresa = " + DB.SQLString(_lcEmpresa) +
3934  " and numero = '" + lcNumero + "' " +
3935  " and letra = ' ' " +
3936  " and tipo = 4 ";
3937  llOk = DB.SQLExec(lcSql, ref ldtResul);
3938 
3939  return llOk;
3940  }
3941 
3942 
3952  public bool ExistePrevision(string tcEmpresa, string tcCliente, string tcFactura, int tcPeriodo)
3953  {
3954  bool llOk = false;
3955 
3956  DataTable ldtPrevisiones = new DataTable();
3957  string lcSql = "Select empresa, periodo, cliente, factura, orden, divisa " +
3958  "From " + DB.SQLDatabase("comunes", "previ_cl") + " " +
3959  "where empresa =" + DB.SQLString(tcEmpresa) +
3960  " and cliente =" + DB.SQLString(tcCliente) +
3961  " and factura =" + DB.SQLString(tcFactura.Trim().PadLeft(10)) +
3962  " and orden = '1'" +
3963  " and periodo =" + tcPeriodo;
3964 
3965  DB.SQLExec(lcSql, ref ldtPrevisiones);
3966 
3967  if (ldtPrevisiones.Rows.Count > 0)
3968  llOk = true;
3969 
3970  FUNCTIONS._DisposeDatatable(ldtPrevisiones);
3971 
3972  return llOk;
3973  }
3974 
3975 
3986  public bool ExistePrevision(string tcEmpresa, string tcCliente, string tcFactura, int tcPeriodo, out int tnorden)
3987  {
3988  bool llOk = false;
3989  tnorden = 1;
3990 
3991  DataTable ldtPrevisiones = new DataTable();
3992  string lcSql = "Select empresa, periodo, cliente, factura, orden, divisa, pendiente " +
3993  "From " + DB.SQLDatabase("comunes", "previ_cl") + " " +
3994  "where empresa =" + DB.SQLString(tcEmpresa) +
3995  " and cliente =" + DB.SQLString(tcCliente) +
3996  " and factura =" + DB.SQLString(tcFactura.Trim().PadLeft(10)) +
3997  " and periodo =" + tcPeriodo;
3998 
3999  DB.SQLExec(lcSql, ref ldtPrevisiones);
4000 
4001  if (ldtPrevisiones.Rows.Count > 0)
4002  {
4003  foreach (DataRow dr in ldtPrevisiones.Rows)
4004  {
4005  // podemos haber realizado un cobro parcial de la previsión y la primera que encontremos tenga valor en pendiente = 1
4006  // por lo cual tenemos que seguir recorriendo previsiones encontradas hasta obtener la primera que pendiente = 0
4007  if (!Convert.ToBoolean(dr["pendiente"]))
4008  {
4009  llOk = true;
4010  tnorden = Convert.ToInt32(dr["orden"]);
4011  break;
4012  }
4013  }
4014  }
4015 
4016  FUNCTIONS._DisposeDatatable(ldtPrevisiones);
4017 
4018  return llOk;
4019  }
4020 
4030  public bool ExistePrevision(string tcEmpresa, string tcFactura, int tcPeriodo, out int tnorden)
4031  {
4032  bool llOk = false;
4033  tnorden = 1;
4034 
4035  DataTable ldtPrevisiones = new DataTable();
4036  string lcSql = "Select empresa, periodo, cliente, factura, orden, divisa, pendiente " +
4037  "From " + DB.SQLDatabase("comunes", "previ_cl") + " " +
4038  "where empresa =" + DB.SQLString(tcEmpresa) +
4039  " and factura =" + DB.SQLString(tcFactura.Trim().PadLeft(10)) +
4040  " and periodo =" + tcPeriodo;
4041 
4042  DB.SQLExec(lcSql, ref ldtPrevisiones);
4043 
4044  if (ldtPrevisiones.Rows.Count > 0)
4045  {
4046  foreach (DataRow dr in ldtPrevisiones.Rows)
4047  {
4048  // podemos haber realizado un cobro parcial de la previsión y la primera que encontremos tenga valor en pendiente = 1
4049  // por lo cual tenemos que seguir recorriendo previsiones encontradas hasta obtener la primera que pendiente = 0
4050  if (!Convert.ToBoolean(dr["pendiente"]))
4051  {
4052  llOk = true;
4053  tnorden = Convert.ToInt32(dr["orden"]);
4054  break;
4055  }
4056  }
4057  }
4058 
4059  FUNCTIONS._DisposeDatatable(ldtPrevisiones);
4060 
4061  return llOk;
4062  }
4063 
4073  public bool ObtenerPendientePrevision(string tcEmpresa, string tcFactura, int tcPeriodo, int tnOrden, out int tnPendiente)
4074  {
4075  bool llOk = false;
4076 
4077  DataTable ldtPrevisiones = new DataTable();
4078  string lcSql = "Select pendiente " +
4079  "From " + DB.SQLDatabase("comunes", "previ_cl") + " " +
4080  "where empresa =" + DB.SQLString(tcEmpresa) +
4081  " and factura =" + DB.SQLString(tcFactura.Trim().PadLeft(10)) +
4082  " and orden = " + tnOrden +
4083  " and periodo =" + tcPeriodo +
4084  " and usuario <> '' " +
4085  " ORDER BY pendiente ASC";
4086 
4087  DB.SQLExec(lcSql, ref ldtPrevisiones);
4088 
4089 
4090  if (ldtPrevisiones != null && ldtPrevisiones.Rows.Count > 0)
4091  {
4092  llOk = true;
4093  tnPendiente = Convert.ToInt32(ldtPrevisiones.Rows[0]["pendiente"]);
4094  }
4095  else
4096  tnPendiente = 0;
4097 
4098  FUNCTIONS._DisposeDatatable(ldtPrevisiones);
4099 
4100  return llOk;
4101  }
4102 
4103 
4104  #endregion METODOS PUBLICOS
4105 
4106 
4107  #region MÉTODOS PUBLIC OVERRIDE
4108 
4109 
4113  public override void _Load()
4114  {
4115  string lcSql = string.Empty;
4116  bool llOk = false;
4117  DataTable ldtPrevision = new DataTable();
4118 
4119  _Pantalla = "PREV_COB"; // PE-92276
4120 
4121  // PE-84040
4122  // Obtener campos de PREVI_CL
4123  base._Load();
4124 
4125  if (!string.IsNullOrWhiteSpace(this._Cliente))
4126  {
4127  if (this._oCli == null)
4128  {
4129  Cliente loCliente = new Cliente(this._Cliente);
4130  this._oCli = loCliente;
4131  }
4132  else
4133  {
4134  if (this._oCli._Codigo != this._Cliente)
4135  this._oCli._Codigo = this._Cliente;
4136  }
4137  }
4138 
4139  _Observacion = "";
4140 
4141  // Task 130919, optimizacion, a veces se llega al _Load() sin tener datos en los campos clave, por ejemplo, haciendo un new PrevisionCobro(), no hace falta hacer esta consulta
4142  if (!string.IsNullOrWhiteSpace(_Empresa) && !string.IsNullOrWhiteSpace(_Factura))
4143  {
4144  // Obtener campos de PREVIOBS
4145  lcSql = "select p.observacio " +
4146  "from " + DB.SQLDatabase("comunes", "previobs") + " p " +
4147  " where p.empresa=" + DB.SQLString(_Empresa) + " " +
4148  " and p.periodo=" + DB.SQLString(_Ejercicio) + " " +
4149  " and p.factura=" + DB.SQLString(_Factura) + " " +
4150  " and p.orden=" + DB.SQLString(_Orden) + " " +
4151  " and p.impagado=" + DB.SQLString(_Impagado) + " " +
4152  " and p.pendiente=" + DB.SQLString(_Pendiente);
4153 
4154  llOk = DB.SQLExec(lcSql, ref ldtPrevision);
4155  if (llOk && ldtPrevision.Rows.Count > 0)
4156  {
4157  _Observacion = Convert.ToString(ldtPrevision.Rows[0]["observacio"]);
4158  }
4159  }
4160 
4161  _cOldAsi = _Asi;
4162 
4163  _Linkado = false;
4164 
4165  // Task 130919, optimización proceso de facturación, el histórico solo se utiliza en el formulario de mantenimiento de previsiones de cobro, si trabajamos las previsiones a nivel de negocio
4166  // no hace falta hacer todas estas consultas, es más, ni que se utilizase en algún otro sitio tampoco parece util esta llamada aquí por que no recoge el DataTable de resultado y por tanto no hace
4167  // hace nada con él. En el formulario cuando se bindea a la grid vuelve a llamar a éste método _HistoricoRecibos() y entonces sí que recoge su resultado.
4168  //
4169  // _HistoricoRecibos();
4170  //
4171  }
4172 
4180  public override string _MultiClave_To_String()
4181  {
4182  string lcMultiClave = base._MultiClave_To_String();
4183 
4184  //Comprobar si existe una previsión con este número de orden. Si es el caso asignamos a la multiclave el pendiente obtenido porque no siempre será 0
4185 
4186  int lnPendiente;
4187  bool lbExistePrevision = ObtenerPendientePrevision(this._Empresa, this._Factura, this._Ejercicio, this._Orden, out lnPendiente);
4188  if (lbExistePrevision)
4189  {
4190  string[] tokens = lcMultiClave.Split(new[] { '|' });
4191  if (tokens.Count() == 6)
4192  {
4193  tokens[5] = Convert.ToString(lnPendiente);
4194  lcMultiClave = string.Join("|", tokens);
4195  }
4196  }
4197 
4198  return lcMultiClave;
4199  }
4200 
4201 
4206  public override void _New(string tcCodigo = "")
4207  {
4208  _Divisa = _lcMonedaEmpresa;
4209  _Cambio = 1.0M;
4210  _Usuario = _lcUsuario;
4211  _Impago = "N";
4212  _Impreso = "N";
4213 
4214  base._New(tcCodigo);
4215  }
4216 
4217 
4222  public override bool _Delete()
4223  {
4224  string lcSql = string.Empty;
4225  string lcConcepto = string.Empty;
4226  bool llDevolucion = false;
4227  string lcConnect = string.Empty;
4228  string lcEjerActual = DB.Ejercicio_EW;
4229  string lcAsi = string.Empty;
4230  string lcMensaje = string.Empty;
4231  DataTable ldtAsientos = new DataTable();
4232  DataTable ldtPrevisiones = new DataTable();
4233 
4234  lcSql = "SELECT * FROM " + DB.SQLDatabase("COMUNES", "PREVI_CL") +
4235  " WHERE PERIODO = " + DB.SQLString(_Ejercicio) +
4236  " AND EMPRESA = " + DB.SQLString(_Empresa) +
4237  " AND FACTURA = " + DB.SQLString(_Factura) +
4238  " AND ORDEN = " + DB.SQLString(_Orden) +
4239  " AND IMPAGADO > 0 " +
4240  " ORDER BY IMPAGADO DESC ";
4241  DB.SQLExec(lcSql, ref ldtPrevisiones);
4242 
4243  // Si hay previsiones anteriores y la previsión no es por impago, hay que restaurar el estado anterior.
4244  if (ldtPrevisiones != null && ldtPrevisiones.Rows.Count > 0)
4245  {
4246  if (!string.IsNullOrWhiteSpace(ldtPrevisiones.Rows[0]["Concepto"].ToString()) && ldtPrevisiones.Rows[0]["Impago"].ToString() == "S")
4247  {
4248  lcConcepto = ldtPrevisiones.Rows[0]["Concepto"].ToString().Trim();
4249  llDevolucion = lcConcepto.IndexOf("ASIENTO DEVOLUCION") >= 0;
4250 
4251  // Eliminamos el último impago de esta previsión
4252  PrevisionCobro loPrevisionCobro = new PrevisionCobro(_Empresa, _Ejercicio, _Factura, _Orden, Convert.ToInt16(ldtPrevisiones.Rows[0]["Impagado"]), _Pendiente);
4253  loPrevisionCobro._Concepto = "";
4254  loPrevisionCobro._Save();
4255 
4256  _Eliminar_Trazabilidad_Impagos(loPrevisionCobro._Guid_Id);
4257 
4258  loPrevisionCobro._Delete();
4259 
4260 
4261  // Actualizamos la previsión actual, para que vuelva a estar "COBRADA"
4262  loPrevisionCobro = new PrevisionCobro(_Empresa, _Ejercicio, _Factura, _Orden, _Impagado, _Pendiente);
4263  loPrevisionCobro._Impago = Convert.ToInt16(ldtPrevisiones.Rows[0]["Impagado"]) > 1 ? "S" : "N";
4264  loPrevisionCobro._Concepto = "";
4265  loPrevisionCobro._Banco = Convert.ToString(ldtPrevisiones.Rows[0]["banco"]);
4266  loPrevisionCobro._Asiento = true;
4267  loPrevisionCobro._Fecha_Cobro = (ldtPrevisiones.Rows[0]["cobro"] != DBNull.Value ? Convert.ToDateTime(ldtPrevisiones.Rows[0]["cobro"]) : this._Fecha_Cobro);
4268  loPrevisionCobro._Asi = Convert.ToString(ldtPrevisiones.Rows[0]["asi"]);
4269 
4270  // Ojo que aquí havia un Convert.ToInt16 y ha de ser Int32, sino, si el número de la remesa
4271  // tiene más 6 o más dígitos casca pues el Int16 no da para un número de 6 o más digitos.
4272  //
4273  loPrevisionCobro._Remesa = Convert.ToInt32(ldtPrevisiones.Rows[0]["remesa"]);
4274 
4275  loPrevisionCobro._Fecha_Remesa = (ldtPrevisiones.Rows[0]["fecreme"] != DBNull.Value ? Convert.ToDateTime(ldtPrevisiones.Rows[0]["fecreme"]) : this._Fecha_Remesa);
4276  loPrevisionCobro._Pagare = Convert.ToString(ldtPrevisiones.Rows[0]["pagare"]);
4277  loPrevisionCobro._Save();
4278 
4279 
4280  if (llDevolucion)
4281  {
4282  if (_lcAny != ldtPrevisiones.Rows[0]["periodo"].ToString())
4283  {
4284  if (!string.IsNullOrWhiteSpace(_lcGrupo))
4285  // El campo ANY debe ir entre [] pues es una palabra clave de SqlServer, si no se pone los [], casca.
4286  lcConnect = Convert.ToString(DB.SQLValor("EJERCICI", "[ANY] = " + DB.SQLString(ldtPrevisiones.Rows[0]["periodo"].ToString()) + " AND GRUPO", DB.SQLString(_lcGrupo), "CONEXION", "COMUNES"));
4287  else
4288  lcConnect = Convert.ToString(DB.SQLValor("EJERCICI", "[ANY]", DB.SQLString(ldtPrevisiones.Rows[0]["periodo"].ToString()), "CONEXION", "COMUNES"));
4289 
4290  if (!string.IsNullOrWhiteSpace(lcConnect))
4291  DB.SQLPredeterminarGestion(lcConnect);
4292  }
4293 
4294  // Comprobem si el asiento de devolución.
4295  lcAsi = lcConcepto.Replace("ASIENTO DEVOLUCION", "").Trim();
4296  if (lcAsi.Length >= 20)
4297  lcAsi = lcAsi.Substring(0, 20);
4298  else
4299  lcAsi = lcAsi.PadRight(20);
4300 
4301 
4302  Asientos loNewAsiento = new Asientos(lcAsi);
4303  loNewAsiento._Delete();
4304 
4305  DB.SQLPredeterminarGestion(lcEjerActual);
4306 
4307  return true;
4308  }
4309  }
4310  }
4311 
4312  bool llOk = base._Delete() && _DeleteHistoricoCambioCierre();
4313 
4314  if (llOk)
4315  {
4316  CalcularLimiteCredito();
4317  }
4318 
4319  return llOk;
4320  }
4321 
4322 
4327  public override bool _Save()
4328  {
4329  bool llRetorno = false;
4330 
4331  // Guardamos los cambios en la tabla PREVI_CL
4332  llRetorno = base._Save();
4333 
4334  if (llRetorno)
4335  {
4336  // Guardamos los cambios en la tabla PREVIOBS
4337  DataTable ldtPreviObs = new DataTable();
4338 
4339  // Miramos si ya existe el registro en la base de datos ...
4340  llRetorno = DB.SQLExec("select empresa,periodo,factura from " + DB.SQLDatabase("comunes", "previobs") + " " +
4341  "where empresa=" + DB.SQLString(_Empresa) + " " +
4342  "and periodo=" + DB.SQLString(_Ejercicio) + " " +
4343  "and factura=" + DB.SQLString(_Factura) + " " +
4344  "and orden=" + DB.SQLString(_Orden) + " " +
4345  "and impagado=" + DB.SQLString(_Impagado) + " " +
4346  "and pendiente=" + DB.SQLString(_Pendiente), ref ldtPreviObs);
4347  if (llRetorno)
4348  {
4349  if (ldtPreviObs.Rows.Count > 0)
4350  {
4351  // Existe, lo updatamos ...
4352  llRetorno = DB.SQLExec("update " + DB.SQLDatabase("comunes", "previobs") + " " +
4353  "set observacio=" + DB.SQLString(_Observacion) + " " +
4354  "where empresa=" + DB.SQLString(_Empresa) + " " +
4355  "and periodo=" + DB.SQLString(_Ejercicio) + " " +
4356  "and factura=" + DB.SQLString(_Factura) + " " +
4357  "and orden=" + DB.SQLString(_Orden) + " " +
4358  "and impagado=" + DB.SQLString(_Impagado) + " " +
4359  "and pendiente=" + DB.SQLString(_Pendiente));
4360  if (!llRetorno)
4361  {
4362  Gestionar_Mensaje("Error en la consulta UPDATE para actualizar registro PREVIOBS.", "_Save");
4363  }
4364  }
4365  else
4366  {
4367  // Si tengo usuario asignado en la propiedad privada ._cUsuario utilizo ésta, sino la internal ._lcUsuario que ya viene calculado el contenido ...
4368  string lcUsuario = string.IsNullOrWhiteSpace(_Usuario) ? _lcUsuario : _Usuario;
4369 
4370  // No existe, lo creamos ...
4371  llRetorno = DB.SQLExec("insert into " + DB.SQLDatabase("comunes", "previobs") + " " +
4372  "(usuario,empresa,periodo,factura,orden,impagado,pendiente,observacio,proveclien) " +
4373  "values ( " +
4374  DB.SQLString(lcUsuario) + ", " +
4375  DB.SQLString(_Empresa) + ", " +
4376  DB.SQLString(_Ejercicio) + ", " +
4377  DB.SQLString(_Factura) + ", " +
4378  DB.SQLString(_Orden) + ", " +
4379  DB.SQLString(_Impagado) + ", " +
4380  DB.SQLString(_Pendiente) + ", " +
4381  DB.SQLString(_Observacion) + ", " +
4382  DB.SQLString(_Cliente) + " ) ");
4383  if (!llRetorno)
4384  {
4385  Gestionar_Mensaje("Error en la consulta INSERT para actualizar registro PREVIOBS.", "_Save");
4386  }
4387  }
4388  }
4389  else
4390  {
4391  Gestionar_Mensaje("Error en la consulta SELECT para comprobar la existencia registro PREVIOBS.", "_Save");
4392  }
4393  }
4394 
4395  if (llRetorno)
4396  {
4397  SaveCriterioCaja();
4398 
4399  CalcularLimiteCredito();
4400  }
4401 
4402  // Devolvemos true si se puedo grabar correctamente, false caso contrario ...
4403  return llRetorno;
4404  }
4405 
4406  private void CalcularLimiteCredito()
4407  {
4408 
4409  cliente.Clases.clsLimiteCredito loLimite = new cliente.Clases.clsLimiteCredito();
4410  loLimite._oTipoRecalculo = cliente.Clases.clsLimiteCredito._TipoRecalculo.FactPendCobro;
4411 
4412  if (!string.IsNullOrWhiteSpace(_Cliente))
4413  {
4414  //cliente anterior
4415  loLimite._CodigoCliente = _Cliente;
4416  loLimite._RecalcularYGuardar();
4417  }
4418  }
4419 
4424  public override bool _MultiClave_Completa()
4425  {
4426  bool llOK = true;
4427 
4428  string[] laCamposClave = this._Clave.Split(',');
4429  string lcFactura = string.Empty;
4430 
4431  //Por cada campo que la compone
4432  foreach (string lcCampoCodigo in laCamposClave)
4433  {
4434 
4435  if (_lisCampos.ContainsKey(lcCampoCodigo))
4436  {
4437  string lcCampo = lcCampoCodigo.ToUpper().Trim();
4438 
4439  switch (lcCampo)
4440  {
4441  case "ORDEN":
4442  llOK = llOK && _lisCampos[lcCampoCodigo]._NewVal != null && (Convert.ToInt32(_lisCampos[lcCampoCodigo]._NewVal) >= 0); // Ha de permitir valor 0 pues si la factura tiene retencion no fiscal se crea una prevision con orden 0
4443  break;
4444 
4445  case "PERIODO":
4446  llOK = llOK && _lisCampos[lcCampoCodigo]._NewVal != null && (Convert.ToInt32(_lisCampos[lcCampoCodigo]._NewVal) > 0);
4447  break;
4448 
4449  case "FACTURA":
4450  llOK = llOK && _lisCampos[lcCampoCodigo]._NewVal != null && (!string.IsNullOrWhiteSpace(_lisCampos[lcCampoCodigo]._NewVal.ToString()));
4451 
4452  // Tenemos que comprobar que no solo exista la letra de la factura
4453  if (llOK)
4454  {
4455  lcFactura = _lisCampos[lcCampoCodigo]._NewVal.ToString();
4456 
4457  // si tenemos letra (izquierda) y no tenemos numero (derecha), no vale
4458  if (!string.IsNullOrWhiteSpace(lcFactura.Substring(0, 1)) && string.IsNullOrWhiteSpace(lcFactura.Substring(lcFactura.Length - 1, 1)))
4459  llOK = false;
4460  }
4461 
4462  break;
4463 
4464  default:
4465  llOK = llOK && _lisCampos[lcCampoCodigo]._NewVal != null && (!string.IsNullOrWhiteSpace(_lisCampos[lcCampoCodigo]._NewVal.ToString()));
4466  break;
4467  }
4468 
4469 
4470  }
4471  else llOK = false;
4472  }
4473 
4474  return llOK;
4475  }
4476 
4477 
4478  #endregion MÉTODOS PUBLIC OVERRIDE
4479 
4480 
4481  #region MÉTODOS PUBLIC VIRTUAL
4482 
4483 
4487  public new virtual void _Show()
4488  {
4489  string lcRetorn = string.Empty;
4490 
4491  // TODO: faig això ja que per saber si aquest botó ha d'anar des de fox o no, només ho sé mitjançant el botó. Després s'haurà de borrar.
4492  sage.ew.docsven.Clases.btPrevisionCliente loBotonTemporal = new docsven.Clases.btPrevisionCliente();
4493  switch (loBotonTemporal.__Abrir_Formulario_En())
4494  {
4495  //TODO Borrar cuando pase por QA
4496  case 0: //No se aplica o error => FOX
4497  case 1: //.FOX
4498  object[] loParametres = new object[5] { this._Factura, this._Orden, this._Ejercicio, this._Impagado, this._Pendiente };
4499  lcRetorn = NETVFP._Abrir_Formulario_VFP("PREV_COB", loParametres);
4500 
4501  break;
4502 
4503  case 2: //.NET
4504 
4505  //TODO: formulari amb net
4506  //frmPrevisionCobroMante frmPrevision = new frmPrevisionCobroMante(this);
4507  //NETVFP._Navegar_Form_Sage50(_FormMante, this._ForzarShowDialog = true);
4508 
4509  base._Show();
4510 
4511  break;
4512 
4513  default:
4514  break;
4515  }
4516  loBotonTemporal = null;
4517 
4518  }
4519 
4520 
4524  public virtual void _Show_Asiento()
4525  {
4526  if (_Ejercicio == 0)
4527  _Ejercicio = Convert.ToInt32(DB.Ejercicio_EW);
4528 
4529 
4530  DateTime fCobro = Convert.ToDateTime(this._Fecha_Cobro);
4531 
4532  // if (Convert.ToInt32(DB.Ejercicio_EW) != _Ejercicio)
4533  if (Convert.ToInt32(DB.Ejercicio_EW) != fCobro.Year)
4534  {
4535  DataTable ldtResul = new DataTable();
4536 
4537  string lcSql = "select fecha " +
4538  "from " + DB.SQLDatabase("gestion", "asientos") + " " +
4539  "where empresa = " + DB.SQLString(this._Empresa) + " " +
4540  "and asi = " + DB.SQLString(this._Asi);
4541  bool llOk = DB.SQLExec(lcSql, ref ldtResul);
4542 
4543  if (ldtResul.Rows.Count == 0)
4544  {
4545  // FUNCTIONS._MessageBox("El asiento corresponde a otro ejercicio. Deberá cambiar al ejercicio " + Convert.ToString(_Ejercicio).Trim() + " para poderlo visualizar", "Ejercicio distinto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
4546  FUNCTIONS._MessageBox("El asiento corresponde a otro ejercicio. Deberá cambiar al ejercicio " + Convert.ToString(fCobro.Year) + " para poderlo visualizar", "Ejercicio distinto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
4547  return;
4548  }
4549  }
4550 
4551  if (!string.IsNullOrWhiteSpace(this._Asi))
4552  {
4553  if (this._Concepto.Length >= 20 && this._Concepto.Substring(0, 20) == "ASIENTO DEVOLUCION ")
4554  {
4555  System.Windows.Forms.ContextMenuStrip loMenu = new System.Windows.Forms.ContextMenuStrip();
4556 
4557  // Borramos las diferentes opciones
4558  loMenu.Items.Clear();
4559 
4560  loMenu.Items.Add("Ver asiento de cobro impagado");
4561  loMenu.Items[0].Name = "Opcion1";
4562  loMenu.Items[0].BackColor = System.Drawing.SystemColors.Menu;
4563  loMenu.Items[0].Enabled = true;
4564  loMenu.Items["Opcion1"].Click += delegate { Mostrar_Asiento(_Asi); };
4565 
4566  loMenu.Items.Add("Ver asiento de devolución");
4567  loMenu.Items[1].Name = "Opcion2";
4568  loMenu.Items[1].BackColor = System.Drawing.SystemColors.Menu;
4569 
4570  loMenu.Items[1].Enabled = true;
4571  loMenu.Items["Opcion2"].Click += delegate { Mostrar_Asiento(_Concepto.Substring(20, 20)); };
4572 
4573  loMenu.AutoClose = true;
4574  loMenu.Show(new System.Drawing.Point(Cursor.Position.X, Cursor.Position.Y));
4575  loMenu.Select();
4576  }
4577  else
4578  {
4579  Mostrar_Asiento(_Asi);
4580  }
4581  }
4582  }
4583 
4584 
4588  public virtual void _Show_Factura()
4589  {
4590  // Bug 136442. Controlar navegaciones no disponibles en modo "SoloConta" y en modo Sage50 Asesor Contable.
4591 
4592  // Task 142633; miramos si estamos en un Sage50 Asesor Contable.
4593  if (EW_GLOBAL._SaborSage50c == EW_GLOBAL.SaboresSage50c.AsesorContable)
4594  {
4595  // Estamos en un Sage50 Asesor Contable
4596  //
4597  // En este caso, no se puede activar la gestión comercial como en el caso del Solo Conta por tanto hemos de cambiar
4598  // el mensaje.
4599  if (!Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_ConceptosFacturables")))
4600  {
4601  FUNCTIONS._MessageBox("Navegación no disponible.", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1, DialogResult.OK);
4602  return;
4603  }
4604  }
4605  else
4606  {
4607  if (EW_GLOBAL._Solucion == 1)
4608  {
4609  // Estamos en un Sage50 Solo Conta
4610  //
4611  FUNCTIONS._MessageBox("Navegación sólo disponible marcando la opción 'Activar gestión comercial' en el mantenimiento de grupos de empresa.", MessageBoxButtons.OK, MessageBoxIcon.Information, MessageBoxDefaultButton.Button1, DialogResult.OK);
4612  return;
4613  }
4614  }
4615 
4616  //CCR 133177: Al navegar a la factura controlamos que no intente navegar a facturas de otro ejercicio. Mostramos mensaje que debe cambiar de ejercicio para visualizar dicha factura
4617  if (_Ejercicio == 0)
4618  _Ejercicio = Convert.ToInt32(DB.Ejercicio_EW);
4619 
4620  if (Convert.ToInt32(DB.Ejercicio_EW) != _Ejercicio)
4621  {
4622  FUNCTIONS._MessageBox("La factura corresponde a otro ejercicio. Deberá cambiar al ejercicio " + Convert.ToString(_Ejercicio).Trim() + " para poderla visualizar", "Ejercicio distinto", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
4623  return;
4624  }
4625  //FI CCR 133177
4626  // Comprobar si existe la factura física.
4627  string lcFactura = DB.SQLValor("C_ALBVEN", new String[] { "EMPRESA", "FACTURA" }, new String[] { _Empresa, _Factura }, "FACTURA").ToString();
4628 
4629 
4630  if (string.IsNullOrWhiteSpace(lcFactura))
4631  {
4632  using (FormBase loForm = new FormBase())
4633  {
4634  loForm._MessageBox("No hay documento de factura asociado ya que esta previsión se ha introducido manualmente.", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
4635  }
4636  }
4637  else
4638  {
4639  string lcLetraFactura = string.Empty;
4640  string lcNumeroFactura = string.Empty;
4641 
4643  {
4644  loForm._Mantener_Ejecucion = true;
4645 
4646  // Si no hi ha número de factura no cal presentar missatge, que presenti la factura de venta buida
4647  if (!string.IsNullOrWhiteSpace(this._Factura))
4648  {
4649  if (Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_Factser")) && Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_Serfact")))
4650  {
4651  lcLetraFactura = this._Factura.Substring(0, 2);
4652  lcNumeroFactura = this._Factura.Substring(2).Trim().PadLeft(8);
4653  }
4654  else
4655  {
4656  lcNumeroFactura = this._Factura.Trim().PadLeft(10);
4657  }
4658  }
4659 
4660  loForm._Documento._Load(this._Empresa, lcNumeroFactura, lcLetraFactura);
4661  // TODO: Abrir el formulario de forma NO MODAL para evitar bloqueos hasta que no se pasen a .NET los formularios de FOX accesibles desde este formulario.
4662  loForm._ShowDialog(); //Bug 114218 Cambiar .ShowDialog() por ._ShowDialog()
4663  //loForm._Show(); //Bug 151387 tornem a deixar el Showdialog, dona problemes amb FOX pero ...
4664  }
4665  }
4666  }
4667 
4668 
4672  public virtual void _Show_Remesa()
4673  {
4674  if (!string.IsNullOrWhiteSpace(this._Empresa) && !string.IsNullOrWhiteSpace(this._Factura))
4675  {
4676  if (this._Remesa != 0)
4677  {
4678  if (CONTABILIDAD._ExisteRemesaCobro(this._Remesa))
4679  {
4680  RemesaBancariaCobro loRemesa = new RemesaBancariaCobro(this._Remesa);
4681  loRemesa._Show();
4682  }
4683  else
4684  {
4685  using (FormBase loForm = new FormBase())
4686  {
4687  loForm._MessageBox("La remesa que pretende consultar no se encuentra en el ejercicio activo." + Environment.NewLine + Environment.NewLine +
4688  "Para acceder a la remesa, deberá hacerlo accediendo a la previsión de cobro desde el ejercicio en el que se " +
4689  "generó la remesa.", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
4690  }
4691  }
4692  }
4693  else
4694  {
4695  using (FormBase loForm = new FormBase())
4696  {
4697  loForm._MessageBox("La previsión de cobro " + this._Factura.Trim() + "/" +
4698  this._Orden.ToString().Trim() + " no está remesada.", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
4699  }
4700  }
4701  }
4702  else
4703  {
4704  using (FormBase loForm = new FormBase())
4705  {
4706  loForm._MessageBox("No hay declarado nº de factura en el objeto PrevisionCobro.", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
4707  }
4708  }
4709  }
4710 
4711 
4718  public virtual void _Show_Vencimientos(dynamic toDocumento = null, bool tlModoConsulta = true, List<PrevisionCobro> toListaPrevCob = null)
4719  {
4720  // Si no hi ha número de factura no cal fer res.
4721  if (string.IsNullOrWhiteSpace(this._Factura))
4722  {
4723  using (FormBase loForm = new FormBase())
4724  {
4725  loForm._MessageBox("Para visualizar los vencimientos debe indicar un número de factura.", MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
4726  }
4727  return;
4728  }
4729 
4730  string lcRetorn = string.Empty;
4731  string lcFactura = this._Factura;
4732  string lcCliente = this._Cliente;
4733  string lcMoneda = Convert.ToString(EW_GLOBAL._GetVariable("wc_moneda"));
4734  string lcDivisa = this._Divisa;
4735 
4736  DateTime ldFechaFac = Convert.ToDateTime(this._Fecha_Emision);
4737  bool llValor = true;
4738 
4739  // TODO: faig això ja que per saber si aquest botó ha d'anar des de fox o no, només ho sé mitjançant el botó. Després s'haurà de borrar.
4741  switch (loBotonTemporal.__Abrir_Formulario_En())
4742  {
4743  //TODO Borrar cuando pase por QA
4744  case 0: //No se aplica o error => FOX
4745  case 1: //.FOX
4746  object[] loParametres = new object[8] { lcFactura, lcCliente, lcMoneda, ldFechaFac, llValor, llValor, llValor, lcDivisa };
4747  lcRetorn = NETVFP._Abrir_Formulario_VFP("VENCIM", loParametres);
4748 
4749  break;
4750 
4751  case 2: //.NET
4752  using (sage.ew.docsven.Forms.frmVencimientos Vencimientos = new sage.ew.docsven.Forms.frmVencimientos(toDocumento, tlModoConsulta, toListaPrevCob))
4753  Vencimientos._ShowDialog(); //Bug 114218 Cambiar .ShowDialog() por ._ShowDialog()
4754 
4755  break;
4756 
4757  default:
4758  break;
4759  }
4760  loBotonTemporal = null;
4761  }
4762 
4763 
4764  #endregion MÉTODOS PUBLIC VIRTUAL
4765 
4766 
4767  #region METODOS PRIVADOS
4768 
4769 
4770 
4776  private Recibo _GetRecibo(DocPrintRecibo.TipoRecibo toTipoRecibo)
4777  {
4778  Recibo loRecibo;
4779 
4780  switch (toTipoRecibo)
4781  {
4782  case DocPrintRecibo.TipoRecibo.LetraCanvio:
4783 
4784  loRecibo = new ReciboLetraCnv();
4785  break;
4786 
4787  case DocPrintRecibo.TipoRecibo.ReciboEspecial:
4788 
4789  loRecibo = new ReciboEspecial();
4790  break;
4791 
4792  case DocPrintRecibo.TipoRecibo.Cuota:
4793 
4794  loRecibo = new ReciboCuota();
4795  break;
4796 
4797  default:
4798  loRecibo = new Recibo();
4799  break;
4800  }
4801 
4802  if (!String.IsNullOrEmpty(_Factura)) loRecibo._Recibo = String.Format("{0}_{1}", _Factura, _Orden);
4803 
4804  return loRecibo;
4805  }
4806 
4807 
4813  private bool _SetImpreso(String tcValor)
4814  {
4815  if (_Impreso != tcValor)
4816  {
4817  _Impreso = tcValor;
4818  _Save();
4819  }
4820 
4821  return true;
4822  }
4823 
4824 
4832  private DialogResult Gestionar_Pregunta(string tcPregunta = "", MessageBoxButtons toMessageButtons = MessageBoxButtons.OKCancel, DialogResult toDefaultDialogResult = DialogResult.OK)
4833  {
4834  DialogResult ldrResp = DialogResult.OK;
4835 
4836  if (_Mostrar_Mensajes)
4837  {
4838  using (FormBase loForm = new FormBase())
4839  {
4840  ldrResp = loForm._MessageBox(tcPregunta, toMessageButtons, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1, toDefaultDialogResult);
4841  }
4842  }
4843 
4844  return ldrResp;
4845  }
4846 
4847 
4853  private PrevisionCobro Generar_Prevision_Impago(int lnOtroImp)
4854  {
4855 
4856  PrevisionCobro loPrevisionNueva = new PrevisionCobro();
4857 
4858  // PE-103582
4859  loPrevisionNueva._Clonar(this, _Empresa, _Ejercicio, _Factura, _Orden, lnOtroImp, _Pendiente);
4860  loPrevisionNueva._Impago = "S";
4861  loPrevisionNueva._Impagado = lnOtroImp;
4862  loPrevisionNueva._Fecha_Vencim2 = null;
4863 
4864  // Guardar las nueva previsión ...
4865  loPrevisionNueva._Save();
4866 
4867  this._Impago = "S";
4868  this._Banco = "";
4869  this._Asi = "";
4870  this._Asiento = false;
4871  this._Remesa = 0;
4872  //this._Fecha_Remesa = null;
4873  this._Fecha_Cobro = null;
4874  this._Pagare = "";
4875  this._Imppagare = 0.0M;
4876  this._Fecha_Vencim2 = null;
4877  this._Fecha_Descuento = null;
4878  // this._Concepto = string.Empty;
4879 
4880  this._ImpagoGastosBancariosContabilizar = false;
4881  this._ImpagoGastosBancariosFecha = null;
4882  this._ImpagoGastosBancariosDivisa = string.Empty;
4883  this._ImpagoGastosBancariosCambio = 0M;
4884  this._ImpagoGastosBancariosImporte = 0M;
4885  this._ImpagoGastosBancariosCuenta = string.Empty;
4886 
4887  this._ImpagoNuevaFacturaGenerar = false;
4888  this._ImpagoNuevaFacturaNumero = string.Empty;
4889  this._ImpagoNuevaFacturaCuenta = string.Empty;
4890  this._ImpagoNuevaFacturaTipoIva = string.Empty;
4891  this._ImpagoNuevaFacturaContabilizar = false;
4892 
4893  this._ImpagoRepercutirGastos = false;
4894  this._ImpagoRepercutirImporte = 0M;
4895  this._ImpagoRepercutirFacturaGenerar = false;
4896  this._ImpagoRepercutirTipoIva = string.Empty;
4897  this._ImpagoRepercutirCuenta = string.Empty;
4898 
4899  // Linkar la previsión original con la nueva
4900  _Insertar_Trazabilidad_Impagos(loPrevisionNueva._Guid_Id, "PREV_NUEVA");
4901 
4902  return loPrevisionNueva;
4903  }
4904 
4905 
4910  private void Revisar_Tpv_Tikets(int lnOtroImp)
4911  {
4912  bool llOk = (Convert.ToString(DB.SQLValor("MODULOS", "NOMBRE", "TPV", "NOMBRE", "COMUNES")).Trim() == "TPV");
4913 
4914  if (llOk)
4915  {
4916  DataTable ldtResul = new DataTable();
4917  string lcSql = string.Empty;
4918 
4919  string lcCaja_Tpv = Convert.ToString(EW_GLOBAL._GetVariable("wc_cajatpv"));
4920  if (!string.IsNullOrWhiteSpace(lcCaja_Tpv))
4921  {
4922  // Ejercicio de la previsión ...
4923  string lcEjercicioPrevi = this._Ejercicio.ToString().Trim();
4924 
4925  // Ejercicio activo ...
4926  string lcAnyPredet = Convert.ToString(EW_GLOBAL._GetVariable("wc_any"));
4927 
4928  string lcFact = (this._Factura.Trim() + "/" + this._Orden.ToString().Trim() + "/" + lnOtroImp.ToString().Trim() + "/" + lcEjercicioPrevi).PadLeft(20, ' '); //PE-90948
4929 
4930  lcSql = "select numero " +
4931  "from " + DB.SQLDatabase("tpv", "tikets") + " " +
4932  "where ejercicio = " + DB.SQLString(lcAnyPredet.PadRight(15, ' ')) + " " +
4933  "and empresa = " + DB.SQLString(_lcEmpresa) + " " +
4934  "and numero = " + (DB.SQLString(this._Factura.Trim() + "/" + this._Orden.ToString().Trim() + "/" + this._Pendiente.ToString().Trim() + "/" + lcEjercicioPrevi)).PadLeft(20, ' ') + " " + //PE-90948
4935  "and letra = ' ' " +
4936  "and tipo = 4 " +
4937  "and asi = " + DB.SQLString(this._Asi);
4938  DB.SQLExec(lcSql, ref ldtResul);
4939 
4940  if (ldtResul.Rows.Count > 0)
4941  {
4942  if (!string.IsNullOrWhiteSpace(Convert.ToString(ldtResul.Rows[0]["numero"])))
4943  {
4944  lcSql = "update " + DB.SQLDatabase("tpv", "tikets") + " " +
4945  "set numero = " + DB.SQLString(lcFact) + " " +
4946  "where ejercicio = " + DB.SQLString(lcAnyPredet.PadRight(15, ' ')) + " " +
4947  "and empresa = " + DB.SQLString(_lcEmpresa) + " " +
4948  "and numero = " + (DB.SQLString(this._Factura.Trim() + "/" + this._Orden.ToString().Trim() + "/" + this._Pendiente.ToString().Trim() + "/" + lcEjercicioPrevi)).PadLeft(20, ' ') + " " + //PE-90948
4949  "and letra = ' ' " +
4950  "and tipo = 4 " +
4951  "and asi = " + DB.SQLString(this._Asi);
4952  DB.SQLExec(lcSql, ref ldtResul);
4953  }
4954  }
4955  }
4956  }
4957  }
4958 
4959 
4966  private bool Impago_Gastos_Nueva_Factura(PrevisionCobro loPrevisionNueva, DateTime tdFechaAsientoImpago)
4967  {
4968  string lcAsi = string.Empty;
4969  bool llOk = false;
4970 
4971  llOk = Asentar_Impago(tdFechaAsientoImpago,
4972  false,
4973  0M,
4974  loPrevisionNueva,
4975  ref lcAsi);
4976 
4977  if (llOk)
4978  {
4979  // Caso 2
4980  // Impago generando una nueva factura por los gastos bancarios
4981  loPrevisionNueva._Concepto = !string.IsNullOrWhiteSpace(_Concepto) ? _Concepto : "ASIENTO DEVOLUCION " + lcAsi; //Bug 179224 y 182667
4982  loPrevisionNueva._Save();
4983 
4984  _Save();
4985 
4986  // Generación de factura de gastos de impago
4987  //
4988  bool llOkGenFact = false;
4989  ParamGenFactCompra loCfgFactCompra = new ParamGenFactCompra
4990  {
4991  _FechaAsiento = tdFechaAsientoImpago,
4992  _FechaFactura = tdFechaAsientoImpago,
4993  _Proveedor = loPrevisionNueva._ImpagoNuevaFacturaCuenta,
4994  _Factura = loPrevisionNueva._ImpagoNuevaFacturaNumero,
4995  _Divisa = loPrevisionNueva._ImpagoGastosBancariosDivisa,
4996  _Cambio = loPrevisionNueva._ImpagoGastosBancariosCambio,
4997  _IvaIncluido = false,
4998  _PresentarVencimientos = false,
4999  _ContabilizarPago = loPrevisionNueva._ImpagoNuevaFacturaContabilizar,
5000  _PresentarFechaBancoPago = false,
5001  _CuentaBancoPago = loPrevisionNueva._ImpagoNuevaFacturaContabilizar ? loPrevisionNueva._Banco : "",
5002  _FechaPago = loPrevisionNueva._ImpagoNuevaFacturaContabilizar ? (DateTime?)tdFechaAsientoImpago : null,
5003  _PresentarAsiento = false,
5004  _PrcDtoPP = 0.0M,
5005  _AplicaRetPro = false
5006  };
5007  loCfgFactCompra._AnadirTipoIva(loPrevisionNueva._ImpagoNuevaFacturaTipoIva, loPrevisionNueva._ImpagoGastosBancariosImporte);
5008  loCfgFactCompra._AnadirContrapartida(loPrevisionNueva._ImpagoGastosBancariosCuenta, loPrevisionNueva._ImpagoGastosBancariosImporte);
5009 
5010  llOkGenFact = CONTABILIDAD._GenerarFacturaCompra(loCfgFactCompra);
5011  if (llOkGenFact)
5012  {
5013  IAsientos loAsiento = loCfgFactCompra._AsientoGenerado;
5014  if (loAsiento != null)
5015  {
5016  docscompra.PrevisionPago loPrevisionPago = new docscompra.PrevisionPago(loAsiento._Empresa, loAsiento._Proveedor, loAsiento._Factura, 1, 0, loPrevisionNueva._Ejercicio)
5017  {
5018  _Concepto = !string.IsNullOrWhiteSpace(_Concepto) ? _Concepto : "ASIENTO PREVISIÓN " + loAsiento._Lineas[0]._Asi //Bug 179224 y 182667
5019  };
5020  loPrevisionPago._Save();
5021 
5022  // Linkar la previsión original con la previsión de pago
5023  _Insertar_Trazabilidad_Impagos(loPrevisionPago._Guid_Id, "PREV_PAGO");
5024  }
5025  }
5026 
5027  //AsientosFacturasCompraGenerador loGenAsiFacCom = new AsientosFacturasCompraGenerador();
5028  //loGenAsiFacCom._LinkForm = false;
5029 
5030  //loGenAsiFacCom._Fecha_Asiento = tdFechaAsientoImpago;
5031  //loGenAsiFacCom._Fecha_Factura = tdFechaAsientoImpago;
5032 
5035  //loGenAsiFacCom._CliPro = loPrevisionNueva._ImpagoNuevaFacturaCuenta;
5036  //loGenAsiFacCom._Factura = loPrevisionNueva._ImpagoNuevaFacturaNumero;
5037 
5039  //loGenAsiFacCom._Divisa = loPrevisionNueva._ImpagoGastosBancariosDivisa;
5040  //loGenAsiFacCom._Cambio = loPrevisionNueva._ImpagoGastosBancariosCambio;
5041 
5042 
5044  //if (loGenAsiFacCom._TipoIvaLineas.Count == 0)
5045  // loGenAsiFacCom._TipoIvaLineas.Add(new AsientosFacturasGenerador.TipoIvaLinea(loGenAsiFacCom));
5046 
5047  //AsientosFacturasCompraGenerador.TipoIvaLinea loLiniaTipoIva = loGenAsiFacCom._TipoIvaLineas[0];
5048  //loLiniaTipoIva._Codigo = loPrevisionNueva._ImpagoNuevaFacturaTipoIva;
5049  //loLiniaTipoIva._Base = loPrevisionNueva._ImpagoGastosBancariosImporte;
5050 
5051 
5052 
5054  //if (loGenAsiFacCom._ContrapartidasLineas.Count == 0)
5055  // loGenAsiFacCom._ContrapartidasLineas.Add(new AsientosFacturasGenerador.ContraPartidaLinea(loGenAsiFacCom));
5056 
5057  //AsientosFacturasCompraGenerador.ContraPartidaLinea loLiniaContrapartida = loGenAsiFacCom._ContrapartidasLineas[0];
5058  //loLiniaContrapartida._Cuenta = loPrevisionNueva._ImpagoGastosBancariosCuenta;
5059  //loLiniaContrapartida._Importe = loPrevisionNueva._ImpagoGastosBancariosImporte;
5060 
5061  //loGenAsiFacCom._GenerarAsientoFactura();
5062 
5063  //IAsientos loAsiento = loGenAsiFacCom._AsientoGenerado;
5064 
5065  //if (loAsiento != null)
5066  //{
5067  // //Generar previsiones.
5068  // loGenAsiFacCom._GenerarPrevisiones(false, null, loGenAsiFacCom._Divisa, loGenAsiFacCom._Cambio);
5069 
5070  // docscompra.PrevisionPago loPrevisionPago = new docscompra.PrevisionPago(loAsiento._Empresa, loAsiento._Proveedor, loAsiento._Factura, 1, 0, loPrevisionNueva._Ejercicio);
5071  // loPrevisionPago._Concepto = "ASIENTO PREVISIÓN " + loAsiento._Lineas[0]._Asi;
5072  // loPrevisionPago._Save();
5073 
5074  // // Linkar la previsión original con la previsión de pago
5075  // _Insertar_Trazabilidad_Impagos(loPrevisionPago._Guid_Id, "PREV_PAGO");
5076 
5077  // // Contabilizar nueva previsión pago
5078  // if (loPrevisionNueva._ImpagoNuevaFacturaContabilizar)
5079  // {
5080  // if (loPrevisionPago._Divisa == _lcMonedaEmpresa)
5081  // loPrevisionPago._Contabilizar(loPrevisionNueva._Banco, tdFechaAsientoImpago, loPrevisionPago._Importe);
5082  // else
5083  // loPrevisionPago._Contabilizar(loPrevisionNueva._Banco, tdFechaAsientoImpago, loPrevisionPago._ImporteDiv);
5084  // }
5085  //}
5086  }
5087  return llOk;
5088  }
5089 
5090 
5097  private bool Impago_Cargo_Empresa(PrevisionCobro loPrevisionNueva, DateTime tdFechaAsientoImpago)
5098  {
5099  string lcAsi = string.Empty;
5100  bool llOk = false;
5101 
5102  llOk = Asentar_Impago(tdFechaAsientoImpago,
5103  loPrevisionNueva._ImpagoGastosBancariosContabilizar,
5104  loPrevisionNueva._ImpagoGastosBancariosImporte,
5105  loPrevisionNueva,
5106  ref lcAsi);
5107 
5108  // Caso 1
5109  // Impago con gastos a cargo de la empresa
5110  if (llOk)
5111  {
5112  // loPrevisionNueva._Concepto = "ASIENTO DEVOLUCION " + lcAsi;
5113  loPrevisionNueva._Save();
5114 
5115  this._Save();
5116 
5117  }
5118  return llOk;
5119  }
5120 
5121 
5128  private bool Repercutir_Gastos_Nueva_Factura(PrevisionCobro loPrevisionNueva, DateTime tdFechaAsientoImpago)
5129  {
5130  // Caso 4
5131  // Repercutir gastos al cliente generando una nueva factura
5132 
5133  bool llSerfact = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_serfact"));
5134 
5135  ParamGenFactVenta loCfgFactVenta = new ParamGenFactVenta();
5136  loCfgFactVenta._FechaAsiento = tdFechaAsientoImpago;
5137  loCfgFactVenta._FechaFactura = tdFechaAsientoImpago;
5138  loCfgFactVenta._Cliente = loPrevisionNueva._Cliente;
5139  loCfgFactVenta._SerieFra = llSerfact ? EW_GLOBAL._Empresa._Letra_Defecto(3) : "";
5140  loCfgFactVenta._Factura = "";
5141  loCfgFactVenta._TipoFactura = 0;
5142  loCfgFactVenta._IvaIncluido = false;
5143  loCfgFactVenta._PresentarVencimientos = false;
5144  loCfgFactVenta._ContabilizarCobro = false;
5145  loCfgFactVenta._PresentarFechaBancoCobro = false;
5146  loCfgFactVenta._PresentarAsiento = false;
5147  loCfgFactVenta._GirosPrc = new List<LineaGiro>() { new LineaGiro() { _NumGiro = 1, _Giro = 0, _Porcentaje = 100 } };
5148  loCfgFactVenta._PrcDtoPP = 0.0M;
5149  loCfgFactVenta._AplicaRetCli = false;
5150  loCfgFactVenta._PrcRecFinan = 0.0M;
5151  loCfgFactVenta._AnadirTipoIva(loPrevisionNueva._ImpagoRepercutirTipoIva, loPrevisionNueva._ImpagoRepercutirImporte);
5152  loCfgFactVenta._AnadirContrapartida(loPrevisionNueva._ImpagoRepercutirCuenta, loPrevisionNueva._ImpagoRepercutirImporte);
5153 
5154  bool llOk = CONTABILIDAD._GenerarFacturaVenta(loCfgFactVenta);
5155 
5156  if (llOk)
5157  {
5158  IAsientos loAsiento = loCfgFactVenta._AsientoGenerado;
5159  if (loAsiento != null)
5160  {
5161  PrevisionCobro loPrevisionCobro = new PrevisionCobro(loAsiento._Empresa, loPrevisionNueva._Ejercicio, loAsiento._Factura, 1, 0, 0)
5162  {
5163  _Concepto = !string.IsNullOrWhiteSpace(_Concepto) ? _Concepto : "ASIENTO REPERCUTIR " + loAsiento._Lineas[0]._Asi //Bug 179224 y 182667
5164  };
5165  loPrevisionCobro._Save();
5166 
5167  // Linkar la previsión original con la previsión de pago
5168  _Insertar_Trazabilidad_Impagos(loPrevisionCobro._Guid_Id, "PREV_FACT");
5169  }
5170  }
5171 
5172  return true;
5173 
5174 
5175 
5177  //AsientosFacturasVentaGenerador loGenAsiFacVen = new AsientosFacturasVentaGenerador();
5178  //loGenAsiFacVen._LinkForm = false;
5179 
5180  //loGenAsiFacVen._Fecha_Asiento = tdFechaAsientoImpago;
5181  //loGenAsiFacVen._Fecha_Factura = tdFechaAsientoImpago;
5182 
5185  //loGenAsiFacVen._CliPro = loPrevisionNueva._Cliente;
5186 
5188  //bool llSerfact = Convert.ToBoolean(EW_GLOBAL._GetVariable("wl_serfact"));
5189  //string lcLetra = EW_GLOBAL._Empresa._Letra_Defecto(3);
5190 
5191  //string lcFactura = CONTABILIDAD._Suma_Numero_Factura_Venta(_lcEmpresa, llSerfact ? lcLetra : "");
5192  //if (llSerfact)
5193  // // En este caso lcFactura llega con 8 dígitos.
5194  // loGenAsiFacVen._Factura = lcLetra + lcFactura;
5195  //else
5196  // loGenAsiFacVen._Factura = lcFactura;
5197 
5198 
5199 
5201  //if (loGenAsiFacVen._TipoIvaLineas.Count == 0)
5202  // loGenAsiFacVen._TipoIvaLineas.Add(new AsientosFacturasGenerador.TipoIvaLinea(loGenAsiFacVen));
5203 
5204  //AsientosFacturasVentaGenerador.TipoIvaLinea loLiniaTipoIva = loGenAsiFacVen._TipoIvaLineas[0];
5205  //loLiniaTipoIva._Codigo = loPrevisionNueva._ImpagoRepercutirTipoIva;
5206  //loLiniaTipoIva._Base = loPrevisionNueva._ImpagoRepercutirImporte;
5207 
5208 
5209 
5211  //if (loGenAsiFacVen._ContrapartidasLineas.Count == 0)
5212  // loGenAsiFacVen._ContrapartidasLineas.Add(new AsientosFacturasGenerador.ContraPartidaLinea(loGenAsiFacVen));
5213 
5214  //AsientosFacturasVentaGenerador.ContraPartidaLinea loLiniaContrapartida = loGenAsiFacVen._ContrapartidasLineas[0];
5215  //loLiniaContrapartida._Cuenta = loPrevisionNueva._ImpagoRepercutirCuenta;
5216  //loLiniaContrapartida._Importe = loPrevisionNueva._ImpagoRepercutirImporte;
5217 
5218 
5220  //loGenAsiFacVen._GenerarAsientoFactura();
5221  //IAsientos loAsiento = loGenAsiFacVen._AsientoGenerado;
5222 
5223  //if (loAsiento != null)
5224  //{
5225  // // Linkar la previsión original con la previsión de pago
5226  // //_Rellenar_Trazabilidad_Impagos(loAsiento._Lineas[0]._Guid_Id, _Guid_Id, "ASI_REPER");
5227 
5228  // //Generar previsiones.
5229  // List<int> lstGiros = new List<int>();
5230  // lstGiros.Add(0);
5231  // if (loGenAsiFacVen._GenerarPrevisiones(false, lstGiros, loGenAsiFacVen._Divisa, loGenAsiFacVen._Cambio))
5232  // {
5233  // PrevisionCobro loPrevisionCobro = new PrevisionCobro(loAsiento._Empresa, loPrevisionNueva._Ejercicio, loAsiento._Factura, 1, 0, 0);
5234  // loPrevisionCobro._Concepto = "ASIENTO REPERCUTIR " + loAsiento._Lineas[0]._Asi;
5235  // loPrevisionCobro._Save();
5236 
5237  // // Linkar la previsión original con la previsión de pago
5238  // _Insertar_Trazabilidad_Impagos(loPrevisionCobro._Guid_Id, "PREV_FACT");
5239  // }
5240  //}
5241  // return true;
5242  }
5243 
5244 
5251  private bool Repercutir_Gastos_Cliente(PrevisionCobro loPrevisionNueva, DateTime tdFechaAsientoImpago)
5252  {
5253  // Caso 3
5254  // Repercutir gastos de devolución al cliente
5255  PrevisionCobro loPrevisionRepercutida = new PrevisionCobro();
5256 
5257  int lnOrden = _Obtener_Orden_Maximo() + 1;
5258 
5259  loPrevisionRepercutida._Clonar(this, _Empresa, _Ejercicio, _Factura, lnOrden, 0, 0);
5260 
5261 
5262 
5263  loPrevisionRepercutida._Impago = "N";
5264  loPrevisionRepercutida._Banco = "";
5265  loPrevisionRepercutida._Asi = "";
5266  loPrevisionRepercutida._Asiento = false;
5267  loPrevisionRepercutida._Remesa = 0;
5268  loPrevisionRepercutida._Fecha_Remesa = null;
5269  loPrevisionRepercutida._Fecha_Cobro = null;
5270  loPrevisionRepercutida._Pagare = "";
5271  loPrevisionRepercutida._Imppagare = 0.0M;
5272  loPrevisionRepercutida._Fecha_Vencim2 = null;
5273  loPrevisionRepercutida._Fecha_Descuento = null;
5274  loPrevisionRepercutida._Concepto = "";
5275 
5276  loPrevisionRepercutida._Vendedor = _Vendedor;
5277  loPrevisionRepercutida._Cobrador = _Cobrador;
5278  loPrevisionRepercutida._Forma_Pago = _Forma_Pago;
5279  loPrevisionRepercutida._Fecha_Emision = tdFechaAsientoImpago;
5280  loPrevisionRepercutida._Fecha_Vencim = _Fecha_Vencim;
5281 
5282 
5283 
5284  decimal lnCambio = Cliente._CambioPactado(loPrevisionRepercutida._Cliente, loPrevisionRepercutida._Divisa, tdFechaAsientoImpago);
5285  loPrevisionRepercutida._Cambio = lnCambio;
5286 
5287  if (loPrevisionRepercutida._Divisa == _lcMonedaEmpresa)
5288  loPrevisionRepercutida._Importe = loPrevisionNueva._ImpagoRepercutirImporte;
5289  else
5290  loPrevisionRepercutida._ImporteDiv = loPrevisionNueva._ImpagoRepercutirImporte;
5291 
5292 
5293  // Guardar las nueva previsión ...
5294  loPrevisionRepercutida._Save();
5295 
5296  // Linkar la previsión original con la previsión de pago
5297  _Insertar_Trazabilidad_Impagos(loPrevisionRepercutida._Guid_Id, "PREV_REPER");
5298 
5299  return true;
5300  }
5301 
5302 
5307  private int Buscar_Pendiente()
5308  {
5309  // Declaración de variables
5310  DataTable ldtResul = new DataTable();
5311  int lnPendiente = 1;
5312  bool llOk = false;
5313 
5314  // Montamos la consulta para buscar el máximo
5315  string lcSql = "select max(pendiente) as pendiente " +
5316  "from " + DB.SQLDatabase("comunes", "previ_cl") + " " +
5317  "where empresa = " + DB.SQLString(this._Empresa) + " " +
5318  "and periodo = " + DB.SQLString(this._Ejercicio) + " " +
5319  "and factura = " + DB.SQLString(this._Factura) + " " +
5320  "and orden = " + DB.SQLString(this._Orden) + " " +
5321  "and impagado = " + DB.SQLString(this._Impagado);
5322 
5323  // Realizamos la consulta. De momento no tratamos si la consulta ha fallado
5324  llOk = DB.SQLExec(lcSql, ref ldtResul);
5325 
5326  // Si tenemos registros incrementamos el pendiente
5327  if (ldtResul.Rows.Count > 0)
5328  lnPendiente = Convert.ToInt32(ldtResul.Rows[0]["pendiente"]) + 1;
5329 
5330  ldtResul = null;
5331 
5332  // Devolvemos el pendiente
5333  return lnPendiente;
5334  }
5335 
5336 
5341  private void SaveCriterioCaja()
5342  {
5343  if (_cOldAsi != _Asi)
5344  {
5345  if (_Recc)
5346  {
5347  bool llOk = true;
5348  string lcOldAsi = _cOldAsi;
5349 
5350  CriterioCaja loCriterioCaja = new CriterioCaja();
5351 
5352  if (string.IsNullOrWhiteSpace(_Asi)) // Si no tenemos ASI vamos a realizar el Delete
5353  llOk = loCriterioCaja._Delete(this, lcOldAsi);
5354  else
5355  llOk = loCriterioCaja._Save(this, _lCobroParcial);
5356 
5357  if (!llOk && !string.IsNullOrWhiteSpace(loCriterioCaja._Mensaje_Error))
5358  Gestionar_Mensaje(loCriterioCaja._Mensaje_Error);
5359  }
5360 
5361  _cOldAsi = _Asi;
5362  }
5363  }
5364 
5365 
5369  private void Establecer_Clave()
5370  {
5371  this._Clave = "EMPRESA,PERIODO,FACTURA,ORDEN,IMPAGADO,PENDIENTE";
5372  this._DataBase = "COMUNES";
5373  this._Tabla = "PREVI_CL";
5374  this._TituloMantenimiento = "Previsiones de cobro";
5375  this._Pregunta_Borrar = "¿Desea eliminar el registro?";
5376  this._FormManteBaseType = typeof(Forms.frmPrevisionCobroMante);
5377  this.Navegacion._Condicion = "EMPRESA = " + DB.SQLString(_lcEmpresa);
5378  }
5379 
5380 
5385  private DialogResult Gestionar_Pregunta(string tcPregunta = "")
5386  {
5387  DialogResult ldrResp = DialogResult.OK;
5388 
5389  if (this._Mostrar_Mensajes)
5390  {
5391  using (FormBase loForm = new FormBase())
5392  {
5393  ldrResp = loForm._MessageBox(tcPregunta, MessageBoxButtons.OKCancel, MessageBoxIcon.Question, MessageBoxDefaultButton.Button1, DialogResult.OK);
5394  }
5395  }
5396 
5397  return ldrResp;
5398  }
5399 
5400 
5406  private void Gestionar_Mensaje(string tcMensaje = "", string tcOrigen = "")
5407  {
5408  _Error_Message = tcMensaje;
5409 
5410  if (_Mostrar_Mensajes)
5411  {
5412  using (FormBase loForm = new FormBase())
5413  {
5414  loForm._MessageBox(tcMensaje, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1, DialogResult.OK);
5415  }
5416  }
5417 
5418  _Error_Message += " (" + tcOrigen + ")";
5419  }
5420 
5421 
5426  private void Mostrar_Asiento(string tcAsi = "")
5427  {
5428  if (string.IsNullOrWhiteSpace(tcAsi))
5429  return;
5430 
5431  Asientos loAsiento = new Asientos(tcAsi);
5432  loAsiento._Show();
5433  }
5434 
5435 
5445  private bool Asentar_Impago(DateTime tdFechaAsientoImpago, bool tlAsentarGastos, decimal tnGastos, PrevisionCobro toPrevisionNueva, ref string tcAsi)
5446  {
5447  bool llOk = false;
5448  string lcDivisa = toPrevisionNueva._Divisa;
5449  decimal lnCambio = toPrevisionNueva._Cambio;
5450  decimal lnNuevoImporte = toPrevisionNueva._Importe;
5451  decimal lnNuevoImporteDivisa = toPrevisionNueva._ImporteDiv;
5452 
5453  string lcGastosDivisa = toPrevisionNueva._ImpagoGastosBancariosDivisa;
5454  decimal lnGastosCambio = toPrevisionNueva._ImpagoGastosBancariosCambio;
5455  decimal lnRepercDivisa = toPrevisionNueva._ImpagoRepercutirImporte;
5456 
5457  string lcBanco = toPrevisionNueva._Banco;
5458  bool llRepercutirGastos = toPrevisionNueva._ImpagoRepercutirGastos;
5459  string lcCuentaGastos = toPrevisionNueva._ImpagoGastosBancariosCuenta;
5460  string lcCuentaReperc = toPrevisionNueva._ImpagoRepercutirCuenta;
5461 
5462  bool llFacturaRepercutir = toPrevisionNueva._ImpagoRepercutirFacturaGenerar;
5463 
5464  // Si no nos llega por parámetro la cuenta de gastos le enchufamos la 62600001
5465  int lnDigitos = EW_GLOBAL._GetLenCampo(KeyDiccionarioLenCampos.wn_digitos);
5466  string lcCtaGastos = string.IsNullOrWhiteSpace(lcCuentaGastos) ? ("626" + new string('0', lnDigitos - 4) + "1") : lcCuentaGastos;
5467 
5468  Asientos loAsiento = new Asientos
5469  {
5470  _Empresa = _Empresa,
5471  _Fecha = tdFechaAsientoImpago,
5472  _Factura = string.Empty,
5473  _Proveedor = string.Empty,
5474  _Divisa = _Divisa,
5475  _Arqueo = 0,
5476  _Cambio = lnCambio
5477  };
5478 
5479  // No hay gastos o si los hay no hay que asentarlos, en este caso haremos un asientos banco-cliente
5480  if (tnGastos == 0.0M || tlAsentarGastos == false)
5481  {
5482  string definicion = string.Empty;
5483 
5484  // Repercutir los gastos al cliente
5485  if (llRepercutirGastos && !llFacturaRepercutir)
5486  {
5487  var esMonedaEmpresa = lcDivisa == _lcMonedaEmpresa;
5488 
5489  #region Asiento repercusión
5490 
5491  // Asiento repercusión
5492  loAsiento = new Asientos
5493  {
5494  _Fecha = tdFechaAsientoImpago,
5495  _Divisa = esMonedaEmpresa ? lcDivisa : lcGastosDivisa,
5496  _Cambio = esMonedaEmpresa ? lnCambio : lnGastosCambio
5497  };
5498 
5499  definicion = "Repercusión impago N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5500 
5501  CrearLineaAsientoDEBE(ref loAsiento, _Cliente, definicion, lnRepercDivisa, lnRepercDivisa); // Primera linea del asiento
5502  CrearLineaAsientoHABER(ref loAsiento, lcCuentaReperc, definicion, lnRepercDivisa, lnRepercDivisa); // Segunda linea del asiento
5503 
5504  loAsiento._Save();
5505 
5506  #endregion Asiento repercusión
5507 
5508  }
5509 
5510  #region Asiento devolución
5511 
5512  loAsiento = new Asientos
5513  {
5514  _Fecha = tdFechaAsientoImpago,
5515  _Divisa = lcDivisa,
5516  _Cambio = lnCambio
5517  };
5518 
5519  definicion = "Devolución N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5520 
5521  CrearLineaAsientoHABER(ref loAsiento, lcBanco, definicion, lnNuevoImporte, lnNuevoImporteDivisa); // Primera linea del asiento
5522  CrearLineaAsientoDEBE(ref loAsiento, _Cliente, definicion, lnNuevoImporte, lnNuevoImporteDivisa); // Segunda linea del asiento
5523 
5524  //Graba al salir
5525 
5526  #endregion Asiento devolución
5527 
5528  }
5529  else
5530  {
5531  // Si pasa por aqui es por que los gastos son diferentes de 0 y ademas hay que asentarlos
5532 
5533  if (!llRepercutirGastos)
5534  {
5535  if (lcDivisa == _lcMonedaEmpresa)
5536  {
5537 
5538  #region Asientos de la devolución
5539 
5540  // Devolucion a cargo de la empresa
5541 
5542  loAsiento._Cambio = lnGastosCambio;
5543  var definicion = "Devolución N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5544 
5545  CrearLineaAsientoHABER(ref loAsiento, lcBanco, definicion, lnNuevoImporte + tnGastos, lnNuevoImporte + tnGastos); // Primera linea del asiento
5546  CrearLineaAsientoDEBE(ref loAsiento, _Cliente, definicion, lnNuevoImporte, lnNuevoImporte); // Segunda linea del asiento
5547 
5548  definicion = "Gastos impago N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5549  CrearLineaAsientoDEBE(ref loAsiento, lcCuentaGastos, definicion, tnGastos, tnGastos); // Tercera linea del asiento
5550 
5551  #endregion Asientos de la devolución
5552 
5553  }
5554  else
5555  {
5556 
5557  #region Asiento de los gastos
5558 
5559  // Primero haremos el asiento de los gastos
5560  loAsiento._Divisa = lcGastosDivisa;
5561  loAsiento._Cambio = lnGastosCambio;
5562 
5563  var definicion = "Gastos impago N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5564 
5565  CrearLineaAsientoHABER(ref loAsiento, lcBanco, definicion, tnGastos, tnGastos); // Primera linea del asiento
5566  CrearLineaAsientoDEBE(ref loAsiento, lcCuentaGastos, definicion, tnGastos, tnGastos); // Segunda linea del asiento
5567 
5568 
5569  loAsiento._Save();
5570 
5571  #endregion Asiento de los gastos
5572 
5573  #region Asiento de la devolución
5574 
5575  // Ahora montamos el asiento de la devolución
5576  loAsiento = new Asientos
5577  {
5578  _Fecha = tdFechaAsientoImpago,
5579  _Divisa = lcDivisa,
5580  _Cambio = lnCambio
5581  };
5582 
5583  definicion = "Devolución N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5584 
5585  CrearLineaAsientoHABER(ref loAsiento, lcBanco, definicion, lnNuevoImporte, lnNuevoImporteDivisa); // Primera linea del asiento
5586  CrearLineaAsientoDEBE(ref loAsiento, _Cliente, definicion, lnNuevoImporte, lnNuevoImporteDivisa); // Segunda linea del asiento
5587 
5588  //Graba al salir
5589 
5590  #endregion Asiento de la devolución
5591 
5592  }
5593  }
5594  else
5595  {
5596  // Repercutir los gastos al cliente
5597 
5598  if (lcDivisa == _lcMonedaEmpresa)
5599  {
5600  var definicion = string.Empty;
5601  if (!llFacturaRepercutir)
5602  {
5603  #region Asiento repercusión
5604 
5605  // Asiento repercusión
5606  loAsiento = new Asientos
5607  {
5608  _Fecha = tdFechaAsientoImpago,
5609  _Divisa = lcDivisa,
5610  _Cambio = lnCambio
5611  };
5612 
5613  definicion = "Repercusión impago N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5614 
5615  CrearLineaAsientoDEBE(ref loAsiento, _Cliente, definicion, lnRepercDivisa, lnRepercDivisa); // Primera linea del asiento
5616  CrearLineaAsientoHABER(ref loAsiento, lcCuentaReperc, definicion, lnRepercDivisa, lnRepercDivisa);// Segunda linea del asiento
5617 
5618  loAsiento._Save();
5619  }
5620 
5621  #endregion Asiento repercusión
5622 
5623  #region Asiento de la devolución
5624 
5625  // Ahora montamos el asiento de la devolución
5626  loAsiento = new Asientos
5627  {
5628  _Fecha = tdFechaAsientoImpago,
5629  _Divisa = lcDivisa,
5630  _Cambio = lnCambio
5631  };
5632 
5633  definicion = "Devolución N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5634 
5635  CrearLineaAsientoHABER(ref loAsiento, lcBanco, definicion, lnNuevoImporte + tnGastos, lnNuevoImporteDivisa + tnGastos); // Primera linea del asiento
5636  CrearLineaAsientoDEBE(ref loAsiento, _Cliente, definicion, lnNuevoImporte, lnNuevoImporteDivisa);// Segunda linea del asiento
5637 
5638  definicion = "Gastos impago Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5639  CrearLineaAsientoDEBE(ref loAsiento, lcCtaGastos, definicion, tnGastos, tnGastos); // Tercera linea del asiento
5640 
5641  //Graba al salir
5642 
5643  #endregion Asiento de la devolución
5644 
5645  }
5646  else
5647  {
5648 
5649  #region Asiento de los gastos
5650 
5651  // Primero haremos el asiento de los gastos
5652  loAsiento._Divisa = lcGastosDivisa;
5653  loAsiento._Cambio = lnGastosCambio;
5654 
5655  var definicion = "Gastos impago N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5656 
5657  CrearLineaAsientoHABER(ref loAsiento, lcBanco, definicion, tnGastos, tnGastos); // Primera linea del asiento
5658  CrearLineaAsientoDEBE(ref loAsiento, lcCuentaGastos, definicion, tnGastos, tnGastos); // Segunda linea del asiento
5659 
5660  loAsiento._Save();
5661 
5662  #endregion Asiento de los gastos
5663 
5664  if (!llFacturaRepercutir)
5665  {
5666  #region Asiento repercusión
5667 
5668  // Asiento repercusión
5669  loAsiento = new Asientos
5670  {
5671  _Fecha = tdFechaAsientoImpago,
5672  _Divisa = lcGastosDivisa,
5673  _Cambio = lnGastosCambio
5674  };
5675 
5676 
5677  definicion = "Repercusión impago N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5678 
5679  CrearLineaAsientoDEBE(ref loAsiento, _Cliente, definicion, lnRepercDivisa, lnRepercDivisa); // Primera linea del asiento
5680  CrearLineaAsientoHABER(ref loAsiento, lcCuentaReperc, definicion, lnRepercDivisa, lnRepercDivisa); // Segunda linea del asiento
5681 
5682  loAsiento._Save();
5683  }
5684 
5685  #endregion Asiento repercusión
5686 
5687  #region Asiento de la devolución
5688 
5689  // Ahora montamos el asiento de la devolución
5690  loAsiento = new Asientos
5691  {
5692  _Fecha = tdFechaAsientoImpago,
5693  _Divisa = lcDivisa,
5694  _Cambio = lnCambio
5695  };
5696 
5697  definicion = "Devolución N/Fra. " + _Factura.Trim() + "/" + _Orden.ToString().Trim();
5698 
5699  CrearLineaAsientoHABER(ref loAsiento, lcBanco, definicion, lnNuevoImporte, lnNuevoImporteDivisa); // Primera linea del asiento
5700  CrearLineaAsientoDEBE(ref loAsiento, _Cliente, definicion, lnNuevoImporte, lnNuevoImporteDivisa); // Segunda linea del asiento
5701 
5702  #endregion Asiento de la devolución
5703 
5704  }
5705  }
5706  }
5707 
5708  //Grabo el asiento que he creado
5709  llOk = loAsiento._Save();
5710  if (llOk)
5711  {
5712  tcAsi = loAsiento._Lineas[0]._Asi;
5713  }
5714  else
5715  tcAsi = "";
5716 
5717  return llOk;
5718  }
5719 
5720 
5729  private void CrearLineaAsientoDEBE(ref Asientos asiento, string cuenta, string definicion, decimal importe, decimal importediv)
5730  {
5731  var lineaNueva = asiento._AddLinea();
5732  lineaNueva._Cuenta = cuenta;
5733  lineaNueva._Definicion = definicion;
5734 
5735  if (lineaNueva._Divisa == EW_GLOBAL._Empresa._Moneda)
5736  {
5737  lineaNueva._Debe = importe;
5738  }
5739  else
5740  {
5741  lineaNueva._DebeDiv = importediv;
5742  }
5743  }
5744 
5745 
5754  private void CrearLineaAsientoHABER(ref Asientos asiento, string cuenta, string definicion, decimal importe, decimal importediv)
5755  {
5756  var lineaNueva = asiento._AddLinea();
5757  lineaNueva._Cuenta = cuenta;
5758  lineaNueva._Definicion = definicion;
5759 
5760  if (lineaNueva._Divisa == EW_GLOBAL._Empresa._Moneda)
5761  {
5762  lineaNueva._Haber = importe;
5763  }
5764  else
5765  {
5766  lineaNueva._HaberDiv = importediv;
5767  }
5768  }
5769 
5770 
5778  private DateTime Calcular_Fecha_Vencimiento(DateTime? tdDiaPago1, DateTime? tdDiaPago2, DateTime tdDiaVencimiento)
5779  {
5780  DateTime ldFechaVencimiento = tdDiaVencimiento;
5781 
5782  if (tdDiaPago1 != null && tdDiaPago2 != null)
5783  {
5784  if (tdDiaVencimiento > tdDiaPago1 && tdDiaVencimiento < tdDiaPago2)
5785  ldFechaVencimiento = Convert.ToDateTime(tdDiaPago2);
5786  else if (tdDiaVencimiento > tdDiaPago1 && tdDiaVencimiento > tdDiaPago2)
5787  ldFechaVencimiento = Convert.ToDateTime(tdDiaPago1).AddMonths(1);
5788  else if (tdDiaVencimiento <= tdDiaPago1)
5789  ldFechaVencimiento = Convert.ToDateTime(tdDiaPago1);
5790  }
5791  else if (tdDiaPago1 != null && tdDiaPago2 == null)
5792  {
5793  if (tdDiaVencimiento > tdDiaPago1)
5794  ldFechaVencimiento = Convert.ToDateTime(tdDiaPago1).AddMonths(1);
5795  else if (tdDiaVencimiento <= tdDiaPago1)
5796  ldFechaVencimiento = Convert.ToDateTime(tdDiaPago1);
5797  }
5798 
5799  return ldFechaVencimiento;
5800  }
5801 
5802 
5811  private bool Es_Valido_Vencimiento(DateTime? tdVencimientoAnterior, DateTime? tdVencimiento, ref int tnDiasIntento)
5812  {
5813  bool llVencimientoOK = (tdVencimientoAnterior == null || tdVencimiento > tdVencimientoAnterior);
5814 
5815  if (llVencimientoOK)
5816  tnDiasIntento = 0;
5817  else
5818  tnDiasIntento = tnDiasIntento + 1;
5819 
5820  if (tnDiasIntento > 91)
5821  llVencimientoOK = true;
5822 
5823  return llVencimientoOK;
5824  }
5825 
5826 
5833  private bool Consultar_Previsiones(EstadoPrevisiones tcEstadoPrevision, ref DataTable tdtPrevisiones)
5834  {
5835  bool llOk = false;
5836  string lcEmpresa = string.IsNullOrWhiteSpace(this._Empresa) ? Convert.ToString(_lcEmpresa) : this._Empresa;
5837 
5838  string lcSql = "Select empresa,periodo,factura,orden,impagado,pendiente " +
5839  "From " + DB.SQLDatabase("comunes", "previ_cl") + " " +
5840  "where empresa =" + DB.SQLString(lcEmpresa);
5841 
5842  // si tenim dates inicials i finals per filtrar
5843  if (_dFechaIni != null)
5844  lcSql = lcSql + " and vencim >= " + DB.SQLString(_dFechaIni);
5845 
5846  if (_dFechaFin != null)
5847  lcSql = lcSql + " and vencim <= " + DB.SQLString(_dFechaFin);
5848 
5849  //si hi ha periode filtrem per aquest
5850  if (_Ejercicio != 0)
5851  lcSql = lcSql + " and periodo =" + DB.SQLString(_Ejercicio);
5852 
5853  //si hi ha factura ho filtrem
5854  if (!string.IsNullOrWhiteSpace(_Factura))
5855  lcSql = lcSql + " and factura =" + DB.SQLString(_Factura);
5856 
5857  //si hi ha client ho filtrem
5858  if (!string.IsNullOrWhiteSpace(_Cliente))
5859  lcSql = lcSql + " and cliente =" + DB.SQLString(_Cliente);
5860 
5861  if (!String.IsNullOrEmpty(_Divisa)) lcSql = lcSql + String.Format(" AND DIVISA = '{0}' ", _Divisa);
5862 
5863 
5864  switch (tcEstadoPrevision)
5865  {
5866  case EstadoPrevisiones.Cobradas:
5867  // si tenim bancs inicials i finals per filtrar
5868  if (!string.IsNullOrWhiteSpace(_cBancoIni + _cBancoFin))
5869  {
5870  lcSql = lcSql + " and banco >= " + DB.SQLString(_cBancoIni) + " and banco <=" + DB.SQLString(_cBancoFin);
5871  }
5872 
5873  lcSql = lcSql + " and (remesa!=0 or refundir!='' or asiento=1 or pagare!='') ";
5874  break;
5875 
5876  case EstadoPrevisiones.Pendientes:
5877  // si tenim bancs inicials i finals per filtrar
5878  if (!string.IsNullOrWhiteSpace(_cBancoIni + _cBancoFin))
5879  {
5880  lcSql = lcSql + " and banco_prev >= " + DB.SQLString(_cBancoIni) + " and banco_prev <=" + DB.SQLString(_cBancoFin);
5881  }
5882 
5883  lcSql = lcSql + " and asiento=0 and impagado=0 and banco='' and remesa=0 and pagare='' ";
5884  break;
5885 
5886  case EstadoPrevisiones.Impagadas:
5887 
5888  lcSql = lcSql + " and impago='S' and impagado!=0 ";
5889  break;
5890 
5891  case EstadoPrevisiones.Todas:
5892  // si tenim bancs inicials i finals per filtrar
5893  if (!string.IsNullOrWhiteSpace(_cBancoIni + _cBancoFin))
5894  {
5895  lcSql = lcSql + " and ((banco_prev >= " + DB.SQLString(_cBancoIni) + " and banco_prev <=" + DB.SQLString(_cBancoFin) + ") or (banco >= " + DB.SQLString(_cBancoIni) + " and banco <=" + DB.SQLString(_cBancoFin) + ")) ";
5896  }
5897 
5898  break;
5899  }
5900 
5901  //T111293
5902 
5903  lcSql = lcSql + " order by factura,orden,vencim ";
5904 
5905  llOk = DB.SQLExec(lcSql, ref tdtPrevisiones);
5906  llOk = llOk && (tdtPrevisiones.Rows.Count > 0);
5907 
5908  return llOk;
5909  }
5910 
5911 
5916  private bool Contabilizar_Duplicar_Prevision(Decimal tnImporteEntrega)
5917  {
5918  bool llOk = false;
5919  PrevisionCobro loPrevisionNueva = null; // PARTE 92883
5920  decimal lnOldImporte = 0; // PARTE 97720. Me interesa el valos anterior por si trabaja con RECC
5921  decimal lnNewImporte = 0;
5922 
5923  if (this._Divisa == EW_GLOBAL._Moneda._Codigo)
5924  {
5925  lnOldImporte = this._Importe; // PARTE 97720. Me interesa el valos anterior por si trabaja con RECC
5926  lnNewImporte = this._Importe;
5927  }
5928  else
5929  {
5930  lnOldImporte = this._ImporteDiv;
5931  lnNewImporte = this._ImporteDiv;
5932  }
5933 
5934  // Actualizar previsión, si el importe cobrado es inferior al importe de la previsión habrá que dividir la previsión en dos dando por cobrada la primera
5935  // y dejando la segunda pendiente.
5936  if (Math.Abs(tnImporteEntrega) < Math.Abs(lnNewImporte))
5937  {
5938  // Importe cobrado inferior al de la previsión, hay que duplicar la prevision y dejar en la nueva previsión la parte pendiente y dejar cargada en el objeto
5939  // la prevision que queda totalmente cobrada.
5940  decimal lnImportePendiente = Math.Abs(lnNewImporte) - Math.Abs(tnImporteEntrega); //T115472 Cambiamos _Importe
5941  if (tnImporteEntrega < 0 & lnNewImporte < 0)
5942  lnImportePendiente = lnImportePendiente * (-1);
5943 
5944  decimal lnImportePendienteEuro = 0;
5945  // En la previsión que tengo cargada en el objeto pongo en los campos de importe la cantidad que me estan entregando.
5946  if (this._Divisa == EW_GLOBAL._Moneda._Codigo)
5947  {
5948  this._Importe = tnImporteEntrega;
5949  this._ImporteDiv = tnImporteEntrega;
5950  }
5951  else
5952  {
5953  // this._Importe = tnImporteEntrega * this._Cambio;
5954  // this._Importe = FUNCTIONS._Round(tnImporteEntrega * this._Cambio, this._loDivMonedaEmpresa._MascaraImporte._Num_Decimales);
5955  this._ImporteDiv = tnImporteEntrega;
5956  // lnImportePendienteEuro = lnImportePendiente * this._Cambio;
5957  lnImportePendienteEuro = FUNCTIONS._Round(lnImportePendiente * this._Cambio, this._loDivMonedaEmpresa._MascaraImporte._Num_Decimales);
5958  }
5959 
5960  // PARTE 92883. Vaciamos los campos
5961  //loPrevisionNueva._Asi = "";
5962  //loPrevisionNueva._Asiento = false;
5963  //loPrevisionNueva._Fecha_Cobro = null;
5964  // FPARTE 9288
5965 
5966  // loPrevisionNueva._Banco = ""; // PE-85895
5967  // loPrevisionNueva._Pendiente = this._Pendiente + 1; // PARTE 92883: La nueva previsión se tiene de quedar con el mismo pendiente original
5968  // loPrevisionNueva._Importe = lnImportePendiente;
5969  // loPrevisionNueva._ImporteDiv = lnImportePendiente;
5970 
5971  // En la previsión que tengo cargada en el objeto pongo en los campos de importe la cantidad que me estan entregando.
5972  //this._Importe = tnImporteEntrega;
5973  //this._ImporteDiv = tnImporteEntrega;
5974 
5975  // Nos guardamos el pendiente para la nueva previsión
5976  int lnPendiente = this._Pendiente;
5977 
5978  this._Pendiente = this.Buscar_Pendiente(); // PARTE 92883. Buscamos el pendiente de la previsión cobrada
5979 
5980  // PARTE 92883
5981  _lCobroParcial = true; // Indicamos que es un cobro parcial
5982  llOk = this._Save();
5983  // _lCobroParcial = false;
5984 
5985  int lnOrdenLast = 0;
5986  if (_lCobroParcial)
5987  {
5988  // Bug 180515:Cobro/Pago parcial de previsiones: al realizar un cobro/parcial, no genera previsión por la diferencia si ya existe una previsión con misma factura y orden.
5989  List<PrevisionCobro> lstPrevTemp = this._Lista_Previsiones();
5990  lnOrdenLast = lstPrevTemp.Where(x => x._Orden >= _Orden).Select(x => x._Orden).Last();
5991  }
5992 
5993 
5994  // TODO
5995  // Creo la nueva previsión a partir de la actual, incremento el campo PENDIENTE, y pongo en el importe de la previsión la parte que resta por entregar.
5996  loPrevisionNueva = new PrevisionCobro(); // PARTE 92883
5997 
5998  if (_Divisa == EW_GLOBAL._Moneda._Codigo)
5999  {
6000  // Cuando cree la nueva previsión no es necesario guardarla ya realizará el INSERT
6001  loPrevisionNueva._New(_Cliente, _Empresa, _Factura,
6002  (_lCobroParcial ? lnOrdenLast + 1 : Convert.ToInt32(this._Numereb)), _Impagado, lnPendiente,
6003  lnImportePendiente, Convert.ToDateTime(_Fecha_Emision),
6004  Convert.ToDateTime(_Fecha_Vencim),
6005  _Divisa, _Num_Banco,
6006  _Referencia, _SIIFraMod,
6007  (_Fecha_Operacion == null ? _Fecha_Operacion : Convert.ToDateTime(_Fecha_Operacion)),
6008  _Vendedor, _Forma_Pago,
6009  _Mandato, _Recc, _Ejercicio, _Cobrador, _Cambio, lnImportePendiente,
6010  _Impreso, _Impago, _Concepto);
6011  }
6012  else
6013  {
6014  loPrevisionNueva._New(_Cliente, _Empresa, _Factura,
6015  (_lCobroParcial ? lnOrdenLast + 1 : Convert.ToInt32(this._Numereb)), _Impagado, lnPendiente,
6016  lnImportePendienteEuro, Convert.ToDateTime(_Fecha_Emision),
6017  Convert.ToDateTime(_Fecha_Vencim),
6018  _Divisa, _Num_Banco,
6019  _Referencia, _SIIFraMod,
6020  (_Fecha_Operacion == null ? _Fecha_Operacion : Convert.ToDateTime(_Fecha_Operacion)),
6021  _Vendedor, _Forma_Pago,
6022  _Mandato, _Recc, _Ejercicio, _Cobrador, _Cambio, lnImportePendiente,
6023  _Impreso, _Impago, _Concepto);
6024  }
6025  _lCobroParcial = false;
6026  }
6027  else
6028  {
6029  // PARTE 92883
6030  llOk = this._Save();
6031  }
6032 
6034  //if (loPrevisionNueva != null)
6035  // loPrevisionNueva._Save();
6036 
6037 
6038 
6039  return llOk;
6040  // FPARTE 92883
6041  }
6042 
6043 
6050  private bool Contabilizar_Comprobacion(DateTime tdFecha, decimal tnImporteEntrega)
6051  {
6052  DateTime ldFechaIniPeriodo = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodoini"));
6053  DateTime ldFechaFinPeriodo = Convert.ToDateTime(EW_GLOBAL._GetVariable("wd_periodofin"));
6054 
6055  // Fecha fuera de ejercicio ...
6056  if (tdFecha < ldFechaIniPeriodo || tdFecha > ldFechaFinPeriodo)
6057  {
6058  if (this.Gestionar_Pregunta("Fecha de cobro de la previsión (asiento de cobro) no está dentro del margen de fechas del ejercicio vigente." +
6059  Environment.NewLine + Environment.NewLine + "¿ Desea continuar con el cobro ?") == DialogResult.Cancel) // PE-86227
6060  return false;
6061  }
6062 
6063  // No tenemos cargado objeto de prevision de cobro, no podemos contabilizar nada.
6064  if (string.IsNullOrWhiteSpace(this._Factura) || string.IsNullOrWhiteSpace(this._Empresa))
6065  {
6066  this.Gestionar_Mensaje("El objeto PrevisionCobro no está cargado con datos.", "_Contabilizar");
6067  return false;
6068  }
6069 
6070 
6071  decimal lnImportePrevision = this._llDivisaVentas && !string.IsNullOrWhiteSpace(this._Divisa) && this._Divisa != this._lcMonedaEmpresa ? this._ImporteDiv : this._Importe;
6072 
6073  // El importe que se contabiliza no puede ser superior al importe de la previsión ...
6074  if (Math.Abs(tnImporteEntrega) > Math.Abs(lnImportePrevision))
6075  {
6076  this.Gestionar_Mensaje("El importe que se cobra (" + tnImporteEntrega.ToString().Trim() + ") no puede superar el importe de la previsión " +
6077  "(" + lnImportePrevision.ToString().Trim() + ")", "_Contabilizar");
6078  return false;
6079  }
6080  else
6081  {
6082  decimal tnImporteDif = Math.Abs(lnImportePrevision) - Math.Abs(tnImporteEntrega);
6083  decimal lnImpPrevision = Math.Abs(lnImportePrevision);
6084  decimal lnImpEntrega = Math.Abs(tnImporteEntrega);
6085  if (tnImporteDif > 0 && tnImporteDif < 1)
6086  {
6087  ewMascara loMascaraPrev = new ewMascara();
6088  Divisa loDivisaPrev = new Divisa(this._Divisa);
6089  loMascaraPrev = loDivisaPrev._MascaraImporte;
6090  int loDecimalesPrev = loDivisaPrev._Decimales;
6091 
6092  // sacamos importe de la previsión con número decimales de la moneda de la previsión
6093  string lcDifImpPrevision = Convert.ToString(lnImportePrevision);
6094  int nPos = 0;
6095  nPos = lcDifImpPrevision.IndexOf(",");
6096 
6097  lcDifImpPrevision = lcDifImpPrevision.Substring(0, (nPos + 1 + loDecimalesPrev));
6098 
6099 
6100  // sacamos importe de la entrega con número decimales de la moneda de la previsión
6101  string lcDifImpEntrega = Convert.ToString(tnImporteEntrega);
6102 
6103  int nPosE = 0;
6104  nPosE = lcDifImpEntrega.IndexOf(",");
6105 
6106  lcDifImpEntrega = lcDifImpEntrega.Substring(0, (nPos + 1 + loDecimalesPrev));
6107 
6108 
6109  if (lcDifImpPrevision == lcDifImpEntrega)
6110  {
6111  this.Gestionar_Mensaje("El importe que se cobra (" + tnImporteEntrega.ToString().Trim() + ") no puede ser diferente al importe de la previsión " +
6112  "(" + lnImportePrevision.ToString().Trim() + ")", "_Contabilizar");
6113 
6114  return false;
6115  }
6116  }
6117  }
6118 
6119  // Comprobar si la previsión ya está contabilizada ...
6120  if (!string.IsNullOrWhiteSpace(this._Asi))
6121  {
6122  this.Gestionar_Mensaje("La previsión de cobro " + this._Factura.Trim() + "/" + this._Orden.ToString().Trim() + " ya se encuentra contabilizada.", "_Contabilizar");
6123  return false;
6124  }
6125 
6126  return true;
6127  }
6128 
6129 
6136  private bool _Insertar_Trazabilidad_Impagos(string tcGuid_id, string tcTipo)
6137  {
6138  string lcSql = string.Empty;
6139 
6140  lcSql = " Insert into " + DB.SQLDatabase("COMUNES", "IMPAGOS") + " (GUID_IDORI, GUID_IDDES, TIPO) " +
6141  " VALUES (" + DB.SQLString(_Guid_Id) + "," + DB.SQLString(tcGuid_id) + "," + DB.SQLString(tcTipo) + ")";
6142 
6143  return DB.SQLExec(lcSql);
6144  }
6145 
6146 
6153  private bool _Eliminar_Trazabilidad_Impagos(string tcGuid_iddes, string tcGuid_idori = "")
6154  {
6155  string lcSql = string.Empty;
6156 
6157  lcSql = " Delete From " + DB.SQLDatabase("COMUNES", "IMPAGOS") +
6158  " Where GUID_IDDES = " + DB.SQLString(tcGuid_iddes);
6159 
6160  if (!string.IsNullOrWhiteSpace(tcGuid_idori))
6161  lcSql += " And GUID_IDORI = " + DB.SQLString(tcGuid_idori);
6162 
6163  return DB.SQLExec(lcSql);
6164  }
6165 
6166 
6167  #region MÉTODOS EXTENSIONES
6168 
6169 
6177  protected internal bool _Addons_Dividir(TipoExecute teBeforeAfter, List<int> tlisDias)
6178  {
6179  _ExtensionPrevisionCobro loExtension = null;
6180 
6181  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6182  foreach (KeyValuePair<string, object> loItem in this._Addons)
6183  {
6184  try
6185  {
6186  if (loItem.Value is _ExtensionPrevisionCobro)
6187  {
6188  // Obtenemos el objeto de extensiones y lo configuramos
6189  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6190  loExtension._eBeforeAfter = teBeforeAfter;
6191  loExtension._Dividir(tlisDias);
6192  }
6193  }
6194  catch (Exception loEx)
6195  {
6196  DB.Registrar_Error(loEx);
6197  this._Addons_Messagebox(loItem.Key, "Dividir", loEx.Message);
6198  }
6199  }
6200 
6201  return true;
6202  }
6203 
6204 
6213  protected internal bool _Addons_Dividir(TipoExecute teBeforeAfter, DataTable tdtVencimientos)
6214  {
6215  _ExtensionPrevisionCobro loExtension = null;
6216 
6217  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6218  foreach (KeyValuePair<string, object> loItem in this._Addons)
6219  {
6220  try
6221  {
6222  if (loItem.Value is _ExtensionPrevisionCobro)
6223  {
6224  // Obtenemos el objeto de extensiones y lo configuramos
6225  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6226  loExtension._eBeforeAfter = teBeforeAfter;
6227  loExtension._Dividir(tdtVencimientos);
6228  }
6229  }
6230  catch (Exception loEx)
6231  {
6232  DB.Registrar_Error(loEx);
6233  this._Addons_Messagebox(loItem.Key, "Dividir", loEx.Message);
6234  }
6235  }
6236 
6237  return true;
6238  }
6239 
6240 
6246  protected internal bool _Addons_Desasentar(TipoExecute teBeforeAfter)
6247  {
6248  _ExtensionPrevisionCobro loExtension = null;
6249 
6250  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6251  foreach (KeyValuePair<string, object> loItem in this._Addons)
6252  {
6253  try
6254  {
6255  // Obtenemos el objeto de extensiones y lo configuramos
6256  if (loItem.Value is _ExtensionPrevisionCobro)
6257  {
6258  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6259  loExtension._eBeforeAfter = teBeforeAfter;
6260  loExtension._Desasentar();
6261  }
6262  }
6263  catch (Exception loEx)
6264  {
6265  DB.Registrar_Error(loEx);
6266  this._Addons_Messagebox(loItem.Key, "Desasentar", loEx.Message);
6267  }
6268  }
6269 
6270  return true;
6271  }
6272 
6273 
6282  protected internal bool _Addons_Descontabilizar(TipoExecute teBeforeAfter, bool tlForzarDesmarcarPrevision)
6283  {
6284  _ExtensionPrevisionCobro loExtension = null;
6285 
6286  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6287  foreach (KeyValuePair<string, object> loItem in this._Addons)
6288  {
6289  try
6290  {
6291  if (loItem.Value is _ExtensionPrevisionCobro)
6292  {
6293  // Obtenemos el objeto de extensiones y lo configuramos
6294  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6295  loExtension._eBeforeAfter = teBeforeAfter;
6296  loExtension._Descontabilizar(tlForzarDesmarcarPrevision);
6297  }
6298  }
6299  catch (Exception loEx)
6300  {
6301  DB.Registrar_Error(loEx);
6302  this._Addons_Messagebox(loItem.Key, "Descontabilizar", loEx.Message);
6303  }
6304  }
6305 
6306  return true;
6307  }
6308 
6309 
6320  protected internal bool _Addons_Contabilizar(TipoExecute teBeforeAfter, Dictionary<string, decimal> tdicCobros, DateTime tdFecha, decimal tnCambio, Asientos toAsiento)
6321  {
6322  _ExtensionPrevisionCobro loExtension = null;
6323 
6324  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6325  foreach (KeyValuePair<string, object> loItem in this._Addons)
6326  {
6327  try
6328  {
6329  if (loItem.Value is _ExtensionPrevisionCobro)
6330  {
6331  // Obtenemos el objeto de extensiones y lo configuramos
6332  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6333  loExtension._eBeforeAfter = teBeforeAfter;
6334  loExtension._Contabilizar(tdicCobros, tdFecha, tnCambio, toAsiento);
6335  }
6336  }
6337  catch (Exception loEx)
6338  {
6339  DB.Registrar_Error(loEx);
6340  this._Addons_Messagebox(loItem.Key, "Contabilizar", loEx.Message);
6341  }
6342  }
6343 
6344  return true;
6345  }
6346 
6347 
6358  protected internal bool _Addons_Contabilizar(TipoExecute teBeforeAfter, Dictionary<string, Tuple<decimal, List<Tuple<decimal, string, string>>>> tdicCobros, DateTime tdFecha, decimal tnCambio, Asientos toAsiento)
6359  {
6360  _ExtensionPrevisionCobro loExtension = null;
6361 
6362  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6363  foreach (KeyValuePair<string, object> loItem in this._Addons)
6364  {
6365  try
6366  {
6367  if (loItem.Value is _ExtensionPrevisionCobro)
6368  {
6369  // Obtenemos el objeto de extensiones y lo configuramos
6370  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6371  loExtension._eBeforeAfter = teBeforeAfter;
6372  loExtension._Contabilizar(tdicCobros, tdFecha, tnCambio, toAsiento);
6373  }
6374  }
6375  catch (Exception loEx)
6376  {
6377  DB.Registrar_Error(loEx);
6378  this._Addons_Messagebox(loItem.Key, "Contabilizar", loEx.Message);
6379  }
6380  }
6381 
6382  return true;
6383  }
6384 
6385 
6395  protected internal bool _Addons_Contabilizar(TipoExecute teBeforeAfter, string tcBanco, DateTime tdFecha, decimal tnImporteEntrega, Asientos toAsiento)
6396  {
6397  _ExtensionPrevisionCobro loExtension = null;
6398 
6399  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6400  foreach (KeyValuePair<string, object> loItem in this._Addons)
6401  {
6402  try
6403  {
6404  if (loItem.Value is _ExtensionPrevisionCobro)
6405  {
6406  // Obtenemos el objeto de extensiones y lo configuramos
6407  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6408  loExtension._eBeforeAfter = teBeforeAfter;
6409  loExtension._Contabilizar(tcBanco, tdFecha, tnImporteEntrega, toAsiento);
6410  }
6411  }
6412  catch (Exception loEx)
6413  {
6414  DB.Registrar_Error(loEx);
6415  this._Addons_Messagebox(loItem.Key, "Contabilizar", loEx.Message);
6416  }
6417  }
6418 
6419  return true;
6420  }
6421 
6422 
6435  protected internal bool _Addons_Contabilizar(TipoExecute teBeforeAfter, string tcBanco, DateTime tdFecha, decimal tnImporteEntrega, decimal tnCambio, Asientos toAsiento, bool tlGroup)
6436  {
6437  _ExtensionPrevisionCobro loExtension = null;
6438 
6439  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6440  foreach (KeyValuePair<string, object> loItem in this._Addons)
6441  {
6442  try
6443  {
6444  if (loItem.Value is _ExtensionPrevisionCobro)
6445  {
6446  // Obtenemos el objeto de extensiones y lo configuramos
6447  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6448  loExtension._eBeforeAfter = teBeforeAfter;
6449  loExtension._Contabilizar(tcBanco, tdFecha, tnImporteEntrega, tnCambio, toAsiento, tlGroup);
6450  }
6451  }
6452  catch (Exception loEx)
6453  {
6454  DB.Registrar_Error(loEx);
6455  this._Addons_Messagebox(loItem.Key, "Contabilizar", loEx.Message);
6456  }
6457  }
6458 
6459  return true;
6460  }
6461 
6462 
6473  protected internal bool _Addons_Contabilizar(TipoExecute teBeforeAfter, string tcBanco, DateTime tdFecha, decimal tnImporteEntrega, string tcAsi)
6474  {
6475  _ExtensionPrevisionCobro loExtension = null;
6476 
6477  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6478  foreach (KeyValuePair<string, object> loItem in this._Addons)
6479  {
6480  try
6481  {
6482  if (loItem.Value is _ExtensionPrevisionCobro)
6483  {
6484  // Obtenemos el objeto de extensiones y lo configuramos
6485  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6486  loExtension._eBeforeAfter = teBeforeAfter;
6487  loExtension._Contabilizar(tcBanco, tdFecha, tnImporteEntrega, tcAsi);
6488  }
6489  }
6490  catch (Exception loEx)
6491  {
6492  DB.Registrar_Error(loEx);
6493  this._Addons_Messagebox(loItem.Key, "Contabilizar", loEx.Message);
6494  }
6495  }
6496 
6497  return true;
6498  }
6499 
6500 
6515  protected internal bool _Addons_Clonar(TipoExecute teBeforeAfter, PrevisionCobro toPrevision, string tcEmpresa, int tnEjercicio, string tcFactura, int tnOrden, int tnImpagado, int tnPendiente)
6516  {
6517  _ExtensionPrevisionCobro loExtension = null;
6518 
6519  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6520  foreach (KeyValuePair<string, object> loItem in this._Addons)
6521  {
6522  try
6523  {
6524  if (loItem.Value is _ExtensionPrevisionCobro)
6525  {
6526  // Obtenemos el objeto de extensiones y lo configuramos
6527  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6528  loExtension._eBeforeAfter = teBeforeAfter;
6529  loExtension._Clonar(toPrevision, tcEmpresa, tnEjercicio, tcFactura, tnOrden, tnImpagado, tnPendiente);
6530  }
6531  }
6532  catch (Exception loEx)
6533  {
6534  DB.Registrar_Error(loEx);
6535  this._Addons_Messagebox(loItem.Key, "Clonar", loEx.Message);
6536  }
6537  }
6538 
6539  return true;
6540  }
6541 
6542 
6572  protected internal bool _Addons_New(TipoExecute teBeforeAfter, string tcCliente, string tcEmpresa, string tcFactura, int tnOrden, int tnImpagado, int tnPendiente, decimal tnImporte, DateTime tdEmision,
6573  DateTime tdVencim, string tcMoneda, int tnNum_Banco, DateTime? tdFecha_Oper, string tcVendedor, string tcFpago,
6574  string tcMandato, bool tlRecc, int tnPeriodo, string tcCobrador, decimal tnCambio, decimal tnImporteDiv,
6575  string tcImpreso, string tcImpago, string tcConcepto)
6576  {
6577  _ExtensionPrevisionCobro loExtension = null;
6578 
6579  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6580  foreach (KeyValuePair<string, object> loItem in this._Addons)
6581  {
6582  try
6583  {
6584  if (loItem.Value is _ExtensionPrevisionCobro)
6585  {
6586  // Obtenemos el objeto de extensiones y lo configuramos
6587  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6588  loExtension._eBeforeAfter = teBeforeAfter;
6589  loExtension._New(tcCliente, tcEmpresa, tcFactura, tnOrden, tnImpagado, tnPendiente, tnImporte, tdEmision,
6590  tdVencim, tcMoneda, tnNum_Banco, tdFecha_Oper, tcVendedor, tcFpago,
6591  tcMandato, tlRecc, tnPeriodo, tcCobrador = "", tnCambio, tnImporteDiv,
6592  tcImpreso, tcImpago, tcConcepto);
6593  }
6594  }
6595  catch (Exception loEx)
6596  {
6597  DB.Registrar_Error(loEx);
6598  this._Addons_Messagebox(loItem.Key, "New", loEx.Message);
6599  }
6600  }
6601 
6602  return true;
6603  }
6604 
6605 
6611  protected internal bool _Addons_Permite_Delete_Prevision(TipoExecute teBeforeAfter)
6612  {
6613  _ExtensionPrevisionCobro loExtension = null;
6614 
6615  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6616  foreach (KeyValuePair<string, object> loItem in this._Addons)
6617  {
6618  try
6619  {
6620  if (loItem.Value is _ExtensionPrevisionCobro)
6621  {
6622  // Obtenemos el objeto de extensiones y lo configuramos
6623  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6624  loExtension._eBeforeAfter = teBeforeAfter;
6625  loExtension._Permite_Delete_Prevision();
6626  }
6627  }
6628  catch (Exception loEx)
6629  {
6630  DB.Registrar_Error(loEx);
6631  this._Addons_Messagebox(loItem.Key, "Permite_Delete_Prevision", loEx.Message);
6632  }
6633  }
6634 
6635  return true;
6636  }
6637 
6638 
6644  protected internal bool _Addons_Perdonar(TipoExecute teBeforeAfter)
6645  {
6646  _ExtensionPrevisionCobro loExtension = null;
6647 
6648  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6649  foreach (KeyValuePair<string, object> loItem in this._Addons)
6650  {
6651  try
6652  {
6653  if (loItem.Value is _ExtensionPrevisionCobro)
6654  {
6655  // Obtenemos el objeto de extensiones y lo configuramos
6656  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6657  loExtension._eBeforeAfter = teBeforeAfter;
6658  loExtension._Perdonar();
6659  }
6660  }
6661  catch (Exception loEx)
6662  {
6663  DB.Registrar_Error(loEx);
6664  this._Addons_Messagebox(loItem.Key, "Perdonar", loEx.Message);
6665  }
6666  }
6667 
6668  return true;
6669  }
6670 
6671 
6679  protected internal bool _Addons_Impagar(TipoExecute teBeforeAfter, DateTime tdFechaAsientoImpago)
6680  {
6681  _ExtensionPrevisionCobro loExtension = null;
6682 
6683  // Recorrido por los addons disponibles, para ejecutar el método deseado en las extensiones
6684  foreach (KeyValuePair<string, object> loItem in this._Addons)
6685  {
6686  try
6687  {
6688  if (loItem.Value is _ExtensionPrevisionCobro)
6689  {
6690  // Obtenemos el objeto de extensiones y lo configuramos
6691  loExtension = (_ExtensionPrevisionCobro)loItem.Value;
6692  loExtension._eBeforeAfter = teBeforeAfter;
6693  loExtension._Impagar(tdFechaAsientoImpago);
6694  }
6695  }
6696  catch (Exception loEx)
6697  {
6698  DB.Registrar_Error(loEx);
6699  this._Addons_Messagebox(loItem.Key, "Impagar", loEx.Message);
6700  }
6701  }
6702 
6703  return true;
6704  }
6705 
6706 
6707  #endregion MÉTODOS EXTENSIONES
6708 
6709 
6710  #endregion METODOS PRIVADOS
6711  }
6712 
6713 
6718  {
6719  #region PROPIEDADES PRIVADAS
6720 
6721 
6722  private Recibo _oRecibo = null;
6723 
6724 
6725  #endregion PROPIEDADES PRIVADAS
6726 
6727 
6728  #region PROPIEDADES PUBLIC
6729 
6730 
6734  public Recibo _Recibo
6735  {
6736  get
6737  {
6738  if (!(_oRecibo is Recibo))
6739  {
6740  PrevisionCobro loPrevision = (PrevisionCobro)_Documento;
6741  DocPrintPrevisionCobro loDocPrint = (DocPrintPrevisionCobro)loPrevision._DocPrint;
6742  Cliente loCliente = new Cliente(loPrevision._Cliente);
6743  String lcDatosCliente = "";
6744  Dictionary<string, object> loDir = null;
6745 
6746 
6747  switch (_TipoRecibo)
6748  {
6749  case TipoRecibo.LetraCanvio:
6750 
6751  _oRecibo = new ReciboLetraCnv();
6752  _oRecibo._Nombre = String.Format("{0}/{1}", loPrevision._Factura, loPrevision._Orden);
6753  break;
6754 
6755  case TipoRecibo.ReciboEspecial:
6756 
6757  _oRecibo = new ReciboEspecial();
6758  break;
6759 
6760  case TipoRecibo.Cuota:
6761 
6762  _oRecibo = new ReciboCuota();
6763  _oRecibo._Recibo = String.Format("{0}/{1}", loPrevision._Factura, loPrevision._Orden);
6764  ((ReciboCuota)_oRecibo)._Factura = loPrevision._Factura;
6765  break;
6766 
6767  default:
6768  _oRecibo = new Recibo();
6769  _oRecibo._Recibo = String.Format("{0}/{1}", loPrevision._Factura, loPrevision._Orden);
6770  break;
6771  }
6772  _oRecibo._Cliente = loPrevision._Cliente;
6773  _oRecibo._ClienteERP = loPrevision._ClienteERP;
6774  _oRecibo._Divisa = loPrevision._Divisa;
6775  _oRecibo._Importe = loPrevision._ImporteDiv;
6776  _oRecibo._Fecha_Expedicion = (DateTime)loPrevision._Fecha_Emision;
6777  _oRecibo._Fecha_Vencimiento = (DateTime)loPrevision._Fecha_Vencim;
6778  _oRecibo._Concepto = String.IsNullOrEmpty(loPrevision._Concepto) ? String.Format("Recibo factura {0}", loPrevision._Factura) : loPrevision._Concepto;
6779  _oRecibo._Lugar = _Empresa._Poblacion;
6780 
6781  if (!String.IsNullOrEmpty(loPrevision._Cliente))
6782  {
6783  loDir = loCliente._Direccion_Predeterminada();
6784  if (loDir.Count() > 0)
6785  {
6786  lcDatosCliente += loCliente._Nombre + Environment.NewLine;
6787  lcDatosCliente += String.IsNullOrEmpty(loDir["direccion"].ToString().Trim()) ? String.Empty : loDir["direccion"].ToString().Trim() + Environment.NewLine;
6788  lcDatosCliente += String.IsNullOrEmpty(loDir["codpos"].ToString().Trim()) ? String.Empty : loDir["codpos"].ToString().Trim() + " " + loDir["poblacion"].ToString().Trim() + Environment.NewLine;
6789  lcDatosCliente += String.IsNullOrEmpty(loDir["provincia"].ToString().Trim()) ? String.Empty : loDir["provincia"].ToString().Trim() + Environment.NewLine;
6790  }
6791  }
6792  _oRecibo._DatosCliente = lcDatosCliente;
6793 
6794  if (loPrevision._Num_Banco != 99)
6795  {
6796  Dictionary<string, object> loDic = loCliente._Banco(Convert.ToString(loPrevision._Num_Banco));
6797 
6798  if (loDic.Count() > 0)
6799  {
6800  _oRecibo._Banco_Cuenta = functions.FUNCTIONS._Formatear_Cuenta_Bancaria(Convert.ToString(loDic["tipocta"]), Convert.ToString(loDic["iban"]), Convert.ToString(loDic["cuentaiban"]).Trim()); // Customer Change Request 126012:03/19- Al imprimir previsión no imprime el banco en formato IBAN
6801  _oRecibo._Banco_Domicilio = loDic["direccion"].ToString().Trim();
6802  _oRecibo._Banco_Entidad = loDic["banco"].ToString().Trim();
6803  _oRecibo._Banco_Poblacion = loDic["poblacion"].ToString().Trim();
6804  }
6805  }
6806  }
6807 
6808  return _oRecibo;
6809  }
6810  }
6811 
6812 
6813  #endregion PROPIEDADES PUBLIC
6814 
6815 
6816  #region CONSTRUCTOR
6817 
6818 
6822  public DocPrintPrevisionCobro(IDocumentoImprimible loDocumentoImprimible) : base(loDocumentoImprimible)
6823  {
6824  _Documento = loDocumentoImprimible;
6825  _TipoRecibo = TipoRecibo.Normal;
6826  _PresentarPantallaImpresion = true;
6827  }
6828 
6829 
6830  #endregion CONSTRUCTOR
6831 
6832 
6833  #region MÉTODOS PRIVADOS
6834 
6835 
6841  void EventoDocPrint_Exportacion_Finalizada(object sender, ewbase.DocPrint.ExportEventArgs e)
6842  {
6843  //Actualizo el path resultado por si Sage Reports lo ha modificado
6844  if (sender != null)
6845  _cPDF_File = e._Path;
6846  }
6847 
6848 
6849  #endregion MÉTODOS PRIVADOS
6850 
6851 
6852  #region PROPIEDADES PUBLIC OVERRIDE
6853 
6857  public bool _AllowEditMode { get; set; } = true;
6858 
6862  public override String _Printer
6863  {
6864  get
6865  {
6866  return ((DocPrint)_Recibo._DocPrint)._Printer;
6867  }
6868  set
6869  {
6870  ((DocPrint)_Recibo._DocPrint)._Printer = value;
6871  }
6872  }
6873 
6874 
6878  public override TipoRecibo _TipoRecibo
6879  {
6880  get
6881  {
6882  return base._TipoRecibo;
6883  }
6884  set
6885  {
6886  base._TipoRecibo = value;
6887  _oRecibo = null;
6888  }
6889  }
6890 
6891 
6895  public override UserControl _UserControlAdicional
6896  {
6897  get
6898  {
6899  if (_oUserControlAdicional == null)
6900  {
6901  _oUserControlAdicional = new UserControls.OpcionesImpresionRecibos();
6902  ((UserControls.OpcionesImpresionRecibos)_oUserControlAdicional)._Copias = _Numero_Copias;
6903 
6904  if (_Documento != null)
6905  {
6906  ((UserControls.OpcionesImpresionRecibos)_oUserControlAdicional)._Factura = String.Format("{0}_{1}", ((PrevisionCobro)_Documento)._Factura, ((PrevisionCobro)_Documento)._Orden);
6907  }
6908  }
6909 
6910  return _oUserControlAdicional;
6911  }
6912  set
6913  {
6914  _oUserControlAdicional = value;
6915  }
6916  }
6917 
6918 
6919  #endregion PROPIEDADES PUBLIC OVERRIDE
6920 
6921 
6922  #region MÉTODOS PUBLIC OVERRIDE
6923 
6924 
6929  public override bool _Print()
6930  {
6931  Boolean llOk = true;
6932  Recibo loRecibo = _Recibo;
6933  PrevisionCobro loPrevision = (PrevisionCobro)_Documento;
6934  DocPrintPrevisionCobro loDocPrint = (DocPrintPrevisionCobro)loPrevision._DocPrint;
6935  DocPrint loTmp;
6937 
6938  if (loDocPrint._ImpresionNormalMultiple == ImpresionNormalMultiple.Multiple && loDocPrint._Numero_Copias > 0)
6939  {
6940  loTmp = (DocPrint)loMulti;
6941  loMulti._Items.Add(loRecibo);
6942  }
6943  else
6944  {
6945  loTmp = (DocPrint)loRecibo._DocPrint;
6946  }
6947 
6948  loTmp._Vista_Preliminar = loDocPrint._Vista_Preliminar;
6949 
6950  if (loTmp._Vista_Preliminar)
6951  {
6952  loTmp._ImpresionVistaPreliminar += () => { ((IMarcaImpreso)_Documento)._Printed(); };
6953  }
6954 
6955  loTmp._Numero_Copias = loDocPrint._Numero_Copias;
6956  loTmp._Printer = loDocPrint._Printer;
6957  loTmp._Exportar = loDocPrint._Exportar;
6958  loTmp._EditMode = loDocPrint._EditMode;
6959  loTmp._FieldRandomBackColor = loDocPrint._FieldRandomBackColor;
6960  loTmp._Formato_exportacion = loDocPrint._Formato_exportacion;
6961  loTmp._Ruta_Fichero = loDocPrint._Ruta_Fichero;
6962 
6963  if (_PresentarPantallaImpresion)
6964  {
6965  loTmp._Evento_Exportacion_Finalizada -= new ewbase.DocPrint._Evento_Exportacion_Completada(EventoDocPrint_Exportacion_Finalizada);
6966  if (loTmp._Exportar) loTmp._Evento_Exportacion_Finalizada += new ewbase.DocPrint._Evento_Exportacion_Completada(EventoDocPrint_Exportacion_Finalizada);
6967  }
6968 
6969  loTmp._Print();
6970 
6971  _PresentarFichero();
6972 
6973  return llOk;
6974  }
6975 
6976 
6982  public override DocPrint _Clonar(DocPrint toDocPrint)
6983  {
6984 
6985  if (toDocPrint is DocPrintPrevisionCobro) ((DocPrintPrevisionCobro)toDocPrint)._TipoRecibo = _TipoRecibo;
6986 
6987  toDocPrint = base._Clonar(toDocPrint);
6988 
6989  return toDocPrint;
6990  }
6991 
6992 
6993  #endregion MÉTODOS PUBLIC OVERRIDE
6994  }
6995 
6996 
7001  {
7002  #region PROPIEDADES PRIVADAS
7003 
7004 
7005  private PrevisionCobro _oInstancia = null;
7006 
7007 
7008  #endregion PROPIEDADES PRIVADAS
7009 
7010 
7011  #region PROPIEDADES PUBLICAS
7012 
7013 
7017  public decimal _Cambio
7018  {
7019  get
7020  {
7021  return _oInstancia._ImpagoGastosBancariosCambio;
7022  }
7023  set
7024  {
7025  _oInstancia._ImpagoGastosBancariosCambio = value;
7026  }
7027  }
7028 
7029 
7033  public string _Divisa
7034  {
7035  get
7036  {
7037  return _oInstancia._ImpagoGastosBancariosDivisa;
7038  }
7039  set
7040  {
7041  bool llChanged = (_oInstancia._ImpagoGastosBancariosDivisa != value);
7042 
7043  _oInstancia._ImpagoGastosBancariosDivisa = value;
7044 
7045  if (_Cambio == 0 || llChanged)
7046  {
7047  obtenerCambio();
7048  }
7049 
7050  }
7051  }
7052 
7053 
7057  public DateTime _Fecha
7058  {
7059  get
7060  {
7061  return (DateTime)_oInstancia._ImpagoGastosBancariosFecha;
7062  }
7063  set
7064  {
7065  bool llChanged = (_oInstancia._ImpagoGastosBancariosFecha != value);
7066 
7067  if (value == DateTimePicker.MinimumDateTime)
7068  {
7069  _oInstancia._ImpagoGastosBancariosFecha = null;
7070  }
7071  else
7072  {
7073  _oInstancia._ImpagoGastosBancariosFecha = value;
7074  }
7075 
7076  if (llChanged)
7077  {
7078  obtenerCambio();
7079  }
7080  }
7081  }
7082 
7083 
7087  public Divisa _oDivisa
7088  {
7089  get
7090  {
7091  if (_oDivisaImpago == null)
7092  _oDivisaImpago = new Divisa(_Divisa);
7093  return _oDivisaImpago;
7094  }
7095  set
7096  {
7097  _oDivisaImpago = value;
7098  }
7099  }
7100  private Divisa _oDivisaImpago = null;
7101 
7102 
7103  #endregion PROPIEDADES PUBLICAS
7104 
7105 
7106  #region CONSTRUCTOR
7107 
7108 
7113  public PrevisionCobroImpago(PrevisionCobro toPrevisionCobro)
7114  {
7115  _oInstancia = toPrevisionCobro;
7116  }
7117 
7118 
7122  private PrevisionCobroImpago()
7123  {
7124 
7125  }
7126 
7127 
7128  #endregion CONSTRUCTOR
7129 
7130 
7131  #region MÉTODOS PRIVADOS
7132 
7133 
7137  private void obtenerCambio()
7138  {
7139  eTipoCambio leTipoCambio = eTipoCambio.Indeterminado;
7140 
7141  if (!string.IsNullOrWhiteSpace(_Divisa))
7142  {
7143  decimal lnCambio = _oInstancia._oCliente._CambioPactado(_Divisa, _Fecha, out leTipoCambio);
7144  _oInstancia._TipoCambio = leTipoCambio;
7145  _Cambio = lnCambio;
7146  }
7147  else
7148  {
7149  _Cambio = 1M;
7150  }
7151 
7152  }
7153 
7154 
7162  bool IDivisaOperable._PermitirCambioValor(object sender, string tcValorCandidato, out string tcMensaje)
7163  {
7164  tcMensaje = "";
7165  return true;
7166  }
7167 
7168 
7169  #endregion MÉTODOS PRIVADOS
7170  }
7171 }
7172 
Boolean _SaveHistoricoCambioCierre()
Guarda el registro para el historico de cierre
decimal _DebeDiv
Importe de la partida DEBE en divisa
Boolean _ShowEditMode
PE-103580 Indica si debemos ocultar la edición del report
DocPrint.eFormato_exportacion _FormatoExportacion
DEvuelve el tipo de exportación
string _Vendedor
Código de vendedor
void _New(string tcCliente, string tcEmpresa, string tcFactura, int tnOrden, int tnImpagado, int tnPendiente, decimal tnImporte, DateTime tdEmision, DateTime tdVencim, string tcMoneda, int tnNum_Banco, DateTime? tdFecha_Oper, string tcVendedor="", string tcFpago="", string tcMandato="", bool tlRecc=false, int tnPeriodo=0, string tcCobrador="", decimal tnCambio=1, decimal tnImporteDiv=0, string tcImpreso="N", string tcImpago="N", string tcConcepto="")
Crea una nueva previsión de cobro a partir de los parámetros indicados y la carga en el objeto...
bool _Delete(IAsientosLinea toIAsientosLinea)
Al borrar un asiento de traspaso de saldo RECC (tipo_mov 8 o 9) eliminamos el registro correspondient...
Clase de negocio para visualizar los giros.
Definition: LineaGiro.cs:12
DateTime _FechaCobro
data que s&#39;ha escollit
Definition: frmCobro.cs:32
string _Lugar
Lugar donde se entrega (por defecto será la población de la empresa)
Clase de negocio base para mantenimientos
Definition: clsEwBase.cs:1643
string _ImpagoRepercutirTipoIva
Tipo de IVA de la factura de gastos a repercutir al cliente
string _Cliente
Código de cliente
DateTime _Fecha_Expedicion
Fecha de expedición
string _Cliente
Cliente del recibo especial
string _Cobrador
Código de cobrador
int _TipoFactura
Tipo de factura: 0 normal, 1 rectificativa, 2 tickets
Clase para las previsiones de cobro
DocPrintPrevisionCobro(IDocumentoImprimible loDocumentoImprimible)
Constructor
DateTime _Fecha_Remesa
Fecha de remesa
static void LineasGirosPrcRepartoDeclaradosOk(List< LineaGiro > tlisGiros)
Al facturar ventas o compras, sea cual sea el origen, al generar previsiones, al principio del método...
bool _Perdonar()
Perdonar la previsión, marcar como cobrada
static bool _GenerarFacturaVenta(ParamGenFactVenta toCfgGenFactVenta)
Realiza proceso de generación de factura de venta a contabilidad (sin albaranes de venta de por medio...
virtual string _Nombre
Nombre
ImpresionNormalMultiple _ImpresionNormalMultiple
Indica el tipo de impresión
string _Mensaje_Error
Mensaje de error
bool ExistePrevision(string tcEmpresa, string tcFactura, int tcPeriodo, out int tnorden)
Consulta si existe alguna previsión de la factura y devuelve el primer orden que encuentra Se utiliza...
bool _Vista_Preliminar
Nos indicará si se realizará una vista preliminar del documento
Definition: IDocPrint.cs:33
string _Divisa
Moneda de la previsión
string _DatosCliente
Datos cliente
bool _Prevision
Indica si la linea está cargada con una previsión real
string _Banco_Poblacion
Población del banco
string _Banco_Entidad
Entidad del banco
string _Refundir
Nº de fact. refundida
static Asientos _AsientoDiferenciasCambio(List< IAsientosPrevisionesGeneradorLinea > toList)
Crea un asiento de las diferencias de cambio
Definition: