import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * Verifies that the note's fields are valid - it does required and format checks.
 *
 * @param note
 * @return boolean True if the document description is valid, false otherwise.
 */
public boolean isNoteValid(Note note) {
    // add the error path keys on the stack
    GlobalVariables.getMessageMap().addToErrorPath(UifPropertyPaths.NEW_COLLECTION_LINES
            + "['"
            + KRADConstants.DOCUMENT_PROPERTY_NAME
            + "."
            + KRADConstants.NOTES_PROPERTY_NAME
            + "']");

    // check the document header for fields like the description
    getDictionaryValidationService().validateBusinessObject(note);

    validateSensitiveDataValue(KRADConstants.NOTE_TEXT_PROPERTY_NAME, note.getNoteText(),
            getDataDictionaryService().getAttributeLabel(Note.class, KRADConstants.NOTE_TEXT_PROPERTY_NAME));

    // drop the error path keys off now
    GlobalVariables.getMessageMap().removeFromErrorPath(UifPropertyPaths.NEW_COLLECTION_LINES
            + "['"
            + KRADConstants.DOCUMENT_PROPERTY_NAME
            + "."
            + KRADConstants.NOTES_PROPERTY_NAME
            + "']");

    return GlobalVariables.getMessageMap().hasNoErrors();
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
@Override
public void moveAttachmentWherePending(Note note) {
   	if (note == null) {
   		throw new IllegalArgumentException("Note must be non-null");
   	}
   	if (StringUtils.isBlank(note.getObjectId())) {
   		throw new IllegalArgumentException("Note does not have a valid object id, object id was null or empty");
   	}
   	Attachment attachment = note.getAttachment();
   	if(attachment!=null){
   		try {
   			moveAttachmentFromPending(attachment, note.getRemoteObjectIdentifier());
   		}
   		catch (IOException e) {
   			throw new RuntimeException("Problem moving pending attachment to final directory");
   		}
   	}
   }
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
    * @see org.kuali.rice.krad.service.NoteService#save(org.kuali.rice.krad.bo.Note)
    */
   @Override
public Note save(Note note) {
   	validateNoteNotNull(note);
   	if (StringUtils.isBlank(note.getRemoteObjectIdentifier())) {
   		throw new IllegalStateException("The remote object identifier must be established on a Note before it can be saved.  Given note had a null or empty remote object identifier.");
   	}
       if (note.getAttachment() != null && note.getAttachment().getAttachmentFileName() == null) {
           note.setAttachment(null);
       }
       if (note != null && note.getNoteIdentifier() == null && note.getAttachment() != null) {
           Attachment attachment = note.getAttachment();
           note.setAttachment(null);
           // store without attachment
           note = dataObjectService.save(note);
           attachment.setNoteIdentifier(note.getNoteIdentifier());
           // put attachment back
           note.setAttachment(attachment);
       }
       note = dataObjectService.save(note);
       // move attachment from pending directory
       if (note.getAttachment() != null) {
       	attachmentService.moveAttachmentWherePending(note);
       }
       return note;
   }
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
    * TODO this method seems awfully out of place in this service
    *
    */
   @Override
public Note createNote(Note noteToCopy, GloballyUnique bo, String authorPrincipalId) {
   	validateNoteNotNull(noteToCopy);
   	if (bo == null) {
   		throw new IllegalArgumentException("The bo must not be null.");
   	}
   	if (StringUtils.isBlank(authorPrincipalId)) {
   		throw new IllegalArgumentException("The authorPrincipalId must not be null.");
   	}

       Note tmpNote = new CopiedObject<Note>(noteToCopy).getContent();
       tmpNote.setRemoteObjectIdentifier(bo.getObjectId());
       tmpNote.setAuthorUniversalIdentifier(authorPrincipalId);

       return tmpNote;
   }
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.DocumentService#disapproveDocument(org.kuali.rice.krad.document.Document,
 *      java.lang.String)
 */
