InstanceEditorController

package org.kuali.ole.editor.contoller;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;
import org.kuali.ole.OLEConstants;
import org.kuali.ole.docstore.model.xmlpojo.ingest.AdditionalAttributes;
import org.kuali.ole.docstore.model.xmlpojo.ingest.Response;
import org.kuali.ole.docstore.model.xmlpojo.work.instance.oleml.*;
import org.kuali.ole.docstore.model.xstream.ingest.ResponseHandler;
import org.kuali.ole.docstore.model.xstream.work.instance.oleml.WorkInstanceOlemlRecordProcessor;
import org.kuali.ole.editor.bo.InstanceEditorFormDataHandler;
import org.kuali.ole.editor.bo.InstanceRecordMetaData;
import org.kuali.ole.editor.bo.MarcEditorControlField;
import org.kuali.ole.editor.bo.MarcEditorDataField;
import org.kuali.ole.editor.form.InstanceEditorForm;
import org.kuali.ole.editor.service.DiscoveryHelperService;
import org.kuali.ole.editor.service.DocstoreHelperService;
import org.kuali.rice.krad.uif.UifParameters;
import org.kuali.rice.krad.web.controller.UifControllerBase;
import org.kuali.rice.krad.web.form.UifFormBase;
import org.springframework.stereotype.Controller;
import org.springframework.validation.BindingResult;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.*;

/**
 * InstanceEditorController is the controller class for Instance Editor
 */
@Controller
@RequestMapping(value = "/instanceeditor")

public class InstanceEditorController extends UifControllerBase {

    private DocstoreHelperService docstoreHelperService;
    private InstanceEditorFormDataHandler instanceEditorFormDataHandler;
    private DiscoveryHelperService discoveryHelperService;

    private static final Logger LOG = Logger.getLogger(InstanceEditorController.class);

    /**
     *   This method creates a instance of InstanceEditorForm
     * @param httpServletRequest
     * @return  InstanceEditorForm
     */
    @Override
    protected InstanceEditorForm createInitialForm(HttpServletRequest httpServletRequest) {
        return new InstanceEditorForm();
    }

    /**
     * This method takes the initial request when click on InstanceEditor Screen.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return  ModelAndView
     */
    @Override
    @RequestMapping(params = "methodToCall=start")
    public ModelAndView start(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                              HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        return super.start(instanceEditorForm, result, request, response);
    }

    @RequestMapping(method = RequestMethod.POST, params = "methodToCall=navigate")
    public ModelAndView navigate(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                 HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        String pageId = form.getActionParamaterValue(UifParameters.NAVIGATE_TO_PAGE_ID);

        return getUIFModelAndView(instanceEditorForm, pageId);
    }

