Dépôt officiel du code source de l'ERP OpenConcerto

/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

 *

 * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.

 *

 * The contents of this file are subject to the terms of the GNU General Public License Version 3

 * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a

 * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific

 * language governing permissions and limitations under the License.

 *

 * When distributing the software, include this License Header Notice in each file.

 */

 package org.openconcerto.erp.core.sales.pos.model;

import org.openconcerto.erp.core.sales.pos.model.RegisterFiles.HashMode;

import org.openconcerto.erp.core.sales.pos.model.RegisterLogEntry.ReceiptEntry;

import org.openconcerto.erp.core.sales.pos.model.RegisterLogEntry.RegisterEntry;

import org.openconcerto.erp.core.sales.pos.model.RegisterState.Status;

import org.openconcerto.utils.CollectionUtils;

import org.openconcerto.utils.CompareUtils;

import java.io.IOException;

import java.nio.file.Path;

import java.text.ParseException;

import java.util.ArrayList;

import java.util.Collections;

import java.util.List;

import org.jdom2.Document;

import org.jdom2.Element;

import org.jdom2.JDOMException;

/**

 * To parse the log file for a register.

 *

 * @author sylvain

 */

public class RegisterLog {

    // TODO RECEIPT_MODIFICATION

    static public enum EventType {

        REGISTER_OPENING, RECEIPT_CREATION, REGISTER_CLOSURE;

    }

    static private final int VERSION = 2;

    static private final String VERSION_ATTR_NAME = "version";

    static final Element createRootElement() {

        return new Element("registerLog").setAttribute(VERSION_ATTR_NAME, String.valueOf(VERSION));

    }

    private final Path logFile;

    private Document parsed;

    private int version;

    private RegisterEntry opening;

    public RegisterLog(Path logFile) {

        super();

        this.logFile = logFile;

    }

    public final Path getLogFile() {

        return this.logFile;

    }

    public final RegisterLog parse() throws IOException, JDOMException {

        final Document doc = RegisterFiles.parse(this.logFile);

        final List<Element> elems = doc.getRootElement().getChildren();

        if (elems.isEmpty())

            throw new IllegalStateException("Empty log");

        final RegisterLogEntry firstEntry;

        try {

            firstEntry = RegisterLogEntry.parseEntry(elems.get(0));

        } catch (ParseException e) {

            throw new IOException(e);

        }

        if (firstEntry.getType() != EventType.REGISTER_OPENING)

            throw new IllegalStateException("Do not begin with " + EventType.REGISTER_OPENING + " : " + firstEntry);

        this.opening = (RegisterEntry) firstEntry;

        this.parsed = doc;

        this.version = Integer.parseInt(doc.getRootElement().getAttributeValue(VERSION_ATTR_NAME, "1"));

        return this;

    }

    public final Document getDocument() {

        return this.parsed;

    }

    public final int getVersion() {

        return this.version;

    }

    public final RegisterLogEntry getLastEvent() throws ParseException {

        return this.getEvent(-1);

    }

    public final RegisterLogEntry getEvent(final int index) throws ParseException {

        final List<Element> elems = this.parsed.getRootElement().getChildren();

        return RegisterLogEntry.parseEntry(elems.get(CollectionUtils.getValidIndex(elems, index, true)));

    }

    public final List<RegisterLogEntry> getAllEvents() throws ParseException {

        final List<Element> elems = this.parsed.getRootElement().getChildren();

        final List<RegisterLogEntry> res = new ArrayList<>();

        for (final Element elem : elems)

            res.add(RegisterLogEntry.parseEntry(elem));

        return res;

    }

    public final String getLastReceiptHash() throws ParseException {

        final ReceiptEntry lastReceiptCreationEvent = this.getLastReceiptCreationEvent();

        if (lastReceiptCreationEvent != null)

            return lastReceiptCreationEvent.getFileHash();

        else

            return this.getFirstRegisterEvent().getLastReceiptHash();

    }

    public final int getRegisterID() {

        return this.getFirstRegisterEvent().getRegisterID();

    }

    public final RegisterEntry getFirstRegisterEvent() {

        return this.opening;

    }

