Inheritance: System.SystemException
        protected override IPaymentResult PerformProcessPayment(SalePreparationBase preparation, IPaymentMethod paymentMethod)
        {
            // We have to use the CheckoutConfirmationModel in this implementation.  If this were to be used
            // outside of a demo, you could consider writing your own base controller that inherits directly from
            // Merchello.Web.Mvc.PaymentMethodUiController<TModel> and complete the transaction there in which case the
            // BazaarPaymentMethodFormControllerBase would be a good example.

            var form = UmbracoContext.HttpContext.Request.Form;
            var DebitOrderNumber = form.Get("DebitOrderNumber");

            if (string.IsNullOrEmpty(DebitOrderNumber))
            {
                var invalidData = new InvalidDataException("The Purchase Order Number cannot be an empty string");
                return new PaymentResult(Attempt<IPayment>.Fail(invalidData), null, false);
            }

            // You need a ProcessorArgumentCollection for this transaction to store the payment method nonce
            // The braintree package includes an extension method off of the ProcessorArgumentCollection - SetPaymentMethodNonce([nonce]);
            var args = new ProcessorArgumentCollection();
            args.SetDebitOrderNumber(DebitOrderNumber);

            // We will want this to be an Authorize(paymentMethod.Key, args);
            // -- Also in a real world situation you would want to validate the PO number somehow.
            return preparation.AuthorizePayment(paymentMethod.Key, args);
        }
        public static void MessageConstructor()
        {
            string message = "MessageConstructor";
            InvalidDataException ide = new InvalidDataException(message);

            Assert.Equal(message, ide.Message);
        }
        protected override void ProcessRecord()
        {
            const string particular = @"Software\ParticularSoftware";

            ProviderInfo provider;
            PSDriveInfo drive;
            var psPath = SessionState.Path.GetUnresolvedProviderPathFromPSPath(LicenseFile, out provider, out drive);
            

            if (provider.ImplementingType != typeof(FileSystemProvider))
            {
                var ex = new ArgumentException(string.Format("{0} does not resolve to a path on the FileSystem provider.", psPath));
                var error = new ErrorRecord(ex, "InvalidProvider", ErrorCategory.InvalidArgument, psPath);
                WriteError(error);
                return;
            }

            var content = File.ReadAllText(psPath);
            if (!CheckFileContentIsALicenseFile(content))
            {
                var ex = new InvalidDataException(string.Format("{0} is not not a valid license file", psPath));
                var error = new ErrorRecord(ex, "InvalidLicense", ErrorCategory.InvalidData, psPath);
                WriteError(error);
                return;
            }

            if (EnvironmentHelper.Is64BitOperatingSystem)
            {
                RegistryHelper.LocalMachine(RegistryView.Registry64).WriteValue(particular, "License", content, RegistryValueKind.String);    
            }
            RegistryHelper.LocalMachine(RegistryView.Registry32).WriteValue(particular, "License", content, RegistryValueKind.String);
        }
Esempio n. 4
0
        public static void MessageConstructor()
        {
            string message           = "MessageConstructor";
            InvalidDataException ide = new InvalidDataException(message);

            Assert.Equal(message, ide.Message);
        }
        public static void MessageInnerExceptionConstructor()
        {
            string message = "MessageConstructor";
            Exception innerException = new Exception();
            InvalidDataException ide = new InvalidDataException(message, innerException);

            Assert.Equal(message, ide.Message);
            Assert.Same(innerException, ide.InnerException);
        }
Esempio n. 6
0
        public static void MessageInnerExceptionConstructor()
        {
            string               message        = "MessageConstructor";
            Exception            innerException = new Exception();
            InvalidDataException ide            = new InvalidDataException(message, innerException);

            Assert.Equal(message, ide.Message);
            Assert.Same(innerException, ide.InnerException);
        }
Esempio n. 7
0
        void IReplayService.SetReplayData(object replayData)
        {
            if (!(replayData is CapturedStorageData storageData) &&
                !CapturedStorageData.TryDeserialize(replayData, out storageData))
            {
                var inner = new System.IO.InvalidDataException($"Failed to deserialize data into `{nameof(CapturedSettingsData)}`.");
                throw new ArgumentException(inner.Message, nameof(replayData), inner);
            }

            SetReplayData(storageData);
        }
        public String RegistrarExcepcion(Exception excepcion, String origen)
        {
            string mensaje = "";

            try
            {
                if (excepcion is System.ApplicationException)
                {
                    System.ApplicationException exc = (System.ApplicationException)excepcion;
                    mensaje = EscribirApplicationException(exc, origen);
                }
                else if (excepcion is System.IO.InvalidDataException)
                {
                    System.IO.InvalidDataException exc = (System.IO.InvalidDataException)excepcion;
                    mensaje = EscribirInvalidDataException(exc, origen);
                }
                else if (excepcion is System.IO.IOException)
                {
                    System.IO.IOException exc = (System.IO.IOException)excepcion;
                    mensaje = EscribirIOEx(exc, origen);
                }
                else if (excepcion is System.FormatException)
                {
                    System.FormatException exc = excepcion as System.FormatException;
                    mensaje = EscribirFormatException(exc, origen);
                }
                else if (excepcion is System.Data.SqlClient.SqlException)
                {
                    System.Data.SqlClient.SqlException exc = excepcion as System.Data.SqlClient.SqlException;
                    mensaje = EscribirSqlEx(exc, origen);
                }
                else if (excepcion is System.Data.OleDb.OleDbException)
                {
                    System.Data.OleDb.OleDbException exc = excepcion as System.Data.OleDb.OleDbException;
                    mensaje = EscribirOleDbEx(exc, origen);
                }
                else
                {
                    mensaje = EscribirGenericEx(excepcion, origen);
                }
            }
            catch (Exception ex)
            {
                mensaje = "Error interno de la Aplicación. Por favor informar a Sopórte Técnico.\n\n";
                mensaje = mensaje + EscribirLocalEx(ex, this.ToString() + ".RegistrarExcepcion");
            }
            return(mensaje);
        }
Esempio n. 9
0
        /// <summary>
        /// This appends the content of one datarow to a dBase file.
        /// </summary>
        /// <param name="columnValues">A DataRow to append to the dBase file</param>
        /// <param name="Table">A DataTable that gives some column information</param>
        /// <exception cref="ArgumentNullException">The columnValues parameter was null</exception>
        /// <exception cref="InvalidOperationException">Header records need to be written first.</exception>
        /// <exception cref="InvalidDataException">Table property of columnValues parameter cannot be null.</exception>
		public void Write(System.Data.DataRow columnValues, System.Data.DataTable Table)
		{

			if (columnValues == null)
            {
                ArgumentNullException ex = new ArgumentNullException("The columnValues parameter was null");
                LogManager.DefaultLogManager.Exception(ex);
				throw ex;
            }
			if (!headerWritten)
            {
				InvalidOperationException ex = new InvalidOperationException("Header records need to be written first.");
                LogManager.DefaultLogManager.Exception(ex);
				throw ex;
            }
            if (columnValues.Table == null)
            {
                InvalidDataException ex = new InvalidDataException("Table property of columnValues parameter cannot be null.");
                LogManager.DefaultLogManager.Exception(ex);
				throw ex;
            }
                
			_writer.Write((byte)0x20); // the deleted flag

            for (int i = 0; i < _header.NumFields; i++)
            {
              
                object columnValue = columnValues[_header.Fields[i].Name];
                if (columnValue == null || columnValue is DBNull)
                    WriteSpaces(_header.Fields[i].Length);
                if (columnValue is double)
                    Write((double)columnValue, _header.Fields[i].Length, _header.Fields[i].DecimalCount);
                else if (columnValue is float)
                    Write((float)columnValue, _header.Fields[i].Length, _header.Fields[i].DecimalCount);
                else if (columnValue is bool)
                    Write((bool)columnValue);
                else if (columnValue is string)
                {
                    int length = _header.Fields[i].Length;
                    Write((string)columnValue, length);
                }
                else if (columnValue is DateTime)
                    Write((DateTime)columnValue);
            }
			
		}
Esempio n. 10
0
        public CompFormatEntryCollection Read(int? entryCount = null)
        {
            Contract.Requires(!entryCount.HasValue || entryCount.Value > 0);

            CompFormatEntryCollection result = new CompFormatEntryCollection();

            foreach (var line in ReadLines(entryCount))
            {
                Exception inner = null;
                string[] ioParts = line.Split(ioSeparators, StringSplitOptions.RemoveEmptyEntries);
                if (ioParts.Length == 2)
                {
                    string iPart = ioParts[0];
                    string oPart = ioParts[1];
                    if (!string.IsNullOrEmpty(iPart) && !string.IsNullOrEmpty(oPart))
                    {
                        var inputs = ParsePart(iPart, false, line).Select(v => v.Value).ToArray();
                        var outputs = ParsePart(oPart, false, line).ToArray();
                        try
                        {
                            result.Add(new CompFormatEntry(inputs, outputs));
                            continue;
                        }
                        catch (Exception ex)
                        {
                            inner = ex;
                        }
                    }
                }
                var dex = new InvalidDataException("Comp format error on: '" + line + "'.", inner);
                dex.Data["line"] = line;
                throw dex;
            }

            return result;
        }
Esempio n. 11
0
        public MovimentoContabile SetMovimentoBancarioGenerico(DatiBancariCondomini banca, Esercizio esercizioRiferimento, SottoConto sottoconto, decimal importo, string descrizione, DateTime dataRegistrazione, CausaleContabile causale)
        {
            try
            {
                var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione} non è valida");
                    _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex,  Utility.GetMethodDescription(), dataRegistrazione, esercizioRiferimento.ID);
                    throw ex;
                }

                var testata = new TestataMovimentoContabile(esercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null)
                {
                    Descrizione = descrizione,
                    IsAbilitataArchiviazioneOttica = false,
                    IsAllowUpdate = true
                };
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                // -------------------------------------------------
                // Segno Movimento
                // ------------------------------------------------
                string segnoContoEconomico = "D";
                if (importo > 0)
                    segnoContoEconomico = "A";
                else
                    importo = importo * -1;

                // ------------------------------------------------
                // Conto economico
                // ------------------------------------------------
                var movimentoContoEconomico = new MovimentoContabile(testata, causale, 1, sottoconto, importo, segnoContoEconomico) {Descrizione = descrizione};
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomico);
                _ripartizioneService.SalvaRipartizione(movimentoContoEconomico, esercizioRiferimento.CondominioRiferimento.ID);

                // ------------------------------------------------
                // BANCA
                // ------------------------------------------------
                var movimentoBancario = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetByCodice(esercizioRiferimento.ID, esercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(segnoContoEconomico))
                {
                    Descrizione = descrizione, 
                    Stato = StatoMovimentoContabileEnum.Evaso,
                    ContoCorrenteBancario = banca
                };
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);

                return movimentoBancario;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella contabilizzazione di un movimento bancario - {0} - importo:{1} - descrizione:{2} - data registrazione:{3:d}", ex, Utility.GetMethodDescription(), importo, descrizione, dataRegistrazione);
                throw;
            }
        }
Esempio n. 12
0
        public static void DefaultConstructor()
        {
            InvalidDataException ide = new InvalidDataException();

            Assert.NotNull(ide.Message);
        }
