fetch=FetchType.LAZY

resultList.getUsersList().size()

@OneToMany(mappedBy = "region")
	private List<City> cities;

@ManyToOne(optional=false)
	@JoinColumn(name="CITY_REG_ID")
   	@NotNull
	private Region region;

   //Новый список городов
        List<City> listOfPickCities= cits.getTarget();
       this.region.setCities(listOfPickCities);
       em.merge(this.region);

package com.kmware.ttk.controller;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

import javax.annotation.PostConstruct;
import javax.ejb.EJB;
import javax.enterprise.context.SessionScoped;
import javax.faces.application.ConfigurableNavigationHandler;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.model.DataModel;
import javax.inject.Inject;
import javax.inject.Named;
import javax.persistence.EntityManager;

import org.primefaces.component.datatable.DataTable;
import org.primefaces.model.DualListModel;

import com.kmware.ttk.model.City;
import com.kmware.ttk.model.CityService;
import com.kmware.ttk.model.Region;
import com.kmware.ttk.model.RegionsDataModel;
import com.kmware.ttk.service.CitiesService;
import com.kmware.ttk.service.RegionService;

@SessionScoped
@Named("regionBean")
public class RegionManager implements Serializable {

	/**
	 * 
	 */
	private static final long serialVersionUID = -4399462461820100316L;

	@Inject
	private EntityManager em;

	@EJB
	private RegionService regionService;
	@EJB 
	private CitiesService cityService;

	private Region region;
	private DataTable dataTable;
	private transient DataModel<Region> model;
	private transient Region[] selectionModel;
	
	private DualListModel<City> cits;
	private List<City> sourceCities;
	private List<City> targetCities;



	public RegionManager() {

	}

	@PostConstruct
	public void init() {
		region = new Region();
		sourceCities = cityService.getResultList();
		targetCities= new ArrayList<City>();
		cits = new DualListModel<City>(sourceCities, targetCities);
		if (model == null) {
			model = new RegionsDataModel(this.getAllRegions());
		}
		
		if(selectionModel == null){
			selectionModel = new Region[0];
		}
		
	}
	
	private boolean isDateValid() {
		 if((this.region.getCreationDate()!=null)&&(this.region.getRegCloseDate()!=null)){
		    return this.region.getCreationDate().getTime()<=this.region.getRegCloseDate().getTime();
		 }
		 else return true;
		  }

	/**
	 * A list of all regions in the database
	 * 
	 * @return Region entities in database
	 */
	public List<Region> getAllRegions() {
		return regionService.getResultList();
	}
	
	
	

	public List<Region> getRegionsById(Long[] ids) {
		if (ids != null && ids.length > 0) {
			return em
					.createQuery(
							"select region FROM Region AS region WHERE region.regId in (:idList) order by region.regName",
							Region.class)
					.setParameter("idList", Arrays.asList(ids)).getResultList();
		} else {
			return Arrays.asList(new Region[] {});
		}
	}
	
	

	/**
	 * Find region by region id
	 * 
	 * @param id
	 *            of the region
	 * @return Region entity
	 */
	public Region getRegionById(Long id) {
		Region r = em
				.createQuery(
						"SELECT region FROM Region AS region WHERE region.regId=:id",
						Region.class).setParameter("id", id).getSingleResult();
		r.getCities().size();
		return r;
	}

	@SuppressWarnings("unchecked")
	public List<Region> getRegionsIdAndName() {
		return em
				.createQuery(
						"select region.regId as id, region.regName as name from Region region ORDER BY region.regName")
				.getResultList();
	}
	
	/* Navigation actions */
	
	/**
	 * Save new region in DB and redirect to region list
	 * @return - outcome "regionlist"
	 */
	public String newRegion() {
		if(isDateValid()){
			em.persist(this.region);
			for(City city: cits.getTarget()){
				this.region.getCities().add(city);
				city.setRegion(this.region);
				em.merge(region);
				em.persist(city);
			}
			em.merge(region);
		model = new RegionsDataModel(this.getAllRegions());
		em.refresh(region);
		this.region.getCities().size();
		return "viewRegion";
		}
		else{
			FacesContext.getCurrentInstance().addMessage(null,new FacesMessage(FacesMessage.SEVERITY_ERROR,"Дата закрытия меньше даты создания", "Дата закрытия меньше даты создания"));
			return null;
		}
	}
	