@Override
public Document disapproveDocument(Document document, String annotation) throws Exception {
    checkForNulls(document);

    Note note = createNoteFromDocument(document, annotation);
    //if note type is BO, override and link disapprove notes to Doc Header
    if (document.getNoteType().equals(NoteType.BUSINESS_OBJECT)) {
        note.setNoteTypeCode(NoteType.DOCUMENT_HEADER.getCode());
        note.setRemoteObjectIdentifier(document.getDocumentHeader().getObjectId());
    }
    document.addNote(note);

    //SAVE THE NOTE
    //Note: This save logic is replicated here and in KualiDocumentAction, when to save (based on doc state) should be moved
    //      into a doc service method
    getNoteService().save(note);

    prepareWorkflowDocument(document);
    getWorkflowDocumentService().disapprove(document.getDocumentHeader().getWorkflowDocument(), annotation);
    UserSessionUtils.addWorkflowDocument(GlobalVariables.getUserSession(),
            document.getDocumentHeader().getWorkflowDocument());
    removeAdHocPersonsAndWorkgroups(document);
    return document;
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
@Override
public Document recallDocument(Document document, String annotation, boolean cancel) throws WorkflowException {
    checkForNulls(document);
    WorkflowDocument workflowDocument = KRADServiceLocatorWeb.getDocumentService().
            getByDocumentHeaderId(document.getDocumentNumber()).getDocumentHeader().getWorkflowDocument();

    if (!workflowDocument.isFinal() && !workflowDocument.isProcessed()) {
        Note note = createNoteFromDocument(document, annotation);
        document.addNote(note);
        getNoteService().save(note);
    }

    prepareWorkflowDocument(document);
    getWorkflowDocumentService().recall(document.getDocumentHeader().getWorkflowDocument(), annotation, cancel);
    UserSessionUtils.addWorkflowDocument(GlobalVariables.getUserSession(),
            document.getDocumentHeader().getWorkflowDocument());
    removeAdHocPersonsAndWorkgroups(document);
    return document;
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * Loads the Notes for the note target on this Document.
 *
 * @param document the document for which to load the notes
 */
protected void loadNotes(final Document document) {
    if (isNoteTargetReady(document)) {
        Object legacyObjectClass;
        if (document instanceof MaintenanceDocument) {
            MaintenanceDocument mdoc = (MaintenanceDocument) document;
            legacyObjectClass = ((Maintainable) org.apache.commons.lang.ObjectUtils.defaultIfNull(mdoc.getOldMaintainableObject(), mdoc.getNewMaintainableObject())).getDataObjectClass();
        } else {
            legacyObjectClass = document.getClass();
        }

        List<Note> notes = new ArrayList<Note>();
        if (StringUtils.isNotBlank(document.getNoteTarget().getObjectId())) {
            notes.addAll(getNoteService().getByRemoteObjectId(document.getNoteTarget().getObjectId()));
        }
        //notes created on 'disapprove' are linked to Doc Header, so this checks that even if notetype = BO
        if (document.getNoteType().equals(NoteType.BUSINESS_OBJECT) && document.getDocumentHeader()
                .getWorkflowDocument().isDisapproved()) {
            notes.addAll(getNoteService().getByRemoteObjectId(document.getDocumentHeader().getObjectId()));
        }

        document.setNotes(notes);
    }
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * @see org.kuali.rice.krad.service.DocumentService#createNoteFromDocument(org.kuali.rice.krad.document.Document,
 *      java.lang.String)
 */
@Override
public Note createNoteFromDocument(Document document, String text) {
    Note note = new Note();

    note.setNotePostedTimestamp(getDateTimeService().getCurrentTimestamp());
    note.setNoteText(text);
    note.setNoteTypeCode(document.getNoteType().getCode());

    GloballyUnique bo = document.getNoteTarget();
    // TODO gah! this is awful
    Person kualiUser = GlobalVariables.getUserSession().getPerson();
    if (kualiUser == null) {
        throw new IllegalStateException("Current UserSession has a null Person.");
    }
    return bo == null ? null : getNoteService().createNote(note, bo, kualiUser.getPrincipalId());
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * In the case of edit maintenance adds a new blank line to the old side
 * This method is intended to override the method in MaintainableImpl
 * but has a different set of parameters, so it is not actually an override.
 * This version was needed to fetch the old collection from a different path
 * than MaintainableImpl uses.
 *
 * @see org.kuali.rice.krad.uif.service.impl.ViewHelperServiceImpl#processAfterAddLine(org.kuali.rice.krad.uif.view.View,
 * org.kuali.rice.krad.uif.container.CollectionGroup, Object, Object, boolean)
 */
@Override
public void processAfterAddLine(ViewModel model, Object addLine, String collectionId, String collectionPath,
            boolean isValidLine) {
    // Check for maintenance documents in edit but exclude notes
    if (model instanceof MaintenanceDocumentForm
            && KRADConstants.MAINTENANCE_EDIT_ACTION.equals(((MaintenanceDocumentForm)model).getMaintenanceAction()) && !(addLine instanceof Note)) {

        Class<?> collectionObjectClass = (Class<?>) model.getViewPostMetadata().getComponentPostData(collectionId,
                UifConstants.PostMetadata.COLL_OBJECT_CLASS);

        // get the old object's collection
        String oldCollectionPath = collectionPath.replace("newMaintainableObject","oldMaintainableObject");
        Collection<Object> oldCollection = ObjectPropertyUtils.getPropertyValue(model, oldCollectionPath );
        try {
            Object blankLine = collectionObjectClass.newInstance();
            oldCollection.add(blankLine);
        } catch (Exception e) {
            throw new RuntimeException("Unable to create new line instance for old maintenance object", e);
        }
    }
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * Downloads the selected attachment to the user's browser
 *
 * @param mapping
 * @param form
 * @param request
 * @param response
 * @return ActionForward
 * @throws Exception
 */
public ActionForward downloadBOAttachment(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    Long noteIdentifier = Long.valueOf(request.getParameter(KRADConstants.NOTE_IDENTIFIER));

    Note note = this.getNoteService().getNoteByNoteId(noteIdentifier);
    if(note != null){
    	Attachment attachment = note.getAttachment();
    	if(attachment != null){
    		//make sure attachment is setup with backwards reference to note (rather then doing this we could also just call the attachment service (with a new method that took in the note)
    		attachment.setNote(note);
    		WebUtils.saveMimeInputStreamAsFile(response, attachment.getAttachmentMimeTypeCode(), attachment.getAttachmentContents(), attachment.getAttachmentFileName(), attachment.getAttachmentFileSize().intValue());
    	}
    	return null;
    }
    
    return mapping.findForward(RiceConstants.MAPPING_BASIC);
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * Downloads the selected attachment to the user's browser
 *
 * @param mapping
 * @param form
 * @param request
 * @param response
 * @return ActionForward
 * @throws Exception
 */
public ActionForward downloadBOAttachment(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {
    KualiDocumentFormBase documentForm = (KualiDocumentFormBase) form;

    int attachmentIndex = selectedAttachmentIndex(request);
    if (attachmentIndex >= 0) {
        Note note = documentForm.getDocument().getNote(attachmentIndex);
        Attachment attachment = note.getAttachment();
        //make sure attachment is setup with backwards reference to note (rather then doing this we could also just call the attachment service (with a new method that took in the note)
        attachment.setNote(note);

        // since we're downloading a file, all of the editable properties from the previous request will continue to be editable.
        documentForm.copyPopulateEditablePropertiesToActionEditableProperties();

        WebUtils.saveMimeInputStreamAsFile(response, attachment.getAttachmentMimeTypeCode(), attachment.getAttachmentContents(), attachment.getAttachmentFileName(), attachment.getAttachmentFileSize().intValue());
        return null;
    }

    return mapping.findForward(RiceConstants.MAPPING_BASIC);
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
protected void addMaintenanceLockedNotes(String documentNumber, Map<SubObjectCode, String> lockedSubObjects, String messageKey, PersistableBusinessObject noteParent, Note noteTemplate) {
    for (Map.Entry<SubObjectCode, String> entry : lockedSubObjects.entrySet()) {
        try {
            SubObjectCode subObjCd = entry.getKey();
            String subObjectString = subObjCd.getUniversityFiscalYear() + " - " + subObjCd.getChartOfAccountsCode() + " - " + subObjCd.getAccountNumber() + " - " + subObjCd.getFinancialObjectCode() + " - " + subObjCd.getFinancialSubObjectCode();
            if (StringUtils.isNotBlank(subObjectString)) {
                String noteTextTemplate = kualiConfigurationService.getPropertyValueAsString(messageKey);
                String noteText = MessageFormat.format(noteTextTemplate, subObjectString, entry.getValue());
                Note note = noteService.createNote(noteTemplate, noteParent, GlobalVariables.getUserSession().getPrincipalId());
                note.setNoteText(noteText);
                note.setNotePostedTimestampToCurrent();
                noteService.save(note);
            }
        }
        catch (Exception e) {
            LOG.error("Unable to create/save notes for document " + documentNumber, e);
            throw new RuntimeException("Unable to create/save notes for document " + documentNumber, e);
        }
    }
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
protected void addMaintenanceLockedNotes(String documentNumber, Map<SubAccount, String> lockedSubAccounts, String messageKey, PersistableBusinessObject noteParent, Note noteTemplate) {
    for (Map.Entry<SubAccount, String> entry : lockedSubAccounts.entrySet()) {
        try {
            SubAccount subAccount = entry.getKey();
            String subAccountString = subAccount.getChartOfAccountsCode() + " - " + subAccount.getAccountNumber() + " - " + subAccount.getSubAccountNumber();
            if (StringUtils.isNotBlank(subAccountString)) {
                String noteTextTemplate = kualiConfigurationService.getPropertyValueAsString(messageKey);
                String noteText = MessageFormat.format(noteTextTemplate, subAccountString, entry.getValue());
                Note note = noteService.createNote(noteTemplate, noteParent, GlobalVariables.getUserSession().getPrincipalId());
                note.setNoteText(noteText);
                noteService.save(note);
            }
        }
        catch (Exception e) {
            LOG.error("Unable to create/save notes for document " + documentNumber, e);
            throw new RuntimeException("Unable to create/save notes for document " + documentNumber, e);
        }
    }
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
protected void addNotes(String documentNumber, List<SubAccount> listOfSubAccounts, String messageKey, PersistableBusinessObject noteParent, Note noteTemplate) {
    for (int i = 0; i < listOfSubAccounts.size(); i += getNumSubAccountsPerNote()) {
        try {
            String subAccountString = createSubAccountChunk(listOfSubAccounts, i, i + getNumSubAccountsPerNote());
            if (StringUtils.isNotBlank(subAccountString)) {
                String noteTextTemplate = kualiConfigurationService.getPropertyValueAsString(messageKey);
                String noteText = MessageFormat.format(noteTextTemplate, subAccountString);
                Note note = noteService.createNote(noteTemplate, noteParent, GlobalVariables.getUserSession().getPrincipalId());
                note.setNoteText(noteText);
                note.setNotePostedTimestampToCurrent();
                noteService.save(note);
            }
        }
        catch (Exception e) {
            LOG.error("Unable to create/save notes for document " + documentNumber, e);
            throw new RuntimeException("Unable to create/save notes for document " + documentNumber, e);
        }
    }
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * Builds a note
 * @param description a description to put into the message of the note
 * @param messageKey the key of the note text in ApplicationResources.properties
 * @param noteTemplate the template for the note
 * @param noteParent the thing to stick the note on
 * @return the built note
 */
protected Note buildNote(String description, String messageKey, Note noteTemplate, PersistableBusinessObject noteParent) {
    Note note = null;
    try {
        final String noteTextTemplate = kualiConfigurationService.getPropertyValueAsString(messageKey);
        final String noteText = MessageFormat.format(noteTextTemplate, description);
        note = noteService.createNote(noteTemplate, noteParent, GlobalVariables.getUserSession().getPrincipalId());
        note.setNoteText(noteText);
    }
    catch (Exception e) {
        // noteService.createNote throws *Exception*???
        // weak!!
        throw new RuntimeException("Cannot create note", e);
    }
    return note;
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
@RequestMapping(params = "methodToCall=acknowledge")
public ModelAndView acknowledge(@ModelAttribute("KualiForm") DocumentFormBase form, BindingResult result,
                                HttpServletRequest request, HttpServletResponse response) throws Exception {
    OLEInvoiceForm oleInvoiceForm = (OLEInvoiceForm) form;
    OleInvoiceDocument oleInvoiceDocument = (OleInvoiceDocument) oleInvoiceForm.getDocument();
    Note noteObj = getDocumentService().createNoteFromDocument(oleInvoiceDocument, "Acknowledged at Budget Node By : " + GlobalVariables.getUserSession().getPerson().getName());
    PersistableBusinessObject noteParent = oleInvoiceDocument.getNoteTarget();
    List<Note> noteList = getNoteService().getByRemoteObjectId(noteParent.getObjectId());
    noteList.add(noteObj);
    getNoteService().saveNoteList(noteList);
    getNoteService().save(noteObj);
    oleInvoiceDocument.setNotes(noteList);
    getDocumentService().saveDocument(oleInvoiceDocument);
    performWorkflowAction(oleInvoiceForm, UifConstants.WorkflowAction.ACKNOWLEDGE, true);
    return returnToPrevious(oleInvoiceForm);
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
public void addPurchaseOrderNote(DocumentRouteLevelChange levelChangeEvent) {

        String newNodeName = levelChangeEvent.getNewNodeName();
        if (newNodeName != null
                && (newNodeName.equalsIgnoreCase(PurapWorkflowConstants.BUDGET_NODE) || newNodeName
                .equalsIgnoreCase(PurapWorkflowConstants.FYI_BUDGET))) {
            String note = "";
            if(newNodeName.equalsIgnoreCase(PurapWorkflowConstants.BUDGET_NODE)){
                note = OLEConstants.SufficientFundCheck.PO_NOTE;
            }
            if(newNodeName.equalsIgnoreCase(PurapWorkflowConstants.FYI_BUDGET)){
                note = OLEConstants.SufficientFundCheck.FYI_NOTE;
            }
            DocumentService documentService = SpringContext.getBean(DocumentService.class);
            Note apoNote = documentService.createNoteFromDocument(this, note);
            this.addNote(apoNote);
            documentService.saveDocumentNotes(this);
        }

    }
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
* @see  org.kuali.kfs.sys.document.FinancialSystemMaintainable.processAfterPost
*/
@Override
public void processAfterPost(MaintenanceDocument document, Map<String, String[]> parameters) {
    String[] customAction = parameters.get(KRADConstants.CUSTOM_ACTION);
    if (customAction != null && customAction.length > 0 && StringUtils.equals(CamsPropertyConstants.Asset.LAST_INVENTORY_DATE_UPDATE_BUTTON,customAction[0])) {
        WorkflowDocument workflowDoc = document.getDocumentHeader().getWorkflowDocument();
        if(workflowDoc != null && workflowDoc.isInitiated()) {
            asset.setLastInventoryDate(new Timestamp(SpringContext.getBean(DateTimeService.class).getCurrentSqlDate().getTime()));            
            String userPrincipalName= GlobalVariables.getUserSession().getPrincipalName();
            final String noteTextPattern = SpringContext.getBean(ConfigurationService.class).getPropertyValueAsString(CamsKeyConstants.Asset.LAST_INVENTORY_DATE_UPDATE_NOTE_TEXT);
            Object[] arguments = { userPrincipalName, asset.getCapitalAssetNumber().toString() };
            String noteText = MessageFormat.format(noteTextPattern, arguments);
            Note lastInventoryDateUpdatedNote = getDocumentService().createNoteFromDocument(document, noteText);
            lastInventoryDateUpdatedNote.setAuthorUniversalIdentifier(getIdentityService().getPrincipalByPrincipalName(KFSConstants.SYSTEM_USER).getPrincipalId());
            document.addNote(lastInventoryDateUpdatedNote);
            getDocumentService().saveDocumentNotes(document);
        }
    }
    super.processAfterPost(document, parameters);
}
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
public ActionForward startResearch(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response) throws Exception {

        ElectronicInvoiceRejectForm electronicInvoiceRejectForm = (ElectronicInvoiceRejectForm) form;
        ElectronicInvoiceRejectDocument eirDocument = (ElectronicInvoiceRejectDocument) electronicInvoiceRejectForm.getDocument();
        eirDocument.setInvoiceResearchIndicator(true);

        Note noteObj = getDocumentService().createNoteFromDocument(eirDocument, "Research started by: " + GlobalVariables.getUserSession().getPerson().getName());
        PersistableBusinessObject noteParent = eirDocument.getNoteTarget();
        List<Note> noteList = getNoteService().getByRemoteObjectId(noteParent.getObjectId());
        noteList.add(noteObj);
        getNoteService().saveNoteList(noteList);
        getNoteService().save(noteObj);
        getDocumentService().saveDocument(eirDocument);

        return mapping.findForward(OLEConstants.MAPPING_BASIC);
    }
 

import org.kuali.rice.krad.bo.Note; //导入依赖的package包/类
/**
 * Creates a note to be added to the Vendor Maintenance Document which is spawned from the PurchaseOrderDocument.
 *
 * @param maintainable
 * @param documentNumber
 * @param poID
 */
protected void addNoteForCommodityCodeToVendor(Maintainable maintainable, String documentNumber, Integer poID) {
    Note newBONote = new Note();
    newBONote.setNoteText("Change vendor document ID <" + documentNumber + ">. Document was automatically created from PO <" + poID + "> to add commodity codes used on this PO that were not yet assigned to this vendor.");
    try {

        newBONote = noteService.createNote(newBONote, maintainable.getBusinessObject(), GlobalVariables.getUserSession().getPrincipalId());
        newBONote.setNotePostedTimestampToCurrent();
    }
    catch (Exception e) {
        throw new RuntimeException("Caught Exception While Trying To Add Note to Vendor", e);
    }
    List<Note> noteList = noteService.getByRemoteObjectId(maintainable.getBusinessObject().getObjectId());
    noteList.add(newBONote);
    noteService.saveNoteList(noteList);
}