Esempio n. 13
0
        public void SetMovimentiPagamenti(Disposizione disposizione, string tipoConto, LogTransazione logTransazione)
        {
            try
            {
                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");
                var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(disposizione.Pagamenti.Count);

                foreach (var pag in disposizione.Pagamenti)
                {
                    try
                    {
                        var numeroRiga = 0;
                        var esercizioRiferimento = getEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, pag.Data.GetValueOrDefault());
                        if (esercizioRiferimento == null)
                        {
                            var ex = new InvalidDataException(string.Format("Non trovato nessun esercizio attivo"));
                            _log.FatalFormat("Non trovato nessun esercizio attivo - {0} - condominio:{1} - disposizione:{2} - tipoConto:{3}", ex, Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, disposizione.ID, tipoConto);
                            throw ex;
                        }

                        var message = IsAllowDataRegistrazione(new List<int> { esercizioRiferimento.CondominioRiferimento.ID }, esercizioRiferimento, pag.Data.GetValueOrDefault());
                        if (message.Count == 0)
                        {
                            // ================================================
                            // Testata
                            // ================================================
                            TestataMovimentoContabile testata;
                            if (lista.ContainsKey(esercizioRiferimento))
                                testata = lista[esercizioRiferimento];
                            else
                            {
                                testata = new TestataMovimentoContabile(esercizioRiferimento, pag.Data, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);
                                if(logTransazione == null)
                                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                                // Per ora ritengo opportuno avere una testata di movimento contabile distinta per ogni pagamento.
                                // Per avere un testata che accorpi diversi pagamenti è sufficiente scommentare la riga successiva.
                                //lista.Add(esercizioRiferimento, testata);
                            }

                            // ================================================
                            // Debiti VS Fornitori
                            // ------------------------------------------------
                            //  Se è già presente un movimento contabile legato alla ritenute
                            //  vuol dire che il pagamento stato annullato.
                            //  In questo caso il movimento di ritenuta non deve essere generato
                            // ================================================
                            numeroRiga++;
                            var importoFornitori = pag.Importo.GetValueOrDefault();
                            if (pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null)
                                importoFornitori += pag.RitenutaAcconto.Importo.GetValueOrDefault();
                            var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoFornitori, "D")
                            {
                                Descrizione = string.Format("Pagamento Fatt. n.{0} del {1:d}", pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento, pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault())
                            };
                            if(logTransazione == null)
                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                            // ================================================
                            // Ritenuta
                            // ================================================
                            decimal importoRitenuta = 0;
                            if (pag.ScadenzaRiferimento.SpesaRiferimento.Detrazione.GetValueOrDefault() == 0 && pag.RitenutaAcconto != null && pag.RitenutaAcconto.MovimentoContabileCreazione == null && pag.RitenutaAcconto.Importo != null && pag.RitenutaAcconto.Importo.GetValueOrDefault() != 0)
                            {
                                numeroRiga++;
                                var segnoRitenuta = "A";
                                importoRitenuta = pag.RitenutaAcconto.Importo.GetValueOrDefault();
                                if (pag.RitenutaAcconto.Importo.GetValueOrDefault() < 0)
                                {
                                    segnoRitenuta = "D";
                                    importoRitenuta = importoRitenuta * -1;
                                }
                                var movimentoRitenuta = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), importoRitenuta, segnoRitenuta)
                                {
                                    FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento
                                };
                                if (!string.IsNullOrEmpty(pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento) && pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento != null)
                                    movimentoRitenuta.Descrizione = "Ritenuta Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.Value.ToShortDateString();

                                pag.RitenutaAcconto.MovimentoContabileCreazione = movimentoRitenuta;
                                if(logTransazione == null)
                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
                            }

                            // ================================================
                            // Conto Patrimoniale
                            // ================================================
                            numeroRiga++;
                            if (pag.Conto == null)
                            {
                                switch (tipoConto)
                                {
                                    case "B":
                                        pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario());
                                        break;
                                    case "C":
                                        pag.Conto = _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, "903");
                                        break;
                                }
                            }

                            var segnoPagamento = "A";
                            var importoPagamento = importoFornitori - importoRitenuta;
                            if (importoPagamento < 0)
                            {
                                segnoPagamento = "D";
                                importoPagamento = importoPagamento * -1;

                                // Inverto segno e importo anche per il movimento di Debiti v/Fornitori
                                movimentoPatrimoniale.Segno = invertiSegno("D");
                                movimentoPatrimoniale.Importo = importoFornitori * -1;
                            }

                            var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importoPagamento, segnoPagamento)
                            {
                                Descrizione = movimentoPatrimoniale.GetDescrizione(),
                                NumeroAssegno = pag.NumeroAssegno,
                                FornitoreRiferimento =
                                    pag.ScadenzaRiferimento.SpesaRiferimento.
                                    FornitoreRiferimento,
                                SottoContoRiferimento = pag.SottoConto,
                                ContoCorrenteBancario = pag.ContoCorrenteBancario
                            };
                            pag.MovimentoContabile = movimentoBancario;
                            if (logTransazione == null)
                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);
                        }
                        else
                        {
                            var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", pag.Data.GetValueOrDefault()));
                            _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - disposizione:{3} - tipoConto:{4} - esercizio:{5}", ex, Utility.GetMethodDescription(), pag.Data.GetValueOrDefault(), pag.ID, disposizione.ID, tipoConto, esercizioRiferimento.ID);
                            throw ex;
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - (SINGOLO PAGAMENTO) - {0} - pagamento:{1} - disposizione:{2}", ex, Utility.GetMethodDescription(), pag.ID, disposizione.ID);
                        throw;
                    }

                }
            }
            catch (Exception ex)
            {
                _log.FatalFormat("Errore inaspettato durante la scrittura dei movimenti per pagamenti - {0} - disposizione:{1}", ex, Utility.GetMethodDescription(), disposizione.ID);
                throw;
            }
        }
Esempio n. 14
0
		internal static Func<IDataRecord, object> CreateFactory(DbClassInfoCache target, FactoryHelperSettings settings)
		{
			var classCtorAttr =
				target.Attributes.First(s => s.Attribute is AutoGenerateCtorAttribute).Attribute as
					AutoGenerateCtorAttribute;

			CodeNamespace importNameSpace;
			importNameSpace = new CodeNamespace(target.Type.Namespace);
			var cp = new CompilerParameters();
			string superName;
			var compiler = new CodeTypeDeclaration();
			compiler.IsClass = true;

			var generateFactory = target.Type.IsSealed || classCtorAttr.CtorGeneratorMode == CtorGeneratorMode.FactoryMethod;

			CodeMemberMethod codeConstructor;
			var codeName = target.Name.Split('.').Last();

			if (generateFactory)
			{
				codeConstructor = GenerateFactory(target, settings, importNameSpace);
				superName = codeName + "_Factory";
				compiler.Attributes = MemberAttributes.Static;
			}
			else
			{
				compiler.BaseTypes.Add(target.Type);
				codeConstructor = GenerateConstructor(target, settings, importNameSpace);
				compiler.IsPartial = true;
				superName = codeName + "_Super";
			}
			if (target.Constructors.Any(f => f.Arguments.Any()))
			{
				throw new TypeAccessException(string.Format("Target type '{0}' does not define an public parametherless constructor. POCO's!!!!", target.Name));
			}

			compiler.Attributes |= MemberAttributes.Public;
			compiler.Name = superName;
			compiler.Members.Add(codeConstructor);

			cp.GenerateInMemory = true;
			if (settings.FileCollisonDetection == CollisonDetectionMode.Pessimistic)
			{
				cp.OutputAssembly =
				Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
				+ @"\"
				+ Guid.NewGuid().ToString("N")
				+ "_Poco.dll";
			}
			else
			{
				cp.OutputAssembly =
				Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
				+ @"\" + target.Type.FullName
				+ "_Poco.dll";
			}

			settings.TempFileData.Add(cp.OutputAssembly);

			Assembly compiledAssembly;
			ConstructorInfo[] constructorInfos = null;
			TypeInfo targetType = null;

			if (File.Exists(cp.OutputAssembly) && settings.FileCollisonDetection == CollisonDetectionMode.Optimistic)
			{
				var bufferAssam = Assembly.Load(cp.OutputAssembly);
				targetType = target.Type.GetTypeInfo();
				var type = bufferAssam.DefinedTypes.FirstOrDefault(s => s == targetType);
				if (targetType != null)
					constructorInfos = targetType.GetConstructors();

				if(constructorInfos == null)
					throw new Exception(string.Format("A dll with a matching name for type: {0} was found and the FileCollisonDetection is Optimistic but no matching Constuctors where found", type.Name));
			}

			if (constructorInfos == null)
			{
				var callingAssm = Assembly.GetEntryAssembly();
				if (callingAssm == null)
				{
					//testing we are?
					callingAssm = Assembly.GetExecutingAssembly();
				}

				if (settings.CreateDebugCode)
				{
					cp.TempFiles = new TempFileCollection(Path.GetDirectoryName(callingAssm.Location), true);
					cp.GenerateInMemory = false;
					cp.TempFiles.KeepFiles = true;
					cp.IncludeDebugInformation = true;
				}

				//cp.GenerateExecutable = true;
				cp.ReferencedAssemblies.Add(target.Type.Assembly.Location);
				cp.ReferencedAssemblies.Add("System.dll");
				cp.ReferencedAssemblies.Add("System.Core.dll");
				cp.ReferencedAssemblies.Add("System.Data.dll");
				cp.ReferencedAssemblies.Add("System.Xml.dll");
				cp.ReferencedAssemblies.Add("System.Xml.Linq.dll");
				cp.ReferencedAssemblies.Add(typeof(DbAccessLayer).Assembly.Location);
				var compileUnit = new CodeCompileUnit();

				foreach (var defaultNamespace in settings.DefaultNamespaces)
				{
					importNameSpace.Imports.Add(new CodeNamespaceImport(defaultNamespace));
				}

				foreach (var additionalNamespace in target.Attributes.Where(f => f.Attribute is AutoGenerateCtorNamespaceAttribute).Select(f => f.Attribute as AutoGenerateCtorNamespaceAttribute))
				{
					importNameSpace.Imports.Add(new CodeNamespaceImport(additionalNamespace.UsedNamespace));
				}

				if (classCtorAttr.FullSateliteImport)
				{
					foreach (var referencedAssembly in target.Type.Assembly.GetReferencedAssemblies())
					{
						cp.ReferencedAssemblies.Add(referencedAssembly.Name);
					}
				}

				importNameSpace.Types.Add(compiler);

				compileUnit.Namespaces.Add(importNameSpace);
				var provider = new CSharpCodeProvider();
				var compileAssemblyFromDom = provider.CompileAssemblyFromDom(cp, compileUnit);

				if (compileAssemblyFromDom.Errors.Count > 0 && !settings.EnforceCreation)
				{
					var sb = new StringBuilder(string.Format("There are {0} errors due compilation.",
							compileAssemblyFromDom.Errors.Count));
					int errNr = 0;
					foreach (CompilerError error in compileAssemblyFromDom.Errors)
					{
						sb.AppendLine(errNr++ + error.ErrorNumber + ":" + error.Column + "," + error.Line + " -> " + error.ErrorText);
					}
					var ex =
						new InvalidDataException(sb.ToString());

					ex.Data.Add("Object", compileAssemblyFromDom);

					throw ex;
				}

				compiledAssembly = compileAssemblyFromDom.CompiledAssembly;

				targetType = compiledAssembly.DefinedTypes.First();
				constructorInfos = targetType.GetConstructors();
				if (!constructorInfos.Any())
				{
					if (settings.EnforceCreation)
						return null;
					var ex =
						new InvalidDataException(string.Format("There are was an unknown error due compilation. No CTOR was build"));

					ex.Data.Add("Object", compileAssemblyFromDom);
					foreach (CompilerError error in compileAssemblyFromDom.Errors)
					{
						ex.Data.Add(error.ErrorNumber, error);
					}
					throw ex;
				}
			}

			var matchingCtor = constructorInfos.FirstOrDefault(s =>
			{
				var param = s.GetParameters();
				if (generateFactory)
				{
					if (param.Length < 1)
						return false;
					if (param.First().ParameterType != typeof(IDataRecord))
						return false;
				}
				return true;
			});

			var dm = new DynamicMethod("Create" + target.Name.Split('.')[0], target.Type, new[] { typeof(IDataRecord) }, target.Type, true);
			var il = dm.GetILGenerator();
			if (generateFactory)
			{
				il.Emit(OpCodes.Nop);
				il.Emit(OpCodes.Ldarg_0);
				il.Emit(OpCodes.Call, targetType.GetMethod("Factory"));
				il.Emit(OpCodes.Ret);
			}
			else
			{
				il.Emit(OpCodes.Ldarg_0);
				il.Emit(OpCodes.Newobj, matchingCtor);
				il.Emit(OpCodes.Ret);
			}

			if (!settings.CreateDebugCode)
				foreach (string tempFile in cp.TempFiles)
				{
					if (!tempFile.EndsWith("dll") && !tempFile.EndsWith("pdb"))
						File.Delete(tempFile);
				}

			var func = (Func<IDataRecord, object>)dm.CreateDelegate(typeof(Func<IDataRecord, object>));
			return func;
		}
