Changes related to postgres

assessment-api/assessment-service/conf/application.conf

@@ -340,7 +340,7 @@ schema.base_path="../../schemas/"
 
 # Cassandra Configuration
 cassandra.lp.connection="127.0.0.1:9042"
-content.keyspace = "content_store"
+content.keyspace = "dev_content_store"
 
 # Redis Configuration
 redis.host="localhost"
@@ -390,12 +390,12 @@ kafka {
   topic.send.enable : true
   topics.instruction : "sunbirddev.assessment.publish.request"
 }
-objectcategorydefinition.keyspace="category_store"
+objectcategorydefinition.keyspace="dev_category_store"
 question {
-  keyspace = "question_store"
+  keyspace = "dev_question_store"
   list.limit=20
 }
-questionset.keyspace="hierarchy_store"
+questionset.keyspace="dev_hierarchy_store"
 
 cassandra {
   lp {

taxonomy-api/taxonomy-actors/src/main/scala/org/sunbird/actors/ObjectCategoryActor.scala

 package org.sunbird.actors
 
 import java.util
-
 import javax.inject.Inject
 import org.apache.commons.lang3.StringUtils
+import org.slf4j.{Logger, LoggerFactory}
 import org.sunbird.actor.core.BaseActor
+import org.sunbird.cache.impl.RedisCache
 import org.sunbird.common.Slug
 import org.sunbird.common.dto.{Request, Response, ResponseHandler}
 import org.sunbird.common.exception.ClientException
@@ -20,11 +21,13 @@ class ObjectCategoryActor @Inject()(implicit oec: OntologyEngineContext) extends
 
     implicit val ec: ExecutionContext = getContext().dispatcher
 
+    private val logger: Logger = LoggerFactory.getLogger(RedisCache.getClass.getCanonicalName)
     override def onReceive(request: Request): Future[Response] = {
         request.getOperation match {
             case Constants.CREATE_OBJECT_CATEGORY => create(request)
             case Constants.READ_OBJECT_CATEGORY => read(request)
             case Constants.UPDATE_OBJECT_CATEGORY => update(request)
+            case Constants.UPLOAD_DATA_OBJECT_CATEGORY => upload(request)
             case _ => ERROR(request.getOperation)
         }
     }
@@ -44,7 +47,7 @@ class ObjectCategoryActor @Inject()(implicit oec: OntologyEngineContext) extends
     private def read(request: Request): Future[Response] = {
         val fields: util.List[String] = JavaConverters.seqAsJavaListConverter(request.get(Constants.FIELDS).asInstanceOf[String].split(",").filter(field => StringUtils.isNotBlank(field) && !StringUtils.equalsIgnoreCase(field, "null"))).asJava
         request.getRequest.put(Constants.FIELDS, fields)
-        DataNode.read(request).map(node => {
+        DataNode.read(request).map(node => {Future
             val metadata: util.Map[String, AnyRef] = NodeUtil.serialize(node, fields, request.getContext.get(Constants.SCHEMA_NAME).asInstanceOf[String], request.getContext.get(Constants.VERSION).asInstanceOf[String])
             ResponseHandler.OK.put(Constants.OBJECT_CATEGORY, metadata)
         })
@@ -58,4 +61,26 @@ class ObjectCategoryActor @Inject()(implicit oec: OntologyEngineContext) extends
         })
     }
 
+    @throws[Exception]
+    private def upload(request: Request): Future[Response] = {
+//        logger.info("Start the upload method")
+//        competencyObj.setCompetencyCode("C1")
+//        competencyObj.setSubject("Midwifery & Gynecological Nursing")
+//        competencyObj.setCompetencyLabel("label")
+//        competencyObj.setCompetencyDescription("Description")
+//        competencyObj.setCompetencyLevel1Label("L1Label")
+//        competencyObj.setCompetencyLevel1Description("L1Desc")
+//        competencyObj.setCompetencyLevel2Label("L2Label")
+//        competencyObj.setCompetencyLevel2Description("L2Desc")
+//        competencyObj.setCompetencyLevel3Label("L3Label")
+//        competencyObj.setCompetencyLevel3Description("L3Desc")
+//        competencyObj.setCompetencyLevel4Label("L4Label")
+//        competencyObj.setCompetencyLevel4Description("L4Desc")
+//        competencyObj.setCompetencyLevel5Label("L5Label")
+//        competencyObj.setCompetencyLevel5Description("L5Desc")
+//        logger.info("After setting all competencies")
+//        competencyRepository.save(competencyObj)
+        Future.apply(ResponseHandler.OK.put(Constants.IDENTIFIER,"12345"))
+    }
+
 }

taxonomy-api/taxonomy-actors/src/main/scala/org/sunbird/utils/Constants.scala

@@ -4,6 +4,7 @@ object Constants {
     val CREATE_OBJECT_CATEGORY: String = "createObjectCategory"
     val READ_OBJECT_CATEGORY: String = "readObjectCategory"
     val UPDATE_OBJECT_CATEGORY: String = "updateObjectCategory"
+    val UPLOAD_DATA_OBJECT_CATEGORY: String = "uploadObjectCategory"
     val IDENTIFIER: String = "identifier"
     val NAME: String = "name"
     val NODE_ID: String = "node_id"

taxonomy-api/taxonomy-service/app/controllers/v4/ObjectCategoryController.scala

@@ -3,19 +3,53 @@ package controllers.v4
 import akka.actor.{ActorRef, ActorSystem}
 import com.google.inject.Singleton
 import controllers.BaseController
+import models.Competency
+import org.slf4j.{Logger, LoggerFactory}
+import org.springframework.beans.factory.annotation.Autowired
+import org.springframework.data.jpa.repository.config.EnableJpaRepositories
+import org.springframework.jdbc.core.namedparam.{MapSqlParameterSource, NamedParameterJdbcTemplate, SqlParameterSource}
+import org.springframework.jdbc.support.{GeneratedKeyHolder, KeyHolder}
+import org.springframework.transaction.annotation.EnableTransactionManagement
+import org.sunbird.cache.impl.RedisCache
+
 import javax.inject.{Inject, Named}
 import org.sunbird.utils.Constants
 import play.api.mvc.ControllerComponents
+import repository.CompetencyRepositoryTrait
+import service.CompetencyService
 import utils.{ActorNames, ApiId}
 
+import java.lang
+import java.util.Optional
 import scala.collection.JavaConverters._
 import scala.concurrent.ExecutionContext
 
 @Singleton
-class ObjectCategoryController @Inject()(@Named(ActorNames.OBJECT_CATEGORY_ACTOR) objectCategoryActor: ActorRef, cc: ControllerComponents, actorSystem: ActorSystem)(implicit exec: ExecutionContext) extends BaseController(cc) {
+@EnableJpaRepositories
+@EnableTransactionManagement
+class ObjectCategoryController @Inject()(@Named(ActorNames.OBJECT_CATEGORY_ACTOR) objectCategoryActor: ActorRef, cc: ControllerComponents, actorSystem: ActorSystem, competencyObj: Competency)(implicit exec: ExecutionContext) extends BaseController(cc) {
+
+//    @Autowired
+//    private val competencyRepositoryLocal:CompetencyRepository = new ObjectCategoryController(objectCategoryActor, cc, actorSystem, competencyObj)
+
+    private val logger: Logger = LoggerFactory.getLogger(RedisCache.getClass.getCanonicalName)
+
+    //final val sql: String = "insert into employee(employeeId, employeeName , employeeAddress,employeeEmail) values(:employeeId,:employeeName,:employeeEmail,:employeeAddress)";
+    final val sql: String = "INSERT INTO taxonomy.competency (competency_code, subject, competency_label, competency_description, competency_level_1_label, competency_level_1_description, competency_level_2_label, competency_level_2_description, competency_level_3_label, competency_level_3_description, competency_level_4_label, competency_level_4_description, competency_level_5_label, competency_level_5_description) VALUES('', '', '', '', '', '', '', '', '', '', '', '', '', '');"
 
     val objectType = "ObjectCategory"
 
+    @Inject
+    var namedParameterJdbcTemplate: NamedParameterJdbcTemplate = null
+    def this(objectCategoryActor: ActorRef, cc: ControllerComponents, actorSystem: ActorSystem, competencyObj: Competency, namedParameterJdbcTemplate: NamedParameterJdbcTemplate)(implicit exec: ExecutionContext) {
+        this(objectCategoryActor,cc,actorSystem,competencyObj)
+        println("this namedParameterJdbcTemplate is "+this.namedParameterJdbcTemplate)
+        println("namedParameterJdbcTemplate is "+namedParameterJdbcTemplate)
+        this.namedParameterJdbcTemplate = namedParameterJdbcTemplate
+        println("again this namedParameterJdbcTemplate is "+this.namedParameterJdbcTemplate)
+    }
+
+
     def create() = Action.async { implicit request =>
         val headers = commonHeaders()
         val body = requestBody()
@@ -46,4 +80,53 @@ class ObjectCategoryController @Inject()(@Named(ActorNames.OBJECT_CATEGORY_ACTOR
         categoryRequest.getContext.put(Constants.IDENTIFIER, identifier)
         getResult(ApiId.UPDATE_OBJECT_CATEGORY, objectCategoryActor, categoryRequest)
     }
+
+    def uploadCompetency() = Action.async { implicit request =>
+        val headers = commonHeaders()
+        val body = requestBody()
+        val category = body.getOrDefault(Constants.OBJECT_CATEGORY, new java.util.HashMap()).asInstanceOf[java.util.Map[String, Object]]
+        category.putAll(headers)
+        val categoryRequest = getRequest(category, headers, Constants.UPLOAD_DATA_OBJECT_CATEGORY)
+        setRequestContext(categoryRequest, Constants.OBJECT_CATEGORY_SCHEMA_VERSION, objectType, Constants.OBJECT_CATEGORY_SCHEMA_NAME)
+        logger.info("Start the upload method")
+        competencyObj.setCompetencyCode("C1")
+        competencyObj.setSubject("Midwifery & Gynecological Nursing")
+        competencyObj.setCompetencyLabel("label")
+        competencyObj.setCompetencyDescription("Description")
+        competencyObj.setCompetencyLevel1Label("L1Label")
+        competencyObj.setCompetencyLevel1Description("L1Desc")
+        competencyObj.setCompetencyLevel2Label("L2Label")
+        competencyObj.setCompetencyLevel2Description("L2Desc")
+        competencyObj.setCompetencyLevel3Label("L3Label")
+        competencyObj.setCompetencyLevel3Description("L3Desc")
+        competencyObj.setCompetencyLevel4Label("L4Label")
+        competencyObj.setCompetencyLevel4Description("L4Desc")
+        competencyObj.setCompetencyLevel5Label("L5Label")
+        competencyObj.setCompetencyLevel5Description("L5Desc")
+        logger.info("After setting all competencies")
+        //competencyRepositoryLocal.save(competencyObj)
+        //competencyService.save(competencyObj);
+        new ObjectCategoryController(objectCategoryActor, cc, actorSystem, competencyObj, namedParameterJdbcTemplate)
+        val holder : KeyHolder = new GeneratedKeyHolder();
+        val param : SqlParameterSource = new MapSqlParameterSource()
+          .addValue("competency_code", competencyObj.getCompetencyCode())
+          .addValue("subject", competencyObj.getSubject())
+          .addValue("competency_label", competencyObj.getCompetencyLabel())
+          .addValue("competency_description", competencyObj.getCompetencyDescription())
+          .addValue("competency_level_1_label", competencyObj.getCompetencyLevel1Label())
+          .addValue("competency_level_1_description", competencyObj.getCompetencyLevel1Description())
+          .addValue("competency_level_2_label", competencyObj.getCompetencyLevel2Label())
+          .addValue("competency_level_2_description", competencyObj.getCompetencyLevel2Description())
+          .addValue("competency_level_3_label", competencyObj.getCompetencyLevel3Label())
+          .addValue("competency_level_3_description", competencyObj.getCompetencyLevel3Description())
+          .addValue("competency_level_4_label", competencyObj.getCompetencyLevel4Label())
+          .addValue("competency_level_4_description", competencyObj.getCompetencyLevel4Description())
+          .addValue("competency_level_5_label", competencyObj.getCompetencyLevel5Label())
+          .addValue("competency_level_5_description", competencyObj.getCompetencyLevel5Description())
+        namedParameterJdbcTemplate.update(sql, param, holder);
+
+        //logger.info("Competency service "+competencyService.findAll())
+        getResult(ApiId.UPLOAD_DATA_OBJECT_CATEGORY, objectCategoryActor, categoryRequest)
+    }
+
 }

taxonomy-api/taxonomy-service/app/handlers/CompetencyExcelParser.scala

+//package handlers
+//
+//import models.Competency
+//import org.apache.poi.xssf.usermodel.XSSFWorkbook
+//import org.slf4j.{Logger, LoggerFactory}
+//import org.springframework.beans.factory.annotation.Autowired
+//import org.springframework.data.jpa.repository.config.EnableJpaRepositories
+//import org.springframework.transaction.annotation.EnableTransactionManagement
+//import org.sunbird.cache.impl.RedisCache
+//import repository.CompetencyRepository
+//
+//import java.io.{File, FileInputStream}
+//import java.lang
+//import java.util.Optional
+//import javax.inject.{Inject, Named}
+//
+//@EnableTransactionManagement
+//@EnableJpaRepositories
+//class CompetencyExcelParser @Inject()(competencyObj : Competency) extends CompetencyRepository {
+//
+//  @Autowired
+//  private val competencyRepositoryLocal = new CompetencyExcelParser(competencyObj);
+//
+//  private val logger: Logger = LoggerFactory.getLogger(RedisCache.getClass.getCanonicalName)
+//  def getCompetency(file: File) = {
+//
+//    try {
+//      val workbook = new XSSFWorkbook(new FileInputStream(file))
+//      val sheet = workbook.getSheetAt(0)
+//      logger.info("Inside the get competency")
+//      (1 until sheet.getPhysicalNumberOfRows)
+//        .filter(rowNum => {
+//          val oRow = Option(sheet.getRow(rowNum))
+//          oRow match {
+//            case Some(_) => {
+//              val competencyCode = sheet.getRow(rowNum).getCell(0)
+//              val subject = sheet.getRow(rowNum).getCell(1)
+//              val competencyLabel = sheet.getRow(rowNum).getCell(2)
+//              val competencyDescription = sheet.getRow(rowNum).getCell(3)
+//              val competencyLevel1Label = sheet.getRow(rowNum).getCell(4)
+//              val competencyLevel1Description = sheet.getRow(rowNum).getCell(5)
+//              val competencyLevel2Label = sheet.getRow(rowNum).getCell(6)
+//              val competencyLevel2Description = sheet.getRow(rowNum).getCell(7)
+//              val competencyLevel3Label = sheet.getRow(rowNum).getCell(8)
+//              val competencyLevel3Description = sheet.getRow(rowNum).getCell(9)
+//              val competencyLevel4Label = sheet.getRow(rowNum).getCell(10)
+//              val competencyLevel4Description = sheet.getRow(rowNum).getCell(11)
+//              val competencyLevel5Label = sheet.getRow(rowNum).getCell(12)
+//              val competencyLevel5Description = sheet.getRow(rowNum).getCell(13)
+//              competencyObj.setCompetencyCode(competencyCode.toString)
+//              competencyObj.setSubject(subject.toString)
+//              competencyObj.setCompetencyLabel(competencyLabel.toString)
+//              competencyObj.setCompetencyDescription(competencyDescription.toString)
+//              competencyObj.setCompetencyLevel1Label(competencyLevel1Label.toString)
+//              competencyObj.setCompetencyLevel1Description(competencyLevel1Description.toString)
+//              competencyObj.setCompetencyLevel2Label(competencyLevel2Label.toString)
+//              competencyObj.setCompetencyLevel2Description(competencyLevel2Description.toString)
+//              competencyObj.setCompetencyLevel3Label(competencyLevel3Label.toString)
+//              competencyObj.setCompetencyLevel3Description(competencyLevel3Description.toString)
+//              competencyObj.setCompetencyLevel4Label(competencyLevel4Label.toString)
+//              competencyObj.setCompetencyLevel4Description(competencyLevel4Description.toString)
+//              competencyObj.setCompetencyLevel5Label(competencyLevel5Label.toString)
+//              competencyObj.setCompetencyLevel5Description(competencyLevel5Description.toString)
+//              competencyRepositoryLocal.save(competencyObj)
+//              boolean2Boolean(true)
+//            }
+//            case None => false
+//          }
+//        }).toList
+//    } catch {
+//      case e : Exception => throw new Exception("Invalid File")
+//    }
+//  }
+//
+//}

taxonomy-api/taxonomy-service/app/models/Competency.java

+package models;
+
+import javax.persistence.Entity;
+import javax.persistence.GeneratedValue;
+import javax.persistence.GenerationType;
+import javax.persistence.Id;
+
+@Entity
+public class Competency {
+    @Id
+    @GeneratedValue(strategy= GenerationType.AUTO)
+    private String competencyCode;
+    private String subject;
+    private String competencyLabel;
+    private String competencyDescription;
+    private String competencyLevel1Label;
+    private String competencyLevel1Description;
+    private String competencyLevel2Label;
+    private String competencyLevel2Description;
+    private String competencyLevel3Label;
+    private String competencyLevel3Description;
+    private String competencyLevel4Label;
+    private String competencyLevel4Description;
+    private String competencyLevel5Label;
+    private String competencyLevel5Description;
+
+    public String getCompetencyCode() {
+        return competencyCode;
+    }
+
+    public void setCompetencyCode(String competencyCode) {
+        this.competencyCode = competencyCode;
+    }
+
+    public String getSubject() {
+        return subject;
+    }
+
+    public void setSubject(String subject) {
+        this.subject = subject;
+    }
+
+    public String getCompetencyLabel() {
+        return competencyLabel;
+    }
+
+    public void setCompetencyLabel(String competencyLabel) {
+        this.competencyLabel = competencyLabel;
+    }
+
+    public String getCompetencyDescription() {
+        return competencyDescription;
+    }
+
+    public void setCompetencyDescription(String competencyDescription) {
+        this.competencyDescription = competencyDescription;
+    }
+
+    public String getCompetencyLevel1Label() {
+        return competencyLevel1Label;
+    }
+
+    public void setCompetencyLevel1Label(String competencyLevel1Label) {
+        this.competencyLevel1Label = competencyLevel1Label;
+    }
+
+    public String getCompetencyLevel1Description() {
+        return competencyLevel1Description;
+    }
+
+    public void setCompetencyLevel1Description(String competencyLevel1Description) {
+        this.competencyLevel1Description = competencyLevel1Description;
+    }
+
+    public String getCompetencyLevel2Label() {
+        return competencyLevel2Label;
+    }
+
+    public void setCompetencyLevel2Label(String competencyLevel2Label) {
+        this.competencyLevel2Label = competencyLevel2Label;
+    }
+
+    public String getCompetencyLevel2Description() {
+        return competencyLevel2Description;
+    }
+
+    public void setCompetencyLevel2Description(String competencyLevel2Description) {
+        this.competencyLevel2Description = competencyLevel2Description;
+    }
+
+    public String getCompetencyLevel3Label() {
+        return competencyLevel3Label;
+    }
+
+    public void setCompetencyLevel3Label(String competencyLevel3Label) {
+        this.competencyLevel3Label = competencyLevel3Label;
+    }
+
+    public String getCompetencyLevel3Description() {
+        return competencyLevel3Description;
+    }
+
+    public void setCompetencyLevel3Description(String competencyLevel3Description) {
+        this.competencyLevel3Description = competencyLevel3Description;
+    }
+
+    public String getCompetencyLevel4Label() {
+        return competencyLevel4Label;
+    }
+
+    public void setCompetencyLevel4Label(String competencyLevel4Label) {
+        this.competencyLevel4Label = competencyLevel4Label;
+    }
+
+    public String getCompetencyLevel4Description() {
+        return competencyLevel4Description;
+    }
+
+    public void setCompetencyLevel4Description(String competencyLevel4Description) {
+        this.competencyLevel4Description = competencyLevel4Description;
+    }
+
+    public String getCompetencyLevel5Label() {
+        return competencyLevel5Label;
+    }
+
+    public void setCompetencyLevel5Label(String competencyLevel5Label) {
+        this.competencyLevel5Label = competencyLevel5Label;
+    }
+
+    public String getCompetencyLevel5Description() {
+        return competencyLevel5Description;
+    }
+
+    public void setCompetencyLevel5Description(String competencyLevel5Description) {
+        this.competencyLevel5Description = competencyLevel5Description;
+    }
+}

taxonomy-api/taxonomy-service/app/models/DatabaseExecutionContext.java

+package models;
+
+import akka.actor.ActorSystem;
+import play.libs.concurrent.CustomExecutionContext;
+
+import javax.inject.Inject;
+
+/**
+ * Custom execution context wired to "database.dispatcher" thread pool
+ */
+public class DatabaseExecutionContext extends CustomExecutionContext {
+    @Inject
+    public DatabaseExecutionContext(ActorSystem actorSystem) {
+        super(actorSystem, "database.dispatcher");
+    }
+}

taxonomy-api/taxonomy-service/app/repository/CompetencyRepository.java

+package repository;
+
+import com.google.inject.ImplementedBy;
+import models.Competency;
+
+import java.util.concurrent.CompletionStage;
+import java.util.stream.Stream;
+
+/**
+ * This interface provides a non-blocking API for possibly blocking operations.
+ */
+@ImplementedBy(JPACompetencyRepository.class)
+public interface CompetencyRepository {
+    CompletionStage<Competency> add(Competency competency);
+
+    CompletionStage<Stream<Competency>> list();
+}

taxonomy-api/taxonomy-service/app/repository/CompetencyRepositoryTrait.scala

+package repository
+
+import models.Competency
+import org.springframework.data.domain.{Example, Page, Pageable, Sort}
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+import java.util.Optional
+import java.{lang, util}
+@Repository
+trait CompetencyRepositoryTrait extends JpaRepository[Competency, String] {
+}
\ No newline at end of file

taxonomy-api/taxonomy-service/app/repository/JPACompetencyRepository.java

+package repository;
+
+import models.Competency;
+import models.DatabaseExecutionContext;
+import play.db.jpa.JPAApi;
+
+import javax.inject.Inject;
+import javax.persistence.EntityManager;
+import java.util.List;
+import java.util.concurrent.CompletionStage;
+import java.util.function.Function;
+import java.util.stream.Stream;
+
+import static java.util.concurrent.CompletableFuture.supplyAsync;
+public class JPACompetencyRepository implements  CompetencyRepository{
+    private final JPAApi jpaApi;
+    private final DatabaseExecutionContext executionContext;
+
+    @Inject
+    public JPACompetencyRepository(JPAApi jpaApi, DatabaseExecutionContext executionContext) {
+        this.jpaApi = jpaApi;
+        this.executionContext = executionContext;
+    }
+
+    @Override
+    public CompletionStage<Competency> add(Competency competency) {
+        return supplyAsync(() -> wrap(em -> insert(em, competency)), executionContext);
+    }
+
+    @Override
+    public CompletionStage<Stream<Competency>> list() {
+        return supplyAsync(() -> wrap(em -> list(em)), executionContext);
+    }
+
+    private <T> T wrap(Function<EntityManager, T> function) {
+        return jpaApi.withTransaction(function);
+    }
+
+    private Competency insert(EntityManager em, Competency competency) {
+        em.persist(competency);
+        return competency;
+    }
+
+    private Stream<Competency> list(EntityManager em) {
+        List<Competency> competencies = em.createQuery("select * from Competency competency", Competency.class).getResultList();
+        return competencies.stream();
+    }
+}

taxonomy-api/taxonomy-service/app/service/CompetencyService.java

+package service;
+
+import models.Competency;
+import org.springframework.data.domain.Example;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Sort;
+import repository.CompetencyRepositoryTrait;
+
+import javax.inject.Singleton;
+import java.util.List;
+import java.util.Optional;
+
+@Singleton
+public class CompetencyService implements CompetencyRepositoryTrait {
+
+    @Override
+    public List<Competency> findAll() {
+        return null;
+    }
+
+    @Override
+    public List<Competency> findAll(Sort sort) {
+        return null;
+    }
+
+    @Override
+    public Page<Competency> findAll(Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public List<Competency> findAllById(Iterable<String> strings) {
+        return null;
+    }
+
+    @Override
+    public long count() {
+        return 0;
+    }
+
+    @Override
+    public void deleteById(String s) {
+
+    }
+
+    @Override
+    public void delete(Competency entity) {
+
+    }
+
+    @Override
+    public void deleteAllById(Iterable<? extends String> strings) {
+
+    }
+
+    @Override
+    public void deleteAll(Iterable<? extends Competency> entities) {
+
+    }
+
+    @Override
+    public void deleteAll() {
+
+    }
+
+    @Override
+    public <S extends Competency> S save(S entity) {
+        return entity;
+    }
+
+    @Override
+    public <S extends Competency> List<S> saveAll(Iterable<S> entities) {
+        return null;
+    }
+
+    @Override
+    public Optional<Competency> findById(String s) {
+        return Optional.empty();
+    }
+
+    @Override
+    public boolean existsById(String s) {
+        return false;
+    }
+
+    @Override
+    public void flush() {
+
+    }
+
+    @Override
+    public <S extends Competency> S saveAndFlush(S entity) {
+        return null;
+    }
+
+    @Override
+    public <S extends Competency> List<S> saveAllAndFlush(Iterable<S> entities) {
+        return null;
+    }
+
+    @Override
+    public void deleteAllInBatch(Iterable<Competency> entities) {
+
+    }
+
+    @Override
+    public void deleteAllByIdInBatch(Iterable<String> strings) {
+
+    }
+
+    @Override
+    public void deleteAllInBatch() {
+
+    }
+
+    @Override
+    public Competency getOne(String s) {
+        return null;
+    }
+
+    @Override
+    public Competency getById(String s) {
+        return null;
+    }
+
+    @Override
+    public <S extends Competency> Optional<S> findOne(Example<S> example) {
+        return Optional.empty();
+    }
+
+    @Override
+    public <S extends Competency> List<S> findAll(Example<S> example) {
+        return null;
+    }
+
+    @Override
+    public <S extends Competency> List<S> findAll(Example<S> example, Sort sort) {
+        return null;
+    }
+
+    @Override
+    public <S extends Competency> Page<S> findAll(Example<S> example, Pageable pageable) {
+        return null;
+    }
+
+    @Override
+    public <S extends Competency> long count(Example<S> example) {
+        return 0;
+    }
+
+    @Override
+    public <S extends Competency> boolean exists(Example<S> example) {
+        return false;
+    }
+}

taxonomy-api/taxonomy-service/app/utils/ApiId.scala

@@ -6,6 +6,7 @@ object ApiId {
 	final val CREATE_OBJECT_CATEGORY = "api.object.category.create"
 	final val READ_OBJECT_CATEGORY = "api.object.category.read"
 	final val UPDATE_OBJECT_CATEGORY = "api.object.category.update"
+	final val UPLOAD_DATA_OBJECT_CATEGORY = "api.object.category.upload"
 	final val CREATE_OBJECT_CATEGORY_DEFINITION = "api.object.category.definition.create"
 	final val READ_OBJECT_CATEGORY_DEFINITION = "api.object.category.definition.read"
 	final val UPDATE_OBJECT_CATEGORY_DEFINITION = "api.object.category.definition.update"

taxonomy-api/taxonomy-service/conf/META-INF/persistence.xml

+<persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
+             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+             xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
+             version="2.2">
+
+    <persistence-unit name="defaultPersistenceUnit" transaction-type="RESOURCE_LOCAL">
+        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
+        <non-jta-data-source>DefaultDS</non-jta-data-source>
+        <properties>
+            <property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver" /> <!-- DB Driver -->
+            <property name="javax.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/postgres" /> <!-- BD Mane -->
+            <property name="javax.persistence.jdbc.user" value="postgres" /> <!-- DB User -->
+            <property name="javax.persistence.jdbc.password" value="postgres" /> <!-- DB Password -->
+
+            <property name="hibernate.dialect" value="org.hibernate.dialect.PostgreSQLDialect"/> <!-- DB Dialect -->
+            <property name="hibernate.hbm2ddl.auto" value="update" /> <!-- create / create-drop / update -->
+
+            <property name="hibernate.show_sql" value="true" /> <!-- Show SQL in console -->
+            <property name="hibernate.format_sql" value="true" /> <!-- Show SQL formatted -->
+        </properties>
+    </persistence-unit>
+
+</persistence>
\ No newline at end of file

taxonomy-api/taxonomy-service/conf/application.conf

@@ -297,6 +297,20 @@ route.bolt.write.all="bolt://localhost:7687"
 route.bolt.read.all="bolt://localhost:7687"
 route.bolt.comment.all="bolt://localhost:7687"
 
+# Postgre configuration
+# spring.jpa.hibernate.ddl-auto="update"
+# spring.datasource.url="jdbc:postgresql://localhost:5432/postgres"
+# spring.datasource.username="postgres"
+# spring.datasource.password="postgres"
+
+#Exposing the datasource through JNDI
+db.default.jndiName=DefaultDS
+jpa.default=defaultPersistenceUnit
+db.default.driver=org.postgresql.Driver
+db.default.url="jdbc:postgresql://localhost:5432/postgres"
+db.default.username="postgres"
+db.default.password="postgres"
+
 # Cassandra Configuration
 cassandra.lp.connection="127.0.0.1:9042"
 cassandra.lpa.connection="127.0.0.1:9042"
@@ -316,5 +330,5 @@ languageCode {
 }
 
 platform.language.codes=["as","bn","en","gu","hi","hoc","jun","ka","mai","mr","unx","or","san","sat","ta","te","urd"]
-objectcategorydefinition.keyspace=category_store
+objectcategorydefinition.keyspace=dev_category_store
 

taxonomy-api/taxonomy-service/conf/routes

@@ -22,6 +22,7 @@ POST      /framework/v3/publish/:identifier               controllers.v3.Framewo
 POST      /object/category/v4/create                           controllers.v4.ObjectCategoryController.create
 PATCH     /object/category/v4/update/:identifier               controllers.v4.ObjectCategoryController.update(identifier:String)
 GET       /object/category/v4/read/:identifier                 controllers.v4.ObjectCategoryController.read(identifier:String, fields:Option[String])
+POST      /object/category/v4/uploadCompetencyData             controllers.v4.ObjectCategoryController.uploadCompetency
 
 # ObjectCategoryDefinition API's
 POST      /object/category/definition/v4/create                controllers.v4.ObjectCategoryDefinitionController.create

taxonomy-api/taxonomy-service/pom.xml

@@ -69,6 +69,27 @@
             <artifactId>scala-library</artifactId>
             <version>${scala.version}</version>
         </dependency>
+        <dependency>
+            <groupId>com.typesafe.play</groupId>
+            <artifactId>play-java-jpa_${scala.major.version}</artifactId>
+            <version>2.7.9</version>
+        </dependency>
+        <dependency>
+            <groupId>postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>9.1-901-1.jdbc4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-jpa</artifactId>
+            <version>2.6.10</version>
+        </dependency>
+        <dependency>
+            <groupId>org.hibernate</groupId>
+            <artifactId>hibernate-core</artifactId>
+            <version>6.1.7.Final</version>
+            <type>pom</type>
+        </dependency>
         <dependency>
             <groupId>org.sunbird</groupId>
             <artifactId>taxonomy-actors</artifactId>
@@ -97,6 +118,11 @@
             <artifactId>logback-kafka-appender</artifactId>
             <version>0.2.0-RC2</version>
         </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-commons</artifactId>
+            <version>2.5.5</version>
+        </dependency>
     </dependencies>
     <build>
         <sourceDirectory>${basedir}/app</sourceDirectory>
@@ -143,6 +169,14 @@
                     <excludedFiles>.*RoutesPrefix.*;.*Routes.*;.*javascript.*</excludedFiles>
                 </configuration>
             </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-compiler-plugin</artifactId>
+                <configuration>
+                    <source>8</source>
+                    <target>8</target>
+                </configuration>
+            </plugin>
         </plugins>
     </build>