Multiple representations of the same entity [data.model.User#50] are being merged. Detached: [data.model.User@75c01cdc];

	
		Vorgang vorgang;
		
		AKKFile akkFile;
		
		if (isTest)
		{
			vorgang = testVorgang;
			akkFile = testAkkFile;
		}
		else
		{
		  Benutzer benutzer = userRepository.findByLogin(getView().getUI().getSession().getAttribute("user").toString());
			
		  vorgang = getView().getVorgang();	  
		  vorgang.setAkkFile(new AKKFile());
		  akkFile = vorgang.getAkkFile();
		  akkFile.setFilename(filePath);
		  akkFile.setUploader("USERNAME");
                  // эту строку комменчу ибл есть двойное подчинение но что так что эдак работает когда как
		  akkFile.setBenutzer(benutzer);
		  // wer hat den Akk-Datei angelegt		  
		  vorgang.getAkkFile().setBenutzer(benutzer);		  
		}		
		akkEntryis = new ArrayList<AKKEntry>();
				
		String line = "";
		
		errLstAkk = new ArrayList<String>();
		
		errCnt = 0;
                // длинная процедура заполнения энтити подчиненного akkFile из csv
                // ошибка именно при сохранении
                vorgang = vorgangRepository.save(vorgang);
                // разные варианты пробовал но никак не помогает
		      vorgangRepository.save(vorgang);
		      vorgang = vorgangRepository.findOne(vorgang.getId());

groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.4.0.M3</version>

@Entity
public class BezugsQuartal
{
	@Id
	@SequenceGenerator(name = "SEQ_BEZUGQUART", sequenceName = "SEQ_BEZUGQUART")
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_BEZUGQUART")
	private Long id;
	
	@OneToMany(mappedBy = "bezugsQuartal", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private List<Vorgang> vorgangList = new ArrayList<Vorgang>();
	
	private String quartal;
	
	public Long getId()
	{
		return id;
	}

	public void setId(Long id)
	{
		this.id = id;
	}
	
	public void addVorgang(Vorgang vorgang)
	{
		if (vorgang != null)
		{
			vorgangList.add(vorgang);
			vorgang.setBezugsQuartal(this);			
		}
	}
	
	public List<Vorgang> getVorgangList()
	{
		return vorgangList;
	}

	public void setVorgangList(List<Vorgang> vorgangList)
	{
		this.vorgangList = vorgangList;
		this.vorgangList.forEach(								
									(vorgang) -> {
														if (vorgang != null)
														{
														  vorgang.setBezugsQuartal(this);
														}
													}
								   ); 
	}
	
	public String getQuartal()
	{
		return quartal;
	}

	public void setQuartal(String quartal)
	{
		this.quartal = quartal;
	}
}

@Entity
public class Vorgang
{
	@Id
	@SequenceGenerator(name = "SEQ_VORGANG", sequenceName = "SEQ_VORGANG")
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_VORGANG")
	private Long id;

	@ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.MERGE)
	@JoinColumn(name = "BUCHUNGS_QUARTAL_ID")
	private BuchungsQuartal buchungsQuartal;
	
	@ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.MERGE)
	@JoinColumn(name = "BEZUGS_QUARTAL_ID")
	private BezugsQuartal bezugsQuartal;

	@ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.MERGE)
	@JoinColumn(name = "BENUTZER_ID")
	private Benutzer benutzer;
	
	@OneToMany(mappedBy = "vorgang", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
	private List<Subvorgang> subvorgangList = new ArrayList<Subvorgang>();
	
	@OneToOne(mappedBy = "vorgang", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private AKKFile akkFile;
	
	@OneToOne(mappedBy = "vorgang", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private UBSFile ubsFile;
	
	@OneToOne(mappedBy = "vorgang", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private KKKFile kkkFile;

	@Temporal(TemporalType.TIMESTAMP)
	@Column(nullable = false)
	private Date created;
	
	private int status;
	
	private String textStatus;
	
	private String arenaTitel;
	
	private String arenaId;

	public Long getId()
	{
		return id;
	}

	public void setId(Long id)
	{
		this.id = id;
	}

	public Benutzer getBenutzer()
	{
		return benutzer;
	}

	public void setBenutzer(Benutzer benutzer)
	{
		this.benutzer = benutzer;
	}

	public void addSubvorgang(Subvorgang subvorgang)
	{
		if (subvorgang != null)
		{
			subvorgangList.add(subvorgang);
			if (subvorgang != null)
			{
			  subvorgang.setVorgang(this);
			}
		}
	}
	
	public List<Subvorgang> getSubvorgangList()
	{
		return subvorgangList;
	}

	public void setSubvorgangList(List<Subvorgang> subvorgangList)
	{
		this.subvorgangList = subvorgangList;
		this.subvorgangList.forEach(								
									(subvorgang) -> {
														if (subvorgang != null)
														{
														  subvorgang.setVorgang(this);
														}
													}
								   ); 
	}
	
	public void setAkkFile(AKKFile akkFile)
	{
		this.akkFile = akkFile;
		if (akkFile != null)
		{
			akkFile.setVorgang(this);
		}
	}
	
	public AKKFile getAkkFile()
	{
		return akkFile;
	}

	public void setKkkFile(KKKFile kkkFile)
	{
		this.kkkFile = kkkFile;
		if (kkkFile != null)
		{
			kkkFile.setVorgang(this);
		}
	}
	
	public KKKFile getKkkFile()
	{
		return kkkFile;
	}
	
	public void setUbsFile(UBSFile ubsFile)
	{
		this.ubsFile = ubsFile;
		if (ubsFile != null)
		{
			ubsFile.setVorgang(this);
		}
	}
	
	public UBSFile getUbsFile()
	{
		return ubsFile;
	}

	public final Date getCreated()
	{
		return created;
	}

	public final void setCreated(Date created)
	{
		this.created = created;
	}

	public BuchungsQuartal getBuchungsQuartal()
	{
		return buchungsQuartal;
	}

	public void setBuchungsQuartal(BuchungsQuartal buchungsQuartal)
	{
		this.buchungsQuartal = buchungsQuartal;
	}
	
	public void setBezugsQuartal(BezugsQuartal bezugsQuartal)
	{
		this.bezugsQuartal = bezugsQuartal;
	}
	
	public BezugsQuartal getBezugsQuartal()
	{
		return bezugsQuartal;
	}
	
	public void setStatus(int status)
	{
		this.status = status;
	}
	
	public int getStatus()
	{
		return status;
	}
	
	public String getTextStatus()
	{
		return textStatus;
	}
	
	public void setTextStatus(String textStatus)
	{
		this.textStatus = textStatus;
	}
	
	public String getTextStauts()
	{
		return this.textStatus;
	}
	
	public void setArenaTitel(String arenaTitel)
	{
		this.arenaTitel = arenaTitel;
	}
	
	public String getArenaTitel()
	{
		return this.arenaTitel;
	}
	
	public void setArenaId(String srenaId)
	{
		this.arenaId = srenaId;
	}
	
	public String getArenaId()
	{
		return this.arenaId;
	}
}

@Entity
public class BuchungsQuartal
{
	@Id
	@SequenceGenerator(name = "SEQ_BUCHUNGSQUART", sequenceName = "SEQ_BUCHUNGSQUART")
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_BUCHUNGSQUART")
	private Long id;

	private String quartal;
	
	@OneToMany(mappedBy = "buchungsQuartal", fetch = FetchType.EAGER, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private List<Vorgang> vorgangList = new ArrayList<Vorgang>();
	
	@ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.MERGE)
	@JoinColumn(name = "BENUTZER_ID")
	private Benutzer benutzer;
	
	private int status;
	
	private String textStatus;

	public Long getId()
	{
		return id;
	}

	public void setId(Long id)
	{
		this.id = id;
	}
	
	public void addVorgang(Vorgang vorgang)
	{
		if (vorgang != null)
		{
			vorgangList.add(vorgang);
			vorgang.setBuchungsQuartal(this);			
		}
	}
	
	public List<Vorgang> getVorgangList()
	{
		return vorgangList;
	}

	public void setVorgangList(List<Vorgang> vorgangList)
	{
		this.vorgangList = vorgangList;
		this.vorgangList.forEach(								
									(vorgang) -> {
														if (vorgang != null)
														{
														  vorgang.setBuchungsQuartal(this);
														}
													}
								   ); 
	}


	public Benutzer getBenutzer()
	{
		return benutzer;
	}

	public void setBenutzer(Benutzer benutzer)
	{
		this.benutzer = benutzer;
	}

	public String getQuartal()
	{
		return quartal;
	}

	public void setQuartal(String quartal)
	{
		this.quartal = quartal;
	}
	
	public void setStatus(int status)
	{
		this.status = status;
	}
	
	public int getStatus()
	{
		return status;
	}
	
	public String getTextStatus()
	{
		return textStatus;
	}
	
	public void setTextStatus(String textStatus)
	{
		this.textStatus = textStatus;
	}
}

@Entity
// @Transactional
public class Benutzer
{
	@Id
	@SequenceGenerator(name = "SEQ_BENUTZER", sequenceName = "SEQ_BENUTZER")
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_BENUTZER")
	private Long id;
	
	@OneToMany(mappedBy = "benutzer", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private List<Vorgang> vorgangList = new ArrayList<Vorgang>();
	
	@OneToMany(mappedBy = "benutzer", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private List<AKKFile> akkFileList = new ArrayList<AKKFile>();
	
	@OneToMany(mappedBy = "benutzer", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private List<KKKFile> kkkFileList = new ArrayList<KKKFile>();
	
	public Long getId()
	{
		return id;
	}

	public void setId(Long id)
	{
		this.id = id;
	}
	
	public void addVorgang(Vorgang vorgang)
	{
		if (vorgang != null)
		{
			vorgangList.add(vorgang);
			vorgang.setBenutzer(this);			
		}
	}
	
	public List<Vorgang> getVorgangList()
	{
		return vorgangList;
	}

	public void setVorgangList(List<Vorgang> vorgangList)
	{
		this.vorgangList = vorgangList;
		this.vorgangList.forEach(								
									(vorgang) -> {
														if (vorgang != null)
														{
														  vorgang.setBenutzer(this);
														}
													}
								   ); 
	}

	
	public void addAkkFile(AKKFile akkFile)
	{
		if (akkFile != null)
		{
			akkFileList.add(akkFile);			
			akkFile.setBenutzer(this);			
		}
	}
	
	public List<AKKFile> getAkkFileList()
	{
		return akkFileList;
	}

	public void setAkkFileList(List<AKKFile> akkFileList)
	{
		this.akkFileList = akkFileList;
		this.akkFileList.forEach(								
									(akkFile) -> {
														if (akkFile != null)
														{
															akkFile.setBenutzer(this);
														}
													}
								   ); 
	}

	
	public List<KKKFile> getKkkFileList()
	{
		return kkkFileList;
	}

	public void setKkkFileList(List<KKKFile> kkkFileList)
	{
		this.kkkFileList = kkkFileList;
		this.kkkFileList.forEach(								
									(kkkFile) -> {
														if (kkkFile != null)
														{
															kkkFile.setBenutzer(this);
														}
													}
								   ); 
	}

	
	private String login;
	
	public String getLogin()
	{
		return login;
	}

	public void setLogin(String login)
	{
		this.login = login;
	}
}

@Entity
@CsvDataType
public class AKKEntry
{

	@Id
	@SequenceGenerator(name = "SEQ_AKKENTRY", sequenceName = "SEQ_AKKENTRY")
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_AKKENTRY")
	private Long id;

	@ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.ALL)
	@JoinColumn(name = "AKKFILE_ID")
	private AKKFile akkFile;
	
	@CsvField(pos = 1)
	@Size(min = 3, max = 3, message = "Die Zeilegrösse musste 3 sein!")
	@Pattern(regexp="^(AKK)", message="Der Satzart ist ungültig, musst nur AKK-Wert sein!")
	private String satzart;

	@Size(min = 5, max = 5, message = "Die Zeilegrösse vom Quartal ist nur 5 Symbolen!")
	@Pattern(regexp="^[1-4]{1}(20)[0-9]{2}", message="Der Quartal ist ungültig! - musste ab 1 bis 4 anfängen und im Ende Jahren ab 20 fangen an")
	@CsvField(pos = 2)
	private String quartal;

	@CsvField(pos = 3)
	@Size(min = 10, max = 10, message = "Der HNR ist ungültig - die Zeilegrösse musste 10 sein!")
	@Pattern(regexp="^[0-9]+${10}", message="Der HNR ist ungültig, nur Ziffern müssen sein!")			
	private String hnr;

	@CsvField(pos = 4)	
	@Column(name = "diff_Hon")
	private int diffHon;

	@CsvField(pos = 5)
	@Min(value = 100, message = "Belegart ist ungültig - die Zeilegrösse musste 3 sein!")
	@Max(value = 999, message = "Belegart ist ungültig - die Zeilegrösse musste 3 sein!")			
	private int belegart;

	@CsvField(pos = 6)
	@Size(max = 255, message = "Die Zeile ist zu lang!")	
	private String text;

	@CsvField(pos = 7)		
	@Column(name = "buch_NrKVAI")
	private int buchNrKVAI;

	public Long getId()
	{
		return id;
	}

	public void setId(Long id)
	{
		this.id = id;
	}

	public AKKFile getAkkFile()
	{
		return akkFile;
	}

	public void setAkkFile(AKKFile akkFile)
	{
		this.akkFile = akkFile;
	}

	public String getSatzart()
	{
		return satzart;
	}

	public void setSatzart(String satzart)
	{
		this.satzart = satzart;
	}

	public String getQuartal()
	{
		return quartal;
	}

	public void setQuartal(String quartal)
	{
		this.quartal = quartal;
	}

	public String getHnr()
	{
		return hnr;
	}

	public void setHnr(String hnr)
	{
		this.hnr = hnr;
	}

	public int getDiffHon()
	{
		return diffHon;
	}

	public void setDiffHon(int diffHon)
	{
		this.diffHon = diffHon;
	}

	public int getBelegart()
	{
		return belegart;
	}

	public void setBelegart(int belegart)
	{
		this.belegart = belegart;
	}

	public String getText()
	{
		return text;
	}

	public void setText(String text)
	{
		this.text = text;
	}

	public int getBuchNrKVAI()
	{
		return buchNrKVAI;
	}

	public void setBuchNrKVAI(int buchNrKVAI)
	{
		this.buchNrKVAI = buchNrKVAI;
	}
}

@Entity
public class AKKFile
{
	@Id
	@SequenceGenerator(name = "SEQ_AKKFILE", sequenceName = "SEQ_AKKFILE")
	@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "SEQ_AKKFILE")
	private Long id;

	@OneToOne(fetch = FetchType.LAZY, cascade = CascadeType.ALL)	
	@JoinColumn(name = "VORGANG_ID")
	private Vorgang vorgang;
	
	@OneToMany(mappedBy = "akkFile", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
	private List<AKKEntry> akkEntryList = new ArrayList<AKKEntry>();
	
	@ManyToOne(fetch = FetchType.EAGER, cascade = CascadeType.MERGE)
	@JoinColumn(name = "BENUTZER_ID")
	private Benutzer benutzer;
	
	@OneToOne(mappedBy = "akkFile", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
	@PrimaryKeyJoinColumn
	private CsvAkkFile csvAkkFile;

	private String filename;

	private String uploader;

	public Long getId()
	{
		return id;
	}

	public void setId(Long id)
	{
		this.id = id;
	}	
	
	public Vorgang getVorgang()
	{
		return vorgang;
	}

	public void setVorgang(Vorgang vorgang)
	{
		this.vorgang = vorgang;
	}
	
	public void addEntry(AKKEntry akkEntry)
	{
		if (akkEntry != null)
		{
			akkEntryList.add(akkEntry);
			akkEntry.setAkkFile(this);
		}
	}
	
	public List<AKKEntry> getAkkEntryList()
	{
		return akkEntryList;
	}

	public void setAkkEntryList(List<AKKEntry> akkEntryList)
	{
		this.akkEntryList = akkEntryList;
		this.akkEntryList.forEach(								
									(akkEntry) -> {
														if (akkEntry != null)
														{															
															akkEntry.setAkkFile(this);
														}
													}
								   ); 
	}
	
	public Benutzer getBenutzer()
	{
		return benutzer;
	}

	public void setBenutzer(Benutzer benutzer)
	{
		this.benutzer = benutzer;
	}
	
	public void setCsvAkkFile(CsvAkkFile csvAkkFile)
	{
		this.csvAkkFile = csvAkkFile;
		if (csvAkkFile != null)
		{
			csvAkkFile.setAkkFile(this);
		}
	}
	
	public CsvAkkFile getCsvAkkFile()
	{
		return csvAkkFile;
	}
	
	@Override
	public String toString()
	{
		return ReflectionToStringBuilder.toString(this);
	}

	public String getFilename()
	{
		return filename;
	}

	public void setFilename(String filename)
	{
		this.filename = filename;
	}

	public String getUploader()
	{
		return uploader;
	}

	public void setUploader(String uploader)
	{
		this.uploader = uploader;
	}
}

vorgangRepository.save(vorgang)

@OneToOne(cascade = {CascadeType.PERSIST, CascadeType.REFRESH}, mappedBy = "vorgang", fetch = FetchType.EAGER, orphanRemoval=true)

       @PrimaryKeyJoinColumn

       private AKKFile akkFile;

@OneToOne(cascade = {CascadeType.MERGE}, fetch = FetchType.LAZY)
@JoinColumn(name = "VORGANG_ID")

       private Vorgang vorgang;