Esempio n. 15
0
        private Dictionary<DatiBancariCondomini, decimal> getSaldoContoBanca(int idEsercizio, int idConto)
        {
            var result = new Dictionary<DatiBancariCondomini, decimal>();

            try
            {
                var esercizio = _daoFactory.GetEsercizioDao().GetById(idEsercizio, false);

                var conti = new List<int> { idConto };
                var movimenti = GetMovimentiByContiData(esercizio.CondominioRiferimento.ID, esercizio.DataApertura.GetValueOrDefault(), esercizio.DataChiusura.GetValueOrDefault(), conti);
                foreach (var movimento in movimenti)
                {
                    try
                    {
                        if (movimento.ContoCorrenteBancario == null)
                            movimento.ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale;
                        if (movimento.ContoCorrenteBancario != null)
                        {
                            decimal saldo = 0;
                            if (result.ContainsKey(movimento.ContoCorrenteBancario))
                            {
                                saldo = result[movimento.ContoCorrenteBancario];
                                result.Remove(movimento.ContoCorrenteBancario);
                            }

                            decimal importo;
                            if (movimento.Segno == "A")
                                importo = movimento.GetImportoSenzaSegno();
                            else
                                importo = movimento.GetImportoSenzaSegno() * -1;
                            saldo += importo;

                            result.Add(movimento.ContoCorrenteBancario, saldo);
                        }
                        else
                        {
                            var ex = new InvalidDataException(string.Format("Non è possibile la chiusura di esercizio presente un movimento del conto banca senza indicazione dello specifico conto corrente bancario.{0}{0}Verificare il movimento '{1}'.{0}Causale: {2}", Environment.NewLine, movimento.Descrizione.Trim(), movimento.Causale.DescrizioneCompleta));
                            _log.FatalFormat("Presente movimento del conto Banca senza indicazione del conto corrente - {0} - movimento:{1} - esercizio:{1} - conto:{2}", ex, Utility.GetMethodDescription(), movimento.ID, idEsercizio, idConto);
                            throw ex;
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.FatalFormat("Errore inaspettato durante il calcolo del saldo del conto Banca (SINGOLO MOVIMENTO) - {0} - movimento:{1} - esercizio:{2} - conto:{3}", ex, Utility.GetMethodDescription(), movimento.ID, idEsercizio, idConto);
                        throw;
                    }

                }
            }
            catch (Exception ex)
            {
                _log.FatalFormat("Errore inaspettato durante il calcolo del saldo del conto Banca - {0} - movimento:{1} - conto:{2}", ex, Utility.GetMethodDescription(), idEsercizio, idConto);
                throw;
            }

            return result;
        }
Esempio n. 16
0
        public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(Esercizio esercizio, AddebitoCompetenza addebito, DateTime dataRegistrazione, Conto conto, SottoConto sottoConto, string descrizione)
        {
            try
            {
                // controllo data registrazione
                var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                    _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - addebito:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, addebito.ID, esercizio.ID);
                    throw ex;
                }

                // se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
                // per ora la testata viene inserita come manuale.
                //TestataMovimentoContabile testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, Sfera.Enums.TipoTestataMovimentoContabileEnum.Automatica);
                var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = descrizione, IsAllowUpdate = true};

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                var numeroRiga = 0;

                // Contropartita
                numeroRiga++;
                var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
                new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = descrizione};

                foreach (var item in addebito.Dettaglio)
                {
                    try
                    {
                        numeroRiga++;
                        var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
                        {
                            SottoContoRiferimento = sottoConto,
                            Descrizione = descrizione,
                            CondominoRiferimento = item.Soggetto
                        };
                        item.MovimentoContabile = movimento;
                    
                        switch (item.Soggetto.Tipo)
                        {
                            case TipoSoggetto.Proprietario:
                                movimento.PercentualeProprieta = 1;
                                break;
                            case TipoSoggetto.Conduttore:
                                movimento.PercentualeProprieta = 0;
                                break;
                        }

                        movimento.IsRipartoPersonalizzato = true;
                        new SpeseUnita(item.Importo, null, item.Soggetto, movimento);

                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO DETTAGLIO - {0} - item:{1}", ex, Utility.GetMethodDescription(), item.ID);
                        throw;
                    }
                }

                addebito.TestataMovimento = testata;
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                return testata;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - {0} - esercizio:{1} - dataRegistrazione:{2} - addebito:{3} - conto:{4} - sottoconto:{5} - descrizione:{6}", ex, Utility.GetMethodDescription(), esercizio != null ? esercizio.ID.ToString() : "<NULL>", dataRegistrazione, addebito != null ? addebito.ID.ToString() : "<NULL>", conto != null ? conto.ID.ToString() : "<NULL>", sottoConto != null ? sottoConto.ID.ToString() : "<NULL>", descrizione);
                throw;
            }
        }
Esempio n. 17
0
        public string SetMovimentoAccreditoInteressiMora(Esercizio esercizio, TestataMovimentoContabile testata, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
        {
            try
            {
                var message = string.Empty;

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("RI");
                if (testata == null)
                    testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {IsAllowUpdate = true};

                // controllo data registrazione
                var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
                if (messageData.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                    _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), conto.ID, esercizio.ID);
                    throw ex;
                }

                var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "A") {Descrizione = descrizione};
                _ripartizioneService.ReloadRipartizioneByMovimento(movimento);

                return message;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella creazione del movimento di accredito per interessi di mora - {0} - esercizio:{1}", ex, Utility.GetMethodDescription(), esercizio.ID);
                throw;
            }
        }
Esempio n. 18
0
        public TestataMovimentoContabile SetMovimentiRiscaldamentoAcqua(Esercizio esercizio, int idContoAcquaRiscaldata, int idContoRiscaldamento, string descrizioneMovimentoAcqua, string descrizioneMovimentoRiscaldamento, IList<ImportiDTO> importiRiscaldamento, DateTime dataRegistrazione, bool checkDataRegistrazione)
        {
            // controllo data registrazione
            if (checkDataRegistrazione)
            {
            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                	_log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - IdEsercizio:" + esercizio.ID, ex);
                    throw ex;
                }
            }

            var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
            {
                Descrizione = descrizioneMovimentoAcqua,
                IsAbilitataArchiviazioneOttica = false,
                IsAllowUpdate = true
            };
            _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");

            // -------------------------------------------------
            // Calcolo Importo
            // ------------------------------------------------
            var importo = importiRiscaldamento.Sum(item => item.Importo);

            // -------------------------------------------------
            // Segno Movimento
            // ------------------------------------------------
            var segnoContoEconomico = "D";
            if (importo < 0)
            {
                segnoContoEconomico = "A";
                importo = importo * -1;
            }

            // ------------------------------------------------
            // Conto economico da addebitare
            // ------------------------------------------------
            var contoEconomico = _daoFactory.GetContoDao().GetById(idContoAcquaRiscaldata, false);
            var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoEconomico, importo, segnoContoEconomico)
            {
                Descrizione = descrizioneMovimentoAcqua,
                IsRipartoPersonalizzato = true,
                RipartoTramiteLetture = true
            };
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);
            _ripartizioneService.SalvaRipartizione(movimentoContoEconomicoAddebito, importiRiscaldamento, false);

            // ------------------------------------------------
            // Conto economico da accreditare
            // ------------------------------------------------
            var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(idContoRiscaldamento, false), importo, invertiSegno(segnoContoEconomico)) {Descrizione = descrizioneMovimentoRiscaldamento};
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);

            return testata;
        }
Esempio n. 19
0
        public TestataMovimentoContabile SetMovimentoSpesaPersonale(Esercizio esercizio, TestataMovimentoContabile testata, SoggettoCondominio soggetto, Conto conto, string descrizione, decimal importo, DateTime dataRegistrazione)
        {
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
            if (testata == null)
            {
                testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) {Descrizione = "Calcolo interessi di mora", IsAllowUpdate = true};
            }

            // controllo data registrazione
            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, testata.DataRegistrazione.GetValueOrDefault());
            if (message.Count > 0)
            {
                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - soggetto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), soggetto.ID, esercizio.ID);
                throw ex;
            }

            var movimento = new MovimentoContabile(testata, causale, testata.Movimenti.Count() + 1, conto, importo, "D") {Descrizione = descrizione};
            switch (soggetto.Tipo)
            {
                case TipoSoggetto.Proprietario:
                    movimento.PercentualeProprieta = 1;
                    break;
                case TipoSoggetto.Conduttore:
                    movimento.PercentualeProprieta = 0;
                    break;
            }

            movimento.IsRipartoPersonalizzato = true;
            new SpeseUnita(importo, null, soggetto, movimento);

            _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

            return testata;
        }
Esempio n. 20
0
        public IList<MovimentoContabile> SetMovimentoBolletta(BollettaDTO bolletta, Spesa spesa, TestataMovimentoContabile testata, LogTransazione logTransazione, bool controlloDataRegistrazione)
        {
            try
            {
                IList<MovimentoContabile> movimentiEconomici = new List<MovimentoContabile>();

                CausaleContabile causale;
                if (spesa.Utenza != null && spesa.Utenza.RipartoLetture)
                    causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                else
                    causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");

                if (testata == null && spesa.TestateMovimenti.Count > 0)
                {
                    testata = spesa.TestateMovimenti.FirstOrDefault();
                    if (testata != null)
                    {
                        testata.EsercizioRiferimento = spesa.EsercizioRiferimento;
                        testata.DataRegistrazione = bolletta.DataRegistrazione;
                    }
                }

                var dataRegistrazione = DateTime.Today;
                if (bolletta.DataRegistrazione != null)
                    dataRegistrazione = bolletta.DataRegistrazione.GetValueOrDefault();

                if (testata == null)
                {
                    testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = spesa };
                    spesa.TestateMovimenti.Add(testata);
                    testata.IsAllowUpdate = false;
                    if(logTransazione == null)
                        _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                    else
                        testata.LogTransazione = logTransazione;
                }

                // controllo data registrazione
                IList<string> message = new List<string>();
                if(controlloDataRegistrazione)
                    message = IsAllowDataRegistrazione(new List<int> { spesa.EsercizioRiferimento.CondominioRiferimento.ID }, spesa.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                    _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), spesa.ID, spesa.EsercizioRiferimento.ID);
                    throw ex;
                }

                testata.Descrizione = bolletta.Descrizione;
                testata.DataRegistrazione = dataRegistrazione;

                // -------------------------------------------
                // Elimino movimenti cancellati
                // -------------------------------------------
                foreach (var mov in testata.Movimenti.Where(item => item.NumeroRiga > 1).ToList())
                    DeleteSingoloMovimento(mov);

                // -------------------------------------------
                // Movimenti Economici
                // -------------------------------------------
                var numeroRiga = 1;
                var importoEconomico = 0m;
                foreach (var movimentoDto in bolletta.Movimenti)
                {
                    if (movimentoDto.IdConto != null)
                    {
                        var importo = Math.Round(movimentoDto.Importo.GetValueOrDefault(), 2);
                        importoEconomico += importo;

                        var segno = "D";
                        if (importo < 0)
                        {
                            segno = "A";
                            importo = importo * -1;
                        }

                        var movimento = _daoFactory.GetMovimentoContabileDao().Find(movimentoDto.ID, false);
                        numeroRiga++;
                        if (movimento != null)
                        {
                            movimento.ContoRiferimento = _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false);
                            movimento.Segno = segno;
                            movimento.Importo = importo;
                            movimento.Causale = causale;
                        }
                        else
                        {
                            movimento = new MovimentoContabile(testata, spesa, causale, testata.Movimenti.Count + 1, _daoFactory.GetContoDao().GetById(movimentoDto.IdConto.Value, false), importo, segno);
                            if(logTransazione == null)
                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                        }

                        movimento.IsMovimentoEconomico = true;
                        movimento.NumeroRiga = numeroRiga;
                        movimento.Descrizione = movimentoDto.Descrizione;
                        if (movimentoDto.IdSottoConto != null && movimentoDto.IdSottoConto > 0)
                            movimento.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(movimentoDto.IdSottoConto.Value, false);

                        movimentoDto.ID = movimento.ID;
                        movimentiEconomici.Add(movimento);
                    }
                    else
                    {
                        _log.ErrorFormat("Movimento senza conto associato - {0} - bolletta:{1}", Utility.GetMethodDescription(), bolletta.ID);
                        throw (new Exception("Movimento senza conto associato - " + Utility.GetMethodDescription() + " - idBolletta:" + bolletta.ID));
                    }
                }

                // ------------------------------------------------
                // Debiti VS Fornitori
                // ------------------------------------------------
                var causalePatrimoniale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
                var importoTotale = spesa.ImportoBolletta.GetValueOrDefault();
                var importoPatrimoniale = importoTotale;

                var segnoPatrimoniale = "A";
                if (importoTotale < 0)
                {
                    segnoPatrimoniale = "D";
                    importoTotale = importoTotale * -1;
                }

                var movimentoPatrimoniale = (testata.Movimenti.Where(item => !item.IsMovimentoEconomico && !item.ContoRiferimento.IsArrotondamento)).FirstOrDefault();
                if (movimentoPatrimoniale == null)
                {
                    movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causalePatrimoniale, 1, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotale, segnoPatrimoniale);
                    if(logTransazione == null)
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);
                }
                else
                {
                    movimentoPatrimoniale.NumeroRiga = 1;
                    movimentoPatrimoniale.Importo = importoTotale;
                    movimentoPatrimoniale.Segno = segnoPatrimoniale;
                }

                movimentoPatrimoniale.Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}";

                // ------------------------------------------------
                // Eventuale arrotondamento
                // ------------------------------------------------
                setMovimentoArrotondamento(importoPatrimoniale, importoEconomico, numeroRiga, spesa, testata, causale, logTransazione);

                return movimentiEconomici;
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella creazione del movimento di registrazione delle bollette - {0} - bolletta:{1}", ex, Utility.GetMethodDescription(), bolletta.ID);
                throw;
            }
        }
 protected Exception CreateException(InvalidDataException innerException, string framingFault)
 {
     Exception exception = this.CreateException(innerException);
     FramingEncodingString.AddFaultString(exception, framingFault);
     return exception;
 }