	/**
	 * Update region in DB and redirect to region card
	 * @return - outcome "viewRegion"
	 */
	public String updateRegion() {
		if(isDateValid()){
			
			List<City> listOfPickCities= cits.getTarget();
			
				this.region.setCities(listOfPickCities);
				em.merge(this.region);
				model = new RegionsDataModel(this.getAllRegions());
                                em.refresh(region);
				
		return "viewRegion";
		}
		else{
			FacesContext.getCurrentInstance().addMessage(null,new FacesMessage(FacesMessage.SEVERITY_ERROR,"Дата закрытия меньше даты создания", "Дата закрытия меньше даты создания"));
			return null;
		}
	}
	
	
	/**
	 * Navigation rule for plrimefaces row selection
	 */
	public void onRowSelected(){
		FacesContext fc = FacesContext.getCurrentInstance();
		ConfigurableNavigationHandler o = (ConfigurableNavigationHandler) fc
				.getApplication().getNavigationHandler();
		o.performNavigation(this.viewRegion());
	}
	
	/**
	 * Perform actions for viewing the region info
	 * @return - outcome "viewRegion"
	 */
	public String viewRegion() {
		setRegion(this.getRegionById(this.region.getRegId()));
		targetCities.clear();
		for(City city:this.region.getCities()){
			targetCities.add(city);
		}
		cits.setTarget(targetCities);

		return "viewRegion";
	}
	
	/**
	 * Perform actions for editing the region info
	 * @return - outcome "editRegion"
	 */
	public String editRegion() {
        sourceCities= cityService.getResultList();
		sourceCities.removeAll(cits.getTarget());
		cits.setSource(sourceCities);
		return "editRegion";
	}
	
	/**
	 * Perform actions for adding the region info
	 * @return - outcome "addRegion"
	 */
	public String addRegion() {
		sourceCities= cityService.getResultList();
		cits.setSource(sourceCities);
		targetCities.clear();
		cits.setTarget(targetCities);
		this.region = new Region();
		return "addRegion";
	}
	
	/**
	 * Perform actions for deleting the region. Redirecting to list
	 * @return - outcome "regionList"
	 */
	public String deleteRegion() {
//		this.regionService.sync(this.region);
		this.regionService.remove(this.region);
		return this.regionList();
	}
	
	/**
	 * Perform actions for region list view.
	 * @return - outcome "regionList"
	 */
	public String regionList() {
		this.region = new Region();
		return "regionList";
	}

	public Region getRegion() {
		return region;
	}

	public void setRegion(Region region) {
		this.region = region;
	}

	public DataTable getDataTable() {
		return dataTable;
	}

	public void setDataTable(DataTable dataTable) {
		this.dataTable = dataTable;
	}

	public DataModel<Region> getModel() {
		return model;
	}

	public void setModel(DataModel<Region> model) {
		this.model = model;
	}
	
	public Region[] getSelectionModel() {
		return selectionModel;
	}
	
	public void setSelectionModel(Region[] selectionModel) {
		this.selectionModel = selectionModel;
	}
	
	public DualListModel<City> getCits() {
		return cits;
	}

	public void setCits(DualListModel<City> cits) {
		this.cits = cits;
	}

	public List<City> getSourceCities() {
		return sourceCities;
	}

	public void setSourceCities(List<City> sourceCities) {
		this.sourceCities = sourceCities;
	}

	public List<City> getTargetCities() {
		return targetCities;
	}

	public void setTargetCities(List<City> targetCities) {
		this.targetCities = targetCities;
	}
}

setRegion(em.merge(this.region));

@OneToMany(mappedBy = "region", cascade = {CascadeType.MERGE})
	private List<City> cities;