    /**
     *  This method will fetch the holding/Item records based on the AdditionalAttributes.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return  ModelAndView
     */
    @RequestMapping(params = "methodToCall=loadInstanceRecord")
    public ModelAndView loadInstanceRecord(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                           HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        String instanceIdentifier = request.getParameter("uuid");
        if (null == instanceIdentifier || StringUtils.isEmpty(instanceIdentifier)) {
            instanceIdentifier = instanceEditorForm.getUuid();
        }
        instanceEditorForm.setExisting("true");
        try {
            String docStoreData = getDocstoreHelperService().getDocstoreData(instanceIdentifier);
            InstanceCollection instanceCollection = new WorkInstanceOlemlRecordProcessor().fromXML(docStoreData);
            instanceEditorForm.setInstance(instanceCollection.getInstance().get(0));
            instanceEditorForm.setSelectedHolding(instanceEditorForm.getInstance().getOleHoldings());
            if(instanceEditorForm.getInstance().getItems().getItem().size()>0)
                instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItems().getItem().get(0));
            if(instanceEditorForm.getInstance().getSourceHoldings() != null) {
                instanceEditorForm.setSelectedSourceHolding(
                        getInstanceEditorFormDataHandler().buildSourceHoldingForUI(instanceEditorForm));
            }

            getInstanceEditorFormDataHandler().setLocationDetails(instanceEditorForm);
            //Building Left Pane hierarchy
            getInstanceEditorFormDataHandler().buildLeftPaneData(instanceEditorForm);

            //Building MetaData fields
            if (instanceEditorForm.getInstance().getSourceHoldings() != null) {
                getInstanceEditorFormDataHandler().setMetaData(instanceEditorForm, OLEConstants.SOURCEHOLDINGS_DOC_TYPE);
            } else {
                getInstanceEditorFormDataHandler().setMetaData(instanceEditorForm, OLEConstants.HOLDING_DOC_TYPE);
            }
            if(instanceEditorForm.getInstance().getItems().getItem().size()>0)
                getInstanceEditorFormDataHandler().setMetaData(instanceEditorForm, OLEConstants.ITEM_DOC_TYPE);

            /*StringBuffer instanceEditorSuccessMessage = new StringBuffer(OLEConstants.INSTANCE_EDITOR_LOAD_SUCCESS);
            instanceEditorForm.setMessage(instanceEditorSuccessMessage.toString());*/
        } catch (Exception e) {
            StringBuffer instanceEditorErrorMessage = new StringBuffer(OLEConstants.INSTANCE_EDITOR_LOAD_FAILURE).append(" :: \n" + e.getMessage());
            instanceEditorForm.setMessage(instanceEditorErrorMessage.toString());
            LOG.error(instanceEditorErrorMessage);
        }
        return getUIFModelAndView(instanceEditorForm, OLEConstants.HOLDINGS_PAGE);
    }

    /**
     *  This method will ingest new record to docStore if uuid is null else it will update exisiting record.
     *  and nullify the form.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return  ModelAndView
     */
    @RequestMapping(params = "methodToCall=submit")
    public ModelAndView submit(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                               HttpServletRequest request, HttpServletResponse response) {
        String responseFromDocstore = null;
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        String uuid = instanceEditorForm.getUuid();
        String instanceEditorSuccessMessage = "";
        try {
            if (uuid != null && !uuid.trim().equals("")) {
                OleHoldings holdingData = instanceEditorForm.getInstance().getOleHoldings();
                String holdingId = instanceEditorForm.getInstance().getOleHoldings().getHoldingsIdentifier();
                String holdingXmlContent = getInstanceEditorFormDataHandler().buildHoldingContent(holdingData);
                String holdingRecordUpdateResponse =
                        getDocstoreHelperService().updateInstanceRecord(holdingId, OLEConstants.HOLDING_DOC_TYPE, holdingXmlContent);

                for (int item = 0; item < instanceEditorForm.getInstance().getItems().getItem().size(); item++) {
                    Item itemData = instanceEditorForm.getInstance().getItems().getItem().get(item);
                    String itemId = instanceEditorForm.getInstance().getItems().getItem().get(item).getItemIdentifier();
                    String itemXmlContent = getInstanceEditorFormDataHandler().buildItemContent(itemData);
                    if (itemId == null) {   //New Item
                        //TODO: Change logic to get Instance UUID. As we are loading existing Instance Identifier, we are getting directly from form
                        String instanceUuid = uuid;
                        String itemRecordUpdateResponse =
                                getDocstoreHelperService().createItemForInstanceRecord(instanceUuid, OLEConstants.ITEM_DOC_TYPE, itemXmlContent);
                    } else {
                        String itemRecordUpdateResponse =
                                getDocstoreHelperService().updateInstanceRecord(itemId, OLEConstants.ITEM_DOC_TYPE, itemXmlContent);
                    }
                }

                if (instanceEditorForm.getInstance().getSourceHoldings() != null) {
                    SourceHoldings sourceHoldings = getInstanceEditorFormDataHandler().buildSourceHoldings(instanceEditorForm);
                    String sourceHoldingId = sourceHoldings.getHoldingsIdentifier();
                    String sourceHoldinXml  =  getInstanceEditorFormDataHandler().buildSourceHoldingContent(sourceHoldings);
                    String sourceHoldingUpdateResponse =
                            getDocstoreHelperService().updateInstanceRecord(sourceHoldingId, "sourceHoldings", sourceHoldinXml);
                }
                loadInstanceRecord(instanceEditorForm, result, request, response);
                instanceEditorSuccessMessage = new String(OLEConstants.INSTANCE_EDITOR_SUCCESS);
            }  else {
                Instance instance = new Instance();
                instanceEditorForm.setInstance(instance);
                Item oleItem = instanceEditorForm.getSelectedItem();
                Items items = new Items();
                items.setItem(Arrays.asList(oleItem));
                instanceEditorForm.getInstance().setItems(items);
                instanceEditorForm.getSelectedHolding().setPrimary("true");
                instanceEditorForm.getInstance().setOleHoldings(instanceEditorForm.getSelectedHolding());
                String content =  getInstanceEditorFormDataHandler().buildInstanceRecordForDocStore(instanceEditorForm, uuid);
                responseFromDocstore = getDocstoreHelperService().
                        instanceRecordCallToDocstore(content, null, OLEConstants.OLEML_FORMAT);

                //Refreshing Editor after creating new instance record to load created instance uuid.
                Response dsResponse = new org.kuali.ole.docstore.model.xstream.ingest.ResponseHandler().toObject(responseFromDocstore);
                if (dsResponse.getStatus().toLowerCase().contains(OLEConstants.OLE_DOCSTORE_RESPONSE_STATUS)) {
                    String responseUUID = dsResponse.getDocuments().get(0).getUuid();
                    instanceEditorForm.setUuid(responseUUID);
                    loadInstanceRecord(instanceEditorForm, result, request, response);
                    instanceEditorSuccessMessage = OLEConstants.INSTANCE_EDITOR_SUCCESS;
                } else {
                    instanceEditorSuccessMessage = OLEConstants.INSTANCE_EDITOR_FAILURE;
                }
            }
            //instanceEditorForm.setUuid("");
            instanceEditorForm.setMessage(instanceEditorSuccessMessage);
        } catch (Exception e) {
            StringBuffer instanceEditorErrorMessage = new StringBuffer(OLEConstants.INSTANCE_EDITOR_FAILURE).append(" :: \n" + e.getMessage());
            instanceEditorForm.setMessage(instanceEditorErrorMessage.toString());
            LOG.error(instanceEditorErrorMessage);
        }
        return getUIFModelAndView(form);
    }

    /**
     *   This Method will update the Left Pane hierarchy details.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return  ModelAndView
     */
    @RequestMapping(params = "methodToCall=updateLeftPane")
    public ModelAndView updateLeftPane(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                       HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        String hiddenVal = instanceEditorForm.getHdnUuid();
        int hdnIndex = instanceEditorForm.getHdnIndex();
        instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItems().getItem().get(hdnIndex));
        DiscoveryHelperService discoveryHelperService = getDiscoveryHelperService();

        List responseFromSOLR =  discoveryHelperService.getResponseFromSOLR("id", hiddenVal);
        LOG.info("solr response:"+responseFromSOLR.toString());
        LOG.info("solr response size:"+responseFromSOLR.size());
        String docType = null;
        for (Iterator iterator = responseFromSOLR.iterator(); iterator.hasNext(); ) {
            Map map = (Map) iterator.next();
            if (map.containsKey(OLEConstants.DOC_TYPE)) {
                String list = (String) map.get(OLEConstants.DOC_TYPE);
                docType = list;
                break;
            }
        }
        if ((docType.toString().equals(OLEConstants.ITEM_DOC_TYPE))) {
            getInstanceEditorFormDataHandler().setMetaData(instanceEditorForm, OLEConstants.ITEM_DOC_TYPE);

            return getUIFModelAndView(instanceEditorForm, OLEConstants.ITEM_PAGE);
        } else {
            return getUIFModelAndView(instanceEditorForm, OLEConstants.HOLDINGS_PAGE);
        }
    }

    /**
     * This method adds the existingItem records from docStore in to oleItems and it will be set in InstanceEditorForm.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return ModelAndView
     */
    @RequestMapping(method = RequestMethod.POST,params = "methodToCall=addNewItem")
    public ModelAndView addItemRecord(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                      HttpServletRequest request, HttpServletResponse response){
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        List<Item> existingItemsFromDoc = instanceEditorForm.getInstance().getItems().getItem();
        List<Item> oleItems = new ArrayList<Item>();

        for(int i=0;i<existingItemsFromDoc.size();i++){
            oleItems.add(existingItemsFromDoc.get(i));
        }
        oleItems.add(new Item());
        instanceEditorForm.setItemRecordMetaData(new InstanceRecordMetaData());
        instanceEditorForm.getInstance().getItems().setItem(oleItems);
        instanceEditorForm.setHdnIndex(oleItems.size());
        int hdnIndex = instanceEditorForm.getHdnIndex();
        instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItems().getItem().get(hdnIndex-1));
        return getUIFModelAndView(instanceEditorForm, OLEConstants.ITEM_PAGE);
    }


    @RequestMapping(method =  RequestMethod.POST,params = "methodToCall=deleteInstance")
    public ModelAndView deleteInstance(@ModelAttribute("KualiForm") UifFormBase form,BindingResult result,HttpServletRequest request,HttpServletResponse response) throws Exception {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        Instance instance = instanceEditorForm.getInstance();
        LOG.info("instance-->"+instance.getInstanceIdentifier());
        StringBuffer instanceEditorSuccessMessage = new StringBuffer(OLEConstants.INSTANCE_EDITOR_DELETE_SUCCESS);
        instanceEditorForm.setMessage(instanceEditorSuccessMessage.toString());
        String deleteResponse = getDocstoreHelperService().deleteInstanceRecord(instance);
        LOG.info("delete response-->" + deleteResponse);
        Response responseObj = new ResponseHandler().toObject(deleteResponse);
        if (responseObj.getStatus().toLowerCase().contains(OLEConstants.OLE_DOCSTORE_RESPONSE_STATUS)) {
            instanceEditorForm.setMessage(OLEConstants.INSTANCE_EDITOR_DELETE_SUCCESS);
        }
        else {
            instanceEditorForm.setMessage(OLEConstants.INSTANCE_EDITOR_DELETE_FAILURE);
        }
        return getUIFModelAndView(instanceEditorForm, OLEConstants.HOLDINGS_PAGE);
    }

    /**
     * This method will get new itemData
     * @param form
     * @param result
     * @param request
     * @param response
     * @return
     */
    @RequestMapping(method = RequestMethod.POST,params = "methodToCall=getNewItemData")
    public ModelAndView getNewItemData(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                       HttpServletRequest request, HttpServletResponse response){
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        List<Item> existingItemsFromDoc = instanceEditorForm.getInstance().getItems().getItem();
        List<Item> oleItems = new ArrayList<Item>();

        for(int i=0;i<existingItemsFromDoc.size();i++){
            oleItems.add(existingItemsFromDoc.get(i));
        }
        instanceEditorForm.setHdnIndex(oleItems.size());
        int hdnIndex = instanceEditorForm.getHdnIndex();
        instanceEditorForm.setSelectedItem(instanceEditorForm.getInstance().getItems().getItem().get(hdnIndex-1));
        return getUIFModelAndView(instanceEditorForm, OLEConstants.ITEM_PAGE);
    }

    /**
     *  Used for Test-case
     * @param result
     * @param request
     * @param response
     * @param instanceEditorForm
     * @return ModelAndView
     */
    protected ModelAndView callSuper(BindingResult result, HttpServletRequest request, HttpServletResponse response, InstanceEditorForm instanceEditorForm) {
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    /**
     *  Gets the docstoreHelperService attribute
     * @return  Returns DocstoreHelperService
     */
    private DocstoreHelperService getDocstoreHelperService() {
        if (null == docstoreHelperService) {
            return new DocstoreHelperService();
        }
        return docstoreHelperService;
    }

    /**
     *    Sets the docstoreHelperService attribute values.
     * @param docstoreHelperService
     */
    public void setDocstoreHelperService(DocstoreHelperService docstoreHelperService) {
        this.docstoreHelperService = docstoreHelperService;
    }

    /**
     *  Gets the InstanceEditorFormDataHandler attribute.
     * @return Returns InstanceEditorFormDataHandler.
     */
    private InstanceEditorFormDataHandler getInstanceEditorFormDataHandler() {
        if (null == instanceEditorFormDataHandler) {
            instanceEditorFormDataHandler = new InstanceEditorFormDataHandler();
        }
        return instanceEditorFormDataHandler;
    }

    /**
     *  This method returns AdditionalAttributes instance from the list of Extension.
     * @param extensionList
     * @return  AdditionalAttributes
     */
    private AdditionalAttributes getFirstAdditionalAttributes(List<Extension> extensionList) {
        for (Extension ext : extensionList) {
            for (Object obj : ext.getContent()) {
                if (obj instanceof AdditionalAttributes) {
                    return (AdditionalAttributes) obj;
                }
            }
        }
        return null;
    }

    /**
     * Sets the discoveryHelperService attribute value.
     * @param discoveryHelperService
     */
    public void setDiscoveryHelperService(DiscoveryHelperService discoveryHelperService) {
        this.discoveryHelperService = discoveryHelperService;
    }

    /**
     *  Gets the discoveryHelperService attribute.
     * @return Returns DiscoveryHelperService.
     */
    public DiscoveryHelperService getDiscoveryHelperService() {
        if (null == discoveryHelperService) {
            return new DiscoveryHelperService();
        }
        return discoveryHelperService;
    }

    /*@RequestMapping(params = "methodToCall=addExtentOfOwnership")
    public ModelAndView addExtentOfOwnership(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                             HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        index++;
        List<ExtentOfOwnership> extentOfOwnershipForUI = instanceEditorForm.getSelectedHolding().getExtentOfOwnership();
        extentOfOwnershipForUI.add(index, new ExtentOfOwnership());
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    @RequestMapping(params = "methodToCall=removeExtentOfOwnership")
    public ModelAndView removeExtentOfOwnership(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                                HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        List<ExtentOfOwnership> extentOfOwnershipForUI = instanceEditorForm.getSelectedHolding().getExtentOfOwnership();
        if (extentOfOwnershipForUI.size() > 1)
            extentOfOwnershipForUI.remove(index);
        return super.updateComponent(instanceEditorForm, result, request, response);
    }*/

    @RequestMapping(params = "methodToCall=addAccessInformation")
    public ModelAndView addAccessInformation(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                             HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        index++;
        List<Uri> accessInformation = instanceEditorForm.getSelectedHolding().getUri();
        accessInformation.add(index, new Uri());
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    @RequestMapping(params = "methodToCall=removeAccessInformation")
    public ModelAndView removeAccessInformation(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                                HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        List<Uri> accessInformation = instanceEditorForm.getSelectedHolding().getUri();
        if (accessInformation.size() > 1)
            accessInformation.remove(index);
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    @RequestMapping(params = "methodToCall=addHoldingNotes")
    public ModelAndView addHoldingNotes(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                        HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        index++;
        List<Note> holdingsNote = instanceEditorForm.getSelectedHolding().getNote();
        holdingsNote.add(index, new Note());
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    @RequestMapping(params = "methodToCall=removeHoldingNotes")
    public ModelAndView removeHoldingNotes(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                           HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        List<Note> holdingsNote = instanceEditorForm.getSelectedHolding().getNote();
        if (holdingsNote.size() > 1)
            holdingsNote.remove(index);
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    /**
     * This method will add the controlField record based on the selected Line index and updates the component.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return  ModelAndView
     */
    @RequestMapping(params = "methodToCall=addControlField")
    public ModelAndView addControlField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                        HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        index++;
        List<MarcEditorControlField> marcEditorControlFieldList = instanceEditorForm.getSelectedSourceHolding().getControlFields();
        marcEditorControlFieldList.add(index, new MarcEditorControlField());
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    /**
     *  This method will remove the controlField based on the index position and updates the component.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return  ModelAndView
     */
    @RequestMapping(params = "methodToCall=removeControlField")
    public ModelAndView removeControlField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                           HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        List<MarcEditorControlField> editorControlFieldList = instanceEditorForm.getSelectedSourceHolding().getControlFields();
        if (editorControlFieldList.size() > 1)
            editorControlFieldList.remove(index);
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    /**
     *  This method will add the datField record based on the selected Line index and updates the component.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return ModelAndView
     */
    @RequestMapping(params = "methodToCall=addDataField")
    public ModelAndView addDataField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                     HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        index++;
        List<MarcEditorDataField> editorDataFieldList = instanceEditorForm.getSelectedSourceHolding().getDataFields();
        editorDataFieldList.add(index, new MarcEditorDataField());
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    /**
     *    This method will remove the dataField based on the index position and updates the component.
     * @param form
     * @param result
     * @param request
     * @param response
     * @return ModelAndView
     */
    @RequestMapping(params = "methodToCall=removeDataField")
    public ModelAndView removeDataField(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                        HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        List<MarcEditorDataField> marcEditorDataFieldList = instanceEditorForm.getSelectedSourceHolding().getDataFields();
        if (marcEditorDataFieldList.size() > 1)
            marcEditorDataFieldList.remove(index);
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    @RequestMapping(method = RequestMethod.POST, params = "methodToCall=deleteItem")
    public ModelAndView deleteItem(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                   HttpServletRequest request, HttpServletResponse response) throws Exception {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        String id = instanceEditorForm.getDeleteItemId();
        String[] ids = id.split("_");
        String itemUuid = ids[0];
        String docstoreResponse = getDocstoreHelperService().deleteItemrecord(itemUuid);
        Response responseObj = new ResponseHandler().toObject(docstoreResponse);
        if (responseObj.getStatus().toLowerCase().contains(OLEConstants.OLE_DOCSTORE_RESPONSE_STATUS)) {
            instanceEditorForm.setMessage(OLEConstants.INSTANCE_EDITOR_DELETE_SUCCESS);
            loadInstanceRecord(instanceEditorForm, result, request, response);
        }
        else {
            instanceEditorForm.setMessage(OLEConstants.INSTANCE_EDITOR_DELETE_FAILURE);
        }
        return getUIFModelAndView(instanceEditorForm, OLEConstants.HOLDINGS_PAGE);
    }

    @RequestMapping(params = "methodToCall=addExtentOfOwnership")
    public ModelAndView addExtentOfOwnership(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                             HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        index++;
        List<ExtentOfOwnership> extentOfOwnershipForUI = instanceEditorForm.getSelectedHolding().getExtentOfOwnership();
        ExtentOfOwnership extentOfOwnership = new ExtentOfOwnership();
        extentOfOwnership.getNote().add(new Note());
        extentOfOwnershipForUI.add(index, extentOfOwnership);
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    @RequestMapping(params = "methodToCall=removeExtentOfOwnership")
    public ModelAndView removeExtentOfOwnership(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                                HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        List<ExtentOfOwnership> extentOfOwnershipForUI = instanceEditorForm.getSelectedHolding().getExtentOfOwnership();
        if (extentOfOwnershipForUI.size() > 1) {
            extentOfOwnershipForUI.remove(index);
        }
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    @RequestMapping(params = "methodToCall=addEOWHoldingNotes")
    public ModelAndView addEOWHoldingNotes(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                           HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        String selectedPath = form.getActionParamaterValue(UifParameters.SELLECTED_COLLECTION_PATH);
        int selectedExtentIndex = Integer.parseInt(StringUtils.substring(selectedPath,
                                                                         (StringUtils.indexOf(selectedPath, "[") + 1),
                                                                         StringUtils.lastIndexOf(selectedPath, "]")));
        index++;
        List<Note> holdingsNote = instanceEditorForm.getSelectedHolding().getExtentOfOwnership()
                                                    .get(selectedExtentIndex).getNote();
        holdingsNote.add(index, new Note());
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

    @RequestMapping(params = "methodToCall=removeEOWHoldingNotes")
    public ModelAndView removeEOWHoldingNotes(@ModelAttribute("KualiForm") UifFormBase form, BindingResult result,
                                              HttpServletRequest request, HttpServletResponse response) {
        InstanceEditorForm instanceEditorForm = (InstanceEditorForm) form;
        int index = Integer.parseInt(form.getActionParamaterValue(UifParameters.SELECTED_LINE_INDEX));
        String selectedPath = form.getActionParamaterValue(UifParameters.SELLECTED_COLLECTION_PATH);
        int selectedExtentIndex = Integer.parseInt(StringUtils.substring(selectedPath,
                                                                         (StringUtils.indexOf(selectedPath, "[") + 1),
                                                                         StringUtils.lastIndexOf(selectedPath, "]")));
        List<Note> holdingsNote = instanceEditorForm.getSelectedHolding().getExtentOfOwnership()
                                                    .get(selectedExtentIndex).getNote();
        if (holdingsNote.size() > 1) {
            holdingsNote.remove(index);
        }
        return super.updateComponent(instanceEditorForm, result, request, response);
    }

}