Esempio n. 22
0
        public TestataMovimentoContabile SetMovimentiContatoreCondominiale(Esercizio esercizio, IList<ImportoMovimento> importiAccredito, IList<ImportiDTO> addebitiContatoriDivisionali, DateTime dataRegistrazione, Conto contoAddebito, SottoConto sottoContoAddebito, string descrizione)
        {
            // controllo data registrazione
            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
            if (message.Count > 0)
            {
                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - esercizio:{2}", ex, Utility.GetMethodDescription(), dataRegistrazione, esercizio.ID);
                throw ex;
            }

            var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
            {
                Descrizione = descrizione,
                IsAbilitataArchiviazioneOttica = false,
                IsAllowUpdate = true
            };
            _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SC");

            // -------------------------------------------------
            // Calcolo Importo
            // ------------------------------------------------
            var importo = importiAccredito.Sum(item => item.Importo);

            // -------------------------------------------------
            // Segno Movimento
            // ------------------------------------------------
            var segnoContoEconomico = "D";
            if (importo < 0)
            {
                segnoContoEconomico = "A";
                importo = importo * -1;
            }

            // ------------------------------------------------
            // Conto economico da addebitare
            // ------------------------------------------------
            var movimentoContoEconomicoAddebito = new MovimentoContabile(testata, causale, 1, contoAddebito, importo, segnoContoEconomico)
            {
                SottoContoRiferimento = sottoContoAddebito,
                Descrizione = descrizione,
                IsRipartoPersonalizzato = true
            };
            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAddebito);

            // ------------------------------------------------
            // Conto economico da accreditare
            // ------------------------------------------------
            foreach (var item in importiAccredito)
            {
                var movimentoContoEconomicoAccredito = new MovimentoContabile(testata, causale, 2, _daoFactory.GetContoDao().GetById(item.IdConto, false), item.Importo, invertiSegno(segnoContoEconomico)) { Descrizione = descrizione, IsRipartoPersonalizzato = true };
                if(item.IdSottoConto > 0)
                    movimentoContoEconomicoAccredito.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.GetValueOrDefault(), false);
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoContoEconomicoAccredito);

                // Ripartizione tra le unità immobiliari
                var totaleMillesimi = addebitiContatoriDivisionali.Sum(mill => mill.Importo);
                foreach (var importiDTO in addebitiContatoriDivisionali)
                {
                    var unita = _daoFactory.GetUnitaImmobiliareDao().GetById(importiDTO.Id, false);
                    var importoUnita = (movimentoContoEconomicoAccredito.GetImportoConSegno() * importiDTO.Importo) / totaleMillesimi;
                    var spesaUnita = new SpeseUnita(importoUnita, unita, null, movimentoContoEconomicoAccredito);
                    _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);

                }
            }

            return testata;
        }
Esempio n. 23
0
			private void SetUnknownDataFormat(Exception deserializeException)
			{
				Exception = new InvalidDataException("Beim deserialisieren des Datenstroms trat ein Fehler auf. Weiter Informationen in der Inner Exception", deserializeException);
				State = States.UnknownDataFormat;
			}
Esempio n. 24
0
        public TestataMovimentoContabile SetMovimentiSollecito(Esercizio esercizio, IList<Sollecito> solleciti, DateTime dataRegistrazione, Conto conto, SottoConto sottoconto)
        {
            try
            {
                // controllo data registrazione
                var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count > 0)
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                    _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - conto:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, conto.ID, esercizio.ID);
                    throw ex;
                }

                var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null)
                {
                    Descrizione = "Addebito solleciti del " + dataRegistrazione.ToShortDateString(),
                    IsAllowUpdate = true
                };

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                var numeroRiga = 0;

                // Contropartita
                numeroRiga++;
                var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
                new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, solleciti.Sum(item => item.ImportoCompetenza.GetValueOrDefault()), "A");

                foreach (var soll in solleciti)
                {
                    numeroRiga++;
                    var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, soll.ImportoCompetenza, "D") {SottoContoRiferimento = sottoconto};
                    if (soll.Soggetto != null)
                        movimento.CondominoRiferimento = soll.Soggetto;
                    soll.MovimentoEconomico = movimento;

                    movimento.IsRipartoPersonalizzato = true;

                    var soggetto = soll.Soggetto ?? soll.Persona.SoggettiCondominio.FirstOrDefault(item => item.UnitaImmobiliare.GruppoStabileRiferimento.PalazzinaRiferimento.CondominioRiferimento.ID == soll.Esercizio.CondominioRiferimento.ID);
                    if (soggetto != null)
                    {
                        movimento.CondominoRiferimento = soggetto;
                        switch (soggetto.Tipo)
                        {
                            case TipoSoggetto.Proprietario:
                                movimento.PercentualeProprieta = 1;
                                break;
                            case TipoSoggetto.Conduttore:
                                movimento.PercentualeProprieta = 0;
                                break;
                        }
                        new SpeseUnita(soll.ImportoCompetenza, null, soggetto, movimento);
                    }
                }

                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                return testata;
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - IdEsercizio:" + esercizio.ID.ToString(), ex);
                throw;
            }
        }
Esempio n. 25
0
        public MovimentoContabile SetMovimentiStornoScadenza(DettaglioSpesa dettaglioSpesa, ScadenzaFattura scadenza, decimal importo, Esercizio esercizio, DateTime dataRegistrazione)
        {
            try
            {
                var message = IsAllowDataRegistrazione(new List<int> { scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count == 0)
                {
                    var numeroRiga = 0;
                    var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SS");

                    // ================================================
                    // Testata
                    // ================================================
                    var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                    // ================================================
                    // Debiti VS Fornitori
                    // ================================================
                    numeroRiga++;

                    var segno = "D";
                    if (importo < 0)
                    {
                        segno = "A";
                        importo = importo * -1;
                    }

                    var movimentoPatrimoniale = new MovimentoContabile(testata, scadenza.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(scadenza.SpesaRiferimento.EsercizioRiferimento.ID, scadenza.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno)
                    {
                        Descrizione = "Storno Fatt. n." + scadenza.SpesaRiferimento.NumeroDocumento + " del " + scadenza.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                    };
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                    // ================================================
                    // Conto Economico
                    // ================================================
                    var importoTotale = 0m;
                    numeroRiga++;

                    if (scadenza.SpesaRiferimento.TipoDocumento != "FATBILAPP")
                    {
                        var movimenti = new List<MovimentoContabile>();

                        // Se è una FATTURA ......
                        if (scadenza.SpesaRiferimento.Dettagli.Count > 0)
                        {
                            importoTotale = scadenza.SpesaRiferimento.Dettagli.Sum(item => item.Movimenti.Sum(item2 => item2.GetImportoConSegno().GetValueOrDefault()));
                            foreach (var dettaglio in scadenza.SpesaRiferimento.Dettagli)
                                movimenti.AddRange(dettaglio.Movimenti);
                        }
                        // .... oppure una BOLLETTA
                        else if (scadenza.SpesaRiferimento.MovimentiBollette.Count > 0)
                        {
                            importoTotale = scadenza.SpesaRiferimento.MovimentiBollette.Sum(item => item.GetImportoConSegno().GetValueOrDefault());
                            movimenti.AddRange(scadenza.SpesaRiferimento.MovimentiBollette);
                        }

                        foreach (var movimento in movimenti)
                        {
                            var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, (importo * movimento.GetImportoConSegno()) / importoTotale, invertiSegno(movimento.Segno))
                            {
                                SottoContoRiferimento = movimento.SottoContoRiferimento,
                                Descrizione = movimento.GetDescrizione(),
                                IsRipartoPersonalizzato = movimento.IsRipartoPersonalizzato,
                                LottiAddebito = movimento.LottiAddebito,
                                StabiliAddebito = movimento.StabiliAddebito,
                                GruppiAddebito = movimento.GruppiAddebito,
                                FornitoreRiferimento = movimento.FornitoreRiferimento,
                                DettaglioRiferimento = dettaglioSpesa
                            };
                            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico);

                            // Se è presente una ripartizione personalizzata o una spesa personale deve salvare anche il riparto.
                            foreach (var itemRiparto in movimento.DettaglioRipartizione)
                            {
                                var importoRiparto = (itemRiparto.Importo.GetValueOrDefault()*movimentoEconomico.Importo.GetValueOrDefault()/movimento.Importo.GetValueOrDefault()) * -1;
                                var spesaUnita = itemRiparto.MovimentoRiferimento.ContoRiferimento.IsSpesePersonali ? new SpeseUnita(importoRiparto, null, itemRiparto.SoggettoCondominio, movimentoEconomico) : new SpeseUnita(importoRiparto, itemRiparto.UnitaRiferimento, null, movimentoEconomico);
                                _daoFactory.GetSpeseUnitaDao().SaveOrUpdate(spesaUnita);
                            }

                            movimento.MovimentoStorno = movimentoEconomico;
                        }
                    }
                    // Se si tratta di fattura da Bilancio di Apertura lo storno avviene esclusivamente dal conto Bancario
                    else
                    {
                        var movimentoEconomico = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), importo, invertiSegno(movimentoPatrimoniale.Segno))
                        {
                            ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale,
                            Descrizione = movimentoPatrimoniale.Descrizione
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoEconomico);
                    }

                    return movimentoPatrimoniale;
                }

                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                
                _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - scadenza:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, scadenza.ID, importo);
                throw ex;
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - scadenza:" + scadenza.ID + " - importo:" + importo, ex);
                throw;
            }
        }
