/// <summary>
/// Costruttore con parametro per la modifica di un dipendente esistente
/// </summary>
/// <param name="dipendente"></param>
public DipendenteViewModel(Dipendente dipendente)
{
DisplayTabName = "Modifica";
_dipendenteId = dipendente.Id;
StartBackgroundAutoProgress(LoadDipendente);
EditMode = true;
}
public bool UpdateUser(Dipendente userModel)
{
IdentityUser iu = userManager.FindById(userModel.FKIDAnagrafica.ToString());
iu.UserName = userModel.Username;
return(userManager.Update(iu).Succeeded);
}
void AggiungiSchedaRisultatiRicercaFiguraPerDipendente(Dipendente dipendente)
{
RisultatiFiguraPerDipendenteViewModel visualizza = new RisultatiFiguraPerDipendenteViewModel(dipendente);
Workspaces.Add(visualizza);
SetActiveWorkspace(visualizza);
}
// MOD_DIPENDENTI
public List <RisultatoRicerca> CercaRuoloDaDipendente(Dipendente dipendente, bool filtraRuoliNonValidi)
{
var algoritmo = _container.Resolve <IAlgoritmoRicerca>("RicercaRuoloDaDipendente");
var result = algoritmo.Cerca(dipendente, filtraRuoliNonValidi);
return(result);
}
static void Main(string[] args)
{
Console.WriteLine("Gestione dipendenti di Lorenzo Curzi, 4H");
//creo un nuovo dipendente
Dipendente d1 = new Dipendente("Rossi", "Mario", "RMA", "333", "Milano", "Saldatore");
//visualizzo le sue informazioni
Console.WriteLine(d1.VisualizzaDati());
Console.WriteLine("----------------------------------------------------");
//Modifico le sue informazioni
d1.ModificaDati("Rossi", "Gianluca", "GMA", "340", "Roma", "Venditore");
//visualizzo le informazioni aggiornate
Console.WriteLine(d1.VisualizzaDati());
Console.WriteLine("----------------------------------------------------");
//cancello le informazioni del dipendente
d1.CancellaDati();
//visualizzo le informazioni aggiornate
Console.WriteLine(d1.VisualizzaDati());
Console.WriteLine("----------------------------------------------------");
}
private void CancellaDipendente(PavimentalContext context, Dipendente dipendente)
{
/*foreach (var c in dipendente.Conoscenze)
* {
* ConoscenzaCompetenza con = new ConoscenzaCompetenza() { Id = c.Id };
* context.ConoscenzaCompetenze.Attach(con);
* context.ConoscenzaCompetenze.Remove(con);
* }
* context.SaveChanges();
*
* Dipendente dipToRemove = new Dipendente() { Id = dipendente.Id };
* context.Dipendenti.Attach(dipToRemove);
* context.Dipendenti.Remove(dipToRemove);
*
* context.SaveChanges();*/
Dipendente dipToRemove = new Dipendente()
{
Id = dipendente.Id
};
context.Dipendenti.Attach(dipToRemove);
context.Dipendenti.Remove(dipToRemove);
context.SaveChanges();
}
private Dipendente AggiornaDipendente(Dipendente d)
{
var reposLivelloConoscenza = ServiceLocator.Current.GetInstance <IRepository <LivelloConoscenza> >();
int idLivelloInsuff = reposLivelloConoscenza.Single(lc => lc.Titolo == Tipologiche.Livello.INSUFFICIENTE).Id;
var reposDipendente = ServiceLocator.Current.GetInstance <IRepository <Dipendente> >();
var reposConoscenze = ServiceLocator.Current.GetInstance <IRepository <ConoscenzaCompetenza> >();
var uow = ServiceLocator.Current.GetInstance <IUnitOfWork>();
Dipendente dipendente = reposDipendente.SingleOrDefault(dip => dip.Id == d.Id);
if (dipendente != null)
{
dipendente.Matricola = d.Matricola;
dipendente.Cognome = d.Cognome;
dipendente.Nome = d.Nome;
dipendente.DataNascita = d.DataNascita;
dipendente.RuoloInAziendaId = d.RuoloInAziendaId;
for (int i = 0; i < d.Conoscenze.Count; i++)
{
ConoscenzaCompetenza c = d.Conoscenze.ToList()[i];
//e salvo solo quelle diverse da 0
if (c.LivelloConoscenzaId != idLivelloInsuff)
{
ConoscenzaCompetenza conoscenza;
conoscenza = dipendente.Conoscenze.SingleOrDefault(con => con.CompetenzaId == c.CompetenzaId);
if (conoscenza == null)
{
conoscenza = new ConoscenzaCompetenza();
conoscenza.CompetenzaId = c.CompetenzaId;
dipendente.Conoscenze.Add(conoscenza);
}
conoscenza.LivelloConoscenzaId = c.LivelloConoscenzaId;
}
else
{
//E' una di quelle che erano presenti in precedenza e sono state settate a 0 per essere cancellate
var conosc = dipendente.Conoscenze.SingleOrDefault(con => con.CompetenzaId == c.CompetenzaId);
if (conosc != null)
{
dipendente.Conoscenze.Remove(conosc);
var cc = reposConoscenze.Single(con => con.Id == conosc.Id);
reposConoscenze.Delete(cc);
}
}
}
uow.Commit();
return(dipendente);
}
else
{
return(CreaDipendente(d));
}
}
public void VisualizzaConfrontoDetails()
{
ConfrontoRuoloDetailsVM confrontoDetailsVM = ServiceLocator.Current.GetInstance <ConfrontoRuoloDetailsVM>();
Dipendente dipendenteSelezionato = _dipendentiServices.CaricaDipendente(RisultatoSelezionato.Id);
confrontoDetailsVM.Atteso = Ruolo;
confrontoDetailsVM.Osservato = dipendenteSelezionato;
confrontoDetailsVM.AddToShell();
}
public Dipendente ToEntity(Dipendente toEdit)
{
toEdit.FKIDAnagrafica = this.FKIDAnagrafica;
toEdit.FKIDRuolo = this.FKIDRuolo;
toEdit.Username = this.Username;
toEdit.Password = this.Password;
toEdit.DipendenteDal = this.DipendenteDal.ToLocalTime();
toEdit.DipendenteAl = (this.DipendenteAl.HasValue ? (DateTimeOffset?)this.DipendenteAl.Value.ToLocalTime() : null);
toEdit.Attivo = this.Attivo;
return(toEdit);
}
//Azione eseguita quando faccio doppioclick su un elemento della listview "VisualizzaDipendenteView"
void AggiungiSchedaRisultatiRicercaAnagrafica(Dipendente dipendente)
{
DipendenteViewModel visualizza = new DipendenteViewModel(dipendente)
{
//Dipendente = dipendente,
RicercaFiguraPerDipendente = AggiungiSchedaRisultatiRicercaFiguraPerDipendente
};
Workspaces.Add(visualizza);
SetActiveWorkspace(visualizza);
}
/// <summary>
/// Devo rielaborare l'oggetto per evitare creazione di duplicati di conoscenze su DB
/// </summary>
/// <param name="dipendente"></param>
public Dipendente SalvaDipendente(Dipendente d)
{
if (d.Id == 0)
{
return(CreaDipendente(d));
}
else
{
return(AggiornaDipendente(d));
}
}
public IdentityResult RegisterUser(Dipendente userModel)
{
IdentityUser user = new IdentityUser
{
UserName = userModel.Username,
Id = userModel.IDDipendente.ToString(),
};
var result = userManager.Create(user, userModel.Password);
return(result);
}
public void EliminaDipendente(int id)
{
var repos = ServiceLocator.Current.GetInstance <IRepository <Dipendente> >();
var uow = ServiceLocator.Current.GetInstance <IUnitOfWork>();
//repos.Attach(dipToRemove);
Dipendente dipToRemove = repos.Single(d => d.Id == id);
repos.Delete(dipToRemove);
uow.Commit();
}
private void CancellaDipendente()
{
Stato = "Cancellazione in corso";
var service = ServiceLocator.Current.GetInstance <IDipendentiServices>();
service.EliminaDipendente(Dipendente.Id);
//Faccio come se sto inserendo il dipendente per la prima volta (modalità new)
Dipendente = new Dipendente();
EditMode = false;
Stato = "Cancellato";
}
public RisultatiFiguraPerDipendenteViewModel(Dipendente dipendente)
{
DisplayTabName = "Sostituti per " + dipendente.Cognome;
/*//Sta arrivando un oggetto con solo l'ID
* if (dipendente.Conoscenze.Count == 0) non mi arriva mai
* {
* //dipendente deve avere tutte le conoscenze caricate
* using (PavimentalDb context = new PavimentalDb())
* {
* context.Anagrafica.Include(a => a.Conoscenze.Select(c => c.Competenza))
* .Include(a => a.Conoscenze.Select(c => c.LivelloConoscenza))
* .Include(a => a.Conoscenze.Select(c => c.Competenza.TipologiaCompetenza));
* Dipendente = context.Anagrafica.Find(dipendente.Id);
* }
* }*/
LoadParametri();
//Non ho salvato il dipendente e mi mancano però le conoscenze per calcolare gli indici
if (dipendente.Id == 0)
{
using (PavimentalContext context = new PavimentalContext())
{
foreach (var cc in dipendente.Conoscenze)
{
cc.LivelloConoscenza = context.LivelliConoscenza.Find(cc.LivelloConoscenzaId);
}
Dipendente = dipendente;
}
}
else
{
//dipendente deve avere tutte le conoscenze caricate
Dipendente = dipendente;
}
//Non faccio l'autoprogress, setto il valore massimo pari al numero di elementi sul db da analizzare
using (PavimentalContext context = new PavimentalContext())
{
FigureProfessionaliTotali = context.FigureProfessionali.Count();
}
//Faccio partire l'algoritmo in background
StartBackground(AvviaAlgoritmo);
}
public void UpdateDipendente()
{
Dipendente dip = new Dipendente();
dip.Id = 1;
dip.Nome = "pidasdadad";
dip.DataNascita = DateTime.Now;
using (PavimentalContext context = new PavimentalContext())
{
context.Dipendenti.Attach(dip);
context.Entry <Dipendente>(dip).State = System.Data.EntityState.Modified;
context.SaveChanges();
}
}
public DipendenteDTO New(DipendenteDTO DTO)
{
using (CaronteContext caronteCtx = new CaronteContext())
{
Dipendente tmp = DTO.ToEntity();
caronteCtx.Dipendente.Add(tmp);
caronteCtx.SaveChanges();
if (tmp.IDDipendente > 0)
{
AuthRepository ar = new AuthRepository();
ar.RegisterUser(tmp);
}
return(this.Get(tmp.IDDipendente));
}
}
private Dipendente SalvaDipendente(D[] lista, string matricola, string cognome, string nome, string ruolo)
{
/*var reposDipendenti = ServiceLocator.Current.GetInstance<IRepository<Dipendente>>();
*
* var reposComp = ServiceLocator.Current.GetInstance<IRepository<Competenza>>();
* var reposLivelli = ServiceLocator.Current.GetInstance<IRepository<LivelloConoscenza>>();
* var uow = ServiceLocator.Current.GetInstance<IUnitOfWork>();*/
/*var reposDipendenti = new BaseRepository<Dipendente>(context);
* var reposRuoli = new BaseRepository<Ruolo>(context);
* var reposComp = new BaseRepository<Competenza>(context);
* var reposLivelli = new BaseRepository<LivelloConoscenza>(context);
* var uow = new UnitOfWork(context);*/
List <ConoscenzaCompetenza> conoscenze = new List <ConoscenzaCompetenza>();
foreach (var elemento in lista)
{
ConoscenzaCompetenza conoscenza = new ConoscenzaCompetenza();
conoscenza.Competenza = context.Competenze.Single(c => c.Titolo == elemento.t && c.TipologiaCompetenza.MacroGruppo == elemento.mg);
conoscenza.LivelloConoscenza = context.LivelliConoscenza.Single(lc => lc.Titolo == elemento.v);
conoscenze.Add(conoscenza);
}
var dipendente = new Dipendente()
{
Matricola = matricola,
Cognome = cognome,
Nome = nome,
Conoscenze = conoscenze
};
dipendente.RuoloInAziendaId = context.Ruoli.Single(r => r.Titolo == ruolo).Id;
if (context.Dipendenti.SingleOrDefault(d => d.Cognome == dipendente.Cognome) == null)
{
context.Dipendenti.Add(dipendente);
//uow.Commit();
context.SaveChanges();
}
return(dipendente);
}
public DipendenteDTO Update(DipendenteDTO DTO)
{
using (CaronteContext caronteCtx = new CaronteContext())
{
Dipendente tmpAna = caronteCtx.Dipendente.Find(DTO.IDDipendente);
DTO.ToEntity(tmpAna);
caronteCtx.SaveChanges();
AuthRepository ar = new AuthRepository();
if (ar.FindUser(DTO.Username, DTO.Password) != null)
{
ar.UpdateUser(tmpAna);
}
else
{
ar.RegisterUser(tmpAna);
}
return(this.Get(tmpAna.IDDipendente));
}
}
/// <summary>
/// Metodo per il salvataggio del dipendente, per evitare duplicazioni devo leggermi tutte le competenze e ricrearle
/// </summary>
private void SalvaDipendente()
{
//Ricreo l'oggetto
Dipendente dip = new Dipendente();
dip.Cognome = Dipendente.Cognome;
dip.Nome = Dipendente.Nome;
dip.DataNascita = Dipendente.DataNascita;
dip.Conoscenze = new List <ConoscenzaCompetenza>();
//Mi scorro tutte le conoscenze
foreach (var c in Dipendente.Conoscenze)
{
//e salvo solo quelle diverse da 0
if (c.LivelloConoscenza.Titolo != Tipologiche.Livello.INSUFFICIENTE)
{
ConoscenzaCompetenza conoscenza = new ConoscenzaCompetenza();
conoscenza.LivelloConoscenzaId = c.LivelloConoscenzaId;
conoscenza.CompetenzaId = c.CompetenzaId;
dip.Conoscenze.Add(conoscenza);
}
}
using (PavimentalContext context = new PavimentalContext())
{
if (EditMode)
{
CancellaDipendente(context, Dipendente);
}
//context.Entry(dip).State = System.Data.EntityState.Modified;
context.Dipendenti.Add(dip);
context.SaveChanges();
}
_dipendenteId = dip.Id;
LoadDipendente();
EditMode = true;
}
private void CreaNuovoDipendente()
{
using (PavimentalContext context = new PavimentalContext())
{
var livelloNullo = context.LivelliConoscenza.Single(lc => lc.Titolo == Tipologiche.Livello.INSUFFICIENTE);
var allCompetenze = context.Competenze.Include(c => c.TipologiaCompetenza).ToList();
/*var knowHowVuoto = (from c in allCompetenze
* select new ConoscenzaCompetenza()
* {
* Competenza = c,
* //LivelloConoscenza = livelloNullo
* CompetenzaId = c.Id,
* LivelloConoscenzaId = livelloNullo.Id
* }).ToList();*/
Dipendente = new Dipendente();// { Conoscenze = knowHowVuoto };
}
}
private Dipendente CreaDipendente(Dipendente d)
{
var reposLivelloConoscenza = ServiceLocator.Current.GetInstance <IRepository <LivelloConoscenza> >();
int idLivelloInsuff = reposLivelloConoscenza.Single(lc => lc.Titolo == Tipologiche.Livello.INSUFFICIENTE).Id;
//Controllo se l'id è uguale a 0
//Ricreo l'oggetto
Dipendente dipendente = new Dipendente();
dipendente.Matricola = d.Matricola;
dipendente.Cognome = d.Cognome;
dipendente.Nome = d.Nome;
dipendente.DataNascita = d.DataNascita;
dipendente.RuoloInAziendaId = d.RuoloInAziendaId;
dipendente.Conoscenze = new List <ConoscenzaCompetenza>();
//Mi scorro tutte le conoscenze
foreach (var c in d.Conoscenze)
{
//e salvo solo quelle diverse da 0
//if (c.LivelloConoscenza.Titolo != Tipologiche.Livello.INSUFFICIENTE)
if (c.LivelloConoscenzaId != idLivelloInsuff)
{
ConoscenzaCompetenza conoscenza = new ConoscenzaCompetenza();
conoscenza.LivelloConoscenzaId = c.LivelloConoscenzaId;
conoscenza.CompetenzaId = c.CompetenzaId;
dipendente.Conoscenze.Add(conoscenza);
}
}
var repos = ServiceLocator.Current.GetInstance <IRepository <Dipendente> >();
var uow = ServiceLocator.Current.GetInstance <IUnitOfWork>();
repos.Add(dipendente);
uow.Commit();
return(dipendente);
}
public void TestExtension()
{
var container = ServiceLocator.Current.GetInstance <IUnityContainer>();
//Registro i servizi
container.RegisterType <IDipendentiServices, DipendentiServices>("Services");
var cnxString = @"Data Source=.\SQLEXPRESS;Initial Catalog=GeCo.DAL.PavimentalContext;Integrated Security=True";
container.AddNewExtension <EFRepositoryExtension>();
container.Configure <IEFRepositoryExtension>()
.WithConnection(cnxString)
.WithContextLifetime(new ContainerControlledLifetimeManager());
Dipendente d = new Dipendente();
d.Nome = "ciccio";
var services = container.Resolve <IDipendentiServices>();
var result = services.CaricaDipendente(1);
}
public async Task <List <Modulo> > Read(ApplicationDbContext db, Dipendente dip)
{
var s = new List <Modulo>();
if (dip.Categoria == "Tutor")
{
s = await db.Moduli
.Include(i => i.Tutor)
.Where(m => m.TutorId == dip.Id).ToListAsync();
return(s);
}
else if (dip.Categoria == "Insegnante")
{
s = await db.Moduli
.Include(i => i.Insegnanti)
.Where(m => m.InsegnanteId == dip.Id).ToListAsync();
return(s);
}
return(s);
}
public void Ricerca()
{
try
{
using (PavimentalContext context = new PavimentalContext())
{
//context.Database.Delete();
//context.Database.Create();
//InitializeDB.InitalizeAll();
var figure = context.Ruoli.Include(f => f.Conoscenze.Select(c => c.Competenza))
.Include(f => f.Conoscenze.Select(c => c.LivelloConoscenza))
.AsEnumerable();
Dipendente dip = CreaDipendenteTest(context);
List <object> risultati = new List <object>();
foreach (var figura in figure)
{
bool idoneo = false;
double percentuale = 0;
int punteggioOsservato = 0; // dip.IndiceTotale;
int punteggioAtteso = 0; // figura.IndiceTotale;
double punteggioAttesoMinimo = punteggioAtteso * 70.0 / 100;
if (punteggioOsservato > punteggioAttesoMinimo)
{
idoneo = true;
percentuale = (double)punteggioOsservato / punteggioAtteso * 100.0;
}
risultati.Add(new { NomeFigura = figura.Titolo, PAM = punteggioAttesoMinimo, Idoneo = idoneo, Percentuale = percentuale });
}
}
}
catch (Exception fault)
{
string ex = fault.Message;
}
}
public void SalvaSurveyRevisionato(int idSurveySession, List <Answer> risposte)
{
Dipendente dipendente = new Dipendente();
//List<LivelloConoscenza> livelli = dipendentiService.GetLivelliConoscenza();
var session = GetSurveySession(idSurveySession);
//Leggo le informazioni dell'utente
UserProfile profilo = userService.GetUtente(session.User);
dipendente.Nome = profilo.Nome;
dipendente.Cognome = profilo.Cognome;
dipendente.Matricola = profilo.Matricola;
var domande = session.Survey.Questions;
foreach (var r in risposte)
{
var domanda = domande.Single(d => d.Id == r.DomandaId);
var subquestion = reposSubQuestion.Get(sb => sb.Id == r.RispostaDataId);
ConoscenzaCompetenza cc = new ConoscenzaCompetenza
{
CompetenzaId = domanda.CompetenzaId,
LivelloConoscenzaId = subquestion.LivelloConoscenzaId
};
dipendente.Conoscenze.Add(cc);
}
dipendentiService.SalvaDipendente(dipendente);
//devo segnare la surveysession come revisionata
session.Revisionato = true;
reposSurveySession.Update(session);
unityOfWork.Commit();
}
private Dipendente CreaDipendenteTest(PavimentalContext context)
{
ConoscenzaCompetenza conoscenza1 = new ConoscenzaCompetenza();
conoscenza1.Competenza = context.Competenze.Single(c => c.Titolo == "Normative Tecniche");
conoscenza1.LivelloConoscenza = context.LivelliConoscenza.Single(lc => lc.Titolo == "Medio");
ConoscenzaCompetenza conoscenza2 = new ConoscenzaCompetenza();
conoscenza2.Competenza = context.Competenze.Single(c => c.Titolo == "Contrattualistica Fornitori");
conoscenza2.LivelloConoscenza = context.LivelliConoscenza.Single(lc => lc.Titolo == "Medio");
List <ConoscenzaCompetenza> conoscenze = new List <ConoscenzaCompetenza>();
conoscenze.Add(conoscenza1);
conoscenze.Add(conoscenza2);
Dipendente dip = new Dipendente();
dip.Conoscenze = conoscenze;
return(dip);
}
private Dipendente CreaDipendente(Dipendente d)
{
int idLivelloInsuff = reposLivelloConoscenza.Get(lc => lc.Titolo == Tipologiche.Livello.INSUFFICIENTE).Id;
//Controllo se l'id è uguale a 0
//Ricreo l'oggetto
Dipendente dipendente = new Dipendente();
dipendente.Matricola = d.Matricola;
dipendente.Cognome = d.Cognome;
dipendente.Nome = d.Nome;
dipendente.DataNascita = d.DataNascita;
dipendente.Conoscenze = new List <ConoscenzaCompetenza>();
//Mi scorro tutte le conoscenze
foreach (var c in d.Conoscenze)
{
//e salvo solo quelle diverse da 0
//if (c.LivelloConoscenza.Titolo != Tipologiche.Livello.INSUFFICIENTE)
if (c.LivelloConoscenzaId != idLivelloInsuff)
{
ConoscenzaCompetenza conoscenza = new ConoscenzaCompetenza();
conoscenza.LivelloConoscenzaId = c.LivelloConoscenzaId;
conoscenza.CompetenzaId = c.CompetenzaId;
dipendente.Conoscenze.Add(conoscenza);
}
}
reposDipendenti.Add(dipendente);
unitOfWork.Commit();
return(dipendente);
}
static void Main(string[] args)
{
// Credo un dipendente senza codice fiscale (verrà generato alla riga 62)
Dipendente dipendente = new Dipendente();
Dipendente.NuovoDipendente();
// Creo un dipendente ed in automatico gli assegnoil codice fiscale
Dipendente dipendente1 = new Dipendente(
"Lorenzo",
"Bartolini",
"M",
"02/11/1974",
"32165448",
"provaU",
"provaP",
"SCM",
"Macchine a controllo numerico",
"Rimini",
"Via Tambroni, 9"
);
Dipendente.NuovoDipendente();
bool flag = false;
string strUser = "";
string strPass = "";
while (true)
{
Console.Write("Username: "******"Password: "******"Accesso Eseguito come {dipendente.Nome} {dipendente.Cognome}");
// Imposto una bandierina che mi permette di capire se l'utente ha fatto il logIn
flag = true;
break;
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Accesso negato, ricontrollare Username e password!");
Console.ResetColor();
}
}
Console.ResetColor();
if (flag)
{
flag = false;
// Stampo i dati riferiti ad un dipendente
Console.WriteLine(dipendente.VisualizzazioneDati());
// Aggiungo i dati e genero il CF
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine(dipendente.AggiungiDati(
"Liam",
"Bartolini",
"M",
"29/01/2003",
"6512356",
"ITTS Rimin O.Belluzzi L.DaVinci",
"4H",
"Rimini",
"Via Tambroni, 9"
));
// Ne modifico modifico username psw e reparto (se scrivo [""] vegono lasciati i valori di default
Console.WriteLine(dipendente.ModificaDati(
"liam",
"bartolini",
"5H"
));
Console.ResetColor();
while (true)
{
Console.Write("\nUsername: "******"Password: "******"\nAccesso Eseguito come {dipendente.Nome} {dipendente.Cognome}");
flag = true;
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Accesso negato, ricontrollare Username e password!");
}
Console.ResetColor();
if (flag)
{
break;
}
}
Console.WriteLine("\n" + dipendente.VisualizzazioneDati());
Console.WriteLine(dipendente.StampaTesseraSanitaria());
Console.ResetColor();
}
Console.ReadLine();
}
/// <summary>
/// Acquisisce dal database di lavoro tutti i Dipendenti presenti e ne anonimizza (mediante selezione RND da elenchi generici) Cognome, Nome, Luogo di Nascita, Codice Fiscale
/// </summary>
public static void anonimizzaAnagraficheDipendenti()
{
const string ANONIM = "ZX";
const string DB_COGNOMI_NOMI = "cognominomi";
Hashtable connectionStringElement;
DataTable tables;
Dictionary <int, string> cognomi;
Dictionary <int, string> nomi;
Dictionary <int, string> sesso;
ArrayList unique;
IList comuni;
IList dipendenti;
Random _random = new Random();
int nRand = 0;
int nCognome;
int nNome;
int nComune;
try
{
cognomi = new Dictionary <int, string>();
nomi = new Dictionary <int, string>();
sesso = new Dictionary <int, string>();
unique = new ArrayList();
connectionStringElement = new Hashtable();
connectionStringElement["Database"] = DB_COGNOMI_NOMI;
//Vengono eseguite query RAW per non dover sviluppare tutto il sistema NHibernate anche sul db di servizio e solo per queste due SELECT
//In considerazione del tipo di query, non vi è alcun rischio di SQL Injection o problematiche affini
tables = DbRawManager.eseguiRawQuery("SELECT id, cognome FROM cognomi ORDER BY cognome", connectionStringElement);
foreach (DataRow r in tables.Rows)
{
cognomi[(int)r[0]] = (string)r[1];
}
tables = DbRawManager.eseguiRawQuery("SELECT id, nome, sesso FROM nomi ORDER BY nome", connectionStringElement);
foreach (DataRow r in tables.Rows)
{
nomi[(int)r[0]] = (string)r[1];
sesso[(int)r[0]] = (string)r[2]; //M / F
}
comuni = Comune.recuperaListaComuni();
dipendenti = Dipendente.recuperaListaDipendenti();
if (dipendenti.Count > cognomi.Count * nomi.Count)
{
throw new Exception("Il numero di Dipendenti supera il totale delle anagrafiche univoche generabili");
}
Comune comuneDefaultIstat = new Comune();
comuneDefaultIstat.denominazione = "placeholder";
comuneDefaultIstat.codiceIstat = "X001";
using (PersistenceManager i_persistence = new PersistenceManager())
{
while (nRand < dipendenti.Count)
{
Dipendente d = (Dipendente)dipendenti[nRand];
if (d.comuneNascita != null && d.comuneNascita.EndsWith(ANONIM))
{
nRand++;
continue;
}
nCognome = _random.Next(1, cognomi.Keys.Max() + 1);
nNome = _random.Next(1, nomi.Keys.Max() + 1);
nComune = _random.Next(1, comuni.Count);
if (!unique.Contains(nCognome + "|" + nNome))
{
d.cognome = cognomi[nCognome];
d.nome = nomi[nNome];
d.comuneNascita = ((Comune)comuni[nComune]).denominazione + ANONIM;
d.codiceFiscale = CodiceFiscale.calcola(d.nome, d.cognome, (d.dataNascita != null ? (DateTime)d.dataNascita : new DateTime(2021, 01, 01)), (sesso[nNome].CompareTo("M") == 0 ? CodiceFiscale.SessoCF.Maschio : CodiceFiscale.SessoCF.Femmina), comuneDefaultIstat);
i_persistence.modifica(d);
unique.Add(nCognome + "|" + nNome);
nRand++;
}
}
}
}
catch (Exception e)
{
//LOG
throw e;
}
}
