BusinessParameter and BusinessParameterConfiguration

src/main/java/com/bytesw/bytebot/bean/BusinessParameterBean.java

+package com.bytesw.bytebot.bean;
+
+import com.google.gson.annotations.Expose;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+import java.time.OffsetDateTime;
+
+
+@Getter @Setter
+public class BusinessParameterBean implements Serializable {
+    @Expose private BigInteger id;
+    @Expose private long version;
+    @Expose private String key;
+    @Expose private String description;
+    @Expose private String required;
+    @Expose private String defaultValue;
+    @Expose private String currentValue;
+    @Expose private OffsetDateTime dateFrom;
+    @Expose private OffsetDateTime dateApplyFrom;
+    @Expose private String programmedValue;
+    @Expose private BigInteger currentConfigurationId;
+    @Expose private BigInteger programmedConfigurationId;
+}

src/main/java/com/bytesw/bytebot/bean/BusinessParameterConfigurationBean.java

+package com.bytesw.bytebot.bean;
+
+import com.google.gson.annotations.Expose;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+import java.time.OffsetDateTime;
+
+
+@Getter @Setter
+public class BusinessParameterConfigurationBean implements Serializable {
+    @Expose private BigInteger id;
+    @Expose private long version;
+    @Expose private OffsetDateTime from;
+    @Expose private OffsetDateTime to;
+    @Expose private String value;
+    @Expose private String programmedValue;
+    @Expose private BusinessParameterBean businessParameters;
+    @Expose private BigInteger currentConfigurationId;
+    @Expose private BigInteger programmedConfigurationId;
+}

src/main/java/com/bytesw/bytebot/bean/BusinessParameterValueBean.java

+package com.bytesw.bytebot.bean;
+
+import com.google.gson.annotations.Expose;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.Serializable;
+import java.math.BigInteger;
+import java.time.OffsetDateTime;
+
+
+@Getter @Setter
+public class BusinessParameterValueBean implements Serializable {
+    @Expose private String key;
+    @Expose private String description;
+    @Expose private boolean required;
+    @Expose private String defaultValue;
+    @Expose private String value;
+    @Expose private OffsetDateTime from;
+    @Expose private BigInteger id;
+}

src/main/java/com/bytesw/bytebot/controller/BusinessParameterConfigurationController.java

+package com.bytesw.bytebot.controller;
+
+import com.bytesw.bytebot.service.BusinessParameterConfigurationService;
+import com.bytesw.xdf.annotation.ProgramSecurity;
+import com.bytesw.xdf.controller.XDFController;
+import com.bytesw.bytebot.bean.BusinessParameterConfigurationBean;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RestController;
+
+import java.math.BigInteger;
+
+
+@RestController()
+@RequestMapping("/service/settings/business-parameter-configuration")
+@ProgramSecurity("BUSINESS_PARAMETERS_CONFIGURATION")
+@Log4j2
+public class BusinessParameterConfigurationController extends XDFController<BusinessParameterConfigurationBean, BigInteger> {
+    public BusinessParameterConfigurationController(BusinessParameterConfigurationService service) {
+        super(service);
+    }
+}

src/main/java/com/bytesw/bytebot/controller/BusinessParameterController.java