Esempio n. 26
0
        public TestataMovimentoContabile SetMovimentiAddebitoCompetenze(AddebitoCompetenzaDTO addebito)
        {
            try
            {
                // se la testata è automatica non è possibile aggiornare gli importi nel dettaglio, se manuale è possibile l'aggiornamento.
                // per ora la testata viene inserita come manuale.
                TestataMovimentoContabile testata;
                var esercizio = _daoFactory.GetEsercizioDao().Find(addebito.IdEsercizio, false);
                var dataRegistrazione = addebito.DataRegistrazioneMovimentoContabile;

                // controllo data registrazione
                var messageData = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (messageData.Count == 0)
                {
                    testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Manuale, null) {Descrizione = addebito.Descrizione, IsAllowUpdate = true};

                    var causale = _daoFactory.GetCausaleContabileDao().Find(addebito.IdCausale, false) ?? _daoFactory.GetCausaleContabileDao().GetByCodice("IA");
                    var numeroRiga = 0;

                    // Contropartita
                    numeroRiga++;
                    var contoContropartita = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, "913");
                    new MovimentoContabile(testata, causale, numeroRiga, contoContropartita, addebito.Dettaglio.Sum(item => item.Importo), "A") {Descrizione = addebito.Descrizione};

                    foreach (var item in addebito.Dettaglio)
                    {
                        try
                        {
                            if (item.Importo != 0)
                            {
                                numeroRiga++;

                                var conto = _daoFactory.GetContoDao().Find(item.IdConto, false);
                                if (conto != null)
                                {
                                    SottoConto sottoConto = null;
                                    if (item.IdSottoConto != null)
                                        sottoConto = _daoFactory.GetSottoContoDao().GetById(item.IdSottoConto.Value, false);
                                    var soggetto = _daoFactory.GetSoggettoCondominioDao().Find(item.IdCondomino.GetValueOrDefault(), false);
                                    if (soggetto != null)
                                    {
                                        var movimento = new MovimentoContabile(testata, causale, numeroRiga, conto, item.Importo, "D")
                                        {
                                            SottoContoRiferimento = sottoConto,
                                            Descrizione = item.DescrizioneMovimentoContabile,
                                            CondominoRiferimento = soggetto
                                        };

                                        switch (soggetto.Tipo)
                                        {
                                            case TipoSoggetto.Proprietario:
                                                movimento.PercentualeProprieta = 1;
                                                break;
                                            case TipoSoggetto.Conduttore:
                                                movimento.PercentualeProprieta = 0;
                                                break;
                                        }

                                        movimento.IsRipartoPersonalizzato = true;
                                        new SpeseUnita(item.Importo, null, soggetto, movimento);

                                        var dettaglio = _daoFactory.GetDettaglioAddebitoCompetenzaDao().Find(item.ID, false);
                                        if (dettaglio != null)
                                        {
                                            dettaglio.MovimentoContabile = movimento;
                                            dettaglio.Soggetto = soggetto;
                                        }
                                    }
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            
                            _log.Fatal(
                                "Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - SINGOLO SOGGETTO - " +
                                Utility.GetMethodDescription() + " - id:" + item.ID + " - importo:" +
                                item.Importo + " - soggetto:" + item.IdCondomino + " - conto:" + item.IdConto +
                                " - sottoconto:" + item.IdSottoConto.GetValueOrDefault() + " - addebito:" + addebito.ID +
                                " - IdEsercizio:" + addebito.IdEsercizio, ex);
                            throw;
                        }

                    }

                    var addebitoItem = _daoFactory.GetAddebitoCompetenzaDao().Find(addebito.ID, false);
                    if (addebitoItem != null)
                        addebitoItem.TestataMovimento = testata;

                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                }
                else
                {
                    var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                    
                    _log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - addebito:" + addebito.ID + " - IdEsercizio:" + addebito.IdEsercizio, ex);
                    throw ex;
                }

                return testata;
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nella creazione del movimento di addebito competenze per sollecito - " + Utility.GetMethodDescription() + " - addebito:" + addebito.ID + " - IdEsercizio:" + addebito.IdEsercizio, ex);
                throw;
            }
        }
Esempio n. 27
0
        public MovimentoContabile SetMovimentiRiscossione(Riscossione riscossione, int? idConto, int? idSottoConto, DateTime dataRegistrazione)
        {
            try
            {
                var esercizio = getEsercizioCompetenza(riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
                var message = IsAllowDataRegistrazione(new List<int> { riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count == 0)
                {
                    var numeroRiga = 0;
                    var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("PF");

                    // ================================================
                    // Testata
                    // ================================================
                    var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                    // ================================================
                    // Crediti VS Fornitori
                    // ================================================
                    numeroRiga++;

                    const string segnoFornitori = "A";
                    var movimentoFornitore = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
                                                                    _daoFactory.GetContoDao().GetByCodice(riscossione.SpesaRiferimento.EsercizioRiferimento.ID, riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()),
                                                                    Math.Abs(riscossione.Importo.GetValueOrDefault()), segnoFornitori)
                    {
                        Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                    };
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoFornitore);

                    // ================================================
                    // Conto Patrimoniale
                    // ================================================
                    numeroRiga++;

                    const string segnoPatrimoniale = "D";
                    var conto = _daoFactory.GetContoDao().GetById(idConto.GetValueOrDefault(), false);
                    SottoConto sottoconto = null;
                    if (idSottoConto > 0)
                        sottoconto = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);

                    var movimentoPatrimoniale = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga, conto, Math.Abs(riscossione.Importo.GetValueOrDefault() - riscossione.ImportoRitenuta.GetValueOrDefault()), segnoPatrimoniale)
                    {
                        SottoContoRiferimento = sottoconto,
                        Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                    };
                    if (idSottoConto < 0)
                        movimentoPatrimoniale.ContoCorrenteBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value * -1, false);
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                    // ================================================
                    // Ritenuta Acconto
                    // ================================================
                    if (Math.Abs(riscossione.ImportoRitenuta.GetValueOrDefault()) > 0)
                    {
                        numeroRiga++;

                        const string segnoRitenuta = "D";
                        var movimentoRitenuta = new MovimentoContabile(testata, riscossione.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
                                                                       _daoFactory.GetContoDao().GetByCodice(riscossione.SpesaRiferimento.EsercizioRiferimento.ID, riscossione.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), Math.Abs(riscossione.ImportoRitenuta.GetValueOrDefault()), segnoRitenuta)
                        {
                            Descrizione = "Riscossione Nota Accredito n." + riscossione.SpesaRiferimento.NumeroDocumento + " del " + riscossione.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoRitenuta);
                    }

                    return movimentoPatrimoniale;
                }

                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
                
                _log.Fatal("Data di registrazione non valida - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - riscossione:" + riscossione.ID + " - idConto:" + idConto.GetValueOrDefault() + " - idSottoConto:" + idSottoConto.GetValueOrDefault(), ex);
                throw ex;
 
            }
            catch (Exception ex)
            {
                
                _log.Fatal("Errore inaspettato nella funzione - " + Utility.GetMethodDescription() + " - data:" + dataRegistrazione + " - riscossione:" + riscossione.ID + " - idConto:" + idConto.GetValueOrDefault() + " - idSottoConto:" + idSottoConto.GetValueOrDefault(), ex);
                throw;
            }
        }
Esempio n. 28
0
        public TestataMovimentoContabile SetMovimentiInserimentoSpesa(Spesa spesa, TestataMovimentoContabile testata, DateTime dataRegistrazione)
        {
            var message = IsAllowDataRegistrazione(new List<int> {spesa.EsercizioRiferimento.CondominioRiferimento.ID}, spesa.EsercizioRiferimento, dataRegistrazione);

            if (message.Count == 0)
            {
                _daoFactory.GetSpesaDao().SaveOrUpdate(spesa);

                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IF");
                if (testata == null)
                    testata = new TestataMovimentoContabile(spesa.EsercizioRiferimento, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                testata.SpesaRiferimento = spesa;
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                // ------------------------------------------------
                // Conto economico
                // ------------------------------------------------
                var numeroRiga = 0;
                var importoEconomico = 0m;
                foreach (var dettaglio in spesa.Dettagli)
                {
                    if (numeroRiga == 0)
                        testata.Descrizione = dettaglio.GetDescrizione();
                    foreach (var movimento in dettaglio.Movimenti)
                    {
                        movimento.Testata = testata;
                        movimento.IsMovimentoEconomico = true;
                        testata.Movimenti.Add(movimento);
                        numeroRiga++;
                        movimento.NumeroRiga = numeroRiga;

                        if (movimento.Importo < 0)
                            _log.WarnFormat("Presente importo movimento con segno negativo - {0} - movimento:{1}", Utility.GetMethodDescription(), movimento.ID);

                        importoEconomico += Math.Round(movimento.GetImportoPerSpesa(true).GetValueOrDefault(), 2);
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                    }
                }

                foreach (var movimento in spesa.MovimentiBollette)
                {
                    movimento.Testata = testata;
                    movimento.IsMovimentoEconomico = true;
                    testata.Movimenti.Add(movimento);
                    numeroRiga++;
                    movimento.NumeroRiga = numeroRiga;

                    if (movimento.GetImportoConSegno() < 0)
                    {
                        movimento.Segno = "A";
                        movimento.Importo = movimento.GetImportoConSegno()*-1;
                    }

                    importoEconomico += movimento.Importo.GetValueOrDefault();
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimento);
                }

                // ------------------------------------------------
                // Debiti VS Fornitori
                // ------------------------------------------------
                var importoTotale = spesa.ImportoLordo + spesa.AltreSpeseEsenti.GetValueOrDefault();
                var importoTotaleArrotondato = Math.Round(importoTotale, 2);

                numeroRiga++;
                var segno = "A";
                if (importoTotale < 0)
                {
                    segno = "D";
                    importoTotaleArrotondato = importoTotaleArrotondato*-1;
                }
                var movimentoPatrimoniale = new MovimentoContabile(testata, spesa.FornitoreRiferimento, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(spesa.EsercizioRiferimento.ID, spesa.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importoTotaleArrotondato, segno)
                {
                    Descrizione = $"Fatt. n. {spesa.NumeroDocumento} del {spesa.DataDocumento.GetValueOrDefault():d}"
                };
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                // ------------------------------------------------
                // Eventuale arrotondamento
                // ------------------------------------------------
                if (spesa.TipoDocumento == "NOTACC" || spesa.ImportoLordo < 0)
                    importoTotaleArrotondato = importoTotaleArrotondato*-1;
                setMovimentoArrotondamento(importoTotaleArrotondato, importoEconomico, numeroRiga, spesa, testata, causale, null);

                return testata;
            }

            var ex = new InvalidDataException($"La data di registrazione {dataRegistrazione:d} non è valida");
            _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - spesa:{2} - dataRegistrazione:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, spesa.ID, dataRegistrazione);
            throw ex;
        }
