mongodb encode/decode

ExecutionCodec.java

package com.redhat.developer.execution.storage.codecs;

import java.util.ArrayList;
import java.util.Date;
import java.util.UUID;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.mongodb.MongoClientSettings;
import com.redhat.developer.execution.models.DMNResultModel;
import com.redhat.developer.execution.models.OutcomeModel;
import org.bson.BsonReader;
import org.bson.BsonString;
import org.bson.BsonType;
import org.bson.BsonValue;
import org.bson.BsonWriter;
import org.bson.Document;
import org.bson.codecs.Codec;
import org.bson.codecs.CollectibleCodec;
import org.bson.codecs.DecoderContext;
import org.bson.codecs.EncoderContext;
import org.bson.codecs.configuration.CodecRegistry;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ExecutionCodec implements CollectibleCodec<DMNResultModel> {
    private static final Logger LOGGER = LoggerFactory.getLogger(ExecutionCodec.class);

    private final Codec<Document> documentCodec;
    private final CodecRegistry codecRegistry;

    private static final ObjectMapper mapper = new ObjectMapper();

    public ExecutionCodec(final CodecRegistry codecRegistry) {
        this.codecRegistry = codecRegistry;
        this.documentCodec = MongoClientSettings.getDefaultCodecRegistry().get(Document.class);
    }

    @Override
    public void encode(BsonWriter writer, DMNResultModel result, EncoderContext encoderContext) {
        Codec outcomeCodec = codecRegistry.get(OutcomeModel.class);

        LOGGER.info("FODISJFSDIOJFIOSDJFIOSDJIOFSDJIOSJDFIOSDJIOFJ");
//        Document doc = new Document();
//        doc.put("executionId", result.executionId);
//        doc.put("modelId", result.modelId);
//        documentCodec.encode(writer, doc, encoderContext);
        try {
            Document myDoc = Document.parse(mapper.writeValueAsString(result));
            documentCodec.encode(writer, myDoc, encoderContext);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

//        writer.writeStartDocument();
//
//        writer.writeName("executionId");
//        writer.writeString(result.executionId);
//
//        writer.writeName("executionDate");
//        writer.writeDateTime(result.executionDate.toInstant().toEpochMilli());
//
//        writer.writeName("modelNamespace");
//        writer.writeString(result.modelNamespace == null ? "" : result.modelNamespace);
//
//        writer.writeName("modelName");
//        writer.writeString(result.modelName == null ? "" : result.modelName);
//
//        writer.writeName("modelId");
//        writer.writeString(result.modelId);
//
//        writer.writeStartArray("decisions");
//        for (OutcomeModel outcome : result.decisions) {
//            encoderContext.encodeWithChildContext(outcomeCodec, writer, outcome);
//        }
//        writer.writeEndArray();
//
//
//
//        writer.writeEndDocument();
    }

    @Override
    public Class<DMNResultModel> getEncoderClass() {
        return DMNResultModel.class;
    }

    @Override
    public DMNResultModel generateIdIfAbsentFromDocument(DMNResultModel document) {
        if (!documentHasId(document)) {
            document.executionId = (UUID.randomUUID().toString());
        }
        return document;
    }

    @Override
    public boolean documentHasId(DMNResultModel document) {
        return document.executionId != null;
    }

    @Override
    public BsonValue getDocumentId(DMNResultModel document) {
        return new BsonString(document.executionId);
    }

    @Override
    public DMNResultModel decode(BsonReader reader, DecoderContext decoderContext) {
        Codec outcomeCodec = codecRegistry.get(OutcomeModel.class);
        LOGGER.info("fiopdjfiodsjiofsdj");

//
        Document document = documentCodec.decode(reader, decoderContext);
//        DMNResultModel resultModel = new DMNResultModel();

        try {
            return mapper.readValue(document.toJson(), DMNResultModel.class);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }

        //        resultModel.decisions = new ArrayList<>();
////        if (document.getString("executionId") != null) {
////            resultModel.executionId = (document.getString("executionId"));
////        }
////        resultModel.executionId = (document.getString("executionId"));
////        resultModel.modelId = (document.getString("modelId"));
////        return resultModel;
//
//        reader.readStartDocument();
//
//        reader.readObjectId();
//        resultModel.executionId = reader.readString();
//
//        reader.readName();
//        resultModel.executionDate = new Date(reader.readDateTime());
//
//        reader.readName();
//        resultModel.modelNamespace = reader.readString();
////
//        reader.readName();
//        resultModel.modelName = reader.readString();
//
//        reader.readName();
//        resultModel.modelId = reader.readString();
//
//        reader.readName();
//        reader.readStartArray();
//        while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
//            resultModel.decisions.add((OutcomeModel) outcomeCodec.decode(reader, decoderContext));
//        }
//        reader.readEndArray();
//
//        reader.readEndDocument();
//
//        LOGGER.info("fiopdjfiodsjiofsdj");
//        Document document = documentCodec.decode(reader, decoderContext);
//        DMNResultModel resultModel = new DMNResultModel();
//        if (document.getString("id") != null) {
//            resultModel.executionId = (document.getString("executionId"));
//        }
//
//        resultModel.executionDate = (document.getDate("executionDate"));
//        resultModel.decisions = (List<OutcomeModel>) document.getList("decisions");
//        resultModel.context = (Map<String, Object>) document.get("context");
//        resultModel.modelNamespace = document.getString("modelNamespace");
//        resultModel.modelName = document.getString("modelName");
//        resultModel.modelId = document.getString("modelId");

//        return resultModel;
        return null;
    }
}

ExecutionCodecProvider.java

package com.redhat.developer.execution.storage.codecs;

import com.redhat.developer.execution.models.DMNResultModel;
import org.bson.codecs.Codec;
import org.bson.codecs.configuration.CodecProvider;
import org.bson.codecs.configuration.CodecRegistry;

public class ExecutionCodecProvider implements CodecProvider {

    @Override
    public <T> Codec<T> get(Class<T> clazz, CodecRegistry registry) {
        if (clazz == DMNResultModel.class) {
            return (Codec<T>) new ExecutionCodec(registry);
        }
        return null;
    }
}

OutcomeCodec.java

package com.redhat.developer.execution.storage.codecs;

import java.util.UUID;

import com.mongodb.MongoClientSettings;
import com.redhat.developer.execution.models.OutcomeEvaluationStatusModel;
import com.redhat.developer.execution.models.OutcomeModel;
import org.bson.BsonReader;
import org.bson.BsonString;
import org.bson.BsonValue;
import org.bson.BsonWriter;
import org.bson.Document;
import org.bson.codecs.Codec;
import org.bson.codecs.CollectibleCodec;
import org.bson.codecs.DecoderContext;
import org.bson.codecs.EncoderContext;
import org.bson.codecs.configuration.CodecRegistry;

public class OutcomeCodec implements CollectibleCodec<OutcomeModel> {

    private final Codec<Document> documentCodec;
    private final CodecRegistry codecRegistry;

    public OutcomeCodec(final CodecRegistry codecRegistry) {
        this.codecRegistry = codecRegistry;
        this.documentCodec = MongoClientSettings.getDefaultCodecRegistry().get(Document.class);
    }

    @Override
    public void encode(BsonWriter writer, OutcomeModel outcome, EncoderContext encoderContext) {
        writer.writeStartDocument();

        writer.writeName("outcomeId");
        writer.writeString(outcome.outcomeId);

        writer.writeName("outcomeName");
        writer.writeString(outcome.outcomeName);

        writer.writeName("hasErrors");
        writer.writeBoolean(outcome.hasErrors);

//        writer.writeName("outcomeResult");
//        writer.(outcome.result);

        writer.writeEndDocument();
    }

    @Override
    public Class<OutcomeModel> getEncoderClass() {
        return OutcomeModel.class;
    }

    @Override
    public OutcomeModel generateIdIfAbsentFromDocument(OutcomeModel document) {
        if (!documentHasId(document)) {
            document.outcomeId = (UUID.randomUUID().toString());
        }
        return document;
    }

    @Override
    public boolean documentHasId(OutcomeModel document) {
        return document.outcomeId != null;
    }

    @Override
    public BsonValue getDocumentId(OutcomeModel document) {
        return new BsonString(document.outcomeId);
    }

    @Override
    public OutcomeModel decode(BsonReader reader, DecoderContext decoderContext) {

        OutcomeModel resultModel = new OutcomeModel();

        reader.readStartDocument();

        reader.readName();
        resultModel.outcomeId = reader.readString();

        reader.readName();
        resultModel.outcomeName = reader.readString();

        reader.readName();
        resultModel.hasErrors = reader.readBoolean();

        reader.readEndDocument();

        return resultModel;
    }
}

OutcomeCodecProvider.java

package com.redhat.developer.execution.storage.codecs;

import com.redhat.developer.execution.models.OutcomeModel;
import org.bson.codecs.Codec;
import org.bson.codecs.configuration.CodecProvider;
import org.bson.codecs.configuration.CodecRegistry;

public class OutcomeCodedProvider implements CodecProvider {
    @Override
    public <T> Codec<T> get(Class<T> clazz, CodecRegistry registry) {
        if (clazz == OutcomeModel.class) {
            return (Codec<T>) new OutcomeCodec(registry);
        }
        return null;
    }
}