+package com.bytesw.bytebot.controller;
+
+
+import com.bytesw.bytebot.bean.BusinessParameterBean;
+import com.bytesw.bytebot.bean.BusinessParameterValueBean;
+import com.bytesw.bytebot.bean.BusinessParameterConfigurationBean;
+import com.bytesw.bytebot.service.BusinessParameterService;
+import com.bytesw.xdf.annotation.ProgramSecurity;
+import com.bytesw.xdf.controller.XDFController;
+import com.bytesw.xdf.exception.ReferentialIntegrityException;
+import com.bytesw.xdf.sql.beans.Pagination;
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import io.swagger.annotations.ApiParam;
+import io.swagger.annotations.ApiResponse;
+import io.swagger.annotations.ApiResponses;
+import lombok.extern.log4j.Log4j2;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.orm.ObjectOptimisticLockingFailureException;
+import org.springframework.security.access.prepost.PreAuthorize;
+import org.springframework.web.bind.annotation.*;
+
+import javax.servlet.http.HttpServletRequest;
+import java.math.BigInteger;
+import java.time.OffsetDateTime;
+import java.util.List;
+
+
+@RestController()
+@RequestMapping("/service/settings/business-parameter")
+@ProgramSecurity("business-parameters")
+@Log4j2
+public class BusinessParameterController extends XDFController<BusinessParameterBean, BigInteger> {
+    @Autowired BusinessParameterService service;
+
+    @Autowired
+    protected GsonBuilder gsonBuilder;
+
+    public BusinessParameterController(BusinessParameterService service) {
+        super(service);
+    }
+
+    @RequestMapping(value = {"/value/{key}"}, method = {RequestMethod.PUT})
+    @ApiResponses({
+            @ApiResponse(code = 200, message = "Success", response = ResponseEntity.class),
+            @ApiResponse(code = 404,message = "Not Found"),
+            @ApiResponse(code = 409,message = "Already exists"),
+            @ApiResponse(code = 505, message = "Internal Server Error")
+    })
+    @PreAuthorize("hasPermission(this, 'edit')")
+    public ResponseEntity<Void> addNewAddValue(
+            @ApiParam(value = "key", required = true) @PathVariable("key") String key,
+            @ApiParam(value = "value", required = true) @RequestParam("value") String value,
+            @ApiParam(value = "from", required = false) @RequestParam("from") String fromString) {
+
+        OffsetDateTime from = OffsetDateTime.parse(fromString);
+
+        this.service.addValue(key, value, from);
+        return new ResponseEntity(HttpStatus.OK);
+    }
+
+    @RequestMapping(value = {"/create"}, method = {RequestMethod.POST})
+    @ApiResponses({
+            @ApiResponse(code = 200, message = "Success", response = ResponseEntity.class),
+            @ApiResponse(code = 409, message = "Already Exists"),
+            @ApiResponse(code = 505, message = "Internal Server Error")
+    })
+    @PreAuthorize("hasPermission(this, 'new')")
+    public ResponseEntity<String> createWithValue(@RequestBody BusinessParameterValueBean bean, HttpServletRequest req) {
+        Gson gson = gsonBuilder.create();
+        bean = this.service.createWithValue(bean);
+        return new ResponseEntity(gson.toJson(bean), HttpStatus.OK);
+    }
+
+    @RequestMapping(value = {"/current/{key}"}, method = {RequestMethod.GET})
+    @ApiResponses({
+            @ApiResponse(code = 200, message = "Success", response = ResponseEntity.class),
+            @ApiResponse(code = 404,message = "Not Found"),
+            @ApiResponse(code = 409, message = "Already Exists"),
+            @ApiResponse(code = 505, message = "Internal Server Error")
+    })
+    @PreAuthorize("hasPermission(this, 'new')")
+    public ResponseEntity<String> getCurrentValue(@ApiParam(value = "key", required = true) @PathVariable("key") String key) {
+        Gson gson = gsonBuilder.create();
+//        String value = this.service.getCurrentValue(key);
+        String value = this.service.getCurrentValueParameterByKey(key);
+        return new ResponseEntity(gson.toJson(value), HttpStatus.OK);
+    }
+
+    @ApiResponses({@ApiResponse(
+            code = 200,
+            message = "Success",
+            response = ResponseEntity.class
+    ), @ApiResponse(
+            code = 505,
+            message = "Internal Server Error"
+    )})
+    @RequestMapping(
+            method = {RequestMethod.GET},
+            value = {"/parameter-value/{key}"}
+    )
+    @ResponseBody
+    @PreAuthorize("hasPermission(this, 'view')")
+    public ResponseEntity<String> getFeaturesTemplate(@PathVariable("key") String key) {
+        String featuresTemplate = ((BusinessParameterService)this.service).getCurrentValueParameterByKey(key);
+        return new ResponseEntity(this.gson.toJson(featuresTemplate), HttpStatus.OK);
+    }
+
+    @ApiResponses({@ApiResponse(
+            code = 200,
+            message = "Success",
+            response = ResponseEntity.class
+    ), @ApiResponse(
+            code = 505,
+            message = "Internal Server Error"
+    )})
+    @RequestMapping(
+            method = {RequestMethod.POST},
+            value = {"/page"}
+    )
+    @ResponseBody
+    @Override
+    @PreAuthorize("hasPermission(this, 'view')")
+    public ResponseEntity<String> findAllByPagination(@RequestBody Pagination<BusinessParameterBean> pagination) {
+        if (pagination.getFilterExpression()!=null) {
+            if (pagination.getFilterExpression().contains("(required==Y)")) {
+                pagination.setFilterExpression(pagination.getFilterExpression().replace("(required==Y)", "(required==true)"));
+            }
+        }
+        this.service.searchByPagination(pagination);
+        return new ResponseEntity(this.gson.toJson(pagination), HttpStatus.OK);
+    }
+
+    @ApiResponses({@ApiResponse(
+            code = 200,
+            message = "Success",
+            response = ResponseEntity.class
+    ), @ApiResponse(
+            code = 404,
+            message = "Not Found"
+    ), @ApiResponse(
+            code = 505,
+            message = "Internal Server Error"
+    )})
+    @RequestMapping(
+            value = {"/{id}"},
+            method = {RequestMethod.DELETE}
+    )
+    @PreAuthorize("hasPermission(this, 'delete')")
+    public ResponseEntity<String> delete(@PathVariable("id") BigInteger id, HttpServletRequest req) {
+        this.service.delete(id);
+        return new ResponseEntity(HttpStatus.OK);
+    }
+
+    @RequestMapping(
+            value = {"/{id}"},
+            method = {RequestMethod.PUT}
+    )
+    @ApiResponses({@ApiResponse(
+            code = 200,
+            message = "Success",
+            response = ResponseEntity.class
+    ), @ApiResponse(
+            code = 404,
+            message = "Not Found"
+    ), @ApiResponse(
+            code = 505,
+            message = "Internal Server Error"
+    )})
+    @PreAuthorize("hasPermission(this, 'edit')")
+    public ResponseEntity<String> update(@PathVariable("id") BigInteger id, @RequestBody BusinessParameterBean bean, HttpServletRequest req) {
+        try {
+            if (this.service.validateKey(bean)) {
+                throw new ReferentialIntegrityException("Ya existe un identificador con el mismo nombre");
+            } else {
+                this.service.update(bean, id);
+            }
+        } catch (ObjectOptimisticLockingFailureException var6) {
+            BusinessParameterBean actualBean = this.service.getById(id);
+            return new ResponseEntity(this.gson.toJson(actualBean), HttpStatus.CONFLICT);
+        }
+
+        return new ResponseEntity(HttpStatus.OK);
+    }
+
+    @RequestMapping(
+            value = {"/"},
+            method = {RequestMethod.POST}
+    )
+    @ApiResponses({@ApiResponse(
+            code = 200,
+            message = "Success",
+            response = ResponseEntity.class
+    ), @ApiResponse(
+            code = 409,
+            message = "Already Exists"
+    ), @ApiResponse(
+            code = 505,
+            message = "Internal Server Error"
+    )})
+    @PreAuthorize("hasPermission(this, 'new')")
+    public ResponseEntity<String> create(@RequestBody BusinessParameterBean bean, HttpServletRequest req) {
+        if (this.service.validateKey(bean)) {
+            throw new ReferentialIntegrityException("Ya existe un identificador con el mismo nombre");
+        } else {
+            bean = this.service.create(bean);
+            return new ResponseEntity(this.gson.toJson(bean), HttpStatus.OK);
+        }
+    }
+
+    @ApiResponses({@ApiResponse(
+            code = 200,
+            message = "Success",
+            response = ResponseEntity.class
+    ), @ApiResponse(
+            code = 404,
+            message = "Not Found"
+    ), @ApiResponse(
+            code = 505,
+            message = "Internal Server Error"
+    )})
+    @RequestMapping(
+            value = {"/searchKey/{busnessKey}"},
+            method = {RequestMethod.GET}
+    )
+    @PreAuthorize("hasPermission(this, 'showHistory')")
+    public ResponseEntity<String> findByKey(@PathVariable("busnessKey") BigInteger busnessKey, HttpServletRequest req) {
+        List<BusinessParameterConfigurationBean> bean = this.service.getConfigurationParametersList(busnessKey);
+        return new ResponseEntity(this.gson.toJson(bean), HttpStatus.OK);
+    }
+}

