Controllers

AngajatorC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.ANGAJATORDTO;
IMPORT COM.DAM.TAM1.ENTITIES.ANGAJATOR;
IMPORT COM.DAM.TAM1.SERVICES.ANGAJATORSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS ANGAJATORCONTROLLER {

@AUTOWIRED
PRIVATE ANGAJATORSERVICE ANGAJATORSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/ANGAJATORI")
PUBLIC LIST<ANGAJATORDTO> GETANGAJATORI(){
LIST<ANGAJATOR> ANGAJATORI = THIS.ANGAJATORSERVICE.GETALLANGAJATORI();

RETURN ANGAJATORI.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/ANGAJATORI/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC ANGAJATORDTO GETANGAJATORBYID(@PATHVARIABLE INTEGER ID) {
ANGAJATOR ANGAJATORFOUND = THIS.ANGAJATORSERVICE.GETANGAJATORBYID(ID);
RETURN CONVERTTODTO(ANGAJATORFOUND);
}

@POSTMAPPING(VALUE= "ANGAJATORI/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC ANGAJATORDTO ADDANGAJATOR(@REQUESTBODY ANGAJATORDTO ANGAJATORDTO)
THROWS PARSEEXCEPTION {
ANGAJATOR ANGAJATOR = CONVERTTOENTITY(ANGAJATORDTO);
ANGAJATOR CREATEDANGAJATOR =
THIS.ANGAJATORSERVICE.SAVEANGAJATOR(ANGAJATOR);

RETURN CONVERTTODTO(CREATEDANGAJATOR);
}

@PUTMAPPING(VALUE="/ANGAJATORI/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATEANGAJATOR(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY ANGAJATORDTO ANGAJATORDTO) THROWS PARSEEXCEPTION {
ANGAJATOR ANGAJATOR = CONVERTTOENTITY(ANGAJATORDTO);
THIS.ANGAJATORSERVICE.UPDATEANGAJATOR(ANGAJATOR);
}

@DELETEMAPPING(VALUE="/ANGAJATORI/DELETE/{ID}")
PUBLIC VOID DELETEANGAJATOR(@PATHVARIABLE INTEGER ID) {
THIS.ANGAJATORSERVICE.DELETEANGAJATOR(ID);
}

//CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE ANGAJATORDTO CONVERTTODTO(ANGAJATOR ANGAJATOR) {
ANGAJATORDTO ANGAJATORDTO = MODELMAPPER.MAP(ANGAJATOR,
ANGAJATORDTO.CLASS);
RETURN ANGAJATORDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE ANGAJATOR CONVERTTOENTITY(ANGAJATORDTO ANGAJATORDTO) THROWS
PARSEEXCEPTION{
ANGAJATOR ANGAJATOR = MODELMAPPER.MAP(ANGAJATORDTO, ANGAJATOR.CLASS);
RETURN ANGAJATOR;
}

AplicareJobC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;
IMPORT COM.DAM.TAM1.DATA.APLICAREJOBDTO;
IMPORT COM.DAM.TAM1.ENTITIES.APLICAREJOB;
IMPORT COM.DAM.TAM1.SERVICES.APLICAREJOBSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS APLICAREJOBCONTROLLER {

@AUTOWIRED
PRIVATE APLICAREJOBSERVICE APLICAREJOBSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/APLICAREJOBURI")
PUBLIC LIST<APLICAREJOBDTO> GETAPLICAREJOBURI(){
LIST<APLICAREJOB> APLICAREJOBURI =
THIS.APLICAREJOBSERVICE.GETALLAPLICAREJOBURI();

RETURN APLICAREJOBURI.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/APLICAREJOBURI/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC APLICAREJOBDTO GETAPLICAREJOBBYID(@PATHVARIABLE INTEGER ID) {
APLICAREJOB APLICAREJOBFOUND =
THIS.APLICAREJOBSERVICE.GETAPLICAREJOBBYID(ID);
RETURN CONVERTTODTO(APLICAREJOBFOUND);
}

@POSTMAPPING(VALUE= "APLICAREJOBURI/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC APLICAREJOBDTO ADDAPLICAREJOB(@REQUESTBODY APLICAREJOBDTO
APLICAREJOBTDTO) THROWS PARSEEXCEPTION {
APLICAREJOB APLICAREJOB = CONVERTTOENTITY(APLICAREJOBDTO);
APLICAREJOB CREATEDAPLICAREJOB =
THIS.APLICAREJOBSERVICE.SAVEAPLICAREJOB(APLICAREJOB);

RETURN CONVERTTODTO(CREATEDAPLICAREJOB);
}

@PUTMAPPING(VALUE="/APLICAREJOBURI/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATEAPLICAREJOB(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY APLICAREJOBDTO APLICAREJOBDTO) THROWS PARSEEXCEPTION {
APLICAREJOB APLICAREJOB = CONVERTTOENTITY(APLICAREJOBDTO);
THIS.APLICAREJOBSERVICE.UPDATEAPLICAREJOB(APLICAREJOB);
}

@DELETEMAPPING(VALUE="/APLICAREJOBURI/DELETE/{ID}")
PUBLIC VOID DELETEAPLICAREJOB(@PATHVARIABLE INTEGER ID) {
THIS.APLICAREJOBSERVICE.DELETEAPLICAREJOB(ID);
}
 //CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)
PRIVATE APLICAREJOBDTO CONVERTTODTO(APLICAREJOB APLICAREJOB) {
APLICAREJOBDTO APLICAREJOBDTO = MODELMAPPER.MAP(APLICAREJOB,
APLICAREJOBDTO.CLASS);
RETURN APLICAREJOBDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE APLICAREJOB CONVERTTOENTITY(APLICAREJOBDTO APLICAREJOBDTO) THROWS
PARSEEXCEPTION{
APLICAREJOB APLICAREJOB = MODELMAPPER.MAP(APLICAREJOBDTO,
APLICAREJOB.CLASS);
RETURN APLICAREJOB;
}

}
CandidatC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.CANDIDATDTO;
IMPORT COM.DAM.TAM1.ENTITIES.CANDIDAT;
IMPORT COM.DAM.TAM1.SERVICES.CANDIDATSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS CANDIDATCONTROLLER {

@AUTOWIRED
PRIVATE CANDIDATSERVICE CANDIDATSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/CANDIDATI")
PUBLIC LIST<CANDIDATDTO> GETCANDIDATI(){
LIST<CANDIDAT> CANDIDATI = THIS.CANDIDATSERVICE.GETALLCANDIDATI();

RETURN CANDIDATI.STREAM()
.MAP(THIS::CONVERTTODTO)
 .COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/CANDIDATI/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC CANDIDATDTO GETCANDIDATBYID(@PATHVARIABLE INTEGER ID) {
CANDIDAT CANDIDATFOUND = THIS.CANDIDATSERVICE.GETCANDIDATBYID(ID);
RETURN CONVERTTODTO(CANDIDATFOUND);
}

@POSTMAPPING(VALUE= "CANDIDATI/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC CANDIDATDTO ADDCANDIDAT(@REQUESTBODY CANDIDATDTO CANDIDATDTO) THROWS
PARSEEXCEPTION {
CANDIDAT CANDIDAT = CONVERTTOENTITY(CANDIDATDTO);
CANDIDAT CREATEDCANDIDAT = THIS.CANDIDATSERVICE.SAVECANDIDAT(CANDIDAT);

RETURN CONVERTTODTO(CREATEDCANDIDAT);
}

@PUTMAPPING(VALUE="/CANDIDATI/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATECANDIDAT(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY CANDIDATDTO CANDIDATDTO) THROWS PARSEEXCEPTION {
CANDIDAT CANDIDAT = CONVERTTOENTITY(CANDIDATDTO);
THIS.CANDIDATSERVICE.UPDATECANDIDAT(CANDIDAT);
}

@DELETEMAPPING(VALUE="/CANDIDATI/DELETE/{ID}")
PUBLIC VOID DELETECANDIDAT(@PATHVARIABLE INTEGER ID) {
THIS.CANDIDATSERVICE.DELETECANDIDAT(ID);
}

//CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE CANDIDATDTO CONVERTTODTO(CANDIDAT CANDIDAT) {
CANDIDATDTO CANDIDATDTO = MODELMAPPER.MAP(CANDIDAT, CANDIDATDTO.CLASS);
RETURN CANDIDATDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE CANDIDAT CONVERTTOENTITY(CANDIDATDTO CANDIDATDTO) THROWS
PARSEEXCEPTION{
CANDIDAT CANDIDAT = MODELMAPPER.MAP(CANDIDATDTO, CANDIDAT.CLASS);
RETURN CANDIDAT;
}

}
CriteriiNecesareC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.CRITERIINECESARENECESAREDTO;
IMPORT COM.DAM.TAM1.ENTITIES.CRITERIINECESARE;
IMPORT COM.DAM.TAM1.SERVICES.CRITERIINECESARESERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS CRITERIINECESARECONTROLLER {

@AUTOWIRED
PRIVATE CRITERIINECESARESERVICE CRITERIINECESARESERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/CRITERIINECESARE")
PUBLIC LIST<CRITERIINECESAREDTO> GETCRITERIINECESARE(){
LIST<CRITERIINECESARE> CRITERIINECESARE =
THIS.CRITERIINECESARESERVICE.GETALLCRITERIINECESARE();

RETURN CRITERIINECESARE.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/CRITERIINECESARE/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC CRITERIINECESAREDTO GETCRITERIINECESAREBYID(@PATHVARIABLE INTEGER ID)
{
CRITERIINECESARE CRITERIINECESAREFOUND =
THIS.CRITERIINECESARESERVICE.GETCRITERIINECESAREBYID(ID);
RETURN CONVERTTODTO(CRITERIINECESAREFOUND);
}

@POSTMAPPING(VALUE= "CRITERIINECESARE/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC CRITERIINECESAREDTO ADDCRITERIINECESARE(@REQUESTBODY
CRITERIINECESAREDTO CRITERIINECESAREDTO) THROWS PARSEEXCEPTION {
CRITERIINECESARE CRITERIINECESARE =
CONVERTTOENTITY(CRITERIINECESAREDTO);
CRITERIINECESARE CREATEDCRITERIINECESARE =
THIS.CRITERIINECESARESERVICE.SAVECRITERIINECESARE(CRITERIINECESARE);

RETURN CONVERTTODTO(CREATEDCRITERIINECESARE);
}

@PUTMAPPING(VALUE="/CRITERIINECESARE/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
 PUBLIC VOID UPDATECRITERIINECESARE(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY CRITERIINECESAREDTO CRITERIINECESAREDTO) THROWS PARSEEXCEPTION {
CRITERIINECESARE CRITERIINECESARE =
CONVERTTOENTITY(CRITERIINECESAREDTO);
THIS.CRITERIINECESARESERVICE.UPDATECRITERIINECESARE(CRITERIINECESARE);
}

@DELETEMAPPING(VALUE="/CRITERIINECESARE/DELETE/{ID}")
PUBLIC VOID DELETECRITERIINECESARE(@PATHVARIABLE INTEGER ID) {
THIS.CRITERIINECESARESERVICE.DELETECRITERIINECESARE(ID);
}

//CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE CRITERIINECESAREDTO CONVERTTODTO(CRITERIINECESARE CRITERIINECESARE) {
CRITERIINECESAREDTO CRITERIINECESAREDTO =
MODELMAPPER.MAP(CRITERIINECESARE, CRITERIINECESAREDTO.CLASS);
RETURN CRITERIINECESAREDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE CRITERIINECESARE CONVERTTOENTITY(CRITERIINECESAREDTO
CRITERIINECESAREDTO) THROWS PARSEEXCEPTION{
CRITERIINECESARE CRITERIINECESARE =
MODELMAPPER.MAP(CRITERIINECESAREDTO, CRITERIINECESARE.CLASS);
RETURN CRITERIINECESARE;
}

}
CriteriuC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.CRITERIUDTO;
IMPORT COM.DAM.TAM1.ENTITIES.CRITERIU;
IMPORT COM.DAM.TAM1.SERVICES.CRITERIUSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS CRITERIUCONTROLLER {
 @AUTOWIRED
PRIVATE CRITERIUSERVICE CRITERIUSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/CRITERII")
PUBLIC LIST<CRITERIUDTO> GETCRITERII(){
LIST<CRITERIU> CRITERII = THIS.CRITERIUSERVICE.GETALLCRITERII();

RETURN CRITERII.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/CRITERII/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC CRITERIUDTO GETCRITERIUBYID(@PATHVARIABLE INTEGER ID) {
CRITERIU CRITERIUFOUND = THIS.CRITERIUSERVICE.GETCRITERIUBYID(ID);
RETURN CONVERTTODTO(CRITERIUFOUND);
}

@POSTMAPPING(VALUE= "CRITERII/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC CRITERIUDTO ADDCRITERIU(@REQUESTBODY CRITERIUDTO CRITERIUDTO) THROWS
PARSEEXCEPTION {
CRITERIU CRITERIU = CONVERTTOENTITY(CRITERIUDTO);
CRITERIU CREATEDCRITERIU = THIS.CRITERIUSERVICE.SAVECRITERIU(CRITERIU);

RETURN CONVERTTODTO(CREATEDCRITERIU);
}

@PUTMAPPING(VALUE="/CRITERII/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATECRITERIU(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY CRITERIUDTO CRITERIUDTO) THROWS PARSEEXCEPTION {
CRITERIU CRITERIU = CONVERTTOENTITY(CRITERIUDTO);
THIS.CRITERIUSERVICE.UPDATECRITERIU(CRITERIU);
}

@DELETEMAPPING(VALUE="/CRITERII/DELETE/{ID}")
PUBLIC VOID DELETECRITERIU(@PATHVARIABLE INTEGER ID) {
THIS.CRITERIUSERVICE.DELETECRITERIU(ID);
}

//CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE CRITERIUDTO CONVERTTODTO(CRITERIU CRITERIU) {
CRITERIUDTO CRITERIUDTO = MODELMAPPER.MAP(CRITERIU, CRITERIUDTO.CLASS);
RETURN CRITERIUDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE CRITERIU CONVERTTOENTITY(CRITERIUDTO CRITERIUDTO) THROWS
PARSEEXCEPTION{
CRITERIU CRITERIU = MODELMAPPER.MAP(CRITERIUDTO, CRITERIU.CLASS);
RETURN CRITERIU;
}
}
HiringC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATCHMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.HIRINGDTO;
IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;
IMPORT COM.DAM.TAM1.SERVICES.HIRINGSERVICE;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = {"HTTP://LOCALHOST:4200"})
PUBLIC CLASS HIRINGCONTROLLER {

@AUTOWIRED
PRIVATE HIRINGSERVICE HIRINGSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/HIRING_PROCESSES")
PUBLIC LIST<HIRINGDTO> GETALLHIRINGPROCESSES(){
RETURN
THIS.HIRINGSERVICE.GETALLHIRINGPROCESSES().STREAM().MAP(THIS::CONVERTTODTO).COLLECT
(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE = "/HIRING_PROCESSES/{ID}", PRODUCES =

MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC HIRINGDTO GETHIRINGPROCESSBYID(@PATHVARIABLE INTEGER ID) {
RETURN THIS.CONVERTTODTO(THIS.HIRINGSERVICE.GETHIRINGPROCESSBYID(ID));
}

@PATCHMAPPING("/HIRING_PROCESSES/UPDATE/{ID}")
PUBLIC VOID UPDATEHIRINGPROCESS(@PATHVARIABLE("ID") INTEGER ID, @REQUESTBODY
HIRINGPROCESS HIRINGPROCESS) {
THIS.HIRINGSERVICE.UPDATEHIRINGPROCESS(HIRINGPROCESS);
}

@DELETEMAPPING(VALUE="HIRING_PROCESSES/DELETE/{ID}")
PUBLIC VOID DELETEHIRINGPROCCES(@PATHVARIABLE("ID") INTEGER ID, @REQUESTBODY
HIRINGPROCESS HIRINGPROCESS) {
THIS.HIRINGSERVICE.DELETEHIRINGPROCESS(HIRINGPROCESS);
}
 PUBLIC HIRINGDTO CONVERTTODTO(HIRINGPROCESS HIRINGPROCESS) {
HIRINGDTO HIRINGDTO = THIS.MODELMAPPER.MAP(HIRINGPROCESS,
HIRINGDTO.CLASS);
RETURN HIRINGDTO;
}

PUBLIC HIRINGPROCESS CONVERTTOENTITY(HIRINGDTO HIRINGDTO) {

HIRINGPROCESS HIRINGPROCESS = THIS.MODELMAPPER.MAP(HIRINGDTO,
HIRINGPROCESS.CLASS);
RETURN HIRINGPROCESS;
}
}
InterviuParticipantC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.COLLECTION;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.INTERVIUDTO;
IMPORT COM.DAM.TAM1.DATA.INTERVIUPARTICIPANTDTO;
IMPORT COM.DAM.TAM1.DATA.INTERVIUPARTICIPANTPKDTO;
IMPORT COM.DAM.TAM1.DATA.PARTICIPANTDTO;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANT;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANTPK;
IMPORT COM.DAM.TAM1.ENTITIES.PARTICIPANT;
IMPORT COM.DAM.TAM1.SERVICES.INTERVIUPARTICIPANTSERVICE;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS INTERVIUPARTICIPANTCONTROLLER {

@AUTOWIRED
PRIVATE INTERVIUPARTICIPANTSERVICE SERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING("/INTERVIUS_PARTICIPANTS")
PUBLIC COLLECTION<INTERVIUPARTICIPANTDTO> GETINTERVIUPARTICIPANTS(){
RETURN
THIS.SERVICE.GETALLPARTICIPANTSONINTERVIU().STREAM().MAP(THIS::CONVERTTODTO).COLLEC
T(COLLECTORS.TOLIST());
}

@GETMAPPING("/INTERVIUS_PARTICIPANTS_1/{ID}")
PUBLIC COLLECTION<INTERVIUDTO>
GETINTERVIUSBYPARTICIPANTID(@PATHVARIABLE(VALUE = "ID") INTEGER ID){
RETURN
THIS.SERVICE.GETINTERVIUSBYPARTICIPANTID(ID).STREAM().MAP(THIS::CONVERTTODTO).COLLE
CT(COLLECTORS.TOLIST());
}

@GETMAPPING("/INTERVIUS_PARTICIPANTS_2/{ID}")
PUBLIC COLLECTION<PARTICIPANTDTO>
GETPARTICIPANTSBYINTERVIUID(@PATHVARIABLE(VALUE = "ID") INTEGER ID){
RETURN
THIS.SERVICE.GETPARTICIPANTSBYINTERVIUID(ID).STREAM().MAP(THIS::CONVERTTODTO).COLLE
CT(COLLECTORS.TOLIST());
}

@POSTMAPPING(VALUE = "/INTERVIUS_PARTICIPANTS/ADD", CONSUMES =

MEDIATYPE.APPLICATION_JSON_VALUE)
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC INTERVIUPARTICIPANTDTO SCHEDULEINTERVIUPARTICIPANT(@REQUESTBODY
INTERVIUPARTICIPANTDTO INTERVIUPARTICIPANT) {
RETURN
CONVERTTODTO(THIS.SERVICE.SAVEINTERVIUPARTICIPANT(CONVERTTOENTITY(INTERVIUPARTICIPA
NT)));
}

@POSTMAPPING(VALUE = "/INTERVIUS_PARTICIPANTS/DELETE/")
PUBLIC VOID DELETEINTERVIUPARTICIPANT(@REQUESTBODY INTERVIUPARTICIPANTPKDTO
INTERVIUPARTICIPANTPKDTO) {
INTERVIUPARTICIPANTPK INTERVIUPARTICIPANTPK = NEW
INTERVIUPARTICIPANTPK();

INTERVIUPARTICIPANTPK.SETINTERVIUID(INTERVIUPARTICIPANTPKDTO.GETINTERVIUID());

INTERVIUPARTICIPANTPK.SETPARTICIPANTID(INTERVIUPARTICIPANTPKDTO.GETPARTICIPANTID())
;
THIS.SERVICE.DELETEINTERVIUPARTICIPANTBYID(INTERVIUPARTICIPANTPK);
}

PRIVATE INTERVIUPARTICIPANTDTO CONVERTTODTO(INTERVIUPARTICIPANT

INTERVIUPARTICIPANT) {
INTERVIUPARTICIPANTDTO INTERVIUPARTICIPANTDTO =
MODELMAPPER.MAP(INTERVIUPARTICIPANT, INTERVIUPARTICIPANTDTO.CLASS);
RETURN INTERVIUPARTICIPANTDTO;
}

PRIVATE INTERVIUPARTICIPANT CONVERTTOENTITY(INTERVIUPARTICIPANTDTO

INTERVIUPARTICIPANTDTO) {
INTERVIUPARTICIPANT INTERVIUPARTICIPANT =
MODELMAPPER.MAP(INTERVIUPARTICIPANTDTO, INTERVIUPARTICIPANT.CLASS);
RETURN INTERVIUPARTICIPANT;
}

PRIVATE INTERVIUDTO CONVERTTODTO(INTERVIU INTERVIU) {

INTERVIUDTO INTERVIUDTO = MODELMAPPER.MAP(INTERVIU, INTERVIUDTO.CLASS);
RETURN INTERVIUDTO;
}

PRIVATE PARTICIPANTDTO CONVERTTODTO(PARTICIPANT PARTICIPANT) {

 PARTICIPANTDTO PARTICIPANTDTO = MODELMAPPER.MAP(PARTICIPANT,
PARTICIPANTDTO.CLASS);
RETURN PARTICIPANTDTO;
}

PRIVATE INTERVIUPARTICIPANTPKDTO CONVERTTODTO(INTERVIUPARTICIPANTPK

INTERVIUPARTICIPANTPK) {
INTERVIUPARTICIPANTPKDTO INTERVIUPARTICIPANTPKDTO =
MODELMAPPER.MAP(INTERVIUPARTICIPANTPK, INTERVIUPARTICIPANTPKDTO.CLASS);
RETURN INTERVIUPARTICIPANTPKDTO;
}

PRIVATE INTERVIUPARTICIPANTPK CONVERTTOENTITY(INTERVIUPARTICIPANTPKDTO

INTERVIUPARTICIPANTPKDTO) {
INTERVIUPARTICIPANTPK INTERVIUPARTICIPANTPK =
MODELMAPPER.MAP(INTERVIUPARTICIPANTPKDTO, INTERVIUPARTICIPANTPK.CLASS);
RETURN INTERVIUPARTICIPANTPK;
}

InterviuC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.INTERVIUDTO;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.SERVICES.INTERVIUSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS INTERVIUCONTROLLER {

@AUTOWIRED
PRIVATE INTERVIUSERVICE INTERVIUSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/INTERVIURI")
PUBLIC LIST<INTERVIUDTO> GETINTERVIURI(){
 LIST<INTERVIU> INTERVIURI = THIS.INTERVIUSERVICE.GETALLINTERVIURI();

RETURN INTERVIURI.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/INTERVIURI/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC INTERVIUDTO GETINTERVIUBYID(@PATHVARIABLE INTEGER ID) {
INTERVIU INTERVIUFOUND = THIS.INTERVIUSERVICE.GETINTERVIUBYID(ID);
RETURN CONVERTTODTO(INTERVIUFOUND);
}

@POSTMAPPING(VALUE= "INTERVIURI/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC INTERVIUDTO ADDINTERVIU(@REQUESTBODY INTERVIUDTO INTERVIUDTO) THROWS
PARSEEXCEPTION {
INTERVIU INTERVIU = CONVERTTOENTITY(INTERVIUDTO);
INTERVIU CREATEDINTERVIU = THIS.INTERVIUSERVICE.SAVEINTERVIU(INTERVIU);

RETURN CONVERTTODTO(CREATEDINTERVIU);
}

@PUTMAPPING(VALUE="/INTERVIURI/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATEINTERVIU(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY INTERVIUDTO INTERVIUDTO) THROWS PARSEEXCEPTION {
INTERVIU INTERVIU = CONVERTTOENTITY(INTERVIUDTO);
THIS.IINTERVIUSERVICE.UPDATEINTERVIU(INTERVIU);
}

@DELETEMAPPING(VALUE="/INTERVIURI/DELETE/{ID}")
PUBLIC VOID DELETEINTERVIU(@PATHVARIABLE INTEGER ID) {
THIS.INTERVIUSERVICE.DELETEINTERVIU(ID);
}

//CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE INTERVIUDTO CONVERTTODTO(INTERVIU INTERVIU) {
INTERVIUDTO INTERVIUDTO = MODELMAPPER.MAP(INTERVIU, INTERVIUDTO.CLASS);
RETURN INTERVIUDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE INTERVIU CONVERTTOENTITY(INTERVIUDTO INTERVIUDTO) THROWS
PARSEEXCEPTION{
INTERVIU INTERVIU = MODELMAPPER.MAP(INTERVIUDTO, INTERVIU.CLASS);
RETURN INTERVIU;
}

}
JobDisponibilC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;
IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.JOBDISPONIBILDTO;
IMPORT COM.DAM.TAM1.ENTITIES.JOBDISPONIBIL;
IMPORT COM.DAM.TAM1.SERVICES.JOBDISPONIBILSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS JOBDISPONIBILCONTROLLER {

@AUTOWIRED
PRIVATE JOBDISPONIBILSERVICE JOBDISPONIBILSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/JOBURIDISPONIBILE")
PUBLIC LIST<JOBDISPONIBILDTO> GETJOBURIDISPONIBILE(){
LIST<JOBDISPONIBIL> JOBURIDISPONIBILE =
THIS.JOBDISPONIBILSERVICE.GETALLJOBURIDISPONIBILE();

RETURN JOBURIDISPONIBILE.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/JOBURIDISPONIBILE/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC JOBDISPONIBILDTO GETJOBDISPONIBILBYID(@PATHVARIABLE INTEGER ID) {
JOBDISPONIBIL JOBDISPONIBILFOUND =
THIS.JOBDISPONIBILSERVICE.GETJOBDISPONIBILBYID(ID);
RETURN CONVERTTODTO(JOBDISPONIBILFOUND);
}

@POSTMAPPING(VALUE= "JOBURIDISPONIBILE/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC JOBDISPONIBILDTO ADDJOBDISPONIBIL(@REQUESTBODY JOBDISPONIBILDTO
JOBDISPONIBILDTO) THROWS PARSEEXCEPTION {
JOBDISPONIBIL JOBDISPONIBIL = CONVERTTOENTITY(JOBDISPONIBILDTO);
JOBDISPONIBIL CREATEDJOBDISPONIBIL =
THIS.JOBDISPONIBILSERVICE.SAVEJOBDISPONIBIL(JOBDISPONIBIL);

RETURN CONVERTTODTO(CREATEDJOBDISPONIBIL);
}
 @PUTMAPPING(VALUE="/JOBURIDISPONIBILE/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATEJOBDISPONIBIL(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY JOBDISPONIBILDTO JOBDISPONIBILDTO) THROWS PARSEEXCEPTION {
JOBDISPONIBIL JOBDISPONIBIL = CONVERTTOENTITY(JOBDISPONIBILDTO);
THIS.JOBDISPONIBILSERVICE.UPDATEJOBDISPONIBIL(JOBDISPONIBIL);
}

@DELETEMAPPING(VALUE="/JOBURIDISPONIBILE/DELETE/{ID}")
PUBLIC VOID DELETEJOBDISPONIBIL(@PATHVARIABLE INTEGER ID) {
THIS.JOBDISPONIBILSERVICE.DELETEJOBDISPONIBIL(ID);
}

//CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE JOBDISPONIBILDTO CONVERTTODTO(JOBDISPONIBIL JOBDISPONIBIL) {
JOBDISPONIBILDTO JOBDISPONIBILDTO = MODELMAPPER.MAP(JOBDISPONIBIL,
JOBDISPONIBILDTO.CLASS);
RETURN JOBDISPONIBILDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE JOBDISPONIBIL CONVERTTOENTITY(JOBDISPONIBILDTO JOBDISPONIBILDTO)
THROWS PARSEEXCEPTION{
JOBDISPONIBIL JOBDISPONIBIL = MODELMAPPER.MAP(JOBDISPONIBILDTO,
JOBDISPONIBIL.CLASS);
RETURN JOBDISPONIBIL;
}

}
NotFoundEXPC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;

@RESPONSESTATUS(CODE = HTTPSTATUS.NOT_FOUND, REASON = "NOT FOUND!")

PUBLIC CLASS NOTFOUNDEXCEPTION EXTENDS RUNTIMEEXCEPTION {

}
ParticipantC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;
IMPORT COM.DAM.TAM1.DATA.PARTICIPANTDTO;
IMPORT COM.DAM.TAM1.ENTITIES.PARTICIPANT;
IMPORT COM.DAM.TAM1.SERVICES.PARTICIPANTSERVICE;

@RESTCONTROLLER
@CROSSORIGIN
PUBLIC CLASS PARTICIPANTCONTROLLER {

@AUTOWIRED
PRIVATE PARTICIPANTSERVICE PARTICIPANTSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/PARTICIPANTS")
PUBLIC LIST<PARTICIPANTDTO> GETALLPARTICIPANTS(){

RETURN PARTICIPANTSERVICE.GETALLPARTICIPANTS()
.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/PARTICIPANTS/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC PARTICIPANTDTO GETPARTICIPANTBYID(@PATHVARIABLE INTEGER ID) {
RETURN CONVERTTODTO(THIS.PARTICIPANTSERVICE.GETPARTICIPANTBYID(ID));
}

@POSTMAPPING(VALUE="/PARTICIPANTS/ADD/", CONSUMES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC PARTICIPANTDTO ADDPARTICIPANT(@REQUESTBODY PARTICIPANTDTO
PARTICIPANTDTO) {
PARTICIPANT PARTICIPANT = CONVERTTOENTITY(PARTICIPANTDTO);
PARTICIPANT SAVEDPARTICIPANT =
THIS.PARTICIPANTSERVICE.SAVEPARTICIPANT(PARTICIPANT);

RETURN THIS.CONVERTTODTO(SAVEDPARTICIPANT);
}

@PUTMAPPING(VALUE="/PARTICIPANTS/UPDATE/{ID}")
PUBLIC VOID UPDATEPARTICIPANT(@PATHVARIABLE INTEGER ID, @REQUESTBODY
PARTICIPANTDTO PARTICIPANTDTO) {
PARTICIPANT PARTICIPANT = CONVERTTOENTITY(PARTICIPANTDTO);
THIS.PARTICIPANTSERVICE.UPDATEPARTICIPANT(PARTICIPANT);
}

@DELETEMAPPING(VALUE="/PARTICIPANTS/DELETE/{ID}")
PUBLIC VOID DELETEPARTICIPANT(@PATHVARIABLE INTEGER ID) {
THIS.PARTICIPANTSERVICE.DELETEPARTICIPANTBYID(ID);
}

PRIVATE PARTICIPANTDTO CONVERTTODTO(PARTICIPANT PARTICIPANT) {

PARTICIPANTDTO PARTICIPANTDTO = MODELMAPPER.MAP(PARTICIPANT,
PARTICIPANTDTO.CLASS);
RETURN PARTICIPANTDTO;
}

PRIVATE PARTICIPANT CONVERTTOENTITY(PARTICIPANTDTO PARTICIPANTDTO) {

 PARTICIPANT PARTICIPANT = MODELMAPPER.MAP(PARTICIPANTDTO,
PARTICIPANT.CLASS);
RETURN PARTICIPANT;
}

}
PositionC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.POSITIONDTO;
IMPORT COM.DAM.TAM1.DATA.POSITIONREADDTO;
IMPORT COM.DAM.TAM1.ENTITIES.POSITION;
IMPORT COM.DAM.TAM1.SERVICES.POSITIONSERVICE;

@RESTCONTROLLER
@CROSSORIGIN
PUBLIC CLASS POSITIONCONTROLLER {

@AUTOWIRED
PRIVATE POSITIONSERVICE POSITIONSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING("/POSITIONS")
PUBLIC LIST<POSITIONREADDTO> GETALLPOSITIONS(){
LIST<POSITION> POSITIONS = THIS.POSITIONSERVICE.GETALLPOSITIONS();

RETURN POSITIONS.STREAM().MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/POSITIONS/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC POSITIONREADDTO GETPOSITIONBYID(@PATHVARIABLE INTEGER ID) {
POSITION POSITIONFOUND = THIS.POSITIONSERVICE.GETPOSITIONBYID(ID);

RETURN CONVERTTODTO(POSITIONFOUND);
}

@POSTMAPPING(VALUE="/POSITIONS/ADD", CONSUMES =
MEDIATYPE.APPLICATION_JSON_VALUE)
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC POSITIONREADDTO ADDPOSITION(@REQUESTBODY POSITIONDTO POSITIONDTO) {
POSITION POSITION = CONVERTTOENTITY(POSITIONDTO);
POSITION.SETISAVAILABLE(TRUE);
POSITION CREATEDPOSITION = THIS.POSITIONSERVICE.SAVEPOSITION(POSITION);

RETURN CONVERTTODTO(CREATEDPOSITION);
}

@PUTMAPPING("/POSITIONS/UPDATE/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATEPOSITION(@PATHVARIABLE INTEGER ID, @REQUESTBODY POSITIONDTO
POSITIONDTO) {
POSITION POSITION = CONVERTTOENTITY(POSITIONDTO);
THIS.POSITIONSERVICE.UPDATEPOSITION(POSITION);
}

@DELETEMAPPING("/POSITIONS/DELETE/{ID}")
PUBLIC VOID DELETEPOSITION(@PATHVARIABLE INTEGER ID) {
THIS.POSITIONSERVICE.DELETEPOSITION(ID);
}

PRIVATE POSITIONREADDTO CONVERTTODTO(POSITION POSITION) {

POSITIONREADDTO POSITIONDTO = MODELMAPPER.MAP(POSITION,
POSITIONREADDTO.CLASS);
RETURN POSITIONDTO;
}

PRIVATE POSITION CONVERTTOENTITY(POSITIONDTO POSITIONDTO) {

POSITION POSITITON = MODELMAPPER.MAP(POSITIONDTO, POSITION.CLASS);
RETURN POSITITON;
}

}
QuestionC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.COLLECTION;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.RASPUNSFINALDTO;
IMPORT COM.DAM.TAM1.DATA.QUESTIONDTO;
IMPORT COM.DAM.TAM1.ENTITIES.RASPUNSFINAL;
IMPORT COM.DAM.TAM1.ENTITIES.QUESTION;
IMPORT COM.DAM.TAM1.SERVICES.QUESTIONSERVICE;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS QUESTIONCONTROLLER {

@AUTOWIRED
PRIVATE QUESTIONSERVICE QUESTIONSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE = "/QUESTIONS")
PUBLIC COLLECTION<QUESTIONDTO> GETALLQUESTIONS(){
RETURN
THIS.QUESTIONSERVICE.GETALLQUESTIONS().STREAM().MAP(THIS::CONVERTTODTO).COLLECT(COL
LECTORS.TOLIST());
}

@GETMAPPING(VALUE = "/QUESTION_RASPUNSFINALS/{ID}")
PUBLIC COLLECTION<RASPUNSFINALDTO> GETALLRASPUNSFINALS(@PATHVARIABLE INTEGER
ID){
RETURN
THIS.QUESTIONSERVICE.GETALLRASPUNSFINALSFORQUESTION(ID).STREAM().MAP(THIS::CONVERTT
ODTO).COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE = "/QUESTIONS/{ID}", PRODUCES =

MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC QUESTIONDTO GETQUESTIONBYID(@PATHVARIABLE INTEGER ID) {
RETURN CONVERTTODTO(THIS.QUESTIONSERVICE.GETQUESTIONBYID(ID));
}

@POSTMAPPING(VALUE = "/QUESTIONS/ADD/")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC QUESTIONDTO ADDQUESTION(@REQUESTBODY QUESTIONDTO QUESTIONDTO) {
RETURN
CONVERTTODTO(THIS.QUESTIONSERVICE.SAVEQUESTION(CONVERTTOENTITY(QUESTIONDTO)));
}

@PUTMAPPING(VALUE = "/QUESTIONS/UPDATE/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATEQUESTION(@PATHVARIABLE(VALUE="ID") INTEGER ID, @REQUESTBODY
QUESTIONDTO QUESTIONDTO) {
THIS.QUESTIONSERVICE.UPDATEQUESTION(CONVERTTOENTITY(QUESTIONDTO));
}

@DELETEMAPPING(VALUE = "/QUESTIONS/DELETE/{ID}")
PUBLIC VOID DELETEQUESTION(@PATHVARIABLE(VALUE = "ID") INTEGER ID) {
THIS.QUESTIONSERVICE.DELETEQUESTION(ID);
}

PRIVATE QUESTIONDTO CONVERTTODTO(QUESTION QUESTION) {

QUESTIONDTO QUESTIONDTO = MODELMAPPER.MAP(QUESTION, QUESTIONDTO.CLASS);
RETURN QUESTIONDTO;
}

PRIVATE QUESTION CONVERTTOENTITY(QUESTIONDTO QUESTIONDTO) {

QUESTION QUESTION = MODELMAPPER.MAP(QUESTIONDTO, QUESTION.CLASS);
 RETURN QUESTION;
}

PRIVATE RASPUNSFINALDTO CONVERTTODTO(RASPUNSFINAL RASPUNSFINAL) {

RASPUNSFINALDTO RASPUNSFINALDTO = MODELMAPPER.MAP(RASPUNSFINAL,
RASPUNSFINALDTO.CLASS);
RETURN RASPUNSFINALDTO;
}

}
QuestionQuizC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS QUESTIONQUIZCONTROLLER {

}
QuizC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.COLLECTION;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.QUESTIONDTO;
IMPORT COM.DAM.TAM1.DATA.QUIZDTO;
IMPORT COM.DAM.TAM1.ENTITIES.QUIZ;
IMPORT COM.DAM.TAM1.SERVICES.QUIZSERVICE;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS QUIZCONTROLLER {

@AUTOWIRED
PRIVATE QUIZSERVICE QUIZSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE = "/QUIZES/")
PUBLIC COLLECTION<QUIZDTO> GETALLQUIZES(){
RETURN
THIS.QUIZSERVICE.GETALLQUIZES().STREAM().MAP(THIS::CONVERTTODTO).COLLECT(COLLECTORS
.TOLIST());
}

@GETMAPPING(VALUE = "/QUIZES/{ID}")
PUBLIC QUIZDTO GETQUIZBYID(@PATHVARIABLE INTEGER ID) {
RETURN CONVERTTODTO(THIS.QUIZSERVICE.GETQUIZBYID(ID));
}

@POSTMAPPING(VALUE = "/QUIZES/ADD")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC QUIZDTO ADDQUIZ(@REQUESTBODY QUIZDTO QUIZDTO) {
RETURN
CONVERTTODTO(THIS.QUIZSERVICE.SAVEQUIZ(CONVERTTOENTITY(QUIZDTO)));
}

@PUTMAPPING(VALUE = "/QUIZES/UPDATE/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATEQUIZ(@PATHVARIABLE INTEGER ID, @REQUESTBODY QUIZDTO
QUIZDTO) {
THIS.QUIZSERVICE.SAVEQUIZ(CONVERTTOENTITY(QUIZDTO));
}

@DELETEMAPPING(VALUE = "/QUIZES/DELETE/{ID}")
PUBLIC VOID DELETEQUIZ(@PATHVARIABLE INTEGER ID) {
THIS.QUIZSERVICE.DELETEQUIZBYID(ID);
}

PUBLIC QUIZDTO CONVERTTODTO(QUIZ QUIZ) {

QUIZDTO QUIZDTO = MODELMAPPER.MAP(QUIZ, QUIZDTO.CLASS);
RETURN QUIZDTO;
}

PUBLIC QUIZ CONVERTTOENTITY(QUIZDTO QUIZDTO) {

QUIZ QUIZ = MODELMAPPER.MAP(QUIZDTO, QUIZ.CLASS);
RETURN QUIZ;
}

RaspunsFinalC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;
IMPORT COM.DAM.TAM1.DATA.RASPUNSFINALDTO;
IMPORT COM.DAM.TAM1.ENTITIES.RASPUNSFINAL;
IMPORT COM.DAM.TAM1.SERVICES.RASPUNSFINALSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS RASPUNSFINALCONTROLLER {

@AUTOWIRED
PRIVATE RASPUNSFINALSERVICE RASPUNSFINALSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/RASPUNSURIFINALE")
PUBLIC LIST<RASPUNSFINALDTO> GETRASPUNSURIFINALE(){
LIST<RASPUNSFINAL> RASPUNSURIFINALE =
THIS.RASPUNSFINALSERVICE.GETALLRASPUNSURIFINALE();

RETURN RASPUNSURIFINALE.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/RASPUNSURIFINALE/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC RASPUNSFINALDTO GETRASPUNSFINALBYID(@PATHVARIABLE INTEGER ID) {
RASPUNSFINAL RASPUNSFINALFOUND =
THIS.RASPUNSFINALSERVICE.GETRASPUNSFINALBYID(ID);
RETURN CONVERTTODTO(RASPUNSFINALFOUND);
}

@POSTMAPPING(VALUE= "RASPUNSURIFINALE/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC RASPUNSFINALDTO ADDRASPUNSFINAL(@REQUESTBODY RASPUNSFINALDTO
RASPUNSFINALDTO) THROWS PARSEEXCEPTION {
RASPUNSFINAL RASPUNSFINAL = CONVERTTOENTITY(RASPUNSFINALDTO);
RASPUNSFINAL CREATEDRASPUNSFINAL =
THIS.RASPUNSFINALSERVICE.SAVERASPUNSFINAL(RASPUNSFINAL);

RETURN CONVERTTODTO(CREATEDRASPUNSFINAL);
}

@PUTMAPPING(VALUE="/RASPUNSURIFINALE/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATERASPUNSFINAL(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY RASPUNSFINALDTO RASPUNSFINALDTO) THROWS PARSEEXCEPTION {
RASPUNSFINAL RASPUNSFINAL = CONVERTTOENTITY(RASPUNSFINALDTO);
THIS.RASPUNSFINALSERVICE.UPDATERASPUNSFINAL(RASPUNSFINAL);
}

@DELETEMAPPING(VALUE="/RASPUNSURIFINALE/DELETE/{ID}")
PUBLIC VOID DELETERASPUNSFINAL(@PATHVARIABLE INTEGER ID) {
THIS.RASPUNSFINALSERVICE.DELETERASPUNSFINAL(ID);
}
 //CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)
PRIVATE RASPUNSFINALDTO CONVERTTODTO(RASPUNSFINAL RASPUNSFINAL) {
RASPUNSFINALDTO RASPUNSFINALDTO = MODELMAPPER.MAP(RASPUNSFINAL,
RASPUNSFINALDTO.CLASS);
RETURN RASPUNSFINALDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE RASPUNSFINAL CONVERTTOENTITY(RASPUNSFINALDTO RASPUNSFINALDTO) THROWS
PARSEEXCEPTION{
RASPUNSFINAL RASPUNSFINAL = MODELMAPPER.MAP(RASPUNSFINALDTO,
RASPUNSFINAL.CLASS);
RETURN RASPUNSFINAL;
}

}
ResponsabilHrC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.RESPONSABILHRDTO;
IMPORT COM.DAM.TAM1.ENTITIES.RESPONSABILHR;
IMPORT COM.DAM.TAM1.SERVICES.RESPONSABILHRSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS RESPONSABILHRCONTROLLER {

@AUTOWIRED
PRIVATE RESPONSABILHRSERVICE RESPONSABILHRSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING(VALUE="/RESPONSABILIHR")
PUBLIC LIST<RESPONSABILHRDTO> GETRESPONSABILIHR(){
LIST<RESPONSABILHR> RESPONSABILIHR =
THIS.RESPONSABILHRSERVICE.GETALLRESPONSABILIHR();
 RETURN RESPONSABILIHR.STREAM()
.MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@GETMAPPING(VALUE="/RESPONSABILIHR/{ID}", PRODUCES =
MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC RESPONSABILHRDTO GETRESPONSABILHRBYID(@PATHVARIABLE INTEGER ID) {
RESPONSABILHR RESPONSABILHRFOUND =
THIS.RESPONSABILHRSERVICE.GETRESPONSABILHRBYID(ID);
RETURN CONVERTTODTO(RESPONSABILHRFOUND);
}

@POSTMAPPING(VALUE= "RESPONSABILIHR/ADD")
@RESPONSESTATUS(HTTPSTATUS.CREATED)
PUBLIC RESPONSABILHRDTO ADDRESPONSABILHR(@REQUESTBODY RESPONSABILHRDTO
RESPONSABILHRDTO) THROWS PARSEEXCEPTION {
RESPONSABILHR RESPONSABILHR = CONVERTTOENTITY(RESPONSABILHRDTO);
RESPONSABILHR CREATEDRESPONSABILHR =
THIS.RESPONSABILHRSERVICE.SAVERESPONSABILHR(RESPONSABILHR);

RETURN CONVERTTODTO(CREATEDRESPONSABILHR);
}

@PUTMAPPING(VALUE="/RESPONSABILIHR/UPDATE/ID/{ID}")
@RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATERESPONSABILHR(@PATHVARIABLE(VALUE = "ID") INTEGER ID,
@REQUESTBODY RESPONSABILHRDTO RESPONSABILHRDTO) THROWS PARSEEXCEPTION {
RESPONSABILHR RESPONSABILHR = CONVERTTOENTITY(RESPONSABILHRDTO);
THIS.RESPONSABILHRSERVICE.UPDATERESPONSABILHR(RESPONSABILHR);
}

@DELETEMAPPING(VALUE="/RESPONSABILIHR/DELETE/{ID}")
PUBLIC VOID DELETERESPONSABILHR(@PATHVARIABLE INTEGER ID) {
THIS.RESPONSABILHRSERVICE.DELETERESPONSABILHR(ID);
}

//CONVERT TO DTO CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE RESPONSABILHRDTO CONVERTTODTO(RESPONSABILHR RESPONSABILHR) {
RESPONSABILHRDTO RESPONSABILHRDTO = MODELMAPPER.MAP(RESPONSABILHR,
RESPONSABILHRDTO.CLASS);
RETURN RESPONSABILHRDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR CANDIDAT MODEL)

PRIVATE RESPONSABILHR CONVERTTOENTITY(RESPONSABILHRDTO RESPONSABILHRDTO)
THROWS PARSEEXCEPTION{
RESPONSABILHR RESPONSABILHR = MODELMAPPER.MAP(RESPONSABILHRDTO,
RESPONSABILHR.CLASS);
RETURN RESPONSABILHR;
}

}
SubmissionC
PACKAGE COM.DAM.TAM1.CONTROLLERS;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.STREAM.COLLECTORS;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.HTTPSTATUS;
IMPORT ORG.SPRINGFRAMEWORK.HTTP.MEDIATYPE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.CROSSORIGIN;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.DELETEMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.GETMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PATHVARIABLE;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.POSTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.PUTMAPPING;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.REQUESTBODY;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESPONSESTATUS;
IMPORT ORG.SPRINGFRAMEWORK.WEB.BIND.ANNOTATION.RESTCONTROLLER;

IMPORT COM.DAM.TAM1.DATA.SUBMISSIONDTO;
IMPORT COM.DAM.TAM1.DATA.SUBMISSIONREADDTO;
IMPORT COM.DAM.TAM1.ENTITIES.SUBMISSION;
IMPORT COM.DAM.TAM1.SERVICES.IHIRINGFLOWSERVICE;
IMPORT COM.DAM.TAM1.SERVICES.SUBMISSIONSERVICE;
IMPORT COM.SUN.EL.PARSER.PARSEEXCEPTION;

@RESTCONTROLLER
@CROSSORIGIN(ORIGINS = "*", ALLOWEDHEADERS = "*")
PUBLIC CLASS SUBMISSIONCONTROLLER {

@AUTOWIRED
PRIVATE SUBMISSIONSERVICE SUBMISSIONSERVICE;

@AUTOWIRED
PRIVATE IHIRINGFLOWSERVICE IHIRINGFLOWSERVICE;

@AUTOWIRED
PRIVATE MODELMAPPER MODELMAPPER;

@GETMAPPING("/SUBMISSIONS")
PUBLIC LIST<SUBMISSIONREADDTO> GETSUBMISSIONS() {
LIST<SUBMISSION> SUBMISSIONS =
THIS.SUBMISSIONSERVICE.GETALLSUBMISSIONS();

RETURN SUBMISSIONS.STREAM().MAP(THIS::CONVERTTODTO)
.COLLECT(COLLECTORS.TOLIST());
}

@POSTMAPPING(VALUE = "/SUBMISSIONS/ADD", PRODUCES = "APPLICATION/JSON")

PUBLIC VOID ADDSUBMISSION(@REQUESTBODY SUBMISSION SUBMISSION) {
THIS.IHIRINGFLOWSERVICE.ENTRYSUBMISSIONWITHCANDIDAT(SUBMISSION);
}

@GETMAPPING(VALUE = "/SUBMISSIONS/{ID}", PRODUCES =

MEDIATYPE.APPLICATION_JSON_VALUE)
PUBLIC SUBMISSIONREADDTO GETSUBMISSIONBYID(@PATHVARIABLE INTEGER ID) {
SUBMISSION SUBMISSIONFOUND =
THIS.SUBMISSIONSERVICE.GETSUBMISSIONBYID(ID);
RETURN CONVERTTODTO(SUBMISSIONFOUND);
}

@PUTMAPPING(VALUE="/SUBMISSIONS/UPDATE/ID/{ID}")
 @RESPONSESTATUS(HTTPSTATUS.OK)
PUBLIC VOID UPDATESUBMISSION(@PATHVARIABLE INTEGER ID, @REQUESTBODY
SUBMISSIONDTO SUBMISSIONDTO) THROWS PARSEEXCEPTION {
SUBMISSION SUBMISSION = CONVERTTOENTITY(SUBMISSIONDTO);
THIS.SUBMISSIONSERVICE.UPDATESUBMISSION(SUBMISSION);
}

@DELETEMAPPING(VALUE = "/SUBMISSIONS/DELETE/{ID}")
PUBLIC VOID DELETESUBMISSION(@PATHVARIABLE(VALUE = "ID") INTEGER ID) {
// THIS.IHIRINGFLOWSERVICE.WITHDRAWSUBMISSION(ID);
THIS.SUBMISSIONSERVICE.DELETESUBMISSIONBYID(ID);
}

//CONVERT TO DTO CLASSES (JUST FOR SUBMISSION MODEL)

PRIVATE SUBMISSIONREADDTO CONVERTTODTO(SUBMISSION SUBMISSION) {
SUBMISSIONREADDTO SUBMISSIONDTO = MODELMAPPER.MAP(SUBMISSION,
SUBMISSIONREADDTO.CLASS);
RETURN SUBMISSIONDTO;
}

//CONVERT TO ENTITY CLASSES (JUST FOR SUBMISSION MODEL)

PRIVATE SUBMISSION CONVERTTOENTITY(SUBMISSIONDTO SUBMISSIONDTO) THROWS
PARSEEXCEPTION{
SUBMISSION SUBMISSION = MODELMAPPER.MAP(SUBMISSIONDTO,
SUBMISSION.CLASS);
RETURN SUBMISSION;
}
}
config
CorsConfig
PACKAGE COM.DAM.TAM1.CONFIG;

IMPORT ORG.MODELMAPPER.MODELMAPPER;
IMPORT ORG.SPRINGFRAMEWORK.CONTEXT.ANNOTATION.BEAN;
IMPORT ORG.SPRINGFRAMEWORK.CONTEXT.ANNOTATION.CONFIGURATION;
IMPORT ORG.SPRINGFRAMEWORK.WEB.SERVLET.CONFIG.ANNOTATION.WEBMVCCONFIGURER;

@CONFIGURATION
PUBLIC CLASS CORSCONFIG {

@BEAN
PUBLIC WEBMVCCONFIGURER CORSCONFIGURER() {
RETURN NEW WEBMVCCONFIGURER() {

@OVERRIDE
PUBLIC VOID
ADDCORSMAPPINGS(ORG.SPRINGFRAMEWORK.WEB.SERVLET.CONFIG.ANNOTATION.CORSREGISTRY
REGISTRY) {
REGISTRY.ADDMAPPING("/**").ALLOWEDMETHODS("GET", "POST",
"PUT", "DELETE", "PATCH")
.ALLOWEDHEADERS("*")
.ALLOWEDORIGINS("HTTP://LOCALHOST:4200");
}

};
}

@BEAN
PUBLIC MODELMAPPER MODELMAPPER() {
 RETURN NEW MODELMAPPER();
}

data
AngajatorDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS ANGAJATORDTO {

PRIVATE LONG ANGAJATOR_ID;

@NOTEMPTY(MESSAGE = "THE FIRST NAME CANNOT BE EMPTY")
PRIVATE STRING FIRSTNAME;
@NOTEMPTY(MESSAGE = "THE LAST NAME CANNOT BE EMPTY")
PRIVATE STRING LASTNAME;
@NOTEMPTY(MESSAGE = "THE ADDRESS CANNOT BE EMPTY")
PRIVATE STRING ADDRESS;

PRIVATE DATE DOB;

@EMAIL
@NOTEMPTY(MESSAGE = "THE EMAIL ADDRESS CANNOT BE EMPTY")
PRIVATE STRING EMAILADDRESS;

@NOTEMPTY(MESSAGE = "THE PHONE NO. CANNOT BE EMPTY")

PRIVATE STRING PHONENO;

PRIVATE RASPUNSVERDICT RASPUNSVERDICT;

PRIVATE RESPONSABILHR RESPONSABILHR;

AplicareJobDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS APLICAREJOBDTO {

PRIVATE LONG APLICAREJOB_ID;

@NOTEMPTY(MESSAGE = "THE RASPUNSAPLICARE CANNOT BE EMPTY")
PRIVATE STRING RASPUNSAPLICARE;

PRIVATE DATE DOB;

PRIVATE CANDIDAT CANDIDAT;

PRIVATE JOBDISPONIBIL JOBDISPONIBIL;

}
CandidatDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS CANDIDATDTO {

PRIVATE LONG CANDIDAT_ID;

@NOTEMPTY(MESSAGE = "THE FIRST NAME CANNOT BE EMPTY")
PRIVATE STRING FIRSTNAME;
@NOTEMPTY(MESSAGE = "THE LAST NAME CANNOT BE EMPTY")
PRIVATE STRING LASTNAME;
@NOTEMPTY(MESSAGE = "THE ADDRESS CANNOT BE EMPTY")
PRIVATE STRING ADDRESS;

PRIVATE DATE DOB;

@EMAIL
@NOTEMPTY(MESSAGE = "THE EMAIL ADDRESS CANNOT BE EMPTY")
PRIVATE STRING EMAILADDRESS;

@NOTEMPTY(MESSAGE = "THE PHONE NO. CANNOT BE EMPTY")

PRIVATE STRING PHONENO;

PRIVATE EXPERIENTA EXPERIENTA;

PRIVATE ANGAJATOR ANGAJATOR;

 PRIVATE RASPUNSFINAL RASPUNSFINAL;

}
CriteriiNecesareDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS CRITERIINECESAREDTO {

PRIVATE LONG CRITERIINECESARE_ID;

@NOTEMPTY(MESSAGE = "THE CRITERIU CANNOT BE EMPTY")
PRIVATE STRING CRITERIU;

PRIVATE JOBDISPONIBIL JOBDISPONIBIL;

}
CriteriuDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS CRITERIUDTO {

PRIVATE LONG CRITERIU_ID;

@NOTEMPTY(MESSAGE = "THE EXPERIENTA CANNOT BE EMPTY")
PRIVATE STRING EXPERIENTA;
@NOTEMPTY(MESSAGE = "THE STUDII CANNOT BE EMPTY")
PRIVATE STRING STUDII;
@NOTEMPTY(MESSAGE = "THE LIMBI CANNOT BE EMPTY")
PRIVATE STRING LIMBI;

PRIVATE CRITERIINECESARE CRITERIINECESARE;

 PRIVATE RESPONSABILHR RESPONSABILHR;

}
HiringDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.HASHMAP;
IMPORT JAVA.UTIL.MAP;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDATSITUATION;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.ENTITIES.SUBMISSION;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@ALLARGSCONSTRUCTOR
@NOARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS HIRINGDTO {

PRIVATE LONG HIRING_ID;

PRIVATE INTERVIU INTERVIU;

PRIVATE SUBMISSION SUBMISSION;

PRIVATE CANDIDATSITUATION CANDIDATSITUATION;

PRIVATE STRING MENTIONS;

PRIVATE MAP<STRING, OBJECT> ADDITIONALINFORMATIONS = NEW HASHMAP<STRING,

OBJECT>();
}
InterviuParticipantDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.HASHMAP;
IMPORT JAVA.UTIL.MAP;

IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANTPK;
IMPORT COM.DAM.TAM1.ENTITIES.PARTICIPANT;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS INTERVIUPARTICIPANTDTO {
 PRIVATE INTERVIUPARTICIPANTPK INTERVIUPARTICIPANTPK;

PRIVATE INTERVIU INTERVIU;

PRIVATE PARTICIPANT PARTICIPANT;

PRIVATE DATE DATEOFALLOCATION;

PRIVATE MAP<STRING, OBJECT> ADDITIONALINFORMATIONS = NEW HASHMAP<STRING,

OBJECT>();

}
InterviuParticipantPkDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS INTERVIUPARTICIPANTPKDTO {

PRIVATE LONG INTERVIUID;

PRIVATE LONG PARTICIPANTID;

}
InterviuReadDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.HASHMAP;
IMPORT JAVA.UTIL.MAP;

IMPORT JAVAX.PERSISTENCE.TRANSIENT;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDAT;
IMPORT COM.DAM.TAM1.ENTITIES.COMMUNICATIONCHANNEL;
IMPORT COM.DAM.TAM1.ENTITIES.POSITION;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYGETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYSETTER;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@JSONDESERIALIZE
PUBLIC CLASS INTERVIUREADDTO {

PRIVATE LONG INTERVIU_ID;

 PRIVATE DATE INTERVIUDATE;

PRIVATE COMMUNICATIONCHANNEL COMM;

PRIVATE CANDIDAT CANDIDAT;

PRIVATE POSITION POSITION;

@TRANSIENT
PRIVATE MAP<STRING, STRING> ADDITIONALINFORMATIONS = NEW HASHMAP<STRING,
STRING>();

@JSONANYGETTER
PUBLIC MAP<STRING, STRING> GETADDITIONALINFORMATION() {
RETURN ADDITIONALINFORMATIONS;
}

PUBLIC VOID SETADDITIONALINFORMATION(MAP<STRING, STRING>

ADDITIONALINFORMATION) {
THIS.ADDITIONALINFORMATIONS = ADDITIONALINFORMATION;
}

@JSONANYSETTER
PUBLIC VOID SETADDITIONALINFORMATION(FINAL STRING KEY, FINAL STRING VALUE) {
THIS.ADDITIONALINFORMATIONS.PUT(KEY, VALUE);
}
}
InterviuDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS INTERVIUDTO {

PRIVATE LONG INTERVIU_ID;

@NOTEMPTY(MESSAGE = "THE RASPUNSCANDIDAT CANNOT BE EMPTY")
PRIVATE STRING RASPUNSCANDIDAT;
@NOTEMPTY(MESSAGE = "THE REZULTATEQUIZ CANNOT BE EMPTY")
PRIVATE STRING REZULTATEQUIZ;
@NOTEMPTY(MESSAGE = "THE RASPFINALHR CANNOT BE EMPTY")
PRIVATE STRING RASPFINALHR;
@NOTEMPTY(MESSAGE = "THE PASSEDTEST CANNOT BE EMPTY")
PRIVATE STRING PASSEDTEST;
@NOTEMPTY(MESSAGE = "THE CANDIDATINTERESAT CANNOT BE EMPTY")
PRIVATE STRING CANDIDATINTERESAT;
@NOTEMPTY(MESSAGE = "THE TRECUTINTERVIU CANNOT BE EMPTY")
 PRIVATE STRING TRECUTINTERVIU;

PRIVATE CANDIDAT CANDIDAT;

PRIVATE RESPONSABILHR RESPONSABILHR;

}
JobDisponibilDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS JOBDISPONIBILDTO {

PRIVATE LONG JOBDISPONIBIL_ID;

@NOTEMPTY(MESSAGE = "THE CATEGORIE CANNOT BE EMPTY")
PRIVATE STRING CATEGORIE;
@NOTEMPTY(MESSAGE = "THE NUMEPOZITIE CANNOT BE EMPTY")
PRIVATE STRING NUMEPOZITIE;
@NOTEMPTY(MESSAGE = "THE DESCRIEREJOB CANNOT BE EMPTY")
PRIVATE STRING DESCRIEREJOB;
@NOTEMPTY(MESSAGE = "THE ORASJOB CANNOT BE EMPTY")
PRIVATE STRING ORASJOB;
@NOTEMPTY(MESSAGE = "THE TIPJOB CANNOT BE EMPTY")
PRIVATE STRING TIPJOB;
@NOTEMPTY(MESSAGE = "THE CRITERII CANNOT BE EMPTY")
PRIVATE STRING CRITERII;
@NOTEMPTY(MESSAGE = "THE DESCRIERECOMPANIE CANNOT BE EMPTY")
PRIVATE STRING DESCRIERECOMPANIE;

PRIVATE TIPJOB TIPJOB;

PRIVATE RESPONSABILHR RESPONSABILHR;

}
ParticipantDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT COM.DAM.TAM1.ENTITIES.POSITION;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS PARTICIPANTDTO {

PRIVATE LONG EMPLOYEE_ID;

PRIVATE STRING FIRSTNAME;

PRIVATE STRING LASTNAME;

PRIVATE STRING ADDRESS;

PRIVATE STRING EMAILADDRESS;

PRIVATE DATE DATEOFBIRTH;

PRIVATE STRING PHONENO;

PRIVATE POSITION POSITION;

PRIVATE STRING PARTICIPANT_ROLE;

PRIVATE STRING MENTIONS;

}
PositionDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS POSITIONDTO {

PRIVATE LONG POSITION_ID;

@NOTEMPTY(MESSAGE = "THE POSITION NAME CANNOT BE EMPTY")

PRIVATE STRING POSITIONNAME;

@MIN(VALUE = 5, MESSAGE = "THE SHORT DESCRIPTION CANNOT BE LESS THAN 5

CHARACTERS")
@MAX(VALUE = 150, MESSAGE = "THE DESCRIPTION CANNOT BE MORE THAN 150
CHARACTERS")
PRIVATE STRING SHORTDESCRIPTION;

PRIVATE BOOLEAN ISAVAILABLE;

PRIVATE INTEGER NO_AVAILABLE_POSITIONS;

}
PositionReadDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS POSITIONREADDTO {

PRIVATE LONG POSITION_ID;

@NOTEMPTY(MESSAGE = "THE POSITION NAME CANNOT BE EMPTY")

PRIVATE STRING POSITIONNAME;

PRIVATE STRING SHORTDESCRIPTION;

PRIVATE BOOLEAN ISAVAILABLE;

PRIVATE INTEGER NO_AVAILABLE_POSITIONS;

}
QuestionDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT COM.DAM.TAM1.ENTITIES.POSITION;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS QUESTIONDTO {

PRIVATE LONG QUESTION_ID;

PRIVATE STRING QUESTION_BODY;

PRIVATE POSITION POSITION;

PRIVATE INTEGER CORRECTRASPUNSFINAL;

}
QuestionQuizDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT COM.DAM.TAM1.ENTITIES.QUESTION;
IMPORT COM.DAM.TAM1.ENTITIES.QUESTIONQUIZPK;
IMPORT COM.DAM.TAM1.ENTITIES.QUIZ;
IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@ALLARGSCONSTRUCTOR
@NOARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS QUESTIONQUIZDTO {

PRIVATE QUESTIONQUIZPK QUESTIONQUIZPK;

PRIVATE QUESTION QUESTION;

PRIVATE QUIZ QUIZ;

}
QuizDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT COM.DAM.TAM1.ENTITIES.POSITION;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS QUIZDTO {

PRIVATE LONG QUIZ_ID;

PRIVATE STRING MENTIONS;

PRIVATE INTEGER SCORE_RESULT;

PRIVATE POSITION POSITION;

}
RaspunsFinalDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS RASPUNSFINALDTO {

PRIVATE LONG RASPUNSFINAL_ID;

@NOTEMPTY(MESSAGE = "THE VERDICT CANNOT BE EMPTY")
PRIVATE STRING VERDICT;

PRIVATE RESPONSABILHR RESPONSABILHR;

PRIVATE CANDIDAT CANDIDAT;

}
ResponsabilHRDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS RESPONSABILHRDTO {

PRIVATE LONG RESPONSABILHR_ID;

@NOTEMPTY(MESSAGE = "THE CONTACTFIRMA CANNOT BE EMPTY")
PRIVATE STRING CONTACTFIRMA;
@NOTEMPTY(MESSAGE = "THE JOBURI CANNOT BE EMPTY")
PRIVATE STRING JOBURI;
@NOTEMPTY(MESSAGE = "THE APLICARI CANNOT BE EMPTY")
PRIVATE STRING APLICARI;
@NOTEMPTY(MESSAGE = "THE INTERVIU CANNOT BE EMPTY")
PRIVATE STRING INTERVIU;

PRIVATE ANGAJATOR ANGAJATOR;

}
SubmissionDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;

IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.HASHMAP;
IMPORT JAVA.UTIL.MAP;

IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDAT;
IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;
IMPORT COM.DAM.TAM1.ENTITIES.POSITION;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYGETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYSETTER;

IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS SUBMISSIONDTO {

PRIVATE LONG ID;

PRIVATE DATE DATEOFSUBMISSION;

@MIN(VALUE= 10, MESSAGE = "THE MENTIONAT CANNOT BE LESS THAN 5 CHARACTERS")

@MAX(VALUE = 150, MESSAGE = "THE MENTION CANNOT BE MORE THAN 150 CHARACTERS")
PRIVATE STRING MENTION;

PRIVATE POSITION APPLIEDPOSITION;

PRIVATE CANDIDAT CANDIDAT;

PRIVATE HIRINGPROCESS HIRING;

PRIVATE MAP<STRING, OBJECT> ADDITIONALINFORMATIONS = NEW HASHMAP<STRING,

OBJECT>();

@JSONANYGETTER
PUBLIC MAP<STRING, OBJECT> GETADDITIONALINFORMATION() {
RETURN ADDITIONALINFORMATIONS;
}

PUBLIC VOID SETADDITIONALINFORMATION(MAP<STRING, OBJECT>

ADDITIONALINFORMATION) {
THIS.ADDITIONALINFORMATIONS = ADDITIONALINFORMATION;
}

@JSONANYSETTER
PUBLIC VOID SETADDITIONALINFORMATION(FINAL STRING KEY, FINAL STRING VALUE) {
THIS.ADDITIONALINFORMATIONS.PUT(KEY, VALUE);
}
}
SubmissionReadDTO
PACKAGE COM.DAM.TAM1.DATA;

IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.HASHMAP;
IMPORT JAVA.UTIL.MAP;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDAT;
IMPORT COM.DAM.TAM1.ENTITIES.POSITION;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYGETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYSETTER;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
PUBLIC CLASS SUBMISSIONREADDTO {

PRIVATE LONG ID;

PRIVATE DATE DATEOFSUBMISSION;

PRIVATE STRING MENTION;

PRIVATE POSITION APPLIEDPOSITION;

PRIVATE CANDIDAT CANDIDAT;

PRIVATE MAP<STRING, OBJECT> ADDITIONALINFORMATIONS = NEW HASHMAP<STRING,

OBJECT>();

@JSONANYGETTER
PUBLIC MAP<STRING, OBJECT> GETADDITIONALINFORMATION() {
RETURN ADDITIONALINFORMATIONS;
}

PUBLIC VOID SETADDITIONALINFORMATION(MAP<STRING, OBJECT>

ADDITIONALINFORMATION) {
THIS.ADDITIONALINFORMATIONS = ADDITIONALINFORMATION;
}

@JSONANYSETTER
PUBLIC VOID SETADDITIONALINFORMATION(FINAL STRING KEY, FINAL STRING VALUE) {
THIS.ADDITIONALINFORMATIONS.PUT(KEY, VALUE);
}

}
Entities
Angajator
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="ANGAJATORI")
PUBLIC CLASS ANGAJATOR IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG ANGAJATOR_ID;

@NOTEMPTY(MESSAGE = "THE FIRST NAME CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING FIRSTNAME;

@NOTEMPTY(MESSAGE = "THE LAST NAME CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING LASTNAME;
@NOTEMPTY(MESSAGE = "THE ADDRESS CANNOT BE EMPTY")
PRIVATE STRING ADDRESS;

@TEMPORAL(TEMPORALTYPE.DATE)
@JSONFORMAT(PATTERN="DD-MM-YYYY")
PRIVATE DATE DOB;

@EMAIL(MESSAGE = "EMAIL SHOULD BE VALID")

@NOTEMPTY(MESSAGE = "THE EMAIL ADDRESS CANNOT BE EMPTY")
PRIVATE STRING EMAILADDRESS;
PRIVATE STRING PHONENO;

@ENUMERATED(ENUMTYPE.STRING)
PRIVATE RASPUNSVERDICT RASPUNSVERDICT;
 @JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"ANGAJATOR")
PRIVATE LIST<CANDIDAT> CANDIDATI;

@ONETOONE(MAPPEDBY = "ANGAJATOR")
@JSONBACKREFERENCE(VALUE = "RESPONSABILHR_BACK")
PRIVATE RESPONSABILHR RESPONSABILHR;

AplicareJob
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="APLICAREJOBURI")
PUBLIC CLASS APLICAREJOB IMPLEMENTS SERIALIZABLE {
 PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG APLICAREJOB_ID;

@NOTEMPTY(MESSAGE = "THE RASPUNSAPLICARE CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING RASPUNSAPLICARE;

@TEMPORAL(TEMPORALTYPE.DATE)
@JSONFORMAT(PATTERN="DD-MM-YYYY")
PRIVATE DATE DOB;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "CANDIDAT_ID")
@JSONBACKREFERENCE
PRIVATE CANDIDAT CANDIDAT;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "JOBDISPONIBIL_ID")
@JSONBACKREFERENCE
PRIVATE JOBDISPONIBIL JOBDISPONIBIL;

}
Candidat
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="CANDIDATI")
PUBLIC CLASS CANDIDAT IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG CANDIDAT_ID;

@NOTEMPTY(MESSAGE = "THE FIRST NAME CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING FIRSTNAME;

@NOTEMPTY(MESSAGE = "THE LAST NAME CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING LASTNAME;
@NOTEMPTY(MESSAGE = "THE ADDRESS CANNOT BE EMPTY")
PRIVATE STRING ADDRESS;

@TEMPORAL(TEMPORALTYPE.DATE)
@JSONFORMAT(PATTERN="DD-MM-YYYY")
PRIVATE DATE DOB;

@EMAIL(MESSAGE = "EMAIL SHOULD BE VALID")

@NOTEMPTY(MESSAGE = "THE EMAIL ADDRESS CANNOT BE EMPTY")
PRIVATE STRING EMAILADDRESS;
PRIVATE STRING PHONENO;

@ENUMERATED(ENUMTYPE.STRING)
PRIVATE EXPERIENTA EXPERIENTA;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"CANDIDAT")
PRIVATE LIST<INTERVIU> INTERVIURI;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"CANDIDAT")
PRIVATE LIST<APLICAREJOB> APLICAREJOBURI;
 @MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "ANGAJATOR_ID")
@JSONBACKREFERENCE
PRIVATE ANGAJATOR ANGAJATOR;

@ONETOONE(MAPPEDBY = "CANDIDAT")
@JSONBACKREFERENCE(VALUE = "RASPUNSFINAL_BACK")
PRIVATE RASPUNSFINAL RASPUNSFINAL;

}
CandidatSituation
PACKAGE COM.DAM.TAM1.ENTITIES;

PUBLIC ENUM CANDIDATSITUATION {

WAITING,
UNDERREVIEW,
READYFORINTERVIU,
SCHEDULEDINTERVIU,
SCHEDULEDEVALUATION,
ACCEPTED,
REJECTED,
WAITINGFORFINALRESPONSE;
}
CommunicationChannel
PACKAGE COM.DAM.TAM1.ENTITIES;

PUBLIC ENUM COMMUNICATIONCHANNEL {

ON_SITE, ONLINE;
}
CriteriiNecesare
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="CRITERIINECESARE")
PUBLIC CLASS CRITERIINECESARE IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG CRITERIINECESARE_ID;

@NOTEMPTY(MESSAGE = "THE CRITERIU CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING CRITERIU;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"CRITERIINECESARE")
PRIVATE LIST<CRITERIU> CRITERII;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "JOBDISPONIBIL_ID")
@JSONBACKREFERENCE
PRIVATE JOBDISPONIBIL JOBDISPONIBIL;

}
Criteriu
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="CRITERII")
PUBLIC CLASS CRITERIU IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG CRITERIU_ID;

@NOTEMPTY(MESSAGE = "THE EXPERIENTA CANNOT BE EMPTY")

PRIVATE STRING EXPERIENTA;

@NOTEMPTY(MESSAGE = "THE STUDII CANNOT BE EMPTY")

PRIVATE STRING STUDII;

@NOTEMPTY(MESSAGE = "THE LIMBI CANNOT BE EMPTY")

PRIVATE STRING LIMBI;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "CRITERIINECESARE_ID")
@JSONBACKREFERENCE
PRIVATE CRITERIINECESARE CRITERIINECESARE;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "RESPONSABILHR_ID")
@JSONBACKREFERENCE
PRIVATE RESPONSABILHR RESPONSABILHR;

}
Employee
PACKAGE COM.DAM.TAM1.ENTITIES;
IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;

IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.JOINCOLUMN;
IMPORT JAVAX.PERSISTENCE.MANYTOONE;
IMPORT JAVAX.PERSISTENCE.MAPPEDSUPERCLASS;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT COM.SUN.ISTACK.NOTNULL;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@MAPPEDSUPERCLASS
@GETTER
@SETTER
@EQUALSANDHASHCODE
PUBLIC CLASS EMPLOYEE IMPLEMENTS SERIALIZABLE{
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG EMPLOYEE_ID;

@NOTNULL
@NOTEMPTY(MESSAGE = "THE FIRST NAME CANNOT BE EMPTY")
@MIN(VALUE = 5, MESSAGE = "THE FIRST NAME CANNOT BE LESS THAN 5 CHARACTERS")
@MAX(VALUE = 30, MESSAGE = "THE FIRST NAME CANNOT BE MORE THAN 30
CHARACTERS")
PRIVATE STRING FIRSTNAME;

@NOTNULL
@NOTEMPTY(MESSAGE = "THE LAST NAME CANNOT BE EMPTY")
@MIN(VALUE = 5, MESSAGE = "THE LAST NAME CANNOT BE LESS THAN 5 CHARACTERS")
@MAX(VALUE = 30, MESSAGE = "THE LAST NAME CANNOT BE MORE THAN 30 CHARACTERS")

PRIVATE STRING LASTNAME;

@NOTNULL
@NOTEMPTY(MESSAGE = "THE ADDRESS CANNOT BE EMPTY")
PRIVATE STRING ADDRESS;
 @EMAIL
@NOTEMPTY(MESSAGE = "THE EMAIL ADDRESS CANNOT BE EMPTY")
@NOTNULL
PRIVATE STRING EMAILADDRESS;

@TEMPORAL(TEMPORALTYPE.DATE)
PRIVATE DATE DATEOFBIRTH;

@NOTEMPTY(MESSAGE = "THE PHONE NUMBER FIELD CANNOT BE EMPTY")

@NOTNULL
@MIN(VALUE = 15, MESSAGE = "THE PHONE NO. CANNOT BE LESS THAN 15 CHARACTERS")
@MAX(VALUE = 20, MESSAGE = "THE PHONE NO. CANNOT BE MORE THAN 20 CHARACTERS")
PRIVATE STRING PHONENO;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "POSITION_ID")
PRIVATE POSITION POSITION;

}
Experienta
PACKAGE COM.DAM.TAM1.ENTITIES;

PUBLIC ENUM EXPERIENTA {

FARAEXPERIENTA, ENTRYLVL, MIDLVL, SENIOR, MANAGER;
}
HiringProcess
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.HASHMAP;
IMPORT JAVA.UTIL.MAP;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.ENUMTYPE;
IMPORT JAVAX.PERSISTENCE.ENUMERATED;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.JOINCOLUMN;
IMPORT JAVAX.PERSISTENCE.ONETOONE;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TRANSIENT;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYGETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYSETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONBACKREFERENCE;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TABLE(NAME = "HIRING_PROCESSES")
PUBLIC CLASS HIRINGPROCESS IMPLEMENTS SERIALIZABLE {
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG HIRING_ID;

@ONETOONE(CASCADE = CASCADETYPE.ALL)
@JOINCOLUMN(NAME = "INTERVIU_ID")
@JSONMANAGEDREFERENCE(VALUE = "HIRING_BACK")
PRIVATE INTERVIU INTERVIU;

@ONETOONE(MAPPEDBY = "HIRING", CASCADE = CASCADETYPE.PERSIST)

@JSONBACKREFERENCE
PRIVATE SUBMISSION SUBMISSION;

@ENUMERATED(ENUMTYPE.STRING)
PRIVATE CANDIDATSITUATION CANDIDATSITUATION;

PRIVATE STRING MENTIONS;

@TRANSIENT
PRIVATE MAP<STRING, OBJECT> ADDITIONALINFORMATIONS = NEW HASHMAP<STRING,
OBJECT>();

@JSONANYGETTER
PUBLIC MAP<STRING, OBJECT> GETADDITIONALINFORMATION() {
RETURN ADDITIONALINFORMATIONS;
}

PUBLIC VOID SETADDITIONALINFORMATION(MAP<STRING, OBJECT>

ADDITIONALINFORMATION) {
THIS.ADDITIONALINFORMATIONS = ADDITIONALINFORMATION;
}

@JSONANYSETTER
PUBLIC VOID SETADDITIONALINFORMATION(FINAL STRING KEY, FINAL OBJECT VALUE) {
THIS.ADDITIONALINFORMATIONS.PUT(KEY, VALUE);
}

}
InterviuParticipant
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.HASHMAP;
IMPORT JAVA.UTIL.MAP;

IMPORT JAVAX.PERSISTENCE.EMBEDDEDID;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.JOINCOLUMN;
IMPORT JAVAX.PERSISTENCE.MANYTOONE;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.PERSISTENCE.TRANSIENT;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYGETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYSETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONBACKREFERENCE;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TABLE(NAME = "INTERVIUS_PARTICIPANTS")
PUBLIC CLASS INTERVIUPARTICIPANT IMPLEMENTS SERIALIZABLE {
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@EMBEDDEDID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE INTERVIUPARTICIPANTPK INTERVIUPARTICIPANTPK;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "INTERVIU_ID", INSERTABLE = FALSE, UPDATABLE = FALSE)
@JSONBACKREFERENCE(VALUE = "INTERVIU_BACK")
PRIVATE INTERVIU INTERVIU;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "PARTICIPANT_ID", INSERTABLE = FALSE, UPDATABLE = FALSE)
@JSONBACKREFERENCE(VALUE = "PARTICIPANT_BACK")
PRIVATE PARTICIPANT PARTICIPANT;

@TEMPORAL(TEMPORALTYPE.DATE)
PRIVATE DATE DATEOFALLOCATION;

PUBLIC INTERVIUPARTICIPANT(INTERVIUPARTICIPANTPK INTERVIUPARTICIPANTPK, DATE

DATEOFALLOCATION) {
SUPER();
THIS.INTERVIUPARTICIPANTPK = INTERVIUPARTICIPANTPK;
THIS.DATEOFALLOCATION = DATEOFALLOCATION;
}

@TRANSIENT
PRIVATE MAP<STRING, OBJECT> ADDITIONALINFORMATIONS = NEW HASHMAP<STRING,
OBJECT>();

@JSONANYGETTER
PUBLIC MAP<STRING, OBJECT> GETADDITIONALINFORMATION() {
RETURN ADDITIONALINFORMATIONS;
}
 PUBLIC VOID SETADDITIONALINFORMATION(MAP<STRING, OBJECT>
ADDITIONALINFORMATION) {
THIS.ADDITIONALINFORMATIONS = ADDITIONALINFORMATION;
}

@JSONANYSETTER
PUBLIC VOID SETADDITIONALINFORMATION(FINAL STRING KEY, FINAL OBJECT VALUE) {
THIS.ADDITIONALINFORMATIONS.PUT(KEY, VALUE);
}
}
InterviuParticipantPk
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;

IMPORT JAVAX.PERSISTENCE.COLUMN;
IMPORT JAVAX.PERSISTENCE.EMBEDDABLE;

@EMBEDDABLE
PUBLIC CLASS INTERVIUPARTICIPANTPK IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@COLUMN(NAME = "INTERVIU_ID")
PRIVATE LONG INTERVIUID;

@COLUMN(NAME = "PARTICIPANT_ID")
PRIVATE LONG PARTICIPANTID;

PUBLIC INTERVIUPARTICIPANTPK() {}

PUBLIC INTERVIUPARTICIPANTPK(LONG INTERVIUID, LONG PARTICIPANTID) {

THIS.INTERVIUID = INTERVIUID;
THIS.PARTICIPANTID = PARTICIPANTID;
}

PUBLIC LONG GETINTERVIUID() {

RETURN INTERVIUID;
}

PUBLIC VOID SETINTERVIUID(LONG INTERVIUID) {

THIS.INTERVIUID = INTERVIUID;
}

PUBLIC LONG GETPARTICIPANTID() {

RETURN PARTICIPANTID;
}

PUBLIC VOID SETPARTICIPANTID(LONG PARTICIPANTID) {

THIS.PARTICIPANTID = PARTICIPANTID;
}

}
Interviu
PACKAGE COM.DAM.TAM1.ENTITIES;
IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="INTERVIURI")
PUBLIC CLASS INTERVIU IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG INTERVIU_ID;

@NOTEMPTY(MESSAGE = "THE RASPUNSCANDIDAT CANNOT BE EMPTY")

PRIVATE STRING RASPUNSCANDIDAT;

@NOTEMPTY(MESSAGE = "THE REZULTATEQUIZ CANNOT BE EMPTY")

PRIVATE STRING REZULTATEQUIZ;

@NOTEMPTY(MESSAGE = "THE RASPFINALHR CANNOT BE EMPTY")

PRIVATE STRING RASPFINALHR;
 @NOTEMPTY(MESSAGE = "THE PASSEDTEST CANNOT BE EMPTY")
PRIVATE STRING PASSEDTEST;

@NOTEMPTY(MESSAGE = "THE CANDIDATINTERESAT CANNOT BE EMPTY")

PRIVATE STRING CANDIDATINTERESAT;

@NOTEMPTY(MESSAGE = "THE TRECUTINTERVIU CANNOT BE EMPTY")

PRIVATE STRING TRECUTINTERVIU;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "CANDIDAT_ID")
@JSONBACKREFERENCE
PRIVATE CANDIDAT CANDIDAT;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "RESPONSABILHR_ID")
@JSONBACKREFERENCE
PRIVATE RESPONSABILHR RESPONSABILHR;

}
JobDisponibil
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="JOBURIDISPONIBILE")
PUBLIC CLASS JOBDISPONIBIL IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG JOBDISPONIBIL_ID;

@NOTEMPTY(MESSAGE = "THE CATEGORIE CANNOT BE EMPTY")

PRIVATE STRING CATEGORIE;

@NOTEMPTY(MESSAGE = "THE NUMEPOZITIE CANNOT BE EMPTY")

PRIVATE STRING NUMEPOZITIE;

@NOTEMPTY(MESSAGE = "THE DESCRIEREJOB CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING DESCRIEREJOB;

@NOTEMPTY(MESSAGE = "THE ORASJOB CANNOT BE EMPTY")

PRIVATE STRING ORASJOB;

@NOTEMPTY(MESSAGE = "THE TIPJOB CANNOT BE EMPTY")

PRIVATE STRING TIPJOB;

@NOTEMPTY(MESSAGE = "THE CRITERII CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING CRITERII;

@NOTEMPTY(MESSAGE = "THE DESCRIERECOMPANIE CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING DESCRIERECOMPANIE;

@ENUMERATED(ENUMTYPE.STRING)
PRIVATE TIPJOB TIPJOB;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"JOBDISPONIBIL")
PRIVATE LIST<APLICAREJOB> APLICAREJOBURI;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"JOBDISPONIBIL")
PRIVATE LIST<CRITERIINECESARE> CRITERIINECESARE;
 @MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "RESPONSABILHR_ID")
@JSONBACKREFERENCE
PRIVATE RESPONSABILHR RESPONSABILHR;

}
Participant
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONIGNORE;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.SUN.ISTACK.NOTNULL;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE(CALLSUPER = TRUE)
PUBLIC CLASS PARTICIPANT EXTENDS EMPLOYEE IMPLEMENTS SERIALIZABLE{
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@NOTEMPTY(MESSAGE = "THE PARTICIPANT ROLE CANNOT BE EMPTY")

@NOTNULL
@MIN(VALUE = 5, MESSAGE = "THE PARTICIPANT ROLE NAME CANNOT BE LESS THAN 5
CHARACTERS")
@MAX(VALUE = 20, MESSAGE = "THE PARTICIPANT ROLE NAME CANNOT BE MORE THAN 20
CHARACTERS")
PRIVATE STRING PARTICIPANT_ROLE;

@ONETOMANY(MAPPEDBY = "PARTICIPANT")
@JSONMANAGEDREFERENCE
@JSONIGNORE
PRIVATE LIST<INTERVIUPARTICIPANT> INTERVIUS;

PRIVATE STRING MENTIONS;

PUBLIC PARTICIPANT(LONG EMPLOYEE_ID, STRING FIRSTNAME, STRING LASTNAME,

STRING ADDRESS, STRING EMAILADDRESS,
DATE DATEOFBIRTH, STRING PHONENO, POSITION POSITION, STRING
PARTICIPANT_ROLE, STRING MENTIONS) {
SUPER(EMPLOYEE_ID, FIRSTNAME, LASTNAME, ADDRESS, EMAILADDRESS,
DATEOFBIRTH, PHONENO, POSITION);
THIS.PARTICIPANT_ROLE = PARTICIPANT_ROLE;
THIS.MENTIONS = MENTIONS;
}

}
Position
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONBACKREFERENCE;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.SUN.ISTACK.NOTNULL;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
PUBLIC CLASS POSITION IMPLEMENTS SERIALIZABLE{
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG POSITION_ID;

@NOTNULL
@NOTEMPTY(MESSAGE = "THE POSITION NAME CANNOT BE EMPTY")
@MIN(VALUE = 4, MESSAGE = "THE POSITION NAME CANNOT BE LESS THAN 4
CHARACTERS")
@MAX(VALUE = 20, MESSAGE = "THE POSITION NAME CANNOT BE MORE THAN 20
CHARACTERS")
PRIVATE STRING POSITIONNAME;

@NOTNULL
@NOTEMPTY(MESSAGE = "THE DESCRIPTION CANNOT BE EMPTY")
 @MIN(VALUE = 15, MESSAGE = "THE SHORT DESCRIPTION CANNOT BE LESS THAN 15
CHARACTERS")
@MAX(VALUE = 200, MESSAGE = "THE SHORT DESCRIPTION CANNOT BE MORE THAN 200
CHARACTERS")
PRIVATE STRING SHORTDESCRIPTION;

PRIVATE BOOLEAN ISAVAILABLE;

PRIVATE INTEGER NO_AVAILABLE_POSITIONS;

@ONETOMANY(MAPPEDBY = "POSITION", CASCADE = CASCADETYPE.ALL)

@JSONMANAGEDREFERENCE(VALUE = "POSITION_BACK")
PRIVATE LIST<QUIZ> QUIZZES;

@ONETOMANY(MAPPEDBY = "POSITION", CASCADE = CASCADETYPE.ALL)

@JSONMANAGEDREFERENCE
PRIVATE LIST<QUESTION> QUESTIONS;
}
Question
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.JOINCOLUMN;
IMPORT JAVAX.PERSISTENCE.MANYTOONE;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONBACKREFERENCE;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.SUN.ISTACK.NOTNULL;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TABLE(NAME = "QUESTIONS")
PUBLIC CLASS QUESTION IMPLEMENTS SERIALIZABLE {
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;
 @ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG QUESTION_ID;

@NOTNULL
@NOTEMPTY(MESSAGE = "THE QUESTION BODY CANNOT BE EMPTY")
@MIN(VALUE = 8, MESSAGE = "THE QUESTION BODY CANNOT BE LESS THAN 8
CHARACTERS")
@MAX(VALUE = 100, MESSAGE = "THE QUESTION BODY CANNOT BE MORE THAN 100
CHARACTERS")
PRIVATE STRING QUESTION_BODY;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "POSITION_ID")
@JSONBACKREFERENCE
PRIVATE POSITION POSITION;

@ONETOMANY(MAPPEDBY = "QUESTION", CASCADE = CASCADETYPE.ALL)

@JSONMANAGEDREFERENCE
PRIVATE LIST<RASPUNSFINAL> RASPUNSFINALS;

@ONETOMANY(MAPPEDBY = "QUESTION")
PRIVATE LIST<QUESTIONQUIZ> QUIZES;

PRIVATE INTEGER CORRECTRASPUNSFINAL;

PUBLIC QUESTION(LONG QUESTION_ID, @NOTEMPTY(MESSAGE = "THE QUESTION BODY

CANNOT BE EMPTY") STRING QUESTION_BODY,
POSITION POSITION) {
SUPER();
THIS.QUESTION_ID = QUESTION_ID;
THIS.QUESTION_BODY = QUESTION_BODY;
THIS.POSITION = POSITION;
}

}
QuestionQuiz
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;

IMPORT JAVAX.PERSISTENCE.EMBEDDEDID;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.JOINCOLUMN;
IMPORT JAVAX.PERSISTENCE.MANYTOONE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;
@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
PUBLIC CLASS QUESTIONQUIZ IMPLEMENTS SERIALIZABLE{
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@EMBEDDEDID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE QUESTIONQUIZPK QUESTIONQUIZPK;

@MANYTOONE(FETCH = FETCHTYPE.LAZY)
@JOINCOLUMN(NAME = "QUESTION_ID", INSERTABLE = FALSE, UPDATABLE = FALSE)
PRIVATE QUESTION QUESTION;

@MANYTOONE(FETCH = FETCHTYPE.LAZY)
@JOINCOLUMN(NAME = "QUIZ_ID", INSERTABLE = FALSE, UPDATABLE = FALSE)
PRIVATE QUIZ QUIZ;

PUBLIC QUESTIONQUIZ(QUESTIONQUIZPK QUESTIONQUIZPK) {

THIS.QUESTIONQUIZPK = QUESTIONQUIZPK;
}
}
QuestionQuizPk
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;

IMPORT JAVAX.PERSISTENCE.COLUMN;
IMPORT JAVAX.PERSISTENCE.EMBEDDABLE;

@EMBEDDABLE
PUBLIC CLASS QUESTIONQUIZPK IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@COLUMN(NAME="QUESTION_ID")
PRIVATE LONG QUESTIONID;

@COLUMN(NAME="QUIZ_ID")
PRIVATE LONG QUIZID;

PUBLIC LONG GETQUESTIONID() {

RETURN QUESTIONID;
}

PUBLIC VOID SETQUESTIONID(LONG QUESTIONID) {

THIS.QUESTIONID = QUESTIONID;
}

PUBLIC LONG GETQUIZID() {

RETURN QUIZID;
}

PUBLIC VOID SETQUIZID(LONG QUIZID) {

THIS.QUIZID = QUIZID;
 }

PUBLIC QUESTIONQUIZPK() {
}

}
Quiz
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.JOINCOLUMN;
IMPORT JAVAX.PERSISTENCE.MANYTOONE;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONBACKREFERENCE;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONIGNORE;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TABLE(NAME = "QUIZZES")
PUBLIC CLASS QUIZ IMPLEMENTS SERIALIZABLE{
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG QUIZ_ID;

PRIVATE STRING MENTIONS;

PRIVATE INTEGER SCORE_RESULT;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "POSITION_ID")
@JSONBACKREFERENCE(VALUE = "POSITION_BACK")
PRIVATE POSITION POSITION;
 @ONETOMANY(MAPPEDBY = "QUIZ", CASCADE = CASCADETYPE.ALL)
PRIVATE LIST<QUESTIONQUIZ> QUESTIONS;

@ONETOMANY(MAPPEDBY = "QUIZ", CASCADE = CASCADETYPE.ALL)

@JSONMANAGEDREFERENCE(VALUE = "QUIZ_BACK")
@JSONIGNORE
PRIVATE LIST<INTERVIU> INTERVIUS;
}
RaspunsFinal
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="RASPUNSURIFINALE")
PUBLIC CLASS RASPUNSFINAL IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
 @GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG RASPUNSFINAL_ID;

@NOTEMPTY(MESSAGE = "THE VERDICT CANNOT BE EMPTY")

@MIN(VALUE = 5, MESSAGE = "THE NUMBER OF CHARACTERS IS LESS THAN 5
CHARACTERS")
@MAX(VALUE= 40, MESSAGE = "THE NUMBER OF CHARACTERS IS MORE THAN 40")
PRIVATE STRING VERDICT;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "RESPONSABILHR_ID")
@JSONBACKREFERENCE
PRIVATE RESPONSABILHR RESPONSABILHR;

@ONETOONE(MAPPEDBY = "RASPUNSFINAL")
@JSONBACKREFERENCE(VALUE = "CANDIDAT_BACK")
PRIVATE CANDIDAT CANDIDAT;

}
RaspunsVerdict
PACKAGE COM.DAM.TAM1.ENTITIES;

PUBLIC ENUM RASPUNSVERDICT {

FAIL, ANGAJAT;
}
ResponsabilHR
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.ONETOMANY;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.EMAIL;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MAX;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.MIN;
IMPORT JAVAX.VALIDATION.CONSTRAINTS.NOTEMPTY;

IMPORT ORG.SPRINGFRAMEWORK.TRANSACTION.ANNOTATION.TRANSACTIONAL;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONFORMAT;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;
IMPORT COM.FASTERXML.JACKSON.DATABIND.ANNOTATION.JSONDESERIALIZE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TRANSACTIONAL(READONLY=TRUE)
@JSONDESERIALIZE
@TABLE(NAME="RESPONSABILIHR")
PUBLIC CLASS RESPONSABILHR IMPLEMENTS SERIALIZABLE {

PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG RESPONSABILHR_ID;

@NOTEMPTY(MESSAGE = "THE CONTACTFIRMA CANNOT BE EMPTY")

PRIVATE STRING CONTACTFIRMA;

@NOTEMPTY(MESSAGE = "THE JOBURI CANNOT BE EMPTY")

PRIVATE STRING JOBURI;

@NOTEMPTY(MESSAGE = "THE APLICARI CANNOT BE EMPTY")

PRIVATE STRING APLICARI;

@NOTEMPTY(MESSAGE = "THE INTERVIU CANNOT BE EMPTY")

PRIVATE STRING INTERVIU;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"RESPONSABILHR")
PRIVATE LIST<RASPUNSFINAL> RASPUNSURIFINALE;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"RESPONSABILHR")
PRIVATE LIST<JOBDISPONIBIL> JOBURIDISPONIBILE;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"RESPONSABILHR")
PRIVATE LIST<CRITERIU> CRITERII;

@JSONMANAGEDREFERENCE
@ONETOMANY(FETCH = FETCHTYPE.EAGER, CASCADE = CASCADETYPE.ALL, MAPPEDBY =
"RESPONSABILHR")
PRIVATE LIST<INTERVIU> INTERVIURI;

@ONETOONE(MAPPEDBY = "RESPONSABILHR")
@JSONBACKREFERENCE(VALUE = "ANGAJATOR_BACK")
PRIVATE ANGAJATOR ANGAJATOR;

}
Submission
PACKAGE COM.DAM.TAM1.ENTITIES;

IMPORT JAVA.IO.SERIALIZABLE;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.HASHMAP;
IMPORT JAVA.UTIL.MAP;

IMPORT JAVAX.PERSISTENCE.CASCADETYPE;
IMPORT JAVAX.PERSISTENCE.ENTITY;
IMPORT JAVAX.PERSISTENCE.FETCHTYPE;
IMPORT JAVAX.PERSISTENCE.GENERATEDVALUE;
IMPORT JAVAX.PERSISTENCE.GENERATIONTYPE;
IMPORT JAVAX.PERSISTENCE.ID;
IMPORT JAVAX.PERSISTENCE.JOINCOLUMN;
IMPORT JAVAX.PERSISTENCE.MANYTOONE;
IMPORT JAVAX.PERSISTENCE.ONETOONE;
IMPORT JAVAX.PERSISTENCE.TABLE;
IMPORT JAVAX.PERSISTENCE.TEMPORAL;
IMPORT JAVAX.PERSISTENCE.TEMPORALTYPE;
IMPORT JAVAX.PERSISTENCE.TRANSIENT;

IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYGETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONANYSETTER;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONBACKREFERENCE;
IMPORT COM.FASTERXML.JACKSON.ANNOTATION.JSONMANAGEDREFERENCE;

IMPORT LOMBOK.ALLARGSCONSTRUCTOR;
IMPORT LOMBOK.DATA;
IMPORT LOMBOK.EQUALSANDHASHCODE;
IMPORT LOMBOK.GETTER;
IMPORT LOMBOK.NOARGSCONSTRUCTOR;
IMPORT LOMBOK.SETTER;

@DATA
@ENTITY
@NOARGSCONSTRUCTOR
@ALLARGSCONSTRUCTOR
@GETTER
@SETTER
@EQUALSANDHASHCODE
@TABLE(NAME = "SUBMISSIONS")
PUBLIC CLASS SUBMISSION IMPLEMENTS SERIALIZABLE {
PRIVATE STATIC FINAL LONG SERIALVERSIONUID = 1L;

@ID
@GENERATEDVALUE(STRATEGY = GENERATIONTYPE.IDENTITY)
PRIVATE LONG ID;

@TEMPORAL(TEMPORALTYPE.DATE)
PRIVATE DATE DATEOFSUBMISSION;

PRIVATE STRING MENTION;

@MANYTOONE(FETCH = FETCHTYPE.EAGER)
@JOINCOLUMN(NAME = "POSITION_ID")
PRIVATE POSITION APPLIEDPOSITION;

@JSONBACKREFERENCE
@MANYTOONE(FETCH = FETCHTYPE.EAGER)
 @JOINCOLUMN(NAME="CANDIDAT_ID")
PRIVATE CANDIDAT CANDIDAT;

@ONETOONE(CASCADE = CASCADETYPE.ALL, OPTIONAL = FALSE, ORPHANREMOVAL = TRUE)

@JOINCOLUMN(NAME = "HIRING_ID")
@JSONMANAGEDREFERENCE
PRIVATE HIRINGPROCESS HIRING;

@TRANSIENT
PRIVATE MAP<STRING, OBJECT> ADDITIONALINFORMATIONS = NEW HASHMAP<STRING,
OBJECT>();

@JSONANYGETTER
PUBLIC MAP<STRING, OBJECT> GETADDITIONALINFORMATION() {
RETURN ADDITIONALINFORMATIONS;
}

PUBLIC VOID SETADDITIONALINFORMATION(MAP<STRING, OBJECT>

ADDITIONALINFORMATION) {
THIS.ADDITIONALINFORMATIONS = ADDITIONALINFORMATION;
}

@JSONANYSETTER
PUBLIC VOID SETADDITIONALINFORMATION(FINAL STRING KEY, FINAL STRING VALUE) {
THIS.ADDITIONALINFORMATIONS.PUT(KEY, VALUE);
}
}
TipJob
PACKAGE COM.DAM.TAM1.ENTITIES;

PUBLIC ENUM TIPJOB {

FULLTIME, PARTTIME, INTERNSHIP, PROIECT;
}
Repository
AngajatorR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.ANGAJATOR;

@REPOSITORY
PUBLIC INTERFACE ANGAJATORREPOSITORY EXTENDS JPAREPOSITORY<ANGAJATOR, LONG> {

AplicareJobR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.APLICAREJOB;

@REPOSITORY
PUBLIC INTERFACE APLICAREJOBREPOSITORY EXTENDS JPAREPOSITORY<APLICAREJOB, LONG> {

}
CandidatR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDAT;

@REPOSITORY
PUBLIC INTERFACE CANDIDATREPOSITORY EXTENDS JPAREPOSITORY<CANDIDAT, LONG> {

}
CriteriiNecesareR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.CRITERIINECESARE;

@REPOSITORY
PUBLIC INTERFACE CRITERIINECESAREREPOSITORY EXTENDS JPAREPOSITORY<CRITERIINECESARE,
LONG> {

}
CriteriuR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.CRITERIU;

@REPOSITORY
PUBLIC INTERFACE CRITERIUREPOSITORY EXTENDS JPAREPOSITORY<CRITERIU, LONG> {

}
EmployeeR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.EMPLOYEE;

@REPOSITORY
PUBLIC INTERFACE EMPLOYEEREPOSITORY EXTENDS JPAREPOSITORY<EMPLOYEE, LONG> {

}
HiringR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;

@REPOSITORY
PUBLIC INTERFACE HIRINGREPOSITORY EXTENDS JPAREPOSITORY<HIRINGPROCESS, LONG> {
}
interviuParticipantR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANT;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANTPK;

@REPOSITORY
PUBLIC INTERFACE INTERVIUPARTICIPANTREPOSITORY EXTENDS
JPAREPOSITORY<INTERVIUPARTICIPANT, INTERVIUPARTICIPANTPK> {

}
InterviuR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;

@REPOSITORY
PUBLIC INTERFACE INTERVIUREPOSITORY EXTENDS JPAREPOSITORY<INTERVIU, LONG> {

}
JobDisponibilR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.JOBDISPONIBIL;

@REPOSITORY
PUBLIC INTERFACE JOBDISPONIBILREPOSITORY EXTENDS JPAREPOSITORY<JOBDISPONIBIL, LONG>
{

}
ParticipantR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.PARTICIPANT;

@REPOSITORY
PUBLIC INTERFACE PARTICIPANTREPOSITORY EXTENDS JPAREPOSITORY<PARTICIPANT, LONG> {

}
PositionR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;
IMPORT COM.DAM.TAM1.ENTITIES.POSITION;

@REPOSITORY
PUBLIC INTERFACE POSITIONREPOSITORY EXTENDS JPAREPOSITORY<POSITION, LONG> {
}
QuestionQuizR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.QUESTIONQUIZ;
IMPORT COM.DAM.TAM1.ENTITIES.QUESTIONQUIZPK;

@REPOSITORY
PUBLIC INTERFACE QUESTIONQUIZREPOSITORY EXTENDS JPAREPOSITORY<QUESTIONQUIZ,
QUESTIONQUIZPK> {

}
QuestionR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.QUESTION;

@REPOSITORY
PUBLIC INTERFACE QUESTIONREPOSITORY EXTENDS JPAREPOSITORY<QUESTION, LONG> {
}
QuizR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.QUIZ;

@REPOSITORY
PUBLIC INTERFACE QUIZREPOSITORY EXTENDS JPAREPOSITORY<QUIZ, LONG> {
}
RaspunsFinalR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.RASPUNSFINAL;

@REPOSITORY
PUBLIC INTERFACE RASPUNSFINALREPOSITORY EXTENDS JPAREPOSITORY<RASPUNSFINAL, LONG> {

}
ResponsabilHRR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;
IMPORT COM.DAM.TAM1.ENTITIES.RESPONSABILHR;

@REPOSITORY
PUBLIC INTERFACE RESPONSABILHRREPOSITORY EXTENDS JPAREPOSITORY<RESPONSABILHR, LONG>
{

}
SubmissionR
PACKAGE COM.DAM.TAM1.REPOSITORIES;

IMPORT ORG.SPRINGFRAMEWORK.DATA.JPA.REPOSITORY.JPAREPOSITORY;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.REPOSITORY;

IMPORT COM.DAM.TAM1.ENTITIES.SUBMISSION;

@REPOSITORY
PUBLIC INTERFACE SUBMISSIONREPOSITORY EXTENDS JPAREPOSITORY<SUBMISSION, LONG> {
}
Services
ANGAJATORSERVICE
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.LISTITERATOR;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.ANGAJATOR;
IMPORT COM.DAM.TAM1.REPOSITORIES.ANGAJATORREPOSITORY;

@SERVICE
PUBLIC CLASS ANGAJATORSERVICE {

PRIVATE ANGAJATORREPOSITORY ANGAJATORREPOSITORY;

@AUTOWIRED
PUBLIC ANGAJATORSERVICE(ANGAJATORREPOSITORY ANGAJATORREPOSITORY) {
THIS.ANGAJATORREPOSITORY = ANGAJATORREPOSITORY;
}

PUBLIC ANGAJATOR SAVEANGAJATOR(ANGAJATOR ANGAJATOR) {

RETURN THIS.ANGAJATORREPOSITORY.SAVE(ANGAJATOR);
}

PUBLIC ANGAJATOR UPDATEANGAJATOR(ANGAJATOR ANGAJATOR) {

RETURN THIS.ANGAJATORREPOSITORY.SAVE(ANGAJATOR);
}

PUBLIC VOID DELETEANGAJATOR(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.ANGAJATORREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC ANGAJATOR GETANGAJATORBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
ANGAJATOR EXISTINGANGAJATOR =
THIS.ANGAJATORREPOSITORY.FINDBYID(LONG_ID).GET();
RETURN EXISTINGANGAJATOR;
 }

PUBLIC ANGAJATOR GETANGAJATORBYNAME(STRING FIRSTNAME, STRING LASTNAME) {

LIST<ANGAJATOR> EXISTINGANGAJATORI =
THIS.ANGAJATORREPOSITORY.FINDALL();

IF(!EXISTINGANGAJATORI.EQUALS(NULL) || !EXISTINGANGAJATORI.ISEMPTY()) {
LISTITERATOR<ANGAJATOR> ANGAJATORITERATOR =
EXISTINGANGAJATORI.LISTITERATOR();
WHILE(ANGAJATORITERATOR.HASNEXT()) {
ANGAJATOR C = ANGAJATORITERATOR.NEXT();
IF(C.GETFIRSTNAME().EQUALS(FIRSTNAME) &&
C.GETLASTNAME().EQUALS(LASTNAME)) {
RETURN C;
} ELSE {
SYSTEM.OUT.PRINTLN("NO ANGAJATOR FOUND!");
}
}
}

RETURN NULL;
}

PUBLIC LIST<ANGAJATOR> GETALLANGAJATORI() {

RETURN THIS.ANGAJATORREPOSITORY.FINDALL();
}

AplicareJobService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.APLICAREJOB;
IMPORT COM.DAM.TAM1.REPOSITORIES.APLICAREJOBREPOSITORY;

@SERVICE
PUBLIC CLASS APLICAREJOBSERVICE {

PRIVATE APLICAREJOBREPOSITORY APLICAREJOBREPOSITORY;

@AUTOWIRED
PUBLIC VOID SETAPLICAREJOBREPOSITORY(APLICAREJOBREPOSITORY
APLICAREJOBREPOSITORY) {
THIS.APLICAREJOBREPOSITORY = APLICAREJOBREPOSITORY;
}

PUBLIC APLICAREJOB SAVEAPLICAREJOB(APLICAREJOB APLICAREJOB) {

RETURN THIS.APLICAREJOBREPOSITORY.SAVE(APLICAREJOB);
}

PUBLIC VOID UPDATEAPLICAREJOB(APLICAREJOB APLICAREJOB) {

THIS.APLICAREJOBREPOSITORY.SAVE(APLICAREJOB);
}
 PUBLIC VOID DELETEAPLICAREJOBBYID(INTEGER ID) {
LONG LONG_ID = LONG.VALUEOF(ID);
THIS.APLICAREJOBREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC APLICAREJOB GETAPLICAREJOBBYID(INTEGER ID) {

LONG APLICAREJOBID = LONG.VALUEOF(ID);
RETURN THIS.APLICAREJOBREPOSITORY.FINDBYID(APLICAREJOBID).GET();
}

PUBLIC LIST<APLICAREJOB> GETALLAPLICAREJOBURI(){

RETURN THIS.APLICAREJOBREPOSITORY.FINDALL();
}
}
CandidatService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.LISTITERATOR;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDAT;
IMPORT COM.DAM.TAM1.REPOSITORIES.CANDIDATREPOSITORY;

@SERVICE
PUBLIC CLASS CANDIDATSERVICE {

PRIVATE CANDIDATREPOSITORY CANDIDATREPOSITORY;

@AUTOWIRED
PUBLIC CANDIDATSERVICE(CANDIDATREPOSITORY CANDIDATREPOSITORY) {
THIS.CANDIDATREPOSITORY = CANDIDATREPOSITORY;
}

PUBLIC CANDIDAT SAVECANDIDAT(CANDIDAT CANDIDAT) {

RETURN THIS.CANDIDATREPOSITORY.SAVE(CANDIDAT);
}

PUBLIC CANDIDAT UPDATECANDIDAT(CANDIDAT CANDIDAT) {

RETURN THIS.CANDIDATREPOSITORY.SAVE(CANDIDAT);
}

PUBLIC VOID DELETECANDIDAT(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.CANDIDATREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC CANDIDAT GETCANDIDATBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
CANDIDAT EXISTINGCANDIDAT =
THIS.CANDIDATREPOSITORY.FINDBYID(LONG_ID).GET();
RETURN EXISTINGCANDIDAT;
}

PUBLIC CANDIDAT GETCANDIDATBYNAME(STRING FIRSTNAME, STRING LASTNAME) {

 LIST<CANDIDAT> EXISTINGCANDIDATI = THIS.CANDIDATREPOSITORY.FINDALL();

IF(!EXISTINGCANDIDATI.EQUALS(NULL) || !EXISTINGCANDIDATI.ISEMPTY()) {
LISTITERATOR<CANDIDAT> CANDIDATITERATOR =
EXISTINGCANDIDATI.LISTITERATOR();
WHILE(CANDIDATITERATOR.HASNEXT()) {
CANDIDAT C = CANDIDATITERATOR.NEXT();
IF(C.GETFIRSTNAME().EQUALS(FIRSTNAME) &&
C.GETLASTNAME().EQUALS(LASTNAME)) {
RETURN C;
} ELSE {
SYSTEM.OUT.PRINTLN("NO CANDIDAT FOUND!");
}
}
}

RETURN NULL;
}

PUBLIC LIST<CANDIDAT> GETALLCANDIDATI() {

RETURN THIS.CANDIDATREPOSITORY.FINDALL();
}

}
CriteriiNecesareService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.CRITERIINECESARE;
IMPORT COM.DAM.TAM1.REPOSITORIES.CRITERIINECESAREREPOSITORY;

@SERVICE
PUBLIC CLASS CRITERIINECESARESERVICE {

PRIVATE CRITERIINECESAREREPOSITORY CRITERIINECESAREREPOSITORY;

@AUTOWIRED
PUBLIC VOID SETCRITERIINECESAREREPOSITORY(CRITERIINECESAREREPOSITORY
CRITERIINECESAREREPOSITORY) {
THIS.CRITERIINECESAREREPOSITORY = CRITERIINECESAREREPOSITORY;
}

PUBLIC CRITERIINECESARE SAVECRITERIINECESARE(CRITERIINECESARE

CRITERIINECESARE) {
RETURN THIS.CRITERIINECESAREREPOSITORY.SAVE(CRITERIINECESARE);
}

PUBLIC VOID UPDATECRITERIINECESARE(CRITERIINECESARE CRITERIINECESARE) {

THIS.CRITERIINECESAREREPOSITORY.SAVE(CRITERIINECESARE);
}

PUBLIC VOID DELETECRITERIINECESAREBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.CRITERIINECESAREREPOSITORY.DELETEBYID(LONG_ID);
 }

PUBLIC CRITERIINECESARE GETCRITERIINECESAREBYID(INTEGER ID) {

LONG CRITERIINECESAREID = LONG.VALUEOF(ID);
RETURN
THIS.CRITERIINECESAREREPOSITORY.FINDBYID(CRITERIINECESAREID).GET();
}

PUBLIC LIST<CRITERIINECESARE> GETALLCRITERIINECESARE(){

RETURN THIS.CRITERIINECESAREREPOSITORY.FINDALL();
}
}
CriteriuService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.CRITERIU;
IMPORT COM.DAM.TAM1.REPOSITORIES.CRITERIUREPOSITORY;

@SERVICE
PUBLIC CLASS CRITERIUSERVICE {

PRIVATE CRITERIUREPOSITORY CRITERIUREPOSITORY;

@AUTOWIRED
PUBLIC VOID SETCRITERIUREPOSITORY(CRITERIUREPOSITORY CRITERIUREPOSITORY) {
THIS.CRITERIUREPOSITORY = CRITERIUREPOSITORY;
}

PUBLIC CRITERIU SAVECRITERIU(CRITERIU CRITERIU) {

RETURN THIS.CRITERIUREPOSITORY.SAVE(CRITERIU);
}

PUBLIC VOID UPDATECRITERIU(CRITERIU CRITERIU) {

THIS.CRITERIUREPOSITORY.SAVE(CRITERIU);
}

PUBLIC VOID DELETECRITERIUBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.CRITERIUREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC CRITERIU GETCRITERIUBYID(INTEGER ID) {

LONG CRITERIUID = LONG.VALUEOF(ID);
RETURN THIS.CRITERIUREPOSITORY.FINDBYID(CRITERIUID).GET();
}

PUBLIC LIST<CRITERIU> GETALLCRITERII(){

RETURN THIS.CRITERIUREPOSITORY.FINDALL();
}
}
HiringFlowServiceImpl
PACKAGE COM.DAM.TAM1.SERVICES;
IMPORT JAVA.TIME.LOCALDATETIME;
IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDAT;
IMPORT COM.DAM.TAM1.ENTITIES.CANDIDATSITUATION;
IMPORT COM.DAM.TAM1.ENTITIES.COMMUNICATIONCHANNEL;
IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANT;
IMPORT COM.DAM.TAM1.ENTITIES.POSITION;
IMPORT COM.DAM.TAM1.ENTITIES.SUBMISSION;
IMPORT COM.DAM.TAM1.UTILS.DATEUTILS4J8API;

@SERVICE
PUBLIC CLASS HIRINGFLOWSERVICEIMPL IMPLEMENTS IHIRINGFLOWSERVICE {

@AUTOWIRED
PRIVATE INTERVIUSERVICE INTERVIUSERVICE;

@AUTOWIRED
PRIVATE HIRINGSERVICE HIRINGSERVICE;

@AUTOWIRED
PRIVATE NOTIFICATIONSERVICE NOTIFICATIONSERVICE;

@AUTOWIRED
PRIVATE SUBMISSIONSERVICE SUBMISSIONSERVICE;

@AUTOWIRED
PRIVATE CANDIDATSERVICE CANDIDATSERVICE;

@AUTOWIRED
PRIVATE POSITIONSERVICE POSITIONSERVICE;

@OVERRIDE
PUBLIC VOID ENTRYSUBMISSIONWITHCANDIDAT(SUBMISSION SUBMISSION) {
LOCALDATETIME ENTRYDATE = LOCALDATETIME.NOW();

SYSTEM.OUT.PRINTLN(ENTRYDATE);
SUBMISSION.SETDATEOFSUBMISSION(DATEUTILS4J8API.ASDATE(ENTRYDATE));

HIRINGPROCESS HIRINGPROCESS = NEW HIRINGPROCESS(NULL, NULL, SUBMISSION,

CANDIDATSITUATION.WAITING, NULL, NULL);
SUBMISSION.SETHIRING(HIRINGPROCESS);

THIS.SUBMISSIONSERVICE.SAVESUBMISSION(SUBMISSION);
}

@OVERRIDE
PUBLIC INTERVIU SCHEDULEINTERVIUWITHDETAILS(HIRINGPROCESS HIRINGPROCESS, DATE
STARTDATE, COMMUNICATIONCHANNEL COMM) {
IF
(HIRINGPROCESS.GETCANDIDATSITUATION().EQUALS(CANDIDATSITUATION.READYFORINTERVIU)
&& STARTDATE != NULL) {
 LOCALDATETIME INTERVIUSCHEDULEDDATE =
DATEUTILS4J8API.ASLOCALDATETIME(STARTDATE);

INTERVIU SCHEDULEDINTERVIU = NEW INTERVIU(NULL,

DATEUTILS4J8API.ASDATE(INTERVIUSCHEDULEDDATE), COMM, HIRINGPROCESS, NULL, NULL,
NULL);

HIRINGPROCESS.SETINTERVIU(SCHEDULEDINTERVIU);
THIS.NOTIFICATIONSERVICE.NOTIFICATIONONINTERVIU(HIRINGPROCESS);

RETURN THIS.INTERVIUSERVICE.SAVEINTERVIU(SCHEDULEDINTERVIU);

} ELSE IF
(HIRINGPROCESS.GETCANDIDATSITUATION().EQUALS(CANDIDATSITUATION.READYFORINTERVIU)
&& STARTDATE == NULL) {

LOCALDATETIME INTERVIUSCHEDULEDDATE =
LOCALDATETIME.NOW().PLUSWEEKS(2);

INTERVIU SCHEDULEDINTERVIU = NEW INTERVIU(NULL,

DATEUTILS4J8API.ASDATE(INTERVIUSCHEDULEDDATE), COMM, HIRINGPROCESS, NULL, NULL,
NULL);

HIRINGPROCESS.SETINTERVIU(SCHEDULEDINTERVIU);
THIS.NOTIFICATIONSERVICE.NOTIFICATIONONINTERVIU(HIRINGPROCESS);

RETURN THIS.INTERVIUSERVICE.SAVEINTERVIU(SCHEDULEDINTERVIU);

RETURN NULL;
}

@OVERRIDE
PUBLIC LIST<SUBMISSION> GETSUBMISSIONS() {
RETURN THIS.SUBMISSIONSERVICE.GETALLSUBMISSIONS();
}

@OVERRIDE
PUBLIC VOID WITHDRAWSUBMISSION(INTEGER ID) {
THIS.SUBMISSIONSERVICE.DELETESUBMISSIONBYID(ID);
}

@OVERRIDE
PUBLIC HIRINGPROCESS ENTRYSUBMISSIONWITHCANDIDAT(INTEGER CANDIDATID, INTEGER
POSITIONID) {

CANDIDAT CANDIDAT = THIS.CANDIDATSERVICE.GETCANDIDATBYID(CANDIDATID);

POSITION POSITION = THIS.POSITIONSERVICE.GETPOSITIONBYID(POSITIONID);

LOCALDATETIME ENTRYDATE = LOCALDATETIME.NOW();

SUBMISSION SUBMISSION = NEW SUBMISSION(NULL,

DATEUTILS4J8API.ASDATE(ENTRYDATE), NULL, POSITION, CANDIDAT, NULL, NULL);

HIRINGPROCESS HIRINGPROCESS = NEW HIRINGPROCESS(NULL, NULL, SUBMISSION,

CANDIDATSITUATION.WAITING, NULL, NULL);
 THIS.CHANGECANDIDATSTATUS(HIRINGPROCESS);
RETURN THIS.HIRINGSERVICE.SAVEHIRING(HIRINGPROCESS);
}

@OVERRIDE
PUBLIC INTERVIU SCHEDULESIMPLEINTERVIU(INTERVIU INTERVIU) {

IF(INTERVIU.GETHIRING().GETCANDIDATSITUATION() ==
CANDIDATSITUATION.READYFORINTERVIU && INTERVIU.GETINTERVIUDATE() != NULL) {
IF(INTERVIU.GETHIRING().GETINTERVIU() != NULL) {
SYSTEM.OUT.PRINTLN("IS HERE");
HIRINGPROCESS HIRING =
THIS.HIRINGSERVICE.GETHIRINGPROCESSBYID(INTERVIU.GETHIRING().GETHIRING_ID().INTVALU
E());
INTERVIU INTERVIUTOBEREMOVED = HIRING.GETINTERVIU();

THIS.INTERVIUSERVICE.DELETEINTERVIUBYID(INTERVIUTOBEREMOVED.GETINTERVIU_ID().INTVAL
UE());

INTERVIU.GETHIRING().SETINTERVIU(INTERVIU);

INTERVIU INTERVIUNOTIFICATION =
THIS.HIRINGSERVICE.UPDATEHIRINGPROCESSWITHINTERVIU(INTERVIU.GETHIRING());

THIS.NOTIFICATIONSERVICE.NOTIFICATIONONINTERVIU(INTERVIUNOTIFICATION.GETHIRING());
// HIRING.SETINTERVIU(INTERVIU);
// THIS.HIRINGSERVICE.UPDATEHIRINGPROCESS(HIRING);
// RETURN THIS.INTERVIUSERVICE.SAVEINTERVIU(INTERVIU);

RETURN INTERVIUNOTIFICATION;
} ELSE {
INTERVIU.GETHIRING().SETINTERVIU(INTERVIU);
INTERVIU INTERVIUNOTIFICATION =
THIS.HIRINGSERVICE.UPDATEHIRINGPROCESSWITHINTERVIU(INTERVIU.GETHIRING());

THIS.NOTIFICATIONSERVICE.NOTIFICATIONONINTERVIU(INTERVIUNOTIFICATION.GETHIRING());

RETURN INTERVIUNOTIFICATION;
}
} ELSE IF (INTERVIU.GETHIRING().GETCANDIDATSITUATION() ==
CANDIDATSITUATION.READYFORINTERVIU && INTERVIU.GETINTERVIUDATE() == NULL) {
LOCALDATETIME INTERVIUSCHEDULEDDATE =
LOCALDATETIME.NOW().PLUSWEEKS(2);

INTERVIU.SETINTERVIUDATE(DATEUTILS4J8API.ASDATE(INTERVIUSCHEDULEDDATE));
INTERVIU.GETHIRING().SETINTERVIU(INTERVIU);

INTERVIU INTERVIUNOTIFICATION =
THIS.HIRINGSERVICE.UPDATEHIRINGPROCESSWITHINTERVIU(INTERVIU.GETHIRING());

THIS.NOTIFICATIONSERVICE.NOTIFICATIONONINTERVIU(INTERVIUNOTIFICATION.GETHIRING());
RETURN INTERVIUNOTIFICATION;
}
RETURN NULL;
 }

@OVERRIDE
PUBLIC VOID ALLOCATEPARTICIPANTTOINTERVIU(INTERVIUPARTICIPANT
INTERVIUPARTICIPANT) {

@OVERRIDE
PUBLIC VOID CHANGECANDIDATSTATUS(HIRINGPROCESS HIRINGPROCESS) {
THIS.NOTIFICATIONSERVICE.NOTIFICATIONONSTATUSCHANGE(HIRINGPROCESS);
}

}
HiringService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.OPTIONAL;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDATSITUATION;
IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.REPOSITORIES.HIRINGREPOSITORY;

@SERVICE
PUBLIC CLASS HIRINGSERVICE {

PRIVATE HIRINGREPOSITORY HIRINGREPOSITORY;

PRIVATE IHIRINGFLOWSERVICE HIRINGSERVICE;

PRIVATE INTEGER NEXTID = 0;

PUBLIC LONG GETNEXTID() {

LONG NEXTIDL = LONG.VALUEOF(NEXTID);
NEXTIDL++;
RETURN NEXTIDL;
}

@AUTOWIRED
PUBLIC VOID SETHIRINGREPOSITORY(HIRINGREPOSITORY HIRINGREPOSITORY) {
THIS.HIRINGREPOSITORY = HIRINGREPOSITORY;
}

@AUTOWIRED
PUBLIC VOID SETHIRINGSERVICE(IHIRINGFLOWSERVICE HIRINGSERVICE) {
THIS.HIRINGSERVICE = HIRINGSERVICE;
}

PUBLIC HIRINGPROCESS SAVEHIRING(HIRINGPROCESS HIRINGPROCESS) {

HIRINGPROCESS.SETCANDIDATSITUATION(CANDIDATSITUATION.WAITING);
RETURN THIS.HIRINGREPOSITORY.SAVE(HIRINGPROCESS);
}
 PUBLIC VOID UPDATEHIRINGPROCESS(HIRINGPROCESS HIRINGPROCESS) {
HIRINGPROCESS UPDATEDHIRING =
THIS.GETHIRINGPROCESSBYID(HIRINGPROCESS.GETHIRING_ID().INTVALUE());
UPDATEDHIRING.SETMENTIONS(HIRINGPROCESS.GETMENTIONS());

UPDATEDHIRING.SETCANDIDATSITUATION(HIRINGPROCESS.GETCANDIDATSITUATION());
THIS.HIRINGSERVICE.CHANGECANDIDATSTATUS(UPDATEDHIRING);
THIS.HIRINGREPOSITORY.SAVE(UPDATEDHIRING);
}

PUBLIC INTERVIU UPDATEHIRINGPROCESSWITHINTERVIU(HIRINGPROCESS HIRINGPROCESS)

{
RETURN THIS.HIRINGREPOSITORY.SAVE(HIRINGPROCESS).GETINTERVIU();
}

PUBLIC VOID DELETEHIRINGPROCESS(HIRINGPROCESS HIRINGPROCESS) {

THIS.HIRINGREPOSITORY.DELETE(HIRINGPROCESS);
}

PUBLIC VOID DELETEHIRINGPROCESSBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.HIRINGREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC HIRINGPROCESS GETHIRINGPROCESSBYID(INTEGER ID) {

LONG HIRINGID = LONG.VALUEOF(ID);

TRY {
OPTIONAL<HIRINGPROCESS> HIRINGPROCESSFOUND =
THIS.HIRINGREPOSITORY.FINDBYID(HIRINGID);
HIRINGPROCESS HIRINGPROCESS = HIRINGPROCESSFOUND.GET();

IF(HIRINGPROCESS.GETINTERVIU() == NULL ||
HIRINGPROCESS.GETINTERVIU().GETINTERVIUDATE() == NULL) {
HIRINGPROCESS.GETADDITIONALINFORMATION().PUT("FIRSTNAME",
HIRINGPROCESS.GETSUBMISSION().GETCANDIDAT().GETFIRSTNAME());

HIRINGPROCESS.GETADDITIONALINFORMATION().PUT("POSITIONNAME",
HIRINGPROCESS.GETSUBMISSION().GETAPPLIEDPOSITION().GETPOSITIONNAME());
} ELSE {

HIRINGPROCESS.GETADDITIONALINFORMATION().PUT("INTERVIUDATE",
HIRINGPROCESS.GETINTERVIU().GETINTERVIUDATE().TOSTRING());
HIRINGPROCESS.GETADDITIONALINFORMATION().PUT("FIRSTNAME",
HIRINGPROCESS.GETSUBMISSION().GETCANDIDAT().GETFIRSTNAME());

HIRINGPROCESS.GETADDITIONALINFORMATION().PUT("POSITIONNAME",
HIRINGPROCESS.GETSUBMISSION().GETAPPLIEDPOSITION().GETPOSITIONNAME());
}

RETURN HIRINGPROCESS;

} CATCH(EXCEPTION E) { E.PRINTSTACKTRACE(); }

RETURN NULL;
}

PUBLIC LIST<HIRINGPROCESS> GETALLHIRINGPROCESSES(){

LIST<HIRINGPROCESS> HIRINGPROCESSES = THIS.HIRINGREPOSITORY.FINDALL();
 FOR(HIRINGPROCESS HP : HIRINGPROCESSES) {
IF(HP.GETINTERVIU() == NULL || HP.GETINTERVIU().GETINTERVIUDATE()
== NULL) {
HP.GETADDITIONALINFORMATION().PUT("FIRSTNAME",
HP.GETSUBMISSION().GETCANDIDAT().GETFIRSTNAME());
HP.GETADDITIONALINFORMATION().PUT("LASTNAME",
HP.GETSUBMISSION().GETCANDIDAT().GETLASTNAME());
HP.GETADDITIONALINFORMATION().PUT("POSITIONNAME",
HP.GETSUBMISSION().GETAPPLIEDPOSITION().GETPOSITIONNAME());
HP.GETADDITIONALINFORMATION().PUT("SUBMISSION_ID",
HP.GETSUBMISSION().GETID());
HP.GETADDITIONALINFORMATION().PUT("SUBMISSION_DATE",
HP.GETSUBMISSION().GETDATEOFSUBMISSION());
} ELSE {
HP.GETADDITIONALINFORMATION().PUT("INTERVIUDATE",
HP.GETINTERVIU().GETINTERVIUDATE().TOSTRING());
HP.GETADDITIONALINFORMATION().PUT("FIRSTNAME",
HP.GETSUBMISSION().GETCANDIDAT().GETFIRSTNAME());
HP.GETADDITIONALINFORMATION().PUT("LASTNAME",
HP.GETSUBMISSION().GETCANDIDAT().GETLASTNAME());
HP.GETADDITIONALINFORMATION().PUT("POSITIONNAME",
HP.GETSUBMISSION().GETAPPLIEDPOSITION().GETPOSITIONNAME());
HP.GETADDITIONALINFORMATION().PUT("SUBMISSION_ID",
HP.GETSUBMISSION().GETID());
HP.GETADDITIONALINFORMATION().PUT("SUBMISSION_DATE",
HP.GETSUBMISSION().GETDATEOFSUBMISSION());
}
}

RETURN HIRINGPROCESSES;
}

}
IHiringFlowService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.DATE;
IMPORT JAVA.UTIL.LIST;

IMPORT COM.DAM.TAM1.ENTITIES.COMMUNICATIONCHANNEL;
IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANT;
IMPORT COM.DAM.TAM1.ENTITIES.SUBMISSION;

PUBLIC INTERFACE IHIRINGFLOWSERVICE {

// USED FOR BUILDING A NEW SIMPLE SUBMISSION FOR A CANDIDAT, INCLUDING THE
CANDIDAT ITSELF
// AND THE POSITION FOR WHICH HE IS APPLYING.
PUBLIC VOID ENTRYSUBMISSIONWITHCANDIDAT(SUBMISSION SUBMISSION);

PUBLIC HIRINGPROCESS ENTRYSUBMISSIONWITHCANDIDAT(INTEGER CANDIDATID,

INTEGER POSITIONID);

// SCHEDULE AN INTERVIU FOR A CANDIDAT AND A START DATE THAT HAS A

DEFAULT IMPLEMENTATION OF 2 WEEKS FROM NOW
// PUBLIC INTERVIU SCHEDULESIMPLEINTERVIU(HIRINGPROCESS HIRINGPROCESS, DATE
STARTDATE);
 PUBLIC INTERVIU SCHEDULESIMPLEINTERVIU(INTERVIU INTERVIU);

// SCHEDULE AN INTERVIU FOR A CANDIDAT, BY INCLUDING A START DATE WITH A

DEFAULT IMPLEMENTATION OF 2 WEEKS FROM NOW
// AND A POSITION SPECIFIED
PUBLIC INTERVIU SCHEDULEINTERVIUWITHDETAILS(HIRINGPROCESS HIRINGPROCESS,
DATE STARTDATE, COMMUNICATIONCHANNEL COMM);

PUBLIC LIST<SUBMISSION> GETSUBMISSIONS();

PUBLIC VOID WITHDRAWSUBMISSION(INTEGER ID);

PUBLIC VOID ALLOCATEPARTICIPANTTOINTERVIU(INTERVIUPARTICIPANT

INTERVIUPARTICIPANT);

PUBLIC VOID CHANGECANDIDATSTATUS(HIRINGPROCESS HIRINGPROCESS);

}
interviuParticipantService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.ARRAYLIST;
IMPORT JAVA.UTIL.COLLECTION;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANT;
IMPORT COM.DAM.TAM1.ENTITIES.INTERVIUPARTICIPANTPK;
IMPORT COM.DAM.TAM1.ENTITIES.PARTICIPANT;
IMPORT COM.DAM.TAM1.REPOSITORIES.INTERVIUPARTICIPANTREPOSITORY;

@SERVICE
PUBLIC CLASS INTERVIUPARTICIPANTSERVICE {

PRIVATE INTERVIUPARTICIPANTREPOSITORY REPOSITORY;

@AUTOWIRED
PUBLIC INTERVIUPARTICIPANTSERVICE(INTERVIUPARTICIPANTREPOSITORY REPOSITORY) {
THIS.REPOSITORY = REPOSITORY;
}

PUBLIC INTERVIUPARTICIPANT SAVEINTERVIUPARTICIPANT(INTERVIUPARTICIPANT

INTERVIUPARTICIPANT) {
INTERVIUPARTICIPANT.SETINTERVIUPARTICIPANTPK(NEW
INTERVIUPARTICIPANTPK(INTERVIUPARTICIPANT.GETINTERVIU().GETINTERVIU_ID(),
INTERVIUPARTICIPANT.GETPARTICIPANT().GETEMPLOYEE_ID()));
RETURN THIS.REPOSITORY.SAVE(INTERVIUPARTICIPANT);
}

PUBLIC COLLECTION<INTERVIUPARTICIPANT> GETALLPARTICIPANTSONINTERVIU(){

COLLECTION<INTERVIUPARTICIPANT> INTERVIU_PARTICIPANTS =
THIS.REPOSITORY.FINDALL();
FOR(INTERVIUPARTICIPANT IP: INTERVIU_PARTICIPANTS) {
IF(IP.GETINTERVIU()!=NULL && IP.GETPARTICIPANT()!= NULL) {
IP.GETADDITIONALINFORMATION().PUT("INTERVIU_ID",
IP.GETINTERVIU().GETINTERVIU_ID());
 IP.GETADDITIONALINFORMATION().PUT("PARTICIPANT_ID",
IP.GETPARTICIPANT().GETEMPLOYEE_ID());
}
}

RETURN INTERVIU_PARTICIPANTS;
}

PUBLIC COLLECTION<INTERVIU> GETINTERVIUSBYPARTICIPANTID(INTEGER ID){

COLLECTION<INTERVIUPARTICIPANT> PARTICIPANTSBYINTERVIU =
THIS.REPOSITORY.FINDALL();
LONG PARTICIPANT_ID = LONG.VALUEOF(ID);

COLLECTION<INTERVIU> INTERVIUS = NEW ARRAYLIST<>();

FOR(INTERVIUPARTICIPANT IP: PARTICIPANTSBYINTERVIU) {
IF(IP.GETPARTICIPANT().GETEMPLOYEE_ID() == PARTICIPANT_ID) {
INTERVIUS.ADD(IP.GETINTERVIU());
}
}

RETURN INTERVIUS;
}

PUBLIC COLLECTION<PARTICIPANT> GETPARTICIPANTSBYINTERVIUID(INTEGER ID){

COLLECTION<INTERVIUPARTICIPANT> INTERVIUSBYPARTICIPANT =
THIS.REPOSITORY.FINDALL();
LONG INTERVIU_ID = LONG.VALUEOF(ID);

COLLECTION<PARTICIPANT> PARTICIPANTS = NEW ARRAYLIST<>();

FOR(INTERVIUPARTICIPANT IP: INTERVIUSBYPARTICIPANT) {
IF(IP.GETINTERVIU().GETINTERVIU_ID() == INTERVIU_ID) {
PARTICIPANTS.ADD(IP.GETPARTICIPANT());
}
}

RETURN PARTICIPANTS;
}

PUBLIC VOID DELETEINTERVIUPARTICIPANTBYID(INTERVIUPARTICIPANTPK ID) {

THIS.REPOSITORY.DELETEBYID(ID);
}

InterviuService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.REPOSITORIES.INTERVIUREPOSITORY;

@SERVICE
PUBLIC CLASS INTERVIUSERVICE {
 PRIVATE INTERVIUREPOSITORY INTERVIUREPOSITORY;

@AUTOWIRED
PUBLIC VOID SETINTERVIUREPOSITORY(INTERVIUREPOSITORY INTERVIUREPOSITORY) {
THIS.INTERVIUREPOSITORY = INTERVIUREPOSITORY;
}

PUBLIC INTERVIU SAVEINTERVIU(INTERVIU INTERVIU) {

RETURN THIS.INTERVIUREPOSITORY.SAVE(INTERVIU);
}

PUBLIC VOID UPDATEINTERVIU(INTERVIU INTERVIU) {

THIS.INTERVIUREPOSITORY.SAVE(INTERVIU);
}

PUBLIC VOID DELETEINTERVIUBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.INTERVIUREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC INTERVIU GETINTERVIUBYID(INTEGER ID) {

LONG INTERVIUID = LONG.VALUEOF(ID);
RETURN THIS.INTERVIUREPOSITORY.FINDBYID(INTERVIUID).GET();
}

PUBLIC LIST<INTERVIU> GETALLINTERVIURI(){

RETURN THIS.INTERVIUREPOSITORY.FINDALL();
}
}
JobDisponibilService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.JOBDISPONIBIL;
IMPORT COM.DAM.TAM1.REPOSITORIES.JOBDISPONIBILREPOSITORY;

@SERVICE
PUBLIC CLASS JOBDISPONIBILSERVICE {

PRIVATE JOBDISPONIBILREPOSITORY JOBDISPONIBILREPOSITORY;

@AUTOWIRED
PUBLIC VOID SETJOBDISPONIBILREPOSITORY(JOBDISPONIBILREPOSITORY
JOBDISPONIBILREPOSITORY) {
THIS.JOBDISPONIBILREPOSITORY = JOBDISPONIBILREPOSITORY;
}

PUBLIC JOBDISPONIBIL SAVEJOBDISPONIBIL(JOBDISPONIBIL JOBDISPONIBIL) {

RETURN THIS.JOBDISPONIBILREPOSITORY.SAVE(JOBDISPONIBIL);
}

PUBLIC VOID UPDATEJOBDISPONIBIL(JOBDISPONIBIL JOBDISPONIBIL) {

THIS.JOBDISPONIBILREPOSITORY.SAVE(JOBDISPONIBIL);
}
 PUBLIC VOID DELETEJOBDISPONIBILBYID(INTEGER ID) {
LONG LONG_ID = LONG.VALUEOF(ID);
THIS.JOBDISPONIBILREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC JOBDISPONIBIL GETJOBDISPONIBILBYID(INTEGER ID) {

LONG JOBDISPONIBILID = LONG.VALUEOF(ID);
RETURN THIS.JOBDISPONIBILREPOSITORY.FINDBYID(JOBDISPONIBILID).GET();
}

PUBLIC LIST<JOBDISPONIBIL> GETALLJOBURIDISPONIBILE(){

RETURN THIS.JOBDISPONIBILREPOSITORY.FINDALL();
}
}
NotificationService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;

PUBLIC INTERFACE NOTIFICATIONSERVICE {

PUBLIC VOID NOTIFICATIONONINTERVIU(HIRINGPROCESS HIRINGPROCESS);

PUBLIC VOID NOTIFICATIONONSTATUSCHANGE(HIRINGPROCESS HIRINGPROCESS);

}
NotificationServiceImpl
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.PROPERTIES;

IMPORT JAVAX.MAIL.AUTHENTICATOR;
IMPORT JAVAX.MAIL.MESSAGE;
IMPORT JAVAX.MAIL.MESSAGINGEXCEPTION;
IMPORT JAVAX.MAIL.PASSWORDAUTHENTICATION;
IMPORT JAVAX.MAIL.SESSION;
IMPORT JAVAX.MAIL.TRANSPORT;
IMPORT JAVAX.MAIL.INTERNET.ADDRESSEXCEPTION;
IMPORT JAVAX.MAIL.INTERNET.INTERNETADDRESS;
IMPORT JAVAX.MAIL.INTERNET.MIMEMESSAGE;

IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.CANDIDAT;
IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;

@SERVICE
PUBLIC CLASS NOTIFICATIONSERVICEIMPL IMPLEMENTS NOTIFICATIONSERVICE {

@OVERRIDE
PUBLIC VOID NOTIFICATIONONINTERVIU(HIRINGPROCESS HIRINGPROCESS) {

STRING CANDIDATEMAIL =
HIRINGPROCESS.GETSUBMISSION().GETCANDIDAT().GETEMAILADDRESS();

STRING ADMINEMAIL = "[email protected]";

FINAL STRING ADMINUSERNAME = "C66C7A99DE9D79";
 FINAL STRING ADMINPASSWORD = "39DA7E6360B986";

STRING SERVICEPROVIDERHOST = "SMTP.MAILTRAP.IO";

PROPERTIES PROPERTIES = NEW PROPERTIES();

PROPERTIES.PUT("MAIL.SMTP.AUTH", "TRUE");
PROPERTIES.PUT("MAIL.SMTP.HOST", SERVICEPROVIDERHOST);
PROPERTIES.PUT("MAIL.SMTP.PORT", "2525");

SESSION SESSION = SESSION.GETINSTANCE(PROPERTIES, NEW AUTHENTICATOR() {

@OVERRIDE
PROTECTED PASSWORDAUTHENTICATION GETPASSWORDAUTHENTICATION() {
RETURN NEW PASSWORDAUTHENTICATION(ADMINUSERNAME,
ADMINPASSWORD);
}
});

TRY {
MESSAGE MESSAGE = NEW MIMEMESSAGE(SESSION);

MESSAGE.SETFROM(NEW INTERNETADDRESS(ADMINEMAIL));
MESSAGE.SETRECIPIENTS(MESSAGE.RECIPIENTTYPE.TO,
INTERNETADDRESS.PARSE(CANDIDATEMAIL));

MESSAGE.SETSUBJECT("ABLAHAMA RECRUITING: INTERVIU DETAILS");

MESSAGE.SETTEXT("AS WE HAVE DISCUSSED EARLIER, " +
HIRINGPROCESS.GETSUBMISSION().GETCANDIDAT().GETLASTNAME()
+ " YOU HAVE BEEN SCHEDULED FOR THE INTERVIU ON THE
DATE OF " + HIRINGPROCESS.GETINTERVIU().GETINTERVIUDATE().TOSTRING());
TRANSPORT.SEND(MESSAGE);

SYSTEM.OUT.PRINTLN("NOTIFICATION SENT SUCCESFULLY");

} CATCH (ADDRESSEXCEPTION E) {
E.PRINTSTACKTRACE();
} CATCH (MESSAGINGEXCEPTION E) {
E.PRINTSTACKTRACE();
}
}

@OVERRIDE
PUBLIC VOID NOTIFICATIONONSTATUSCHANGE(HIRINGPROCESS HIRINGPROCESS) {
CANDIDAT CANDIDAT = HIRINGPROCESS.GETSUBMISSION().GETCANDIDAT();

STRING CANDIDATTO = CANDIDAT.GETEMAILADDRESS();

STRING SENDERFROM = "[email protected]";

FINAL STRING SENDERUSERNAME = "C66C7A99DE9D79";
FINAL STRING SENDERPASSWORD = "39DA7E6360B986";

STRING SERVICEPROVIDERHOST = "SMTP.MAILTRAP.IO";

PROPERTIES PROPERTIES = NEW PROPERTIES();

PROPERTIES.PUT("MAIL.SMTP.AUTH", "TRUE");
PROPERTIES.PUT("MAIL.SMTP.HOST", SERVICEPROVIDERHOST);
PROPERTIES.PUT("MAIL.SMTP.PORT", "2525");

SESSION SESSION = SESSION.GETINSTANCE(PROPERTIES, NEW AUTHENTICATOR() {

 @OVERRIDE
PROTECTED PASSWORDAUTHENTICATION GETPASSWORDAUTHENTICATION() {
RETURN NEW PASSWORDAUTHENTICATION(SENDERUSERNAME, SENDERPASSWORD);
}
});

STRING CANDIDATSITUATION = HIRINGPROCESS.GETCANDIDATSITUATION().TOSTRING();

IF (!(CANDIDATSITUATION.EQUALS("WAITING") ||
CANDIDATSITUATION.EQUALS("UNDERREVIEW")
|| CANDIDATSITUATION.EQUALS("WAITINGFORFINALRESPONSE"))) {

TRY {

SYSTEM.OUT.PRINTLN();
MESSAGE MESSAGE = NEW MIMEMESSAGE(SESSION);

MESSAGE.SETFROM(NEW INTERNETADDRESS(SENDERFROM));
MESSAGE.SETRECIPIENTS(MESSAGE.RECIPIENTTYPE.TO,
INTERNETADDRESS.PARSE(CANDIDATTO));

MESSAGE.SETSUBJECT("ABLAHAMA RECRUITING: HIRING STATUS CHANGED!");

MESSAGE.SETCONTENT("HELLO, " + "<B>" +
HIRINGPROCESS.GETSUBMISSION().GETCANDIDAT().GETLASTNAME() + "</B>" + " YOU ARE
CURRENTLY ON THE STATE "
+ CANDIDATSITUATION, "TEXT/HTML");
TRANSPORT.SEND(MESSAGE);

SYSTEM.OUT.PRINTLN("MESSAGE SENT SUCCESFULLY");

} CATCH (ADDRESSEXCEPTION E) {
E.PRINTSTACKTRACE();
} CATCH (MESSAGINGEXCEPTION E) {
E.PRINTSTACKTRACE();
}
}
}

}
ParticipantService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.PARTICIPANT;
IMPORT COM.DAM.TAM1.REPOSITORIES.PARTICIPANTREPOSITORY;

@SERVICE
PUBLIC CLASS PARTICIPANTSERVICE {

PRIVATE PARTICIPANTREPOSITORY PARTICIPANTREPOSITORY;

@AUTOWIRED
PUBLIC PARTICIPANTSERVICE(PARTICIPANTREPOSITORY PARTICIPANTREPO) {
THIS.PARTICIPANTREPOSITORY = PARTICIPANTREPO;
 }

PUBLIC PARTICIPANT SAVEPARTICIPANT(PARTICIPANT PARTICIPANT) {

RETURN THIS.PARTICIPANTREPOSITORY.SAVE(PARTICIPANT);
}

PUBLIC PARTICIPANT UPDATEPARTICIPANT(PARTICIPANT PARTICIPANT) {

RETURN THIS.PARTICIPANTREPOSITORY.SAVE(PARTICIPANT);
}

PUBLIC VOID DELETEPARTICIPANT(PARTICIPANT PARTICIPANT) {

THIS.PARTICIPANTREPOSITORY.DELETE(PARTICIPANT);
}

PUBLIC VOID DELETEPARTICIPANTBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.PARTICIPANTREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC PARTICIPANT GETPARTICIPANTBYID(INTEGER ID) {

LONG PARTICIPANTID = LONG.VALUEOF(ID);
RETURN THIS.PARTICIPANTREPOSITORY.FINDBYID(PARTICIPANTID).GET();
}

PUBLIC LIST<PARTICIPANT> GETALLPARTICIPANTS(){

RETURN THIS.PARTICIPANTREPOSITORY.FINDALL();
}
}
PositionService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.OPTIONAL;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.POSITION;
IMPORT COM.DAM.TAM1.REPOSITORIES.POSITIONREPOSITORY;

@SERVICE
PUBLIC CLASS POSITIONSERVICE {

PRIVATE POSITIONREPOSITORY POSITIONREPOSITORY;

PRIVATE INTEGER NEXTID = 0;

PUBLIC LONG GETNEXTID() {

LONG NEXTIDL = LONG.VALUEOF(NEXTID);
NEXTIDL++;
RETURN NEXTIDL;
}

@AUTOWIRED
PUBLIC VOID SETPOSITIONREPOSITORY(POSITIONREPOSITORY POSITIONREPOSITORY) {
THIS.POSITIONREPOSITORY = POSITIONREPOSITORY;
}

PUBLIC POSITION SAVEPOSITION(POSITION POSITION) {

 RETURN THIS.POSITIONREPOSITORY.SAVE(POSITION);
}

PUBLIC POSITION UPDATEPOSITION(POSITION POSITION) {

POSITION POSITIONFOUND =
THIS.POSITIONREPOSITORY.FINDBYID(POSITION.GETPOSITION_ID()).GET();
POSITIONFOUND.SETPOSITIONNAME(POSITION.GETPOSITIONNAME());
POSITIONFOUND.SETSHORTDESCRIPTION(POSITION.GETSHORTDESCRIPTION());

POSITIONFOUND.SETNO_AVAILABLE_POSITIONS(POSITION.GETNO_AVAILABLE_POSITIONS());
POSITIONFOUND.SETISAVAILABLE(POSITION.GETISAVAILABLE());
RETURN THIS.POSITIONREPOSITORY.SAVE(POSITIONFOUND);
}

PUBLIC VOID DELETEPOSITION(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.POSITIONREPOSITORY.DELETEBYID(LONG_ID);;
}

PUBLIC POSITION GETPOSITIONBYID(INTEGER ID) {

LONG POSITIONID = LONG.VALUEOF(ID);
OPTIONAL<POSITION> POSITIONFOUND =
THIS.POSITIONREPOSITORY.FINDBYID(POSITIONID);
POSITION POSITION = POSITIONFOUND.GET();
RETURN POSITION;
}

PUBLIC LIST<POSITION> GETALLPOSITIONS(){

RETURN THIS.POSITIONREPOSITORY.FINDALL();
}
}
QuestionQuizService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.COLLECTION;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.QUESTIONQUIZ;
IMPORT COM.DAM.TAM1.REPOSITORIES.QUESTIONQUIZREPOSITORY;

@SERVICE
PUBLIC CLASS QUESTIONQUIZSERVICE {

PRIVATE QUESTIONQUIZREPOSITORY QUESTIONQUIZREPOSITORY;

@AUTOWIRED
PUBLIC QUESTIONQUIZSERVICE(QUESTIONQUIZREPOSITORY QUESTIONQUIZREPOSITORY) {
SUPER();
THIS.QUESTIONQUIZREPOSITORY = QUESTIONQUIZREPOSITORY;
}

PUBLIC COLLECTION<QUESTIONQUIZ> GETALLQUESTIONSQUIZES(){

RETURN THIS.QUESTIONQUIZREPOSITORY.FINDALL();
}
}
QuestionService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.ARRAYLIST;
IMPORT JAVA.UTIL.COLLECTION;
IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.RASPUNSFINAL;
IMPORT COM.DAM.TAM1.ENTITIES.QUESTION;
IMPORT COM.DAM.TAM1.REPOSITORIES.RASPUNSFINALREPOSITORY;
IMPORT COM.DAM.TAM1.REPOSITORIES.QUESTIONREPOSITORY;

@SERVICE
PUBLIC CLASS QUESTIONSERVICE {

PRIVATE QUESTIONREPOSITORY QUESTIONREPOSITORY;

PRIVATE RASPUNSFINALREPOSITORY RASPUNSFINALREPOSITORY;

@AUTOWIRED
PUBLIC VOID SETQUESTIONREPOSITORY(QUESTIONREPOSITORY QUESTIONREPOSITORY,
RASPUNSFINALREPOSITORY RASPUNSFINALREPOSITORY) {
THIS.QUESTIONREPOSITORY = QUESTIONREPOSITORY;
THIS.RASPUNSFINALREPOSITORY = RASPUNSFINALREPOSITORY;
}

PUBLIC QUESTION SAVEQUESTION(QUESTION QUESTION) {

RETURN THIS.QUESTIONREPOSITORY.SAVE(QUESTION);
}

PUBLIC VOID UPDATEQUESTION(QUESTION QUESTION) {

QUESTION QUESTIONFOUND =
THIS.QUESTIONREPOSITORY.FINDBYID(QUESTION.GETQUESTION_ID()).GET();
QUESTIONFOUND.SETQUESTION_BODY(QUESTION.GETQUESTION_BODY());
QUESTIONFOUND.SETPOSITION(QUESTION.GETPOSITION());

QUESTIONFOUND.SETCORRECTRASPUNSFINAL(QUESTION.GETCORRECTRASPUNSFINAL());
THIS.QUESTIONREPOSITORY.SAVE(QUESTIONFOUND);
}

PUBLIC VOID DELETEQUESTION(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.QUESTIONREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC QUESTION GETQUESTIONBYID(INTEGER ID) {

LONG QUESTIONID = LONG.VALUEOF(ID);
RETURN THIS.QUESTIONREPOSITORY.FINDBYID(QUESTIONID).GET();
}

PUBLIC LIST<QUESTION> GETALLQUESTIONS(){

RETURN THIS.QUESTIONREPOSITORY.FINDALL();
}

PUBLIC COLLECTION<RASPUNSFINAL> GETALLRASPUNSFINALSFORQUESTION(INTEGER ID){

 LIST<RASPUNSFINAL> RASPUNSFINALS =
THIS.RASPUNSFINALREPOSITORY.FINDALL();

LONG QUESTION_ID = LONG.VALUEOF(ID);

QUESTION QUESTIONFOUND =
THIS.QUESTIONREPOSITORY.FINDBYID(QUESTION_ID).GET();

COLLECTION<RASPUNSFINAL> RASPUNSFINALSFOUND = NEW ARRAYLIST<>();

FOR(RASPUNSFINAL RASPUNSFINAL: RASPUNSFINALS) {

IF(RASPUNSFINAL.GETQUESTION() == QUESTIONFOUND) {
RASPUNSFINALSFOUND.ADD(RASPUNSFINAL);
}
}

RETURN RASPUNSFINALSFOUND;
}

}
QuizService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.COLLECTION;
IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.INTERVIU;
IMPORT COM.DAM.TAM1.ENTITIES.QUESTIONQUIZ;
IMPORT COM.DAM.TAM1.ENTITIES.QUIZ;
IMPORT COM.DAM.TAM1.REPOSITORIES.QUESTIONQUIZREPOSITORY;
IMPORT COM.DAM.TAM1.REPOSITORIES.QUIZREPOSITORY;

@SERVICE
PUBLIC CLASS QUIZSERVICE {

PRIVATE QUIZREPOSITORY QUIZREPOSITORY;

PRIVATE QUESTIONQUIZREPOSITORY QUESTIONQUIZREPOSITORY;

PRIVATE INTERVIUSERVICE INTERVIUSERVICE;

@AUTOWIRED
PUBLIC VOID SETQUIZREPOSITORY(QUIZREPOSITORY QUIZREPOSITORY) {
THIS.QUIZREPOSITORY = QUIZREPOSITORY;
}

@AUTOWIRED
PUBLIC VOID SETQUESTIONQUIZREPOSITORY(QUESTIONQUIZREPOSITORY
QUESTIONQUIZREPOSITORY) {
THIS.QUESTIONQUIZREPOSITORY = QUESTIONQUIZREPOSITORY;
}

@AUTOWIRED
PUBLIC VOID SETINTERVIUSERVICE(INTERVIUSERVICE INTERVIUSERVICE) {
THIS.INTERVIUSERVICE = INTERVIUSERVICE;
}
 PUBLIC QUIZ SAVEQUIZ(QUIZ QUIZ) {
RETURN THIS.QUIZREPOSITORY.SAVE(QUIZ);
}

PUBLIC VOID UPDATEQUIZ(QUIZ QUIZ) {

THIS.QUIZREPOSITORY.SAVE(QUIZ);
}

PUBLIC VOID DELETEQUIZBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
QUIZ QUIZFOUND = THIS.QUIZREPOSITORY.FINDBYID(LONG_ID).GET();
COLLECTION<INTERVIU> INTERVIUS =
THIS.INTERVIUSERVICE.GETALLINTERVIUS();

FOR(INTERVIU INTERVIU : INTERVIUS) {

IF(INTERVIU.GETQUIZ() == QUIZFOUND) {
INTERVIU.SETQUIZ(NULL);
THIS.INTERVIUSERVICE.UPDATEINTERVIU(INTERVIU);
}
}

THIS.QUIZREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC QUIZ GETQUIZBYID(INTEGER ID) {

LONG QUIZID = LONG.VALUEOF(ID);
RETURN THIS.QUIZREPOSITORY.FINDBYID(QUIZID).GET();
}

PUBLIC LIST<QUIZ> GETALLQUIZES(){

RETURN THIS.QUIZREPOSITORY.FINDALL();
}

PUBLIC QUESTIONQUIZ SAVEQUESTIONQUIZ(QUESTIONQUIZ QUESTIONQUIZ) {

RETURN THIS.QUESTIONQUIZREPOSITORY.SAVE(QUESTIONQUIZ);
}

PUBLIC VOID DELETEQUESTIONQUIZ(QUESTIONQUIZ QUESTIONQUIZ) {

THIS.QUESTIONQUIZREPOSITORY.DELETE(QUESTIONQUIZ);
}

PUBLIC LIST<QUESTIONQUIZ> GETQUESTIONQUIZ(){

RETURN THIS.QUESTIONQUIZREPOSITORY.FINDALL();
}

}
RaspunsFinalService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.RASPUNSFINAL;
IMPORT COM.DAM.TAM1.REPOSITORIES.RASPUNSFINALREPOSITORY;

@SERVICE
PUBLIC CLASS RASPUNSFINALSERVICE {
 PRIVATE RASPUNSFINALREPOSITORY RASPUNSFINALREPOSITORY;

@AUTOWIRED
PUBLIC VOID SETRASPUNSFINALREPOSITORY(RASPUNSFINALREPOSITORY
RASPUNSFINALREPOSITORY) {
THIS.RASPUNSFINALREPOSITORY = RASPUNSFINALREPOSITORY;
}

PUBLIC RASPUNSFINAL SAVERASPUNSFINAL(RASPUNSFINAL RASPUNSFINAL) {

RETURN THIS.RASPUNSFINALREPOSITORY.SAVE(RASPUNSFINAL);
}

PUBLIC VOID UPDATERASPUNSFINAL(RASPUNSFINAL RASPUNSFINAL) {

THIS.RASPUNSFINALREPOSITORY.SAVE(RASPUNSFINAL);
}

PUBLIC VOID DELETERASPUNSFINALBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.RASPUNSFINALREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC RASPUNSFINAL GETRASPUNSFINALBYID(INTEGER ID) {

LONG RASPUNSFINALID = LONG.VALUEOF(ID);
RETURN THIS.RASPUNSFINALREPOSITORY.FINDBYID(RASPUNSFINALID).GET();
}

PUBLIC LIST<RASPUNSFINAL> GETALLRASPUNSURIFINALE(){

RETURN THIS.RASPUNSFINALREPOSITORY.FINDALL();
}
}
ResponsabilHRService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.RESPONSABILHR;
IMPORT COM.DAM.TAM1.REPOSITORIES.RESPONSABILHRREPOSITORY;

@SERVICE
PUBLIC CLASS RESPONSABILHRSERVICE {

PRIVATE RESPONSABILHRREPOSITORY RESPONSABILHRREPOSITORY;

@AUTOWIRED
PUBLIC VOID SETRESPONSABILHRREPOSITORY(RESPONSABILHRREPOSITORY
RESPONSABILHRREPOSITORY) {
THIS.RESPONSABILHRREPOSITORY = RESPONSABILHRREPOSITORY;
}

PUBLIC RESPONSABILHR SAVERESPONSABILHR(RESPONSABILHR RESPONSABILHR) {

RETURN THIS.RESPONSABILHRREPOSITORY.SAVE(RESPONSABILHR);
}

PUBLIC VOID UPDATERESPONSABILHR(RESPONSABILHR RESPONSABILHR) {

 THIS.RESPONSABILHRREPOSITORY.SAVE(RESPONSABILHR);
}

PUBLIC VOID DELETERESPONSABILHRBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.RESPONSABILHRREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC RESPONSABILHR GETRESPONSABILHRBYID(INTEGER ID) {

LONG RESPONSABILHRID = LONG.VALUEOF(ID);
RETURN THIS.RESPONSABILHRREPOSITORY.FINDBYID(RESPONSABILHRID).GET();
}

PUBLIC LIST<RESPONSABILHR> GETALLRESPONSABILIHR(){

RETURN THIS.RESPONSABILHRREPOSITORY.FINDALL();
}
}
SubmissionService
PACKAGE COM.DAM.TAM1.SERVICES;

IMPORT JAVA.UTIL.LIST;
IMPORT JAVA.UTIL.OPTIONAL;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.STEREOTYPE.SERVICE;

IMPORT COM.DAM.TAM1.ENTITIES.HIRINGPROCESS;
IMPORT COM.DAM.TAM1.ENTITIES.SUBMISSION;
IMPORT COM.DAM.TAM1.REPOSITORIES.HIRINGREPOSITORY;
IMPORT COM.DAM.TAM1.REPOSITORIES.SUBMISSIONREPOSITORY;

@SERVICE
PUBLIC CLASS SUBMISSIONSERVICE {

PRIVATE SUBMISSIONREPOSITORY SUBMISSIONREPOSITORY;

PRIVATE HIRINGREPOSITORY HIRINGREPOSITORY;

PRIVATE INTEGER NEXTID;

PUBLIC LONG GETNEXTID() {

LONG NEXTIDL = LONG.VALUEOF(NEXTID);
NEXTIDL++;
RETURN NEXTIDL;
}

// @AUTOWIRED
// PUBLIC VOID SETSUBMISSIONREPOSITORY(SUBMISSIONREPOSITORY
SUBMISSIONREPOSITORY) {
// THIS.SUBMISSIONREPOSITORY = SUBMISSIONREPOSITORY;
// }
//
PUBLIC SUBMISSION SAVESUBMISSION(SUBMISSION SUBMISSION) {
RETURN THIS.SUBMISSIONREPOSITORY.SAVE(SUBMISSION);
}

@AUTOWIRED
PUBLIC SUBMISSIONSERVICE(SUBMISSIONREPOSITORY SUBMISSIONREPOSITORY,
HIRINGREPOSITORY HIRINGREPOSITORY) {
SUPER();
THIS.SUBMISSIONREPOSITORY = SUBMISSIONREPOSITORY;
THIS.HIRINGREPOSITORY = HIRINGREPOSITORY;
}

PUBLIC VOID UPDATESUBMISSION(SUBMISSION SUBMISSION) {

OPTIONAL<SUBMISSION> SUBMISSIONFOUND =
THIS.SUBMISSIONREPOSITORY.FINDBYID(SUBMISSION.GETID());
SUBMISSION SUBMISS = SUBMISSIONFOUND.GET();

IF(!SUBMISS.EQUALS(NULL)) {
SUBMISS.SETMENTION(SUBMISSION.GETMENTION());
THIS.SUBMISSIONREPOSITORY.SAVE(SUBMISS);
}
}

PUBLIC VOID DELETESUBMISSION(SUBMISSION SUBMISSION) {

THIS.SUBMISSIONREPOSITORY.DELETE(SUBMISSION);
}

PUBLIC SUBMISSION GETSUBMISSIONBYID(INTEGER ID) {

LONG LONGID = LONG.VALUEOF(ID);
SUBMISSION SUBMISSIONFOUND =
THIS.SUBMISSIONREPOSITORY.FINDBYID(LONGID).GET();
LIST<HIRINGPROCESS> HIRINGPROCESSES = THIS.HIRINGREPOSITORY.FINDALL();
FOR(HIRINGPROCESS HIRINGPROCESS: HIRINGPROCESSES) {
IF(HIRINGPROCESS.GETSUBMISSION().EQUALS(SUBMISSIONFOUND)) {
SUBMISSIONFOUND.GETADDITIONALINFORMATION().PUT("HIRING_ID",
HIRINGPROCESS.GETHIRING_ID().TOSTRING());

SUBMISSIONFOUND.GETADDITIONALINFORMATION().PUT("CANDIDAT_SITUATION",
HIRINGPROCESS.GETCANDIDATSITUATION().TOSTRING());

SUBMISSIONFOUND.GETADDITIONALINFORMATION().PUT("HIRING_MENTIONS",
HIRINGPROCESS.GETMENTIONS());
}
}

RETURN SUBMISSIONFOUND;
}

PUBLIC LIST<SUBMISSION> GETALLSUBMISSIONS(){

LIST<HIRINGPROCESS> HIRINGPROCESSES = THIS.HIRINGREPOSITORY.FINDALL();
LIST<SUBMISSION> SUBMISSIONS = THIS.SUBMISSIONREPOSITORY.FINDALL();
FOR(SUBMISSION SUBMISSION: SUBMISSIONS) {
FOR(HIRINGPROCESS HIRINGPROCESS: HIRINGPROCESSES) {
IF(HIRINGPROCESS.GETSUBMISSION() == SUBMISSION) {

SUBMISSION.GETADDITIONALINFORMATION().PUT("HIRING_ID",
HIRINGPROCESS.GETHIRING_ID().TOSTRING());

SUBMISSION.GETADDITIONALINFORMATION().PUT("CANDIDAT_SITUATION",
HIRINGPROCESS.GETCANDIDATSITUATION().TOSTRING());

SUBMISSION.GETADDITIONALINFORMATION().PUT("HIRING_MENTIONS",
HIRINGPROCESS.GETMENTIONS());
 SUBMISSION.GETADDITIONALINFORMATION().PUT("CANDIDAT_ID",
HIRINGPROCESS.GETSUBMISSION().GETCANDIDAT().GETCANDIDAT_ID());
}
}
}

RETURN THIS.SUBMISSIONREPOSITORY.FINDALL();
}

PUBLIC VOID DELETESUBMISSIONBYID(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
THIS.SUBMISSIONREPOSITORY.DELETEBYID(LONG_ID);
}

PUBLIC VOID DELETESUBMISSION(INTEGER ID) {

LONG LONG_ID = LONG.VALUEOF(ID);
SUBMISSION SUBMISSIONFOUND =
THIS.SUBMISSIONREPOSITORY.FINDBYID(LONG_ID).GET();
THIS.SUBMISSIONREPOSITORY.DELETE(SUBMISSIONFOUND);
}

}
utils
DATEUTILS4J8API
PACKAGE COM.DAM.TAM1.UTILS;
IMPORT JAVA.TIME.INSTANT;
IMPORT JAVA.TIME.LOCALDATE;
IMPORT JAVA.TIME.LOCALDATETIME;
IMPORT JAVA.TIME.ZONEID;
IMPORT JAVA.UTIL.DATE;

PUBLIC CLASS DATEUTILS4J8API {

PUBLIC STATIC DATE ASDATE(LOCALDATE LOCALDATE) {

RETURN
DATE.FROM(LOCALDATE.ATSTARTOFDAY().ATZONE(ZONEID.SYSTEMDEFAULT()).TOINSTANT());
}

PUBLIC STATIC DATE ASDATE(LOCALDATETIME LOCALDATETIME) {

RETURN DATE.FROM(LOCALDATETIME.ATZONE(ZONEID.SYSTEMDEFAULT()).TOINSTANT());
}

PUBLIC STATIC LOCALDATE ASLOCALDATE(DATE DATE) {

RETURN
INSTANT.OFEPOCHMILLI(DATE.GETTIME()).ATZONE(ZONEID.SYSTEMDEFAULT()).TOLOCALDATE();
}

PUBLIC STATIC LOCALDATETIME ASLOCALDATETIME(DATE DATE) {

RETURN
INSTANT.OFEPOCHMILLI(DATE.GETTIME()).ATZONE(ZONEID.SYSTEMDEFAULT()).TOLOCALDATETIME
();
}
}
Tam1Application
PACKAGE COM.DAM.TAM1;

IMPORT ORG.SPRINGFRAMEWORK.BEANS.FACTORY.ANNOTATION.AUTOWIRED;
IMPORT ORG.SPRINGFRAMEWORK.BOOT.SPRINGAPPLICATION;
IMPORT ORG.SPRINGFRAMEWORK.BOOT.AUTOCONFIGURE.SPRINGBOOTAPPLICATION;

IMPORT COM.DAM.TAM1.SERVICES.CANDIDATSERVICE;

@SPRINGBOOTAPPLICATION
PUBLIC CLASS TAM1APPLICATION {

@AUTOWIRED
PRIVATE STATIC CANDIDATSERVICE CANDIDATSERVICE;

PUBLIC STATIC VOID MAIN(STRING[] ARGS) {

SPRINGAPPLICATION.RUN(TAM1APPLICATION.CLASS, ARGS);
}
}