Esempio n. 29
0
        public void SetMovimentiRitenuta(PagamentoRitenuta fileRitenuta, string descrizioneAddebitoInteressi, string descrizioneAddebitoSanzioni)
        {
            try
            {
                var numeroRiga = 0;
                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");
                var lista = new Dictionary<Esercizio, TestataMovimentoContabile>(fileRitenuta.Pagamenti.Count);

                foreach (var pag in fileRitenuta.Pagamenti)
                {
                    try
                    {
                        // ------------------------------------------------
                        // Testata
                        // ------------------------------------------------
                        TestataMovimentoContabile testata;

                        var esercizi = (from es in _daoFactory.GetEsercizioDao().GetByCondominio(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento)
                                        where es.Gestione == GestioneEsercizioEnum.Ordinario && es.DataApertura <= fileRitenuta.Data.GetValueOrDefault() && es.DataChiusura >= fileRitenuta.Data.GetValueOrDefault()
                                        select es).ToList();

                        if (esercizi.Count() > 1)
                        {
                            var eserciziId = esercizi.Aggregate(string.Empty, (current, es) => current + (" id:" + es.ID + " descrizione:" + es.Descrizione + " - "));
                            _log.WarnFormat("Uno o più esercizi ordinari si sovrappongono - {0} - condominio:{1} - esercizi:{2}", Utility.GetMethodDescription(), pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, eserciziId);
                        }
                        var esercizio = esercizi.FirstOrDefault() ?? pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento;

                        if (lista.ContainsKey(esercizio))
                            testata = lista[esercizio];
                        else
                        {
                            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, fileRitenuta.Data.GetValueOrDefault());
                            if (message.Count == 0)
                            {
                                testata = new TestataMovimentoContabile(esercizio, fileRitenuta.Data, TipoTestataMovimentoContabileEnum.Automatica, null);
                                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);
                                lista.Add(esercizio, testata);
                            }
                            else
                            {
                                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", fileRitenuta.Data));
                                _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - esercizio:{3}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, pag.ID , esercizio.ID);
                                throw ex;
                            }
                        }

                        var spesa = pag.ScadenzaRiferimento.SpesaRiferimento;
                        var firstDettaglio = spesa.Dettagli.FirstOrDefault();
                        TestataMovimentoContabile testataFattura = null;
                        if (firstDettaglio != null)
                        {
                            var firstMovimento = firstDettaglio.Movimenti.FirstOrDefault();
                            if (firstMovimento != null)
                                testataFattura = firstMovimento.Testata;
                        }
                        
                        // ------------------------------------------------
                        // Interessi per Ravvedimento Operoso
                        // ------------------------------------------------
                        if (pag.RitenutaAcconto.ImportoInteressi > 0)
                        {
                            if (testataFattura != null && !testataFattura.AperturaBilancio)
                            {
                                var importo = spesa.Dettagli.SelectMany(item => item.Movimenti).Sum(item => item.Importo.GetValueOrDefault());
                                foreach (var dettaglio in spesa.Dettagli)
                                {
                                    try
                                    {
                                        foreach (var movimento in dettaglio.Movimenti)
                                        {
                                            try
                                            {
                                                var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                                if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                                    importoMovimento = importoMovimento * -1;

                                                var interesseCompetenza = pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault();
                                                if (spesa.ImportoLordo != 0)
                                                    interesseCompetenza = (pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault() * importoMovimento) / importo;
                                                else
                                                {
                                                    _log.WarnFormat("Trovata spesa con importo lordo a 0 - {0} - spesa:{1} - data:{2} - movimento:{3} - pagamento:{4} - file ritenuta:{5}", Utility.GetMethodDescription(), spesa.ID, fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
                                                }

                                                var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
                                                {
                                                    SottoContoRiferimento = movimento.SottoContoRiferimento,
                                                    FornitoreRiferimento = movimento.FornitoreRiferimento,
                                                    Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
                                                    TipoInteresseSanzione = TipoInteresseSanzioneEnum.Interesse,
                                                    PagamentoInteresseSanzione = pag
                                                };

                                                // TODO: Da verificare per i problemi riscontrati con interessi e sanzioni
                                                // "Interessi ravv. operoso - " + movimento.GetDescrizione();
                                                _ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);

                                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);

                                            }
                                            catch (Exception ex)
                                            {
                                                _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO MOVIMENTO INTERESSE) - {0} - data:{1} - movimento:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
                                                throw;
                                            }
                                        }

                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO DETTAGLIO INTERESSE) - {0} - data:{1} - dettaglio:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, dettaglio.ID, pag.ID, fileRitenuta.ID);
                                        throw;
                                    }
                                }
                            }
                            else
                            {
                                numeroRiga++;
                                var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
                                if (sottoContoInteressiSanzioni != null)
                                {
                                    var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, pag.RitenutaAcconto.ImportoInteressi.GetValueOrDefault(), "D")
                                    {
                                        SottoContoRiferimento = sottoContoInteressiSanzioni,
                                        FornitoreRiferimento = spesa.FornitoreRiferimento,
                                        Descrizione = "Interesse versamento ritenuta"
                                    };

                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                                }
                                else
                                {
                                    pag.RitenutaAcconto.ImportoInteressi = null;
                                }
                            }

                        }

                        // ------------------------------------------------
                        // Sanzione per Ravvedimento Operoso
                        // ------------------------------------------------
                        if (pag.RitenutaAcconto.ImportoSanzione > 0)
                        {
                            if (testataFattura != null && !testataFattura.AperturaBilancio)
                            {
                                var importo = spesa.Dettagli.SelectMany(item => item.Movimenti).Sum(item => item.Importo.GetValueOrDefault());
                                foreach (var dettaglio in spesa.Dettagli)
                                {
                                    try
                                    {
                                        foreach (var movimento in dettaglio.Movimenti)
                                        {
                                            try
                                            {
                                                var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                                if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                                    importoMovimento = importoMovimento * -1;

                                                var sanzioneCompetenza = pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault();
                                                if (spesa.ImportoLordo != 0)
                                                    sanzioneCompetenza = (pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault() * importoMovimento) / importo;
                                                else
                                                {
                                                    _log.WarnFormat("Trovata spesa con importo lordo a 0 - (SANZIONE) - {0} - spesa:{1} - data:{2} - movimento:{3} - pagamento:{4} - file ritenuta:{5}", Utility.GetMethodDescription(), spesa.ID, fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
                                                }

                                                var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, sanzioneCompetenza, "D")
                                                {
                                                    SottoContoRiferimento = movimento.SottoContoRiferimento,
                                                    FornitoreRiferimento = movimento.FornitoreRiferimento,
                                                    Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione()),
                                                    TipoInteresseSanzione = TipoInteresseSanzioneEnum.Sanzione,
                                                    PagamentoInteresseSanzione = pag
                                                };
                                                //"Sanzione ravv. operoso - " + movimento.GetDescrizione();
                                                _ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);

                                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);

                                            }
                                            catch (Exception ex)
                                            {
                                                _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO MOVIMENTO INTERESSE) - {0} - data:{1} - movimento:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, movimento.ID, pag.ID, fileRitenuta.ID);
                                                throw;
                                            }
                                        }
                                    }
                                    catch (Exception ex)
                                    {
                                        _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO DETTAGLIO RAVVEDIMENTO) - {0} - data:{1} - dettaglio:{2} - pagamento:{3} - file ritenuta:{4}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, dettaglio.ID, pag.ID, fileRitenuta.ID);
                                        throw;
                                    }
                                }
                            }
                            else
                            {
                                numeroRiga++;
                                var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
                                if (sottoContoInteressiSanzioni != null)
                                {
                                    var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, pag.RitenutaAcconto.ImportoSanzione, "D")
                                    {
                                        SottoContoRiferimento = sottoContoInteressiSanzioni,
                                        FornitoreRiferimento = spesa.FornitoreRiferimento,
                                        Descrizione = "Sanzione versamento ritenuta"
                                    };

                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                                }
                                else
                                {
                                    pag.RitenutaAcconto.ImportoSanzione = 0;
                                }
                            }
                        }

                        // ------------------------------------------------
                        // Ritenuta
                        // ------------------------------------------------
                        numeroRiga++;
                        var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta()), pag.RitenutaAcconto.Importo, "D")
                        {
                            FornitoreRiferimento = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
                            Descrizione = "Versamento Ritenuta " + pag.GetDescrizione()
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                        // ------------------------------------------------
                        // BANCA
                        // ------------------------------------------------
                        numeroRiga++;
                        var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoBancario()), pag.RitenutaAcconto.ImportoConInteressi + pag.RitenutaAcconto.ImportoSanzione.GetValueOrDefault(), "A")
                        {
                            FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
                            Descrizione = movimentoPatrimoniale.Descrizione,
                            ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale
                        };
                        _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);

                        pag.RitenutaAcconto.MovimentoContabilePagamento = movimentoBancario;

                        setMovimentoArrotondamento(testata, causale, null);
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato nella funzione - (SINGOLO PAGAMENTO) - {0} - data:{1} - pagamento:{2} - fileRitenuta:{3}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, pag.ID, fileRitenuta.ID);
                        throw;
                    }

                }
            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella funzione - {0} - data:{1} - fileRitenuta:{2}", ex, Utility.GetMethodDescription(), fileRitenuta.Data, fileRitenuta.ID);
                throw;
            }
        }
Esempio n. 30
0
        public MovimentoContabile SetMovimentiStornoPagamento(Pagamento pag, decimal importo, DateTime dataRegistrazione)
        {
            try
            {
                var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
                var message = IsAllowDataRegistrazione(new List<int> { pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
                if (message.Count == 0)
                {
                    var numeroRiga = 0;
                    var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("SS");

                    // ================================================
                    // Testata
                    // ================================================
                    var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null);
                    _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                    // ================================================
                    // Debiti VS Fornitori
                    // ================================================
                    numeroRiga++;

                    var segno = "A";
                    if (importo < 0)
                    {
                        segno = "D";
                        importo = importo * -1;
                    }

                    var movimentoPatrimoniale = new MovimentoContabile(testata, pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento, causale, numeroRiga,
                                                                       _daoFactory.GetContoDao().GetByCodice(pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.ID, 
                                                                       pag.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoFornitori()), importo, segno)
                    {
                        Descrizione = "Storno Fatt. n." + pag.ScadenzaRiferimento.SpesaRiferimento.NumeroDocumento + " del " + pag.ScadenzaRiferimento.SpesaRiferimento.DataDocumento.GetValueOrDefault().ToShortDateString()
                    };
                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                    // ================================================
                    // Conto Patrimoniale
                    // ================================================
                    numeroRiga++;

                    var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, pag.Conto, importo, invertiSegno(segno))
                    {
                        Descrizione = movimentoPatrimoniale.Descrizione,
                        FornitoreRiferimento = pag.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
                        SottoContoRiferimento = pag.SottoConto,
                        ContoCorrenteBancario = pag.ContoCorrenteBancario
                    };

                    pag.MovimentoContabileStorno = movimentoBancario;

                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);

                    return movimentoBancario;
                }

                var ex = new InvalidDataException(string.Format("La data di registrazione {0:d} non è valida", dataRegistrazione));

                _log.ErrorFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
                throw ex;

            }
            catch (Exception ex)
            {
                _log.ErrorFormat("Errore inaspettato nella funzione - {0} - data:{1} - pagamento:{2} - importo:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pag.ID, importo);
                throw;
            }
        }