src/main/java/com/bytesw/bytebot/model/BusinessParameter.java

+package com.bytesw.bytebot.model;
+
+import com.bytesw.xdf.model.converter.BooleanToStringConverter;
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import org.hibernate.envers.Audited;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.math.BigInteger;
+
+@Audited
+@Entity
+@Table(name = "AVB_BUSINESS_PARAMETER")
+@NamedQuery(name = "BusinessParameter.findByPK", query = "Select u from BusinessParameter u where u.id = ?1")
+@Getter @Setter @EqualsAndHashCode @ToString(exclude = "id")
+public class BusinessParameter implements Serializable {
+
+    @Id
+    @Column(name = "BUPA_ID")
+    @SequenceGenerator(name = "AVB_BUSINESS_PARAMETER_GENERATOR", sequenceName = "AVB_BUSINESS_PARAMETER_SEQ", initialValue = 1, allocationSize = 1)
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "AVB_BUSINESS_PARAMETER_GENERATOR")
+    private BigInteger id;
+
+    @Version
+    @Column(name = "VERSION")
+    @Basic(optional = false)
+    private long version;
+
+    @Column(name = "BUPA_KEY", nullable = false, unique = true)
+    private String key;
+
+    @Column(name = "BUPA_DESCR", nullable = false)
+    private String description;
+
+    @Column(name = "BUPA_REQUI", nullable = false)
+    @Convert(converter = BooleanToStringConverter.class)
+    private Boolean required;
+
+    @Column(name = "BUPA_DEFVA")
+    private String defaultValue;
+
+}

