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);
}
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);
}
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);
}
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);
}
/// <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);
}
}
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;
}
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;
}
}
public static void DefaultConstructor()
{
InvalidDataException ide = new InvalidDataException();
Assert.NotNull(ide.Message);
}
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;
}
}
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;
}
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;
}
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;
}
}
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;
}
}
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;
}
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;
}
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;
}
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;
}
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;
}
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;
}
}
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;
}
}
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;
}
}
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;
}
}
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;
}
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;
}
}
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;
}
}
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);
}
}
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();
}
}
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;
}
