net.intelie.liverig.witsml.query.LogQuery20 Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of liverig-witsml Show documentation
liverig witsml
The newest version!
package net.intelie.liverig.witsml.query;

import com.google.common.base.Strings;
import net.intelie.liverig.parser.ParseException;
import net.intelie.liverig.witsml.WITSMLResult;
import net.intelie.liverig.witsml.objects.*;

import java.util.*;
import java.util.stream.Collectors;

class LogQuery20 extends AbstractLogQuery20 implements LogQuery {
    private final boolean logData;
    private final boolean raw;

    LogQuery20(String uidWell, String uidWellbore, String uid, LogRange range, boolean logData, boolean raw) {
        super(uidWell, uidWellbore, uid, range);
        this.logData = logData;
        this.raw = raw;
    }


    @Override
    public LogData parse(WITSMLResult witsmlResult) throws ParseException {
        String xml = witsmlResult.getXml();
        LogData result = new LogData();
        if (logData)
            result.setData(new ArrayList<>());
        parse(xml, new Parser(result), (range instanceof LogDepthIndex ? "depth" : "date time"));
        if (raw)
            result.setRaw(xml);
        result.setRawResult(witsmlResult.getResult());
        return result;
    }

    static class Parser extends AbstractParser {
        private final LogData result;

        public Parser(LogData result) {
            this.result = result;
        }

        static LogHeader20 getHeader(Map object) {
            LogHeader20 header = new LogHeader20();

            header.setUidWell(getString(object, "uidWell"));
            header.setUidWellbore(getString(getMapOrValue(object, "Wellbore"), "Uuid"));
            header.setUid(getString(object, "uuid"));
            header.setNameWell(getString(object, "nameWell"));
            header.setNameWellbore(getString(getMapOrValue(object, "Wellbore"), "Title"));
            header.setName(getString(getMapOrValue(object, "Citation"), "Title"));

            List channelSets = (List) object
                    .entrySet()
                    .stream()
                    .filter(entry -> entry.getKey().equals("ChannelSets"))
                    .map(Map.Entry::getValue)
                    .map(List.class::cast)
                    .flatMap(x -> x.stream())
                    .map(o -> {
                        Map channelSetMap = (Map) o;

                        List indexes = channelSetMap
                                .entrySet()
                                .stream()
                                .filter(entry -> entry.getKey().equals("Index"))
                                .map(Map.Entry::getValue)
                                .map(y -> {
                                    Map indexMap = (Map) y;

                                    return new ChannelSetIndex(getString(indexMap, "Mnemonic"),
                                            getString(indexMap, "Uom"),
                                            getString(indexMap, "IndexType"),
                                            getString(indexMap, "Direction"));
                                })
                                .collect(Collectors.toList());

                        List channels = (List) channelSetMap
                                .entrySet()
                                .stream()
                                .filter(entry -> entry.getKey().equals("Channels"))
                                .map(Map.Entry::getValue)
                                .map(List.class::cast)
                                .flatMap(x -> x.stream())
                                .map(y -> {
                                    Map channelMap = (Map) y;

                                    return new Channel(getString(channelMap, "uuid"),
                                            getString(channelMap, "Uom"),
                                            getString(channelMap, "Mnemonic"));
                                })
                                .collect(Collectors.toList());

                        return new ChannelSet(getString(channelSetMap, "uuid"), indexes, channels);
                    })
                    .collect(Collectors.toList());

            header.setChannelSets(channelSets);

            Map startIndex = getMapOrValue(object, "StartIndex");
            Map endIndex = getMapOrValue(object, "EndIndex");
            LogIndex logIndex = null;
            LogDateTimeIndex logDateTimeIndex = null;

            ChannelSetIndex channelSetIndex =
                    header.getChannelSets().stream()
                            .flatMap(channelSet -> channelSet.getIndexes().stream())
                            .findFirst().orElse(null);


            if (!startIndex.isEmpty()) {
                String type = getString(startIndex, "type");
                if ("DepthIndexValue".equals(type)) {
                    Double value = getDouble(startIndex, "Depth");
                    logIndex = logIndex == null ? new LogDepthIndex() : logIndex;
                    logIndex.setStartIndex(value);
                    logIndex.setStartIndexUom(channelSetIndex != null ? channelSetIndex.getUom() : null);
                    header.setIndexType(channelSetIndex != null ? channelSetIndex.getIndexType() : "measured depth");
                } else if ("TimeIndexValue".equals(type)) {
                    String value = getString(startIndex, "Time");
                    logDateTimeIndex = logDateTimeIndex == null ? new LogDateTimeIndex() : logDateTimeIndex;
                    logDateTimeIndex.setStartDateTimeIndex(value);
                    header.setIndexType("date time");
                }
            }

            if (!endIndex.isEmpty()) {
                String type = getString(endIndex, "type");
                if ("DepthIndexValue".equals(type)) {
                    Double value = getDouble(endIndex, "Depth");
                    logIndex = logIndex == null ? new LogDepthIndex() : logIndex;
                    logIndex.setEndIndex(value);
                    logIndex.setEndIndexUom(channelSetIndex != null ? channelSetIndex.getUom() : null);
                    header.setIndexType(channelSetIndex != null ? channelSetIndex.getIndexType() : "measured depth");
                } else if ("TimeIndexValue".equals(type)) {
                    String value = getString(endIndex, "Time");
                    logDateTimeIndex = logDateTimeIndex == null ? new LogDateTimeIndex() : logDateTimeIndex;
                    logDateTimeIndex.setEndDateTimeIndex(value);
                    header.setIndexType("date time");
                }
            }

            header.setIndex(logIndex);
            header.setDateTimeIndex(logDateTimeIndex);

            return header;
        }

        @Override
        protected void event(Map object, Map data) {
            if (!"Log".equals(object.get("object")))
                return;

            LogHeader20 header = (LogHeader20) result.getHeader();
            if (header == null) {
                header = getHeader(object);
                result.setHeader(header);
            } else {
                if (!Objects.equals(header.getUidWell(), getString(object, "uidWell")))
                    return;
                if (!Objects.equals(header.getUidWellbore(), getString(object, "uidWellbore")))
                    return;
                if (!Objects.equals(header.getUid(), getString(object, "uid")))
                    return;
            }

            List> logData = result.getData();
            if (logData != null) {

                List mnemonics = header
                        .getChannelSets()
                        .stream()
                        .flatMap(channelSet -> channelSet.channels().stream())
                        .filter(channel -> !Strings.isNullOrEmpty(channel.getMnemonic()))
                        .map(channel -> channel.getMnemonic())
                        .collect(Collectors.toList());

                Map map = new LinkedHashMap<>(mnemonics.size());
                for (String mnemonic : mnemonics)
                    map.put(mnemonic, getMapOrValue(data, mnemonic).get("value"));
                logData.add(map);
            }
        }
    }
}