public ControllerLog()
: base(enAmbiente.LogViewList, enAmbiente.LogViewList)
{
sub1 = EventAggregator.Instance().Subscribe <Remove <EventLog> >(
(b) =>
{
using (var saveEntity = new SaveEntityManager())
{
var uof = saveEntity.UnitOfWork;
var item = ((EventLog)SelectedItem);
var sel = uof.EventLogRepository.Find(a => a.ID == item.ID).FirstOrDefault();
if (sel == null)
{
EventAggregator.Instance().Publish <UpdateList <EventLog> >(new UpdateList <EventLog>(this));
return;
}
uof.EventLogRepository.Delete(sel);
if (saveEntity.SaveEntity(operation: enSaveOperation.OpDelete))
{
EventAggregator.Instance().Publish <UpdateList <EventLog> >(new UpdateList <EventLog>(this));
}
}
}
);
}
private void SaveArticolo(object arg)
{
try
{
using (var save = new SaveEntityManager())
{
var uof = save.UnitOfWork;
if (EditItem.ID <= 0 ||
uof.ArticoliRepository.Find(a => a.ID == EditItem.ID).Count() == 0)
{
uof.ArticoliRepository.Add(EditItem);
}
else
{
EditItem.Categoria = null;
uof.ArticoliRepository.Update(EditItem);
}
if (
save.SaveEntity(enSaveOperation.OpSave))
{
EventAggregator.Instance().Publish <UpdateList <Articolo> >(new UpdateList <Articolo>(this));
}
}
}
catch (MessageException ex)
{
ExceptionManager.ManageError(ex);
}
catch (Exception ex)
{
ExceptionManager.ManageError(ex);
}
}
private void Save(Save <ListinoPrezziFornitori> obj)
{
using (var saveManager = new SaveEntityManager())
{
SelectedItem.ArticoloID = _controllerMaster.EditItem.ID;
if (_controllerMaster.EditItem.ID == 0)
{
return;
}
var uof = saveManager.UnitOfWork;
if (SelectedItem.ID > 0)
{
uof.ListinoPrezziFornitoriRepository.Update(SelectedItem);
}
else
{
if (uof.ListinoPrezziFornitoriRepository.Find(a => a.ArticoloID == SelectedItem.ArticoloID && a.FornitoreID == SelectedItem.FornitoreID)
.Count() > 0)
{
MessageManager.NotificaWarnig("Esiste già l''associazione articolo fornitore!");
return;
}
uof.ListinoPrezziFornitoriRepository.Add(SelectedItem);
}
if (saveManager.SaveEntity(enSaveOperation.OpSave))
{
RiselezionaSelezionato();
}
}
}
private void Save(Save <Fattura> obj)
{
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
EditItem.Data = EditItem.Data.Date;
if (EditItem.ID > 0)
{
if (saveManager.UnitOfWork.FatturaRepository.Find(a => a.ID == EditItem.ID).Select(a => a.ChiusaSpedita).First())
{
MessageManager.NotificaWarnig("Documento già chiuso, non è possibile modificare altro!");
return;
}
EditItem = CalcolaTotali(EditItem);
uof.FatturaRepository.Update(EditItem);
}
else
{
uof.FatturaRepository.Add(EditItem);
}
if (saveManager.SaveEntity(enSaveOperation.OpSave))
{
EventAggregator.Instance().Publish <UpdateList <Fattura> >(
new UpdateList <Fattura>(this));
}
}
}
private void DelFattura(Remove <Fattura> obj)
{
try
{
if (!MessageManager.QuestionMessage("Sei sicuro di voler cancellare il documento selezionato?"))
{
return;
}
using (var saveEntity = new SaveEntityManager())
{
var uof = saveEntity.UnitOfWork;
int val = ((Fattura)SelectedItem).ID;
var item = uof.FatturaRepository.Find(a => a.ID == val).FirstOrDefault();
_logger.Info(string.Format("Cancellazione documento/r/n codice {0} /r/n ID {1}",
item.Codice, item.ID));
foreach (var itemRiga in uof.FattureRigheRepository.Find(a => a.FatturaID == val))
{
uof.FattureRigheRepository.Delete(itemRiga);
}
uof.FatturaRepository.Delete(item);
if (saveEntity.SaveEntity(enSaveOperation.OpDelete))
{
EventAggregator.Instance().Publish <UpdateList <Fattura> >(
new UpdateList <Fattura>(this));
}
}
}
catch (Exception ex)
{
ExceptionManager.ManageError(ex);
}
}
private void Sconta(ArticoloSconta obj)
{
if (!MessageManager.QuestionMessage(string.Format(@"Sei sicuro di volere applicare questo sconto su tutti i {0} articoli visualizzati nella lista?", DataSource.Count())))
{
return;
}
if (DataSource.Count() > 100)
{
if (!MessageManager.QuestionMessage(string.Format(@"Sei veramente sicuro di volere applicare questo sconto su tutti i {0} articoli visualizzati nella lista?", DataSource.Count())))
{
return;
}
}
_logger.Info("Applicato sconto su marca {0} e filtro ricerca {1} di {2} %. ", FiltroMarca, this.TestoRicerca, obj.Percentuale);
using (var saveEnt = new SaveEntityManager())
{
var list = DataSource.Select(a => a.ID).ToList();
foreach (var item in saveEnt.UnitOfWork.ArticoliRepository.Find(a => list.Contains(a.ID)).ToList())
{
item.Prezzo += item.Prezzo * obj.Percentuale / (decimal)100;
_logger.Info("Applicato sconto su articolo codice {0}, nuovo prezzo ", item.ID, item.Prezzo.ToString("C2"));
saveEnt.UnitOfWork.ArticoliRepository.Update(item);
}
if (saveEnt.SaveEntity("Variazione applicata con successo"))
{
EventAggregator.Instance().Publish <UpdateList <Articolo> >(new UpdateList <Articolo>(this));
}
}
}
private void Save(Save <FatturaRiga> obj)
{
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
EditItem.Fattura = null;
EditItem.FatturaID = _controllerFatturazione.EditItem.ID;
if (_controllerFatturazione.EditItem.ID == 0)
{
return;
}
if (saveManager.UnitOfWork.FatturaRepository.Find(a => a.ID == EditItem.FatturaID).Select(a => a.ChiusaSpedita).First())
{
MessageManager.NotificaWarnig("Documento già chiuso, non è possibile modificare altro!");
return;
}
if (EditItem.ID > 0)
{
uof.FattureRigheRepository.Update(EditItem);
}
else
{
uof.FattureRigheRepository.Add(EditItem);
}
if (saveManager.SaveEntity(enSaveOperation.OpSave))
{
AggiornaTotaliFattura();
RiselezionaSelezionato();
}
}
}
private void ImageRemoveSet(ImageRemove <PagamentoDocumenti> obj)
{
if (obj.GuidKey == this._INSTANCE_KEY)
{
if (!SettingDocumentiPagamentiValidator.CheckFolderPdfPagamenti())
{
return;
}
var folderPagamenti = SettingDocumentiPagamentiValidator.ReadSetting().CartellaReteDocumentiPagamenti;
using (var saveManager = new SaveEntityManager())
{
var repo = saveManager.UnitOfWork.PagamentoDocumentiRepository;
var filePdf = obj.File.Entity;
var nomeFile = Path.Combine(folderPagamenti, filePdf.PathFile);
File.Delete(nomeFile);
var item = repo.Find(a => a.ID == filePdf.ID).First();
repo.Delete(item);
saveManager.SaveEntity("Rimossa immagine");
}
EventAggregator.Instance().Publish <ImageListUpdate>(new ImageListUpdate());
}
}
private void SavePreordine_Click(object sender, EventArgs e)
{
using (var saveEnt = new SaveEntityManager())
{
bool save = false;
foreach (var item in DataSource.Where(a => a.ToSave == true))
{
var listino = saveEnt.UnitOfWork.ListinoPrezziFornitoriRepository.Find(a => a.ID == item.ID).FirstOrDefault();
var preOrdAcq = saveEnt.UnitOfWork.PreOrdineAcquistoRepository.Find(a => a.FornitoreID == listino.FornitoreID && a.ArticoloID == listino.ArticoloID).FirstOrDefault();
if (preOrdAcq == null)
{
preOrdAcq = new PreOrdineAcquisto();
preOrdAcq.ArticoloID = listino.ArticoloID;
preOrdAcq.FornitoreID = listino.FornitoreID;
}
save = true;
preOrdAcq.QtaDaOrdinare = item.QtaDaOrdinare;
if (preOrdAcq.ID <= 0)
{
saveEnt.UnitOfWork.PreOrdineAcquistoRepository.Add(preOrdAcq);
}
else
{
saveEnt.UnitOfWork.PreOrdineAcquistoRepository.Update(preOrdAcq);
}
}
if (save)
{
saveEnt.SaveEntity(enSaveOperation.OpSave);
EventAggregator.Instance().Publish <UpdateList <ListinoPrezziFornitori> >(new UpdateList <ListinoPrezziFornitori>(this));
}
}
}
/// <summary>
/// Unisce gli articoli in quello selezionato nella prima form
/// </summary>
/// <param name="artToMerge"></param>
private void MergeArticoli(Articolo artToMerge)
{
using (var save = new SaveEntityManager(true))
{
var elem = save.UnitOfWork.ArticoliRepository.Find(a => a.ID == this.SelectedItem.ID ||
a.ID == artToMerge.ID).ToList();
var baseItem = elem.Where(a => a.ID == this.SelectedItem.ID).First();
elem.Remove(baseItem);
var secondItem = elem.First();
var list = UtilityProp.GetProperties(baseItem);
/*escludo le proprieta del oggetto entita base
*/
MergeObjects(baseItem, secondItem);
if (baseItem.Condizione == enCondizioneArticolo.NonSpecificato)
{
baseItem.Condizione = secondItem.Condizione;
}
save.UnitOfWork.ArticoliRepository.Update(baseItem);
var fotoArt2 = save.UnitOfWork.FotoArticoloRepository.Find(a => a.ArticoloID == secondItem.ID).ToList();
if (fotoArt2.Count() > 0)
{
MessageManager.NotificaInfo("Sposto le eventuali foto da un articolo all'altro");
foreach (var item in fotoArt2)
{
/*sostituisco l'articolo*/
item.ArticoloID = baseItem.ID;
save.UnitOfWork.FotoArticoloRepository.Update(item);
}
}
else
{
MessageManager.NotificaInfo("Non ci sono foto");
}
var aggList = save.UnitOfWork.AggiornamentoWebArticoloRepository.Find(a => a.ArticoloID == baseItem.ID ||
a.ArticoloID == secondItem.ID).ToList();
var baseAgg = aggList.Where(a => a.ArticoloID == baseItem.ID).First();
var secondAgg = aggList.Where(a => a.ArticoloID != baseItem.ID).First();
if (string.IsNullOrEmpty(baseAgg.CodiceArticoloEcommerce))
{
/*scambio l'eventuale codice dell'articolo nell'ecommerce*/
baseAgg.CodiceArticoloEcommerce = secondAgg.CodiceArticoloEcommerce;
secondAgg.CodiceArticoloEcommerce = "";
save.UnitOfWork.AggiornamentoWebArticoloRepository.Update(baseAgg);
save.UnitOfWork.AggiornamentoWebArticoloRepository.Update(secondAgg);
}
save.SaveEntity(enSaveOperation.Unione);
MessageManager.NotificaInfo("Le eventuali giacenze vanno spostate manualmente");
}
}
public ControllerRigheFatture(ControllerFatturazione controllerFatturazione)
: base(enAmbiente.FattureRigheList, enAmbiente.FattureRigheDett)
{
_controllerFatturazione = controllerFatturazione;
TipoDocFattura = _controllerFatturazione.EditItem.TipoDocumento;
SelectedItem = new FatturaRiga();
_removePrio = EventAggregator.Instance().Subscribe <AddPriority <FatturaRiga> >((a) => { CambiaPriorita(true); });;
_addPrio = EventAggregator.Instance().Subscribe <RemovePriority <FatturaRiga> >((a) => { CambiaPriorita(false); });;
EventAggregator.Instance().Subscribe <Save <FatturaRiga> >((a) =>
{
});
_selectSub = EventAggregator.Instance().Subscribe <Add <FatturaRiga> >((a) =>
{
EditItem = new FatturaRiga()
{
IvaApplicata = "22", Fattura = _controllerFatturazione.EditItem
};
ShowEditView();
});
_subRemove = EventAggregator.Instance().Subscribe <Remove <FatturaRiga> >((x) =>
{
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
var curItem = (FatturaRiga)SelectedItem;
if (curItem != null && curItem.ID > 0)
{
if (!MessageManager.QuestionMessage("Sei sicuro di volere eliminare la riga selezionata?"))
{
return;
}
if (saveManager.UnitOfWork.FatturaRepository.Find(a => a.ID == curItem.FatturaID).First().ChiusaSpedita)
{
MessageManager.NotificaWarnig("Documento già chiuso, non è possibile modificare altro!");
return;
}
var item = uof.FattureRigheRepository.Find(b => b.ID == curItem.ID).First();
uof.FattureRigheRepository.Delete(item);
if (saveManager.SaveEntity(enSaveOperation.OpDelete))
{
AggiornaTotaliFattura();
EventAggregator.Instance().Publish <UpdateList <FatturaRiga> >(new UpdateList <FatturaRiga>(this));
}
}
}
});
_subSave = EventAggregator.Instance().Subscribe <Save <FatturaRiga> >((a) =>
{
Save(null);
});
}
public ControllerListinoPrezziNomi(bool gestioneInline)
: base(enAmbiente.NomeListiniClientiList, enAmbiente.NomeListiniClienti, gestioneInline)
{
SelectedItem = new ListinoPrezziVenditaNome();
_selectSub = EventAggregator.Instance().Subscribe <Add <ListinoPrezziVenditaNome> >((a) =>
{
EditItem = new ListinoPrezziVenditaNome();
ShowEditView();
});
_subRemove = EventAggregator.Instance().Subscribe <Remove <ListinoPrezziVenditaNome> >((a) =>
{
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
var curItem = SelectedItem;
if (curItem != null && curItem.ID > 0)
{
if (!MessageManager.QuestionMessage("Sei sicuro di volere eliminare la riga selezionata?"))
{
return;
}
var item = uof.ListinoPrezziVenditaNomeRepository.Find(b => b.ID == curItem.ID).First();
uof.ListinoPrezziVenditaNomeRepository.Delete(item);
if (saveManager.SaveEntity(enSaveOperation.OpDelete))
{
EventAggregator.Instance().Publish(new UpdateList <ListinoPrezziVenditaNome>(this));
}
}
}
});
_subSave = EventAggregator.Instance().Subscribe <Save <ListinoPrezziVenditaNome> >((a) =>
{
EventAggregator.Instance().Publish(new ValidateViewEvent <ListinoPrezziVenditaNome>());
Save(null);
});
EventAggregator.Instance().Subscribe <UpdateList <ListinoPrezziVenditaNome> >((a) =>
{
RefreshList(a);
});
EventAggregator.Instance().Subscribe <ItemSelected <ListinoPrezziVenditaNomeItem, ListinoPrezziVenditaNome> >((a) =>
{
if (a.ItemSelected != null)
{
SelectedItem = a.ItemSelected.Entity;
}
else
{
SelectedItem = null;
}
});
}
public ControllerCategorie()
: base(enAmbiente.CategorieArticoliList, enAmbiente.CategorieArticoliDett, false)
{
SelectedItem = new Categoria();
_selectSub = EventAggregator.Instance().Subscribe <Add <Categoria> >((a) =>
{
EditItem = new Categoria();
ShowEditView();
});
_subRemove = EventAggregator.Instance().Subscribe <Remove <Categoria> >((a) =>
{
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
var curItem = SelectedItem;
if (curItem != null && curItem.ID > 0)
{
if (!MessageManager.QuestionMessage("Sei sicuro di volere eliminare la riga selezionata?"))
{
return;
}
var item = uof.CategorieRepository.Find(b => b.ID == curItem.ID).First();
uof.CategorieRepository.Delete(item);
if (saveManager.SaveEntity(enSaveOperation.OpDelete))
{
EventAggregator.Instance().Publish(new UpdateList <Categoria>(this));
}
}
}
});
_subSave = EventAggregator.Instance().Subscribe <Save <Categoria> >((a) =>
{
EventAggregator.Instance().Publish(new ValidateViewEvent <Categoria>());
Save(null);
});
EventAggregator.Instance().Subscribe <UpdateList <Categoria> >((a) =>
{
RefreshList(a);
});
EventAggregator.Instance().Subscribe <ItemSelected <CategoriaItem, Categoria> >((a) =>
{
if (a.ItemSelected != null)
{
SelectedItem = a.ItemSelected.Entity;
}
else
{
SelectedItem = null;
}
});
}
//public void ImportaCsvArticoli()
//{
// try
// {
// using (OpenFileDialog res = new OpenFileDialog())
// {
// res.Title = "Seleziona file da importare";
// //Filter
// res.Filter = "File csv|*.csv;";
// //When the user select the file
// if (res.ShowDialog() == DialogResult.OK)
// {
// //Get the file's path
// var fileName = res.FileName;
// using (var curs = new CursorManager())
// {
// using (StreamReader sr = new StreamReader(fileName, Encoding.Default, true))
// {
// String line;
// bool firstLine = true;
// int progress = 1;
// // Read and display lines from the file until the end of
// // the file is reached.
// using (var uof = new UnitOfWork())
// {
// while ((line = sr.ReadLine()) != null)
// {
// if (!firstLine)
// {
// progress = ImportLine(line, progress, uof);
// }
// firstLine = false;
// }
// uof.Commit();
// }
// }
// }
// EventAggregator.Instance().Publish<UpdateList<Articolo>>(new UpdateList<Articolo>(this));
// MessageManager.NotificaInfo("Terminata importazione articoli");
// }
// }
// }
// catch (Exception ex)
// {
// ExceptionManager.ManageError(ex);
// }
//}
//private int ImportLine(string line, int progress, UnitOfWork uof)
//{
// var dat = line.Split('§');
// var cond = enCondizioneArticolo.Nuovo;
// if (dat[2] == "N")
// {
// cond = enCondizioneArticolo.Nuovo;
// }
// else if (dat[2] == "U")
// {
// cond = enCondizioneArticolo.UsatoGarantito;
// }
// else if (dat[2] == "E")
// {
// cond = enCondizioneArticolo.ExDemo;
// }
// else
// {
// throw new Exception("Tipo dato non gestito o mancante nella condizione articolo.");
// }
// decimal prezzo = 0;
// decimal prezzoBarrato = 0;
// bool prezzoARichiesta = false;
// var strPrezzo = dat[6];
// if (strPrezzo == "NC")
// {
// prezzoARichiesta = true;
// }
// else if (strPrezzo.Contains(";"))
// {
// prezzo = decimal.Parse(strPrezzo.Split(';')[0]);
// }
// else
// {
// if (strPrezzo.Trim().Length > 0)
// {
// prezzo = decimal.Parse(strPrezzo);
// }
// }
// var artNew = (new Articolo()
// {
// CategoriaID = int.Parse(dat[1]),
// Condizione = cond,
// Titolo = dat[4],
// Testo = dat[5].Replace("<br>", Environment.NewLine),
// Prezzo = prezzo,
// });
// artNew.Strumento.Marca = dat[3];
// uof.ArticoliRepository.Add(artNew);
// var foto = dat[7];
// if (foto.Length > 0)
// {
// int ordine = 0;
// foreach (var item in foto.Split(';'))
// {
// var artFoto = new FotoArticolo()
// {
// Articolo = artNew,
// UrlFoto = item,
// Ordine = ordine
// };
// ordine++;
// uof.FotoArticoloRepository.Add(artFoto);
// }
// }
// return progress;
//}
private void DeleteArticolo(object obj)
{
try
{
if (!MessageManager.QuestionMessage("Sei sicuro di voler cancellare l'articolo selezionato?"))
{
return;
}
using (var save = new SaveEntityManager())
{
using (var immaginiController = new ControllerImmagini())
{
var item = save.UnitOfWork.ArticoliRepository.Find(a => a.ID ==
this.SelectedItem.ID).FirstOrDefault();
_logger.Info(string.Format("Cancellazione articolo /r/n{0} /r/n{1}", item.Titolo, item.ID));
if (!immaginiController.CheckFolderImmagini())
{
return;
}
var folderFoto = SettingSitoValidator.ReadSetting().CartellaLocaleImmagini;
var listFile = new List <string>();
foreach (var itemFoto in save.UnitOfWork.FotoArticoloRepository.Find(a => a.ArticoloID == item.ID))
{
immaginiController.RimuoviItemDaRepo(
folderFoto, listFile, save.UnitOfWork, itemFoto);
}
immaginiController.DeleteFile(listFile);
var mag = save.UnitOfWork.MagazzinoRepository.Find(a => a.ArticoloID == item.ID);
foreach (Magazzino itemMg in mag)
{
save.UnitOfWork.MagazzinoRepository.Delete(itemMg);
}
foreach (var itemAgg in save.UnitOfWork.AggiornamentoWebArticoloRepository.Find(a => a.ArticoloID == item.ID))
{
save.UnitOfWork.AggiornamentoWebArticoloRepository.Delete(itemAgg);
}
save.UnitOfWork.ArticoliRepository.Delete(item);
if (save.SaveEntity(enSaveOperation.OpDelete))
{
EventAggregator.Instance().Publish <UpdateList <Articolo> >(new UpdateList <Articolo>(this));
}
}
}
}
catch (Exception ex)
{
ExceptionManager.ManageError(ex);
}
}
public static bool AddImageFiles(ImageArticoloAddFiles args)
{
if (!CheckFolderImmagini())
{
return(false);
}
try
{
var folderFoto = SettingSitoValidator.ReadSetting().CartellaLocaleImmagini;
using (var save = new SaveEntityManager())
{
var uof = save.UnitOfWork;
var maxOrdineItem = uof.FotoArticoloRepository
.Find(a => a.ArticoloID == args.Articolo.ID)
.OrderByDescending(a => a.Ordine).FirstOrDefault();
var maxOrdine = 0;
if (maxOrdineItem != null)
{
maxOrdine = maxOrdineItem.Ordine + 1;
}
foreach (var item in args.Files)
{
var file = new FileInfo(item);
var newName = DateTime.Now.Ticks.ToString() + file.Extension;
File.Copy(item, Path.Combine(folderFoto, newName));
uof.FotoArticoloRepository.Add(
new FotoArticolo()
{
ArticoloID = args.Articolo.ID,
UrlFoto = newName,
Ordine = maxOrdine
});
maxOrdine++;
}
if (save.SaveEntity(string.Format(@"{0} Immagine\i aggiunta\e", args.Files.Count())))
{
EventAggregator.Instance().Publish <ImageListUpdate>(new ImageListUpdate());
return(true);
}
}
}
catch (Exception ex)
{
ExceptionManager.ManageError(ex);
}
return(false);
}
private void Save(Save <Pagamento> obj)
{
Pagamento nuovoPagamento = null;
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
if (((EditItem).ID > 0))
{
uof.PagamentoRepository.Update(EditItem);
}
else
{
if (EditItem.ID == 0)
{
Guid guid = Guid.NewGuid();
var importoRata = EditItem.ImportoTotale / (decimal)EditItem.NumeroRate;
foreach (var item in Enumerable.Range(1, EditItem.NumeroRate))
{
var pagamento = (Pagamento)EditItem.Clone();
{
pagamento.IDPagamentoMaster = guid;
pagamento.ImportoRata = importoRata;
pagamento.DataRata = EditItem.DataInizio.AddMonths(item);
pagamento.ImportoResiduo =
EditItem.ImportoTotale - (importoRata * item);
};
uof.PagamentoRepository.Add(pagamento);
if (nuovoPagamento == null)
{
nuovoPagamento = pagamento;
}
}
}
}
if (saveManager.SaveEntity(enSaveOperation.OpSave))
{
RiselezionaSelezionato();
if (nuovoPagamento != null)
{
EventAggregator.Instance().Publish <ForceCloseActiveFormView>(new ForceCloseActiveFormView());
}
}
}
}
public ControllerUtenti()
: base(enAmbiente.UtentiList, enAmbiente.Utente)
{
SelectedItem = new Utente();
_selectSub = EventAggregator.Instance().Subscribe <Add <Utente> >((a) =>
{
EditItem = new Utente()
{
NomeUtente = "Nome utente"
};
ShowEditView();
});
_subRemove = EventAggregator.Instance().Subscribe <Remove <Utente> >((a) =>
{
if (!MessageManager.QuestionMessage("Sei sicuro di volere eliminare la riga selezionata?"))
{
return;
}
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
var curItem = (Utente)SelectedItem;
if (curItem.ID > 0)
{
try
{
var item = uof.UtentiRepository.Find(b => b.ID == curItem.ID).First();
uof.UtentiRepository.Delete(item);
if (saveManager.SaveEntity(enSaveOperation.OpDelete))
{
EventAggregator.Instance().Publish <UpdateList <Utente> >(new UpdateList <Utente>(this));
}
}
catch (Exception ex)
{
ExceptionManager.ManageError(ex);
}
}
}
});
_subSave = EventAggregator.Instance().Subscribe <Save <Utente> >((a) =>
{
Save(null);
});
}
private void ApriSettingMittenteFattura()
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
var setItem = unitOfWork.DatiMittenteRepository.Find(a => 1 == 1).FirstOrDefault();
if (setItem == null)
{
setItem = new DatiMittente();
setItem.ID = 1;
unitOfWork.DatiMittenteRepository.Add(setItem);
unitOfWork.Commit();
}
if (setItem.UfficioRegistroImp == null)
{
setItem.UfficioRegistroImp = new DatiMittente.UfficioRegistro();
}
if (setItem.Indirizzo == null)
{
setItem.Indirizzo = new Library.Entity.Indirizzo();
}
if (setItem.PecConfig == null)
{
setItem.PecConfig = new Library.Entity.PecConfig();
}
var view = new GenericSettingView(setItem);
{
view.OnSave += (a, b) =>
{
using (var cur = new CursorManager())
{
view.Validate();
using (var save = new SaveEntityManager())
{
save.UnitOfWork.DatiMittenteRepository.Update(setItem);
save.SaveEntity(enSaveOperation.OpSave);
}
}
};
this.ShowView(view, enAmbiente.SettingFatture);
}
}
}
private void AddImageFiles(ImageAddFiles obj)
{
if (obj.GuidKey == this._INSTANCE_KEY)
{
if (!SettingDocumentiPagamentiValidator.CheckFolderPdfPagamenti())
{
return;
}
var folderPagamenti = SettingDocumentiPagamentiValidator.ReadSetting().CartellaReteDocumentiPagamenti;
using (var saveManager = new SaveEntityManager())
{
var repo = saveManager.UnitOfWork.PagamentoDocumentiRepository;
foreach (var item in obj.Files)
{
var filePdf = item;
var info = new FileInfo(filePdf);
var nomeFile = info.Name;
var dir = Path.Combine(folderPagamenti, this._IDPagamentoMaster.ToString());
if (!Directory.Exists(dir))
{
Directory.CreateDirectory(dir);
}
File.Copy(filePdf, Path.Combine(dir, nomeFile));
repo.Add(new PagamentoDocumenti()
{
IDPagamentoMaster = this._IDPagamentoMaster,
FileName = nomeFile,
Ordine = 0,
PathFile = Path.Combine(this._IDPagamentoMaster.ToString(), nomeFile),
});
}
saveManager.SaveEntity("Immagini aggiunte correttamente");
EventAggregator.Instance().Publish <ImageListUpdate>(new ImageListUpdate());
}
}
}
private void Save(Save <Deposito> obj)
{
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
if (((EditItem).ID > 0))
{
uof.DepositoRepository.Update(EditItem);
}
else
{
uof.DepositoRepository.Add(EditItem);
}
if (saveManager.SaveEntity(enSaveOperation.OpSave))
{
RiselezionaSelezionato();
}
}
}
private void Save(Save <ListinoPrezziVenditaNome> obj)
{
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
if (EditItem.ID > 0)
{
uof.ListinoPrezziVenditaNomeRepository.Update(EditItem);
}
else
{
uof.ListinoPrezziVenditaNomeRepository.Add(EditItem);
}
if (saveManager.SaveEntity(enSaveOperation.OpSave))
{
RiselezionaSelezionato();
}
}
}
private void ApriSettingStampaFattura()
{
var setItem = DatiIntestazioneStampaFatturaValidator.ReadSetting();
var view = new GenericSettingView(setItem);
{
view.OnSave += (a, b) =>
{
using (var cur = new CursorManager())
{
view.Validate();
using (var uof = new SaveEntityManager())
{
uof.UnitOfWork.DatiIntestazioneStampaFatturaRepository.Update(setItem);
uof.SaveEntity(enSaveOperation.OpSave);
}
}
};
this.ShowView(view, enAmbiente.SettingStampa);
}
}
private void ApriSettingSito()
{
var settingSito = SettingSitoValidator.ReadSetting();
var view = new GenericSettingView(settingSito);
{
view.OnSave += (a, b) =>
{
using (var cur = new CursorManager())
{
view.Validate();
using (var save = new SaveEntityManager())
{
save.UnitOfWork.SettingSitoRepository.Update(settingSito);
save.SaveEntity(enSaveOperation.OpSave);
}
}
};
this.ShowView(view, enAmbiente.SettingSito);
}
}
public ControllerDepositi()
: base(enAmbiente.DepositoList, enAmbiente.Deposito)
{
SelectedItem = new Deposito();
_selectSub = EventAggregator.Instance().Subscribe <Add <Deposito> >((a) =>
{
EditItem = new Deposito()
{
NomeDeposito = "Nuovo Deposito"
};
ShowEditView();
});
_subRemove = EventAggregator.Instance().Subscribe <Remove <Deposito> >((a) =>
{
if (!MessageManager.QuestionMessage("Sei sicuro di volere eliminare il deposito selezionato?"))
{
return;
}
using (var saveManager = new SaveEntityManager())
{
var uof = saveManager.UnitOfWork;
var curItem = SelectedItem;
if (curItem.ID > 0)
{
var item = uof.DepositoRepository.Find(b => b.ID == curItem.ID).First();
uof.DepositoRepository.Delete(item);
if (saveManager.SaveEntity(enSaveOperation.OpDelete))
{
EventAggregator.Instance().Publish <UpdateList <Deposito> >(new UpdateList <Deposito>(this));
}
}
}
});
_subSave = EventAggregator.Instance().Subscribe <Save <Deposito> >((a) =>
{
Save(null);
});
}
private void DuplicaArticolo(ArticoloDuplicate obj)
{
try
{
using (var saveEntity = new SaveEntityManager())
{
var uof = saveEntity.UnitOfWork;
var itemCurrent = (SelectedItem);
var art =
(new Articolo()
{
CategoriaID = itemCurrent.Categoria.ID,
Condizione = itemCurrent.Condizione,
Prezzo = itemCurrent.Prezzo,
DataUltimaModifica = DateTime.Now,
DataCreazione = DateTime.Now
});
art.ArticoloWeb.Testo = itemCurrent.ArticoloWeb.Testo;
art.Titolo = "* " + itemCurrent.Titolo;
art.Strumento = itemCurrent.Strumento;
art.Libro = itemCurrent.Libro;
uof.ArticoliRepository.Add(art);
if (saveEntity.SaveEntity(enSaveOperation.Duplicazione))
{
_logger.Info("Duplica articolo");
SelectedItem = art;
EventAggregator.Instance().Publish <UpdateList <Articolo> >(new UpdateList <Articolo>(this));
}
}
}
catch (Exception ex)
{
ExceptionManager.ManageError(ex);
}
}
private void GeneraMovimentiDaOrdineDiCarico()
{
var fatt = SelectedItem;
//controllo se ci sono già altri ordini di carico
//per le righe di questo ordine
if (fatt.ChiusaSpedita)
{
MessageManager.NotificaWarnig("Documento già chiuso, non è possibile generare altre giacenze!");
return;
}
if (fatt.TipoDocumento != EnTipoDocumento.OrdineDiCarico)
{
MessageManager.NotificaWarnig("Documento deve essere del tipo ordine di carico!");
return;
}
if (!MessageManager.QuestionMessage("Generando i movimenti, il documento non sarà più modificabile. Vuoi proseguire?"))
{
return;
}
using (var saveEnt = new SaveEntityManager())
{
var depositi = saveEnt.UnitOfWork.DepositoRepository.Find(a => a.ID == a.ID).Select(a => new { a.ID, a.NomeDeposito }).ToList();
using (var selezionaDeposito = new ListViewCustom(depositi.Select(a => a.NomeDeposito).ToList(), "Imposta deposito e nome ddt fornitore", "Numero Ddt Fornitore", false))
{
var diag = selezionaDeposito.ShowDialog();
if (diag != DialogResult.OK)
{
return;
}
if (selezionaDeposito.SelectedItem == null)
{
MessageManager.NotificaWarnig("Occorre impostare deposito su cui versare la merce!");
return;
}
if (selezionaDeposito.SelectedTextProp.Length == 0)
{
if (!MessageManager.QuestionMessage("Sei sicuro di non volere impostare il codice ddt o un riferimento al ddt fornitore. Vuoi proseguire?"))
{
return;
}
}
var deposito = depositi.Where(a => a.NomeDeposito == selezionaDeposito.SelectedItem).FirstOrDefault();
var list = saveEnt.UnitOfWork.FattureRigheRepository.Find(a => a.FatturaID == fatt.ID && a.Ricevuti > 0).ToList();
if (list.Count() == 0)
{
MessageManager.NotificaWarnig("Non c'è niente tra le qta ricevute nelle righe del documento!");
return;
}
ControllerMagazzino controllerMagazzino = new ControllerMagazzino();
foreach (var item in list)
{
if (!controllerMagazzino.NuovoMovimento(new Library.Core.Events.Magazzino.MovimentoMagazzino()
{
ArticoloID = item.ArticoloID.Value,
Deposito = deposito.ID,
Causale = selezionaDeposito.SelectedTextProp,
Qta = item.Ricevuti,
Prezzo = item.PrezzoUnitario
}, saveEnt.UnitOfWork))
{
MessageManager.NotificaWarnig("Sei sicuro un errore nell'inserimento del movimento");
return;
}
/*salvo i dati di evasione nella riga parent dell'ordine di acquisto*/
var evasi = saveEnt.UnitOfWork.FattureRigheRepository.Find(a => a.IdRigaCollegata != null &&
a.IdRigaCollegata == item.IdRigaCollegata)
.Select(a => new { a.IdRigaCollegata, a.Qta })
.GroupBy(a => a.IdRigaCollegata).Select(a => new { TOT = a.Sum(b => b.Qta), IdRigaParent = a.Key.Value }).FirstOrDefault();
var rigaParent = saveEnt.UnitOfWork.FattureRigheRepository.Find(a => a.ID == evasi.IdRigaParent).FirstOrDefault();
if (rigaParent.Evasi != evasi.TOT)
{
rigaParent.Evasi = evasi.TOT;
saveEnt.UnitOfWork.FattureRigheRepository.Update(rigaParent);
}
}
var dato = saveEnt.UnitOfWork.FatturaRepository.Find(a => a.ID == fatt.ID).FirstOrDefault();
dato.ChiusaSpedita = true;
saveEnt.UnitOfWork.FatturaRepository.Update(dato);
saveEnt.SaveEntity("Creati movimenti ingresso a magazzino e chiuso documento");
}
}
}
private void CambiaPriorita(bool aumenta)
{
if (_controllerFatturazione.EditItem.ID == 0)
{
return;
}
var itemSel = ((FatturaRiga)SelectedItem);
if (itemSel.ID == 0)
{
return;
}
else
{
try
{
using (var curs = new CursorManager())
{
using (var save = new SaveEntityManager())
{
var uof = save.UnitOfWork;
var list = uof.FattureRigheRepository.Find(
a => a.FatturaID == itemSel.FatturaID).OrderBy(a => a.OrdineVisualizzazione).ToList();
foreach (var item in list)
{
if (item.ID == itemSel.ID)
{
if (aumenta)
{
var itemToUpdate = list.Where(a => a.OrdineVisualizzazione == item.OrdineVisualizzazione - 1).FirstOrDefault();
if (itemToUpdate != null)
{
itemToUpdate.OrdineVisualizzazione++;
}
item.OrdineVisualizzazione--;
}
else
{
var itemToUpdateTwo = list.Where(a => a.OrdineVisualizzazione == item.OrdineVisualizzazione + 1).FirstOrDefault();
if (itemToUpdateTwo != null)
{
itemToUpdateTwo.OrdineVisualizzazione--;
}
item.OrdineVisualizzazione++;
}
}
}
var setOrdine = 0;
foreach (var item in list.OrderBy(a => a.OrdineVisualizzazione))
{
item.OrdineVisualizzazione = setOrdine;
setOrdine++;
uof.FattureRigheRepository.Update(item);
}
if (save.SaveEntity(enSaveOperation.OpSave))
{
RiselezionaSelezionato();
}
}
}
}
catch (Exception ex)
{
ExceptionManager.ManageError(ex);
}
}
}
private void GeneraOrdineCarico()
{
var fatt = SelectedItem;
//controllo se ci sono già altri ordini di carico
//per le righe di questo ordine
if (fatt.ChiusaSpedita)
{
MessageManager.NotificaWarnig("Documento già chiuso, non è possibile fare altri documenti di carico!");
return;
}
if (fatt.TipoDocumento != EnTipoDocumento.OrdineAlFornitore)
{
MessageManager.NotificaWarnig("Documento deve essere del tipo ordine al fornitore!");
return;
}
using (var saveEnt = new SaveEntityManager())
{
bool save = false;
var listFatt = new List <Library.Entity.Fattura>();
var daGenerare = new List <Tuple <FatturaRiga, int> >();
foreach (var item in saveEnt.UnitOfWork.FattureRigheRepository.Find(a => a.FatturaID == fatt.ID).ToList())
{
/*deve cercare gli ordini di carico già fatti, e collegati, e detrarre la qta per vedere se farne di nuovi*/
var evaso = saveEnt.UnitOfWork.FattureRigheRepository.Find(a => a.IdRigaCollegata == item.ID).Select(a => new
{ Qta = a.Fattura.ChiusaSpedita == true ? a.Ricevuti : a.Qta }).Select(a => a.Qta).DefaultIfEmpty(0).Sum();
if (evaso == item.Qta)
{
continue;
}
daGenerare.Add(new Tuple <FatturaRiga, int>(item, item.Qta - evaso));
}
if (daGenerare.Count() == 0)
{
MessageManager.NotificaInfo("Non ci altre righe da fare ingressare, chiudi ordine fornitore !");
return;
}
Library.Entity.Fattura fattExt = null;
foreach (var item in daGenerare)
{
if (fattExt == null)
{
fattExt = new Library.Entity.Fattura();
fattExt.ClienteFornitoreID = fatt.ClienteFornitoreID;
fattExt.TipoDocumento = Library.Entity.EnTipoDocumento.OrdineDiCarico;
fattExt.Data = DateTime.Now;
fattExt.Codice = ControllerFatturazione.CalcolaCodice(fattExt);
var fornitore = saveEnt.UnitOfWork.SoggettiRepository.Find(a => a.ID == fattExt.ClienteFornitoreID).ToList().Select(a => new
{
RagioneSociale = !string.IsNullOrEmpty(a.RagioneSociale) ? a.RagioneSociale : a.Cognome + " " + a.Nome,
PIVA = !string.IsNullOrEmpty(a.PIVA) ? a.PIVA : a.CodiceFiscale
}).FirstOrDefault();
fattExt.RagioneSociale = fornitore.RagioneSociale;
fattExt.PIVA = fornitore.PIVA;
saveEnt.UnitOfWork.FatturaRepository.Add(fattExt);
//saveEnt.SaveEntity("");
listFatt.Add(fattExt);
}
var rigaMaster = item.Item1;
var riga = (new Library.Entity.FatturaRiga()
{
CodiceFornitore = rigaMaster.CodiceFornitore,
ArticoloID = rigaMaster.ArticoloID,
Descrizione = rigaMaster.Descrizione,
Qta = item.Item2,
Fattura = fattExt,
PrezzoUnitario = rigaMaster.PrezzoUnitario,
IvaApplicata = rigaMaster.IvaApplicata,
IdRigaCollegata = rigaMaster.ID
});
saveEnt.UnitOfWork.FattureRigheRepository.Add(riga);
save = true;
}
if (save)
{
saveEnt.SaveEntity("");
}
else
{
MessageManager.NotificaInfo("Non ci sono articoli da ordinare!");
return;
}
foreach (var item in listFatt.Distinct())
{
ControllerFatturazione.CalcolaTotali(item);
saveEnt.UnitOfWork.FatturaRepository.Update(item);
}
if (save)
{
saveEnt.SaveEntity("Generato ordine di carico!");
}
RefreshList(null);
}
}
/// <summary>
/// genera l'ordine scarico dalla vendita a banco e scarica le giacenze
/// </summary>
/// <param name="items"></param>
/// <param name="cliente"></param>
/// <param name="saveEnt"></param>
/// <returns></returns>
internal static bool GeneraOrdScarico(List <ScontrinoLine> items, int cliente, SaveEntityManager saveEnt)
{
bool save = false;
var listFatt = new List <Library.Entity.Fattura>();
var fattExt = new Library.Entity.Fattura();
fattExt.ClienteFornitoreID = cliente;
fattExt.TipoDocumento = Library.Entity.EnTipoDocumento.OrdineDiScarico;
fattExt.Data = DateTime.Now;
fattExt.Codice = ControllerFatturazione.CalcolaCodice(fattExt);
var fornitore = saveEnt.UnitOfWork.SoggettiRepository.Find(a => a.ID == fattExt.ClienteFornitoreID).Select(a => new { a.RagioneSociale, a.CodiceFiscale, a.PIVA }).FirstOrDefault();
fattExt.RagioneSociale = fornitore.RagioneSociale;
fattExt.PIVA = fornitore.PIVA;
saveEnt.UnitOfWork.FatturaRepository.Add(fattExt);
saveEnt.SaveEntity("");
listFatt.Add(fattExt);
var negozio = saveEnt.UnitOfWork.DepositoRepository.Find(a => a.Principale == true).First();
using (var depo = new Core.Controllers.ControllerMagazzino())
{
foreach (var item in items
.Select(a => new { Qta = a.Qta, a.Articolo, a.Descrizione, a.IvaPerc, a.PrezzoIvato })
.ToList())
{
var riga = (new Library.Entity.FatturaRiga()
{
ArticoloID = item.Articolo,
Descrizione = item.Descrizione,
Qta = (int)item.Qta,
Fattura = fattExt,
PrezzoUnitario = Math.Round(item.PrezzoIvato / (1 + ((decimal)item.IvaPerc / (decimal)100)), 5, MidpointRounding.ToEven),
IvaApplicata = item.IvaPerc.ToString(),
});
saveEnt.UnitOfWork.FattureRigheRepository.Add(riga);
if (item.Articolo > 0)
{
ScaricaQtaMagazzino scarica = new ScaricaQtaMagazzino();
scarica.Qta = item.Qta;
scarica.Prezzo = item.PrezzoIvato;
scarica.Deposito = negozio.ID;
scarica.ArticoloID = item.Articolo;
scarica.Causale = "Ordine scarico " + fattExt.Codice;
EventAggregator.Instance().Publish <ScaricaQtaMagazzino>(scarica);
}
save = true;
}
}
if (save)
{
saveEnt.SaveEntity("");
}
else
{
MessageManager.NotificaInfo("Non ci sono articoli da ordinare!");
return(false);
}
foreach (var item in listFatt.Distinct())
{
ControllerFatturazione.CalcolaTotali(item);
saveEnt.UnitOfWork.FatturaRepository.Update(item);
}
if (save)
{
saveEnt.SaveEntity("Generato l'ordine di scarico!");
}
return(true);
}
public static bool GeneraOrdAcq(List <ListinoPrezziFornitoriItem> items)
{
using (var saveEnt = new SaveEntityManager())
{
bool save = false;
var listFatt = new List <Library.Entity.Fattura>();
foreach (var item in items.Where(a => a.QtaDaOrdinare - a.QtaInOrdine > 0)
.Select(a => new { Qta = a.QtaDaOrdinare - a.QtaInOrdine, a.CodiceArticoloFornitore, a.ID, a.Entity, a.Prezzo }).OrderBy(a => a.Entity.FornitoreID).ToList())
{
Library.Entity.Fattura fattExt = saveEnt.UnitOfWork.FatturaRepository.Find(a => a.ChiusaSpedita == false && a.ClienteFornitoreID == item.Entity.FornitoreID &&
a.TipoDocumento == Library.Entity.EnTipoDocumento.OrdineAlFornitore).FirstOrDefault();
var riga = new Library.Entity.FatturaRiga();
Library.Entity.Articoli.Articolo art = saveEnt.UnitOfWork.ArticoliRepository.Find(a => a.ID == item.Entity.ArticoloID).FirstOrDefault();
if (fattExt == null)
{
fattExt = listFatt.Where(a => a.ClienteFornitoreID == item.Entity.FornitoreID).FirstOrDefault();
}
if (fattExt == null)
{
fattExt = new Library.Entity.Fattura();
fattExt.ClienteFornitoreID = item.Entity.FornitoreID;
fattExt.TipoDocumento = Library.Entity.EnTipoDocumento.OrdineAlFornitore;
fattExt.Data = DateTime.Now;
fattExt.Codice = ControllerFatturazione.CalcolaCodice(fattExt);
var fornitore = saveEnt.UnitOfWork.SoggettiRepository.Find(a => a.ID == fattExt.ClienteFornitoreID).Select(a => new { a.RagioneSociale, a.CodiceFiscale, a.PIVA }).FirstOrDefault();
fattExt.RagioneSociale = fornitore.RagioneSociale;
fattExt.PIVA = fornitore.PIVA;
saveEnt.UnitOfWork.FatturaRepository.Add(fattExt);
saveEnt.SaveEntity("");
}
listFatt.Add(fattExt);
riga = (new Library.Entity.FatturaRiga()
{
CodiceFornitore = item.CodiceArticoloFornitore,
ArticoloID = item.Entity.ArticoloID,
Descrizione = art.Titolo,
Qta = item.Qta,
Fattura = fattExt,
PrezzoUnitario = item.Prezzo,
IvaApplicata = art.Iva.ToString(),
});
saveEnt.UnitOfWork.FattureRigheRepository.Add(riga);
save = true;
}
if (save)
{
saveEnt.SaveEntity("");
}
else
{
MessageManager.NotificaInfo("Non ci sono articoli da ordinare!");
return(false);
}
foreach (var item in listFatt.Distinct())
{
ControllerFatturazione.CalcolaTotali(item);
saveEnt.UnitOfWork.FatturaRepository.Update(item);
}
if (save)
{
saveEnt.SaveEntity("Generati gli ordini di acquisto!");
}
return(true);
}
}