<file_sep>package com.cubetech.facturador.emisor.application.impl;

import java.util.List;

import javax.persistence.PersistenceException;
import javax.transaction.Transactional;
import javax.validation.ValidationException;

import org.modelmapper.ModelMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.cubetech.facturador.emisor.application.EmisorService;
import com.cubetech.facturador.emisor.application.assembler.EmisorAssembler;
import com.cubetech.facturador.emisor.domain.cuenta.ArchivoCuenta;
import com.cubetech.facturador.emisor.domain.cuenta.Cuenta;
import com.cubetech.facturador.emisor.domain.cuenta.CuentaRepository;
import com.cubetech.facturador.emisor.domain.cuenta.Emisor;
import com.cubetech.facturador.emisor.interfaces.facade.CatalogosService;
import com.cubetech.facturador.emisor.interfaces.facade.dto.ArchivoDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.CertificadoDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.CuentaDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.DireccionDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.EmisorDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.EmitirDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.ImprimirDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.RegistroEmisorDTO;
import com.cubetech.facturador.emisor.interfaces.rest.archivos.ArchivoRepDTO;
import com.cubetech.facturador.emisor.interfaces.rest.archivos.ArchivoRepository;

@Service
public class EmisorServiceImpl implements  EmisorService{

	private final static Logger logger = LoggerFactory.getLogger(EmisorServiceImpl.class);
	
	
	private CuentaRepository cuentaRepository;
	private ModelMapper modelMapper;
	private ArchivoRepository archivoRepository;
	private EmisorAssembler emisorAssembler;
	
	@Autowired
	public EmisorServiceImpl(CuentaRepository cuentaRepository, ModelMapper modelMapper, 
													ArchivoRepository archivoRepository, CatalogosService catalogoService){
		this.cuentaRepository = cuentaRepository;
		this.modelMapper = modelMapper;
		this.archivoRepository = archivoRepository;
		this.emisorAssembler = new EmisorAssembler(catalogoService, this.modelMapper );
		
	}
	
	@Override
	public RegistroEmisorDTO creaEmisor(String cuenta, EmisorDTO emisor) {
		RegistroEmisorDTO ret;
		Cuenta cta;
		Emisor e;
		Emisor tmp;
		boolean banUpdate = true;
		
		try{
			cta = consultaCuenta(cuenta);
			logger.debug("Cuenta:" + cta.toString());
		}catch(Exception exp){
			logger.error("Cuenta: " + cuenta, exp);
			throw exp;
		}
		
		try{
			if(emisor.getCorrelacion() != null && !emisor.getCorrelacion().isEmpty() ){
				logger.info("Registro Correlation: " + emisor.getCorrelacion());				
				tmp = emisorAssembler.toEmisor(emisor);
				try{
					e = cta.buscaEmisor(emisor.getCorrelacion());
					logger.debug("EmisorEncontrado: {}", e.toString());
					consultaArchivos(cta,e);
					if(e.sameIdentityAs(tmp)){
						banUpdate = false;
					}else{
						tmp.correlacion(e);
						e = tmp;
					}
				}catch(ValidationException excep){
					logger.info("New emisor: {}" , tmp.toString());
					e = tmp;
				}
				if(banUpdate){
					e.valida();
					actualizaCorrelaciones(e);
					save(cta, e);
				}
			}else{
				throw new ValidationException("No se puede registrar un emisor sin un identificado de correlacion");
			}
			
		}catch(Exception exp){
			logger.error(emisor.toString(), exp);
			throw exp;
		}
		ret = emisorAssembler.emisorToRegistroEmisorDTO(e);
		return ret;
	}
	
	private void actualizaCorrelaciones(Emisor e){
		//Consultar el repositorio de comprobantes por numero de certificado
		//Si encuentra alguno se genera un nuevo correlacion para el certificado de clave publica
	}
	