src/main/java/com/bytesw/bytebot/model/BusinessParameterConfiguration.java

+package com.bytesw.bytebot.model;
+
+import lombok.EqualsAndHashCode;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import org.hibernate.envers.Audited;
+
+import javax.persistence.*;
+import java.io.Serializable;
+import java.math.BigInteger;
+import java.time.OffsetDateTime;
+
+
+@Audited
+@Entity
+@Table(name = "AVB_BUSINESS_PARAMETER_CONFIG")
+@NamedQuery(name = "BusinessParameterConfiguration.findByPK", query = "Select u from BusinessParameterConfiguration u where u.id = ?1")
+@Getter @Setter @EqualsAndHashCode @ToString(exclude = "id")
+public class BusinessParameterConfiguration implements Serializable, Comparable<BusinessParameterConfiguration> {
+
+    @Id
+    @Column(name = "BUPC_ID")
+    @SequenceGenerator(name = "AVB_BUSINESS_PARAMETER_CONFIG_GENERATOR", sequenceName = "AVB_BUSINESS_PARAM_CONFIG_SEQ", initialValue = 1, allocationSize = 1)
+    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "AVB_BUSINESS_PARAMETER_CONFIG_GENERATOR")
+    private BigInteger id;
+
+    @Version
+    @Column(name = "VERSION")
+    @Basic(optional = false)
+    private long version;
+
+    @Column(name = "BUPC_FROM", nullable = false)
+    private OffsetDateTime from;
+
+    @Column(name = "BUPC_TO")
+    private OffsetDateTime to;
+
+    @Column(name = "BUPC_VALUE", nullable = false)
+    private String value;
+
+    @ManyToOne(optional = false)
+    @JoinColumn(name = "BUPA_ID", referencedColumnName = "BUPA_ID", nullable = false)
+    private BusinessParameter businessParameter;
+
+    @Override
+    public int compareTo(BusinessParameterConfiguration o) {
+        return from.compareTo(o.getFrom());
+    }
+}

src/main/java/com/bytesw/bytebot/repository/BusinessParameterConfigurationRepository.java

+package com.bytesw.bytebot.repository;
+
+
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import com.bytesw.bytebot.model.BusinessParameterConfiguration;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.query.Param;
+
+import java.math.BigInteger;
+import java.time.OffsetDateTime;
+import java.util.List;
+import java.util.Optional;
+
+
+public interface BusinessParameterConfigurationRepository extends CrudRepository<BusinessParameterConfiguration, BigInteger>, JpaSpecificationExecutor<BusinessParameterConfiguration> {
+    @Query("select b from BusinessParameterConfiguration b where b.businessParameter.key = :key and ((b.from < :fromDate and b.to >= :fromDate) OR (b.to is null))")
+    List<BusinessParameterConfiguration> findValidByKey(@Param("key") String key, @Param("fromDate") OffsetDateTime fromDate);
+
+    @Query("select b from BusinessParameterConfiguration b where b.businessParameter.key = :key and ((b.from < :currentDate and b.to >= :currentDate) OR (b.from < :currentDate and b.to is null))")
+    Optional<BusinessParameterConfiguration> findCurrentValueByKey(@Param("key") String key, @Param("currentDate") OffsetDateTime currentDate);
+
+    @Query("select b from BusinessParameterConfiguration b where b.businessParameter.id = :id")
+    List<BusinessParameterConfiguration> findBusinessParameterConfigurationListByBusinessParameter(@Param("id") BigInteger id);
+
+    @Query("select b from BusinessParameterConfiguration b where b.businessParameter.id = :id and (b.to > :toDate or b.to is null) order by b.from desc")
+    List<BusinessParameterConfiguration> findBusinessParameterConfigurationListByBusinessParameterWithLowestDateFrom(@Param("id") BigInteger id, @Param("toDate") OffsetDateTime toDate);
+}

src/main/java/com/bytesw/bytebot/repository/BusinessParameterRepository.java

+package com.bytesw.bytebot.repository;
+
+import com.bytesw.bytebot.model.BusinessParameter;
+import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.query.Param;
+
+import java.math.BigInteger;
+import java.util.Optional;
+
+/**
+ * @author Renzo Carranza
+ * @version 26/08/2021
+ * <p>
+ * Copyright (c) 2019 Byte, S.A. Todos los derechos reservados.
+ * <p>
+ * Este software constituye información confidencial y propietaria de Byte, S.A.
+ * ("Información Confidencial"). Usted no debe develar dicha Información
+ * Confidencial y debe usarla de acuerdo con los términos de aceptación de
+ * licencia de uso que firmó con Byte.
+ */
+public interface BusinessParameterRepository extends CrudRepository<BusinessParameter, BigInteger>, JpaSpecificationExecutor<BusinessParameter> {
+    @Query("select b from BusinessParameter b where b.key = :key")
+    Optional<BusinessParameter> findByKey(@Param("key") String key);
+}

