bflows-bandi-be/src/main/java/net/gepafin/tendermanagement/dao/CompanyDao.java

package net.gepafin.tendermanagement.dao;

import java.util.List;

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import net.gepafin.tendermanagement.config.Translator;
import net.gepafin.tendermanagement.constants.GepafinConstant;
import net.gepafin.tendermanagement.entities.CompanyEntity;
import net.gepafin.tendermanagement.entities.UserEntity;
import net.gepafin.tendermanagement.entities.UserWithCompanyEntity;
import net.gepafin.tendermanagement.model.request.CompanyRequest;
import net.gepafin.tendermanagement.model.response.CompanyResponse;
import net.gepafin.tendermanagement.repositories.CompanyRepository;
import net.gepafin.tendermanagement.repositories.UserWithCompanyRepository;
import net.gepafin.tendermanagement.service.UserService;
import net.gepafin.tendermanagement.util.Utils;
import net.gepafin.tendermanagement.web.rest.api.errors.CustomValidationException;
import net.gepafin.tendermanagement.web.rest.api.errors.ResourceNotFoundException;
import net.gepafin.tendermanagement.web.rest.api.errors.Status;

@Component
public class CompanyDao {

	@Autowired
	private CompanyRepository companyRepository;

	@Autowired
	private UserService userService;

	@Autowired
	private UserWithCompanyRepository userWithCompanyRepository;

	public CompanyResponse createCompany(UserEntity userEntity, CompanyRequest companyRequest) {
		CompanyEntity existingCompany = companyRepository.findByVatNumber(companyRequest.getVatNumber());
		if (existingCompany != null) {
			UserWithCompanyEntity existingRelation = userWithCompanyRepository.findByUserIdAndCompanyId(userEntity.getId(), existingCompany.getId())
					.orElse(null);
			if (existingRelation == null) {
				createUserWithCompanyRelation(userEntity, existingCompany);
			} else {
				throw new CustomValidationException(Status.VALIDATION_ERROR,
						Translator.toLocale(GepafinConstant.USER_ALREADY_CONNECTED_TO_COMPANY));
			}
			return convertCompanyEntityToCompanyResponse(existingCompany);
		} else {
			validateCompany(companyRequest);
			CompanyEntity companyEntity = convertCompanyRequestToCompanyEntity(companyRequest);
			companyRepository.save(companyEntity);
			createUserWithCompanyRelation(userEntity, companyEntity);
			return convertCompanyEntityToCompanyResponse(companyEntity);
		}
	}


	private void validateCompany(CompanyRequest companyRequest) {
		
		if (Boolean.FALSE.equals(StringUtils.isEmpty(companyRequest.getEmail()))
				&& Boolean.FALSE.equals(Utils.isValidEmail(companyRequest.getEmail()))) {
			throw new CustomValidationException(Status.VALIDATION_ERROR,
					Translator.toLocale(GepafinConstant.INVALID_EMAIL));
		}
		if (StringUtils.isEmpty(companyRequest.getVatNumber())) {
			throw new CustomValidationException(Status.VALIDATION_ERROR,
					Translator.toLocale(GepafinConstant.VATNUMBER_MANDATORY));
		}
		if (companyRepository.existsByVatNumber(companyRequest.getVatNumber())) {
			throw new CustomValidationException(Status.VALIDATION_ERROR,
					Translator.toLocale(GepafinConstant.VATNUMBER_ALREADY_EXISTS));
		}
	}

	private UserWithCompanyEntity createUserWithCompanyRelation(UserEntity userEntity, CompanyEntity companyEntity) {
		UserWithCompanyEntity userWithCompanyEntity = new UserWithCompanyEntity();
		if (userEntity.getBeneficiary() != null) {
			userWithCompanyEntity.setBeneficiaryId(userEntity.getBeneficiary().getId());
		}
		userWithCompanyEntity.setCompanyId(companyEntity.getId());
		userWithCompanyEntity.setUserId(userEntity.getId());
		return userWithCompanyRepository.save(userWithCompanyEntity);
	}

	private CompanyEntity convertCompanyRequestToCompanyEntity(CompanyRequest request) {
		CompanyEntity entity = new CompanyEntity();
		entity.setCompanyName(request.getCompanyName());
		entity.setVatNumber(request.getVatNumber());
		entity.setCodiceFiscale(request.getCodiceFiscale());
		entity.setAddress(request.getAddress());
		entity.setPhoneNumber(request.getPhoneNumber());
		entity.setCity(request.getCity());
		entity.setProvince(request.getProvince());
		entity.setCap(request.getCap());
		entity.setCountry(request.getCountry());
		entity.setPec(request.getPec());
		entity.setEmail(request.getEmail());
		entity.setNumberOfEmployees(request.getNumberOfEmployees());
		entity.setAnnualRevenue(request.getAnnualRevenue());
		return entity;
	}

