diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/questionnaire/QuestionExportDTO.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/questionnaire/QuestionExportDTO.java
index 9884462a240af31a698bd49e448ed0eea3916e78..b54f857d211bc116463c76f4700a4f645ce3ad3e 100644
--- a/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/questionnaire/QuestionExportDTO.java
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/questionnaire/QuestionExportDTO.java
@@ -3,11 +3,9 @@ package cz.muni.ics.kypo.training.adaptive.dto.export.phases.questionnaire;
import cz.muni.ics.kypo.training.adaptive.enums.QuestionType;
import io.swagger.annotations.ApiModelProperty;
-import javax.validation.constraints.NotEmpty;
-import javax.validation.constraints.NotNull;
import java.util.List;
-public abstract class QuestionExportDTO {
+public class QuestionExportDTO {
@ApiModelProperty(value = "Order of question", required = true, example = "0")
private int order;
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/DecisionMatrixRowExportDTO.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/DecisionMatrixRowExportDTO.java
new file mode 100644
index 0000000000000000000000000000000000000000..da536f9513781d26728d36ad816ba71d96d16faa
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/DecisionMatrixRowExportDTO.java
@@ -0,0 +1,80 @@
+package cz.muni.ics.kypo.training.adaptive.dto.export.phases.training;
+
+public class DecisionMatrixRowExportDTO {
+ private long id;
+ private int order;
+ private double assessmentAnswered;
+ private double keywordUsed;
+ private double completedInTime;
+ private double solutionDisplayed;
+ private double wrongAnswers;
+
+ public long getId() {
+ return id;
+ }
+
+ public void setId(long id) {
+ this.id = id;
+ }
+
+ public int getOrder() {
+ return order;
+ }
+
+ public void setOrder(int order) {
+ this.order = order;
+ }
+
+ public double getAssessmentAnswered() {
+ return assessmentAnswered;
+ }
+
+ public void setAssessmentAnswered(double assessmentAnswered) {
+ this.assessmentAnswered = assessmentAnswered;
+ }
+
+ public double getKeywordUsed() {
+ return keywordUsed;
+ }
+
+ public void setKeywordUsed(double keywordUsed) {
+ this.keywordUsed = keywordUsed;
+ }
+
+ public double getCompletedInTime() {
+ return completedInTime;
+ }
+
+ public void setCompletedInTime(double completedInTime) {
+ this.completedInTime = completedInTime;
+ }
+
+ public double getSolutionDisplayed() {
+ return solutionDisplayed;
+ }
+
+ public void setSolutionDisplayed(double solutionDisplayed) {
+ this.solutionDisplayed = solutionDisplayed;
+ }
+
+ public double getWrongAnswers() {
+ return wrongAnswers;
+ }
+
+ public void setWrongAnswers(double wrongAnswers) {
+ this.wrongAnswers = wrongAnswers;
+ }
+
+ @Override
+ public String toString() {
+ return "DecisionMatrixRow{" +
+ "id=" + id +
+ ", order=" + order +
+ ", assessmentAnswered=" + assessmentAnswered +
+ ", keywordUsed=" + keywordUsed +
+ ", completedInTime=" + completedInTime +
+ ", solutionDisplayed=" + solutionDisplayed +
+ ", wrongAnswers=" + wrongAnswers +
+ '}';
+ }
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/TaskExportDTO.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/TaskExportDTO.java
new file mode 100644
index 0000000000000000000000000000000000000000..e91d3adde8c55a8075c0611a312e5c31da9d3cf3
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/TaskExportDTO.java
@@ -0,0 +1,101 @@
+package cz.muni.ics.kypo.training.adaptive.dto.export.phases.training;
+
+public class TaskExportDTO {
+
+ private Long id;
+ private String title;
+ private Integer order;
+ private String content;
+ private String answer;
+ private String solution;
+ private int incorrectAnswerLimit;
+ private boolean modifySandbox;
+ private int sandboxChangeExpectedDuration;
+
+ public Long getId() {
+ return id;
+ }
+
+ public void setId(Long id) {
+ this.id = id;
+ }
+
+ public String getTitle() {
+ return title;
+ }
+
+ public void setTitle(String title) {
+ this.title = title;
+ }
+
+ public Integer getOrder() {
+ return order;
+ }
+
+ public void setOrder(Integer order) {
+ this.order = order;
+ }
+
+ public String getContent() {
+ return content;
+ }
+
+ public void setContent(String content) {
+ this.content = content;
+ }
+
+ public String getAnswer() {
+ return answer;
+ }
+
+ public void setAnswer(String answer) {
+ this.answer = answer;
+ }
+
+ public String getSolution() {
+ return solution;
+ }
+
+ public void setSolution(String solution) {
+ this.solution = solution;
+ }
+
+ public int getIncorrectAnswerLimit() {
+ return incorrectAnswerLimit;
+ }
+
+ public void setIncorrectAnswerLimit(int incorrectAnswerLimit) {
+ this.incorrectAnswerLimit = incorrectAnswerLimit;
+ }
+
+ public boolean isModifySandbox() {
+ return modifySandbox;
+ }
+
+ public void setModifySandbox(boolean modifySandbox) {
+ this.modifySandbox = modifySandbox;
+ }
+
+ public int getSandboxChangeExpectedDuration() {
+ return sandboxChangeExpectedDuration;
+ }
+
+ public void setSandboxChangeExpectedDuration(int sandboxChangeExpectedDuration) {
+ this.sandboxChangeExpectedDuration = sandboxChangeExpectedDuration;
+ }
+
+ @Override
+ public String toString() {
+ return "TaskDTO{" +
+ "id=" + id +
+ ", title='" + title + '\'' +
+ ", order=" + order +
+ ", content='" + content + '\'' +
+ ", answer='" + answer + '\'' +
+ ", solution='" + solution + '\'' +
+ ", incorrectAnswerLimit=" + incorrectAnswerLimit +
+ ", modifySandbox=" + modifySandbox +
+ ", sandboxChangeExpectedDuration=" + sandboxChangeExpectedDuration +
+ '}';
+ }
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/TrainingPhaseExportDTO.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/TrainingPhaseExportDTO.java
index a19e7a94cd21e947efc33647309e7043c5b4e6da..629dcedc0d90ba00551bb1542d03be16324d2902 100644
--- a/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/TrainingPhaseExportDTO.java
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/dto/export/phases/training/TrainingPhaseExportDTO.java
@@ -2,7 +2,10 @@ package cz.muni.ics.kypo.training.adaptive.dto.export.phases.training;
import cz.muni.ics.kypo.training.adaptive.dto.export.phases.AbstractPhaseExportDTO;
import io.swagger.annotations.ApiModel;
-import io.swagger.annotations.ApiModelProperty;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
/**
* Encapsulates information about training phase. Inherits from {@link AbstractPhaseExportDTO}
@@ -11,103 +14,77 @@ import io.swagger.annotations.ApiModelProperty;
@ApiModel(value = "TrainingPhaseExportDTO", description = "Exported game level.", parent = AbstractPhaseExportDTO.class)
public class TrainingPhaseExportDTO extends AbstractPhaseExportDTO {
- @ApiModelProperty(value = "Keyword found in game, used for access next level.", example = "secretFlag")
- private String flag;
- @ApiModelProperty(value = "The information and experiences that are directed towards a participant.", example = "Play me")
- private String content;
- @ApiModelProperty(value = "Instruction how to get flag in game.", example = "This is how you do it")
- private String solution;
- @ApiModelProperty(value = "How many times player can submit incorrect flag before displaying solution.", example = "5")
- private int incorrectFlagLimit;
+ private int estimatedDuration;
+ private int allowedCommands;
+ private int allowedWrongAnswers;
+ private List<TaskExportDTO> tasks = new ArrayList<>();
+ private List<DecisionMatrixRowExportDTO> decisionMatrix;
+
+ public int getEstimatedDuration() {
+ return estimatedDuration;
+ }
+
+ public void setEstimatedDuration(int estimatedDuration) {
+ this.estimatedDuration = estimatedDuration;
+ }
+ public int getAllowedCommands() {
+ return allowedCommands;
+ }
- /**
- * Instantiates a new Game level export dto.
- */
- public TrainingPhaseExportDTO() {
+ public void setAllowedCommands(int allowedCommands) {
+ this.allowedCommands = allowedCommands;
}
- /**
- * Gets flag.
- *
- * @return the flag
- */
- public String getFlag() {
- return flag;
+ public int getAllowedWrongAnswers() {
+ return allowedWrongAnswers;
}
- /**
- * Sets flag.
- *
- * @param flag the flag
- */
- public void setFlag(String flag) {
- this.flag = flag;
+ public void setAllowedWrongAnswers(int allowedWrongAnswers) {
+ this.allowedWrongAnswers = allowedWrongAnswers;
}
- /**
- * Gets content.
- *
- * @return the content
- */
- public String getContent() {
- return content;
+ public List<TaskExportDTO> getTasks() {
+ return tasks;
}
- /**
- * Sets content.
- *
- * @param content the content
- */
- public void setContent(String content) {
- this.content = content;
+ public void setTasks(List<TaskExportDTO> tasks) {
+ this.tasks = tasks;
}
- /**
- * Gets solution.
- *
- * @return the solution
- */
- public String getSolution() {
- return solution;
+ public List<DecisionMatrixRowExportDTO> getDecisionMatrix() {
+ return decisionMatrix;
}
- /**
- * Sets solution.
- *
- * @param solution the solution
- */
- public void setSolution(String solution) {
- this.solution = solution;
+ public void setDecisionMatrix(List<DecisionMatrixRowExportDTO> decisionMatrix) {
+ this.decisionMatrix = decisionMatrix;
}
- /**
- * Gets incorrect flag limit.
- *
- * @return the incorrect flag limit
- */
- public int getIncorrectFlagLimit() {
- return incorrectFlagLimit;
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) return true;
+ if (!(o instanceof TrainingPhaseExportDTO)) return false;
+ if (!super.equals(o)) return false;
+ TrainingPhaseExportDTO that = (TrainingPhaseExportDTO) o;
+ return getEstimatedDuration() == that.getEstimatedDuration() &&
+ getAllowedCommands() == that.getAllowedCommands() &&
+ getAllowedWrongAnswers() == that.getAllowedWrongAnswers();
}
- /**
- * Sets incorrect flag limit.
- *
- * @param incorrectFlagLimit the incorrect flag limit
- */
- public void setIncorrectFlagLimit(int incorrectFlagLimit) {
- this.incorrectFlagLimit = incorrectFlagLimit;
+ @Override
+ public int hashCode() {
+ return Objects.hash(super.hashCode(), getEstimatedDuration(), getAllowedCommands(), getAllowedWrongAnswers());
}
@Override
public String toString() {
- return "GameLevelExportDTO{" +
- "flag='" + flag + '\'' +
- ", content='" + content + '\'' +
- ", solution='" + solution + '\'' +
- ", incorrectFlagLimit=" + incorrectFlagLimit +
+ return "TrainingPhaseExportDTO{" +
+ "estimatedDuration=" + estimatedDuration +
+ ", allowedCommands=" + allowedCommands +
+ ", allowedWrongAnswers=" + allowedWrongAnswers +
", title='" + title + '\'' +
- ", levelType=" + phaseType +
+ ", phaseType=" + phaseType +
+ ", order=" + order +
'}';
}
}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/DecisionMatrixMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/DecisionMatrixMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..cf7f2db1d9620c6fe5b026d8cb9fcb24c2128217
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/DecisionMatrixMapper.java
@@ -0,0 +1,58 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.phases.*;
+import cz.muni.ics.kypo.training.adaptive.domain.phases.questions.Question;
+import cz.muni.ics.kypo.training.adaptive.dto.BasicPhaseInfoDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.AbstractPhaseArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.info.InfoPhaseArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.questionnaire.QuestionnairePhaseArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.training.DecisionMatrixRowArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.training.TrainingPhaseArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.AbstractPhaseExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.info.InfoPhaseExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.questionnaire.QuestionnairePhaseExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.training.DecisionMatrixRowExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.training.TrainingPhaseExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.info.InfoPhaseImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.questionnaire.QuestionnairePhaseImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.training.DecisionMatrixRowImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.training.TrainingPhaseImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.info.InfoPhaseDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.info.InfoPhaseUpdateDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.questionnaire.QuestionDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.questionnaire.QuestionnairePhaseDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.questionnaire.QuestionnaireUpdateDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.training.DecisionMatrixRowDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.training.TrainingPhaseDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.training.TrainingPhaseUpdateDTO;
+import cz.muni.ics.kypo.training.adaptive.enums.PhaseType;
+import cz.muni.ics.kypo.training.adaptive.exceptions.InternalServerErrorException;
+import org.mapstruct.Mapper;
+import org.mapstruct.NullValueCheckStrategy;
+import org.mapstruct.ReportingPolicy;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * The InfoLevelMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type InfoLevelMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring", nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS,
+ unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface DecisionMatrixMapper extends ParentMapper {
+ // INFO PHASE
+ DecisionMatrixRow mapToEntity(DecisionMatrixRowDTO dto);
+ DecisionMatrixRow mapToEntity(DecisionMatrixRowImportDTO dto);
+
+ DecisionMatrixRowDTO mapToDecisionMatrixRowDTO(DecisionMatrixRow entity);
+ DecisionMatrixRowExportDTO mapToDecisionMatrixRowExportDTO(DecisionMatrixRow entity);
+ DecisionMatrixRowArchiveDTO mapToDecisionMatrixRowArchiveDTO(DecisionMatrixRow entity);
+
+ List<DecisionMatrixRow> mapToList(Collection<DecisionMatrixRowDTO> dtos);
+ List<DecisionMatrixRowDTO> mapToListDTO(Collection<DecisionMatrixRow> entities);
+ Set<DecisionMatrixRow> mapToSet(Collection<DecisionMatrixRowDTO> dtos);
+ Set<DecisionMatrixRowDTO> mapToSetDTO(Collection<DecisionMatrixRow> entities);
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/ExportImportMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/ExportImportMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..9a4bb3dba6f82b84409bd7f6b1a7f5208f1d9884
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/ExportImportMapper.java
@@ -0,0 +1,30 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.training.TrainingDefinition;
+import cz.muni.ics.kypo.training.adaptive.domain.training.TrainingInstance;
+import cz.muni.ics.kypo.training.adaptive.domain.training.TrainingRun;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.training.TrainingDefinitionArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.training.TrainingInstanceArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.training.TrainingRunArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.training.TrainingDefinitionWithPhasesExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.training.TrainingRunExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.ImportTrainingDefinitionDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * The ExportImportMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type ExportImportMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring",
+ uses = {UserRefMapper.class}, unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface ExportImportMapper extends ParentMapper {
+
+ TrainingDefinitionWithPhasesExportDTO mapToDTO(TrainingDefinition entity);
+ TrainingDefinition mapToEntity(ImportTrainingDefinitionDTO dto);
+ TrainingInstanceArchiveDTO mapToDTO(TrainingInstance entity);
+ TrainingRunExportDTO mapToDTO(TrainingRun entity);
+ TrainingDefinitionArchiveDTO mapToArchiveDTO(TrainingDefinition entity);
+ TrainingRunArchiveDTO mapToArchiveDTO(TrainingRun entity);
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/ParentMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/ParentMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..4217f9449e1ef6c1f69db7736927418058f9a597
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/ParentMapper.java
@@ -0,0 +1,22 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.dto.responses.PageResultResource;
+import org.springframework.data.domain.Page;
+
+/**
+ * ParentMapper is parent class for mappers which contains only one method for creating pagination.
+ *
+ */
+
+public interface ParentMapper {
+
+ default PageResultResource.Pagination createPagination(Page<?> objects) {
+ PageResultResource.Pagination pageMetadata = new PageResultResource.Pagination();
+ pageMetadata.setNumber(objects.getNumber());
+ pageMetadata.setNumberOfElements(objects.getNumberOfElements());
+ pageMetadata.setSize(objects.getSize());
+ pageMetadata.setTotalElements(objects.getTotalElements());
+ pageMetadata.setTotalPages(objects.getTotalPages());
+ return pageMetadata;
+ }
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/PhaseMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/PhaseMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..566f376b81b861ce4e34a24d21f5884f1505e76b
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/PhaseMapper.java
@@ -0,0 +1,103 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.phases.AbstractPhase;
+import cz.muni.ics.kypo.training.adaptive.domain.phases.InfoPhase;
+import cz.muni.ics.kypo.training.adaptive.domain.phases.QuestionnairePhase;
+import cz.muni.ics.kypo.training.adaptive.domain.phases.TrainingPhase;
+import cz.muni.ics.kypo.training.adaptive.dto.BasicPhaseInfoDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.AbstractPhaseArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.info.InfoPhaseArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.questionnaire.QuestionnairePhaseArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.training.TrainingPhaseArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.AbstractPhaseExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.info.InfoPhaseExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.questionnaire.QuestionnairePhaseExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.training.TrainingPhaseExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.info.InfoPhaseImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.questionnaire.QuestionnairePhaseImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.training.TrainingPhaseImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.info.InfoPhaseDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.info.InfoPhaseUpdateDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.questionnaire.QuestionnairePhaseDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.questionnaire.QuestionnaireUpdateDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.training.TrainingPhaseDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.training.TrainingPhaseUpdateDTO;
+import cz.muni.ics.kypo.training.adaptive.enums.PhaseType;
+import cz.muni.ics.kypo.training.adaptive.exceptions.InternalServerErrorException;
+import org.mapstruct.Mapper;
+import org.mapstruct.NullValueCheckStrategy;
+import org.mapstruct.ReportingPolicy;
+
+/**
+ * The InfoLevelMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type InfoLevelMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring", uses = {QuestionMapper.class, TaskMapper.class, DecisionMatrixMapper.class},
+ nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS, unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface PhaseMapper extends ParentMapper {
+ // INFO PHASE
+ InfoPhase mapToEntity(InfoPhaseDTO dto);
+ InfoPhase mapToEntity(InfoPhaseUpdateDTO dto);
+ InfoPhase mapToEntity(InfoPhaseImportDTO dto);
+
+ BasicPhaseInfoDTO mapToBasicPhaseInfoDTO(InfoPhase infoLevel);
+ InfoPhaseDTO mapToInfoPhaseDTO(InfoPhase entity);
+ InfoPhaseExportDTO mapToInfoPhaseExportDTO(InfoPhase entity);
+ InfoPhaseArchiveDTO mapToInfoPhaseArchiveDTO(InfoPhase entity);
+
+ // ASSESSMENT LEVEL
+ QuestionnairePhase mapToEntity(QuestionnairePhaseDTO dto);
+ QuestionnairePhase mapToEntity(QuestionnairePhaseImportDTO dto);
+ QuestionnairePhase mapToEntity(QuestionnaireUpdateDTO dto);
+
+ BasicPhaseInfoDTO mapToBasicPhaseInfoDTO(QuestionnairePhase entity);
+ QuestionnairePhaseDTO mapToQuestionnairePhaseDTO(QuestionnairePhase entity);
+ QuestionnairePhaseArchiveDTO mapToQuestionnairePhaseArchiveDTO(QuestionnairePhase entity);
+ QuestionnairePhaseExportDTO mapToQuestionnairePhaseExportDTO(QuestionnairePhase entity);
+
+ // GAME LEVEL
+ TrainingPhase mapToEntity(TrainingPhaseDTO dto);
+ TrainingPhase mapUpdateToEntity(TrainingPhaseUpdateDTO dto);
+ TrainingPhase mapImportToEntity(TrainingPhaseImportDTO dto);
+
+ BasicPhaseInfoDTO mapTo(TrainingPhase entity);
+ TrainingPhaseDTO mapToTrainingPhaseDTO(TrainingPhase entity);
+ TrainingPhaseExportDTO mapToTrainingPhaseExportDTO(TrainingPhase entity);
+ TrainingPhaseArchiveDTO mapToTrainingPhaseArchiveDTO(TrainingPhase entity);
+
+ // ABSTRACT
+ default AbstractPhaseArchiveDTO mapToArchiveDTO(AbstractPhase entity) {
+ AbstractPhaseArchiveDTO abstractPhaseArchiveDTO;
+ if (entity instanceof TrainingPhase) {
+ abstractPhaseArchiveDTO = mapToTrainingPhaseArchiveDTO((TrainingPhase) entity);
+ abstractPhaseArchiveDTO.setPhaseType(PhaseType.TRAINING);
+ } else if (entity instanceof InfoPhase) {
+ abstractPhaseArchiveDTO = mapToInfoPhaseArchiveDTO((InfoPhase) entity);
+ abstractPhaseArchiveDTO.setPhaseType(PhaseType.INFO);
+ } else if (entity instanceof QuestionnairePhase) {
+ abstractPhaseArchiveDTO = mapToQuestionnairePhaseArchiveDTO((QuestionnairePhase) entity);
+ abstractPhaseArchiveDTO.setPhaseType(PhaseType.QUESTIONNAIRE);
+ } else {
+ throw new InternalServerErrorException("Phase with id: " + entity.getId() + " is not instance of questionnaire, training or info phase.");
+ }
+ return abstractPhaseArchiveDTO;
+ }
+
+ default AbstractPhaseExportDTO mapToExportDTO(AbstractPhase entity) {
+ AbstractPhaseExportDTO abstractPhaseExportDTO;
+ if (entity instanceof TrainingPhase) {
+ abstractPhaseExportDTO = mapToTrainingPhaseExportDTO((TrainingPhase) entity);
+ abstractPhaseExportDTO.setPhaseType(PhaseType.TRAINING);
+ } else if (entity instanceof InfoPhase) {
+ abstractPhaseExportDTO = mapToInfoPhaseExportDTO((InfoPhase) entity);
+ abstractPhaseExportDTO.setPhaseType(PhaseType.INFO);
+ } else if (entity instanceof QuestionnairePhase) {
+ abstractPhaseExportDTO = mapToQuestionnairePhaseExportDTO((QuestionnairePhase) entity);
+ abstractPhaseExportDTO.setPhaseType(PhaseType.QUESTIONNAIRE);
+ } else {
+ throw new InternalServerErrorException("Phase with id: " + entity.getId() + " is not instance of questionnaire, training or info phase.");
+ }
+ return abstractPhaseExportDTO;
+ }
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/QuestionMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/QuestionMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..116b26e4cdd08650e3da07ac2a4ce7ab99c5492b
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/QuestionMapper.java
@@ -0,0 +1,55 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.phases.questions.Question;
+import cz.muni.ics.kypo.training.adaptive.domain.phases.questions.QuestionChoice;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.questionnaire.QuestionArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.questionnaire.QuestionChoiceArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.questionnaire.QuestionChoiceExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.questionnaire.QuestionExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.questionnaire.QuestionChoiceImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.questionnaire.QuestionImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.questionnaire.QuestionChoiceDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.questionnaire.QuestionDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.questionnaire.QuestionUpdateDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.responses.PageResultResource;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+
+import java.util.*;
+
+/**
+ * The HintMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type HintMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface QuestionMapper extends ParentMapper {
+// QUESTIONS
+ Question mapToEntity(QuestionDTO dto);
+ Question mapToEntity(QuestionUpdateDTO dto);
+ Question mapToEntity(QuestionImportDTO dto);
+
+ QuestionArchiveDTO mapToQuestionArchiveDTO(Question entity);
+ QuestionExportDTO mapToQuestionExportDTO(Question entity);
+ QuestionDTO mapToQuestionDTO(Question entity);
+
+ List<Question> mapToList(Collection<QuestionDTO> dtos);
+ List<QuestionDTO> mapToListDTO(Collection<Question> entities);
+ Set<Question> mapToSet(Collection<QuestionDTO> dtos);
+ Set<QuestionDTO> mapToSetDTO(Collection<Question> entities);
+
+// QUESTION CHOICES
+ QuestionChoice mapToEntity(QuestionChoiceDTO dto);
+ QuestionChoice mapToEntity(QuestionChoiceImportDTO dto);
+
+ QuestionChoiceArchiveDTO mapToQuestionArchiveDTO(QuestionChoice entity);
+ QuestionChoiceExportDTO mapToQuestionExportDTO(QuestionChoice entity);
+ QuestionChoiceDTO mapToQuestionDTO(QuestionChoice entity);
+
+ List<QuestionChoice> mapChoicesToList(Collection<QuestionChoiceDTO> dtos);
+ List<QuestionDTO> mapToChoicesListDTO(Collection<QuestionChoice> entities);
+ Set<QuestionChoice> mapChoicesToSet(Collection<QuestionChoiceDTO> dtos);
+ Set<QuestionDTO> mapToChoicesSetDTO(Collection<QuestionChoice> entities);
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TaskMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TaskMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..3980601e8eda2a5c748f0456110116ad2de42cd9
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TaskMapper.java
@@ -0,0 +1,36 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.phases.Task;
+import cz.muni.ics.kypo.training.adaptive.dto.archive.phases.training.TaskArchiveDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.phases.training.TaskExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.imports.phases.training.TaskImportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.training.TaskDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.training.TaskUpdateDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * The HintMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type HintMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface TaskMapper extends ParentMapper {
+ Task mapToEntity(TaskDTO dto);
+ Task mapToEntity(TaskUpdateDTO dto);
+ Task mapToEntity(TaskImportDTO dto);
+
+ TaskArchiveDTO mapToQuestionArchiveDTO(Task entity);
+ TaskExportDTO mapToQuestionExportDTO(Task entity);
+ TaskDTO mapToQuestionDTO(Task entity);
+
+ List<Task> mapToList(Collection<TaskDTO> dtos);
+ List<TaskDTO> mapToListDTO(Collection<Task> entities);
+ Set<Task> mapToSet(Collection<TaskDTO> dtos);
+ Set<TaskDTO> mapToSetDTO(Collection<Task> entities);
+
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingDefinitionMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingDefinitionMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..43c4a824eb9d0216573871865f39fbb630831fb5
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingDefinitionMapper.java
@@ -0,0 +1,73 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.training.TrainingDefinition;
+import cz.muni.ics.kypo.training.adaptive.dto.responses.PageResultResource;
+import cz.muni.ics.kypo.training.adaptive.dto.trainingdefinition.*;
+import org.mapstruct.Mapper;
+import org.mapstruct.NullValueCheckStrategy;
+import org.mapstruct.ReportingPolicy;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+
+import java.util.*;
+
+/**
+ * The TrainingDefinitionMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type TrainingDefinitionMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring",
+ uses = {UserRefMapper.class},
+ nullValueCheckStrategy = NullValueCheckStrategy.ALWAYS, unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface TrainingDefinitionMapper extends ParentMapper {
+
+ TrainingDefinition mapToEntity(TrainingDefinitionByIdDTO dto);
+
+ TrainingDefinitionByIdDTO mapToDTOById(TrainingDefinition entity);
+
+ TrainingDefinitionDTO mapToDTO(TrainingDefinition entity);
+
+ TrainingDefinitionInfoDTO mapToInfoDTO(TrainingDefinition entity);
+
+ TrainingDefinition mapCreateToEntity(TrainingDefinitionCreateDTO dto);
+
+ TrainingDefinition mapUpdateToEntity(TrainingDefinitionUpdateDTO dto);
+
+ List<TrainingDefinition> mapToList(Collection<TrainingDefinitionByIdDTO> dtos);
+
+ List<TrainingDefinitionByIdDTO> mapToListDTO(Collection<TrainingDefinition> entities);
+
+ Set<TrainingDefinition> mapToSet(Collection<TrainingDefinitionByIdDTO> dtos);
+
+ Set<TrainingDefinitionByIdDTO> mapToSetDTO(Collection<TrainingDefinition> entities);
+
+ default Optional<TrainingDefinition> mapToOptional(TrainingDefinitionByIdDTO dto) {
+ return Optional.ofNullable(mapToEntity(dto));
+ }
+
+ default Optional<TrainingDefinitionByIdDTO> mapToOptional(TrainingDefinition entity) {
+ return Optional.ofNullable(mapToDTOById(entity));
+ }
+
+ default Page<TrainingDefinitionByIdDTO> mapToPageDTO(Page<TrainingDefinition> objects) {
+ List<TrainingDefinitionByIdDTO> mapped = mapToListDTO(objects.getContent());
+ return new PageImpl<>(mapped, objects.getPageable(), mapped.size());
+ }
+
+ default Page<TrainingDefinition> mapToPage(Page<TrainingDefinitionByIdDTO> objects) {
+ List<TrainingDefinition> mapped = mapToList(objects.getContent());
+ return new PageImpl<>(mapped, objects.getPageable(), mapped.size());
+ }
+
+ default PageResultResource<TrainingDefinitionDTO> mapToPageResultResource(Page<TrainingDefinition> objects) {
+ List<TrainingDefinitionDTO> mapped = new ArrayList<>();
+ objects.forEach(object -> mapped.add(mapToDTO(object)));
+ return new PageResultResource<>(mapped, createPagination(objects));
+ }
+
+ default PageResultResource<TrainingDefinitionInfoDTO> mapToPageResultResourceInfoDTO(Page<TrainingDefinition> objects) {
+ List<TrainingDefinitionInfoDTO> mapped = new ArrayList<>();
+ objects.forEach(object -> mapped.add(mapToInfoDTO(object)));
+ return new PageResultResource<>(mapped, createPagination(objects));
+ }
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingInstanceMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingInstanceMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..5b1849c211ff62d48587f0faa5883afee606abeb
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingInstanceMapper.java
@@ -0,0 +1,72 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.training.TrainingInstance;
+import cz.muni.ics.kypo.training.adaptive.dto.responses.PageResultResource;
+import cz.muni.ics.kypo.training.adaptive.dto.traininginstance.*;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+
+import java.util.*;
+
+/**
+ * The TrainingInstanceMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type TrainingInstanceMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring", uses = {TrainingDefinitionMapper.class, UserRefMapper.class}, unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface TrainingInstanceMapper extends ParentMapper{
+ TrainingInstance mapToEntity(TrainingInstanceDTO dto);
+
+ TrainingInstance mapUpdateToEntity(TrainingInstanceUpdateDTO dto);
+
+ TrainingInstance mapCreateToEntity(TrainingInstanceCreateDTO dto);
+
+ TrainingInstance mapPartialUpdateToEntity(TrainingInstanceAssignPoolIdDTO dto);
+
+ TrainingInstanceBasicInfoDTO mapEntityToTIBasicInfo(TrainingInstance dto);
+
+ TrainingInstanceDTO mapToDTO(TrainingInstance entity);
+
+ TrainingInstanceFindAllResponseDTO mapToFindAllViewDTO(TrainingInstance entity);
+
+ List<TrainingInstance> mapToList(Collection<TrainingInstanceDTO> dtos);
+
+ List<TrainingInstanceDTO> mapToListDTO(Collection<TrainingInstance> entities);
+
+ Set<TrainingInstance> mapToSet(Collection<TrainingInstanceDTO> dtos);
+
+ Set<TrainingInstanceDTO> mapToSetDTO(Collection<TrainingInstance> entities);
+
+ default Optional<TrainingInstance> mapToOptional(TrainingInstanceDTO dto){
+ return Optional.ofNullable(mapToEntity(dto));
+ }
+
+ default Optional<TrainingInstanceDTO> mapToOptional(TrainingInstance entity){
+ return Optional.ofNullable(mapToDTO(entity));
+ }
+
+ default Page<TrainingInstanceDTO> mapToPageDTO(Page<TrainingInstance> objects){
+ List<TrainingInstanceDTO> mapped = mapToListDTO(objects.getContent());
+ return new PageImpl<>(mapped, objects.getPageable(), mapped.size());
+ }
+
+ default Page<TrainingInstance> mapToPage(Page<TrainingInstanceDTO> objects){
+ List<TrainingInstance> mapped = mapToList(objects.getContent());
+ return new PageImpl<>(mapped, objects.getPageable(), mapped.size());
+ }
+
+ default PageResultResource<TrainingInstanceDTO> mapToPageResultResource(Page<TrainingInstance> objects){
+ List<TrainingInstanceDTO> mapped = new ArrayList<>();
+ objects.forEach(object -> mapped.add(mapToDTO(object)));
+ return new PageResultResource<>(mapped, createPagination(objects));
+ }
+
+ default PageResultResource<TrainingInstanceFindAllResponseDTO> mapToPageResultResourceBasicView(Page<TrainingInstance> objects){
+ List<TrainingInstanceFindAllResponseDTO> mapped = new ArrayList<>();
+ objects.forEach(object -> mapped.add(mapToFindAllViewDTO(object)));
+ return new PageResultResource<>(mapped, createPagination(objects));
+ }
+
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingRunMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingRunMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..7f58a3a31f276b88cbd35587c7d4edc6b80638b6
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/TrainingRunMapper.java
@@ -0,0 +1,65 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.training.TrainingRun;
+import cz.muni.ics.kypo.training.adaptive.dto.responses.PageResultResource;
+import cz.muni.ics.kypo.training.adaptive.dto.trainingrun.AccessedTrainingRunDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.trainingrun.TrainingRunByIdDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.trainingrun.TrainingRunDTO;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+
+import java.util.*;
+
+/**
+ * The TrainingRunMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type TrainingRunMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring", unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface TrainingRunMapper extends ParentMapper {
+ TrainingRun mapToEntity(TrainingRunDTO dto);
+
+ TrainingRunDTO mapToDTO(TrainingRun entity);
+
+ TrainingRunByIdDTO mapToFindByIdDTO(TrainingRun entity);
+
+ List<TrainingRun> mapToList(Collection<TrainingRunDTO> dtos);
+
+ List<TrainingRunDTO> mapToListDTO(Collection<TrainingRun> entities);
+
+ Set<TrainingRun> mapToSet(Collection<TrainingRunDTO> dtos);
+
+ Set<TrainingRunDTO> mapToSetDTO(Collection<TrainingRun> entities);
+
+ default Optional<TrainingRun> mapToOptional(TrainingRunDTO dto){
+ return Optional.ofNullable(mapToEntity(dto));
+ }
+
+ default Optional<TrainingRunDTO> mapToOptional(TrainingRun entity){
+ return Optional.ofNullable(mapToDTO(entity));
+ }
+
+ default Page<TrainingRunDTO> mapToPageDTO(Page<TrainingRun> objects){
+ List<TrainingRunDTO> mapped = mapToListDTO(objects.getContent());
+ return new PageImpl<>(mapped, objects.getPageable(), mapped.size());
+ }
+
+ default Page<TrainingRun> mapToPage(Page<TrainingRunDTO> objects){
+ List<TrainingRun> mapped = mapToList(objects.getContent());
+ return new PageImpl<>(mapped, objects.getPageable(), mapped.size());
+ }
+
+ default PageResultResource<TrainingRunDTO> mapToPageResultResource(Page<TrainingRun> objects){
+ List<TrainingRunDTO> mapped = new ArrayList<>();
+ objects.forEach(object -> mapped.add(mapToDTO(object)));
+ return new PageResultResource<>(mapped, createPagination(objects));
+ }
+
+ default PageResultResource<AccessedTrainingRunDTO> mapToPageResultResourceAccessed(Page<AccessedTrainingRunDTO> objects){
+ List<AccessedTrainingRunDTO> mapped = new ArrayList<>();
+ objects.forEach(mapped::add);
+ return new PageResultResource<>(mapped, createPagination(objects));
+ }
+}
diff --git a/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/UserRefMapper.java b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/UserRefMapper.java
new file mode 100644
index 0000000000000000000000000000000000000000..9dcbec2485807821a1e181f0ab5ecac820fc1d5e
--- /dev/null
+++ b/src/main/java/cz/muni/ics/kypo/training/adaptive/mapper/mapstruct/UserRefMapper.java
@@ -0,0 +1,59 @@
+package cz.muni.ics.kypo.training.adaptive.mapper.mapstruct;
+
+import cz.muni.ics.kypo.training.adaptive.domain.UserRef;
+import cz.muni.ics.kypo.training.adaptive.dto.UserRefDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.export.UserRefExportDTO;
+import cz.muni.ics.kypo.training.adaptive.dto.responses.PageResultResource;
+import org.mapstruct.Mapper;
+import org.mapstruct.ReportingPolicy;
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.PageImpl;
+
+import java.util.*;
+
+/**
+ * The UserRefMapper is an utility class to map items into data transfer objects. It provides the implementation of mappings between Java bean type UserRefMapper and
+ * DTOs classes. Code is generated during compile time.
+ *
+ */
+@Mapper(componentModel = "spring", uses = {TrainingInstanceMapper.class}, unmappedTargetPolicy = ReportingPolicy.IGNORE)
+public interface UserRefMapper extends ParentMapper {
+
+ UserRef mapToEntity(UserRefDTO dto);
+
+ UserRefDTO mapToDTO(UserRef entity);
+
+ List<UserRef> mapToList(Collection<UserRefDTO> dtos);
+
+ List<UserRefDTO> mapToListDTO(Collection<UserRef> entities);
+
+ Set<UserRef> mapToSet(Collection<UserRefDTO> dtos);
+
+ Set<UserRefDTO> mapToSetDTO(Collection<UserRef> entities);
+
+ List<UserRefExportDTO> mapUserRefExportDTOToUserRefDTO(Collection<UserRefDTO> userRefDTOs);
+
+ default Optional<UserRef> mapToOptional(UserRefDTO dto) {
+ return Optional.ofNullable(mapToEntity(dto));
+ }
+
+ default Optional<UserRefDTO> mapToOptional(UserRef entity) {
+ return Optional.ofNullable(mapToDTO(entity));
+ }
+
+ default Page<UserRefDTO> mapToPageDTO(Page<UserRef> objects) {
+ List<UserRefDTO> mapped = mapToListDTO(objects.getContent());
+ return new PageImpl<>(mapped, objects.getPageable(), mapped.size());
+ }
+
+ default Page<UserRef> mapToPage(Page<UserRefDTO> objects) {
+ List<UserRef> mapped = mapToList(objects.getContent());
+ return new PageImpl<>(mapped, objects.getPageable(), mapped.size());
+ }
+
+ default PageResultResource<UserRefDTO> mapToPageResultResource(Page<UserRef> objects) {
+ List<UserRefDTO> mapped = new ArrayList<>();
+ objects.forEach(object -> mapped.add(mapToDTO(object)));
+ return new PageResultResource<>(mapped, createPagination(objects));
+ }
+}