src/main/java/com/bytesw/bytebot/service/BusinessParameterConfigurationService.java

+package com.bytesw.bytebot.service;
+
+import com.bytesw.bytebot.service.BusinessParameterService;
+import com.bytesw.bytebot.repository.BusinessParameterRepository;
+import com.bytesw.bytebot.repository.BusinessParameterConfigurationRepository;
+import com.bytesw.bytebot.model.BusinessParameter;
+import com.bytesw.bytebot.model.BusinessParameterConfiguration;
+import com.bytesw.bytebot.bean.BusinessParameterConfigurationBean;
+import com.bytesw.xdf.exception.NotFoundException;
+import com.bytesw.xdf.service.XDFService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+
+import java.math.BigInteger;
+import java.util.Optional;
+
+@Service
+@Transactional
+public class BusinessParameterConfigurationService extends XDFService<BusinessParameterConfiguration, BusinessParameterConfigurationBean, BigInteger> {
+    @Autowired
+    private BusinessParameterService gatewayBusinessParameterService;
+    @Autowired
+    private BusinessParameterRepository businessParameterRepository;
+    @Autowired
+    private BusinessParameterConfigurationRepository businessParameterConfigurationRepository;
+
+    protected BusinessParameterConfigurationService(BusinessParameterConfigurationRepository repository) {
+        super(repository);
+    }
+
+    @Override
+    protected BusinessParameterConfiguration toModel(BusinessParameterConfiguration model, BusinessParameterConfigurationBean bean) {
+        if (model == null) {
+            model = new BusinessParameterConfiguration();
+        }
+        BeanUtils.copyProperties(bean, model);
+        if (bean.getBusinessParameters() == null) {
+            throw new NotFoundException("BusinessParameter can not be null");
+        }
+        Optional<BusinessParameter> businessParameterOptional = businessParameterRepository.findById(bean.getBusinessParameters().getId());
+        if (!businessParameterOptional.isPresent()) {
+            throw new NotFoundException("BusinessParameter not found " + bean.getBusinessParameters().getId());
+        }
+        model.setBusinessParameter(businessParameterOptional.get());
+        return model;
+    }
+
+    @Override
+    protected BusinessParameterConfigurationBean toBean(BusinessParameterConfiguration model) {
+        BusinessParameterConfigurationBean bean = new BusinessParameterConfigurationBean();
+        BeanUtils.copyProperties(model, bean);
+        bean.setBusinessParameters(gatewayBusinessParameterService.toBean(model.getBusinessParameter()));
+        return bean;
+    }
+}

src/main/java/com/bytesw/bytebot/service/BusinessParameterService.java