	@Transactional
	private void save(Cuenta cuenta, Emisor emisor) throws PersistenceException{
		List<ArchivoRepDTO> archs = this.emisorAssembler.emisorToListArchivoRepDTO(emisor);
		
		cuenta.upsert(emisor);
		this.cuentaRepository.save(cuenta);
		archivoRepository.save(cuenta.getCorrelacion(), archs);
		
	}
	/*
	private ArchivoCuenta consultaArchivo(Cuenta cuenta, String correlacion){
		ArchivoCuenta ret;
		ArchivoRepDTO archivo;
		
		if(correlacion != null){
			archivo = archivoRepository.findbyCuentaCorrelacion(cuenta.getCorrelacion(), correlacion);
			if(archivo == null){
				logger.debug("No se encutra el archivo: {}", correlacion);
				throw new IllegalArgumentException("No se encuetra el archivo: " + correlacion);
			}
			ret = this.modelMapper.map(archivo, ArchivoCuenta.class);
			ret.setContent(ArchivoCuenta.toByteArray(archivo.getContent()));
		}else{
			throw new IllegalArgumentException("la correlacion no puede ser null");
		}
		return ret;
	}
	*/
	private void consultaArchivos(Cuenta cuenta, Emisor emisor){
		ArchivoRepDTO archivo;
		ArchivoCuenta tmp;
		if(emisor.getLogo() != null && emisor.getLogo().getCorrelacion()!= null ){
			archivo = archivoRepository.findbyCuentaCorrelacion(cuenta.getCorrelacion(), emisor.getLogo().getCorrelacion());
			if(archivo == null){
				logger.error("No se encutra el archivo: {}", emisor.getLogo());
				throw new IllegalArgumentException("No se encuetra el archivo: " + emisor.getLogo().toString());
			}
			tmp = this.modelMapper.map(archivo, ArchivoCuenta.class);
			tmp.setContent(ArchivoCuenta.toByteArray(archivo.getContent()));
			emisor.getLogo().actualiza(tmp);
		}
		
		if(emisor.getCertificado() != null && emisor.getCertificado().getPrivado() != null && emisor.getCertificado().getPrivado().getCorrelacion()!= null){
			archivo = archivoRepository.findbyCuentaCorrelacion(cuenta.getCorrelacion(), emisor.getCertificado().getPrivado().getCorrelacion());
			if(archivo == null){
				logger.error("No se encutra el archivo: {}", emisor.getCertificado().getPrivado());
				throw new IllegalArgumentException("No se encutra el archivo: " + emisor.getCertificado().getPrivado().toString());
			}
			tmp = this.modelMapper.map(archivo, ArchivoCuenta.class);
			tmp.setContent(ArchivoCuenta.toByteArray(archivo.getContent()));
			emisor.getCertificado().getPrivado().actualiza(tmp);
		}else{
			logger.error("No se encutra el archivo: {}", emisor.getCertificado().getPrivado());
			throw new IllegalArgumentException("No se encutra el archivo Logo: " + emisor.toString());
		}
		if(emisor.getCertificado() != null && emisor.getCertificado().getPublico() != null && emisor.getCertificado().getPublico().getCorrelacion()!= null){
			archivo = archivoRepository.findbyCuentaCorrelacion(cuenta.getCorrelacion(), emisor.getCertificado().getPublico().getCorrelacion());
			if(archivo == null){
				logger.error("No se encutra el archivo: {}", emisor.getCertificado().getPublico());
				throw new IllegalArgumentException("No se encutra el archivo: " + emisor.getCertificado().getPublico().toString());
			}
			tmp = this.modelMapper.map(archivo, ArchivoCuenta.class);
			tmp.setContent(ArchivoCuenta.toByteArray(archivo.getContent()));
			emisor.getCertificado().getPublico().actualiza(tmp);
		}else{
			logger.error("No se encutra el archivo: {}", emisor.getCertificado().getPublico());
			throw new IllegalArgumentException("No se encutra el archivo Logo: " + emisor.toString());
		}
	}
	
	private Cuenta consultaCuenta(String cuenta){
		Cuenta ret = null;
		ret = cuentaRepository.findOneByCorrelacion(cuenta);
		if(ret == null)
			throw new ValidationException("La cuenta no existe");
		if(!ret.isActiva())
			throw new ValidationException("Cuenta Inactiva");
		
		return ret;
	}
	
