@Override
  public UtenteDTO getByMatricola(long matricola) {

    Utente utente = utenteRepository.findOne(matricola);
    LOG.warn("Find utente by matricola");

    return UtenteConverter.convertToDTO(utente);
  }
  @Override
  public List<UtenteDTO> findAll() {
    List<Utente> listaUtenti = utenteRepository.findAll();

    List<UtenteDTO> listaDTO = new ArrayList<UtenteDTO>();
    for (Utente utente : listaUtenti) {
      String mansione = utente.getTbMansione().getDescrizione();
      BigDecimal costoOrario = utente.getTbMansione().getCostoOrarioOrd();
      UtenteDTO utenteDTO = UtenteConverter.convertToDTO(utente);
      utenteDTO.setNomeMansione(mansione);
      utenteDTO.setCostoOrario(costoOrario);

      listaDTO.add(utenteDTO);
    }

    LOG.warn("Find all utenti");
    return listaDTO;
  }
  @Override
  public List<UtenteDTO> getByCompetenze(String competenza, Integer livello) {

    // cerco l'id corrispondente all'id della competenza
    Map<String, SearchDTO> andMap = new HashMap<String, SearchDTO>();
    SearchDTO so = new SearchDTO();
    so.setOperatore(it.linksmt.corsoedoc.intranet.enumeration.Operator.EQUAL);
    so.setValue(competenza);
    andMap.put("descrizione", so);

    ISpecifications<Skill> u = new ISpecifications<Skill>();
    Specification<Skill> spec = u.findByCriteria(andMap, null);
    Skill skill = skillRepJpa.findOne(spec);

    long idSkill = skill.getId();

    // cerco gli utenti idonei una cerca competenza e un certo livello

    Map<String, SearchDTO> andMap2 = new HashMap<String, SearchDTO>();
    SearchDTO so2 = new SearchDTO();
    so2.setOperatore(it.linksmt.corsoedoc.intranet.enumeration.Operator.EQUAL);
    so2.setValue(idSkill);
    andMap.put("tb_skill_id", so2);
    so2.setValue(livello);
    andMap.put("livello", so2);
    ISpecifications<UtenteHasSkill> uS = new ISpecifications<UtenteHasSkill>();
    Specification<UtenteHasSkill> spec2 = uS.findByCriteria(andMap2, null);
    List<UtenteHasSkill> listaUtentiHasSkill = utenteSkillRepository.findAll(spec2);

    // riempio una lista con tutti gli utenti DTO idonei

    List<Utente> utentiIdonei = new ArrayList<Utente>();

    for (UtenteHasSkill utenteHasSkill : listaUtentiHasSkill) {
      utentiIdonei.add(utenteRepository.findOne(utenteHasSkill.getId()));
    }

    return UtenteConverter.convertListToDTO(utentiIdonei);
  }
  @Transactional
  @Override
  public void addUpdateUtente(UtenteInsertJobDTO dto)
      throws DuplicatedEmailException, DuplicatedUsernameException, ParseException {
    UtenteDTO udto = dto.getUtenteDTO();
    Utente u = null;
    if (udto.getId() == null) {
      Mansione m = mansioneRepository.findOne(dto.getIdMansione());
      u = UtenteConverter.convertToEntity(dto.getUtenteDTO());
      u.setTbMansione(m);
    } else {
      u = utenteRepository.getOne(udto.getId());
      u.setCapDomicilio(udto.getCapDomicilio());
      u.setCapResidenza(udto.getCapResidenza());
      u.setCellulare(udto.getCellulare());
      u.setCf(udto.getCf());
      u.setCittaDomicilio(udto.getCittaDomicilio());
      u.setCittaNascita(udto.getCittaDomicilio());
      u.setCittaResidenza(udto.getCittaResidenza());
      u.setCognome(udto.getCognome());
      u.setDataAssunzione(DateConverter.convertFromStringToDate(udto.getDataAssunzione()));
      u.setDataNascita(DateConverter.convertFromStringToDate(udto.getDataNascita()));
      u.setIndirizzoDomicilio(udto.getIndirizzoDomicilio());
      u.setIndirizzoResidenza(udto.getIndirizzoResidenza());
      u.setMail(udto.getMail());
      u.setNome(udto.getNome());
      u.setProvinciaDomicilio(udto.getProvinciaDomicilio());
      u.setProvinciaNascita(udto.getProvinciaNascita());
      u.setProvinciaResidenza(udto.getProvinciaResidenza());
      u.setTbMansione(mansioneRepository.findOne(dto.getIdMansione()));
    }
    utenteRepository.save(u);
    Utente temp = utenteRepository.getByEmail(u.getMail());
    if (temp != null && temp.getId().longValue() != u.getId().longValue()) {
      throw new DuplicatedEmailException("User modified some values on JSON object");
    }

    // E' necessario ricercare l'insieme delle skills già presenti, se siamo
    // in update
    List<UtenteHasSkill> skills = u.getTbUtenteHasTbSkills();
    List<Long> skillsPresenti = new ArrayList<Long>();
    skillsPresenti.addAll(dto.getSkill());
    List<Integer> skillsLivelli = new ArrayList<Integer>();
    skillsLivelli.addAll(dto.getLivello());
    if (skills != null) {
      // A partire da queste tre liste è necessario iterare per ogni skill
      // esistente
      for (int p = 0; p < skills.size(); p++) {
        UtenteHasSkill skill = skills.get(p);
        boolean presente = false;
        // Innanzitutto controlliamo la presenza della skill in esame
        // (presente mappa o meno la presenza)
        for (int i = 0; i < skillsPresenti.size(); i++) {
          Long l = skillsPresenti.get(i);
          if (skill.getTbSkill().getId().longValue() == l) {
            if (skill.getLivello() != skillsLivelli.get(i).intValue()) {
              skill.setLivello(skillsLivelli.get(i));
              utenteSkillRepository.save(skill);
            }
            skillsPresenti.remove(i);
            skillsLivelli.remove(i);
            presente = true;
            break;
          }
        }
        if (!presente) {
          utenteSkillRepository.delete(skill);
        }
      }
    }
    // Una volta arrivati qui, la lista skillsPresenti ha al suo interno
    // solo le skills non ancora collegate, per cui passiamo all'aggiunta
    // delle rimanenti
    for (int i = 0; i < skillsPresenti.size(); i++) {
      Long l = skillsPresenti.get(i);
      Skill skill = skillRepJpa.findOne(l);
      UtenteHasSkill uhs = new UtenteHasSkill();
      uhs.setLivello(skillsLivelli.get(i));
      uhs.setTbSkill(skill);
      uhs.setTbUtente(u);
      utenteSkillRepository.save(uhs);
    }

    // Controlliamo l'esistenza di un utente con la stessa mail aziendale
    DatiLogin datiLogin = datiLoginRepository.getByUsername(dto.getUsername());
    if (datiLogin != null && datiLogin.getTbUtente().getId().longValue() != u.getId().longValue()) {
      throw new DuplicatedUsernameException("Username già presente nel DB per un altro utente");
    }

    if (datiLogin == null) {
      DatiLogin dL = new DatiLogin();
      dL.setAttivo(!dto.getDisabled());
      dL.setPassword(Utility.md5(dto.getPassword()));
      dL.setUsername(dto.getUsername());
      dL.setTbUtente(u);
      Profilo p = profiloRepository.findOne(dto.getIdProfilo());
      dL.setTbProfilo(p);
      datiLoginRepository.save(dL);
    } else {
      if (!dto.getPassword().equals("vecchiapw")) {
        datiLogin.setPassword(Utility.md5(dto.getPassword()));
      }
      datiLogin.setUsername(dto.getUsername());
      datiLogin.setAttivo(!dto.getDisabled());
      datiLogin.setTbProfilo(profiloRepository.findOne(dto.getIdProfilo()));
      datiLoginRepository.save(datiLogin);
    }
    LOG.warn("Insert or update ");
    if (curriculumRepository.getByUtente(u) == null) {
      Curriculum curriculum = new Curriculum();
      curriculum.setUtente(u);
      curriculum.setEsperienze(new String());
      curriculum.setFormazione(new String());
      curriculum.setLingue(new String());
      curriculumRepository.save(curriculum);
    }
  }
 /*
  * (non-Javadoc)
  *
  * @see
  * it.linksmt.corsoedoc.intranet.service.UtenteService#getById(java.lang.
  * Long)
  */
 @Override
 public UtenteDTO getById(Long id) {
   return UtenteConverter.convertToDTO(utenteRepository.getOne(id));
 }