	private CompanyResponse convertCompanyEntityToCompanyResponse(CompanyEntity entity) {
		CompanyResponse response = new CompanyResponse();
		response.setId(entity.getId());
		response.setCompanyName(entity.getCompanyName());
		response.setVatNumber(entity.getVatNumber());
		response.setCodiceFiscale(entity.getCodiceFiscale());
		response.setAddress(entity.getAddress());
		response.setPhoneNumber(entity.getPhoneNumber());
		response.setCity(entity.getCity());
		response.setProvince(entity.getProvince());
		response.setCap(entity.getCap());
		response.setCountry(entity.getCountry());
		response.setPec(entity.getPec());
		response.setEmail(entity.getEmail());
		response.setNumberOfEmployees(entity.getNumberOfEmployees());
		response.setAnnualRevenue(entity.getAnnualRevenue());
		response.setCreatedDate(entity.getCreatedDate());
		response.setUpdatedDate(entity.getUpdatedDate());
		return response;
	}

	public CompanyResponse updateCompany(UserEntity userEntity, Long companyId, CompanyRequest companyRequest) {
		CompanyEntity companyEntity = validateCompany(companyId);
		Utils.setIfUpdated(companyEntity::getCompanyName, companyEntity::setCompanyName,
				companyRequest.getCompanyName());
		Utils.setIfUpdated(companyEntity::getVatNumber, companyEntity::setVatNumber, companyRequest.getVatNumber());
		Utils.setIfUpdated(companyEntity::getCodiceFiscale, companyEntity::setCodiceFiscale,
				companyRequest.getCodiceFiscale());
		Utils.setIfUpdated(companyEntity::getAddress, companyEntity::setAddress, companyRequest.getAddress());
		Utils.setIfUpdated(companyEntity::getPhoneNumber, companyEntity::setPhoneNumber,
				companyRequest.getPhoneNumber());
		Utils.setIfUpdated(companyEntity::getCity, companyEntity::setCity, companyRequest.getCity());
		Utils.setIfUpdated(companyEntity::getProvince, companyEntity::setProvince, companyRequest.getProvince());
		Utils.setIfUpdated(companyEntity::getCap, companyEntity::setCap, companyRequest.getCap());
		Utils.setIfUpdated(companyEntity::getCountry, companyEntity::setCountry, companyRequest.getCountry());
		Utils.setIfUpdated(companyEntity::getPec, companyEntity::setPec, companyRequest.getPec());
		Utils.setIfUpdated(companyEntity::getEmail, companyEntity::setEmail, companyRequest.getEmail());
		Utils.setIfUpdated(companyEntity::getNumberOfEmployees, companyEntity::setNumberOfEmployees,
				companyRequest.getNumberOfEmployees());
		Utils.setIfUpdated(companyEntity::getAnnualRevenue, companyEntity::setAnnualRevenue,
				companyRequest.getAnnualRevenue());
		companyRepository.save(companyEntity);
		return convertCompanyEntityToCompanyResponse(companyEntity);
	}

	public CompanyEntity validateCompany(Long companyId) {
		return companyRepository.findById(companyId).orElseThrow(() -> new ResourceNotFoundException(Status.NOT_FOUND,
				Translator.toLocale(GepafinConstant.COMPANY_NOT_FOUND_MSG)));
	}

	public CompanyResponse getCompany(UserEntity userEntity, Long companyId) {
		return convertCompanyEntityToCompanyResponse(validateCompany(companyId));
	}

	public void deleteCompany(UserEntity userEntity, Long companyId) {
		CompanyEntity companyEntity = validateCompany(companyId);
		companyRepository.delete(companyEntity);
		userWithCompanyRepository.deleteByCompanyId(companyId);
	}

	public List<CompanyResponse> getCompanyByUserId(Long userId) {
		UserEntity userEntity = userService.validateUser(userId);
		List<Long> companyIds = userWithCompanyRepository.findCompanyIdByUserId(userEntity.getId());
		List<CompanyEntity> list = companyRepository.findByIdIn(companyIds);
		return list.stream().map(this::convertCompanyEntityToCompanyResponse).toList();
	}

	public UserWithCompanyEntity validateUserWithCompny(Long userId, Long companyId) {
		return userWithCompanyRepository.findByUserIdAndCompanyId(userId, companyId).orElseThrow(() -> new CustomValidationException(Status.UNAUTHORIZED,
				Translator.toLocale(GepafinConstant.UNAUTHORIZED)));
	}

}