CheckinManager

/*
 * Copyright 2011 The Kuali Foundation.
 *
 * Licensed under the Educational Community License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.opensource.org/licenses/ecl2.php
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.kuali.ole.repository;

import java.io.ByteArrayInputStream;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Iterator;
import java.util.List;

import javax.jcr.Binary;
import javax.jcr.Node;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.version.VersionHistory;
import javax.jcr.version.VersionIterator;
import javax.jcr.version.VersionManager;

import org.kuali.ole.RepositoryManager;
import org.kuali.ole.docstore.DocStoreConstants;
import org.kuali.ole.docstore.model.enums.DocType;
import org.kuali.ole.docstore.model.xmlpojo.ingest.RequestDocument;
import org.kuali.ole.docstore.model.xmlpojo.work.instance.oleml.OleHolding;
import org.kuali.ole.docstore.model.xmlpojo.work.instance.oleml.OleItem;
import org.kuali.ole.docstore.model.xstream.work.instance.oleml.WorkHoldingOlemlRecordProcessor;
import org.kuali.ole.docstore.model.xstream.work.instance.oleml.WorkItemOlemlRecordProcessor;
import org.kuali.ole.docstore.service.ServiceLocator;
import org.kuali.ole.logger.DocStoreLogger;
import org.kuali.ole.pojo.OleException;

import static org.kuali.ole.docstore.process.ProcessParameters.FILE_ITEM;

public class CheckinManager {
    private static final String XML_DECL = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>";
    DocStoreLogger docStoreLogger = new DocStoreLogger(this.getClass().getName());
     private static final org.apache.log4j.Logger LOG  = org.apache.log4j.Logger.getLogger(CheckinManager.class);

    public String updateContent(RequestDocument requestDocument) throws OleException {
        List<String> ingestDocs = new ArrayList<String>();
        List<String> uuids = new ArrayList<String>();
        StringBuilder sb = new StringBuilder();
        String uuid = null;
        String content = null;
        String latestVersion = null;
        content = requestDocument.getContent().getContent();
        requestDocument.setUuid(requestDocument.getId());
        uuid = requestDocument.getId();
        ingestDocs.add(sb.toString());
        uuids.add(uuid);
        if (DocType.INSTANCE.getCode().equalsIgnoreCase(requestDocument.getType())
            && content == null && requestDocument.getId() != null ) {
            for(RequestDocument linkedItemDocument : requestDocument.getLinkedRequestDocuments()){
                if(DocType.ITEM.getCode().equalsIgnoreCase(linkedItemDocument.getType())
                     && linkedItemDocument.getContent().getContent() != null){
                     ingestNIndexItemRecForInstance(requestDocument);
                }
            }
        }
        try {
            ServiceLocator.getIndexerService().indexDocument(requestDocument);
            try {
                latestVersion = updateRecordInDocStore(requestDocument);
            }
            catch (Exception e) {
                ServiceLocator.getIndexerService().deleteDocument(uuid, requestDocument.getCategory());
                e.printStackTrace();
                throw new OleException(e);
            }
        }
        catch (Exception e) {
            docStoreLogger.log(e.getMessage());
            throw new OleException(e.getMessage());
        }
        return latestVersion;
    }

    private void ingestNIndexItemRecForInstance(RequestDocument reqDoc) throws OleException {
        try {
            Session session = RepositoryManager.getRepositoryManager().getSession("CheckinManager","ingestNIndexItemRecForInstance");
            Node nodeByUUID = getNodeByUUID(session, reqDoc.getId());
            Node holdingsNode = nodeByUUID.getNode("holdings");
            NodeHandler nodeHandler = new NodeHandler();

            for(RequestDocument linkedItemDocument : reqDoc.getLinkedRequestDocuments()){
             WorkItemOlemlRecordProcessor recordProcessor = new WorkItemOlemlRecordProcessor();
             OleItem item = recordProcessor.fromXML(linkedItemDocument.getContent().getContent());
             linkedItemDocument.getContent().setContentObject(item);
            String uuid = (nodeHandler.initFileNode(linkedItemDocument, FILE_ITEM, holdingsNode,
                                                    session)).getIdentifier();
            linkedItemDocument.setId(uuid);
            }
            session.save();
        }
        catch (Exception e) {
           docStoreLogger.log(e.getMessage());
           throw new OleException(e.getMessage(), e);
        }
    }


    private String updateRecordInDocStore(RequestDocument reqDoc) throws OleException, RepositoryException {
        Session session = RepositoryManager.getRepositoryManager().getSession("CheckinManager","updateRecordInDocStore");
        String charset = "UTF-8";
        byte[] documentBytes = null;
        String currentVersion = null;
        try {
            if(reqDoc.getContent().getContent() != null){
                setIdentifierValueInContent(reqDoc);
                documentBytes = reqDoc.getContent().getContent().getBytes(charset);
            }
        }
        catch (Exception e) {
            getDocStoreLogger().log("Failed to convert input string to byte[] with charset " + charset, e);
            throw new OleException(e.getMessage());
        }
        RequestDocument linkReqInfo = new RequestDocument();
         if (reqDoc.getLinkedRequestDocuments() != null && reqDoc.getLinkedRequestDocuments().size() > 0) {
            for (Iterator<RequestDocument> linkIterator = reqDoc.getLinkedRequestDocuments().iterator(); linkIterator.hasNext(); ) {
                linkReqInfo = linkIterator.next();
            }
        }
        Node nodeByUUID = getNodeByUUID(session, reqDoc.getId());
        try {
            Binary binary = null;
            if (documentBytes != null) {
                binary = session.getValueFactory().createBinary(new ByteArrayInputStream(documentBytes));
                nodeByUUID.getNode("jcr:content").setProperty("jcr:data", binary);
            }
            if (linkReqInfo != null && linkReqInfo.getId() != null && linkReqInfo.getType().equalsIgnoreCase(DocType.INSTANCE.getCode())) {
                nodeByUUID.setProperty("instanceIdentifier", linkReqInfo.getId());
            }
            Calendar lastModified = Calendar.getInstance();
            lastModified.setTimeInMillis(lastModified.getTimeInMillis());
            if(!reqDoc.getType().equalsIgnoreCase(DocType.INSTANCE.getCode())){
               nodeByUUID.getNode("jcr:content").setProperty("jcr:lastModified", lastModified);
            }
            session.save();
            if (DocStoreConstants.isVersioningEnabled) {
                VersionManager versionManager = getVersionManager(session);
                versionManager.checkpoint(nodeByUUID.getPath());
                VersionHistory versionHistory = versionManager.getVersionHistory(nodeByUUID.getPath());
                VersionIterator allVersions = versionHistory.getAllVersions();
                while (allVersions.hasNext()) {
                    currentVersion = allVersions.nextVersion().getName();
                }
                getDocStoreLogger().log("Version updated for UUID:" + reqDoc.getUuid() + "  ====  version:" + currentVersion);
            }
        }
        catch (Exception e) {
            docStoreLogger.log(e.getMessage());
            throw new OleException(e.getMessage());
        }
        finally {
            RepositoryManager.getRepositoryManager().logout(session);
        }
        return currentVersion;
    }

    private void setIdentifierValueInContent(RequestDocument reqDoc) {
        if (reqDoc.getType().equalsIgnoreCase(DocType.ITEM.getCode())) {
            WorkItemOlemlRecordProcessor recordProcessor = new WorkItemOlemlRecordProcessor();
            OleItem item = recordProcessor.fromXML(reqDoc.getContent().getContent());
            item.setItemIdentifier(reqDoc.getId());
            reqDoc.getContent().setContent(recordProcessor.toXML(item));
        }
        if (reqDoc.getType().equalsIgnoreCase(DocType.HOLDINGS.getDescription())) {
            WorkHoldingOlemlRecordProcessor recordProcessor = new WorkHoldingOlemlRecordProcessor();
            OleHolding holdings = recordProcessor.fromXML(reqDoc.getContent().getContent());
            holdings.setHoldingsIdentifier(reqDoc.getId());
            reqDoc.getContent().setContent(recordProcessor.toXML(holdings));
        }
    }

    private Node getNodeByUUID(Session newSession, String uuid)
            throws OleException {
        return new NodeHandler().getNodeByUUID(newSession, uuid);
    }

    public DocStoreLogger getDocStoreLogger() {
        return docStoreLogger;
    }

    public VersionManager getVersionManager(Session session)
            throws OleException, RepositoryException {
        return session.getWorkspace().getVersionManager();
    }
}