	@Override
	public List<EmisorDTO> consulta(String cuenta) {
		CuentaDTO ret = new CuentaDTO();
		EmisorDTO emisortmp = new EmisorDTO();
		CertificadoDTO certificadotmp = new CertificadoDTO();
		DireccionDTO direcciontmp = new DireccionDTO();
		ArchivoDTO logo = new ArchivoDTO();
		ArchivoDTO privado = new ArchivoDTO();
		ArchivoDTO publico = new ArchivoDTO();
		
		direcciontmp.setCalle("Av siempre viva");
		direcciontmp.setCodigoPostal("78398");
		direcciontmp.setColonia("El paseo");
		direcciontmp.setEstado("San Luis Potosi");
		direcciontmp.setMunicipio("SLP");
		direcciontmp.setNumeroExterior("322");
		direcciontmp.setPais("Mexico");
		
		logo.setNombre("LogotipoCompañia.jpg");
		logo.setTipo("JPG/Image");
		logo.setContent("<KEY>//<KEY>);
		
		privado.setNombre("archivo.key");
		privado.setTipo("Application/certificate");
		privado.setContent("<KEY>

		publico.setNombre("archivo.cer");
		publico.setTipo("Application/certificate");
		publico.setContent("<KEY>

		certificadotmp.setPassword("<PASSWORD>");
		certificadotmp.setPrivado(privado);
		certificadotmp.setPublico(publico);
		
		emisortmp.setCertificado(certificadotmp);
		emisortmp.setCorrelacion("1");
		emisortmp.setDireccion(direcciontmp);
		emisortmp.setLugarExpedicion("78398");
		emisortmp.setLogo(logo);
		emisortmp.setNombre("CUBETECHNOLOGIC");
		emisortmp.setRegimenFiscal("601");
		emisortmp.setRfc("CMC161114E10");
		
		ret.setCorrelacion("123456789-987654321");
		ret.getEmisores().add(emisortmp);
		
		
		return ret.getEmisores();
		
	}

	@Override
	public EmitirDTO consultaDatosEmitir(String cuenta, String emisor) {
		Cuenta cta;
		Emisor e;
		EmitirDTO ret;
		
		
		try{
			cta = consultaCuenta(cuenta);
			logger.debug("Cuenta:" + cta.toString());
		}catch(Exception exp){
			logger.error("Cuenta: " + cuenta, exp);
			throw exp;
		}
		e = cta.buscaEmisor(emisor);
		logger.debug("EmisorEncontrado: {}", e);
		try{
			ret = emisorAssembler.emisorToEmitirDTO(e);
			logger.debug("Emitir: {}", ret);
		}catch(Exception exp){
			logger.error("No se encuentra el certificado emisor: {}: ", e, exp);
			throw exp;
		}
		
		return ret;
	}

	@Override
	public ImprimirDTO consultaDatosImprimir(String cuenta, String emisor) {
		Cuenta cta;
		Emisor e;
		ImprimirDTO ret;
		
		try{
			cta = consultaCuenta(cuenta);
			logger.debug("Cuenta:" + cta.toString());
		}catch(Exception exp){
			logger.error("Cuenta: " + cuenta, exp);
			throw exp;
		}
		e = cta.buscaEmisor(emisor);
		try{
			ret = emisorAssembler.emisorToImprimirDTO(e);
			logger.debug("Emitir: {}", ret);
		}catch(Exception exp){
			logger.error("construccion de respuesta emisro: {} ", e, exp);
			throw exp;
		}
		
		return ret;
	}

}
<file_sep>package com.cubetech.facturador.emisor.interfaces.facade.dto.catalogos;

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

import com.cubetech.facturador.emisor.interfaces.facade.internal.deserializer.DatosJsonDeserializer;
import com.fasterxml.jackson.databind.annotation.JsonDeserialize;

import lombok.Data;
import lombok.ToString;

@Data
public class CatalogosDTO implements Serializable{
	
	private String nombre;
	//@JsonDeserialize(using = DatosJsonDeserializer.class)
	List<String> datos;
	
	public CatalogosDTO(String nombre){
		this.nombre = nombre;
		datos = new ArrayList<String>();
	}
	public CatalogosDTO(){
		/*this.nombre = nombre;*/
		datos = new ArrayList<String>();
	}

}
<file_sep>package com.cubetech.facturador.emisor.application;

import com.cubetech.facturador.emisor.interfaces.facade.dto.CuentaDTO;

public interface CuentaService {
	public void creaCuenta(CuentaDTO cuenta);
}
<file_sep>package com.cubetech.facturador.emisor.domain.common;

import java.text.SimpleDateFormat;
import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Embeddable;

import com.cubetech.facturador.emisor.domain.shared.ValueObject;

import lombok.Data;

@Data
@Embeddable
public class Vigencia implements ValueObject<Vigencia> {

	@Column(name = "inicial")
	private Date fechaInicial;
	
	@Column(name="final")
	private Date fechaFinal;
	
	public Vigencia(Date ini, Date fin){
		this.fechaInicial = ini;
		this.fechaFinal = fin;
	}
	public Vigencia(Date ini){
		this.fechaInicial = ini;
		this.fechaFinal = null;
	}
	public Vigencia(){
		this.fechaInicial = null;
		this.fechaFinal = null;
	}
	
	@Override
	public boolean sameValueAs(Vigencia other) {
		boolean ret = false;

		ret = (this.fechaInicial.equals(other.fechaInicial) && this.fechaFinal.equals(other.fechaFinal));

		return ret;
	}

	public boolean vigente() {
		boolean ret = false;
		Date ahora = new Date();
		
		ret = this.vigenteEn(ahora);
		
		return ret;
	}

	public boolean vigenteEn(Date fecha) {
		boolean ret = false;

		if (this.fechaInicial != null)
			ret = this.fechaInicial.before(fecha);

		if (fechaFinal != null)
			ret = ret && this.fechaFinal.after(fecha);

		return ret;
	}

	public String fechaLegible(){
		String ret;
		SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
		ret = "Vigencia:[" + formatter.format(fechaInicial) + " - " + formatter.format(fechaFinal) + "]";
		
		return ret;
	}
}
<file_sep>package com.cubetech.facturador.emisor.interfaces.facade.internal;
/*
import static org.junit.Assert.*;

import java.util.HashMap;
import java.util.Map;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import com.cubetech.facturador.emisor.AppConfigTest;
import com.cubetech.facturador.emisor.interfaces.facade.CatalogosService;
import com.cubetech.facturador.emisor.interfaces.facade.dto.catalogos.CatalogoDTO;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes=AppConfigTest.class)
public class CatalogosServiceImplTest {

	@Autowired
	CatalogosService catalogosService;
	
	@Test
	public void test2catalogos() {
		Map<String, String> catalogos = new HashMap<String, String>();
		Map<String, CatalogoDTO> respuesta;
		boolean asser = true;
		
		catalogos.put("regimenFiscal", "601");
		catalogos.put("codigoPostal", "78398");
		respuesta = catalogosService.consultaCatalogos(catalogos);
		
		asser = respuesta.containsKey("regimenFiscal") && respuesta.containsKey("codigoPostal");
		
		assertTrue(asser);
		
	}
	
	@Test
	public void testVigenteFalse() {
		Map<String, String> catalogos = new HashMap<String, String>();
		Map<String, CatalogoDTO> respuesta;
		boolean asser = true;
		
		catalogos.put("regimenFiscal", "628");
		catalogos.put("codigoPostal", "78398");
		respuesta = catalogosService.consultaCatalogos(catalogos);
		
		asser = respuesta.containsKey("regimenFiscal") && respuesta.containsKey("codigoPostal")
				&& !respuesta.get("regimenFiscal").isVigente();
		
		assertTrue(asser);
		
	}

}
*/
<file_sep>package com.cubetech.facturador.emisor.interfaces.rest.archivos.impl;

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

import javax.xml.ws.http.HTTPException;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.http.client.BufferingClientHttpRequestFactory;
import org.springframework.http.client.ClientHttpRequestInterceptor;
import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.stereotype.Repository;
import org.springframework.web.client.RestTemplate;

import com.cubetech.facturador.emisor.AppProperties;
import com.cubetech.facturador.emisor.interceptor.RequestLoggingInterceptor;
import com.cubetech.facturador.emisor.interfaces.rest.archivos.ArchivoRepDTO;
import com.cubetech.facturador.emisor.interfaces.rest.archivos.ArchivoRepository;

@Repository
public class ArchivoRepositoryImpl implements ArchivoRepository {
	
	@Autowired
	AppProperties properties;
	
  private RestTemplate rest;
  private HttpStatus status;
	
  public ArchivoRepositoryImpl() {
    this.rest = new RestTemplate(new BufferingClientHttpRequestFactory(new SimpleClientHttpRequestFactory()));
    List<ClientHttpRequestInterceptor> tmp = new ArrayList<ClientHttpRequestInterceptor>();
    tmp.add(new RequestLoggingInterceptor());
    rest.setInterceptors(tmp);
  }
  
	@Override
	public ArchivoRepDTO findbyCuentaCorrelacion(String cuenta, String correlation) {
		ArchivoRepDTO ret = null;
		final String url = properties.getArchivourl() + "/Archivo" + "/" + correlation;
		HttpHeaders headers = ArchivoRepositoryImpl.HedersJson();
		headers.set("cuenta", cuenta);
		HttpEntity<ArchivoRepDTO> request = new  HttpEntity<>(headers);
		
		ResponseEntity<ArchivoRepDTO> response = rest.exchange(url, HttpMethod.GET, request, ArchivoRepDTO.class);

		status = response.getStatusCode();
		
		if(status == HttpStatus.ACCEPTED){
			ret = response.getBody();
		}
		
		return ret;
	}

	public static HttpHeaders HedersJson(){
		HttpHeaders headers =  new HttpHeaders();
		
		headers.add("Content-Type", "application/json");
    headers.add("Accept", "*/*");
    headers.add("Authorization","Basic dXNlcjo1RFtqWjRSXyRyOHdZLlNM");
		return headers;
	}
	
	@Override
	public List<ArchivoRepDTO> save(String cuenta, List<ArchivoRepDTO> archivo) {
		final String url = properties.getArchivourl() +  "/Archivo";
		ArchivoRepDTO[] tmp = archivo.toArray( new ArchivoRepDTO[0]);
		ArchivoRepDTO[] respuesta;
		List<ArchivoRepDTO> ret;
		HttpHeaders headers = ArchivoRepositoryImpl.HedersJson();
		headers.set("cuenta", cuenta);
		
		HttpEntity<ArchivoRepDTO[]> request = new  HttpEntity<>(tmp, headers);
		ResponseEntity<ArchivoRepDTO[]> response = rest.exchange(url, HttpMethod.POST, request, ArchivoRepDTO[].class);

		status = response.getStatusCode();
		
		if(status == HttpStatus.OK){
			respuesta = response.getBody();
			ret = Arrays.asList(respuesta);
		}else{
			throw new HTTPException(status.value());
		}
		
		return ret;
	}

}
<file_sep>package com.cubetech.facturador.emisor.interfaces.facade.dto;

import lombok.Data;
import lombok.EqualsAndHashCode;

@Data
@EqualsAndHashCode(callSuper=true)
public class ImprimirDTO extends DireccionDTO {
	private String logo;
}
<file_sep>package com.cubetech.facturador.emisor.interfaces.facade.dto.catalogos;


import java.util.Map;

import lombok.Data;
import lombok.ToString;

@Data
@ToString(callSuper=true)
public class RegimenFiscalDTO extends CatalogoDTO {
	
	private static final String NAME = "regimenFiscal";
	
	private boolean fisica;
	private boolean moral;
	
	@Override
	public String url() {
		return NAME + "=" + super.getClaveSat();
	}
	@Override
	public String getName(){
		return NAME;
	}
	
	public RegimenFiscalDTO(){
		
	}
}
<file_sep>package com.cubetech.facturador.emisor.domain.common;

public enum EnumPersonaFiscal {
	FISICA(1),
	MORAL(2);
	
	//true fisica
	private int valor;
	
	EnumPersonaFiscal(int valor){
		this.valor = valor;
	}
	
	public int getValue(){
		return this.valor;
	}
	
}
<file_sep>package com.cubetech.facturador.emisor.domain.common;

import javax.persistence.Embeddable;

import com.cubetech.facturador.emisor.domain.shared.ValueObject;
import com.cubetech.facturador.emisor.domain.shared.ValueObjectBase;

import lombok.Data;

@Data
@Embeddable
public class Direccion extends ValueObjectBase implements ValueObject<Direccion> {

	private String calle;
	private String numeroExterior;
	private String numeroInterior;
	private String codigoPostal;
	private String colonia;
	private String pais;
	private String estado;
	private String municipio;
	
	@Override
	public boolean sameValueAs(Direccion other) {
		
		return other != null && (
			compara(this.calle, other.calle) 									 && 
			compara(this.numeroExterior, other.numeroExterior) &&
			compara(this.numeroInterior, other.numeroInterior) && 
			compara(this.codigoPostal, other.codigoPostal)	   &&
			compara(this.colonia, other.colonia) 							 && 
			compara(this.pais, other.pais)									   &&
			compara(this.estado, other.estado)								 && 
			compara(this.municipio, other.municipio)
			)
			;
	}
}
<file_sep>package com.cubetech.facturador.emisor.interfaces.facade.dto;

import java.util.ArrayList;
import java.util.List;

import lombok.Data;

@Data
public class CuentaDTO {
	private String correlacion;
	private List<EmisorDTO> emisores = new ArrayList<EmisorDTO>();
}
<file_sep>package com.cubetech.facturador.emisor.interfaces.facade.dto;

import org.hibernate.validator.constraints.Length;
import org.hibernate.validator.constraints.NotEmpty;

import lombok.Data;

@Data
public class EmisorDTO {
	@NotEmpty
	private String correlacion;
	@NotEmpty
	@Length(max=14)
	private String rfc;
	private String nombre;
	@NotEmpty
	private String regimenFiscal;
	@NotEmpty
	private String LugarExpedicion;
	private ArchivoDTO logo;
	private DireccionDTO direccion;
	
	private CertificadoDTO certificado;	
}
<file_sep>package com.cubetech.facturador.emisor;


import org.modelmapper.ModelMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

import com.cubetech.facturador.emisor.interceptor.ComprobantesFiscalesInterceptor;
import com.cubetech.facturador.emisor.interfaces.facade.internal.assembler.EmisorDtoTOEmisor;


@Configuration
public class AppConfig extends WebMvcConfigurerAdapter{
	
	@Bean
	public ModelMapper modelMapper() {
		ModelMapper modelMapper = new ModelMapper();
		modelMapper.addMappings(new EmisorDtoTOEmisor());
	  return modelMapper;
	}
	
	@Override
	public void addInterceptors(InterceptorRegistry registry){
		registry.addInterceptor(new ComprobantesFiscalesInterceptor());
	}
	
}
<file_sep>package com.cubetech.facturador.emisor.domain.common;

import javax.persistence.Embeddable;
import javax.persistence.Transient;
import javax.validation.ValidationException;

import com.cubetech.facturador.emisor.domain.catalogo.RegimenFiscal;

import lombok.Data;

@Data
@Embeddable
public class PersonaFiscal{
	
	@Transient
	private EnumPersonaFiscal tipo;
	
	private Rfc rfc;
	private RazonSocial razonSocial;
	
	public boolean sameValueAs(PersonaFiscal other) {
		boolean ret = true;
		 ret = rfc.canEqual(other.rfc);
		 ret = ret && ((razonSocial == null && other.razonSocial == null)  || (razonSocial != null && razonSocial.sameValueAs(other.razonSocial)));
		 return ret;
	}
	
	public void validaRegimenFiscal(RegimenFiscal regimenFisal) throws ValidationException{
		tipo = this.rfc.tipoPersonaFiscal();
		
		regimenFisal.valida(tipo);
		
	}
	
	public void setRfc(Rfc rfc){		
		this.rfc = rfc;
		//tipo = rfc.tipoPersonaFiscal();
	}
	
}
<file_sep>package com.cubetech.facturador.emisor.domain.cuenta;

import org.springframework.data.repository.Repository;

public interface CuentaRepository extends Repository<Cuenta, Long>{
	public Cuenta findOneByCorrelacion (String correlacion);
	public Cuenta save(Cuenta cuenta);
	public void delete(Cuenta cuenta);
}
<file_sep>package com.cubetech.facturador.emisor.application.impl;

import org.springframework.stereotype.Service;

import com.cubetech.facturador.emisor.application.CuentaService;
import com.cubetech.facturador.emisor.interfaces.facade.dto.CuentaDTO;

@Service 
public class CuentaServiceImpl implements CuentaService {



	@Override
	public void creaCuenta(CuentaDTO cuenta) {
		// TODO Auto-generated method stub

	}

}
<file_sep>package com.cubetech.facturador.emisor.application.impl;
/*
import static org.junit.Assert.*;

import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringRunner;

import com.cubetech.facturador.emisor.AppConfigTest;
import com.cubetech.facturador.emisor.application.EmisorService;
import com.cubetech.facturador.emisor.interfaces.facade.dto.ArchivoDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.CertificadoDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.DireccionDTO;
import com.cubetech.facturador.emisor.interfaces.facade.dto.EmisorDTO;

@RunWith(SpringRunner.class)
@ContextConfiguration(classes=AppConfigTest.class)
public class EmisorServiceImpl_tempTest {

	@Autowired
	EmisorService emisorService;
	
	@Test
	public void consultaEmisortest() {
		
		EmisorDTO emisortmp = new EmisorDTO();
		CertificadoDTO certificadotmp = new CertificadoDTO();
		DireccionDTO direcciontmp = new DireccionDTO();
		ArchivoDTO logo = new ArchivoDTO();
		ArchivoDTO privado = new ArchivoDTO();
		ArchivoDTO publico = new ArchivoDTO();
		
		direcciontmp.setCalle("Av siempre viva");
		direcciontmp.setCodigoPostal("78398");
		direcciontmp.setColonia("El paseo");
		direcciontmp.setEstado("San Luis Potosi");
		direcciontmp.setMunicipio("SLP");
		direcciontmp.setNumeroExterior("322");
		direcciontmp.setPais("Mexico");
		
		logo.setNombre("LogotipoCompañia.jpg");
		logo.setTipo("JPG/Image");
		logo.setContent("<KEY>);
		
		privado.setNombre("archivo.key");
		privado.setTipo("Application/certificate");
		privado.setContent("<KEY>

		publico.setNombre("archivo.cer");
		publico.setTipo("Application/certificate");
		publico.setContent("<KEY>

		certificadotmp.setPassword("<PASSWORD>");
		certificadotmp.setPrivado(privado);
		certificadotmp.setPublico(publico);
		
		emisortmp.setCertificado(certificadotmp);
		emisortmp.setCorrelacion("1");
		emisortmp.setDireccion(direcciontmp);
		emisortmp.setLugarExpedicion("78398");
		emisortmp.setLogo(logo);
		emisortmp.setNombre("CUBETECHNOLOGIC");
		emisortmp.setRegimenFiscal("601");
		emisortmp.setRfc("CMC161114E10");
		
	}

}
*/<file_sep>VERSION=0.0.1
IMAGEN=kster/emisor
NAME=emisor
docker service rm $NAME  || true
mvn package
docker service rm $NAME  || true
docker rmi $IMAGEN:$VERSION || true
docker build -t $IMAGEN:$VERSION .

docker service create \
        --name $NAME \
        --network revnet \
        --network appnet \
        --restart-condition any \
        --replicas=1  \
        --restart-delay 5s \
        --update-delay 10s \
        --update-parallelism 1 \
        -p 57778:57778  \
        --mount type=bind,source=/etc/localtime,destination=/etc/localtime \
        $IMAGEN:$VERSION
<file_sep>package com.cubetech.facturador.emisor.domain;

import static org.junit.Assert.*;

import org.junit.Test;

import com.cubetech.facturador.emisor.domain.common.RazonSocial;

public class RazonSocialTest {

	@Test
	public void valido() {
		//fail("Not yet implemented");
		
		assertEquals(true, RazonSocial.Valido("CUBETECHNOLOGIC SAS DE CV"));
		assertEquals(false, RazonSocial.Valido("|CUBETECHNOLOGIC SAS DE CV"));
		assertEquals(true, RazonSocial.Valido("CUBE Ññ!\"%&'´-:;<=>@_,{}`~áéíóúÁÉÍÓÚüÜTECHNOLOGIC SAS DE CV"));
		assertEquals(false, RazonSocial.Valido(".CUBETECHNOLOGIC SAS DE CV"));
		assertEquals(true, RazonSocial.Valido("CUBETECHNOLOGIC SAS DE CVksmfklsdmfangkjdnfgmdfngmjsnfdnsjglrnvfjdngdfgbsrjkn,,dfnfjdngsrjngk;rtsntgirengdfngkjrengrengnzdfkgnarel-ngadfkgndz,:mngz-kjdnv  zdsjrengarenjengjerg mdngjdfngkjdzfngkjdfngjznv kzdfgnzdmdhjsndfkjsdfkjdnfdgbjfddbfdbgfdbgfdmnfbfd"));
		assertEquals(false, RazonSocial.Valido("CUBETECHNOLOGIC SAS DE CVksmfklsdmfangkjdnfgmdfngmjsnfdnsjglrnvfjdngdfgbsrjkn,,dfnfjdngsrjngk;rtsntgirengdfngkjrengrengnzdfkgnarel-ngadfkgndz,:mngz-kjdnv  zdsjrengarenjengjerg mdngjdfngkjdzfngkjdfngjznv kzdfgnzdmdhjsndfkjsdfkjdnfdgbjfddbfdbgfdbgfdmnfbfdab"));
	}
	
	@Test( expected = IllegalArgumentException.class)
	public void constructorException(){
		new RazonSocial(".CUBETECHNOLOGIC SAS DE CV");
	}
	
	@Test
	public void constructorOK(){
		new RazonSocial("CUBETECHNOLOGIC SAS DE CV");
	}

}
