br.com.jarch.faces.migration.MigrationController Maven / Gradle / Ivy

Go to download
package br.com.jarch.faces.migration;

import br.com.jarch.core.annotation.JArchViewScoped;
import br.com.jarch.faces.util.JavaScriptUtils;
import br.com.jarch.core.migration.Migrated;
import br.com.jarch.core.migration.MigrationService;
import br.com.jarch.core.model.ICrudEntity;
import br.com.jarch.core.model.IIdentity;
import br.com.jarch.core.util.BundleUtils;
import br.com.jarch.util.LogUtils;
import br.com.jarch.core.type.FileType;
import org.apache.commons.io.FileUtils;
import org.primefaces.event.FileUploadEvent;
import org.primefaces.event.SelectEvent;
import org.primefaces.event.TransferEvent;
import org.primefaces.model.DefaultStreamedContent;
import org.primefaces.model.DualListModel;
import org.primefaces.model.StreamedContent;
import org.primefaces.model.file.UploadedFile;

import javax.annotation.PostConstruct;
import javax.inject.Inject;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.util.*;
import java.util.stream.Collectors;

@JArchViewScoped
public class MigrationController implements Serializable {
	private DualListModel listTypeMigration;
	private DualListModel listTypeRestore;
	private DualListModel listMigration;

	private List listData;

	private Migrated migrated;

	private File file;
	private UploadedFile uploadedFile;

	private Map mapa;

	@Inject
	private MigrationService migrationService;

	@PostConstruct
	public void init(){
		mapa = new HashMap<>();

		listMigration = new DualListModel(new ArrayList<>(), new ArrayList<>());
		listTypeMigration = new DualListModel(new ArrayList<>(), new ArrayList<>());
		listTypeRestore = new DualListModel(new ArrayList<>(), new ArrayList<>());

		List lista = new ArrayList<>();
		for(Class clazz: migrationService.pesquisaEntidades()){
			if (mapa.get(clazz.getSimpleName()) == null) {
				try {
                    ICrudEntity instance = (ICrudEntity) clazz.getConstructor().newInstance();
					Migrated migrated = new Migrated(instance);
					mapa.put(clazz.getSimpleName(), migrated);

					lista.add(migrated);
				} catch (Exception ex) {
					LogUtils.generate(ex);
				}
			}
		}

		lista = lista
				.stream()
				.sorted(Comparator.comparing(Migrated::getNameClassEntity))
				.collect(Collectors.toList());

		listTypeMigration.getSource().addAll(lista);
		listTypeRestore.getSource().addAll(lista);
	}

	public StreamedContent migraDados() throws IOException {
		if (listTypeMigration.getTarget().isEmpty()){
			JavaScriptUtils.showMessageHeaderError(BundleUtils.messageBundle("message.obrigatorioSelecionarPeloMenosUmaEntidade"));
			return null;
		}

		InputStream inputStream = migrationService.migraDados(listTypeMigration.getTarget());
		return DefaultStreamedContent.builder().stream(() -> inputStream).contentEncoding(FileType.ZIP.getContentType()).name("migracao.zip").build();
	}

	public void restauraDados() throws IOException {
		if (listTypeRestore.getTarget().isEmpty()){
			JavaScriptUtils.showMessageHeaderError(BundleUtils.messageBundle("message.obrigatorioSelecionarPeloMenosUmaEntidade"));
			return;
		}

		migrationService.restauraDados(listTypeRestore.getTarget(), file);
	}

	public void onSelect(SelectEvent event) {
		listMigration = new DualListModel(new ArrayList<>(), new ArrayList<>());
		migrated = preencheLista((Migrated) event.getObject());
	}

	public void onTransferEntity(TransferEvent event) {
		for (Object item : event.getItems()) {
			if (event.isAdd()) {
				listTypeMigration.getSource().remove(item);
				listTypeMigration.getTarget().add(item);

				Migrated migratedItem = (Migrated) item;
				preencheLista(migratedItem);

				if (migratedItem.getListSelected().isEmpty()){
					migratedItem.getListSelected().addAll(migratedItem.getListAvailable());
					migratedItem.getListAvailable().clear();
				}
			} else {
				listTypeMigration.getSource().add(item);
				listTypeMigration.getTarget().remove(item);
			}
		}
	}

	public Migrated preencheLista(Migrated migratedSelected){
		try {
			if (migratedSelected.getListAvailable().isEmpty()) {
				migratedSelected
						.getRepository()
						.searchAll()
						.stream()
						.forEach(entity -> migratedSelected.getListAvailable().add((ICrudEntity) entity));

				List lista = new ArrayList<>(migratedSelected.getListAvailable());
				migratedSelected.getListAvailable().clear();
				for (ICrudEntity item: lista){
					IIdentity entity = migratedSelected
							.getRepository()
							.searchOneAndInitializeCollectionsBy(item.getId());

					migratedSelected.getListAvailable().add((ICrudEntity) entity);
				}
			}

			List listaFiltrada = migratedSelected
					.getListAvailable()
					.stream()
					.filter(item -> !migratedSelected.getListSelected().contains(item))
					.sorted((m1, m2) -> m1.toString().compareTo(m2.toString()))
					.collect(Collectors.toList());

			listMigration = new DualListModel(listaFiltrada, migratedSelected.getListSelected());
		} catch (Exception ex){
			LogUtils.generate(ex);
		}

		return migratedSelected;
	}

	public void onTransferDados(TransferEvent event) {
		for (Object item : event.getItems()) {
			if (event.isAdd()) {
				migrated.getListSelected().add((ICrudEntity) item);

			} else {
				migrated.getListSelected().remove(item);
			}
		}
	}

	public DualListModel getListMigration() {
		return listMigration;
	}

	public void setListMigration(DualListModel listMigration) {
		this.listMigration = listMigration;
	}

	public List getListData() {
		return listData;
	}

	public void setListData(List listData) {
		this.listData = listData;
	}

	public DualListModel getListTypeMigration() {
		return listTypeMigration;
	}

	public void setListTypeMigration(DualListModel listTypeMigration) {
		this.listTypeMigration = listTypeMigration;
	}

	public DualListModel getListTypeRestore() {
		return listTypeRestore;
	}

	public void setListTypeRestore(DualListModel listTypeRestore) {
		this.listTypeRestore = listTypeRestore;
	}

	public boolean isArquivoImportado() {
		return file != null;
	}

	public File getFile() {
		return file;
	}

	public void setFile(File file) {
		this.file = file;
	}

	public UploadedFile getUploadedFile() {
		return uploadedFile;
	}

	public void handleFileUpload(FileUploadEvent event) {
		setUploadedFile(event.getFile());
	}

	public void setUploadedFile(UploadedFile uploadedFile) {
		this.uploadedFile = uploadedFile;

		try {
			file = File.createTempFile("migration", "jarch");
			FileUtils.writeByteArrayToFile(file, uploadedFile.getContent());
		} catch (Exception ex){
			LogUtils.generate(ex);
		}
	}

	public String getNomeArquivo(){
		if(uploadedFile == null){
			return "";
		}

		return uploadedFile.getFileName();
	}

	public String getNomeClass(Migrated migrated){
		if (migrated == null){
			return "";
		}

		return migrated.getNameClassEntity();
	}
}