Esempio n. 31
0
        public TestataMovimentoContabile SetMovimentiRitenuta(Pagamento pagamento, Ritenuta ritenuta, Conto contoPatrimoniale, int? idSottoConto, DateTime dataRegistrazione, string descrizione, string descrizioneAddebitoInteressi, string descrizioneAddebitoSanzioni, decimal? importo)
        {
            var esercizio = _daoFactory.GetEsercizioDao().GetEsercizioCompetenza(pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento, dataRegistrazione);
            if (esercizio == null || esercizio.Stato == StatoEsercizioEnum.Chiuso)
            {
                throw new InvalidDataException(string.Format("La data di registrazione {0:d} del versamento della ritenuta per {1:c} non è valida per il condominio:'{2}' perchè non è stato trovato un esercizio aperto di competenza", dataRegistrazione, ritenuta.Importo, pagamento.ScadenzaRiferimento.SpesaRiferimento.EsercizioRiferimento.CondominioRiferimento.DisplayName));
            }

            var message = IsAllowDataRegistrazione(new List<int> { esercizio.CondominioRiferimento.ID }, esercizio, dataRegistrazione);
            if (message.Count == 0)
            {
                var numeroRiga = 0;
                var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("VR");

                var importoRitenuta = ritenuta.Importo.GetValueOrDefault();
                if (importo != null)
                    importoRitenuta = importo.Value;
                importoRitenuta = Math.Round(importoRitenuta, 2);

                // ------------------------------------------------
                // Testata
                // ------------------------------------------------
                var testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, null) { SpesaRiferimento = pagamento.ScadenzaRiferimento.SpesaRiferimento };
                _daoFactory.GetTestataMovimentoContabileDao().SaveOrUpdate(testata);

                var contoRitenuta = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRitenuta());

                var spesa = pagamento.ScadenzaRiferimento.SpesaRiferimento;
                var firstDettaglio = spesa.Dettagli.FirstOrDefault();
                TestataMovimentoContabile testataFattura = null;
                if (firstDettaglio != null)
                {
                    var firstMovimento = firstDettaglio.Movimenti.FirstOrDefault();
                    if (firstMovimento != null)
                        testataFattura = firstMovimento.Testata;
                }

                // ------------------------------------------------
                // Interessi per Ravvedimento Operoso
                // ------------------------------------------------
                if (ritenuta.ImportoInteressi > 0)
                {
                    if (testataFattura != null && !testataFattura.AperturaBilancio)
                    {
                        foreach (var dettaglio in spesa.Dettagli)
                        {
                            if (dettaglio.Movimenti.Count > 0)
                            {

                                foreach (var movimento in dettaglio.Movimenti)
                                {
                                    var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                    if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                        importoMovimento = importoMovimento * -1;

                                    numeroRiga++;
                                    var interesseCompetenza = ritenuta.ImportoInteressi.GetValueOrDefault();
                                    if (spesa.ImportoLordo != 0)
                                        interesseCompetenza = (ritenuta.ImportoInteressi.GetValueOrDefault() * importoMovimento) / spesa.ImportoLordo;
                                    var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, movimento.ContoRiferimento, interesseCompetenza, "D")
                                    {
                                        SottoContoRiferimento = movimento.SottoContoRiferimento,
                                        FornitoreRiferimento = movimento.FornitoreRiferimento
                                    };

                                    if (!string.IsNullOrEmpty(descrizioneAddebitoInteressi))
                                        movimentoInteresse.Descrizione = descrizioneAddebitoInteressi.Replace("<DescrizioneSpesa>", movimento.GetDescrizione());

                                    _ripartizioneService.CloneRipartizioneByMovimento(movimentoInteresse, movimento);

                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                                }
                            }
                            else
                            {
                                numeroRiga++;
                                var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, ritenuta.ImportoInteressi, "D")
                                {
                                    FornitoreRiferimento = spesa.FornitoreRiferimento,
                                    Descrizione = "Interesse versamento ritenuta"
                                };

                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                            }

                        }                        
                    }
                    else
                    {
                        numeroRiga++;
                        var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
                        if (sottoContoInteressiSanzioni != null)
                        {
                            var movimentoInteresse = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, ritenuta.ImportoInteressi, "D")
                            {
                                SottoContoRiferimento = sottoContoInteressiSanzioni,
                                FornitoreRiferimento = spesa.FornitoreRiferimento,
                                Descrizione = "Interesse versamento ritenuta"
                            };

                            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoInteresse);
                        }
                        else
                        {
                            ritenuta.ImportoInteressi = 0;
                        }
                        
                    }

                }

                // ------------------------------------------------
                // Sanzione per Ravvedimento Operoso
                // ------------------------------------------------
                if (ritenuta.ImportoSanzione > 0)
                {
                    if (testataFattura != null && !testataFattura.AperturaBilancio)
                    {
                        foreach (var dettaglio in spesa.Dettagli)
                        {
                            if (dettaglio.Movimenti.Count > 0)
                            {

                                foreach (var movimento in dettaglio.Movimenti)
                                {
                                    var importoMovimento = movimento.GetImportoConSegno().GetValueOrDefault();
                                    if (movimento.ContoRiferimento.Tipo == TipoContoEconomicoEnum.Patrimoniale)
                                        importoMovimento = importoMovimento*-1;

                                    numeroRiga++;
                                    var sanzioneCompetenza = ritenuta.ImportoSanzione.GetValueOrDefault();
                                    if (spesa.ImportoLordo != 0)
                                        sanzioneCompetenza = (ritenuta.ImportoSanzione.GetValueOrDefault()*
                                                              importoMovimento)/spesa.ImportoLordo;
                                    var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga,
                                        movimento.ContoRiferimento, sanzioneCompetenza, "D")
                                    {
                                        SottoContoRiferimento = movimento.SottoContoRiferimento,
                                        FornitoreRiferimento = movimento.FornitoreRiferimento
                                    };

                                    if (!string.IsNullOrEmpty(descrizioneAddebitoSanzioni))
                                        movimentoSanzione.Descrizione = descrizioneAddebitoSanzioni.Replace("<DescrizioneSpesa>", movimento.GetDescrizione());

                                    _ripartizioneService.CloneRipartizioneByMovimento(movimentoSanzione, movimento);

                                    _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                                }
                            }
                            else
                            {
                                numeroRiga++;
                                var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, ritenuta.ImportoSanzione, "D")
                                {
                                    FornitoreRiferimento = spesa.FornitoreRiferimento,
                                    Descrizione = "Sanzione versamento ritenuta"
                                };

                                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                            }
                        }
                    }
                    else
                    {
                        numeroRiga++;
                        var sottoContoInteressiSanzioni = _daoFactory.GetSottoContoDao().GetInteressiSanzioniByEsercizio(testata.EsercizioRiferimento.ID, testata.EsercizioRiferimento.CondominioRiferimento.ID);
                        if (sottoContoInteressiSanzioni != null)
                        {
                            var movimentoSanzione = new MovimentoContabile(testata, causale, numeroRiga, sottoContoInteressiSanzioni.ContoRiferimento, ritenuta.ImportoSanzione, "D")
                            {
                                SottoContoRiferimento = sottoContoInteressiSanzioni,
                                FornitoreRiferimento = spesa.FornitoreRiferimento,
                                Descrizione = "Sanzione versamento ritenuta"
                            };

                            _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoSanzione);
                        }
                        else
                        {
                            ritenuta.ImportoSanzione = 0;
                        }
                    }
                }

                // ------------------------------------------------
                // Ritenuta
                // ------------------------------------------------
                numeroRiga++;
                var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoRitenuta, importoRitenuta, "D")
                {
                    FornitoreRiferimento = pagamento.ScadenzaRiferimento.SpesaRiferimento.FornitoreRiferimento,
                    Descrizione = "Ritenuta " + pagamento.GetDescrizione()
                };
                if (!string.IsNullOrEmpty(descrizione))
                    movimentoPatrimoniale.Descrizione += " - " + descrizione;
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoPatrimoniale);

                // ------------------------------------------------
                // Conto Patrimoniale
                // ------------------------------------------------
                numeroRiga++;

                var movimentoBancario = new MovimentoContabile(testata, causale, numeroRiga, contoPatrimoniale, importoRitenuta + ritenuta.ImportoInteressi.GetValueOrDefault() + ritenuta.ImportoSanzione.GetValueOrDefault(), "A")
                {
                    FornitoreRiferimento = movimentoPatrimoniale.FornitoreRiferimento,
                    Descrizione = movimentoPatrimoniale.Descrizione
                };
                _daoFactory.GetMovimentoContabileDao().SaveOrUpdate(movimentoBancario);

                if (idSottoConto != null)
                {
                    if (idSottoConto > 0)
                        movimentoBancario.SottoContoRiferimento = _daoFactory.GetSottoContoDao().GetById(idSottoConto.Value, false);
                    if (idSottoConto < 0)
                        movimentoBancario.ContoCorrenteBancario = _daoFactory.GetDatiBancariCondominiDao().GetById(idSottoConto.Value*-1, false);
                }

                if (contoPatrimoniale.Codice == _pianoContiService.GetCodiceContoBancario() &&
                    movimentoBancario.ContoCorrenteBancario == null)
                    movimentoBancario.ContoCorrenteBancario = esercizio.CondominioRiferimento.DatiBancariPrincipale;

                testata.Descrizione = movimentoPatrimoniale.Descrizione;
                ritenuta.MovimentoContabilePagamento = movimentoBancario;

                return testata;
            }

            var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", dataRegistrazione));
            
            _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - pagamento:{2} - conto:{3}", ex, Utility.GetMethodDescription(), dataRegistrazione, pagamento.ID, contoPatrimoniale.ID);
            throw ex;
        }
        private RavenJObject ReadDocumentData(string normalizedKey, Slice sliceKey, Etag existingEtag, RavenJObject metadata, out int size)
        {
            try
            {
                size = -1;

                var existingCachedDocument = documentCacher.GetCachedDocument(normalizedKey, existingEtag);
                if (existingCachedDocument != null)
                {
                    size = existingCachedDocument.Size;
                    return existingCachedDocument.Document;
                }

                var documentReadResult = tableStorage.Documents.Read(Snapshot, sliceKey, writeBatch.Value);
                if (documentReadResult == null) //non existing document
                    return null;

                using (var stream = documentReadResult.Reader.AsStream())
                {
                    using (var decodedDocumentStream = documentCodecs.Aggregate(stream,
                            (current, codec) => codec.Value.Decode(normalizedKey, metadata, current)))
                    {
                        var streamToUse = decodedDocumentStream;
                        if (stream != decodedDocumentStream)
                            streamToUse = new CountingStream(decodedDocumentStream);

                        var documentData = decodedDocumentStream.ToJObject();

                        size = (int)Math.Max(stream.Position, streamToUse.Position);
                        documentCacher.SetCachedDocument(normalizedKey, existingEtag, documentData, metadata, size);

                        return documentData;
                    }
                }
            }
            catch (Exception e)
            { 
                InvalidDataException invalidDataException = null;
                try
                {
                    size = -1;
                    var documentReadResult = tableStorage.Documents.Read(Snapshot, sliceKey, writeBatch.Value);
                    if (documentReadResult == null) //non existing document
                        return null;

                    using (var stream = documentReadResult.Reader.AsStream())
                    {
                        using (var reader = new BinaryReader(stream))
                        {
                            if (reader.ReadUInt32() == DocumentCompression.CompressFileMagic)
                            {
                                invalidDataException = new InvalidDataException(string.Format("Document '{0}' is compressed, but the compression bundle is not enabled.\r\n" +
                                                                                              "You have to enable the compression bundle when dealing with compressed documents.", normalizedKey), e);
                            }
                        }
                    }

            
                }
                catch (Exception)
                {
                    // we are already in error handling mode, just ignore this
                }
                if(invalidDataException != null)
                    throw invalidDataException;

                throw new InvalidDataException("Failed to de-serialize a document: " + normalizedKey, e);
            }
        }
Esempio n. 33
0
        public void SetMovimentiRichiamoRata(RataSoggetto rata, LogTransazione logTransazione)
        {
            // Movimenti Contabili: Non devono essere registrati movimenti contabili all'atto dell'annullamento di una rata bugid#6383
            return;
            var numeroRiga = 0;
            var causale = _daoFactory.GetCausaleContabileDao().GetByCodice("IR");

            // ------------------------------------------------
            // Testata
            // ------------------------------------------------
            var testata = new TestataMovimentoContabile(rata.Esercizio, DateTime.Today, TipoTestataMovimentoContabileEnum.Automatica, logTransazione);

            // controllo data registrazione
            var message = IsAllowDataRegistrazione(new List<int> { rata.Esercizio.CondominioRiferimento.ID }, rata.Esercizio, testata.DataRegistrazione.GetValueOrDefault());
            if (message.Count > 0)
            {
                var ex = new InvalidDataException(string.Format("La data di registrazione {0} non è valida", testata.DataRegistrazione.GetValueOrDefault()));
                _log.ErrorFormat("Data di registrazione non valida - {0} - testata:{1} - data:{2} - rata:{3}", ex, Utility.GetMethodDescription(), testata.ID, testata.DataRegistrazione.GetValueOrDefault(), rata.ID);
                throw ex;
            }

            // ------------------------------------------------
            // Crediti V/S Condomini - a Saldo
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini()), rata.Importo, "A")
            {
                CondominoRiferimento = rata.Soggetto,
                Descrizione = "Richiamo Rata n. " + rata.PianoRatealeDettaglio.Progressivo + " di " + rata.Soggetto.DisplayName + " - " + rata.MotivoRichiamo
            };

            // ------------------------------------------------
            // Storno rate condominiali
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, _daoFactory.GetContoDao().GetByCodice(rata.Esercizio.ID, rata.Esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoRateCondomini()), rata.Importo, "D")
            {
                CondominoRiferimento = rata.Soggetto,
                Descrizione = movimentoPatrimoniale.Descrizione
            };
        }
        void OnConnectionModeKnown(ListenerConnectionModeReader modeReader)
        {
            lock (ThisLock)
            {
                if (isDisposed)
                {
                    return;
                }

                connectionReaders.Remove(modeReader);
            }

            try
            {
                FramingMode framingMode = modeReader.GetConnectionMode();
                switch (framingMode)
                {
                    case FramingMode.Duplex:
                        OnDuplexConnection(modeReader);
                        break;
                    case FramingMode.Singleton:
                        OnSingletonConnection(modeReader);
                        break;
                    default:
                        {
                            Exception inner = new InvalidDataException(SR.GetString(
                                SR.FramingModeNotSupported, framingMode));
                            Exception exception = new ProtocolException(inner.Message, inner);
                            FramingEncodingString.AddFaultString(exception, FramingEncodingString.UnsupportedModeFault);
                            throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(exception);
                        }
                }
            }
            catch (ProtocolException exception)
            {
                DiagnosticUtility.TraceHandledException(exception, TraceEventType.Information);

                modeReader.Dispose();
            }
            catch (Exception exception)
            {
                if (Fx.IsFatal(exception))
                {
                    throw;
                }

                DiagnosticUtility.TraceHandledException(exception, TraceEventType.Error);

                // containment -- abort the errant reader
                modeReader.Dispose();
            }
        }