+package com.bytesw.bytebot.service;
+
+import com.bytesw.bytebot.model.BusinessParameter;
+import com.bytesw.bytebot.model.BusinessParameterConfiguration;
+import com.bytesw.bytebot.bean.BusinessParameterBean;
+import com.bytesw.bytebot.bean.BusinessParameterConfigurationBean;
+import com.bytesw.bytebot.bean.BusinessParameterValueBean;
+import com.bytesw.xdf.exception.AlreadyExistsException;
+import com.bytesw.xdf.exception.NotFoundException;
+import com.bytesw.xdf.service.XDFService;
+import org.springframework.beans.BeanUtils;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
+import com.bytesw.bytebot.repository.BusinessParameterConfigurationRepository;
+import com.bytesw.bytebot.repository.BusinessParameterRepository;
+import java.math.BigInteger;
+import java.time.OffsetDateTime;
+import java.util.*;
+
+
+@Service
+@Transactional
+public class BusinessParameterService extends XDFService<BusinessParameter, BusinessParameterBean, BigInteger> {
+    @Autowired
+    BusinessParameterRepository businessParameterRepository;
+    @Autowired
+    BusinessParameterConfigurationRepository businessParameterConfigurationRepository;
+    @Autowired
+    private BusinessParameterService businessParameterService;
+    @Autowired
+    private BusinessParameterConfigurationService businessParameterConfigurationService;
+
+    protected BusinessParameterService(BusinessParameterRepository repository) {
+        super(repository);
+    }
+
+    @Override
+    protected BusinessParameter toModel(BusinessParameter model, BusinessParameterBean bean) {
+        if (model == null) {
+            model = new BusinessParameter();
+        }
+        BeanUtils.copyProperties(bean, model);
+        model.setRequired("Y".equals(bean.getRequired()));
+        return model;
+    }
+
+    @Override
+    protected BusinessParameterBean toBean(BusinessParameter model) {
+        BusinessParameterBean bean = new BusinessParameterBean();
+        BeanUtils.copyProperties(model, bean);
+        bean.setRequired(model.getRequired() ? "Y" : "N");
+        BusinessParameterConfigurationBean businessParameterConfigurationBean = getBusinessConfiguration(model.getId());
+        bean.setCurrentValue(businessParameterConfigurationBean.getValue());
+        bean.setDateFrom(businessParameterConfigurationBean.getFrom());
+        bean.setDateApplyFrom(businessParameterConfigurationBean.getTo());
+        bean.setProgrammedValue(businessParameterConfigurationBean.getProgrammedValue());
+        bean.setCurrentConfigurationId(businessParameterConfigurationBean.getCurrentConfigurationId());
+        bean.setProgrammedConfigurationId(businessParameterConfigurationBean.getProgrammedConfigurationId());
+        return bean;
+    }
+
+    /**
+     * Permite crear un parámetro general utilizando el valor y la fecha de aplicación. Si la fecha no viene entonces se utiliza la fecha actual.
+     * <p></p>
+     *
+     * @param bean
+     * @return
+     */
+    public BusinessParameterValueBean createWithValue(BusinessParameterValueBean bean) {
+        Optional<BusinessParameter> businessParameterOptional = businessParameterRepository.findByKey(bean.getKey());
+        if (businessParameterOptional.isPresent()) {
+            String message = String.format("BusinessParameter is already created: %s. ", bean.getKey());
+            throw new AlreadyExistsException(message);
+        }
+        BusinessParameter businessParameter = new BusinessParameter();
+        businessParameter.setKey(bean.getKey());
+        businessParameter.setDescription(bean.getDescription());
+        businessParameter.setRequired(bean.isRequired());
+        businessParameter.setDefaultValue(bean.getDefaultValue());
+        businessParameter = businessParameterRepository.save(businessParameter);
+
+        if (bean.getFrom() == null) {
+            bean.setFrom(OffsetDateTime.now());
+        }
+
+        BusinessParameterConfiguration businessParameterConfiguration = prepareBusinessParameterConfiguration(businessParameter, bean.getValue(), bean.getFrom());
+        businessParameterConfiguration.setBusinessParameter(businessParameter);
+        businessParameterConfigurationRepository.save(businessParameterConfiguration);
+
+        bean.setId(businessParameter.getId());
+        return bean;
+    }
+
+    /**
+     * Este método parte de que solo se puede un valor actual y/o un valor programado.
+     *
+     * @param key
+     * @param value
+     * @return
+     */
+    public void addValue(String key, String value, OffsetDateTime from) {
+        Optional<BusinessParameter> businessParameterOptional = businessParameterRepository.findByKey(key);
+        if (!businessParameterOptional.isPresent()) {
+            String message = String.format("BusinessParameter %s not found.", key);
+            throw new NotFoundException(message);
+        }
+
+        if (from == null) {
+            from = OffsetDateTime.now();
+        } else if (from.compareTo(OffsetDateTime.now()) < 0) {
+            String message = String.format("New date (%s) for the parameter (%s)  cannot be less than the current", key, from.toString());
+            throw new NotFoundException(message);
+        }
+
+        List<BusinessParameterConfiguration> businessParameterConfigurationList = businessParameterConfigurationRepository.findValidByKey(key, from);
+        if (businessParameterConfigurationList.isEmpty()) {
+            BusinessParameterConfiguration businessParameterConfiguration = prepareBusinessParameterConfiguration(businessParameterOptional.get(), value, from);
+            businessParameterConfigurationRepository.save(businessParameterConfiguration);
+        } else {
+            Collections.sort(businessParameterConfigurationList);
+            OffsetDateTime temporallyTo = null;
+            for (BusinessParameterConfiguration businessParameterConfiguration : businessParameterConfigurationList) {
+                if (businessParameterConfiguration.getTo() != null) {
+                    if (temporallyTo != null) {
+                        businessParameterConfiguration.setFrom(temporallyTo);
+                    }
+                    temporallyTo = businessParameterConfiguration.getTo();
+                    businessParameterConfiguration.setTo(from);
+                    businessParameterConfigurationRepository.save(businessParameterConfiguration);
+                    continue;
+                }
+                if (temporallyTo != null) {
+                    businessParameterConfiguration.setFrom(from);
+                    businessParameterConfiguration.setValue(value);
+                    businessParameterConfigurationRepository.save(businessParameterConfiguration);
+                } else {
+                    businessParameterConfiguration.setTo(from);
+                    businessParameterConfigurationRepository.save(businessParameterConfiguration);
+
+                    businessParameterConfiguration = prepareBusinessParameterConfiguration(businessParameterOptional.get(), value, from);
+                    businessParameterConfigurationRepository.save(businessParameterConfiguration);
+                }
+
+            }
+        }
+    }
+
+    private BusinessParameterConfiguration prepareBusinessParameterConfiguration(BusinessParameter businessParameter, String value, OffsetDateTime from) {
+        BusinessParameterConfiguration businessParameterConfiguration = new BusinessParameterConfiguration();
+        businessParameterConfiguration.setValue(value);
+        if (from == null) {
+            businessParameterConfiguration.setFrom(OffsetDateTime.now());
+        } else {
+            businessParameterConfiguration.setFrom(from);
+        }
+        businessParameterConfiguration.setBusinessParameter(businessParameter);
+        return businessParameterConfiguration;
+    }
+
+    public String getCurrentValueParameterByKey(String key) {
+        String value = businessParameterService.getCurrentValueParameterByKey(key);
+//        String value = businessParameterService.getCurrentValue(key);
+        if (Objects.isNull(value)) {
+            throw new RuntimeException(String.format("Parameter %s not found", key));
+        }
+        return value;
+    }
+
+    @Override
+    public void delete(BigInteger id) {
+        List<BusinessParameterConfiguration> businessParameterConfigurationList = businessParameterConfigurationRepository.findBusinessParameterConfigurationListByBusinessParameter(id);
+        for (BusinessParameterConfiguration businessParameterConfiguration : businessParameterConfigurationList) {
+            businessParameterConfigurationRepository.delete(businessParameterConfiguration);
+        }
+        Optional<BusinessParameter> found = this.repository.findById(id);
+        if (!found.isPresent()) {
+            throw new NotFoundException();
+        } else {
+            this.repository.delete(found.get());
+        }
+    }
+
+    @Override
+    public BusinessParameterBean update(BusinessParameterBean bean, BigInteger id) {
+        Optional<BusinessParameter> found = this.repository.findById(id);
+        if (!found.isPresent()) {
+            throw new NotFoundException();
+        } else {
+            BusinessParameter businesParameter = this.toModel(found.get(), bean);
+            BeanUtils.copyProperties(businesParameter, found.get());
+            businesParameter = (BusinessParameter) this.repository.save(found.get());
+            if (bean.getDateFrom() != null) {
+                if (bean.getCurrentConfigurationId() != null) {
+                    Optional<BusinessParameterConfiguration> businessParameterConfigurationCurrent = businessParameterConfigurationRepository.findById(bean.getCurrentConfigurationId());
+                    businessParameterConfigurationCurrent.get().setFrom(bean.getDateFrom());
+                    businessParameterConfigurationCurrent.get().setTo(bean.getDateApplyFrom());
+                    businessParameterConfigurationCurrent.get().setValue(bean.getCurrentValue());
+                    businessParameterConfigurationRepository.save(businessParameterConfigurationCurrent.get());
+                } else {
+                    BusinessParameterConfiguration businessParameterConfigurationCurrent = new BusinessParameterConfiguration();
+                    businessParameterConfigurationCurrent.setFrom(bean.getDateFrom());
+                    businessParameterConfigurationCurrent.setTo(bean.getDateApplyFrom());
+                    businessParameterConfigurationCurrent.setValue(bean.getCurrentValue());
+                    businessParameterConfigurationCurrent.setBusinessParameter(businesParameter);
+                    businessParameterConfigurationRepository.save(businessParameterConfigurationCurrent);
+                }
+            } else if (bean.getCurrentConfigurationId() != null) {
+                Optional<BusinessParameterConfiguration> businessParameterConfigurationCurrent = businessParameterConfigurationRepository.findById(bean.getCurrentConfigurationId());
+                businessParameterConfigurationRepository.delete(businessParameterConfigurationCurrent.get());
+            }
+            if (bean.getDateApplyFrom() != null) {
+                if (bean.getProgrammedConfigurationId() != null) {
+                    Optional<BusinessParameterConfiguration> businessParameterConfigurationProgrammed = businessParameterConfigurationRepository.findById(bean.getProgrammedConfigurationId());
+                    businessParameterConfigurationProgrammed.get().setFrom(bean.getDateApplyFrom());
+                    businessParameterConfigurationProgrammed.get().setValue(bean.getProgrammedValue());
+                    businessParameterConfigurationRepository.save(businessParameterConfigurationProgrammed.get());
+                } else {
+                    BusinessParameterConfiguration businessParameterConfigurationProgrammed = new BusinessParameterConfiguration();
+                    businessParameterConfigurationProgrammed.setFrom(bean.getDateApplyFrom());
+                    businessParameterConfigurationProgrammed.setValue(bean.getProgrammedValue());
+                    businessParameterConfigurationProgrammed.setBusinessParameter(businesParameter);
+                    businessParameterConfigurationRepository.save(businessParameterConfigurationProgrammed);
+                }
+            } else if (bean.getProgrammedConfigurationId() != null) {
+                Optional<BusinessParameterConfiguration> businessParameterConfigurationProgrammed = businessParameterConfigurationRepository.findById(bean.getProgrammedConfigurationId());
+                businessParameterConfigurationRepository.delete(businessParameterConfigurationProgrammed.get());
+            }
+            return this.toBean(businesParameter);
+        }
+    }
+
+    @Override
+    public BusinessParameterBean create(BusinessParameterBean bean) {
+        BusinessParameter model = new BusinessParameter();
+        BusinessParameterConfiguration businessParameterConfiguration = new BusinessParameterConfiguration();
+        if (this.existsByUK(bean)) {
+            throw new AlreadyExistsException();
+        }
+        model = this.businessParameterRepository.save(this.toModel(model, bean));
+        if (bean.getCurrentValue() != null && !bean.getCurrentValue().isEmpty()) {
+            businessParameterConfiguration.setTo(bean.getDateApplyFrom());
+            businessParameterConfiguration.setFrom(bean.getDateFrom());
+            businessParameterConfiguration.setValue(bean.getCurrentValue());
+            businessParameterConfiguration.setBusinessParameter(model);
+            this.businessParameterConfigurationRepository.save(businessParameterConfiguration);
+        }
+        if (bean.getProgrammedValue() != null && !bean.getProgrammedValue().isEmpty()) {
+            BusinessParameterConfiguration programmedValue = new BusinessParameterConfiguration();
+            programmedValue.setFrom(bean.getDateApplyFrom());
+            programmedValue.setValue(bean.getProgrammedValue());
+            programmedValue.setBusinessParameter(model);
+            this.businessParameterConfigurationRepository.save(programmedValue);
+        }
+        return this.toBean(model);
+    }
+
+    public BusinessParameterConfigurationBean getBusinessConfiguration(BigInteger id) {
+        List<BusinessParameterConfiguration> businessConfigurationList = businessParameterConfigurationRepository.findBusinessParameterConfigurationListByBusinessParameterWithLowestDateFrom(id, OffsetDateTime.now());
+        BusinessParameterConfigurationBean bean = new BusinessParameterConfigurationBean();
+        if (!businessConfigurationList.isEmpty()) {
+            BusinessParameterConfiguration businessParameterConfigurationFirst = businessConfigurationList.get(0);
+            if (businessConfigurationList.size() == 1) {
+                bean.setValue(businessParameterConfigurationFirst.getValue());
+                bean.setFrom(businessParameterConfigurationFirst.getFrom());
+                bean.setCurrentConfigurationId(businessParameterConfigurationFirst.getId());
+            } else {
+                for (BusinessParameterConfiguration bpc : businessConfigurationList) {
+                    if (businessParameterConfigurationFirst.getFrom().equals(bpc.getTo())) {
+                        bean.setValue(bpc.getValue());
+                        bean.setFrom(bpc.getFrom());
+                        bean.setTo(bpc.getTo());
+                        bean.setProgrammedValue(businessParameterConfigurationFirst.getValue());
+                        bean.setCurrentConfigurationId(bpc.getId());
+                        bean.setProgrammedConfigurationId(bpc.getId());
+                        bean.setCurrentConfigurationId(businessParameterConfigurationFirst.getId());
+                    }
+                }
+            }
+        }
+        return bean;
+    }
+
+    public boolean validateKey(BusinessParameterBean bean) {
+        Optional<BusinessParameter> businessParameterOptional = this.businessParameterRepository.findByKey(bean.getKey());
+        System.out.println(businessParameterOptional);
+        if (businessParameterOptional.isPresent()) {
+            BusinessParameterBean businessParameterBeanOptional = toBean(businessParameterOptional.get());
+            if (!businessParameterBeanOptional.getId().equals(bean.getId())) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public List<BusinessParameterConfigurationBean> getConfigurationParametersList(BigInteger busnessKey) {
+        List<BusinessParameterConfiguration> businessParametersConfigurationModelList = this.businessParameterConfigurationRepository.findBusinessParameterConfigurationListByBusinessParameter(busnessKey);
+        List<BusinessParameterConfigurationBean> beanList = new ArrayList<>();
+        if (!businessParametersConfigurationModelList.isEmpty()) {
+            for (BusinessParameterConfiguration model : businessParametersConfigurationModelList) {
+                BusinessParameterConfigurationBean businessParametersConfigurationBean = businessParameterConfigurationService.toBean(model);
+                beanList.add(businessParametersConfigurationBean);
+            }
+            return beanList;
+        }
+        return beanList;
+    }
+}