    public final RegisterEntry getLastRegisterEvent() throws ParseException {

        final RegisterLogEntry lastEvent = this.getLastEvent();

        if (lastEvent.getType() == EventType.REGISTER_CLOSURE)

            return (RegisterEntry) lastEvent;

        else

            return this.opening;

    }

    public final RegisterState getRegisterState() throws ParseException {

        final RegisterEntry lastRegisterEvent = this.getLastRegisterEvent();

        return new RegisterState(lastRegisterEvent.getType() == EventType.REGISTER_OPENING ? Status.OPEN : Status.CLOSED, lastRegisterEvent.getDate());

    }

    public final List<ReceiptEntry> getReceiptEvents() throws ParseException {

        final List<Element> elems = this.parsed.getRootElement().getChildren();

        final int size = elems.size();

        if (size <= 1)

            return Collections.emptyList();

        final List<ReceiptEntry> res = new ArrayList<>();

        for (final Element elem : elems.subList(1, size)) {

            final RegisterLogEntry parsedEntry = RegisterLogEntry.parseEntry(elem);

            if (parsedEntry instanceof ReceiptEntry) {

                res.add((ReceiptEntry) parsedEntry);

            } else if (parsedEntry.getType() == EventType.REGISTER_CLOSURE) {

                if (res.size() != size - 2)

                    throw new IllegalStateException("Closure not at the end : " + elems);

            } else {

                throw new IllegalStateException("Unexpected entry : " + parsedEntry);

            }

        }

        return res;

    }

    /**

     * Parse all receipts logged in this. This also validates that data recorded in this log matches

     * the parsed receipts' files.

     *

     * @return the list of current receipts in this.

     * @throws ParseException if an entry couldn't be parsed.

     * @throws IOException if the receipts couldn't be parsed.

     */

    public final List<Ticket> parseReceipts() throws ParseException, IOException {

        final List<Ticket> receipts = new ArrayList<>();

        final Path toUse = this.getLogFile().getParent();

        final List<ReceiptEntry> receiptEvents = this.getReceiptEvents();

        String lastHash = this.getFirstRegisterEvent().getLastReceiptHash();

        int index = 1;

        for (final ReceiptEntry receiptEntry : receiptEvents) {

            final Path receiptFile = toUse.resolve(receiptEntry.getCode().getFileName());

            final Ticket receipt;

            try {

                receipt = Ticket.parseFile(receiptFile.toFile(), HashMode.equalTo(receiptEntry.getFileHash()));

            } catch (Exception e) {

                throw new IOException("Couldn't parse file of " + receiptEntry + " : " + receiptFile, e);

            }

            assert receipt != null;

            if (!receipt.getCode().equals(receiptEntry.getCodeString()))

                throw new IllegalStateException("Code mismatch");

            if (!CompareUtils.equals(lastHash, receipt.getPreviousHash()))

                throw new IllegalStateException("Previous hash mismatch for " + receiptEntry.getCodeString());

            lastHash = receiptEntry.getFileHash();

            if (receipt.getNumber() != index)

                throw new IllegalStateException("Invalid index, expected " + index + " got " + receipt.getNumber());

            index++;

            if (receipt.getCreationDate().compareTo(receiptEntry.getDate()) != 0)

                throw new IllegalStateException("Date mismatch for " + receiptEntry.getCodeString() + " logged " + receiptEntry.getDate() + " but receipt " + receipt.getCreationDate());

            receipts.add(receipt);

        }

        return receipts;

    }

    public final ReceiptEntry getLastReceiptCreationEvent() throws ParseException {

        for (int i = -1; i >= -2; i--) {

            final RegisterLogEntry event = this.getEvent(i);

            if (event.getType() == EventType.REGISTER_OPENING) {

                return null;

            } else if (event.getType() == EventType.RECEIPT_CREATION) {

                return (ReceiptEntry) event;

            }

        }

        throw new IllegalStateException("2 " + EventType.REGISTER_CLOSURE);

    }

    @Override

    public String toString() {

        return this.getClass().getSimpleName() + " " + this.getLogFile() + " opened " + this.getFirstRegisterEvent().getDate();

    }

}