Esempio n. 35
0
        public IList<TestataMovimentoContabile> SetMovimentiVersamentoCondomino(TestataMovimentoContabile testata, MovimentoContabile movimentoPatrimonialeAttivo, Esercizio esercizio, VersamentoSoggetto versamento, DateTime dataRegistrazione, CausaleContabile causale, Conto contoVersamentoCondomini, int? idMovimentoBancario, FileCBI file, LogTransazione logTransazione)
        {
            var testate = new List<TestataMovimentoContabile>();
            if(causale == null)
                causale = _daoFactory.GetCausaleContabileDao().GetByCodice("RR");
            if (contoVersamentoCondomini == null)
                contoVersamentoCondomini = _daoFactory.GetContoDao().GetByCodice(esercizio.ID, esercizio.CondominioRiferimento.ID, _pianoContiService.GetCodiceContoVersamentiCondomini());
            bool evasioneBancaria = false;
            
            // ================================================================================
            //  Registrazione Movimenti Contabili per Versamento Condomino
            // ================================================================================
            var rateVersate = string.Empty;
            foreach (var versamentoRata in versamento.Rate)
            {
                if (!string.IsNullOrEmpty(rateVersate))
                    rateVersate += ", ";
                rateVersate += versamentoRata.Rata.PianoRatealeDettaglio.Progressivo;
            }
            if (!string.IsNullOrEmpty(rateVersate))
                rateVersate = "(" + rateVersate + ")";

            var descrizione = $"Versamento Rata di {versamento.Soggetto.DisplayName} {rateVersate}";
            
            // ------------------------------------------------
            // Testata
            // ------------------------------------------------
            if (testata == null)
            {
                testata = new TestataMovimentoContabile(esercizio, dataRegistrazione, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
                {
                    Descrizione = descrizione
                };
            }

            testate.Add(testata);
            var message = IsAllowDataRegistrazione(new List<int>(), testata.EsercizioRiferimento, testata.DataRegistrazione.GetValueOrDefault());
            if (message.Count > 0)
            {
                var ex = new InvalidDataException($"La data di registrazione {testata.DataRegistrazione.GetValueOrDefault()} non è valida");
                _log.FatalFormat("Data di registrazione non valida - {0} - data:{1} - versamento:{2} - message:{3}", ex, Utility.GetMethodDescription(), testata.DataRegistrazione.GetValueOrDefault(), versamento.ID, message.Aggregate(string.Empty, (current, str) => current + string.Format("{0}{1}", message, Environment.NewLine)));
                throw ex;
            }

            var numeroRiga = testata.Movimenti.Count;

            // ------------------------------------------------
            // Crediti V/S Condomini - a Saldo
            // ------------------------------------------------
            numeroRiga++;
            var movimentoPatrimoniale = new MovimentoContabile(testata, causale, numeroRiga, contoVersamentoCondomini, versamento.Importo, "A")
            {
                CondominoRiferimento = versamento.Soggetto, 
                Descrizione = descrizione
            };

            // ------------------------------------------------
            // Banca / Cassa
            // ------------------------------------------------
            if (movimentoPatrimonialeAttivo == null)
            {
                evasioneBancaria = true;
                numeroRiga++;
                movimentoPatrimonialeAttivo = new MovimentoContabile(testata, causale, numeroRiga, versamento.ContoPatrimoniale, versamento.Importo, "D")
                {
                    Descrizione = descrizione,
                    SottoContoRiferimento = versamento.SottoContoPatrimoniale,
                    ContoCorrenteBancario = versamento.ContoBancario,
                    NumeroAssegno = versamento.NumeroAssegno
                };
            }
            else
                movimentoPatrimonialeAttivo.Importo = movimentoPatrimonialeAttivo.GetImportoSenzaSegno() + versamento.Importo;

            // ================================================================================
            //  SOLO ESERCIZI ORDINARI
            //  Se la data di registrazione è successiva alla data di chiusura dell'esercizio
            //  registro i movimenti, usando un contro transitorio, che permette di rilevare
            //  il versamento nello stato patrimoniale dell'esercizio.
            // ================================================================================
            if (versamento.TipoVersamentoDopoChiusura.GetValueOrDefault() == TipoVersamentoDopoChiusuraEnum.Giroconto  && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
            {
                var esercizioPrecedente = esercizio.GetEsercizioPrecedente();
                if (esercizioPrecedente != null)
                {
                    var causaleVersamentiCondominiDopoChiusura = _daoFactory.GetCausaleContabileDao().GetByCodice("VS");
                    var contoVersamentiDopoChiusura = _pianoContiService.GetContoVersamentiSuccessiviAllaChiusura(esercizio);
                    try
                    {
                        if (movimentoPatrimoniale.CondominoRiferimento != null)
                        {
                            var descrizioneStorno = string.Format("Versamento dopo data chiusura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);

                            // ---------------------------------------------------------------------------------------
                            // Movimenti per storno e riconoscimento versamenti ai condomini
                            // Nuova testata nell'esercizio precedente per registrare lo storno
                            // ---------------------------------------------------------------------------------------
                            var numeroRigaStorno = 0;
                            var testataStorno = new TestataMovimentoContabile(esercizioPrecedente, esercizioPrecedente.DataChiusura, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
                            {
                                Descrizione = descrizioneStorno
                            };
                            testate.Add(testataStorno);

                            numeroRigaStorno++;
                            var movimentoVersamento = new MovimentoContabile(testataStorno, causaleVersamentiCondominiDopoChiusura, numeroRigaStorno, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
                            {
                                CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                Descrizione = descrizioneStorno
                            };

                            numeroRigaStorno++;
                            var movimentoContoTemporaneo = new MovimentoContabile(testataStorno, causaleVersamentiCondominiDopoChiusura, numeroRigaStorno, contoVersamentiDopoChiusura, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
                            {
                                CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                Descrizione = descrizioneStorno
                            };

                            // ---------------------------------------------------------------------------------------
                            // Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
                            // ---------------------------------------------------------------------------------------
                            numeroRiga++;
                            var descrizioneChiusuraStorno = string.Format("Chiusura dello storno del versamento dopo data chiusura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
                            var movimentoVersamentoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiDopoChiusura, numeroRiga, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
                            {
                                CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                Descrizione = descrizioneChiusuraStorno
                            };

                            numeroRiga++;
                            var movimentoContoTemporaneoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiDopoChiusura, numeroRiga, contoVersamentiDopoChiusura, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
                            {
                                CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                Descrizione = descrizioneChiusuraStorno
                            };
                            versamento.TestataMovimentoDopoChiusura = testataStorno;
                        }
                    }
                    catch (Exception ex)
                    {
                        _log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizio.ID, movimentoPatrimoniale.ID);
                        throw;
                    }
                }
                else
                {
                    _log.ErrorFormat("Esercizio precedente a null - {0} - versamento:{1} - esercizio:{2}", Utility.GetMethodDescription(), versamento.ID, esercizio.ID);
                }
            }

            // ================================================================================
            //  SOLO ESERCIZI ORDINARI - bugid#6223
            //  Se la data di registrazione è antecedente alla data di apertura dell'esercizio
            //  registro i movimenti, usando un contro transitorio, che permette di rilevare
            //  il versamento nello stato patrimoniale dell'esercizio.
            // ================================================================================
            if (versamento.TipoVersamentoPrimaApertura.GetValueOrDefault() == TipoVersamentoPrimaAperturaEnum.Giroconto && esercizio.Gestione == GestioneEsercizioEnum.Ordinario)
            {
                var annoSuccessivo = _daoFactory.GetAnnoGestionaleDao().GetAnnoSuccessivo(esercizio.AnnoGestionale.ID);
                if (annoSuccessivo != null)
                {
                    if (annoSuccessivo.EsercizioOrdinario != null)
                    {
                        var causaleVersamentiCondominiPrimaApertura = _daoFactory.GetCausaleContabileDao().GetByCodice("VA");
                        var contoVersamentiPrecedentiAllaApertura = _pianoContiService.GetContoVersamentiPrecedentiAllaApertura(esercizio);
                        try
                        {
                            if (movimentoPatrimoniale.CondominoRiferimento != null)
                            {
                                var descrizioneStorno = string.Format("Versamento prima della data di apertura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);

                                // ---------------------------------------------------------------------------------------
                                // Movimenti per storno e riconoscimento versamenti ai condomini
                                // Nuova testata nell'esercizio successivo per registrare lo storno
                                // ---------------------------------------------------------------------------------------
                                var numeroRigaStorno = 0;
                                var testataStorno = new TestataMovimentoContabile(annoSuccessivo.EsercizioOrdinario, annoSuccessivo.EsercizioOrdinario.DataApertura, TipoTestataMovimentoContabileEnum.Automatica, file, logTransazione)
                                {
                                    Descrizione = descrizioneStorno
                                };
                                testate.Add(testataStorno);

                                numeroRigaStorno++;
                                var movimentoVersamento = new MovimentoContabile(testataStorno, causaleVersamentiCondominiPrimaApertura, numeroRigaStorno, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
                                {
                                    CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                    Descrizione = descrizioneStorno
                                };

                                numeroRigaStorno++;
                                var movimentoContoTemporaneo = new MovimentoContabile(testataStorno, causaleVersamentiCondominiPrimaApertura, numeroRigaStorno, contoVersamentiPrecedentiAllaApertura, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
                                {
                                    CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                    Descrizione = descrizioneStorno
                                };

                                // ---------------------------------------------------------------------------------------
                                // Nella stessa testata del versamento originale aggiungo il movimento di chiusura del conto temporaneo
                                // ---------------------------------------------------------------------------------------
                                numeroRiga++;
                                var descrizioneChiusuraStorno = string.Format("Chiusura dello storno del versamento prima della data di apertura - {0} del {1} {2}", movimentoPatrimoniale.CondominoRiferimento.DisplayName, movimentoPatrimoniale.Testata.DataRegistrazione.GetValueOrDefault().ToShortDateString(), rateVersate);
                                var movimentoVersamentoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiPrimaApertura, numeroRiga, movimentoPatrimoniale.ContoRiferimento, movimentoPatrimoniale.Importo, invertiSegno(movimentoPatrimoniale.Segno))
                                {
                                    CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                    Descrizione = descrizioneChiusuraStorno
                                };

                                numeroRiga++;
                                var movimentoContoTemporaneoChiusura = new MovimentoContabile(testata, causaleVersamentiCondominiPrimaApertura, numeroRiga, contoVersamentiPrecedentiAllaApertura, movimentoPatrimoniale.Importo, movimentoPatrimoniale.Segno)
                                {
                                    CondominoRiferimento = movimentoPatrimoniale.CondominoRiferimento,
                                    Descrizione = descrizioneChiusuraStorno
                                };
                                versamento.TestataMovimentoDopoChiusura = testataStorno;
                            }
                        }
                        catch (Exception ex)
                        {
                            _log.ErrorFormat("Errore inaspettato durante la registrazione dei movimenti per i versamenti eseguiti dopo la chiusura - SINGOLO MOVIMENTO - {0} - esercizio:{1} - movimento:{2}", ex, Utility.GetMethodDescription(), esercizio.ID, movimentoPatrimoniale.ID);
                            throw;
                        }                        
    
                    }
                }
                else
                {
                    _log.ErrorFormat("Esercizio successivo a null - {0} - versamento:{1} - esercizio:{2}", Utility.GetMethodDescription(), versamento.ID, esercizio.ID);
                }
            }

            // ================================================================================
            //  Evado il corrispondente Movimento Bancario
            // ================================================================================
            if (evasioneBancaria && idMovimentoBancario != null)
            {
                EvadiMovimento(string.Format("Evasione automatica per contabilizzazione versamento condomino del {0}", dataRegistrazione.ToShortDateString()), new List<MovimentoContabile> { movimentoPatrimonialeAttivo }, new List<int> { idMovimentoBancario.Value }, dataRegistrazione, logTransazione);
                _log.DebugFormat("Evasione automatica per contabilizzazione versamento condomino - {0} - movimento economico:{1} - movimento bancario:{2} - data registrazione:{3}", Utility.GetMethodDescription(), movimentoPatrimoniale.ID, idMovimentoBancario.GetValueOrDefault(), dataRegistrazione);
            }
            versamento.MovimentoContabilePatrimoniale = movimentoPatrimonialeAttivo;

            return testate;
        }