private ArrayList<MetaUnitEntityItemDTO> toEntitySubitemsDTOs(MetaUnitEntityItem item) {
   ArrayList<MetaUnitEntityItemDTO> subitems = new ArrayList<MetaUnitEntityItemDTO>();
   if (item.getSubitems() != null)
     for (MetaUnitEntityItem it : item.getSubitems()) {
       subitems.add(toEntityItemDTO_Light(it));
     }
   return subitems;
 }
 private void getRecursiveItemsFlattened(
     ArrayList<String> names, ArrayList<Long> ids, MetaUnitEntityItem ite, String shift) {
   if (ite.getSubitems() != null && ite.getSubitems().size() > 0)
     for (MetaUnitEntityItem item : ite.getSubitems()) {
       names.add(shift + item.getValue());
       ids.add(item.getId());
       getRecursiveItemsFlattened(names, ids, item, ". " + shift);
     }
 }
 @Override
 public ArrayList<Long> getEntityItemSubitemsIDs(Long id_item) {
   MetaUnitEntityItem item = em.find(MetaUnitEntityItem.class, id_item);
   Collection<MetaUnitEntityItem> items = item.getSubitems();
   ArrayList<Long> arr = new ArrayList<Long>();
   for (MetaUnitEntityItem it : items) {
     arr.add(it.getId());
   }
   return arr;
 }
 @Override
 public ArrayList<String> getEntityItemTaggedEntitiesIdentifiers(Long id_item) {
   MetaUnitEntityItem item = em.find(MetaUnitEntityItem.class, id_item);
   List<String> ids = item.getTagged_entities_identifiers();
   ArrayList<String> arr = new ArrayList<String>();
   if (ids != null)
     for (String id : ids) {
       arr.add(id);
     }
   return arr;
 }
 @Override
 public ArrayList<Long> getEntityItemTaggedEntitiesIDs(Long id_item, String identif) {
   MetaUnitEntityItem item = em.find(MetaUnitEntityItem.class, id_item);
   List<Long> ids = item.getTagged_entities_ids();
   List<String> idents = item.getTagged_entities_identifiers();
   ArrayList<Long> arr = new ArrayList<Long>();
   int i = 0;
   if (ids != null)
     for (Long id : ids) {
       if (idents.get(i).equals(identif)) arr.add(id);
       i++;
     }
   return arr;
 }
  private MetaUnitEntityItemDTO toEntityItemDTO_Light(MetaUnitEntityItem item) {
    MetaUnitEntityItemDTO dto =
        new MetaUnitEntityItemDTO(item.getId(), item.getValue(), item.getMapped_values());
    ArrayList<Long> ent_ids = new ArrayList<Long>();
    if (item.getTagged_entities_ids() != null)
      for (Long id : item.getTagged_entities_ids()) {
        ent_ids.add(id);
      }

    ArrayList<String> ent_idents = new ArrayList<String>();
    if (item.getTagged_entities_identifiers() != null)
      for (String ident : item.getTagged_entities_identifiers()) {
        ent_idents.add(ident);
      }
    dto.setTagged_entities_ids(ent_ids);
    dto.setTagged_entities_identifiers(ent_idents);

    ArrayList<MetaUnitEntityItemDTO> subitems = new ArrayList<MetaUnitEntityItemDTO>();
    dto.setSubitems(subitems);
    return dto;
  }
 @Override
 public HashMap<String, String> getEntityItem(Long id) {
   MetaUnitEntityItem item = em.find(MetaUnitEntityItem.class, id);
   return item.getMapped_values();
 }
  private MetaUnitMultivaluedEntityDTO toMultivaluedEntityDTO(
      MetaUnitMultivaluedEntity m, boolean flattened_items) {
    MetaUnitMultivaluedEntityDTO dto = new MetaUnitMultivaluedEntityDTO();
    try {
      dto.setId(m.getId());
      dto.setDesc(m.getDescription());
      dto.setUnique_name(m.getUnique_name());
      dto.setIsCatalogizable(m.getIsCatalogizable() != 0);
      dto.setIsSplittingEnabled(m.getIsSplittingEnabled() != 0);
      dto.setIsMultiselected(m.getIsMultiSelected() != 0);
      Collection<MetaUnitEntityItem> items = m.getItems();
      ArrayList<String> names = new ArrayList<String>();
      ArrayList<Long> ids = new ArrayList<Long>();
      for (MetaUnitEntityItem item : items) {
        names.add(item.getValue());
        ids.add(item.getId());
        if (flattened_items) getRecursiveItemsFlattened(names, ids, item, ". ");
        //                {
        //                    for(MetaUnitEntityItem it:item.getSubitems())
        //                    {
        //                        names.add(".  "+it.getValue());
        //                        ids.add(it.getId());
        //                    }
        //                }
      }
      dto.setItem_ids(ids);
      dto.setItem_names(names);
      ArrayList<Long> tagged_ent = new ArrayList<Long>();
      if (m.getTagged_entities() != null)
        for (Long ent : m.getTagged_entities()) {
          tagged_ent.add(ent);
        }
      dto.setTagged_entities(tagged_ent);
      ArrayList<MetaUnitDTO> sub_meta_units_dtos = new ArrayList<MetaUnitDTO>();
      if (m.getSub_meta_units() != null)
        for (MetaUnit unit : m.getSub_meta_units()) {
          if (unit != null) {
            if (unit instanceof MetaUnitMultivaluedEntity) {
              MetaUnitDTO dt;
              // DONE FOR SPLIITING DOWNLOAD OF DEEP TREE
              if (((MetaUnitMultivalued) unit).getIsSplittingEnabled() != 0) {
                dt =
                    new MetaUnitMultivaluedEntityDTO(
                        unit.getId(), unit.getUnique_name(), unit.getDescription());
                ((MetaUnitMultivaluedDTO) dt)
                    .setIsCatalogizable(((MetaUnitMultivalued) unit).getIsCatalogizable() != 0);
                ((MetaUnitMultivaluedDTO) dt)
                    .setIsSplittingEnabled(
                        ((MetaUnitMultivalued) unit).getIsSplittingEnabled() != 0);
                ((MetaUnitMultivaluedEntityDTO) dt)
                    .setIsMultiselected(
                        ((MetaUnitMultivaluedEntity) unit).getIsMultiSelected() != 0);
                Collection<MetaUnitEntityItem> items2 =
                    ((MetaUnitMultivaluedEntity) unit).getItems();
                ArrayList<String> names2 = new ArrayList<String>();
                ArrayList<Long> ids2 = new ArrayList<Long>();
                for (MetaUnitEntityItem item : items2) {
                  names2.add(item.getValue());
                  ids2.add(item.getId());
                }
                ((MetaUnitMultivaluedEntityDTO) dt).setItem_ids(ids2);
                ((MetaUnitMultivaluedEntityDTO) dt).setItem_names(names2);

              } else {
                dt = toMultivaluedEntityDTO((MetaUnitMultivaluedEntity) unit, flattened_items);
              }
              if (dt != null) sub_meta_units_dtos.add(dt);
            } else if (unit instanceof MetaUnitMultivaluedStructure) {
              MetaUnitDTO dt;
              // DONE FOR SPLIITING DOWNLOAD OF DEEP TREE
              if (((MetaUnitMultivalued) unit).getIsSplittingEnabled() != 0) {
                dt =
                    new MetaUnitMultivaluedStructureDTO(
                        unit.getId(), unit.getUnique_name(), unit.getDescription());
                ((MetaUnitMultivaluedDTO) dt)
                    .setIsCatalogizable(((MetaUnitMultivalued) unit).getIsCatalogizable() != 0);
                ((MetaUnitMultivaluedDTO) dt)
                    .setIsSplittingEnabled(
                        ((MetaUnitMultivalued) unit).getIsSplittingEnabled() != 0);
              } else {
                dt = toMultivaluedStructureDTO((MetaUnitMultivaluedStructure) unit);
              }
              if (dt != null) sub_meta_units_dtos.add(dt);
            } else {
              sub_meta_units_dtos.add(unit.toDTO());
            }
          }
        }
      dto.setSub_meta_units(sub_meta_units_dtos);

      return dto;
    } catch (Exception ex) {
      ex.printStackTrace();
    } finally {
      return dto;
    }
  }