public VariationInformationEditConfiguration() {
        rootSection = new VerticalSectionView(ProgramSections.PROGRAM_DETAILS_EDIT, ProgramProperties.get().program_menu_sections_programInformation(), ProgramConstants.PROGRAM_MODEL_ID);
    }

    @Override
    protected void buildLayout() {
        HorizontalSection horizontalSection = new HorizontalSection();
        horizontalSection.addSection(createLeftSection());
        horizontalSection.addSection(createRightSection());
        rootSection.addSection(horizontalSection);
    }

    private VerticalSection createLeftSection() {
        VerticalSection section = new VerticalSection();
        section.addSection(createKeyProgramInformationSection());
        section.addSection(createProgramTitleSection());
        section.addSection(createDatesSection());
        section.addSection(createOtherInformationSection());
        return section;
    }

    private VerticalSection createRightSection() {
        VerticalSection section = new VerticalSection();
        section.addStyleName("readOnlySection");
        section.addSection(createReadOnlySection());
        return section;
    }

    private VerticalSection createKeyProgramInformationSection() {
        VerticalSection section = new VerticalSection(SectionTitle.generateH3Title(ProgramProperties.get().programInformation_identifyingDetails()));
        configurer.addField(section, ProgramConstants.CODE, new MessageKeyInfo(ProgramProperties.get().programInformation_code()));
        configurer.addField(section, ProgramConstants.PROGRAM_CLASSIFICATION, new MessageKeyInfo(ProgramProperties.get().programInformation_classification()));
        configurer.addField(section, ProgramConstants.DEGREE_TYPE, new MessageKeyInfo(ProgramProperties.get().programInformation_degreeType()));
        return section;
    }

    private VerticalSection createProgramTitleSection() {
        VerticalSection section = new VerticalSection(SectionTitle.generateH3Title(ProgramProperties.get().programInformation_programTitle()));
        configurer.addField(section, ProgramConstants.LONG_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleFull()));
        configurer.addField(section, ProgramConstants.SHORT_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleShort()));
        configurer.addField(section, ProgramConstants.TRANSCRIPT, new MessageKeyInfo(ProgramProperties.get().programInformation_titleTranscript()));
        configurer.addField(section, ProgramConstants.DIPLOMA, new MessageKeyInfo(ProgramProperties.get().programInformation_titleDiploma())).setWidgetBinding(new DiplomaBinding());
        return section;
    }

    private VerticalSection createDatesSection() {
        VerticalSection section = new VerticalSection(SectionTitle.generateH3Title(ProgramProperties.get().programInformation_dates()));
        configurer.addField(section, ProgramConstants.START_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_startTerm()));
        configurer.addField(section, ProgramConstants.END_INSTITUTIONAL_ADMIT_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_admitTerm()));
        configurer.addField(section, ProgramConstants.END_PROGRAM_ENTRY_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_entryTerm()));
        configurer.addField(section, ProgramConstants.END_PROGRAM_ENROLL_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_enrollTerm()));
        return section;
    }

    private VerticalSection createOtherInformationSection() {
        VerticalSection section = new VerticalSection(SectionTitle.generateH3Title(ProgramProperties.get().programInformation_otherInformation()));
        configurer.addField(section, ProgramConstants.LOCATION, new MessageKeyInfo(ProgramProperties.get().programInformation_location()));
        Widget cip2000Picker = configureSearch(ProgramConstants.CIP_2000);
        configurer.addField(section, ProgramConstants.CIP_2000, new MessageKeyInfo(ProgramProperties.get().programInformation_cip2000()), cip2000Picker);
        Widget cip2010Picker = configureSearch(ProgramConstants.CIP_2010);
        configurer.addField(section, ProgramConstants.CIP_2010, new MessageKeyInfo(ProgramProperties.get().programInformation_cip2010()), cip2010Picker);
        configurer.addField(section, ProgramConstants.HEGIS_CODE, new MessageKeyInfo(ProgramProperties.get().programInformation_hegis()));

                                    luRpcServiceAsync.getClu(versionInfo.getId(), new AsyncCallback<CluInfo>() {
                                        @Override
                                        public void onFailure(Throwable throwable) {
                                            Window.alert(throwable.getMessage());
                                            GWT.log("Failed to retrieve clu", throwable);
                                        }

                                        @Override
                                        public void onSuccess(CluInfo cluInfo) {
                                            courseWidget.setLabelContent(cluInfo.getVersionInfo().getVersionIndId(), cluInfo.getOfficialIdentifier().getCode());
                                        }
                                    });
                                }
                            });


                        }
                    });

                    customWidgets.put("kuali.reqComponent.field.type.course.clu.id", courseWidget);
                } else if (RulesUtil.isProgramWidget(fieldTypeInfo.getId())) {
                    final ProgramWidget programWidget = new ProgramWidget();

                    programWidget.addGetCluNameCallback(new Callback() {

                        @Override
                        public void exec(Object id) {

                            statementRpcServiceAsync.getCurrentVersion(CLU_NAMESPACE_URI, (String)id, new AsyncCallback<VersionDisplayInfo>() {
                                @Override
                                public void onFailure(Throwable throwable) {
                                    Window.alert(throwable.getMessage());
                                    GWT.log("Failed to retrieve clu for id: '" +  "'", throwable);
                                }

                                @Override
                                public void onSuccess(final VersionDisplayInfo versionInfo) {
                                    statementRpcServiceAsync.getClu(versionInfo.getId(), new AsyncCallback<CluInfo>() {
                                        @Override
                                        public void onFailure(Throwable throwable) {
                                            Window.alert(throwable.getMessage());
                                            GWT.log("Failed to retrieve clu", throwable);
                                        }

                                        @Override
                                        public void onSuccess(CluInfo cluInfo) {
                                            programWidget.setLabelContent(cluInfo.getVersionInfo().getVersionIndId(), cluInfo.getOfficialIdentifier().getCode());
                                        }
                                    });
                                }
                            });
                        }
                    });

                    customWidgets.put("kuali.reqComponent.field.type.program.clu.id", programWidget);
                }
            }
        }
        return customWidgets;
    }

    //called when user selects a rule type in the rule editor
    protected Callback<ReqComponentInfo> retrieveCompositionTemplateCallback = new Callback<ReqComponentInfo>(){
        public void exec(final ReqComponentInfo reqComp) {
            statementRpcServiceAsync.translateReqComponentToNL(reqComp, COMPOSITION_TEMLATE, TEMLATE_LANGUAGE, new KSAsyncCallback<String>() {
                public void handleFailure(Throwable caught) {
                    Window.alert(caught.getMessage());
                    GWT.log("translateReqComponentToNL failed for req. comp. type: '" + reqComp.getType() + "'",caught);
                }

                public void onSuccess(final String compositionTemplate) {
                    editReqCompWidget.displayFieldsStart(compositionTemplate);
                }
            });
        }
    };

    protected Callback<List<String>> retrieveFieldsMetadataCallback = new Callback<List<String>>(){
        public void exec(final List<String> fieldTypes) {

            if (fieldTypes.contains("kuali.reqComponent.field.type.grade.id")) {
                fieldTypes.add("kuali.reqComponent.field.type.gradeType.id");
            }

            metadataServiceAsync.getMetadataList("org.kuali.student.core.statement.dto.ReqCompFieldInfo", fieldTypes, null, new KSAsyncCallback<List<Metadata>>() {
                public void handleFailure(Throwable caught) {
                    Window.alert(caught.getMessage());
                    GWT.log("getMetadataList failed for req. comp. types: '" + fieldTypes.toString() + "'",caught);
                }

                public void onSuccess(final List<Metadata> metadataList) {
                    editReqCompWidget.displayFieldsEnd(metadataList);
                }
            });
        }
    };

    protected Callback<String> retrieveCustomWidgetCallback = new Callback<String>(){
        public void exec(final String fieldType) {
            if (RulesUtil.isCluSetWidget(fieldType)) {
                String clusetType = "kuali.cluSet.type.Course";
                if (fieldType.toLowerCase().indexOf("program") > 0) {
                    clusetType = "kuali.cluSet.type.Program";
                }
                editReqCompWidget.displayCustomWidget(fieldType, new BuildCluSetWidget(new CluSetRetrieverImpl(), clusetType, false));
            }
        }
    };

    public boolean isUserClickedSaveButton() {

        if (metadata != null && data != null) {
            __translateIds(data, metadata);
        }
    }
    
    /**
     * Uses the IdTranslator and Metadata to convert IDs into their display text and stores those translations in the
     * _runtimeData node
     * 
     * @param data
     *            the Data instance containing IDs to be translated
     * @param metadata
     *            the Metadata instance representing the data provided.
     * @throws AssemblyException
     */
    private void __translateIds(Data data, Metadata metadata)
            throws AssemblyException {
        try{
            if (data != null && metadata != null) {
                //Iterate through all the data;s properties
                for (Iterator<Property> iter = data.realPropertyIterator(); iter.hasNext();) {
                    Property prop = iter.next();
                    
                    Object fieldData = prop.getValue();
                    Object fieldKey = prop.getKey();

                    Metadata fieldMetadata = metadata.getProperties().get(fieldKey);
                    
                    //if the fieldMetadata is null then try to use the parent metadata as in the case of lists
                    if(fieldMetadata==null){
                        fieldMetadata=metadata;
                    }
                    
                    //If the fieldData is Data itself the recurse
                    if (fieldData instanceof Data) {
                        if (DataType.LIST.equals(fieldMetadata.getDataType())) {
                            //Lists are a special case where the metadata property name is "*"
                            Metadata listChildMetadata = fieldMetadata.getProperties().get("*");
                            //see if this is a list of data or a list of fields
                            if(DataType.DATA.equals(listChildMetadata.getDataType())){
                                __translateIds((Data) prop.getValue(), listChildMetadata);
                            }else{
                                //its a list of fields so loop through and translate using the "index"
                                for(Iterator<Property> listIter = ((Data)fieldData).realPropertyIterator(); listIter.hasNext();){
                                    Property listItem = listIter.next();
                                    Object listData = listItem.getValue();
                                    if (listData != null && listData instanceof String) {
                                        if (fieldMetadata.getInitialLookup() != null
                                                && !StringUtils.isEmpty((String) listData)) {
                                            //This is a string with a lookup so do the translation
                                            IdTranslation trans = idTranslator.getTranslation(fieldMetadata.getInitialLookup(), (String) listData);
                                            if (trans != null) {
                                                Integer index = listItem.getKey();
                                                setTranslation((Data)fieldData, listItem.getKey().toString(), index, trans.getDisplay());
                                            }
                                        }
                                    }
                                }
                            }
                        } else {
                            //Otherwise just use the fieldMetadata
                            __translateIds((Data) prop.getValue(), fieldMetadata);
                        }
                    } else if (fieldData != null && fieldData instanceof String) {
                        if (fieldMetadata.getInitialLookup() != null
                                && !StringUtils.isEmpty((String) fieldData)) {
                            //This is a string with a lookup so do the translation
                            IdTranslation trans = idTranslator.getTranslation(fieldMetadata.getInitialLookup(), (String) fieldData);
                            if (trans != null) {
                                setTranslation(data, prop.getKey().toString(), null, trans.getDisplay());
                            }
                        }
                    }
                }
            }
        }catch(Exception e){
            LOG.error("Error translating", e);
        }
    }

    private static void setTranslation(Data data, String field, Integer index, String translation) {
        if (data != null) {
            //Get runtime data for the node and create if it doesn't exist
            Data runtime = data.get("_runtimeData");
            if (runtime == null) {
                runtime = new Data();
                data.set("_runtimeData", runtime);
            }
            if(index != null) {
                //If the index is set this is a list item (foo/bar/0/, foo/bar/1/)
                Data fieldIndexData = runtime.get(index);
                if(fieldIndexData==null){
                    fieldIndexData = new Data();
                    runtime.set(index, fieldIndexData);
                }
                fieldIndexData.set("id-translation", translation);
            }else{
                //Otherwise set the translation directly referenced by the field
                //If the index is set this is a list item (foo/bar/0/, foo/bar/1/)
                Data fieldData = runtime.get(field);
                if(fieldData==null){
                    fieldData = new Data(); 
                    runtime.set(field, fieldData);
                }
                fieldData.set("id-translation", translation);
            }
        }
    }
}

    private VariationInformationViewConfiguration(SectionView sectionView) {
        rootSection = sectionView;
        rootSection.addStyleName("programInformationView");
    }

    @Override
    protected void buildLayout() {
        HorizontalSection section = new HorizontalSection();
        section.addSection(createIdentifyingDetailsSection());
        section.addSection(createProgramTitleSection());
        section.nextRow();
        section.addSection(createDatesSection());
        section.addSection(createOtherInformationSection());
        rootSection.addSection(section);
    }

    private TableSection createIdentifyingDetailsSection() {
        TableSection section = new TableSection(SectionTitle.generateH4Title(ProgramProperties.get().programInformation_identifyingDetails()));
        configurer.addReadOnlyField(section, ProgramConstants.CODE, new MessageKeyInfo(ProgramProperties.get().programInformation_code()));
        configurer.addReadOnlyField(section, ProgramConstants.CREDENTIAL_PROGRAM_LEVEL, new MessageKeyInfo(ProgramProperties.get().programInformation_level()));
        configurer.addReadOnlyField(section, ProgramConstants.CREDENTIAL_PROGRAM_TYPE_NAME, new MessageKeyInfo(ProgramProperties.get().programInformation_credentialProgram()));
        configurer.addReadOnlyField(section, ProgramConstants.PROGRAM_CLASSIFICATION, new MessageKeyInfo(ProgramProperties.get().programInformation_classification()));
        configurer.addReadOnlyField(section, ProgramConstants.DEGREE_TYPE, new MessageKeyInfo(ProgramProperties.get().programInformation_degreeType()));
        return section;
    }

    private TableSection createProgramTitleSection() {
        TableSection section = new TableSection(SectionTitle.generateH4Title(ProgramProperties.get().programInformation_programTitle()));
        configurer.addReadOnlyField(section, ProgramConstants.LONG_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleFull()));
        configurer.addReadOnlyField(section, ProgramConstants.SHORT_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleShort()));
        configurer.addReadOnlyField(section, ProgramConstants.TRANSCRIPT, new MessageKeyInfo(ProgramProperties.get().programInformation_titleTranscript()));
        configurer.addReadOnlyField(section, ProgramConstants.DIPLOMA, new MessageKeyInfo(ProgramProperties.get().programInformation_titleDiploma()));
        return section;
    }

    private TableSection createDatesSection() {
        TableSection section = new TableSection(SectionTitle.generateH4Title(ProgramProperties.get().programInformation_dates()));
        configurer.addReadOnlyField(section, ProgramConstants.START_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_startTerm()));
        configurer.addReadOnlyField(section, ProgramConstants.END_INSTITUTIONAL_ADMIT_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_admitTerm()));
        configurer.addReadOnlyField(section, ProgramConstants.END_PROGRAM_ENTRY_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_entryTerm()));
        configurer.addReadOnlyField(section, ProgramConstants.END_PROGRAM_ENROLL_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_enrollTerm()));
        configurer.addReadOnlyField(section, ProgramConstants.PROGRAM_APPROVAL_DATE, new MessageKeyInfo(ProgramProperties.get().programInformation_approvalDate()));
        return section;
    }

    private TableSection createOtherInformationSection() {
        TableSection section = new TableSection(SectionTitle.generateH4Title(ProgramProperties.get().programInformation_otherInformation()));
        configurer.addReadOnlyField(section, ProgramConstants.LOCATION, new MessageKeyInfo(ProgramProperties.get().programInformation_location()));

        configurer = GWT.create(CredentialEditConfigurer.class);
        bind();
    }

    @Override
    protected void configureView() {
        super.configureView();
        if (!initialized) {
            eventBus.fireEvent(new MetadataLoadedEvent(programModel.getDefinition(), this));
            List<Enum<?>> excludedViews = new ArrayList<Enum<?>>();
            excludedViews.add(ProgramSections.PROGRAM_REQUIREMENTS_EDIT);
            excludedViews.add(ProgramSections.SUPPORTING_DOCUMENTS_EDIT);
            excludedViews.add(ProgramSections.SUMMARY);
            addCommonButton(ProgramProperties.get().program_menu_sections(), saveButton, excludedViews);
            addCommonButton(ProgramProperties.get().program_menu_sections(), cancelButton, excludedViews);
            initialized = true;
        }
    }

    private void bind() {
        saveButton.addClickHandler(new ClickHandler() {

            @Override
            public void onClick(ClickEvent event) {
                doSave();
            }
        });
        cancelButton.addClickHandler(new ClickHandler() {

            @Override
            public void onClick(ClickEvent event) {
                doCancel();
            }
        });
        eventBus.addHandler(StoreRequirementIDsEvent.TYPE, new StoreRequirementIDsEvent.Handler() {
            @Override
            public void onEvent(StoreRequirementIDsEvent event) {
                List<String> ids = event.getProgramRequirementIds();

                programModel.set(QueryPath.parse(ProgramConstants.PROGRAM_REQUIREMENTS), new Data());
                Data programRequirements = programModel.get(ProgramConstants.PROGRAM_REQUIREMENTS);

                if (programRequirements == null) {
                    Window.alert("Cannot find program requirements in data model.");
                    GWT.log("Cannot find program requirements in data model", null);
                    return;
                }

                for (String id : ids) {
                    programRequirements.add(id);
                }
                doSave();
            }
        });
        eventBus.addHandler(ChangeViewEvent.TYPE, new ChangeViewEvent.Handler() {
            @Override
            public void onEvent(ChangeViewEvent event) {
                showView(event.getViewToken());
            }
        });
        eventBus.addHandler(UpdateEvent.TYPE, new UpdateEvent.Handler() {
            @Override
            public void onEvent(UpdateEvent event) {
                doSave(event.getOkCallback());
            }
        });
        eventBus.addHandler(StateChangeEvent.TYPE, new StateChangeEvent.Handler() {
            @Override
            public void onEvent(final StateChangeEvent event) {
                programModel.validateNextState(new Callback<List<ValidationResultInfo>>() {
                    @Override
                    public void exec(List<ValidationResultInfo> result) {
                        boolean isSectionValid = isValid(result, true);
                        if (isSectionValid) {
                            Callback<Boolean> callback = new Callback<Boolean>() {
                                @Override
                                public void exec(Boolean result) {
                                    if (result) {
                                        reloadMetadata = true;
                                        loadMetadata(new Callback<Boolean>() {
                                            @Override
                                            public void exec(Boolean result) {
                                                if (result) {
                                                    ProgramUtils.syncMetadata(configurer, programModel.getDefinition());
                                                    HistoryManager.navigate(AppLocations.Locations.VIEW_BACC_PROGRAM.getLocation(), context);

    }

    protected List<SearchResultRow> relatedOrgsFromOrgId(String orgId, String relationType, String relatedOrgType) {
        List<SearchResultRow> results = null;
        if (null != orgId) {
            List<SearchParam> queryParamValues = new ArrayList<SearchParam>(2);
            SearchParam qpRelType = new SearchParam();
            qpRelType.setKey("org.queryParam.relationType");
            qpRelType.setValue(relationType);
            queryParamValues.add(qpRelType);

            SearchParam qpOrgId = new SearchParam();
            qpOrgId.setKey("org.queryParam.orgId");
            qpOrgId.setValue(orgId);
            queryParamValues.add(qpOrgId);

            SearchParam qpRelOrgType = new SearchParam();
            qpRelOrgType.setKey("org.queryParam.relatedOrgType");
            qpRelOrgType.setValue(relatedOrgType);
            queryParamValues.add(qpRelOrgType);

            SearchRequest searchRequest = new SearchRequest();
            searchRequest.setSearchKey("org.search.orgQuickViewByRelationTypeRelatedOrgTypeOrgId");
            searchRequest.setParams(queryParamValues);
            try {
                SearchResult result = getOrganizationService().search(searchRequest);
                results = result.getRows();
            } catch (Exception e) {
                LOG.error("Error calling org service");
                throw new RuntimeException(e);
            }
        }
        return results;
    }

    protected List<AttributeSet> attributeSetFromSearchResult(List<SearchResultRow> results, String orgShortNameKey, String orgIdKey) {
        List<AttributeSet> returnAttrSetList = new ArrayList<AttributeSet>();
        if (results != null) {
            for (SearchResultRow result : results) {
                AttributeSet attributeSet = new AttributeSet();
                String resolvedOrgId = "";
                String resolvedOrgShortName = "";
                for (SearchResultCell resultCell : result.getCells()) {
                    if ("org.resultColumn.orgId".equals(resultCell.getKey())) {
                        resolvedOrgId = resultCell.getValue();
                    } else if ("org.resultColumn.orgShortName".equals(resultCell.getKey())) {
                        resolvedOrgShortName = resultCell.getValue();
                    }
                }
                if (orgShortNameKey != null) {
                    attributeSet.put(orgShortNameKey, resolvedOrgShortName);
                }
                if (orgIdKey != null) {
                    attributeSet.put(orgIdKey, resolvedOrgId);
                }
                attributeSet.put(KualiStudentKimAttributes.QUALIFICATION_ORG, resolvedOrgShortName);
                attributeSet.put(KualiStudentKimAttributes.QUALIFICATION_ORG_ID, resolvedOrgId);
                returnAttrSetList.add(attributeSet);
            }
        }
        return returnAttrSetList;
    }

    protected List<AttributeSet> cocAttributeSetsFromAncestors(String orgId, String orgType, String orgShortNameKey, String orgIdKey) {
        List<AttributeSet> returnAttributeSets = new ArrayList<AttributeSet>();
        List<OrgInfo> orgsForRouting = null;

        if (orgId != null) {
            try {
                List<String> orgIds = new ArrayList<String>();
                // add the existing org in to the list to check for the given type
                orgIds.add(orgId);
                orgIds.addAll(getOrganizationService().getAllAncestors(orgId, getOrganizationHierarchyTypeCode()));

        List<String> selected  = SwitchSection.this.selectableWidget.getSelectedItems();
        for(int i = 0; i < selected.size(); i++){
            String key = selected.get(i);
            showSwappableSection(key);
        }
        
        Iterator<String> it = swapSectionMap.keySet().iterator();
        while(it.hasNext()){
            String key = it.next();
            if(!selected.contains(key)){
                removeSwappableSection(key);
            }
        }
    }
    
    private void showSwappableSection(String key){
        Section section = swapSectionMap.get(key);
        if(section != null){
            if(deleted.contains(section)){
                deleted.remove(section);
            }
            if(!section.getLayout().isVisible()){
                section.enableValidation(true);
                section.getLayout().setVisible(true);
            }
        }
    }
    
    private void removeSwappableSection(String key){
        Section section = swapSectionMap.get(key);
        if(section != null){
            if(!deleted.contains(section)){
                deleted.add(section);
            }
            if(section.getLayout().isVisible()){
                section.enableValidation(false);
                section.getLayout().setVisible(false);
            }

        }
    }
    
    public void enableConfirmation(boolean enable){
        showConfirmation = enable;
    }
    
    public String addSection(Section section, String swapKey){
        swapSectionMap.put(swapKey, section);
        String key = layout.addLayout(section.getLayout());
        section.getLayout().setVisible(false);
        if(selectableWidget.getSelectedItems().contains(swapKey)){
            handleSelection();
        }
        sections.add(section);
        return key;
    }
    
    public String addSection(String key, Section section, String swapKey){
        swapSectionMap.put(swapKey, section);
        section.getLayout().setKey(key);
        String rkey = layout.addLayout(section.getLayout());
        section.getLayout().setVisible(false);
        if(selectableWidget.getSelectedItems().contains(swapKey)){
            handleSelection();
        }
        sections.add(section);
        return rkey;
    }
    
    
    @Override
    public String addSection(Section section) {
        throw new UnsupportedOperationException("Sections can be added to swappable section only through " +
                "the addSection(Section section, String swapKey) method");
        
    }

    @Override
    public String addSection(String key, Section section) {
        throw new UnsupportedOperationException("Sections can be added to swappable section only through " +
                "the addSection(Section section, String swapKey) method");
    }

        rule = RulesUtil.clone(stmtTreeInfo);
        isNewRule = newRuleFlag;
        originalReqCompNL = getAllReqCompNLs();

        //update screen elements
        editReqCompWidget.setupNewReqComp();
        ruleManageWidget.redraw(rule, false);
       // originalLogicExpression = ruleManageWidget.getLogicExpression();
    }

    //retrieve the latest version from rule table widget and update the local copy
    public StatementTreeViewInfo getRuleTree() {
        rule = ruleManageWidget.getStatementTreeViewInfo();
        return rule;
    }

    public boolean isNewRule() {
        return isNewRule;
    }

    //called when user clicked on rule 'edit' link
    protected Callback<ReqComponentInfo> editReqCompCallback = new Callback<ReqComponentInfo>(){
        public void exec(ReqComponentInfo reqComp) {
            setEnabled(false);
            editReqCompWidget.setupExistingReqComp(reqComp);
            editedReqCompInfo = reqComp;
        }
    };

    protected Callback<Boolean> ruleChangedCallback = new Callback<Boolean>(){
        public void exec(Boolean ruleChanged) {
            actionCancelButtons.getButton(ButtonEnumerations.SaveCancelEnum.SAVE).setEnabled(ruleChanged);
        }
    };

    protected void setEnabled(boolean enabled) {
        ruleManageWidget.setEnabled(enabled);
        actionCancelButtons.getButton(ButtonEnumerations.SaveCancelEnum.SAVE).setEnabled(enabled);
    }

    @Override
    public boolean isDirty() {
        if (!isInitialized) {
            return false;
        }

        //TODO until we figure out how to detect changes, always return true
        return true;

        //first check logic expression
//        if (!ruleManageWidget.getLogicExpression().equals(originalLogicExpression)) {
//            return true;
//        }

        //next check NL for req. components
      //  if ((originalNL == null) && (rule.getNaturalLanguageTranslation() == null)) {
      //      return !ruleManageWidget.getLogicExpression().equals(originalLogicExpression);
      //  }
        //TODO how to check whether rule changed or not?
       // !(ruleManageWidget.getLogicExpression().equals(originalLogicExpression) && getAllReqCompNLs().equals(originalReqCompNL));
    }

    private String getAllReqCompNLs() {
        StringBuilder NL = new StringBuilder();
        for (StatementTreeViewInfo tree : rule.getStatements()) {
            for (ReqComponentInfo reqComp : tree.getReqComponents()) {
                NL.append(reqComp.getNaturalLanguageTranslation());
            }
        }
        return NL.toString();
    }

    //called when user clicks 'Add Rule' or 'Update Rule' when editing a req. component
    protected Callback<ReqComponentInfoUi> actionButtonClickedReqCompCallback = new Callback<ReqComponentInfoUi>(){
        public void exec(final ReqComponentInfoUi reqComp) {

            editReqCompWidget.setupNewReqComp();
            setEnabled(true);

            //true if user cancel adding/editing req. component
            if (reqComp == null) {
                return;
            }

            KSBlockingProgressIndicator.addTask(creatingRuleTask);

            //1. update NL for the req. component
            statementRpcServiceAsync.translateReqComponentToNLs(reqComp, new String[]{RULEEDIT_TEMLATE, RULEPREVIEW_TEMLATE}, TEMLATE_LANGUAGE, new KSAsyncCallback<List<String>>() {
                public void handleFailure(Throwable caught) {
                    KSBlockingProgressIndicator.removeTask(creatingRuleTask);
                    Window.alert(caught.getMessage());
                    GWT.log("translateReqComponentToNL failed", caught);
               }

                public void onSuccess(final List<String> reqCompNL) {

                    reqComp.setNaturalLanguageTranslation(reqCompNL.get(0));
                    reqComp.setPreviewNaturalLanguageTranslation(reqCompNL.get(1));

                    //2. add / update req. component
                    rule = ruleManageWidget.getStatementTreeViewInfo();  //TODO ?

                    if (editedReqCompInfo == null) {  //add req. component
                        if (rule.getStatements() != null && !rule.getStatements().isEmpty()) {
                            StatementTreeViewInfo newStatementTreeViewInfo = new StatementTreeViewInfo();
                            newStatementTreeViewInfo.setId(CourseRequirementsSummaryView.NEW_STMT_TREE_ID + Integer.toString(tempStmtTreeViewInfoID++));

                            newStatementTreeViewInfo.setId(CourseRequirementsSummaryView.NEW_STMT_TREE_ID + Integer.toString(tempStmtTreeViewInfoID++));
                            newStatementTreeViewInfo.setOperator(rule.getStatements().get(0).getOperator());
                            newStatementTreeViewInfo.getReqComponents().add(reqComp);
                            rule.getStatements().add(newStatementTreeViewInfo);
                        } else {
                            rule.getReqComponents().add(reqComp);
                            //set default operator between req. components of the rule
                            if (rule.getOperator() == null) {
                                rule.setOperator(StatementOperatorTypeKey.AND);
                            }
                        }
                    } else {    //update req. component
                        editedReqCompInfo.setNaturalLanguageTranslation(reqComp.getNaturalLanguageTranslation());
                        editedReqCompInfo.setReqCompFields(reqComp.getReqCompFields());
                        editedReqCompInfo.setType(reqComp.getType());
                        editedReqCompInfo = null;  //de-reference from existing req. component
                    }

                    ruleManageWidget.redraw(rule, true);
                    KSBlockingProgressIndicator.removeTask(creatingRuleTask);
                }
            });
        }
    };

    //called when user selects a rule type in the editor
    protected Callback<ReqComponentInfo> newReqCompSelectedCallbackCallback = new Callback<ReqComponentInfo>(){
        public void exec(final ReqComponentInfo reqComp) {
            setEnabled(false);
        }
    };

    private void retrieveAndSetupReqCompTypes() {

        statementRpcServiceAsync.getReqComponentTypesForStatementType(rule.getType(), new KSAsyncCallback<List<ReqComponentTypeInfo>>() {
            public void handleFailure(Throwable cause) {
            	GWT.log("Failed to get req. component types for statement of type:" + rule.getType(), cause);
            	Window.alert("Failed to get req. component types for statement of type:" + rule.getType());
            }

            public void onSuccess(final List<ReqComponentTypeInfo> reqComponentTypeInfoList) {
                if (reqComponentTypeInfoList == null || reqComponentTypeInfoList.size() == 0) {
                    GWT.log("Missing Requirement Component Types", null);
                    Window.alert("Missing Requirement Component Types");
                    return;
                }
                editReqCompWidget.setReqCompList(reqComponentTypeInfoList);
                editReqCompWidget.setCustomWidgets(getCustomWidgets(reqComponentTypeInfoList));                
            }
        });
    }

    private Map<String, Widget> getCustomWidgets(List<ReqComponentTypeInfo> reqComponentTypeInfoList) {
        Map<String, Widget> customWidgets = new HashMap<String, Widget>();

        for (ReqComponentTypeInfo reqCompTypeInfo : reqComponentTypeInfoList) {
            for (ReqCompFieldTypeInfo fieldTypeInfo : reqCompTypeInfo.getReqCompFieldTypeInfos()) {
                if (RulesUtil.isGradeWidget(fieldTypeInfo.getId())) {
                    customWidgets.put("kuali.reqComponent.field.type.grade.id", new GradeWidget());
                } else if (RulesUtil.isCourseWidget(fieldTypeInfo.getId())) {

                    final CourseWidget courseWidget = new CourseWidget();
                    
                    courseWidget.addGetCluNameCallback(new Callback() {

                        @Override
                        public void exec(Object id) {

    }

    public void setProgramRequirements(List<String> programRequirements) {
        this.programRequirements = programRequirements;
    }
    
    public List<String> getDivisionsContentOwner() {
        return divisionsContentOwner;
    }

    public void setDivisionsContentOwner(List<String> divisionsContentOwner) {
        this.divisionsContentOwner = divisionsContentOwner;
    }

    public List<String> getDivisionsStudentOversight() {
        return divisionsStudentOversight;
    }

    public void setDivisionsStudentOversight(List<String> divisionsStudentOversight) {
        this.divisionsStudentOversight = divisionsStudentOversight;
    }

    public List<String> getDivisionsDeployment() {
        return divisionsDeployment;
    }

    public void setDivisionsDeployment(List<String> divisionsDeployment) {
        this.divisionsDeployment = divisionsDeployment;
    }

    public List<String> getDivisionsFinancialResources() {
        return divisionsFinancialResources;
    }

    public void setDivisionsFinancialResources(List<String> divisionsFinancialResources) {
        this.divisionsFinancialResources = divisionsFinancialResources;
    }

    public List<String> getDivisionsFinancialControl() {
        return divisionsFinancialControl;
    }

    public void setDivisionsFinancialControl(List<String> divisionsFinancialControl) {
        this.divisionsFinancialControl = divisionsFinancialControl;
    }

    public List<String> getUnitsContentOwner() {
        return unitsContentOwner;
    }

    public void setUnitsContentOwner(List<String> unitsContentOwner) {
        this.unitsContentOwner = unitsContentOwner;
    }

    public List<String> getUnitsStudentOversight() {
        return unitsStudentOversight;
    }

    public void setUnitsStudentOversight(List<String> unitsStudentOversight) {
        this.unitsStudentOversight = unitsStudentOversight;
    }

    public List<String> getUnitsDeployment() {
        return unitsDeployment;
    }

    public void setUnitsDeployment(List<String> unitsDeployment) {
        this.unitsDeployment = unitsDeployment;
    }

    public List<String> getUnitsFinancialResources() {
        return unitsFinancialResources;
    }

    public void setUnitsFinancialResources(List<String> unitsFinancialResources) {
        this.unitsFinancialResources = unitsFinancialResources;
    }

    public List<String> getUnitsFinancialControl() {
        return unitsFinancialControl;
    }

    public void setUnitsFinancialControl(List<String> unitsFinancialControl) {
        this.unitsFinancialControl = unitsFinancialControl;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    @Override
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    @Override
    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    }

    protected List<SearchResultRow> relatedOrgsFromOrgId(String orgId, String relationType, String relatedOrgType) {
        List<SearchResultRow> results = null;
        if (null != orgId) {
            List<SearchParam> queryParamValues = new ArrayList<SearchParam>(2);
            SearchParam qpRelType = new SearchParam();
            qpRelType.setKey("org.queryParam.relationType");
            qpRelType.setValue(relationType);
            queryParamValues.add(qpRelType);

            SearchParam qpOrgId = new SearchParam();
            qpOrgId.setKey("org.queryParam.orgId");
            qpOrgId.setValue(orgId);
            queryParamValues.add(qpOrgId);

            SearchParam qpRelOrgType = new SearchParam();
            qpRelOrgType.setKey("org.queryParam.relatedOrgType");
            qpRelOrgType.setValue(relatedOrgType);
            queryParamValues.add(qpRelOrgType);

            SearchRequest searchRequest = new SearchRequest();
            searchRequest.setSearchKey("org.search.orgQuickViewByRelationTypeRelatedOrgTypeOrgId");
            searchRequest.setParams(queryParamValues);
            try {
                SearchResult result = getOrganizationService().search(searchRequest);
                results = result.getRows();
            } catch (Exception e) {
                LOG.error("Error calling org service");
                throw new RuntimeException(e);
            }
        }
        return results;
    }

    protected List<AttributeSet> attributeSetFromSearchResult(List<SearchResultRow> results, String orgShortNameKey, String orgIdKey) {
        List<AttributeSet> returnAttrSetList = new ArrayList<AttributeSet>();
        if (results != null) {
            for (SearchResultRow result : results) {
                AttributeSet attributeSet = new AttributeSet();
                String resolvedOrgId = "";
                String resolvedOrgShortName = "";
                for (SearchResultCell resultCell : result.getCells()) {
                    if ("org.resultColumn.orgId".equals(resultCell.getKey())) {
                        resolvedOrgId = resultCell.getValue();
                    } else if ("org.resultColumn.orgShortName".equals(resultCell.getKey())) {
                        resolvedOrgShortName = resultCell.getValue();
                    }
                }
                if (orgShortNameKey != null) {
                    attributeSet.put(orgShortNameKey, resolvedOrgShortName);
                }
                if (orgIdKey != null) {
                    attributeSet.put(orgIdKey, resolvedOrgId);
                }
                attributeSet.put(KualiStudentKimAttributes.QUALIFICATION_ORG, resolvedOrgShortName);
                attributeSet.put(KualiStudentKimAttributes.QUALIFICATION_ORG_ID, resolvedOrgId);
                returnAttrSetList.add(attributeSet);
            }
        }
        return returnAttrSetList;
    }

    }

    private List<Token> getTokenList(List<String> tokenValueList) {
        List<Token> tokenList = new ArrayList<Token>();
        for (String value : tokenValueList) {
            if (value.isEmpty()) {
                continue;
            }
            if ("(".equals(value)) {
                Token t = new Token();
                t.type = Token.StartParenthesis;
                tokenList.add(t);
            } else if (")".equals(value)) {
                Token t = new Token();
                t.type = Token.EndParenthesis;
                tokenList.add(t);

            } else if ("and".equals(value)) {
                Token t = new Token();
                t.type = Token.And;
                tokenList.add(t);

            } else if ("or".equals(value)) {
                Token t = new Token();
                t.type = Token.Or;
                tokenList.add(t);

            } else {
                Token t = new Token();
                t.type = Token.Condition;
                t.value = value;
                tokenList.add(t);

            }
        }
        return tokenList;
    }

    private List<String> getTokenValue(String expression) {
        expression = expression.toLowerCase();
        List<String> tokenValueList = new ArrayList<String>();
        StringBuffer tokenValue = new StringBuffer();
        for (int i = 0; i < expression.length(); i++) {

            char ch = expression.charAt(i);
            if (ch == ' ') {
                tokenValueList.add(tokenValue.toString());
                tokenValue = new StringBuffer();
            } else if (ch == '(' || ch == ')') {
                tokenValueList.add(tokenValue.toString());
                tokenValue = new StringBuffer();
                tokenValueList.add(String.valueOf(ch));
            } else {
                tokenValue.append(ch);
            }
        }
        tokenValueList.add(tokenValue.toString());
        return tokenValueList;
    }

    }

    protected MessageKeyInfo generateMessageInfo(String labelKey) {
        return new MessageKeyInfo(groupName, type, state, labelKey);
    }

    protected String getLabel(String labelKey) {
        return Application.getApplicationContext().getUILabel(groupName, type, state, labelKey);
    }

    protected SectionTitle getH1Title(String labelKey) {
        return SectionTitle.generateH1Title(getLabel(labelKey));
    }

    protected SectionTitle getH2Title(String labelKey) {
        return SectionTitle.generateH2Title(getLabel(labelKey));
    }

    protected SectionTitle getH3Title(String labelKey) {
        return SectionTitle.generateH3Title(getLabel(labelKey));
    }

    protected SectionTitle getH4Title(String labelKey) {
        return SectionTitle.generateH4Title(getLabel(labelKey));
    }

    protected SectionTitle getH5Title(String labelKey) {
        return SectionTitle.generateH5Title(getLabel(labelKey));
    }

    // TODO - when DOL is pushed farther down into LOBuilder,
    // revert these 5 methods to returning void again.

    public FieldDescriptor addField(Section section, String fieldKey) {
        return addField(section, fieldKey, null, null, null);
    }

    public FieldDescriptor addField(Section section, String fieldKey, MessageKeyInfo messageKey) {
        return addField(section, fieldKey, messageKey, null, null);
    }

    public FieldDescriptor addField(Section section, String fieldKey, MessageKeyInfo messageKey, Widget widget) {
        return addField(section, fieldKey, messageKey, widget, null);
    }

    public FieldDescriptor addField(Section section, String fieldKey, MessageKeyInfo messageKey, String parentPath) {
        return addField(section, fieldKey, messageKey, null, parentPath);
    }

    public FieldDescriptor addField(Section section, String fieldKey, MessageKeyInfo messageKey, Widget widget, String parentPath) {
        QueryPath path = QueryPath.concat(parentPath, fieldKey);
        Metadata meta = modelDefinition.getMetadata(path);

        FieldDescriptor fd = new FieldDescriptor(path.toString(), messageKey, meta);
        if (widget != null) {
            fd.setFieldWidget(widget);
        }
        section.addField(fd);
        return fd;
    }

    	);

    	navDropDown.setItems(items);
    	navDropDown.setArrowImage(Theme.INSTANCE.getCommonImages().getDropDownIconWhite());

	}

	public void setContent(Widget wrappedContent){
		content.setWidget(wrappedContent);
	}

	public void setHeaderCustomLinks(List<KSLabel> links){
		for(KSLabel link: links){
			FocusPanel panel = new FocusPanel();
			panel.setWidget(link);
			//headerTopLinks.add(panel);
			panel.addStyleName("KS-Wrapper-Header-Custom-Link-Panel");
			link.addStyleName("KS-Wrapper-Header-Custom-Link");
		}
	}

	public void setFooterLinks(List<KSLabel> links){
		for(KSLabel link: links){
			//footer.add(link);
			link.addStyleName("KS-Wrapper-Footer-Link");
		}
	}


    private KSLabel buildLink(final String text, final String title, final String actionUrl) {

        //Using KSLabel for now - couldn't change color for Anchor
        final KSLabel link = new KSLabel(text);
        link.addStyleName("KS-Header-Link");
        link.setTitle(title);
        link.addMouseOverHandler(new MouseOverHandler() {

            @Override
            public void onMouseOver(MouseOverEvent event) {
                link.addStyleName("KS-Header-Link-Focus");
            }});

        link.addMouseOutHandler(new MouseOutHandler() {

            @Override
            public void onMouseOut(MouseOutEvent event) {
                link.removeStyleName("KS-Header-Link-Focus");

            }});
        link.addClickHandler(new ClickHandler() {

            @Override
            public void onClick(ClickEvent event) {
                Window.Location.assign(actionUrl);
            }});

        return link;

    }

    //Method to build the light box for the doc search
    private void buildDocSearchPanel(){
    	if (docSearch == null){
	        docSearch = new Frame();
	    	docSearch.setSize("700px", "500px");
	        docSearch.setUrl(docSearchUrl);

	        VerticalPanel docSearchPanel = new VerticalPanel();
	        docSearchPanel.add(docSearch);

	        KSButton closeActionButton = new KSButton(getMessage("wrapperPanelClose"));
	        closeActionButton.addClickHandler(new ClickHandler(){
	            public void onClick(ClickEvent event) {
	                docSearchDialog.hide();
	            }
	        });

	        docSearchPanel.add(closeActionButton);
	        docSearchDialog.setWidget(docSearchPanel);

    public KSRadioButtonList() {
        initWidget(selectItemWidget);
    }

	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#deSelectItem(java.lang.String)
	 */
	public void deSelectItem(String id) {
	    selectItemWidget.deSelectItem(id);	
	}

	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#getSelectedItems()
	 */
	public List<String> getSelectedItems() {
	    return selectItemWidget.getSelectedItems();
	}

	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#selectItem(java.lang.String)
	 */
	public void selectItem(String id) {
	    selectItemWidget.selectItem(id);
	}

    public void setListItems(ListItems listItems) {
        selectItemWidget.setListItems(listItems);      
    }

    /**
     * Use to set number of columns to use when displaying list
     * 
     */
    public void setColumnSize(int cols){
        selectItemWidget.setColumnSize(cols);
    }
        
    public void setMultipleSelect(boolean isMultipleSelect) {}

    /**
     * This overridden method is not used
     * 
     * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#onLoad()
     */
    @Override
    public void onLoad() {}
   
    public HandlerRegistration addSelectionChangeHandler(SelectionChangeHandler handler) {
        return selectItemWidget.addSelectionChangeHandler(handler);
    }

    public ListItems getListItems() {
        return selectItemWidget.getListItems();
    }

    public String getName() {
        return selectItemWidget.getName();
    }

    public void setName(String name) {
        selectItemWidget.setName(name);
    }

    @Override
    public void setEnabled(boolean b) {
        selectItemWidget.setEnabled(b);
    }

    @Override
    public boolean isEnabled() {
        return selectItemWidget.isEnabled();
    }

    @Override
    public boolean isMultipleSelect() {
        return selectItemWidget.isMultipleSelect();
    }

    @Override
    public void redraw() {
        selectItemWidget.redraw();
    }

    @Override
    public void clear() {
        selectItemWidget.clear();
    }

	@Override
	public HandlerRegistration addBlurHandler(BlurHandler handler) {
		return selectItemWidget.addBlurHandler(handler);
	}

	@Override
	public HandlerRegistration addFocusHandler(FocusHandler handler) {
		return selectItemWidget.addFocusHandler(handler);
	}

    public void addWidgetReadyCallback(Callback<Widget> callback) {
        selectItemWidget.addWidgetReadyCallback(callback);
    }

    public boolean isInitialized() {
        return selectItemWidget.isInitialized();
    }

    public void setInitialized(boolean initialized) {
        selectItemWidget.setInitialized(initialized);
    }
    
    /**
     * By default if the list items used by the radiobutton has multiple attributes, the radiobutton
     * generated will display all attributes as columns. Set this property to true if this
     * behavior is not desired.
     * 
     * @param ignoreMultiple
     */
    public void setIgnoreMultipleAttributes(boolean ignoreMultiple){
    	selectItemWidget.setIgnoreMultipleAttributes(ignoreMultiple);
    }
}

        initWidget(selectItemWidget);
    }

	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#deSelectItem(java.lang.String)
	 */
	public void deSelectItem(String id) {
	    selectItemWidget.deSelectItem(id);	
	}

	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#getSelectedItems()
	 */
	public List<String> getSelectedItems() {
	    return selectItemWidget.getSelectedItems();
	}

	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#selectItem(java.lang.String)
	 */
	public void selectItem(String id) {
	    selectItemWidget.selectItem(id);
	}

    public void setListItems(ListItems listItems) {
        selectItemWidget.setListItems(listItems);      
    }

    /**
     * Use to set number of columns to use when displaying list
     * 
     */
    public void setColumnSize(int cols){
        selectItemWidget.setColumnSize(cols);
    }
        
    public void setMultipleSelect(boolean isMultipleSelect) {}

    /**
     * This overridden method is not used
     * 
     * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#onLoad()
     */
    @Override
    public void onLoad() {}
   
    public HandlerRegistration addSelectionChangeHandler(SelectionChangeHandler handler) {
        return selectItemWidget.addSelectionChangeHandler(handler);
    }

    public ListItems getListItems() {
        return selectItemWidget.getListItems();
    }

    public String getName() {
        return selectItemWidget.getName();
    }

    public void setName(String name) {
        selectItemWidget.setName(name);
    }

    @Override
    public void setEnabled(boolean b) {
        selectItemWidget.setEnabled(b);
    }

    @Override
    public boolean isEnabled() {
        return selectItemWidget.isEnabled();
    }

    @Override
    public boolean isMultipleSelect() {
        return selectItemWidget.isMultipleSelect();
    }

    @Override
    public void redraw() {
        selectItemWidget.redraw();
    }

    @Override
    public void clear() {
        selectItemWidget.clear();
    }

	@Override
	public HandlerRegistration addBlurHandler(BlurHandler handler) {
		return selectItemWidget.addBlurHandler(handler);
	}

	@Override
	public HandlerRegistration addFocusHandler(FocusHandler handler) {
		return selectItemWidget.addFocusHandler(handler);
	}

    public void addWidgetReadyCallback(Callback<Widget> callback) {
        selectItemWidget.addWidgetReadyCallback(callback);
    }

    public boolean isInitialized() {
        return selectItemWidget.isInitialized();
    }

    public void setInitialized(boolean initialized) {
        selectItemWidget.setInitialized(initialized);
    }
    
    /**
     * By default if the list items used by the checkbox has multiple attributes, the checkbox
     * generated will display all attributes as columns. Set this property to true if this
     * behavior is not desired.
     * 
     * @param ignoreMultiple
     */
    public void setIgnoreMultipleAttributes(boolean ignoreMultiple){
    	selectItemWidget.setIgnoreMultipleAttributes(ignoreMultiple);
    }
}

    }

    /**
     * If higher push to stack, else pop till less than or equal, add to list push to stack if ( push to stack if ) pop to
     * list till (.
     * 
     * http://en.wikipedia.org/wiki/Reverse_Polish_notation
     * 
     */
    private List<Node<Token>> getRPN(List<Node<Token>> nodeList) {
        List<Node<Token>> rpnList = new ArrayList<Node<Token>>();
        Stack<Node<Token>> operatorStack = new Stack<Node<Token>>();

        for (Node<Token> node : nodeList) {
            if (node.getUserObject().type == Token.Condition) {
                rpnList.add(node);

            } else if (node.getUserObject().type == Token.And) {
                operatorStack.push(node);
            } else if (node.getUserObject().type == Token.StartParenthesis) {
                operatorStack.push(node);
            } else if (node.getUserObject().type == Token.Or) {

                if (operatorStack.isEmpty() == false && operatorStack.peek().getUserObject().type == Token.And) {
                    do {
                        rpnList.add(operatorStack.pop());
                    } while (operatorStack.isEmpty() == false && operatorStack.peek().getUserObject().type == Token.And);
                }

                operatorStack.push(node);
            } else if (node.getUserObject().type == Token.EndParenthesis) {
                while (operatorStack.peek().getUserObject().type != Token.StartParenthesis) {
                    rpnList.add(operatorStack.pop());
                }
                operatorStack.pop();// pop the (
            }
        }
        if (operatorStack.isEmpty() == false) {
            do {
                rpnList.add(operatorStack.pop());
            } while (operatorStack.isEmpty() == false);
        }
        return rpnList;
    }

    private int findNodeIndex(List<Node<Token>> nodeList, int type) {

public class RuntimeDataHelper
{
	private static final long serialVersionUID = 1;
	
	public enum Properties implements PropertyEnum
	{
		CREATED ("created"),
		DELETED ("deleted"),
		UPDATED ("updated"),
		VERSIONS ("versions");
		
		private final String key;
		
		private Properties (final String key)
		{
			this.key = key;
		}
		
		@Override
		public String getKey ()
		{
			return this.key;
		}
	}
	private Data data;
	
	private RuntimeDataHelper (Data data)
	{
		this.data = data;
	}
	
	public static RuntimeDataHelper wrap (Data data)
	{
		if (data == null)
		{
			 return null;
		}
		return new RuntimeDataHelper (data);
	}
	
	public Data getData ()
	{
		return data;
	}
	
	
	public void setCreated (Boolean value)
	{
		data.set (Properties.CREATED.getKey (), value);
	}
	
	
	public Boolean isCreated ()
	{
		return (Boolean) data.get (Properties.CREATED.getKey ());
	}
	
	
	public void setDeleted (Boolean value)
	{
		data.set (Properties.DELETED.getKey (), value);
	}
	
	
	public Boolean isDeleted ()
	{
		return (Boolean) data.get (Properties.DELETED.getKey ());
	}
	
	
	public void setUpdated (Boolean value)
	{
		data.set (Properties.UPDATED.getKey (), value);
	}
	
	
	public Boolean isUpdated ()
	{
		return (Boolean) data.get (Properties.UPDATED.getKey ());
	}
	
	
	public void setVersions (Data value)
	{
		data.set (Properties.VERSIONS.getKey (), value);
	}
	
	
	public Data getVersions ()
	{
		return (Data) data.get (Properties.VERSIONS.getKey ());
	}
	
}

    }

    public void addSelectionHandler(RowSelectionHandler selectionHandler){
        pagingScrollTable.getDataTable().addRowSelectionHandler(selectionHandler);
    }
    public void redraw(){
        tableModel.setRows(resultRows);
        pagingScrollTable = builder.build(tableModel);
        pagingScrollTable.setResizePolicy(ResizePolicy.FILL_WIDTH);
        layout.clear();
        layout.add(pagingScrollTable);
        pagingScrollTable.reloadPage();
        pagingScrollTable.fillWidth();
    }

    public List<ResultRow> getSelectedRows(){
        List<ResultRow> rows = new ArrayList<ResultRow>();
        Set<Integer> selectedRows = pagingScrollTable.getDataTable().getSelectedRows();
        for(Integer i: selectedRows){
            rows.add(pagingScrollTable.getRowValue(i));
        }
        return rows;
    }

    public List<String> getSelectedIds(){
        List<String> ids = new ArrayList<String>();
        Set<Integer> selectedRows = pagingScrollTable.getDataTable().getSelectedRows();
        for(Integer i: selectedRows){
            ids.add(pagingScrollTable.getRowValue(i).getId());
        }
        return ids;
    }

    public List<String> getAllIds(){
        List<String> ids = new ArrayList<String>();
        for(ResultRow r: resultRows){
            ids.add(r.getId());
        }
        return ids;
    }

    public List<ResultRow> getAllRows(){
        List<ResultRow> rows = new ArrayList<ResultRow>();
        for(ResultRow r: resultRows){
            rows.add(r);
        }
        return rows;
    }

    public String getOrgId(){
        return this.orgId;
    }

    public void setOrgId(String orgId){
        this.orgId=orgId;
    }

        createMenuItems(items, 1);
    }

    private void createMenuItems(List<KSMenuItemData> theItems, int currentDepth){
        int itemNum = 0;
        for(KSMenuItemData i: theItems){
            itemNum++;
            addMenuItem(new MenuItemPanel(i, currentDepth, itemNum));
            if(!(i.getSubItems().isEmpty())){
                createMenuItems(i.getSubItems(), currentDepth + 1);
            }
            i.addMenuEventHandler(MenuSelectEvent.TYPE, menuHandler);
            i.addMenuEventHandler(MenuChangeEvent.TYPE, menuHandler);
        }
    }

    private void addMenuItem(MenuItemPanel panel){
        menuPanel.add(panel);
        menuItems.add(panel);
    }

    public boolean isNumberAllItems() {
        return numberAllItems;
    }

    public void setNumberAllItems(boolean numberAllItems) {
        this.numberAllItems = numberAllItems;
    }

    @Override
    public boolean selectMenuItem(String[] hierarchy) {
        List<KSMenuItemData> currentItems = items;
        KSMenuItemData itemToSelect = null;
        for(String s: hierarchy){
            s = s.trim();
            for(KSMenuItemData i: currentItems){
                if(s.equalsIgnoreCase(i.getLabel().trim())){
                    itemToSelect = i;
                    currentItems = i.getSubItems();
                    break;
                }
            }
        }

        if(itemToSelect != null){

            for(MenuItemPanel p: menuItems){
                if(itemToSelect.equals(p.getItem())){
                    p.getItem().setSelected(true);
                    return true;
                }
            }

        }

        return false;
    }

    /**
     * @see org.kuali.student.common.ui.client.widgets.menus.KSMenu#clearSelected()
     */
    @Override
    public void clearSelected() {
        for(MenuItemPanel m : menuItems){
            m.deSelect();
            m.getItem().unhandledSetSelected(false);
        }
    }

    }

    private void upWrap(CluSetInfo cluSetInfo) throws AssemblyException {
        List<String> cluSetIds = (cluSetInfo == null)? null : cluSetInfo.getCluSetIds();
        List<String> unWrappedCluSetIds = null;
        List<CluSetInfo> wrappedCluSets = null;
        List<CluSetInfo> subCluSets = null;

        try {
            if (cluSetIds != null && !cluSetIds.isEmpty()) {
                subCluSets = luService.getCluSetInfoByIdList(cluSetIds);
            }
        } catch (Exception e) {
            LOG.error(e.getMessage(), e);
            throw new AssemblyException("Failed to retrieve the sub clusets of cluset " +
                    cluSetInfo.getId());
        }
        // goes through the list of sub clusets and ignore the ones that are not reusable
        if (subCluSets != null) {
            for (CluSetInfo subCluSet : subCluSets) {
                if (subCluSet.getIsReusable()) {
                    unWrappedCluSetIds = (unWrappedCluSetIds == null)?
                            new ArrayList<String>() : unWrappedCluSetIds;
                            unWrappedCluSetIds.add(subCluSet.getId());
                } else {
                    wrappedCluSets = (wrappedCluSets == null)?
                            new ArrayList<CluSetInfo>() : wrappedCluSets;
                            wrappedCluSets.add(subCluSet);
                }
            }
        }
        cluSetInfo.setCluSetIds(unWrappedCluSetIds);
        if (wrappedCluSets != null) {
            for (CluSetInfo wrappedCluSet : wrappedCluSets) {
                MembershipQueryInfo mqInfo = wrappedCluSet.getMembershipQuery();
                if (wrappedCluSet.getCluIds() != null && !wrappedCluSet.getCluIds().isEmpty()) {
                    cluSetInfo.setCluIds(wrappedCluSet.getCluIds());
                }
                if (mqInfo != null && mqInfo.getSearchTypeKey() != null && !mqInfo.getSearchTypeKey().isEmpty()) {
                    cluSetInfo.setMembershipQuery(mqInfo);
                }
            }
        }
    }
    
    private List<CluInformation> getCluInformations(List<String> cluIds) throws OperationFailedException {

                relation.setState(cluState);

                BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo> relationNode = new BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo>(
                        null);
                relationNode.setNodeData(relation);
                relationNode.setOperation(NodeOperation.CREATE);

                results.add(relationNode);
            } else if (NodeOperation.UPDATE == operation
					&& currentCluLoRelations.containsKey(loDisplay.getLoInfo().getId())) {
				// If the clu already has this lo, then just update the lo
                BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = loAssembler
                		.disassemble(loDisplay, NodeOperation.UPDATE);
				results.add(loNode);

				// remove this entry from the map so we can tell what needs to
				// be deleted at the end
				currentCluLoRelations.remove(loDisplay.getLoInfo().getId());
			} else if (NodeOperation.DELETE == operation
                    && currentCluLoRelations.containsKey(loDisplay.getLoInfo().getId())) {

                // Delete the Format and its relation
				CluLoRelationInfo relationToDelete = currentCluLoRelations.get(loDisplay.getLoInfo().getId());
                BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo>(
                        null);
                relationToDeleteNode.setNodeData(relationToDelete);
                relationToDeleteNode.setOperation(NodeOperation.DELETE);
                results.add(relationToDeleteNode);

                BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = loAssembler
        				.disassemble(loDisplay, NodeOperation.DELETE);
                results.add(loNode);

                // remove this entry from the map so we can tell what needs to
                // be deleted at the end
                currentCluLoRelations.remove(loDisplay.getLoInfo().getId());
			}
		}

        // Now any leftover lo ids are no longer needed, so delete
        // los and relations
        for (Entry<String, CluLoRelationInfo> entry : currentCluLoRelations.entrySet()) {
            // Create a new relation with the id of the relation we want to
            // delete
        	CluLoRelationInfo relationToDelete = entry.getValue();
            BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<LoDisplayInfo, CluLoRelationInfo>(
                    null);
            relationToDeleteNode.setNodeData(relationToDelete);
            relationToDeleteNode.setOperation(NodeOperation.DELETE);
            results.add(relationToDeleteNode);

    }

    /**
     * Date and time the Variation became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Abbreviated name of the Variation
     */
    public String getShortTitle() {
        return shortTitle;
    }

    public void setShortTitle(String shortTitle) {
        this.shortTitle = shortTitle;
    }

    /**
     * Full name of the Variation Discipline
     */
    public String getLongTitle() {
        return longTitle;
    }

    public void setLongTitle(String longTitle) {
        this.longTitle = longTitle;
    }

    /**
     * Information related to the official identification of the Variation, typically in human readable form. Used to officially reference or publish.
     */
    public String getTranscriptTitle() {
        return transcriptTitle;
    }

    public void setTranscriptTitle(String transcriptTitle) {
        this.transcriptTitle = transcriptTitle;
    }

    /**
     * 
     */
    public String getDiplomaTitle() {
        return diplomaTitle;
    }

    public void setDiplomaTitle(String diplomaTitle) {
        this.diplomaTitle = diplomaTitle;
    }

    /**
     * Narrative description of the Variation.
     */
    public RichTextInfo getDescr() {
        return descr;
    }

    public void setDescr(RichTextInfo descr) {
        this.descr = descr;
    }

    /**
     * Narrative description of the Variation that will show up in Catalog
     */
    public RichTextInfo getCatalogDescr() {
        return catalogDescr;
    }

    public void setCatalogDescr(RichTextInfo catalogDescr) {
        this.catalogDescr = catalogDescr;
    }
    
    /**
     * List of catalog targets where program variation information will be published.   
     */
    public List<String> getCatalogPublicationTargets() {
        return catalogPublicationTargets;
    }

    public void setCatalogPublicationTargets(List<String> catalogPublicationTargets) {
        this.catalogPublicationTargets = catalogPublicationTargets;
    }
    
    /**
     * Learning Objectives associated with this Variation.
     */
    public List<LoDisplayInfo> getLearningObjectives() {
        if (learningObjectives == null) {
            learningObjectives = new ArrayList<LoDisplayInfo>(0);
        }
        return learningObjectives;
    }

    public void setLearningObjectives(List<LoDisplayInfo> learningObjectives) {
        this.learningObjectives = learningObjectives;
    }

    /**
     * Places where this Variation might be offered
     */
    public List<String> getCampusLocations() {
        if (campusLocations == null) {
            campusLocations = new ArrayList<String>(0);
        }
        return campusLocations;
    }

    public void setCampusLocations(List<String> campusLocations) {
        this.campusLocations = campusLocations;
    }

    /**
     * Program Variation Requirements.
     */
    public List<String> getProgramRequirements() {

public class LoLoRelationTypeInfo implements Serializable, Idable, HasAttributes {

    private static final long serialVersionUID = 1L;

    @XmlElement
    private String name;

    @XmlElement
    private String desc;

    @XmlElement
    private String revName;

    @XmlElement
    private String revDesc;

    @XmlElement
    private Date effectiveDate;

    @XmlElement
    private Date expirationDate;

    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String, String> attributes;

    @XmlAttribute(name="key")
    private String id;

    /**
     * Short name of the LO to LO relationship type. This is primarily to be used by developers and may end up translated in the end system.
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * Narrative description of the LO to LO relationship type.
     */
    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    /**
     * Name for the reverse LO to LO relationship type. This is primarily to be used by developers and may end up translated in the end system.
     */
    public String getRevName() {
        return revName;
    }

    public void setRevName(String revName) {
        this.revName = revName;
    }

    /**
     * Description of the reverse of the LO to LO relationship type
     */
    public String getRevDesc() {
        return revDesc;
    }

    public void setRevDesc(String revDesc) {
        this.revDesc = revDesc;
    }

    /**
     * Date and time that this LO to LO relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LO to LO relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for the LO to LO relation type.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

public class MinorDisciplineInfo implements Serializable, Idable, HasTypeState, HasAttributes {

    private static final long serialVersionUID = 1L;

    @XmlElement
    private String credentialProgramId;

    @XmlElement
    private List<String> programRequirements;

    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String, String> attributes;

    @XmlElement
    private MetaInfo metaInfo;

    @XmlAttribute
    private String type;

    @XmlAttribute
    private String state;

    @XmlAttribute
    private String id;

    /**
     * Identifier of the credential program under which the minor belongs
     */
    public String getCredentialProgramId() {
        return credentialProgramId;
    }

    public void setCredentialProgramId(String credentialProgramId) {
        this.credentialProgramId = credentialProgramId;
    }

    /**
     * Minor Discipline Program Requirements.
     */
    public List<String> getProgramRequirements() {
        if (programRequirements == null) {
            programRequirements = new ArrayList<String>(0);
        }
        return programRequirements;
    }

    public void setProgramRequirements(List<String> programRequirements) {
        this.programRequirements = programRequirements;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning unit type. Once set at create time, this field may not be updated.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the credential program. The values for this field are constrained to those in the luState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for an Minor Discipline. This is optional, due to the identifier being set at the time of creation. Once the Program has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

        block.setTitle(getLabel(LUUIConstants.INFORMATION_LABEL_KEY));
        //block.addSummaryTableFieldRow(getFieldRow(PROPOSAL_TITLE_PATH, generateMessageInfo(LUConstants.PROPOSAL_TITLE_LABEL_KEY)));
        block.addSummaryTableFieldRow(getFieldRow(COURSE + "/" + COURSE_TITLE, generateMessageInfo(LUUIConstants.COURSE_TITLE_LABEL_KEY)));
        block.addSummaryTableFieldRow(getFieldRow(COURSE + "/" + TRANSCRIPT_TITLE, generateMessageInfo(LUUIConstants.SHORT_TITLE_LABEL_KEY)));
        block.addSummaryTableFieldRow(getFieldRow(COURSE + "/" + SUBJECT_AREA, generateMessageInfo(LUUIConstants.SUBJECT_CODE_LABEL_KEY)));
        block.addSummaryTableFieldRow(getFieldRow(COURSE + "/" + COURSE_NUMBER_SUFFIX, generateMessageInfo(LUUIConstants.COURSE_NUMBER_LABEL_KEY)));
        block.addSummaryTableFieldRow(getFieldRow(COURSE + "/" + INSTRUCTORS, generateMessageInfo(LUUIConstants.INSTRUCTORS_LABEL_KEY), null, null, null, new KeyListModelWigetBinding("personId"), false));

        block.addSummaryMultiplicity(getMultiplicityConfig(COURSE + QueryPath.getPathSeparator() + CROSS_LISTINGS,
		        LUUIConstants.CROSS_LISTED_ITEM_LABEL_KEY,
		        Arrays.asList(
		                Arrays.asList(SUBJECT_AREA, LUUIConstants.SUBJECT_CODE_LABEL_KEY),
		                Arrays.asList(COURSE_NUMBER_SUFFIX, LUUIConstants.COURSE_NUMBER_LABEL_KEY))));
        block.addSummaryMultiplicity(getMultiplicityConfig(COURSE + QueryPath.getPathSeparator() + JOINTS,
		        LUUIConstants.JOINT_OFFER_ITEM_LABEL_KEY,
		        Arrays.asList(
		                Arrays.asList(CreditCourseJointsConstants.COURSE_ID, LUUIConstants.COURSE_NUMBER_OR_TITLE_LABEL_KEY))));
        block.addSummaryMultiplicity(getMultiplicityConfig(COURSE + QueryPath.getPathSeparator() + VERSIONS,
		        LUUIConstants.VERSION_CODE_LABEL_KEY,
		        Arrays.asList(
		                Arrays.asList("variationCode", LUUIConstants.VERSION_CODE_LABEL_KEY),
		                Arrays.asList("variationTitle", LUUIConstants.TITLE_LABEL_KEY))));

        block.addSummaryTableFieldRow(getFieldRow(COURSE + "/" + PROPOSAL_DESCRIPTION + "/" + RichTextInfoConstants.PLAIN, generateMessageInfo(LUUIConstants.DESCRIPTION_LABEL_KEY)));

            for(LookupParamMetadata metaParam: meta.getParams()){
                if(metaParam.getWriteAccess() == WriteAccess.NEVER){
                    if ((metaParam.getDefaultValueString() == null || metaParam.getDefaultValueString().isEmpty())&&
                        (metaParam.getDefaultValueList() == null || metaParam.getDefaultValueList().isEmpty())) {
                        //FIXME throw an exception?
                        GWT.log("Key = " + metaParam.getKey() + " has write access NEVER but has no default value!", null);
                        continue;
                    }
                    SearchParam param = new SearchParam();
                    param.setKey(metaParam.getKey());
                    if(metaParam.getDefaultValueList()==null){
                        param.setValue(metaParam.getDefaultValueString());
                    }else{
                        param.setValue(metaParam.getDefaultValueList());
                    }
                    params.add(param);
                }
                else if(metaParam.getWriteAccess() == WriteAccess.WHEN_NULL){
                    if((metaParam.getDefaultValueString() != null && !metaParam.getDefaultValueString().isEmpty())||
                       (metaParam.getDefaultValueList() != null && !metaParam.getDefaultValueList().isEmpty())){
                        SearchParam param = new SearchParam();
                        param.setKey(metaParam.getKey());
                        if(metaParam.getDefaultValueList()==null){
                            param.setValue(metaParam.getDefaultValueString());
                        }else{
                            param.setValue(metaParam.getDefaultValueList());
                        }
                        params.add(param);
                    }
                }
            }
            sr.setParams(params);

							translateIds((Data) prop.getValue(), fieldMetadata);
						}
					} else if (fieldData != null && fieldData instanceof String) {
						if (fieldMetadata.getInitialLookup() != null
								&& !StringUtils.isEmpty((String) fieldData)) {
							//This is a string with a lookup so do the translation
							IdTranslation trans = idTranslator.getTranslation(fieldMetadata.getInitialLookup(),	(String) fieldData);
							if (trans != null) {
								setTranslation(data, prop.getKey().toString(), null, trans.getDisplay());
							}
						}
					}
				}
			}
		}catch(Exception e){
			LOG.error("Error translating", e);
		}
	}

    private static void setTranslation(Data data, String field, Integer index, String translation) {
        if (data != null) {
        	//Get runtime data for the node and create if it doesn't exist
            Data runtime = data.get("_runtimeData");
            if (runtime == null) {
                runtime = new Data();
                data.set("_runtimeData", runtime);
            }
            if(index != null) {
                //If the index is set this is a list item (foo/bar/0/, foo/bar/1/)
                Data fieldIndexData = runtime.get(index);
                if(fieldIndexData==null){
                	fieldIndexData = new Data();
                    runtime.set(index, fieldIndexData);
                }
                fieldIndexData.set("id-translation", translation);
            }else{
            	//Otherwise set the translation directly referenced by the field
                //If the index is set this is a list item (foo/bar/0/, foo/bar/1/)
                Data fieldData = runtime.get(field);
                if(fieldData==null){
                	fieldData = new Data();
                    runtime.set(field, fieldData);
                }
                fieldData.set("id-translation", translation);
            }
        }
    }
	
}

		this.initWidget(ksHeader);
	}
	protected void onLoad() {
		super.onLoad();
		if (!loaded){
			List<String> serverPropertyList = Arrays.asList(APP_URL, DOC_SEARCH_URL, LUM_APP_URL,RICE_URL,RICE_LINK_LABEL, APP_VERSION, CODE_SERVER);

	        serverPropertiesRpcService.get(serverPropertyList, new KSAsyncCallback<Map<String,String>>() {
	            public void handleFailure(Throwable caught) {
	            	//ignoring, we'll use the default
	            	init();
	            }

	            public void onSuccess(Map<String,String> result) {
	                GWT.log("ServerProperties fetched: "+result.toString(), null);
	                if(result != null){
	                    appUrl 			= result.get(APP_URL);
	                    docSearchUrl	= result.get(DOC_SEARCH_URL);
	                    lumAppUrl 		= result.get(LUM_APP_URL);
	                    riceURL         = result.get(RICE_URL);
	                    riceLinkLabel 	= result.get(RICE_LINK_LABEL);
	                    appVersion		= result.get(APP_VERSION);
	                    
	                    if (result.get(CODE_SERVER) != null){
	                    	codeServer	= result.get(CODE_SERVER);
	                    }
	                }
	                init();
	            }

	        });

			loaded = false;
		}
	}
	private void init(){
		//headerBottomLinks.setVerticalAlignment(HasVerticalAlignment.ALIGN_BOTTOM);
		createUserDropDown();
		//headerBottomLinks.add(userDropDown);
		ksHeader.setHiLabelText("Hi,");
		ksHeader.setUserName(Application.getApplicationContext().getUserId());
		Anchor logoutLink = new Anchor(getMessage("wrapperPanelLogout"));
		logoutLink.addClickHandler(new WrapperNavigationHandler("j_spring_security_logout"));
		ksHeader.addLogout(logoutLink);
		ksHeader.addLogout(versionAnchor);

		//headerBottomLinks.add(logoutLink);
		createHelpInfo();
		createNavDropDown();
		ksHeader.addNavigation(navDropDown);

                CredentialEditController.this.updateModelFromCurrentView();
                model.validate(new Callback<List<ValidationResultInfo>>() {
                    @Override
                    public void exec(List<ValidationResultInfo> result) {
                        boolean isSectionValid = isValid(result, true);
                        if (isSectionValid) {
                            saveData(okCallback);
                        } else {
                            okCallback.exec(false);
                            Window.alert("Save failed.  Please check fields for errors.");
                        }
                    }
                });

            }

            @Override
            public void onRequestFail(Throwable cause) {
                GWT.log("Unable to retrieve model for validation and save", cause);
            }
        });
    }

    private void saveData(final Callback<Boolean> okCallback) {
        programRemoteService.saveData(programModel.getRoot(), new AbstractCallback<DataSaveResult>(ProgramProperties.get().common_savingData()) {
            @Override
            public void onSuccess(DataSaveResult result) {
                super.onSuccess(result);
                if (result.getValidationResults() != null && !result.getValidationResults().isEmpty()) {
                    if (previousState != null) {
                        ProgramUtils.setStatus(programModel, previousState.getValue());
                    }
                    isValid(result.getValidationResults(), false, true);
                    StringBuilder msg = new StringBuilder();
                    for (ValidationResultInfo vri : result.getValidationResults()) {
                        msg.append(vri.getMessage());
                    }
                    okCallback.exec(false);
                } else {
                    previousState = null;
                    programModel.setRoot(result.getValue());
                    setHeaderTitle();
                    setStatus();

    }

    /**
     * Unique identifier for a document.
     */
    public String getDocumentId() {
        return documentId;
    }

    public void setDocumentId(String documentId) {
        this.documentId = documentId;
    }

    /**
     * The title of the document usage in the context of the CLU.
     */
    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    /**
     * The description of the document usage in the context of the CLU.
     */
    public RichTextInfo getDesc() {
        return desc;
    }

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this LU Doc Relation became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LU Doc Relation expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for an LU document relationship type. Describes the type of usage of the document.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the LU to document relationship. The values for this field are constrained to those in the luDocRelationState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a LU to document relation. This is optional, due to the identifier being set at the time of creation. Once the connection has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }
	
	
	@Override
	public SearchCriteriaTypeInfo getSearchCriteriaType(
			String searchCriteriaTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {

		return searchManager.getSearchCriteriaType(searchCriteriaTypeKey);
	}

	@Override
	public List<SearchCriteriaTypeInfo> getSearchCriteriaTypes()
			throws OperationFailedException {
		return searchManager.getSearchCriteriaTypes();
	}

	@Override
	public SearchResultTypeInfo getSearchResultType(String searchResultTypeKey)
			throws DoesNotExistException, InvalidParameterException,
			MissingParameterException, OperationFailedException {
		checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
		return searchManager.getSearchResultType(searchResultTypeKey);
	}

	@Override
	public List<SearchResultTypeInfo> getSearchResultTypes()
			throws OperationFailedException {
		return searchManager.getSearchResultTypes();
	}

	@Override
	public SearchTypeInfo getSearchType(String searchTypeKey)
			throws DoesNotExistException, InvalidParameterException,
			MissingParameterException, OperationFailedException {
		checkForMissingParameter(searchTypeKey, "searchTypeKey");
		return searchManager.getSearchType(searchTypeKey);
	}

	@Override
	public List<SearchTypeInfo> getSearchTypes()
			throws OperationFailedException {
		return searchManager.getSearchTypes();
	}

	@Override
	public List<SearchTypeInfo> getSearchTypesByCriteria(
			String searchCriteriaTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {
		checkForMissingParameter(searchCriteriaTypeKey, "searchCriteriaTypeKey");
		return searchManager.getSearchTypesByCriteria(searchCriteriaTypeKey);
	}

	@Override
	public List<SearchTypeInfo> getSearchTypesByResult(
			String searchResultTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {
		checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
		return searchManager.getSearchTypesByResult(searchResultTypeKey);
	}

	@Override
	public SearchResult search(SearchRequest searchRequest) throws MissingParameterException {
		return searchManager.search(searchRequest, enumDAO);

        final Iterator<Map.Entry<Key, Value>> impl = map.entrySet().iterator();

        return new Iterator<Property>() {
            Map.Entry<Key, Value> current;

            @Override
            public boolean hasNext() {
                return impl.hasNext();
            }

            @Override
            public Property next() {
                final Map.Entry<Key, Value> entry = impl.next();
                current = entry;
                return new Property() {
                    @Override
                    public <T> T getKey() {
                        return (T) entry.getKey().get();
                    }

                    @Override
                    public Class<?> getKeyType() {
                        return entry.getKey().getType();
                    }

                    @Override
                    public <T> T getValue() {
                        return (T) entry.getValue().get();
                    }

                    @Override
                    public Class<?> getValueType() {
                        return entry.getValue().getType();
                    }

                    @Override
                    public Key getWrappedKey() {
                        return entry.getKey();
                    }

                    @Override
                    public Value getWrappedValue() {
                        return entry.getValue();
                    }
                };
            }

            @Override
            public void remove() {
                impl.remove();
                QueryPath path = getQueryPath();
                path.add(current.getKey());
                execChangeCallbacks(ChangeType.REMOVE, path);
            }
        };
    }

    @Column(name = "CD")
    private String code;

    @Column(name = "SHRT_NAME")
    private String shortName;

    @Column(name = "LNG_NAME")
    private String longName;

    @Column(name = "LVL")
    private String level;

    @Column(name = "DIV")
    private String division;

    @Column(name = "VARTN")
    private String variation;

    @Column(name = "SUFX_CD")
    private String suffixCode;

    @Column(name = "ORG_ID")
    private String orgId;

    @Column(name = "TYPE")
    private String type;

    @Column(name = "ST")
    private String state;
    
    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getShortName() {
        return shortName;
    }

    public void setShortName(String shortName) {
        this.shortName = shortName;
    }

    public String getLongName() {
        return longName;
    }

    public void setLongName(String longName) {
        this.longName = longName;
    }

    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }

    public String getDivision() {
        return division;
    }

    public void setDivision(String division) {
        this.division = division;
    }

    public String getVariation() {
        return variation;
    }

    public void setVariation(String variation) {
        this.variation = variation;
    }

    public String getType() {

    }

    /**
     * Unique identifier for a reference type.
     */
    public String getReferenceTypeKey() {
        return referenceTypeKey;
    }

    public void setReferenceTypeKey(String referenceTypeKey) {
        this.referenceTypeKey = referenceTypeKey;
    }

    /**
     * Identifier component for a reference. This is an external identifier and such may not uniquely identify a particular reference unless combined with the type. A referenceId could be a cluId, a luiId, an orgId, a documentId, etc.
     */
    public String getReferenceId() {
        return referenceId;
    }

    public void setReferenceId(String referenceId) {
        this.referenceId = referenceId;
    }

    /**
     * Date and time that this tag became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this tag expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a tag type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the tag. The values for this field are constrained to those in the tagState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a tag. This is optional, due to the identifier being set at the time of creation. Once the tag has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

        selectItemWidget.setInitialized(initialzed);
    }
    
	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#deSelectItem(java.lang.String)
	 */
	public void deSelectItem(String id) {
	    selectItemWidget.deSelectItem(id);	
	}

	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#getSelectedItems()
	 */
	public List<String> getSelectedItems() {
	    return selectItemWidget.getSelectedItems();
	}

	/**
	 * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#selectItem(java.lang.String)
	 */
	public void selectItem(String id) {
	    selectItemWidget.selectItem(id);
	}

    public void setListItems(ListItems listItems) {
        selectItemWidget.setListItems(listItems);      
    }

    /**
     * Use to set number of columns to use when displaying list
     * 
     */
    public void setColumnSize(int cols){
        selectItemWidget.setColumnSize(cols);
    }
        
    public void setMultipleSelect(boolean isMultipleSelect) {}

    /**
     * This overridden method is not used
     * 
     * @see org.kuali.student.common.ui.client.widgets.list.KSSelectItemWidgetAbstract#onLoad()
     */
    @Override
    public void onLoad() {}
   
    public HandlerRegistration addSelectionChangeHandler(SelectionChangeHandler handler) {
        return selectItemWidget.addSelectionChangeHandler(handler);
    }

    public ListItems getListItems() {
        return selectItemWidget.getListItems();
    }

    public String getName() {
        return selectItemWidget.getName();
    }

    public void setName(String name) {
        selectItemWidget.setName(name);
    }

    @Override
    public void setEnabled(boolean b) {
        selectItemWidget.setEnabled(b);
    }

    @Override
    public boolean isEnabled() {
        return selectItemWidget.isEnabled();
    }

    @Override
    public boolean isMultipleSelect() {
        return selectItemWidget.isMultipleSelect();
    }

    @Override
    public void redraw() {
        selectItemWidget.redraw();
    }

    @Override
    public void clear() {
        selectItemWidget.clear();
    }

	@Override
	public HandlerRegistration addFocusHandler(FocusHandler handler) {

		pagingScrollTable.reloadPage();
	}

	public void addSelectionHandler (RowSelectionHandler selectionHandler)
	{
		pagingScrollTable.getDataTable ().addRowSelectionHandler (selectionHandler);
	}

	public List<ResultRow> getSelectedRows ()
	{
		List<ResultRow> rows = new ArrayList<ResultRow> ();
		Set<Integer> selectedRows =
			pagingScrollTable.getDataTable ().getSelectedRows ();
		for (Integer i : selectedRows)
		{
			rows.add (pagingScrollTable.getRowValue (i));
		}
		return rows;
	}

	public List<String> getSelectedIds ()
	{
		List<String> ids = new ArrayList<String> ();
		Set<Integer> selectedRows =
			pagingScrollTable.getDataTable ().getSelectedRows ();
		for (Integer i : selectedRows)
		{
			ids.add (pagingScrollTable.getRowValue (i).getId ());
		}
		return ids;
	}

	public List<String> getAllIds ()
	{
		List<String> ids = new ArrayList<String> ();
		for (ResultRow r : resultRows)
		{
			ids.add (r.getId ());
		}
		return ids;
	}

	public List<ResultRow> getAllRows ()
	{
		List<ResultRow> rows = new ArrayList<ResultRow> ();
		for (ResultRow r : resultRows)
		{
			rows.add (r);
		}
		return rows;
	}

}

public class LuDocRelationTypeInfo implements Serializable, Idable, HasAttributes {

    private static final long serialVersionUID = 1L;

    @XmlElement
    private String name;

    @XmlElement
    private String desc;

    @XmlElement
    private Date effectiveDate;

    @XmlElement
    private Date expirationDate;

    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String, String> attributes;

    @XmlAttribute(name="key")
    private String id;

    /**
     * Friendly name of the LU document relationship type
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * Narrative description of the LU document relationship type
     */
    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this LU document relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LU document relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * The page luDocumentTypeKey Structure does not exist.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

public class ScaleInfo implements Serializable, Idable, HasAttributes {

    private static final long serialVersionUID = 1L;

    @XmlElement
    private String name;

    @XmlElement
    private RichTextInfo desc;

    @XmlElement
    private Date effectiveDate;

    @XmlElement
    private Date expirationDate;

    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String, String> attributes;

    @XmlAttribute(name="key")
    private String id;

    /**
     * Name of the scale.
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * Description of the scale.
     */
    public RichTextInfo getDesc() {
        return desc;
    }

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this scale became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this scale expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a scale.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

public class PersonTypeInfo implements Serializable, Idable, HasAttributes {

    private static final long serialVersionUID = 1L;

    @XmlElement
    private String name;

    @XmlElement
    private String desc;

    @XmlElement
    private Date effectiveDate;

    @XmlElement
    private Date expirationDate;

    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String, String> attributes;

    @XmlAttribute(name="key")
    private String id;

    /**
     * Friendly name for a person type.
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * Narrative description for a person type.
     */
    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this person type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this person type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a person type.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

						MultiplicityFieldConfiguration field = fields.get(i).get(j);
	    				String fieldKey = translatePath(field.getFieldPath(), path, number);
	    				FieldDescriptorReadOnly fd1 = new FieldDescriptorReadOnly(fieldKey, field.getMessageKeyInfo(), field.getMetadata());
	    				fd1.setOptional(field.isOptional());
	    				if(field.getModelWidgetBinding() != null){
	    					fd1.setWidgetBinding(field.getModelWidgetBinding());
	    				}
	    				FieldDescriptorReadOnly fd2 = new FieldDescriptorReadOnly(fieldKey, field.getMessageKeyInfo(), field.getMetadata());
	    				fd2.setOptional(field.isOptional());
	    				if(field.getModelWidgetBinding() != null){
	    					fd2.setWidgetBinding(field.getModelWidgetBinding());
	    				}
	    				SummaryTableFieldRow row = new SummaryTableFieldRow(fd1, fd2);
	    				row.setTemporaryRowFlag(true);
	    				rowList.add(index, row);
	    				index++;
	    				fieldRowsCreated++;
	    			}
				}
				
    			
	    		if(config.getNestedConfig() != null){
	    			MultiplicityConfiguration nestedConfig = config.getNestedConfig();
	    			nestedConfig.getParentFd().getFieldKey().replace(config.getParentFd().getFieldKey(), path);
	    			SummaryTableMultiplicityFieldRow mRow = new SummaryTableMultiplicityFieldRow(nestedConfig);
	    			mRow.setTemporaryRowFlag(true);
	    			rowList.add(index, mRow);
	    			index++;
	    			fieldRowsCreated++;

    }

    /**
     * Method to fetch the organization ids from the KEW document content XML
     * 
     * @param context
     *            - RouteContext class that holds data about the current document's routing and data
     * @return A list of organization ids that are listed in the XML (may have duplicates if duplicates are allowed by
     *         KS code)
     */
    protected Set<String> getOrganizationIdsFromDocumentContent(RouteContext context) {
        String baseXpathExpression = "/" + KEWConstants.DOCUMENT_CONTENT_ELEMENT + "/" + KEWConstants.APPLICATION_CONTENT_ELEMENT + "/" + DOCUMENT_CONTENT_XML_ROOT_ELEMENT_NAME;
        String orgXpathExpression = "./" + getOrganizationIdDocumentContentFieldKey(context);
        Document xmlContent = context.getDocumentContent().getDocument();
        XPath xPath = XPathHelper.newXPath();
        try {
            NodeList baseElements = (NodeList) xPath.evaluate(baseXpathExpression, xmlContent, XPathConstants.NODESET);
            if (LOG.isDebugEnabled()) {
                LOG.debug("Found " + baseElements.getLength() + " baseElements to parse for AttributeSets using document XML:");
                XmlHelper.printDocumentStructure(xmlContent);
            }
            Set<String> distinctiveOrganizationIds = new HashSet<String>();
            for (int i = 0; i < baseElements.getLength(); i++) {
                Node baseNode = baseElements.item(i);
                NodeList attributes = (NodeList) xPath.evaluate(orgXpathExpression, baseNode, XPathConstants.NODESET);
                for (int j = 0; j < attributes.getLength(); j++) {
                    Element attributeElement = (Element) attributes.item(j);
                    distinctiveOrganizationIds.add(attributeElement.getTextContent());
                }
            }
            return distinctiveOrganizationIds;
        } catch (XPathExpressionException e) {
            throw new RuntimeException("Encountered an issue executing XPath.", e);
        }
    }

    protected List<SearchResultRow> relatedOrgsFromOrgId(String orgId, String relationType, String relatedOrgType) {

        return dictionaryServiceDelegate.getObjectTypes();
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchCriteriaType(java.lang.String)
	 */
    @Override
    public SearchCriteriaTypeInfo getSearchCriteriaType(
            String searchCriteriaTypeKey) throws DoesNotExistException,
            InvalidParameterException, MissingParameterException,
            OperationFailedException {

        return searchManager.getSearchCriteriaType(searchCriteriaTypeKey);
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchCriteriaTypes()
	 */
    @Override
    public List<SearchCriteriaTypeInfo> getSearchCriteriaTypes()
    throws OperationFailedException {
        return searchManager.getSearchCriteriaTypes();
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchResultType(java.lang.String)
	 */
    @Override
    public SearchResultTypeInfo getSearchResultType(String searchResultTypeKey)
    throws DoesNotExistException, InvalidParameterException,
    MissingParameterException, OperationFailedException {
        checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
        return searchManager.getSearchResultType(searchResultTypeKey);
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchResultTypes()
	 */
    @Override
    public List<SearchResultTypeInfo> getSearchResultTypes()
    throws OperationFailedException {
        return searchManager.getSearchResultTypes();
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchType(java.lang.String)
	 */
    @Override
    public SearchTypeInfo getSearchType(String searchTypeKey)
    throws DoesNotExistException, InvalidParameterException,
    MissingParameterException, OperationFailedException {
        checkForMissingParameter(searchTypeKey, "searchTypeKey");
        return searchManager.getSearchType(searchTypeKey);
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchTypes()
	 */
    @Override
    public List<SearchTypeInfo> getSearchTypes()
    throws OperationFailedException {
        return searchManager.getSearchTypes();
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchTypesByCriteria(java.lang.String)
	 */
    @Override
    public List<SearchTypeInfo> getSearchTypesByCriteria(
            String searchCriteriaTypeKey) throws DoesNotExistException,
            InvalidParameterException, MissingParameterException,
            OperationFailedException {
        checkForMissingParameter(searchCriteriaTypeKey, "searchCriteriaTypeKey");
        return searchManager.getSearchTypesByCriteria(searchCriteriaTypeKey);
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchTypesByResult(java.lang.String)
	 */
    @Override
    public List<SearchTypeInfo> getSearchTypesByResult(
            String searchResultTypeKey) throws DoesNotExistException,
            InvalidParameterException, MissingParameterException,
            OperationFailedException {
        checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
        return searchManager.getSearchTypesByResult(searchResultTypeKey);
    }

	@Override
	public LoLoRelationInfo createLoLoRelation(String loId, String relatedLoId,

    }
    
    protected SummaryTableFieldRow getFieldRow(String fieldKey, MessageKeyInfo messageKey) {
        return getFieldRow(fieldKey, messageKey, null, null, null, null, false);
    }
    protected SummaryTableFieldRow getFieldRow(String fieldKey, MessageKeyInfo messageKey, boolean optional) {
        return getFieldRow(fieldKey, messageKey, null, null, null, null, optional);
    }

    protected SummaryTableFieldRow getFieldRow(String fieldKey, MessageKeyInfo messageKey, Widget widget, Widget widget2, String parentPath, ModelWidgetBinding<?> binding, boolean optional) {
        QueryPath path = QueryPath.concat(parentPath, fieldKey);
        Metadata meta = modelDefinition.getMetadata(path);

        FieldDescriptorReadOnly fd = new FieldDescriptorReadOnly(path.toString(), messageKey, meta);
        if (widget != null) {
            fd.setFieldWidget(widget);
        }
        if(binding != null){
            fd.setWidgetBinding(binding);
        }
        fd.setOptional(optional);

        FieldDescriptorReadOnly fd2 = new FieldDescriptorReadOnly(path.toString(), messageKey, meta);
        if (widget2 != null) {
            fd2.setFieldWidget(widget2);
        }
        if(binding != null){
            fd2.setWidgetBinding(binding);
        }
        fd2.setOptional(optional);

        SummaryTableFieldRow fieldRow = new SummaryTableFieldRow(fd,fd2);

        return fieldRow;
    }

    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchCriteriaType(java.lang.String)
	 */
    @Override
    public SearchCriteriaTypeInfo getSearchCriteriaType(
            String searchCriteriaTypeKey) throws DoesNotExistException,
            InvalidParameterException, MissingParameterException,
            OperationFailedException {

        return searchManager.getSearchCriteriaType(searchCriteriaTypeKey);
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchCriteriaTypes()
	 */
    @Override
    public List<SearchCriteriaTypeInfo> getSearchCriteriaTypes()
    throws OperationFailedException {
        return searchManager.getSearchCriteriaTypes();
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchResultType(java.lang.String)
	 */
    @Override
    public SearchResultTypeInfo getSearchResultType(String searchResultTypeKey)
    throws DoesNotExistException, InvalidParameterException,
    MissingParameterException, OperationFailedException {
        checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
        return searchManager.getSearchResultType(searchResultTypeKey);
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchResultTypes()
	 */
    @Override
    public List<SearchResultTypeInfo> getSearchResultTypes()
    throws OperationFailedException {
        return searchManager.getSearchResultTypes();
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchType(java.lang.String)
	 */
    @Override
    public SearchTypeInfo getSearchType(String searchTypeKey)
    throws DoesNotExistException, InvalidParameterException,
    MissingParameterException, OperationFailedException {
        checkForMissingParameter(searchTypeKey, "searchTypeKey");
        return searchManager.getSearchType(searchTypeKey);
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchTypes()
	 */
    @Override
    public List<SearchTypeInfo> getSearchTypes()
    throws OperationFailedException {
        return searchManager.getSearchTypes();
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchTypesByCriteria(java.lang.String)
	 */
    @Override
    public List<SearchTypeInfo> getSearchTypesByCriteria(
            String searchCriteriaTypeKey) throws DoesNotExistException,
            InvalidParameterException, MissingParameterException,
            OperationFailedException {
        checkForMissingParameter(searchCriteriaTypeKey, "searchCriteriaTypeKey");
        return searchManager.getSearchTypesByCriteria(searchCriteriaTypeKey);
    }

	/* (non-Javadoc)
	 * @see org.kuali.student.core.search.service.SearchService#getSearchTypesByResult(java.lang.String)
	 */
    @Override
    public List<SearchTypeInfo> getSearchTypesByResult(
            String searchResultTypeKey) throws DoesNotExistException,
            InvalidParameterException, MissingParameterException,
            OperationFailedException {
        checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
        return searchManager.getSearchTypesByResult(searchResultTypeKey);
    }

	@Override
	public LoLoRelationInfo createLoLoRelation(String loId, String relatedLoId,

    }

	@Override
	public SearchCriteriaTypeInfo getSearchCriteriaType(
			String searchCriteriaTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {

		return searchManager.getSearchCriteriaType(searchCriteriaTypeKey);
	}

	@Override
	public List<SearchCriteriaTypeInfo> getSearchCriteriaTypes()
			throws OperationFailedException {
		return searchManager.getSearchCriteriaTypes();
	}

	@Override
	public SearchResultTypeInfo getSearchResultType(String searchResultTypeKey)
			throws DoesNotExistException, InvalidParameterException,
			MissingParameterException, OperationFailedException {
		checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
		return searchManager.getSearchResultType(searchResultTypeKey);
	}

	@Override
	public List<SearchResultTypeInfo> getSearchResultTypes()
			throws OperationFailedException {
		return searchManager.getSearchResultTypes();
	}

	@Override
	public SearchTypeInfo getSearchType(String searchTypeKey)
			throws DoesNotExistException, InvalidParameterException,
			MissingParameterException, OperationFailedException {
		checkForMissingParameter(searchTypeKey, "searchTypeKey");
		return searchManager.getSearchType(searchTypeKey);
	}

	@Override
	public List<SearchTypeInfo> getSearchTypes()
			throws OperationFailedException {
		return searchManager.getSearchTypes();
	}

	@Override
	public List<SearchTypeInfo> getSearchTypesByCriteria(
			String searchCriteriaTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {
		checkForMissingParameter(searchCriteriaTypeKey, "searchCriteriaTypeKey");
		return searchManager.getSearchTypesByCriteria(searchCriteriaTypeKey);
	}

	@Override
	public List<SearchTypeInfo> getSearchTypesByResult(
			String searchResultTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {
		checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
		return searchManager.getSearchTypesByResult(searchResultTypeKey);
	}

	public SearchManager getSearchManager() {

	}

	/**************************************************************************
	 * SEARCH OPERATIONS *
	 **************************************************************************/

	@Override
	public SearchCriteriaTypeInfo getSearchCriteriaType(
			String searchCriteriaTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {

		return searchManager.getSearchCriteriaType(searchCriteriaTypeKey);
	}

	@Override
	public List<SearchCriteriaTypeInfo> getSearchCriteriaTypes()
			throws OperationFailedException {
		return searchManager.getSearchCriteriaTypes();
	}

	@Override
	public SearchResultTypeInfo getSearchResultType(String searchResultTypeKey)
			throws DoesNotExistException, InvalidParameterException,
			MissingParameterException, OperationFailedException {
		checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
		return searchManager.getSearchResultType(searchResultTypeKey);
	}

	@Override
	public List<SearchResultTypeInfo> getSearchResultTypes()
			throws OperationFailedException {
		return searchManager.getSearchResultTypes();
	}

	@Override
	public SearchTypeInfo getSearchType(String searchTypeKey)
			throws DoesNotExistException, InvalidParameterException,
			MissingParameterException, OperationFailedException {
		checkForMissingParameter(searchTypeKey, "searchTypeKey");
		return searchManager.getSearchType(searchTypeKey);
	}

	@Override
	public List<SearchTypeInfo> getSearchTypes()
			throws OperationFailedException {
		return searchManager.getSearchTypes();
	}

	@Override
	public List<SearchTypeInfo> getSearchTypesByCriteria(
			String searchCriteriaTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {
		checkForMissingParameter(searchCriteriaTypeKey, "searchCriteriaTypeKey");
		return searchManager.getSearchTypesByCriteria(searchCriteriaTypeKey);
	}

	@Override
	public List<SearchTypeInfo> getSearchTypesByResult(
			String searchResultTypeKey) throws DoesNotExistException,
			InvalidParameterException, MissingParameterException,
			OperationFailedException {
		checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
		return searchManager.getSearchTypesByResult(searchResultTypeKey);
	}

        return data.get(Properties.TYPE.getKey());
    }
    
    public Date getEffectiveDate() {
        if(data.get(Properties.EFFECTIVE_DATE.getKey()) instanceof String){
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
          
                try {
                    return df.parse((String) data.get(Properties.EFFECTIVE_DATE.getKey()));
                } catch (Exception e) {
                    LOG.error(e);
                }
            
        }
        return data.get(Properties.EFFECTIVE_DATE.getKey());
    }
    
    public void setEffectiveDate(Date value)  {
        data.set(Properties.EFFECTIVE_DATE.getKey(), value);
    }
    
    public Date getExpirationDate() {
        if(data.get(Properties.EXPIRATION_DATE.getKey()) instanceof String){
            DateFormat df = new SimpleDateFormat("yyyy-MM-dd");
            try {
                return df.parse((String) data.get(Properties.EXPIRATION_DATE.getKey()));
            } catch (Exception e) {
                LOG.error(e);
            }
        }
        return data.get(Properties.EXPIRATION_DATE.getKey());
    }
    
    public void setExpirationDate(Date value)  {
        data.set(Properties.EXPIRATION_DATE.getKey(), value);
    }

    private String id;

    /**
     * Name of this credit. This may have a direct relation to the combination of value and type fields.
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * Description of this credit.
     */
    public RichTextInfo getDesc() {
        return desc;
    }

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Value of the credit. This may be numeric based on the type of credit (ex. academic credit hours could be an integer).
     */
    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    /**
     * Date and time that this credit value became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this credit value expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a credit type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The page creditId Structure does not exist.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

                row++;
                col = 0;
            }

        }
        else if (maxCols <= 2){
            //Row flow - increment row faster than column
            int maxRows = (itemCount / maxCols) + (itemCount % 2);
            for (String id:super.getListItems().getItemIds()){
                currCount++;
                row = (currCount % maxRows);
                row = ((row == 0) ? maxRows:row) - 1;

                layout.setWidget(row, col, createCheckboxWithLabel(id));                    

                col += ((row + 1)/ maxRows) * 1;

            }
        } else {
            //Column flow - increment column faster than row
            for (String id:super.getListItems().getItemIds()){
                currCount++;
                col = currCount % maxCols;
                col = ((col == 0) ? maxCols:col) - 1;

                layout.setWidget(row, col, createCheckboxWithLabel(id));

                row += ((col + 1 )/ maxCols) * 1;
            }
        }
        
        setInitialized(true);
    }

    @Override
    public <T extends Idable> void setListItems(ListItems listItems) {
        if(listItems instanceof ModelListItems){
            Callback<T> redrawCallback = new Callback<T>(){

                @Override 
                public void exec(T result){

                    HistoryManager.navigate(AppLocations.Locations.EDIT_BACC_PROGRAM.getLocation(), viewContext);
                }
            }
        });
        eventBus.addHandler(ProgramViewEvent.TYPE, new ProgramViewEvent.Handler() {
            @Override
            public void onEvent(ProgramViewEvent event) {
                actionBox.setSelectedIndex(0);
            }
        });
        eventBus.addHandler(ModelLoadedEvent.TYPE, new ModelLoadedEvent.Handler() {
            @Override
            public void onEvent(ModelLoadedEvent event) {
                resetActionList();
            }
        });
    }

    @Override
    protected void configureView() {
        super.configureView();
        addContentWidget(actionBox);
        initialized = true;
    }

    protected void resetActionList() {
        //Only allow modify with version option for an active course that id also the latest version
        ProgramStatus status = ProgramStatus.of(programModel.<String>get(ProgramConstants.STATE));
        String versionIndId = programModel.get(ProgramConstants.VERSION_IND_ID);
        Long sequenceNumber = programModel.get(ProgramConstants.VERSION_SEQUENCE_NUMBER);

        actionBox.clear();
        if (status == ProgramStatus.ACTIVE) {
            programRemoteService.isLatestVersion(versionIndId, sequenceNumber, new KSAsyncCallback<Boolean>() {
                public void onSuccess(Boolean isLatest) {
                    actionBox.setList(ActionType.getValues(isLatest));
                }
            });
        } else {
            actionBox.setList(ActionType.getValues(false));
        }
    }
}

    }

    /**
     * The first academic time period that this credential program would be effective. This may not reflect the first "real" academic time period for this program. 
     */
    public String getStartTerm() {
        return startTerm;
    }

    public void setStartTerm(String startTerm) {
        this.startTerm = startTerm;
    }
    
    /**
     * The last academic time period that this credential program would be effective.   
     */
    public String getEndTerm() {
        return endTerm;
    }

    public void setEndTerm(String endTerm) {
        this.endTerm = endTerm;
    }
    
    /**
     * The last academic time period that this credential program would be available for enrollment. This may not reflect the last "real" academic time period for this program.    
     */
    public String getEndProgramEntryTerm() {
        return endProgramEntryTerm;
    }

    public void setEndProgramEntryTerm(String endProgramEntryTerm) {
        this.endProgramEntryTerm = endProgramEntryTerm;
    }

    /**
     * Divisions responsible to make changes to the credential program  
     */
    public List<String> getDivisionsContentOwner() {
        return divisionsContentOwner;
    }

    public void setDivisionsContentOwner(List<String> divisionsContentOwner) {
        this.divisionsContentOwner = divisionsContentOwner;
    }

    /**
     * Divisions responsible for student exceptions to the credential program.  
     */
    public List<String> getDivisionsStudentOversight() {
        return divisionsStudentOversight;
    }

    public void setDivisionsStudentOversight(List<String> divisionsStudentOversight) {
        this.divisionsStudentOversight = divisionsStudentOversight;
    }

    /*
     * Unit responsible to make changes to the credential program   
     */
    public List<String> getUnitsContentOwner() {
        return unitsContentOwner;
    }

    public void setUnitsContentOwner(List<String> unitsContentOwner) {
        this.unitsContentOwner = unitsContentOwner;
    }

    /**
     * Unit responsible for student exceptions to the credential program.   
     */
    public List<String> getUnitsStudentOversight() {
        return unitsStudentOversight;
    }

    public void setUnitsStudentOversight(List<String> unitsStudentOversight) {
        this.unitsStudentOversight = unitsStudentOversight;
    }

    /**
     * Narrative description of the Credential program. 
     */
    public RichTextInfo getDescr() {
        return descr;
    }

    public void setDescr(RichTextInfo descr) {
        this.descr = descr;
    }

    /**
     * Learning Objectives associated with this credential program. 
     */
    public List<LoDisplayInfo> getLearningObjectives() {

        pagingScrollTable.fillWidth();
    }

    public List<ResultRow> getSelectedRows(){
        List<ResultRow> rows = new ArrayList<ResultRow>();
        Set<Integer> selectedRows = pagingScrollTable.getDataTable().getSelectedRows();
        for(Integer i: selectedRows){
            rows.add(pagingScrollTable.getRowValue(i));
        }
        return rows;
    }

    public List<String> getSelectedIds(){
        List<String> ids = new ArrayList<String>();
        Set<Integer> selectedRows = pagingScrollTable.getDataTable().getSelectedRows();
        for(Integer i: selectedRows){
            ids.add(pagingScrollTable.getRowValue(i).getId());
        }
        return ids;
    }

    public List<String> getAllIds(){
        List<String> ids = new ArrayList<String>();
        for(ResultRow r: resultRows){
            ids.add(r.getId());
        }
        return ids;
    }

    public List<ResultRow> getAllRows(){
        List<ResultRow> rows = new ArrayList<ResultRow>();
        for(ResultRow r: resultRows){
            rows.add(r);
        }
        return rows;
    }

	}
	
    //This builds up a list of the child nodes so that the spring parseListElement can be used
    //it also translates <fooRef> elements into straight spring <ref> elements
    private Element getChildList(Element element, String localName) {
    	try{
    		//Create a new document to contain our list of elements
	    	DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
	    	DocumentBuilder builder = dbf.newDocumentBuilder();
	    	Document doc = builder.newDocument();
	
	    	Element root = doc.createElement("listRoot");
	    	
	        for(int i = 0;i<element.getChildNodes().getLength();i++){
	            Node node = element.getChildNodes().item(i);
	            if(Node.ELEMENT_NODE == node.getNodeType() && localName.equals(node.getLocalName())){
	            	
	            	//Copy the node from the spring config to our list
	            	Node copied = doc.importNode(node, true);
	            	root.appendChild(copied);
	            }
	            if(Node.ELEMENT_NODE == node.getNodeType() && (localName+"Ref").equals(node.getLocalName())){
	            	
	            	//Create a new spring ref element and copy the bean attribute
	            	Element ref = doc.createElement("ref");
	            	ref.setAttribute("bean", ((Element)node).getAttribute("bean"));
	            	root.appendChild(ref);
	            }
	        }
	        
	    	return root;
    	}catch(Exception e){
    		logger.error("Exception occured: ", e);
    	}
    	return null;
	}
    
	private Element getFirstChildElement(Node node) {

        courseBriefSection.addShowRowCallback(new ShowRowConditionCallback(){
			@Override
			public void processShowConditions(SummaryTableFieldRow row,
					DataModel column1, DataModel column2) {
				if(row.getFieldDescriptor1() != null &&
						row.getFieldDescriptor1().getFieldKey().contains(CREDIT_OPTIONS) &&
						row.getFieldDescriptor1().getFieldKey().contains("resultValues")){
		    		String type = row.getFieldDescriptor1().getFieldKey().replace("resultValues", CreditCourseConstants.TYPE);
		    		Object data1 = null;
		    		Object data2 = null;
		    		if(column1 != null){
		    			data1 = column1.get(type);
		    		}
		    		if(column2 != null){
		    			data2 = column2.get(type);
		    		}

		    		if(data1 != null && data1 instanceof String){
		    			if(!((String)data1).equals("kuali.resultComponentType.credit.degree.multiple")){
		    				row.setShown(false);
		    			}
		    		}
		    		else if(data2 != null && data2 instanceof String){
		    			if(!((String)data2).equals("kuali.resultComponentType.credit.degree.multiple")){
		    				row.setShown(false);
		    			}
		    		}
		    	}
			}
		});
        block.addSummaryMultiplicity(outcomesConfig);

    public LearningObjectivesEditConfiguration() {
        rootSection = new VerticalSectionView(ProgramSections.LEARNING_OBJECTIVES_EDIT, ProgramProperties.get().program_menu_sections_learningObjectives(), ProgramConstants.PROGRAM_MODEL_ID);
    }

    protected void buildLayout() {
        VerticalSection section = new VerticalSection();
        QueryPath path = QueryPath.concat("", ProgramConstants.LEARNING_OBJECTIVES, "*", "loInfo", "desc");
        Metadata meta = configurer.getModelDefinition().getMetadata(path);
        FieldDescriptor fd = addField(section, ProgramConstants.LEARNING_OBJECTIVES,
                null,
                new LOBuilder("type", "state", "course", "kuali.loRepository.key.singleUse", meta),
                "");
        fd.setWidgetBinding(LOBuilderBinding.INSTANCE);
        section.addStyleName("KS-LUM-Section-Divider");
        rootSection.addSection(section);
    }

    public FieldDescriptor addField(Section section, String fieldKey, MessageKeyInfo messageKey, Widget widget, String parentPath) {
        QueryPath path = QueryPath.concat(parentPath, fieldKey);
        Metadata meta = configurer.getModelDefinition().getMetadata(path);

        FieldDescriptor fd = new FieldDescriptor(path.toString(), messageKey, meta);
        if (widget != null) {
            fd.setFieldWidget(widget);
        }
        section.addField(fd);
        return fd;
    }

}

    private class EventHandler implements ClickHandler, MouseOverHandler, MouseOutHandler{

        @Override
        public void onClick(ClickEvent event) {
            Widget sender = (Widget) event.getSource();
            if(sender instanceof MenuItemPanel){
                selectMenuItemPanel((MenuItemPanel)sender);
                sender.removeStyleName("KS-Basic-Menu-Item-Panel-Hover");
                ((MenuItemPanel) sender).getItemLabel().removeStyleName("KS-Basic-Menu-Item-Label-Hover");
            }
        }



        @Override
        public void onMouseOver(MouseOverEvent event) {
            Widget sender = (Widget) event.getSource();
            if(sender instanceof MenuItemPanel){
                if(((MenuItemPanel) sender).isSelectable() && !((MenuItemPanel) sender).isSelected()){
                    sender.addStyleName("KS-Basic-Menu-Item-Panel-Hover");
                    ((MenuItemPanel) sender).getItemLabel().addStyleName("KS-Basic-Menu-Item-Label-Hover");
                }
            }
        }

        @Override
        public void onMouseOut(MouseOutEvent event) {
            Widget sender = (Widget) event.getSource();
            if(sender instanceof MenuItemPanel){
                if(((MenuItemPanel) sender).isSelectable()){
                    sender.removeStyleName("KS-Basic-Menu-Item-Panel-Hover");
                    ((MenuItemPanel) sender).getItemLabel().removeStyleName("KS-Basic-Menu-Item-Label-Hover");
                }
            }
        }

    }

    /**
     * Date and time that this LU publication type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LU publication type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Type of publication for which this information should be used.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * Current state of the information for this publication type. This value should be constrained to those within the cluPublishingState enumeration. In general, an "active" record for a type indicates that the clu should be published within that media, though that may be further constrained by the cycle information included.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Identifier for the publishing information. This is set by the service to be able to determine changes and alterations to the structure as well as provides a handle for searches. This structure is not currently accessible through unique operations, and it is strongly recommended that no external references to this particular identifier be maintained.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
    	return "CluPublicationInfo[id=" + id + ", cluId=" + cluId + ", type=" + type + "]";

	private EventHandler handler = new EventHandler();

    private MenuEventHandler menuHandler = new MenuEventHandler(){

        @Override
        public void onChange(MenuChangeEvent e) {
            KSMenuItemData i = (KSMenuItemData) e.getSource();
            MenuItemPanel itemToChange = null;
            for(MenuItemPanel p: menuItems){
                if(i.equals(p.getItem())){
                    itemToChange = p;
                }
            }
            if(itemToChange != null){
                if(!(i.getLabel().equals(itemToChange.getItemLabel().getText()))){
                    itemToChange.getItemLabel().setText(i.getLabel());
                }
                else if(i.getShownIcon() != null){
                    itemToChange.addImage(i.getShownIcon());
                }
            }

        }

        @Override
        public void onSelect(MenuSelectEvent e) {

            KSMenuItemData i = (KSMenuItemData) e.getSource();
            MenuItemPanel itemToSelect = null;
            for(MenuItemPanel p: menuItems){
                if(i.equals(p.getItem())){
                    itemToSelect = p;
                }
            }
            if(itemToSelect != null){

            AttributeSet qualification = getQualification(idType, id, docType);
            AttributeSet permissionDetails = new AttributeSet("dtoName", dtoName);
            List<KimPermissionInfo> permissions = permissionService.getAuthorizedPermissionsByTemplateName(principalId,
            		PermissionType.FIELD_ACCESS.getPermissionNamespace(), PermissionType.FIELD_ACCESS.getPermissionTemplateName(), permissionDetails, qualification);
            Map<String, String> permMap = new HashMap<String, String>();
            if (permissions != null) {
                for (KimPermissionInfo permission : permissions) {
                    String dtoFieldKey = permission.getDetails().get("dtoFieldKey");
                    String fieldAccessLevel = permission.getDetails().get("fieldAccessLevel");
                    permMap.put(dtoFieldKey, fieldAccessLevel);
                }
            }
            return permMap;
        } catch (Exception e) {
            LOG.warn("Error calling permission service.", e);
        }
        return null;
    }
   
    /**
     * Sets the metadata node and all it's children to readOnly (i.e. canEdit=false).
     * 
     * @param metadata
     * @param readOnly
     */
	private void setReadOnly(Metadata metadata, boolean readOnly) {
		metadata.setCanEdit(!readOnly);
		Map<String, Metadata> childProperties = metadata.getProperties();
		if (childProperties != null && childProperties.size() > 0) {
			for (Metadata child : childProperties.values()) {
				setReadOnly(child, readOnly);
			}
		}
	}

    public CredentialManagingBodiesEditConfiguration() {
        rootSection = new VerticalSectionView(ProgramSections.MANAGE_BODIES_EDIT, ProgramProperties.get().program_menu_sections_managingBodies(), ProgramConstants.PROGRAM_MODEL_ID);
    }

    @Override
    protected void buildLayout() {
        HorizontalSection horizontalSection = new HorizontalSection();
        horizontalSection.addSection(createLeftSection());
        horizontalSection.addSection(createRightSection());
        rootSection.addSection(horizontalSection);
    }

    private VerticalSection createLeftSection() {
        VerticalSection section = new VerticalSection();
        configurer.addField(section, ProgramConstants.CURRICULUM_OVERSIGHT_UNIT, new MessageKeyInfo(ProgramProperties.get().managingBodies_curriculumOversightUnit()));
        configurer.addField(section, ProgramConstants.STUDENT_OVERSIGHT_UNIT, new MessageKeyInfo(ProgramProperties.get().managingBodies_studentOversightUnit()));
        return section;
    }

    private VerticalSection createRightSection() {
        VerticalSection section = new VerticalSection();
        configurer.addField(section, ProgramConstants.CURRICULUM_OVERSIGHT_DIVISION, new MessageKeyInfo(ProgramProperties.get().managingBodies_curriculumOversightDivision()));
        configurer.addField(section, ProgramConstants.STUDENT_OVERSIGHT_DIVISION, new MessageKeyInfo(ProgramProperties.get().managingBodies_studentOversightDivision()));
        return section;
    }
}

    }

    /**
     * Date and time that this LUI to LUI relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LUI to LUI relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for the LU to LU relation type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the LUI to LUI relationship. The values for this field are constrained to those in the luLuRelationState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a LUI to LUI relation. This is optional, due to the identifier being set at the time of creation. Once the relation has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Date and time the Course became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this Course expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning unit type. Once set at create time, this field may not be updated.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the course. The values for this field are constrained to those in the luState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value. This field may not be updated through updating this structure and must instead be updated through a dedicated operation.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a Course. This is optional, due to the identifier being set at the time of creation. Once the Course has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public VersionInfo getVersionInfo() {

    }

    /**
     * Date and time that this learning objective category became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this learning objective category expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning objective category type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the learning objective category. The values for this field are constrained to those in the loCategoryState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a learning objective category record. This is optional, due to the identifier being set at the time of creation. Once the learning objective category has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

	}

    /**
     * Start date and time for the date range. This must be less than or equal to the end date of this range.
     */
    public Date getStartDate() {
        return startDate;
    }

    public void setStartDate(Date startDate) {
        this.startDate = startDate;
    }

    /**
     * End date and time for the date range. This must be greater than or equal to the start date of this range.
     */
    public Date getEndDate() {
        return endDate;
    }

    public void setEndDate(Date endDate) {
        this.endDate = endDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String,String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String,String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String,String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a date range type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the date range. The values for this field are constrained to those in the dateRangeState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a date range.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

}

	public List<KeyLabelPair> getKeyValues() {
        List<KeyLabelPair> departments = new ArrayList<KeyLabelPair>();

        SearchRequest searchRequest = new SearchRequest();
        searchRequest.setSearchKey("org.search.generic");

        try {
            for (SearchResultRow result : getOrganizationService().search(searchRequest).getRows()) {
                String orgId = "";
                String orgShortName = "";
                String orgOptionalLongName = "";
                String orgType = "";
                for (SearchResultCell resultCell : result.getCells()) {
                    if ("org.resultColumn.orgId".equals(resultCell.getKey())) {
                        orgId = resultCell.getValue();
                    } else if ("org.resultColumn.orgShortName".equals(resultCell.getKey())) {
                        orgShortName = resultCell.getValue();
                    } else if ("org.resultColumn.orgOptionalLongName".equals(resultCell.getKey())) {
                    	orgOptionalLongName = resultCell.getValue();
                    } else if ("org.resultColumn.orgType".equals(resultCell.getKey())) {
                    	orgType = resultCell.getValue();
                    }
                }
                departments.add(buildKeyLabelPair(orgId, orgShortName, orgOptionalLongName, orgType));
            }

    }

    /**
     * Date and time that this learning objective became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this learning objective expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning objective type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the learning objective. The values for this field are constrained to those in the loState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a learning objective record. This is optional, due to the identifier being set at the time of creation. Once the learning objective has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

		content.addStyleName("KS-Wrapper-Content");
	}

	private void createHelpInfo(){
	    versionAnchor.addClickHandler(new ClickHandler(){

	           public void onClick(ClickEvent event) {
	               final PopupPanel helpPopup = new PopupPanel(true);
	               helpPopup.setWidget(new HTML("<br><h3>&nbsp;&nbsp; " + appVersion + "&nbsp;&nbsp;<h3>"));

	               helpPopup.setPopupPositionAndShow(new PopupPanel.PositionCallback() {
	                   public void setPosition(int offsetWidth, int offsetHeight) {
	                     int left = (Window.getClientWidth() - offsetWidth);
	                     int top = 0;
	                     helpPopup.setPopupPosition(left, top);
	                   }
	               });
	           }
	    });
	}

	private void createUserDropDown() {
		List<KSMenuItemData> items = new ArrayList<KSMenuItemData>();
    	items.add(new KSMenuItemData(getMessage("wrapperPanelLogout"),new WrapperNavigationHandler("j_spring_security_logout")));
	}

	private void createNavDropDown() {
		navDropDown.setImageLocation(MenuImageLocation.LEFT);

		List<KSMenuItemData> items = new ArrayList<KSMenuItemData>();

		items.add(new KSMenuItemData(getMessage("wrapperPanelTitleHome"),Theme.INSTANCE.getCommonImages().getApplicationIcon(),

	    private String resultDisplayKey;
	    
	    private String resultSortKey;

	    // how a search criteria will be used. ADVANCED_CUSTOM is shown on both advanced
		// and custom screens of the advanced search lightbox
	    //TODO is DEFAULT needed? it has 0 references
	    public enum Usage {
	        DEFAULT, ADVANCED, CUSTOM, ADVANCED_CUSTOM
	    }

	    private Usage usage;
	    
	    //TODO BUTTON has 0 references. Is it needed?
	    public enum Widget {
	        NO_WIDGET, SUGGEST_BOX, ADVANCED_LIGHTBOX, DROP_DOWN, BUTTON, CHECKBOX_LIST, RADIO
	    }
	    private Widget widget;    

	    public enum WidgetOption {
	        ADVANCED_LIGHTBOX_PREVIEW_MODE, ADVANCED_LIGHTBOX_ACTION_LABEL
	    }
	    
	    private Map<WidgetOption, String> widgetOptions;
	    
	    public Map<WidgetOption, String> getWidgetOptions() {
	        return widgetOptions;
	    }
	    
	    public void setWidgetOptions(Map<WidgetOption, String> widgetOptions) {
	        this.widgetOptions = widgetOptions;
	    }
	    
	    public String getWidgetOptionValue(WidgetOption widgetOption) {
	        if (widgetOptions == null) return null;
	        return widgetOptions.get(widgetOption);
	    }

	    public String getName() {
	        return name;
	    }

	    public void setName(String name) {
	        this.name = name;
	    }

	    public String getDesc() {
	        return desc;
	    }

	    public void setDesc(String desc) {
	        this.desc = desc;
	    }

	    public String getTitle() {
			return title;
		}

		public void setTitle(String title) {
			this.title = title;
		}
	    
//	    public List<LookupParamMetadata> getParams() {
//	        if (params == null) {
//	            params = new ArrayList<LookupParamMetadata>();
//	        }
//	        return params;
//	    }
//
//	    public void setParams(List<LookupParamMetadata> params) {
//	        this.params = params;
//	    }

	    public List<LookupResultMetadata> getResults() {

                    SearchParam param = new SearchParam();
                    param.setKey(metaParam.getKey());
                    if(metaParam.getDefaultValueList()==null){
                        param.setValue(metaParam.getDefaultValueString());
                    }else{
                        param.setValue(metaParam.getDefaultValueList());
                    }
                    params.add(param);
                }
                else if(metaParam.getWriteAccess() == WriteAccess.WHEN_NULL){
                    if((metaParam.getDefaultValueString() != null && !metaParam.getDefaultValueString().isEmpty())||
                       (metaParam.getDefaultValueList() != null && !metaParam.getDefaultValueList().isEmpty())){
                        SearchParam param = new SearchParam();
                        param.setKey(metaParam.getKey());
                        if(metaParam.getDefaultValueList()==null){
                            param.setValue(metaParam.getDefaultValueString());
                        }else{
                            param.setValue(metaParam.getDefaultValueList());
                        }
                        params.add(param);
                    }
                }
            }

            sr.setParams(params);

                    orgController.fireApplicationEvent(new ModifyActionEvent(id));
                }
            };
            label.addClickHandler(handlerModify);
            
            ClickHandler memberHandler = new ClickHandler() {

                @Override
                public void onClick(ClickEvent event) {
                    if(!showMembers){
                        ((KSLabel)event.getSource()).getElement().setInnerText("Hide Members " + "["+ positions + "]");
                        w.add(memberTable);
                        memberTable.fetchMemberTable();
                        memberTable.setVisible(true);
                        showMembers = true;
                        
                    }
                    else{
                        ((KSLabel)event.getSource()).getElement().setInnerText("Members " + "["+ positions + "]");
                        memberTable.setVisible(false);
                        showMembers = false;
                    }
                }

            };
            
            
            final KSLabel members = new KSLabel("Members " + "["+ positions + "]");
            members.addStyleName("action");
            members.addClickHandler(memberHandler);
            members.getElement().setAttribute("value", "");
            
            w.add(label);
            w.add(members);
            w.addStyleName("KS-Org-Tree-Section");
            
            addStyleName("KS-Org-Widget");
        }
        
    }

		ModBeanDefinitionVisitor visitor = new ModBeanDefinitionVisitor(valueResolver);
		
		String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
		for (int i = 0; i < beanNames.length; i++) {
			// Check that we're not parsing our own bean definition,
			// to avoid failing on unresolvable placeholders in properties file locations.
			if (!(beanNames[i].equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) {
				BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(beanNames[i]);
				try {
					visitor.visitBeanDefinition(bd);
				}
				catch (BeanDefinitionStoreException ex) {
					throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanNames[i], ex.getMessage());
				}
			}
		}
		
		// New in Spring 2.5: resolve placeholders in alias target names and aliases as well.
		beanFactoryToProcess.resolveAliases(valueResolver);
	}
	
	/**
	 * BeanDefinitionVisitor that resolves placeholders in String values,
	 * delegating to the <code>parseStringValue</code> method of the
	 * containing class.
	 */
	public class PlaceholderResolvingStringValueResolver implements StringValueResolver {

		private final Properties props;

		public PlaceholderResolvingStringValueResolver(Properties props) {
			this.props = props;
		}

		public String resolveStringValue(String strVal) throws BeansException {
			String value = parseStringValue(strVal, this.props, new HashSet<String>());
			return (value.equals(nullValue) ? null : value);
		}
		
		public Properties resolvePropertyValue(String strVal){

    public CluSetManagementIdTranslatorAssemblerFilter(IdTranslator idTranslator) {
        this.idTranslator = idTranslator;
    }
    
    @Override
    public void doGetFilter(FilterParamWrapper<String> id, FilterParamWrapper<Data> response, GetFilterChain<Data, Void> chain) throws AssemblyException {
        chain.doGetFilter(id, response);
        Data data = response.getValue(); 
        if (data != null) {
            translateIds(data, chain);
        }
    }
    
    @Override
    public void doSaveFilter(FilterParamWrapper<Data> request, FilterParamWrapper<SaveResult<Data>> response, SaveFilterChain<Data, Void> chain) throws AssemblyException {
        chain.doSaveFilter(request, response);
        SaveResult<Data> saveResult = response.getValue();
        Data data = saveResult != null && saveResult.getValue() != null ? saveResult.getValue() : null;
        if(data != null) {
            translateIds(data, chain);
        }
    }

    private void translateIds(Data data, AssemblerManagerAccessable<Data, Void> chain) throws AssemblyException {

		}
	}

	@Override
	public String getObjectId() {
		return (dataMap.containsKey("id") && null != dataMap.get("id")) ? dataMap.get("id").toString() : null;
	}

	@Override
	public Object getValue(String fieldKey) {
		return dataMap.get(fieldKey);
	}

	@Override
	public Boolean hasField(String fieldKey) {
		return dataMap.containsKey(fieldKey);
	}

	private Map<String, PropertyDescriptor> getBeanInfo(Class<?> clazz) {
		Map<String, PropertyDescriptor> properties = new HashMap<String, PropertyDescriptor>();
		BeanInfo beanInfo = null;
		try {
			beanInfo = Introspector.getBeanInfo(clazz);
		} catch (IntrospectionException e) {
			throw new RuntimeException(e);
		}
		PropertyDescriptor[] propertyDescriptors = beanInfo
				.getPropertyDescriptors();
		for (PropertyDescriptor propertyDescriptor : propertyDescriptors) {
			properties.put(propertyDescriptor.getName(), propertyDescriptor);
		}
		return properties;
	}
}

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

        
    public VersionInfo getVersionInfo() {
		return versionInfo;
	}

	public void setVersionInfo(VersionInfo versionInfo) {
		this.versionInfo = versionInfo;
	}

	/**
     * Unique identifier for a learning unit type. Once set at create time, this field may not be updated.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the credential program. The values for this field are constrained to those in the luState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for an Core Program Requirement. This is optional, due to the identifier being set at the time of creation. Once the Program has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
    
    /**
     * Abbreviated name of the Core requirement 
     */
    public String getShortTitle() {

    }

    public String getNodeSpecificOrganizationIdAttributeSetKey(RouteContext context) {
        String organizationIdFieldKey = RouteNodeUtils.getValueOfCustomProperty(context.getNodeInstance().getRouteNode(), ROUTE_NODE_XML_ORG_ID_QUALIFIER_KEY);
        if (StringUtils.isBlank(organizationIdFieldKey)) {
            if (usesNonDerivedOrganizationRoles(context)) {
                throw new RuntimeException("Cannot find required XML element '" + ROUTE_NODE_XML_ORG_ID_QUALIFIER_KEY + "' on the Route Node XML configuration.");
            }
        }
        return organizationIdFieldKey;
    }

    public String getNodeSpecificOrganizationShortNameAttributeSetKey(RouteContext context) {
        String organizationShortNameFieldKey = RouteNodeUtils.getValueOfCustomProperty(context.getNodeInstance().getRouteNode(), ROUTE_NODE_XML_ORG_SHORT_NAME_QUALIFIER_KEY);
        if (StringUtils.isBlank(organizationShortNameFieldKey)) {
            if (usesNonDerivedOrganizationRoles(context)) {
                throw new RuntimeException("Cannot find required XML element '" + ROUTE_NODE_XML_ORG_SHORT_NAME_QUALIFIER_KEY + "' on the Route Node XML configuration.");
            }
        }
        return organizationShortNameFieldKey;
    }

    public Boolean usesNonDerivedOrganizationRoles(RouteContext context) {
        String useNonDerivedOrganizationRoles = RouteNodeUtils.getValueOfCustomProperty(context.getNodeInstance().getRouteNode(), ROUTE_NODE_XML_USE_NON_DERIVED_ROLES);
        if (StringUtils.isNotBlank(useNonDerivedOrganizationRoles)) {
            return Boolean.valueOf(useNonDerivedOrganizationRoles);
        }
        return true;
    }

    @XmlElement
    private List<String> divisionsContentOwner;
    
    @XmlElement
    private List<String> divisionsStudentOversight;

    @XmlElement
    private List<String> divisionsDeployment;

    @XmlElement
    private List<String> divisionsFinancialResources;

    @XmlElement
    private List<String> divisionsFinancialControl;

    @XmlElement
    private List<String> unitsContentOwner;
    
    @XmlElement
    private List<String> unitsStudentOversight;

    @XmlElement
    private List<String> unitsDeployment;

    @XmlElement
    private List<String> unitsFinancialResources;

    @XmlElement
    private List<String> unitsFinancialControl;

    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String, String> attributes;

    @XmlElement
    private MetaInfo metaInfo;

    @XmlElement
    private VersionInfo versionInfo;    

    @XmlAttribute
    private String type;

    @XmlAttribute
    private String state;

    @XmlAttribute
    private String id;

    /**
     * Indicates if the program is full time, part time, both etc
     */
    public String getIntensity() {
        return intensity;
    }

    public void setIntensity(String intensity) {
        this.intensity = intensity;
    }

    /**
     * An URL for additional information about the Variation.
     */
    public String getReferenceURL() {
        return referenceURL;
    }

    public void setReferenceURL(String referenceURL) {
        this.referenceURL = referenceURL;
    }

    /**
     * The composite string that is used to officially reference or publish the Variation. Note it may have an internal structure that each Institution may want to enforce.
     */
    public String getCode() {

    }

    /**
     * Date and time that this LUI became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LUI expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * The current status of the LUI. The values for this field are constrained to those in the luState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a Learning Unit Instance (LUI). This is optional, due to the identifier being set at the time of creation. Once the LUI has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

public class UpdatePositionRestrictionForOrg {

    @XmlElement(name = "orgId")
    private java.lang.String orgId;
    @XmlElement(name = "orgPersonRelationTypeKey")
    private java.lang.String orgPersonRelationTypeKey;
    @XmlElement(name = "orgPositionRestrictionInfo")
    private org.kuali.student.core.organization.dto.OrgPositionRestrictionInfo orgPositionRestrictionInfo;

    public java.lang.String getOrgId() {
        return this.orgId;
    }

    public void setOrgId(java.lang.String newOrgId)  {
        this.orgId = newOrgId;
    }

    public java.lang.String getOrgPersonRelationTypeKey() {
        return this.orgPersonRelationTypeKey;
    }

    public void setOrgPersonRelationTypeKey(java.lang.String newOrgPersonRelationTypeKey)  {
        this.orgPersonRelationTypeKey = newOrgPersonRelationTypeKey;
    }

    public org.kuali.student.core.organization.dto.OrgPositionRestrictionInfo getOrgPositionRestrictionInfo() {
        return this.orgPositionRestrictionInfo;
    }

    public void setOrgPositionRestrictionInfo(org.kuali.student.core.organization.dto.OrgPositionRestrictionInfo newOrgPositionRestrictionInfo)  {
        this.orgPositionRestrictionInfo = newOrgPositionRestrictionInfo;
    }

}

  builder.append (rowSeperator);
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("Field");
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("Required?");
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("DataType");
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("Length");
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("Dynamic");
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("Default");
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("Repeats?");
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("Valid Characters");
  builder.append (colSeperator);
  builder.append (colSeperator);
  builder.append ("Lookup");

        block.addSummaryTableFieldRow(getFieldRow(COURSE + "/" + AUDIT, generateMessageInfo(LUUIConstants.LEARNING_RESULT_AUDIT_LABEL_KEY), true));
        MultiplicityConfiguration formatsConfig = getMultiplicityConfig(COURSE + QueryPath.getPathSeparator() + FORMATS,
		        LUUIConstants.FORMAT_LABEL_KEY,
		        null);
        MultiplicityConfiguration activitiesConfig = getMultiplicityConfig(COURSE + QueryPath.getPathSeparator() + FORMATS + QueryPath.getPathSeparator()
        		+ QueryPath.getWildCard() + QueryPath.getPathSeparator() + ACTIVITIES,
		        LUUIConstants.ACTIVITY_LITERAL_LABEL_KEY,
		        Arrays.asList(
		                Arrays.asList(ACTIVITY_TYPE, LUUIConstants.ACTIVITY_TYPE_LABEL_KEY),
		                Arrays.asList(CONTACT_HOURS + "/" + "unitQuantity", LUUIConstants.CONTACT_HOURS_LABEL_KEY),
		                Arrays.asList(CONTACT_HOURS + "/" + "unitType", "per"),
		                Arrays.asList(CreditCourseActivityConstants.DURATION + "/" + "atpDurationTypeKey", LUUIConstants.DURATION_TYPE_LABEL_KEY),
		                Arrays.asList(CreditCourseActivityConstants.DURATION + "/" + "timeQuantity", LUUIConstants.DURATION_LITERAL_LABEL_KEY),
		                Arrays.asList(DEFAULT_ENROLLMENT_ESTIMATE, LUUIConstants.CLASS_SIZE_LABEL_KEY)));
        formatsConfig.setNestedConfig(activitiesConfig);
        block.addSummaryMultiplicity(formatsConfig);

public class LUUIConstants {

	// FIXME: Duplicated from lum-api LUConstants
		    public final static String COURSE_GROUP_NAME = "course";
		    public final static String PROPOSAL_TYPE_COURSE_CREATE = "kuali.proposal.type.course.create";
		    public final static String CLU_TYPE_CREDIT_COURSE = "kuali.lu.type.CreditCourse";
		    public final static String PROGRAM_GROUP_NAME = "program";    
		    public final static String PROPOSAL_TYPE_PROGRAM_CREATE = "kuali.proposal.type.program.create";
		    public final static String CLU_TYPE_CREDIT_PROGRAM = "kuali.lu.type.CreditProgram";    
		    
			// found this in https://test.kuali.org/confluence/display/KULSTU/LuConfig.Types.LuLuRelationType
		    public final static String LU_LU_RELATION_TYPE_HAS_COURSE_FORMAT = "luLuRelationType.hasCourseFormat";
		    public final static String LU_LU_RELATION_TYPE_CONTAINS = "luLuRelationType.contains";
		    public final static String LU_LU_RELATION_TYPE_CROSS_LISTED = "luLuRelationType.alias";
		    public final static String LU_LU_RELATION_TYPE_JOINTLY_OFFERED = "luLuRelationType.colocated";
		
		    // Valid states for Credit Course
		    public final static String LU_STATE_DRAFT = "Draft"; 
		    public final static String LU_STATE_SUBMITTED = "Submitted";
		    public final static String LU_STATE_WITHDRAWN = "Withdrawn";
		    public final static String LU_STATE_APPROVED = "Approved";
		    public final static String LU_STATE_NOT_APPROVED = "Not Approved";
		    public final static String LU_STATE_ACTIVE = "Active";
		    public final static String LU_STATE_INACTIVE = "Inactive";
		    public final static String LU_STATE_SUPERSEDED  = "Superseded";
		    public final static String LU_STATE_RETIRED = "Retired";
		    
		    // Dictionary definitions
		    public static final String STRUCTURE_CLU_INFO = "org.kuali.student.lum.lu.dto.CluInfo";
		    public static final String STRUCTURE_CLU_ID_INFO = "org.kuali.student.lum.lu.dto.CluIdentifierInfo";
		    public static final String STRUCTURE_PROPOSAL_INFO = "org.kuali.student.lum.proposal.dto.ProposalInfo";
		
			public static final String REF_DOC_RELATION_PROPOSAL_TYPE = "kuali.org.RefObjectType.ProposalInfo";

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    @Override
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    @Override
    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning unit type. Once set at create time, this field may not be updated.
     */
    @Override
    public String getType() {
        return type;
    }

    @Override
    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the credential program. The values for this field are constrained to those in the luState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    @Override
    public String getState() {
        return state;
    }

    @Override
    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a Program Requirement This is optional, due to the identifier being set at the time of creation. Once the Program has been created, this should be seen as required.
     */
    @Override
    public String getId() {
        return id;
    }

    @Override
    public void setId(String id) {
        this.id = id;
    }

    }

    private void setReqCompNL(StatementTreeViewInfo tree) throws Exception {
        List<StatementTreeViewInfo> statements = tree.getStatements();
        List<ReqComponentInfo> reqComponentInfos = tree.getReqComponents();

         if ((statements != null) && (statements.size() > 0)) {
            // retrieve all statements
            for (StatementTreeViewInfo statement : statements) {
                setReqCompNL(statement); // inside set the children of this statementTreeViewInfo
            }
        } else if ((reqComponentInfos != null) && (reqComponentInfos.size() > 0)) {
            // retrieve all req. component LEAFS
        	for (int i = 0; i < reqComponentInfos.size(); i++) {
        		ReqComponentInfoUi reqUi = RulesUtil.clone(reqComponentInfos.get(i));
        		reqUi.setNaturalLanguageTranslation(statementService.translateReqComponentToNL(reqUi, "KUALI.RULE", "en"));
        		reqUi.setPreviewNaturalLanguageTranslation(statementService.translateReqComponentToNL(reqUi, "KUALI.RULE.PREVIEW", "en"));
        		reqComponentInfos.set(i, reqUi);
        	}
        }
    }

         + fd.getInclusiveMax ();
 }
 private static final String PAGE_PREFIX = "Formatted View of ";
 private static final String PAGE_SUFFIX = " Searches";

 private String calcWikiSearchPage (String searchType)
 {
  return PAGE_PREFIX + calcWikigPageAbbrev (searchType) + PAGE_SUFFIX;
 }

 private String calcWikigPageAbbrev (String searchType)
 {
  if (searchType == null)
  {
   return null;
  }
  if (searchType.equals ("enumeration.management.search"))
  {
   return "EM";
  }
  if (searchType.startsWith ("lu."))
  {
   return "LU";
  }
  if (searchType.startsWith ("cluset."))
  {
   return "LU";
  }
  if (searchType.startsWith ("lo."))
  {
   return "LO";
  }
  if (searchType.startsWith ("lrc."))
  {
   return "LRC";
  }
  if (searchType.startsWith ("comment."))
  {
   return "Comment";
  }
  if (searchType.startsWith ("org."))
  {
   return "Organization";
  }
  if (searchType.startsWith ("atp."))
  {
   return "ATP";
  }

	{
		checkRequiredAttributes = true;
        // add document number as one required attribute set
		List<String> listOne = new ArrayList<String>();
		listOne.add( KimAttributes.DOCUMENT_NUMBER );
		newRequiredAttributes.add(listOne);
        // add document type name and KEW application id as one required attribute set
		List<String> listTwo = new ArrayList<String>();
		listTwo.add( KimAttributes.DOCUMENT_TYPE_NAME );
		listTwo.add( StudentIdentityConstants.QUALIFICATION_KEW_OBJECT_ID );
		newRequiredAttributes.add(listTwo);
        // add object id and object type as one required attribute set
		List<String> listThree = new ArrayList<String>();
		listThree.add( StudentIdentityConstants.QUALIFICATION_KEW_OBJECT_ID );
		listThree.add( StudentIdentityConstants.QUALIFICATION_KEW_OBJECT_TYPE );
		newRequiredAttributes.add(listThree);
        // add each proposal reference type as a required attribute set
        for (String proposalReferenceType : StudentIdentityConstants.QUALIFICATION_PROPOSAL_ID_REF_TYPES) {
            List<String> tempList = new ArrayList<String>();
            tempList.add( proposalReferenceType );
            newRequiredAttributes.add(tempList);
        }
	}

	/** 
	 * The part about where the receivedAttributes list being empty does not return errors is copied from Rice base class.
	 * 
	 * @see org.kuali.rice.kim.service.support.impl.KimTypeServiceBase#validateRequiredAttributesAgainstReceived(org.kuali.rice.kim.bo.types.dto.AttributeSet)
	 **/
	@Override
	protected void validateRequiredAttributesAgainstReceived(AttributeSet receivedAttributes){
		KimQualificationHelper.validateRequiredAttributesAgainstReceived(newRequiredAttributes, receivedAttributes, isCheckFutureRequests(), COMMA_SEPARATOR);

                doSave(event.getOkCallback());

            }
        });
        eventBus.addHandler(StateChangeEvent.TYPE, new StateChangeEvent.Handler() {
            @Override
            public void onEvent(final StateChangeEvent event) {
                programModel.validateNextState(new Callback<List<ValidationResultInfo>>() {
                    @Override
                    public void exec(List<ValidationResultInfo> result) {
                        boolean isSectionValid = isValid(result, true);
                        if (isSectionValid) {
                            Callback<Boolean> callback = new Callback<Boolean>() {
                                @Override
                                public void exec(Boolean result) {
                                    if (result) {
                                        reloadMetadata = true;
                                        loadMetadata(new Callback<Boolean>() {
                                            @Override
                                            public void exec(Boolean result) {
                                                if (result) {
                                                    ProgramUtils.syncMetadata(configurer, programModel.getDefinition());
                                                    HistoryManager.navigate(AppLocations.Locations.VIEW_PROGRAM.getLocation(), context);

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning objective type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the learning objective. The values for this field are constrained to those in the loState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a learning objective record. This is optional, due to the identifier being set at the time of creation. Once the learning objective has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
    	return "LoInfo[id=" + id + "]";

        return searchManager.getSearchCriteriaType(searchCriteriaTypeKey);
    }

    /**
     * @see org.kuali.student.core.search.service.SearchService#getSearchCriteriaTypes()
     */
    @Override
    public List<SearchCriteriaTypeInfo> getSearchCriteriaTypes() throws OperationFailedException {
        return searchManager.getSearchCriteriaTypes();
    }

    /**
     * @see org.kuali.student.core.search.service.SearchService#getSearchResultType(java.lang.String)
     */
    @Override
    public SearchResultTypeInfo getSearchResultType(String searchResultTypeKey) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException {
        checkForMissingParameter(searchResultTypeKey, "searchResultTypeKey");
        return searchManager.getSearchResultType(searchResultTypeKey);
    }

    /**
     * @see org.kuali.student.core.search.service.SearchService#getSearchResultTypes()
     */
    @Override
    public List<SearchResultTypeInfo> getSearchResultTypes() throws OperationFailedException {
        return searchManager.getSearchResultTypes();
    }

    /**
     * @see org.kuali.student.core.search.service.SearchService#getSearchType(java.lang.String)
     */
    @Override
    public SearchTypeInfo getSearchType(String searchTypeKey) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException {
        checkForMissingParameter(searchTypeKey, "searchTypeKey");
        return searchManager.getSearchType(searchTypeKey);    
    }

    /**
     * @see org.kuali.student.core.search.service.SearchService#getSearchTypes()
     */
    @Override
    public List<SearchTypeInfo> getSearchTypes() throws OperationFailedException {
        return searchManager.getSearchTypes();
    }

    /**
     * @see org.kuali.student.core.search.service.SearchService#getSearchTypesByCriteria(java.lang.String)
     */
    @Override
    public List<SearchTypeInfo> getSearchTypesByCriteria(String searchCriteriaTypeKey) throws DoesNotExistException, InvalidParameterException, MissingParameterException, OperationFailedException {

    }
    
    private String getParameterDisplayName(String parameterKey) {
        String parameterDisplayName = null;
        if (lookupMetadata == null) {
            parameterDisplayName = parameterKey;
        } else {
            List<LookupParamMetadata> searchParams = lookupMetadata.getParams();
            if (searchParams != null) {
                for (LookupParamMetadata searchParam : searchParams) {
                    if (nullSafeEquals(searchParam.getKey(), parameterKey)) {
                        parameterDisplayName = searchParam.getName();
                    }
                }
            }
            if (parameterDisplayName == null) {
                parameterDisplayName = parameterKey;
            }
        }
        return parameterDisplayName;
    }
    
    private boolean nullSafeEquals(Object str1, Object str2) {
        return (str1 == null && str2 == null ||
                str1 != null && str2 != null && str1.equals(str2));
    }
    
//    public class MyGwtEvent extends ValueChangeEvent<Data.Value> {
//        public MyGwtEvent(Data.Value value) {
//            super(value);
//        }
//    }

    public LookupMetadata getLookupMetadata() {
        return lookupMetadata;
    }

    public void setLookupMetadata(LookupMetadata lookupMetadata) {
        this.lookupMetadata = lookupMetadata;
    }

}

        return SectionTitle.generateH3Title(getLabel(labelKey));
    }
    
    protected MessageKeyInfo generateMessageInfo(String labelKey) {
        return new MessageKeyInfo("clusetmanagement", "clusetmanagement", "draft", labelKey);
    }
    
    private FieldDescriptor getFieldDescriptor( 
            String fieldKey, 
            MessageKeyInfo messageKey, 
            Widget widget, 
            String parentPath) {
        QueryPath path = QueryPath.concat(parentPath, fieldKey);
        Metadata meta = modelDefinition.getMetadata(path);
        FieldDescriptor fd;
        if (widget != null) {
            fd = new FieldDescriptor(path.toString(), messageKey, meta, widget);
        }
        else{
            fd = new FieldDescriptor(path.toString(), messageKey, meta);
        }
        return fd;
    }

    private FieldDescriptor addField(Section section, 
            String fieldKey, 
            MessageKeyInfo messageKey, 
            Widget widget, 
            String parentPath) {
        FieldDescriptor fd = getFieldDescriptor(fieldKey, messageKey, widget, parentPath);
        section.addField(fd);
        return fd;
    }

    private Picker configureSearch(String fieldKey) {

        Metadata metaData = searchDefinition.getMetadata(path);
        Picker picker = new Picker(metaData.getInitialLookup(), metaData.getAdditionalLookups());
        return picker;
    }

    public static class Picker extends KSPicker {

        private String name;
        private LookupMetadata initLookupMetadata;
        private List<LookupMetadata> additionalLookupMetadata;

        public Picker(LookupMetadata inLookupMetadata, List<LookupMetadata> additionalLookupMetadata) {
            super(inLookupMetadata, additionalLookupMetadata);
            this.initLookupMetadata = inLookupMetadata;
            this.additionalLookupMetadata = additionalLookupMetadata;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public LookupMetadata getInitLookupMetadata() {
            return initLookupMetadata;
        }

        public void setInitLookupMetadata(LookupMetadata initLookupMetadata) {
            this.initLookupMetadata = initLookupMetadata;
        }

        public List<LookupMetadata> getAdditionalLookupMetadata() {
            return additionalLookupMetadata;
        }

        public void setAdditionalLookupMetadata(List<LookupMetadata> additionalLookupMetadata) {
            this.additionalLookupMetadata = additionalLookupMetadata;
        }
        
    }

								translateIds((Data) prop.getValue(), listChildMetadata);
							}else{
								//its a list of fields so loop through and translate using the "index"
								for(Iterator<Property> listIter = ((Data)fieldData).realPropertyIterator(); listIter.hasNext();){
									Property listItem = listIter.next();
									Object listData = listItem.getValue();
									if (listData != null && listData instanceof String) {
										if (fieldMetadata.getInitialLookup() != null
												&& !StringUtils.isEmpty((String) listData)) {
											//This is a string with a lookup so do the translation
											IdTranslation trans = idTranslator.getTranslation(fieldMetadata.getInitialLookup(),	(String) listData);
											if (trans != null) {
												Integer index = listItem.getKey();
												setTranslation((Data)fieldData, listItem.getKey().toString(), index, trans.getDisplay());
											}
										}

									}

    static private void findCluSetIds(StatementTreeViewInfo rule, Set<String> list) {

        List<StatementTreeViewInfo> statements = rule.getStatements();
        List<ReqComponentInfo> reqComponentInfos = rule.getReqComponents();

        if ((statements != null) && (statements.size() > 0)) {
            // retrieve all statements
            for (StatementTreeViewInfo statement : statements) {
                findCluSetIds(statement, list); // inside set the children of this statementTreeViewInfo
            }
        } else if ((reqComponentInfos != null) && (reqComponentInfos.size() > 0)) {
            // retrieve all req. component LEAFS
            for (ReqComponentInfo reqComponent : reqComponentInfos) {
                List<ReqCompFieldInfo> fieldInfos = reqComponent.getReqCompFields();
                for (ReqCompFieldInfo fieldInfo : fieldInfos) {
                    if (RulesUtil.isCluSetWidget(fieldInfo.getType())) {
                        list.add(fieldInfo.getValue());
                    }
                }
            }
        }
    }

    private void setupSaveCancelButtons() {

                HistoryManager.navigate(AppLocations.Locations.EDIT_VARIATION.getLocation(), viewContext);

            }
        });

        eventBus.addHandler(StoreRequirementIDsEvent.TYPE, new StoreRequirementIDsEvent.Handler() {
            @Override
            public void onEvent(StoreRequirementIDsEvent event) {
                List<String> ids = event.getProgramRequirementIds();

                programModel.set(QueryPath.parse(ProgramConstants.PROGRAM_REQUIREMENTS), new Data());
                Data programRequirements = programModel.get(ProgramConstants.PROGRAM_REQUIREMENTS);

                if (programRequirements == null) {
                    Window.alert("Cannot find program requirements in data model.");
                    GWT.log("Cannot find program requirements in data model", null);
                    return;
                }

                for (String id : ids) {
                    programRequirements.add(id);
                }
                doSave();
            }
        });
        eventBus.addHandler(ChangeViewEvent.TYPE, new ChangeViewEvent.Handler() {
            @Override
            public void onEvent(ChangeViewEvent event) {
                showView(event.getViewToken());
            }
        });

			CredentialProgramInfo previousVersionCoreInfo = programService.getCredentialProgram(versionFromId);
			
			if (previousVersionData == null){
				//This is an initial get. Create previous version data to send back to client 
				previousVersionData = new Data();
				previousVersionData.set(ProgramConstants.ID, previousVersionCoreInfo.getId());
				previousVersionData.set(ProgramConstants.END_PROGRAM_ENTRY_TERM, previousVersionCoreInfo.getEndProgramEntryTerm());
				previousVersionData.set(ProgramConstants.END_PROGRAM_ENROLL_TERM, previousVersionCoreInfo.getEndTerm());
				previousVersionData.set(ProgramConstants.STATE, previousVersionCoreInfo.getState());
			} else {
				//This is a save operation. Check state field change for previous version state, indicating an "Activate" action,
				//which requires updating previous program with new states and end terms and setting activated program
				//to be the current version.
				
				String state = previousVersionData.get(ProgramConstants.STATE);
				if (state!= null && !state.equals(previousVersionCoreInfo.getState())){
					//Update previous program version with new state and terms
					String endEntryTerm = previousVersionData.get(ProgramConstants.END_PROGRAM_ENTRY_TERM); 
					String endEnrollTerm = previousVersionData.get(ProgramConstants.END_PROGRAM_ENROLL_TERM);

					previousVersionCoreInfo.setState(state);
					previousVersionCoreInfo.setEndProgramEntryTerm(endEntryTerm);
					previousVersionCoreInfo.setEndTerm(endEnrollTerm);
					
					programService.updateCredentialProgram(previousVersionCoreInfo);

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning unit type. Once set at create time, this field may not be updated.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the credential program. The values for this field are constrained to those in the luState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for an Honors Program. This is optional, due to the identifier being set at the time of creation. Once the Program has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Date and time that this grade value became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this grade value expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a grade type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * Unique identifier for a grade value.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /*
     * Date and time the accreditation became effective. 
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /*
     * Date and time the accreditation expires. 
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }
    
    /*
     * Create and last update info for the structure. 
     * This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }
    
    /*
     * Unique identifier for the accreditation.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning unit type. Once set at create time, this field may not be updated.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the course. The values for this field are constrained to those in the luState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value. This field may not be updated through updating this structure and must instead be updated through a dedicated operation.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a Canonical Learning Unit (CLU). This is optional, due to the identifier being set at the time of creation. Once the Format has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Date and time that this learning objective repository became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this learning objective repository expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning objective repository.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for an organization type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the organization. The values for this field are constrained to those in the orgState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for an organization. This is optional, due to the identifier being set at the time of creation. Once the organization has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning unit type. Once set at create time, this field may not be updated.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the credential program. The values for this field are constrained to those in the luState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for an Honors Program. This is optional, due to the identifier being set at the time of creation. Once the Program has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    }

    /**
     * Date and time that this CLU Set became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this CLU Set expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

//    /**
//     * Specifies a search for CLU identifiers. Present for dynamic CLU Sets
//     */
//    public CluCriteriaInfo getCluCriteria() {
//        return cluCriteria;
//    }
//
//    public void setCluCriteria(CluCriteriaInfo cluCriteria) {
//        this.cluCriteria = cluCriteria;
//    }


    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a CLU Set. This is optional, due to the identifier being set at the time of creation. Once the CLU Set has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for an LU statement type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the statement. The values for this field are constrained to those in the StatementState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a single LU statement record. This is optional, due to the identifier being set at the time of creation. Once the LU statement has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    }

    /**
     * Date and time that this CLU Set became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this CLU Set expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

//    /**
//     * Specifies a search for CLU identifiers. Present for dynamic CLU Sets
//     */
//    public CluCriteriaInfo getCluCriteria() {
//        return cluCriteria;
//    }
//
//    public void setCluCriteria(CluCriteriaInfo cluCriteria) {
//        this.cluCriteria = cluCriteria;
//    }


    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a CLU Set. This is optional, due to the identifier being set at the time of creation. Once the CLU Set has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for an LU statement type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the statement. The values for this field are constrained to those in the StatementState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a single LU statement record. This is optional, due to the identifier being set at the time of creation. Once the LU statement has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

				node.getRightNode().getValue() == true &&
				node.getLeftNode().getNodeMessage() != null && 
				node.getRightNode().getNodeMessage() != null) {
	        String logMessage = node.getLeftNode().getNodeMessage() + " " + 
	        	this.booleanOperators.getAndOperator() + " " + 
	        	node.getRightNode().getNodeMessage();
			
			if(node.getParent() != null && 
					( (node.getLabel().equals("+") && 
							node.getParent().getLabel().equals("*")) || 
							(node.getLabel().equals("*") && 
									node.getParent().getLabel().equals("+")))) {
			    logMessage = "(" + logMessage + ")";
			}
			node.setNodeMessage(logMessage);
		}
	}

				node.getRightNode().getValue() == true && 
				node.getLeftNode().getNodeMessage() != null && 
				node.getRightNode().getNodeMessage() != null) {
	        String logMessage = node.getLeftNode().getNodeMessage() + " " + 
	        	this.booleanOperators.getOrOperator() + " " + 
	        	node.getRightNode().getNodeMessage();

			if(node.getParent() != null && 
					( (node.getLabel().equals("+") && 
							node.getParent().getLabel().equals("*")) || 
							(node.getLabel().equals("*") && 
									node.getParent().getLabel().equals("+")))) {
			    logMessage = "(" + logMessage + ")";
			}
			node.setNodeMessage(logMessage);
		} 
	}	

			Integer minValue = ValidatorUtils.getInteger(bcb.minValue);

			if (maxValue != null && minValue != null) {
				// validate range
				if (v > maxValue || v < minValue) {
					val.setError(MessageUtils.interpolate(
							getMessage("validation.outOfRange"), bcb.toMap()));
				}
			} else if (maxValue != null) {
				if (v > maxValue) {
					val.setError(MessageUtils.interpolate(
							getMessage("validation.maxValueFailed"), bcb
									.toMap()));
				}
			} else if (minValue != null) {
				if (v < minValue) {
					val.setError(MessageUtils.interpolate(
							getMessage("validation.minValueFailed"), bcb
									.toMap()));
				}
			}
		}

		if (!val.isOk()) {
			results.add(val);
		}
	}

	private void validateDate(Object value, BaseConstraintBean bcb,

        return MetaInfoHelper.wrap ((Data) data.get (Properties.META_INFO.getKey ()));
    }

    public void setName(String name) {
        data.set(Properties.NAME.getKey(), name);
    }
    public String getName() {
        return (String) data.get(Properties.NAME.getKey());
    }

    public void setState(String state) {
        data.set(Properties.STATE.getKey(), state);
    }
    public String getState() {
        return (String) data.get(Properties.STATE.getKey());
    }

    public void setType(String type) {
        data.set(Properties.TYPE.getKey(), type);
    }
    public String getType() {
        return (String) data.get(Properties.TYPE.getKey());
    }

    public void setReusable(Boolean reusable) {

    private CredentialManagingBodiesViewConfiguration(SectionView sectionView) {
        rootSection = sectionView;
    }

    @Override
    protected void buildLayout() {
        VerticalSection section = createMainSection();
        rootSection.addSection(section);
    }

    private VerticalSection createMainSection() {
        VerticalSection section = new VerticalSection();
        configurer.addReadOnlyField(section, ProgramConstants.CURRICULUM_OVERSIGHT_DIVISION, new MessageKeyInfo(ProgramProperties.get().managingBodies_curriculumOversightDivision()));
        configurer.addReadOnlyField(section, ProgramConstants.CURRICULUM_OVERSIGHT_UNIT, new MessageKeyInfo(ProgramProperties.get().managingBodies_curriculumOversightUnit()));
        configurer.addReadOnlyField(section, ProgramConstants.STUDENT_OVERSIGHT_DIVISION, new MessageKeyInfo(ProgramProperties.get().managingBodies_studentOversightDivision()));
        configurer.addReadOnlyField(section, ProgramConstants.STUDENT_OVERSIGHT_UNIT, new MessageKeyInfo(ProgramProperties.get().managingBodies_studentOversightUnit()));
        return section;
    }
}

	        Map<String, String> permissions = getFieldAccessPermissions(dtoName,idType,id, docType);
	        if (permissions != null) {
	            for (Map.Entry<String, String> permission : permissions.entrySet()) {
	                String dtoFieldPath = permission.getKey();
	                String fieldAccessLevel = permission.getValue();
	                String[] fieldPathTokens = getPathTokens(dtoFieldPath);
	                Metadata fieldMetadata = metadata.getProperties().get(fieldPathTokens[0]);
	                for(int i = 1; i < fieldPathTokens.length; i++) {
	                    if(fieldMetadata == null) {
	                        break;
	                    }
	                    fieldMetadata = fieldMetadata.getProperties().get(fieldPathTokens[i]);
	                }
	                if (fieldMetadata != null) {
	                    Permission perm = Permission.kimValueOf(fieldAccessLevel);
	                    if (Permission.EDIT.equals(perm)) {
	                        setReadOnly(fieldMetadata, false);
	                    } else if (Permission.PARTIAL_UNMASK.equals(perm)){

            Integer minValue = ValidatorUtils.getInteger(constraint.getExclusiveMin());

            if (maxValue != null && minValue != null) {
                // validate range
                if (v > maxValue || v < minValue) {
                    val.setError(MessageUtils.interpolate(getMessage("validation.outOfRange"), toMap(constraint)));
                }
            } else if (maxValue != null) {
                if (v > maxValue) {
                    val.setError(MessageUtils.interpolate(getMessage("validation.maxValueFailed"), toMap(constraint)));
                }
            } else if (minValue != null) {
                if (v < minValue) {
                    val.setError(MessageUtils.interpolate(getMessage("validation.minValueFailed"), toMap(constraint)));
                }
            }
        }

        if (!val.isOk()) {
            results.add(val);
        }
    }

    protected void validateDate(Object value, Constraint constraint, String element, List<ValidationResultInfo> results, DateParser dateParser) {

	private String messageLocaleKey = "en";

	private String messageGroupKey = "validation";

	private DateParser dateParser = new ServerDateParser();

	private boolean serverSide = true;

	public MessageService getMessageService() {
		return messageService;
	}

	public void setMessageService(MessageService messageService) {
		this.messageService = messageService;
	}

	public String getMessageLocaleKey() {
		return messageLocaleKey;
	}

	public void setMessageLocaleKey(String messageLocaleKey) {
		this.messageLocaleKey = messageLocaleKey;
	}

	public String getMessageGroupKey() {
		return messageGroupKey;
	}

	public void setMessageGroupKey(String messageGroupKey) {
		this.messageGroupKey = messageGroupKey;
	}

	public void setDateParser(DateParser dateParser) {
		this.dateParser = dateParser;
	}

	/**
	 * @return the serverSide
	 */
	public boolean isServerSide() {
		return serverSide;
	}

	/**
	 * @param serverSide
	 *            the serverSide to set
	 */
	public void setServerSide(boolean serverSide) {
		this.serverSide = serverSide;
	}

	/**
	 * @return the dateParser
	 */
	public DateParser getDateParser() {
		return dateParser;
	}




	/**
	 * Validate Object and all its nested child objects for given type and state
	 *
	 * @param data
	 * @param objStructure
	 * @return
	 */
	public List<ValidationResultInfo> validateTypeStateObject(Object data,

				feeRec.setAffiliatedOrgs(toAffiliatedOrgs(isUpdate, feeRec.getAffiliatedOrgs(), feeRecordInfo.getAffiliatedOrgs(),dao));
				feeRec.setFeeType(feeRecordInfo.getFeeType());
				feeRec.setRateType(feeRecordInfo.getRateType());
				feeRec.setDescr(toRichText(LuRichText.class, feeRecordInfo.getDescr()));
				feeRec.setFeeAmounts(toFeeAmounts(isUpdate, feeRec.getFeeAmounts(), feeRecordInfo.getFeeAmounts(),dao));
				feeRec.setAttributes(LuServiceAssembler.toGenericAttributes(
						CluFeeRecordAttribute.class, feeRecordInfo
								.getAttributes(), feeRec, dao));
				if(cluFee.getCluFeeRecords()==null){
					cluFee.setCluFeeRecords(new ArrayList<CluFeeRecord>());
				}
				cluFee.getCluFeeRecords().add(feeRec);
			}

    }

    /**
     * Date and time that this CLU result became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this CLU result expires. This is a similar concept to the expiration date on enumerated values. If specified, this must be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a clu learning result object type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the CLU Result. The values for this field are constrained to those in the cluResultState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a CLU result. This is optional, due to the identifier being set at the time of creation. Once the result set has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

        }

        public void addImage(Image shownIcon) {
            shownIcon.addStyleName("KS-Basic-Menu-Item-Image");
            contentPanel.add(shownIcon);

        }

        public void deSelect(){
            this.removeStyleName("KS-Basic-Menu-Item-Panel-Selected");
            itemLabel.removeStyleName("KS-Basic-Menu-Item-Label-Selected");
            selected = false;
        }

        public void select(){
            this.addStyleName("KS-Basic-Menu-Item-Panel-Selected");
            itemLabel.addStyleName("KS-Basic-Menu-Item-Label-Selected");
            selected = true;
        }

        public KSLabel getItemLabel() {
            return itemLabel;
        }

        public boolean isSelectable() {
            return selectable;
        }

        public void setSelectable(boolean selectable) {
            this.selectable = selectable;
        }

        public KSMenuItemData getItem() {
            return item;
        }

		public boolean isSelected() {
			return selected;
		}

		public void setSelected(boolean selected) {
			this.selected = selected;
		}


    }

    @Override
    protected void populateMenu() {

				KSTextBox.super.setText(watermarkText);
				watermarkShowing = true;
			}
		}
	}
	
	@Override
	public boolean hasWatermark(){
		return hasWatermark;
	}
	
	@Override
	public boolean watermarkShowing() {
		return watermarkShowing;
	}
	
	@Override
	public String getText() {
		if(!watermarkShowing){
			return super.getText();
		}
		return null;
	}
	
	@Override
	public String getValue() {
		if(!watermarkShowing){
			return super.getValue();
		}
		return null;
	}
	
	@Override
	public void setValue(String value) {
		if(hasWatermark){
			if(value == null || (value != null && value.isEmpty())){
				super.setValue(watermarkText);
				addStyleName("watermark-text");
				watermarkShowing = true;
			}
			else{
				super.setValue(value);

@Embeddable
public class Meta {

//	Hibernate will not allow @Version in @Embeddable for some annoying reason
//	@Version
//	private long versionInd;
	
//	public long getVersionNumber() {
//	    return versionInd;
//  }
//
//  public void setVersionInd(long versionInd) {
//	    this.versionInd = versionInd;
//  }
	
	@Temporal(TemporalType.TIMESTAMP)
	@Column(updatable=false)
	private Date createTime;

	@Column(updatable=false)
	private String createId;

	@Temporal(TemporalType.TIMESTAMP)
	private Date updateTime;

	private String updateId;

	public Date getCreateTime() {
		return createTime;
	}

	public void setCreateTime(Date createTime) {
		this.createTime = createTime;
	}

	public String getCreateId() {
		return createId;
	}

	public void setCreateId(String createId) {
		this.createId = createId;
	}
	
	public Date getUpdateTime() {
		return updateTime;
	}

	public void setUpdateTime(Date updateTime) {
		this.updateTime = updateTime;
	}

	public String getUpdateId() {
		return updateId;
	}

	public void setUpdateId(String updateId) {
		this.updateId = updateId;
	}
}

    public String getKey() {
        return key;
    }
    public void setKey(String key) {
        this.key = key;
    }
    public boolean isRequired() {
        return isRequired;
    }
    public void setRequired(boolean isRequired) {
        this.isRequired = isRequired;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public int getContentCellCount() {
        return contentCellCount;
    }
    public void setContentCellCount(int contentCellCount) {
        this.contentCellCount = contentCellCount;
    }
    public Widget getCell1() {
        return cell1;
    }
    public void setCell1(Widget cell1) {
        this.cell1 = cell1;
    }
    public Widget getCell2() {
        return cell2;
    }
    public void setCell2(Widget cell2) {
        this.cell2 = cell2;
    }

                    programWidget.addGetCluNameCallback(new Callback() {

                        @Override
                        public void exec(Object id) {

                            statementRpcServiceAsync.getCurrentVersion(CLU_NAMESPACE_URI, (String)id, new AsyncCallback<VersionDisplayInfo>() {
                                @Override
                                public void onFailure(Throwable throwable) {
                                    Window.alert(throwable.getMessage());
                                    GWT.log("Failed to retrieve clu for id: '" +  "'", throwable);
                                }

                                @Override
                                public void onSuccess(final VersionDisplayInfo versionInfo) {
                                    statementRpcServiceAsync.getClu(versionInfo.getId(), new AsyncCallback<CluInfo>() {
                                        @Override
                                        public void onFailure(Throwable throwable) {
                                            Window.alert(throwable.getMessage());
                                            GWT.log("Failed to retrieve clu", throwable);
                                        }

                                        @Override
                                        public void onSuccess(CluInfo cluInfo) {

@WebService(targetNamespace = "http://schemas.xmlsoap.org/ws/2005/02/trust/wsdl", name = "WSSecurityRequestor")
@XmlSeeAlso({org.kuali.student.security.wssecurity.secext.dto.ObjectFactory.class,org.kuali.student.security.trust.dto.ObjectFactory.class,org.kuali.student.security.wssecurity.utility.dto.ObjectFactory.class,org.kuali.student.security.addressing.dto.ObjectFactory.class,org.kuali.student.security.policy.dto.ObjectFactory.class,org.kuali.student.security.xmldsig.dto.ObjectFactory.class})
@SOAPBinding(style = SOAPBinding.Style.DOCUMENT, use = SOAPBinding.Use.LITERAL, parameterStyle = SOAPBinding.ParameterStyle.WRAPPED)
public interface WSSecurityRequestor {

        public CreateCategoryDialog() {
        	this.setSize(540, 200);
        	spacer.setStyleName("KS-LOSpacer");
        	cancelButton.setStyleName("KS-LODialogCancel");
        	typeListBox.setHeight("21px");
        	KSLabel catLabel = new KSLabel("Category");
        	catLabel.setStyleName("KS-LODialogFieldLabel");
        	KSLabel typeLabel = new KSLabel("Type");
        	typeLabel.setStyleName("KS-LODialogFieldLabel");
            layoutTable.setWidget(0, 0, catLabel);
            layoutTable.setWidget(0, 1, typeLabel);
            layoutTable.setWidget(1, 0, nameTextBox);
            layoutTable.setWidget(1, 1, typeListBox);
            
            HorizontalPanel buttonPanel = new HorizontalPanel();
            buttonPanel.add(okButton);
            buttonPanel.add(cancelButton);
            
            VerticalPanel mainPanel = new VerticalPanel();
            mainPanel.add(spacer);
            KSLabel titleLabel = new KSLabel("Create New Category");

    public static final String SEARCH_COURSE = "findCourse";
    public static final String CLU_SET_ID = "id";
    public static final String CLU_SET_ORGANIZATION_FIELD = "organization";
    public static final String CLU_SET_NAME_FIELD = "name";
    public static final String CLU_SET_DESCRIPTION_FIELD = "description";
    public static final String CLU_SET_EFF_DATE_FIELD = "effectiveDate";
    public static final String CLU_SET_EXP_DATE_FIELD = "expirationDate";
    public static final String CLU_SET_ALL_CLUS_FIELD = "allClus";
    public static final String CLU_SET_APPROVED_CLUS_FIELD = "approvedClus";
    public static final String CLU_SET_PROPOSED_CLUS_FIELD = "proposedClus";
    public static final String CLU_SET_CLU_SETS_FIELD = "clusets";
    public static final String CLU_SET_CLU_SET_RANGE_FIELD = "clusetRange";
    public static final String CLU_SET_CLU_SET_RANGE_EDIT_FIELD = "clusetRangeEdit";
    public static final String CLU_SET_CLUSET_RANGE_VIEW_DETAILS_FIELD = "cluSetRangeViewDetails";
    public static final String CLU_SET_TYPE_FIELD = "type";
    
    // Swappable Section Keys
    public static final String CLU_SET_SWAP_APPROVED_CLUS = "activatedClus";
    public static final String CLU_SET_SWAP_PROPOSED_CLUS = "proposedClus";
    public static final String CLU_SET_SWAP_CLU_SETS = "clusets";
    public static final String CLU_SET_SWAP_CLU_SET_RANGE = "clusetRange";
    
    
}

    public SwitchSection(KSSelectItemWidgetAbstract selectableWidget, ConfirmationDialog dialog){
        this.dialog = dialog;
        this.init(selectableWidget);
    }
    
    private void init(KSSelectItemWidgetAbstract selectableWidget){
        this.selectableWidget = selectableWidget;
        
        if(dialog == null){
            dialog = 
                new ConfirmationDialog(Application.getApplicationContext().getMessage("fieldDeletionTitle"),  
                        Application.getApplicationContext().getMessage("fieldDeletionConfirmMessage"));
        }
        dialog.getConfirmButton().addClickHandler(new ClickHandler(){

            @Override
            public void onClick(ClickEvent event) {
                handleUserSelection();
                dialog.hide();
            }
        });
        
        selectableWidget.addSelectionChangeHandler(new SelectionChangeHandler(){

            @Override
            public void onSelectionChange(SelectionChangeEvent event) {
                if(event.isUserInitiated() && showConfirmation){
                    if(SwitchSection.this.selectableWidget.getSelectedItems().size() < lastSelection.size()){

 	private void translateIds(Data data, Metadata metadata){
 		try {
 			if (data != null && metadata != null) {
				//Iterate through all the data;s properties
				for (Iterator<Property> iter = data.realPropertyIterator(); iter.hasNext();) {
					Property prop = iter.next();

					Object fieldData = prop.getValue();
					Object fieldKey = prop.getKey();

					Metadata fieldMetadata = metadata.getProperties().get(fieldKey);

					//if the fieldMetadata is null then try to use the parent metadata as in the case of lists
					if(fieldMetadata==null){
						fieldMetadata=metadata;
					}

					//If the fieldData is Data itself the recurse
					if (fieldData instanceof Data) {
						if (DataType.LIST.equals(fieldMetadata.getDataType())) {
							//Lists are a special case where the metadata property name is "*"
							Metadata listChildMetadata = fieldMetadata.getProperties().get("*");
							//see if this is a list of data or a list of fields
							if(DataType.DATA.equals(listChildMetadata.getDataType())){

    private MajorInformationViewConfiguration(SectionView sectionView) {
        rootSection = sectionView;
        rootSection.addStyleName("programInformationView");
    }

    @Override
    protected void buildLayout() {
        HorizontalSection section = new HorizontalSection();
        section.addSection(createIdentifyingDetailsSection());
        section.addSection(createProgramTitleSection());
        section.nextRow();
        section.addSection(createDatesSection());
        section.addSection(createOtherInformationSection());
        rootSection.addSection(section);
    }

    private TableSection createIdentifyingDetailsSection() {
        TableSection section = new TableSection(SectionTitle.generateH4Title(ProgramProperties.get().programInformation_identifyingDetails()));
        configurer.addReadOnlyField(section, ProgramConstants.CODE, new MessageKeyInfo(ProgramProperties.get().programInformation_code()));
        configurer.addReadOnlyField(section, ProgramConstants.CREDENTIAL_PROGRAM_LEVEL, new MessageKeyInfo(ProgramProperties.get().programInformation_level()));

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this document category became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this document category expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a document category.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

	public SearchBackedTable ()
	{
		super ();
		redraw ();
		layout.setWidth ("100%");
		initWidget (layout);
	}

	public void clearTable ()
	{
		resultRows.clear ();
		this.redraw ();
	}

	public void removeSelected ()
	{
		for (ResultRow r : getSelectedRows ())
		{
			resultRows.remove (r);
		}
		this.redraw ();
	}

	public void performSearch (SearchRequest searchRequest,
			List<LookupResultMetadata> listResultMetadata,
			String resultIdKey)
	{

		initializeTable (listResultMetadata, resultIdKey);

		searchRequest.setNeededTotalResults (false);

		if (pagingScrollTable != null)
		{
			pagingScrollTable.setEmptyTableWidget (new Label ("Processing Search..."));
		}

		//  Window.alert ("About to invoke asynch search...");
		searchRpcServiceAsync.search (searchRequest, new KSAsyncCallback<SearchResult> (){

			@Override
			public void onSuccess (SearchResult searchResults)

	private void doValidateBoolean(DataModel model, Metadata meta,
			QueryPath path, List<ValidationResultInfo> results) {
		
	    Map<QueryPath, Object> values = model.query(path);

		if (values.isEmpty() && isRequiredCheck(meta)) {
			addError(results, path, REQUIRED);
		} else {
	
		    Object[] keys = values.keySet().toArray();
			for (int keyIndex = 0; keyIndex < keys.length; keyIndex++) {
				QueryPath element = (QueryPath)keys[keyIndex];
	
				Object o = values.get(element);
				
				if (o == null) {
					if (isRequiredCheck(meta)) {
						addError(results, element, REQUIRED);
					}
				} else {

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this document category became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this document category expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a document category.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String, String> attributes;

    @XmlElement
    private MetaInfo metaInfo;

    @XmlAttribute
    private String type;

    @XmlAttribute
    private String state;

    @XmlAttribute
    private String id;

    /**
     * Friendly name of the CLU Set.
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * Narrative description of the CLU Set.
     */
    public RichTextInfo getDescr() {
        return descr;
    }

    public void setDescr(RichTextInfo descr) {
        this.descr = descr;
    }

    /**
     * Date and time that this CLU Set became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this CLU Set expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

//    /**
//     * Specifies a search for CLU identifiers. Present for dynamic CLU Sets
//     */
//    public CluCriteriaInfo getCluCriteria() {
//        return cluCriteria;
//    }
//
//    public void setCluCriteria(CluCriteriaInfo cluCriteria) {
//        this.cluCriteria = cluCriteria;
//    }


    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {

        block.addSummaryTableFieldRow(getFieldRow(COURSE + "/" + CAMPUS_LOCATIONS, generateMessageInfo(LUUIConstants.CAMPUS_LOCATION_LABEL_KEY)));

        Map<String, ModelWidgetBinding> customBindings = new HashMap<String, ModelWidgetBinding>();
        ListToTextBinding resultValuesBinding = new ListToTextBinding();
        customBindings.put("resultValues", resultValuesBinding);
        String outcomesKey = COURSE + QueryPath.getPathSeparator() + CREDIT_OPTIONS;
        MultiplicityConfiguration outcomesConfig = getMultiplicityConfig(outcomesKey,
        		LUUIConstants.LEARNING_RESULT_OUTCOME_LABEL_KEY,
		        Arrays.asList(
		                Arrays.asList(CreditCourseConstants.TYPE, LUUIConstants.LEARNING_RESULT_OUTCOME_TYPE_LABEL_KEY),
		                Arrays.asList(CREDIT_OPTION_FIXED_CREDITS, LUUIConstants.CONTACT_HOURS_LABEL_KEY, OPTIONAL),
		                Arrays.asList(CREDIT_OPTION_MIN_CREDITS, LUUIConstants.CREDIT_OPTION_MIN_CREDITS_LABEL_KEY, OPTIONAL),
		                Arrays.asList(CREDIT_OPTION_MAX_CREDITS, LUUIConstants.CREDIT_OPTION_MAX_CREDITS_LABEL_KEY, OPTIONAL),
		                Arrays.asList("resultValues", LUUIConstants.CREDIT_OPTION_FIXED_CREDITS_LABEL_KEY, OPTIONAL)),
		                customBindings);

    }

//    public class CourseList extends UpdatableMultiplicityComposite {
//        private final String parentPath;
//        public CourseList(String parentPath){
//            super(StyleType.TOP_LEVEL_GROUP);
//            this.parentPath = parentPath;
//            setAddItemLabel("Add Course");
////            setItemLabel(getLabel(LUConstants.FORMAT_LABEL_KEY));
//        }
//
//        public Widget createItem() {
//            String path = QueryPath.concat(parentPath, String.valueOf(itemCount-1)).toString();
//            GroupSection item = new GroupSection();
//            addField(item, "id", "" , path);
//            addField(item, "name", "", path);
//            return item;
//        }
//    }

    public static class Picker extends KSPicker {

        private String name;
        private LookupMetadata initLookupMetadata;
        private List<LookupMetadata> additionalLookupMetadata;

        public Picker(LookupMetadata inLookupMetadata, List<LookupMetadata> additionalLookupMetadata) {
            super(inLookupMetadata, additionalLookupMetadata);
            this.initLookupMetadata = inLookupMetadata;
            this.additionalLookupMetadata = additionalLookupMetadata;
        }

        public String getName() {
            return name;
        }

        public void setName(String name) {
            this.name = name;
        }

        public LookupMetadata getInitLookupMetadata() {
            return initLookupMetadata;
        }

        public void setInitLookupMetadata(LookupMetadata initLookupMetadata) {
            this.initLookupMetadata = initLookupMetadata;
        }

        public List<LookupMetadata> getAdditionalLookupMetadata() {
            return additionalLookupMetadata;
        }

        public void setAdditionalLookupMetadata(List<LookupMetadata> additionalLookupMetadata) {
            this.additionalLookupMetadata = additionalLookupMetadata;
        }
        
    }

    public ManagingBodiesEditConfiguration() {
        rootSection = new VerticalSectionView(ProgramSections.MANAGE_BODIES_EDIT, ProgramProperties.get().program_menu_sections_managingBodies(), ProgramConstants.PROGRAM_MODEL_ID);
    }

    @Override
    protected void buildLayout() {
        HorizontalSection horizontalSection = new HorizontalSection();
        horizontalSection.addSection(createLeftSection());
        horizontalSection.addSection(createRightSection());
        rootSection.addSection(horizontalSection);
    }

    private VerticalSection createLeftSection() {
        VerticalSection section = new VerticalSection();
        configurer.addField(section, ProgramConstants.CURRICULUM_OVERSIGHT_UNIT, new MessageKeyInfo(ProgramProperties.get().managingBodies_curriculumOversightUnit()));
        configurer.addField(section, ProgramConstants.STUDENT_OVERSIGHT_UNIT, new MessageKeyInfo(ProgramProperties.get().managingBodies_studentOversightUnit()));

				cluResult.setType(resultType);
				RichTextInfo desc = new RichTextInfo();
				desc.setPlain(resultsDescription);
				cluResult.setDesc(desc);
				cluResult.setEffectiveDate(new Date());
				cluResultNode.setOperation(NodeOperation.CREATE);
			}

			cluResult.setResultOptions(new ArrayList<ResultOptionInfo>());

			// Loop through all the credit options in this clu
			for (String optionType : options) {
				if(currentResults.containsKey(optionType)){
					//If the option exists already copy it to the new list of result options
					ResultOptionInfo resultOptionInfo = currentResults.get(optionType);
					cluResult.getResultOptions().add(resultOptionInfo);
				}else{
					//Otherwise create a new result option
					ResultOptionInfo resultOptionInfo = new ResultOptionInfo();
					RichTextInfo desc = new RichTextInfo();
					desc.setPlain(resultDescription);
					resultOptionInfo.setDesc(desc);
					resultOptionInfo.setResultComponentId(optionType);
					resultOptionInfo.setState(cluState);

						GWT.log("getCommentsByType Failed" ,caught);
						commentList.remove(loadingComments);
					}

					@Override
					public void onSuccess(List<CommentInfo> result) {
						if(result != null){
							comments.clear();
							commentList.clear();
							types.clear();
							Collections.sort(result, commentInfoComparator);
							for(CommentInfo c: result){
								if(!(types.contains(c.getType()))){
									types.add(c.getType());
								}

								Comment commentWidget = new Comment(c);
								comments.add(commentWidget);
								commentList.add(commentWidget);
							}
							commentTypes.redraw();
						}

						commentList.remove(loadingComments);
						//refreshCommentTypes();
					}
				});

    		}

		if(node.getLabel().equals("+") &&
				node.getLeftNode() != null && 
				node.getRightNode() != null &&
				node.getLeftNode().getNodeMessage() != null && 
				node.getRightNode().getNodeMessage() != null) {
			String preIndent = "";
			if(node.getLeftNode().getChildCount() == 0) {
				preIndent = getIndent(node, 0);
			}
			String postIndent = "";
			if(node.getRightNode().getChildCount() == 0) {
				postIndent = getIndent(node, 0);
			}

			String logMessage = this.indentString + node.getLeftNode().getNodeMessage() + 
			this.booleanOperatorPrefix + 
				preIndent + this.booleanOperators.getOrOperator() + 

					if (bcb.minOccurs > ((Collection<?>) value).size()) {
						ValidationResultInfo valRes = new ValidationResultInfo(
								xPath);
						valRes.setError(MessageUtils.interpolate(getMessage("validation.minOccurs"), bcb.toMap()));
						results.add(valRes);
					}

					Integer maxOccurs = tryParse(bcb.maxOccurs);
					if (maxOccurs != null
							&& maxOccurs < ((Collection<?>) value).size()) {
						ValidationResultInfo valRes = new ValidationResultInfo(
								xPath);
						valRes.setError(MessageUtils.interpolate(getMessage("validation.maxOccurs"), bcb.toMap()));
						results.add(valRes);
					}
				} else {

    private void init(){
        super.setStyleName("ks-lightbox");

        mainPanel.setStyleName("ks-lightbox-mainPanel");
        titlePanel.setStyleName("ks-lightbox-titlePanel");
        closeLink.setStyleName("ks-lightbox-title-closeLink");
        scrollPanel.setStyleName("ks-lightbox-title-scrollPanel");
         
        setGlassEnabled(true);
        super.setWidget(mainPanel);
        mainPanel.add(titlePanel);
        mainPanel.add(scrollPanel);
        titlePanel.add(closeLink);
        
        verticalPanel.setStyleName("ks-lightbox-layoutTable");
        verticalPanel.setWidget(1, 0, buttonPanel);
        verticalPanel.getRowFormatter().setStyleName(1, "ks-lightbox-buttonRow");
        scrollPanel.add(verticalPanel);
        
        installResizeHandler();
        //super.
        closeLink.addClickHandler(new ClickHandler(){

            @Override
            public void onClick(ClickEvent event) {
               hide();
            }
        });
    }
    public KSLightBox(boolean addCloseLink) {

    }

    /**
     * Date and time that this person became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this person record expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Indicates the state of this person record
     */
    public String getState() {

    public List<String> getProgramRequirements() {
        if (programRequirements == null) {
            programRequirements = new ArrayList<String>(0);
        }
        return programRequirements;
    }

    public void setProgramRequirements(List<String> programRequirements) {
        this.programRequirements = programRequirements;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning unit type. Once set at create time, this field may not be updated.
     */
    public String getType() {

    }

    /**
     * The description of the document usage in the context of the CLU.
     */
    public RichTextInfo getDesc() {
        return desc;
    }

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this LU Doc Relation became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LU Doc Relation expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {

    }

    /**
     * Date and time that this LO to LO relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LO to LO relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for the LO to LO relation type.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

	/**
	 * 	Narrative description of the CLU Fee Record. 
	 */
    public RichTextInfo getDescr() {
		return descr;
	}

	public void setDescr(RichTextInfo descr) {
		this.descr = descr;
	}

	/**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    
    /**
	 * Create and last update info for the structure. This is optional and treated as read only since the 
	 * data is set by the internals of the service during maintenance operations.     
	 */
    public MetaInfo getMetaInfo() {
		return metaInfo;
	}

	public void setMetaInfo(MetaInfo metaInfo) {
		this.metaInfo = metaInfo;
	}

	/**
     * Identifier for the clu fee record.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

		return attributes;
	}

	/**
	 * Sets the list of key/value pairs, typically used for dynamic attributes.
	 *
	 * @param attributes Map of attributes
	 */
	public void setAttributes(Map<String, String> attributes) {
		this.attributes = attributes;
	}

	/**
	 * Gets the create and last update info for the structure.
	 * This is optional and treated as read only since the data is set by
	 * the internals of the service during maintenance operations.
	 *
	 * @return Meta data information
	 */
	public MetaInfo getMetaInfo() {
		return metaInfo;
	}

	/**
	 * Sets the create and last update info for the structure.
	 * This is optional and treated as read only since the data is set by
	 * the internals of the service during maintenance operations.
	 *
	 * @param metaInfo Meta data information
	 */
	public void setMetaInfo(MetaInfo metaInfo) {
		this.metaInfo = metaInfo;
	}

	/**
	 * Gets the object to statement relation type.
	 *
	 * @return Object to statement relation type
	 */
	public String getType() {
		return type;
	}

	/**
	 * Sets the object to statement relation type.
	 *
	 * @param type Object to statement relation type
	 */
	public void setType(String type) {
		this.type = type;
	}

	/**
	 * Gets the identifier for the current status of the object to statement
	 * relationship. The values for this field are constrained to those in
	 * the refStatementRelationState enumeration. A separate setup operation
	 * does not exist for retrieval of the meta data around this value.
	 *
	 * @return Object to statement relation state
	 */
	public String getState() {
		return state;
	}

	/**
	 * Sets the identifier for the current status of the object to statement
	 * relationship. The values for this field are constrained to those in
	 * the refStatementRelationState enumeration. A separate setup operation
	 * does not exist for retrieval of the meta data around this value.
	 *
	 * @param state Object to statement relation state
	 */
	public void setState(String state) {
		this.state = state;
	}

	/**
	 * Gets the unique identifier for a single Object Statement Relationship record.
	 *
	 * @return Object to Statement Relation Identifier
	 */
	public String getId() {
		return id;
	}

	/**
	 * Sets the unique identifier for a single Object Statement Relationship record.
	 *
	 * @param id Object to statement relation identifier
	 */
	public void setId(String id) {
		this.id = id;
	}

	@Override
	public String toString() {
		return "RefStatementRelationInfo[id=" + id + ", type=" + type

    }

    /**
     * Date and time that this LO to LO relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LO to LO relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for the LO to LO relation type.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Description of the scale.
     */
    public RichTextInfo getDesc() {
        return desc;
    }

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this scale became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this scale expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a scale.
     */
    public String getId() {

    }

    /**
     * Date and time that this person type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this person type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a person type.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Description of the scale.
     */
    public RichTextInfo getDesc() {
        return desc;
    }

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this scale became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this scale expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a scale.
     */
    public String getId() {

    }

    /**
     * Date that this person to person relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date that this person to person relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Identifier for a person to person relationship type.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * The description of the document usage in the context of the relation to the object.
     */
    public RichTextInfo getDesc() {
        return desc;
    }

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this Object Doc Relation became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this Object Doc Relation expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {

    }

    /**
     * Date that this person to person relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date that this person to person relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Identifier for a person to person relationship type.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

		innerLayout.add(mainImage);

		titlePanel.setVerticalAlignment(HasVerticalAlignment.ALIGN_BOTTOM);
		titlePanel.add(titleLabel);
		titlePanel.setHorizontalAlignment(HasHorizontalAlignment.ALIGN_RIGHT);
		titlePanel.add(titleWidgetsPanel);
		descLayout.add(this.largeDescription);
		contentLayout.add(descLayout);
		contentLayout.add(content);
		innerLayout.add(contentLayout);

		layout.add(titlePanel);
		layout.add(innerLayout);
		wrapper.setWidget(layout);
		this.largeDescription.addStyleName("KS-LandingPage-Description");
		this.titleLabel.addStyleName("KS-LandingPage-Title");
		this.layout.addStyleName("KS-LandingPage-Panel");
		this.innerLayout.addStyleName("KS-LandingPage-ContentPanel");
		this.titlePanel.addStyleName("KS-LandingPage-TitlePanel");
		this.wrapper.addStyleName("KS-LandingPage");
		this.titleWidgetsPanel.addStyleName("KS-LandingPage-TitleWidgetsPanel");

	}
	
	public Date getEffectiveDate(){
		return effectiveDate;
	}
	
	public void setEffectiveDate(Date effectiveDate){
		this.effectiveDate = effectiveDate;
	}
	
	public Date getExpirationDate(){
		return expirationDate;
	}
	
	public void setExpirationDate(Date expirationDate){
		this.expirationDate = expirationDate;
	}
	
	public Map<String, String> getAttributes(){
		if(attributes == null){
			attributes = new HashMap<String, String>();
		}
		return attributes;
	}
	
	public void setAttributes(Map<String, String> attributes){
		this.attributes = attributes;
	}
	
	public String getId(){
		return id;
	}
	
	public void setId(String id){
		this.id = id;
	}
}

            }

            String user = XmlUtils.getTextForElement(response, "user");
            String pgt  = XmlUtils.getTextForElement(response, "proxyGrantingTicket");
            String proxies = XmlUtils.getTextForElement(response, "proxies");
            
            Map<String,String> samlProperties = new HashMap<String,String>();
            samlProperties.put("user", user.trim());
            samlProperties.put("proxyGrantingTicket", pgt.trim());
            samlProperties.put("proxies", proxies.trim());
            samlProperties.put("samlIssuerForUser", samlIssuerForUser.trim());
            
            SamlUtils.setSamlProperties(samlProperties);
            SAMLAssertion samlAssertion = SamlUtils.createAssertion();
            
            Document signedSAML = SamlUtils.signAssertion(samlAssertion);

    private Document validateCasProxyTicket(String proxyTicketId, String proxyTargetService) throws KSSecurityException{
        
        String url = constructUrl(proxyTicketId, proxyTargetService);
        HttpURLConnection conn = null;
        
        try {
            URL constructedUrl = new URL(url);
            conn = (HttpURLConnection) constructedUrl.openConnection();

            BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));

            String line;
            StringBuffer stringBuffer = new StringBuffer(255);
            String response;

            while ((line = in.readLine()) != null) {
                stringBuffer.append(line);
            }
            
            response = stringBuffer.toString();
            String error = XmlUtils.getTextForElement(response, "authenticationFailure");

            if (CommonUtils.isNotEmpty(error)) {

			String errorSections = "";
			StringBuilder errorSectionsbuffer = new StringBuilder();
			errorSectionsbuffer.append(errorSections);
			for (Entry<Enum<?>, View> entry:viewMap.entrySet()) {
				View v = entry.getValue();
				if (v instanceof Section){
					if (!isValid(validationResults, (Section)v)){
						isValid = false;
						errorSectionsbuffer.append(((SectionView)v).getName() + ", ");
					}
				}
			}
			errorSections = errorSectionsbuffer.toString();
			if (!errorSections.isEmpty()){
				errorSections = errorSections.substring(0, errorSections.length()-2);

public class RequestSecurityTokenType {

    @XmlAnyElement(lax = true)
    protected List<Object> any;
    @XmlAttribute(name = "Context")
    @XmlSchemaType(name = "anyURI")
    protected String context;
    @XmlAnyAttribute
    private Map<QName, String> otherAttributes = new HashMap<QName, String>();

    /**
     * Gets the value of the any property.
     * 
     * <p>
     * This accessor method returns a reference to the live list,
     * not a snapshot. Therefore any modification you make to the
     * returned list will be present inside the JAXB object.
     * This is why there is not a <CODE>set</CODE> method for the any property.
     * 
     * <p>
     * For example, to add a new item, do as follows:
     * <pre>
     *    getAny().add(newItem);
     * </pre>
     * 
     * 
     * <p>
     * Objects of the following type(s) are allowed in the list
     * {@link Object }
     * {@link Element }
     * 
     * 
     */
    public List<Object> getAny() {
        if (any == null) {
            any = new ArrayList<Object>();
        }
        return this.any;
    }

    /**
     * Gets the value of the context property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getContext() {
        return context;
    }

    /**
     * Sets the value of the context property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setContext(String value) {
        this.context = value;
    }

    /**
     * Gets a map that contains attributes that aren't bound to any typed property on this class.
     * 
     * <p>
     * the map is keyed by the name of the attribute and 
     * the value is the string value of the attribute.
     * 
     * the map returned by this method is live, and you can add new attribute
     * by updating the map directly. Because of this design, there's no setter.
     * 
     * 
     * @return
     *     always non-null
     */
    public Map<QName, String> getOtherAttributes() {
        return otherAttributes;
    }

}

        initHandlers();
    }

    @Override
    protected void configureView() {
        super.configureView();
        if (!initialized) {
            eventBus.fireEvent(new MetadataLoadedEvent(programModel.getDefinition(), this));
            List<Enum<?>> excludedViews = new ArrayList<Enum<?>>();
            excludedViews.add(ProgramSections.PROGRAM_REQUIREMENTS_EDIT);
            excludedViews.add(ProgramSections.SUPPORTING_DOCUMENTS_EDIT);
            excludedViews.add(ProgramSections.SUMMARY);
            addCommonButton(ProgramProperties.get().program_menu_sections(), saveButton, excludedViews);
            addCommonButton(ProgramProperties.get().program_menu_sections(), cancelButton, excludedViews);
            initialized = true;
        }
    }

    private void initHandlers() {

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for the LU to LU relation type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * Identifier for the current status of a CLU to CLU relationship. The values for this field are constrained to those in the luLuRelationState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a CLU to CLU relationship. This is optional, due to the identifier being set at the time of creation. Once the relation has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
    	return "CluCluRelationInfo[id=" + id + ", cluId=" + cluId + ", relatedCluId=" + relatedCluId + ", type=" + type + ", cluRelationRequired=" + isCluRelationRequired + "]";

public class ValidateCourseStatement {

    @XmlElement(name = "courseId")
    private java.lang.String courseId;
    @XmlElement(name = "statementTreeViewInfo")
    private org.kuali.student.core.statement.dto.StatementTreeViewInfo statementTreeViewInfo;

    public java.lang.String getCourseId() {
        return this.courseId;
    }

    public void setCourseId(java.lang.String newCourseId)  {
        this.courseId = newCourseId;
    }

    public org.kuali.student.core.statement.dto.StatementTreeViewInfo getStatementTreeViewInfo() {
        return this.statementTreeViewInfo;
    }

    public void setStatementTreeViewInfo(org.kuali.student.core.statement.dto.StatementTreeViewInfo newStatementTreeViewInfo)  {
        this.statementTreeViewInfo = newStatementTreeViewInfo;
    }

}

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for the LU to LU relation type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * Identifier for the current status of a CLU to CLU relationship. The values for this field are constrained to those in the luLuRelationState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a CLU to CLU relationship. This is optional, due to the identifier being set at the time of creation. Once the relation has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
    	return "CluCluRelationInfo[id=" + id + ", cluId=" + cluId + ", relatedCluId=" + relatedCluId + ", type=" + type + ", cluRelationRequired=" + isCluRelationRequired + "]";

    private static class RecursionCounter{
        public static final int MAX_DEPTH = 4;
        
        private Map<String, Integer> recursions = new HashMap<String, Integer>();
        
        public int increment(String objectName){
            Integer hits = recursions.get(objectName);
            
            if (hits == null){
                hits = new Integer(1);
            } else {
                hits++;
            }
            recursions.put(objectName, hits);
            return hits;
        }
        
        public int decrement(String objectName){
            Integer hits = recursions.get(objectName);
             if (hits >= 1){
                 hits--;
             }

             recursions.put(objectName, hits);
             return hits;
        }
    }
    
    /**
     * Create a Metadata service initialized using a given classpath metadata context file
     * 
     * @param metadataContext the classpath metadata context file
     */
    public MetadataServiceImpl(String metadataContext){

 }

 private String escapeWiki(String str) {
		StringBuilder bldr = new StringBuilder(str.length());
		boolean precededByBackSlash = false;
		for (int i = 0; i < str.length(); i++) {
			char c = str.charAt(i);
			switch (c) {
			case '\\':
			case '[':
			case '*':
			case ']':
			case '|':
				if (!precededByBackSlash) {
					bldr.append('\\');
				}
				break;
			default:
				break;
			}
			bldr.append(c);
			if (c == '\\') {
				precededByBackSlash = true;
			} else {
				precededByBackSlash = false;
			}
		}
		return bldr.toString();
	}

				roleQuals.putAll(attributes);
			}
			if (StringUtils.isNotBlank(namespaceCode) && StringUtils.isNotBlank(permissionTemplateName)) {
				LOG.info("Checking Permission '" + namespaceCode + "/" + permissionTemplateName + "' for user '" + user + "'");
				result = getPermissionService().isAuthorizedByTemplateName(user, namespaceCode, permissionTemplateName, null, roleQuals);
			}
			else {
				LOG.info("Can not check Permission with namespace '" + namespaceCode + "' and template name '" + permissionTemplateName + "' for user '" + user + "'");
				return Boolean.TRUE;
			}
		}
		else {
			LOG.info("Will not check for document level permissions. Defaulting authorization to true.");
			result = true;
		}
		LOG.info("Result of authorization check for user '" + user + "': " + result);
		return Boolean.valueOf(result);
	}

            if (isRepeating(field)){
                Metadata repeatingMetadata = new Metadata();
                metadata.setDataType(DataType.LIST);
                
                repeatingMetadata.setWriteAccess(WriteAccess.ALWAYS);
                repeatingMetadata.setOnChangeRefreshMetadata(false);
                repeatingMetadata.setDataType(convertDictionaryDataType(fd.getDataType()));
                
                if (nestedProperties != null){
                    repeatingMetadata.setProperties(nestedProperties);
                }
                
                Map<String, Metadata> repeatingProperty = new HashMap<String, Metadata>();
                repeatingProperty.put("*", repeatingMetadata);
                metadata.setProperties(repeatingProperty);
            } else if (nestedProperties != null){
                metadata.setProperties(nestedProperties);
            }
            
            properties.put(fd.getName(), metadata);
            
        }

		if(statementTreeView!=null){
			statementTreeView.setId(null);
			for(ReqComponentInfo reqComp:statementTreeView.getReqComponents()){
				reqComp.setId(null);
				for(ReqCompFieldInfo field:reqComp.getReqCompFields()){
					field.setId(null);
					//copy any clusets that are adhoc'd and set the field value to the new cluset
					if(ReqComponentFieldTypes.COURSE_CLUSET_KEY.getId().equals(field.getType())||
					   ReqComponentFieldTypes.PROGRAM_CLUSET_KEY.getId().equals(field.getType())||
					   ReqComponentFieldTypes.CLUSET_KEY.getId().equals(field.getType())){
						try {
							CluSetInfo cluSet = luService.getCluSetInfo(field.getValue());
							cluSet.setId(null);

			throws DoesNotExistException, InvalidParameterException,
			MissingParameterException, OperationFailedException,
			PermissionDeniedException {
        
        Enumeration meta;
        try {           
            meta = enumDAO.fetch(Enumeration.class, enumeratedValue.getEnumerationKey());           
        } catch (DoesNotExistException e) {
            throw new InvalidParameterException("Enumeration does not exist for key:"+enumerationKey);
        }
    	
    	if(meta != null){
	        List<ValidationResultInfo> results = this.validateEnumeratedValue(enumeratedValue);

	        if(null != results) {
	            for(ValidationResultInfo result:results){
	                if(result !=null && ValidationResultInfo.ErrorLevel.ERROR.equals(result.getErrorLevel())){
	                    throw new EnumerationException("addEnumeratedValue failed because the EnumeratdValue failed to pass validation against its EnumerationMeta - With Messages: " + result.toString());//FIXME need to get messages here
	                }
	            }
	        }
    	}

	    EnumeratedValue enumeratedValueEntity = new EnumeratedValue();    

    @Column(name = "CAN_CREATE_LUI")
    private boolean canCreateLui;

    @Column(name = "REF_URL")
    private String referenceURL;

    @OneToMany(cascade = CascadeType.ALL, mappedBy="clu")
    private List<LuCode> luCodes;
        
    @Column(name = "NEXT_REVIEW_PRD")
    private String nextReviewPeriod;

    @Column(name = "IS_ENRL")
    private boolean enrollable;
    
    @OneToMany(cascade=CascadeType.ALL, mappedBy="clu")
    private List<CluAtpTypeKey> offeredAtpTypes;
    
    @Column(name = "HAS_EARLY_DROP_DEDLN")
    private boolean hasEarlyDropDeadline;

    @Column(name = "DEF_ENRL_EST")
    private int defaultEnrollmentEstimate;

    @Column(name = "DEF_MAX_ENRL")
    private int defaultMaximumEnrollment;

    @Column(name = "IS_HAZR_DISBLD_STU")
    private boolean hazardousForDisabledStudents;

public class AttributedDateTime {

    @XmlValue
    protected String value;
    @XmlAttribute(name = "Id", namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd")
    @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
    @XmlID
    @XmlSchemaType(name = "ID")
    protected String id;
    @XmlAnyAttribute
    private Map<QName, String> otherAttributes = new HashMap<QName, String>();

    /**
     * Gets the value of the value property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getValue() {
        return value;
    }

    /**
     * Sets the value of the value property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setValue(String value) {
        this.value = value;
    }

    /**
     * Gets the value of the id property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getId() {
        return id;
    }

    /**
     * Sets the value of the id property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setId(String value) {
        this.id = value;
    }

    /**
     * Gets a map that contains attributes that aren't bound to any typed property on this class.
     * 
     * <p>
     * the map is keyed by the name of the attribute and 
     * the value is the string value of the attribute.
     * 
     * the map returned by this method is live, and you can add new attribute
     * by updating the map directly. Because of this design, there's no setter.
     * 
     * 
     * @return
     *     always non-null
     */
    public Map<QName, String> getOtherAttributes() {
        return otherAttributes;
    }

}

        searchRequest.setParams(queryParamValues);
        
        try {
            SearchResult results = getOrganizationService().search(searchRequest);

            for (SearchResultRow result : results.getRows()) {
                String orgId = "";
                String orgShortName = "";
                for (SearchResultCell resultCell : result.getCells()) {
                    if ("org.resultColumn.orgId".equals(resultCell
                            .getKey())) {
                        orgId = resultCell.getValue();
                    } else if ("org.resultColumn.orgShortName"
                            .equals(resultCell.getKey())) {
                        orgShortName = resultCell.getValue();
                    }
                }
                departments.add(buildKeyLabelPair(orgId, orgShortName, null, null));
            }

            return departments;
        } catch (Exception e) {

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    /**
     * Abbreviated name of the CLU, commonly used on transcripts
     */
    public String getShortName() {
        return shortName;
    }

    public void setShortName(String shortName) {
        this.shortName = shortName;
    }

    public String getLongName() {
        return longName;
    }

    public void setLongName(String longName) {
        this.longName = longName;
    }

    /**
     * A code that indicates whether this is introductory, advanced, etc.
     */
    public String getLevel() {
        return level;
    }

    public void setLevel(String level) {
        this.level = level;
    }

    /**
     * A code that indicates what school, program, major, subject area, etc. Examples: "Chem", "18"
     */
    public String getDivision() {
        return division;
    }

    public void setDivision(String division) {
        this.division = division;
    }
    
    /*
     * The "extra" portion of the code, which usually corresponds with the most detailed part of the number. 
     */    
    public String getSuffixCode() {

    }

    protected void resetActionList() {
    	//Only allow modify with version option for an active course that id also the latest version
    	ProgramStatus status = ProgramStatus.of(programModel.<String>get(ProgramConstants.STATE));
        String versionIndId = programModel.get(ProgramConstants.VERSION_IND_ID);
        Long sequenceNumber = programModel.get(ProgramConstants.VERSION_SEQUENCE_NUMBER);
                       
        actionBox.clear();
        if (status == ProgramStatus.ACTIVE){
        	programRemoteService.isLatestVersion(versionIndId, sequenceNumber, new KSAsyncCallback<Boolean>(){
				public void onSuccess(Boolean isLatest) {
			        actionBox.setList(ActionType.getValues(isLatest));				
				}        	
	        });
        } else {
        	actionBox.setList(ActionType.getValues(false));
        }
    }

	@ManyToOne
	@JoinColumn(name = "LU_TYPE_ID")
	private LuType luType;

	@Temporal(TemporalType.TIMESTAMP)
	@Column(name = "EFF_DT")
	private Date effectiveDate;

	@Temporal(TemporalType.TIMESTAMP)
	@Column(name = "EXPIR_DT")
	private Date expirationDate;

	public LuType getLuType() {
		return luType;
	}

	public void setLuType(LuType luType) {
		this.luType = luType;
	}

	public Date getEffectiveDate() {
		return effectiveDate;
	}

	public void setEffectiveDate(Date effectiveDate) {
		this.effectiveDate = effectiveDate;
	}

	public Date getExpirationDate() {
		return expirationDate;
	}

	public void setExpirationDate(Date expirationDate) {
		this.expirationDate = expirationDate;
	}
	
	public ResultUsageType getResultUsageType() {

    }

	/**
	 * Gets the clu set type. 
	 * Once set at create time, this field may not be updated.
	 * 
	 * @return Clu set type
	 */
	public String getType() {
		return type;
	}

	/**
	 * Sets the clu set type. 
	 * Once set at create time, this field may not be updated.
	 * 
	 * @param type Clu set type
	 */
	public void setType(String type) {
		this.type = type;
	}

	public String getState() {
		return state;
	}

	public void setState(String state) {
		this.state = state;
	}

	public String getAdminOrg() {
		return adminOrg;
	}

	public void setAdminOrg(String adminOrg) {
		this.adminOrg = adminOrg;
	}

	public Boolean getIsReusable() {
		return isReusable;
	}

	public void setIsReusable(Boolean isReusable) {
		this.isReusable = isReusable;
	}

	public Boolean getIsReferenceable() {
		return isReferenceable;
	}

	public void setIsReferenceable(Boolean isReferenceable) {
		this.isReferenceable = isReferenceable;
	}

    public String getCode() {
        return code;
    }

    public void setCode(String code) {
        this.code = code;
    }

    public String getAbbrevValue() {
        return abbrevValue;
    }

    public void setAbbrevValue(String abbrevValue) {
        this.abbrevValue = abbrevValue;
    }

    public String getValue() {
        return value;
    }

    public void setValue(String value) {
        this.value = value;
    }

    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    public int getSortKey() {

        configurer.addReadOnlyField(section, ProgramConstants.CREDENTIAL_PROGRAM_INSTITUTION_ID, new MessageKeyInfo(ProgramProperties.get().programInformation_institution()));
        return section;
    }

    public VerticalSection createActivateProgramSection(){
        VerticalSection section = new VerticalSection(SectionTitle.generateH2Title(ProgramProperties.get().programInformation_activateProgram()));
        section.setInstructions("<br>" + ProgramProperties.get().programInformation_activateInstructions() + "<br><br>");
        configurer.addField(section, ProgramConstants.PREV_END_PROGRAM_ENTRY_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_entryTerm()));
        configurer.addField(section, ProgramConstants.PREV_END_PROGRAM_ENROLL_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_enrollTerm()));
        return section;
    }


}

    public String getVersionIndId() {
        return versionIndId;
    }

    public void setVersionIndId(String versionIndId) {
        this.versionIndId = versionIndId;
    }

    /**
     * The sequence number of the version
     */
    public Long getSequenceNumber() {
        return sequenceNumber;
    }

    public void setSequenceNumber(Long sequenceNumber) {
        this.sequenceNumber = sequenceNumber;
    }

    /**
     * The date and time this version became current.
     */
    public Date getCurrentVersionStart() {
		return currentVersionStart;
	}

	public void setCurrentVersionStart(Date currentVersionStart) {
		this.currentVersionStart = currentVersionStart;
	}

    /**
     * The date and time when this version stopped being current.
     */
	public Date getCurrentVersionEnd() {
		return currentVersionEnd;
	}

	public void setCurrentVersionEnd(Date currentVersionEnd) {
		this.currentVersionEnd = currentVersionEnd;
	}

    /**
     * Comments associated with the verison
     */
    public String getVersionComment() {
        return versionComment;
    }

    public void setVersionComment(String versionComment) {
        this.versionComment = versionComment;
    }

    protected String value;
    @XmlAttribute(name = "Id", namespace = "http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd")
    @XmlJavaTypeAdapter(CollapsedStringAdapter.class)
    @XmlID
    @XmlSchemaType(name = "ID")
    protected String id;
    @XmlAnyAttribute
    private Map<QName, String> otherAttributes = new HashMap<QName, String>();

    /**
     * Gets the value of the value property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getValue() {
        return value;
    }

    /**
     * Sets the value of the value property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setValue(String value) {
        this.value = value;
    }

    /**
     * Gets the value of the id property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getId() {
        return id;
    }

    /**
     * Sets the value of the id property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setId(String value) {
        this.id = value;
    }

    /**
     * Gets a map that contains attributes that aren't bound to any typed property on this class.
     * 
     * <p>
     * the map is keyed by the name of the attribute and 
     * the value is the string value of the attribute.
     * 
     * the map returned by this method is live, and you can add new attribute
     * by updating the map directly. Because of this design, there's no setter.
     * 
     * 
     * @return
     *     always non-null
     */
    public Map<QName, String> getOtherAttributes() {
        return otherAttributes;
    }

}

        rootSection.addSection(collapsableSection);
    }

    private VerticalSection createMainSection() {
        VerticalSection section = new VerticalSection();
        configurer.addReadOnlyField(section, ProgramConstants.CURRICULUM_OVERSIGHT_DIVISION, new MessageKeyInfo(ProgramProperties.get().managingBodies_curriculumOversightDivision()));
        configurer.addReadOnlyField(section, ProgramConstants.CURRICULUM_OVERSIGHT_UNIT, new MessageKeyInfo(ProgramProperties.get().managingBodies_curriculumOversightUnit()));
        configurer.addReadOnlyField(section, ProgramConstants.STUDENT_OVERSIGHT_DIVISION, new MessageKeyInfo(ProgramProperties.get().managingBodies_studentOversightDivision()));
        configurer.addReadOnlyField(section, ProgramConstants.STUDENT_OVERSIGHT_UNIT, new MessageKeyInfo(ProgramProperties.get().managingBodies_studentOversightUnit()));
        return section;
    }

		return attributes;
	}

	/**
	 * Sets the list of key/value pairs, typically used for dynamic attributes.
	 *
	 * @param attributes Map of attributes
	 */
	public void setAttributes(Map<String, String> attributes) {
		this.attributes = attributes;
	}

	/**
	 * Gets the create and last update info for the structure.
	 * This is optional and treated as read only since the data is set by
	 * the internals of the service during maintenance operations.
	 *
	 * @return Meta data information
	 */
	public MetaInfo getMetaInfo() {
		return metaInfo;
	}

	/**
	 * Sets the create and last update info for the structure.
	 * This is optional and treated as read only since the data is set by
	 * the internals of the service during maintenance operations.
	 *
	 * @param metaInfo Meta data information
	 */
	public void setMetaInfo(MetaInfo metaInfo) {
		this.metaInfo = metaInfo;
	}

	/**
	 * Gets the object to statement relation type.
	 *
	 * @return Object to statement relation type
	 */
	public String getType() {
		return type;
	}

	/**
	 * Sets the object to statement relation type.
	 *
	 * @param type Object to statement relation type
	 */
	public void setType(String type) {
		this.type = type;
	}

	/**
	 * Gets the identifier for the current status of the object to statement
	 * relationship. The values for this field are constrained to those in
	 * the refStatementRelationState enumeration. A separate setup operation
	 * does not exist for retrieval of the meta data around this value.
	 *
	 * @return Object to statement relation state
	 */
	public String getState() {
		return state;
	}

	/**
	 * Sets the identifier for the current status of the object to statement
	 * relationship. The values for this field are constrained to those in
	 * the refStatementRelationState enumeration. A separate setup operation
	 * does not exist for retrieval of the meta data around this value.
	 *
	 * @param state Object to statement relation state
	 */
	public void setState(String state) {
		this.state = state;
	}

	/**
	 * Gets the unique identifier for a single Object Statement Relationship record.
	 *
	 * @return Object to Statement Relation Identifier
	 */
	public String getId() {
		return id;
	}

	/**
	 * Sets the unique identifier for a single Object Statement Relationship record.
	 *
	 * @param id Object to statement relation identifier
	 */
	public void setId(String id) {
		this.id = id;
	}

        });
    }

    @Override
    protected void loadModel(ModelRequestCallback<DataModel> callback) {
        ViewContext viewContext = getViewContext();
        if (viewContext.getIdType() == IdType.COPY_OF_OBJECT_ID) {
            createNewVersionAndLoadModel(callback, viewContext);
        } else {
            super.loadModel(callback);
        }
    }

    protected void createNewVersionAndLoadModel(final ModelRequestCallback<DataModel> callback, final ViewContext viewContext) {
        Data data = new Data();
        Data versionData = new Data();
        versionData.set(new Data.StringKey("versionIndId"), getViewContext().getId());
        versionData.set(new Data.StringKey("versionComment"), "Credential Program Version");

			results = credentialProgramAssembler.disassemble(originaCredentialProgram, NodeOperation.UPDATE);

			// Use the results to make the appropriate service calls here
			programServiceMethodInvoker.invokeServiceCalls(results);

			return results.getBusinessDTORef();
		} catch(AssemblyException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (AlreadyExistsException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (DependentObjectsExistException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (CircularRelationshipException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (UnsupportedActionException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (CircularReferenceException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		}
	}


	@Override
	public StatusInfo setCurrentCoreProgramVersion(String coreProgramId,

    @XmlAttribute(name="key")
    private String id;

    /**
     * Gets the friendly name of the Object Statement Relation type.
     * 
     * @return Statement relation type name
     */
    public String getName() {
		return name;
	}

    /**
     * Sets the friendly name of the Object Statement Relation type.
     * 
     * @param name Statement relation type name
     */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * Gets the narrative description of the Object Statement Relation.
	 * 
	 * @return Statement relation description
	 */
	public String getDesc() {
		return desc;
	}

	/**
	 * Sets the narrative description of the Object Statement Relation.
	 * 
	 * @param desc Object statement relation description
	 */
	public void setDesc(String desc) {
		this.desc = desc;
	}

	/**
	 * Gets the Date and time that this object statement relation type 
	 * became effective. This is a similar concept to the effective date on 
	 * enumerated values. When an expiration date has been specified, 
	 * this field must be less than or equal to the expiration date.
	 * 
	 * @return Statement relation type effective date
	 */
	public Date getEffectiveDate() {
		return effectiveDate;
	}

	/**
	 * Sets the Date and time that this object statement relation type 
	 * became effective. This is a similar concept to the effective date on 
	 * enumerated values. When an expiration date has been specified, 
	 * this field must be less than or equal to the expiration date.
	 * 
	 * @param effectiveDate Statement relation type effective date
	 */
	public void setEffectiveDate(Date effectiveDate) {
		this.effectiveDate = effectiveDate;
	}

	/**
	 * Sets the date and time that this object statement relation type expires. 
	 * This is a similar concept to the expiration date on enumerated values. 
	 * If specified, this should be greater than or equal to the effective date. 
	 * If this field is not specified, then no expiration date has been 
	 * currently defined and should automatically be considered greater than 
	 * the effective date.
	 * 
	 * @return Statement relation type expiration date
	 */
	public Date getExpirationDate() {
		return expirationDate;
	}

	/**
	 * Gets the date and time that this object statement relation type expires. 
	 * This is a similar concept to the expiration date on enumerated values. 
	 * If specified, this should be greater than or equal to the effective date. 
	 * If this field is not specified, then no expiration date has been 
	 * currently defined and should automatically be considered greater than 
	 * the effective date.
	 * 
	 * @param expirationDate Statement relation type expiration date
	 */
	public void setExpirationDate(Date expirationDate) {
		this.expirationDate = expirationDate;
	}

	/**
	 * Gets the list of key/value pairs, typically used for dynamic attributes.
	 * 
	 * @return Map of attributes
	 */
	public Map<String, String> getAttributes() {

    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String,String> attributes;

    @XmlElement
    private MetaInfo metaInfo;

    @XmlAttribute
    private String type;

    @XmlAttribute
    private String state;

    @XmlAttribute(name="key")
    private String id;

    /**
     * Name of the milestone.
     */
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    /**
     * Description of the milestone.
     */
    public RichTextInfo getDesc() {
        return desc;
    }

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Unique identifier for an Academic Time Period (ATP).
     */
    public String getAtpId() {
        return atpId;
    }

    public void setAtpId(String atpId) {
        this.atpId = atpId;
    }

    /**
     * Date and time of the milestone.
     */
    public Date getMilestoneDate() {

				preIndent + this.booleanOperators.getOrOperator() + 
				this.booleanOperatorSuffix + 
				postIndent + this.indentString + node.getRightNode().getNodeMessage();

			if(node.getParent() != null && 
					((node.getLabel().equals("+") && 
							node.getParent().getLabel().equals("*")) || 
							(node.getLabel().equals("*") && 
									node.getParent().getLabel().equals("+")))) {
				logMessage = node.getLeftNode().getNodeMessage() + 
					this.booleanOperatorPrefix + 
					preIndent + this.booleanOperators.getOrOperator() + 

    @XmlAttribute(name="key")
    private String id;

    /**
     * Gets the friendly name of the Object Statement Relation type.
     * 
     * @return Statement relation type name
     */
    public String getName() {
		return name;
	}

    /**
     * Sets the friendly name of the Object Statement Relation type.
     * 
     * @param name Statement relation type name
     */
	public void setName(String name) {
		this.name = name;
	}

	/**
	 * Gets the narrative description of the Object Statement Relation.
	 * 
	 * @return Statement relation description
	 */
	public String getDesc() {
		return desc;
	}

	/**
	 * Sets the narrative description of the Object Statement Relation.
	 * 
	 * @param desc Object statement relation description
	 */
	public void setDesc(String desc) {
		this.desc = desc;
	}

	/**
	 * Gets the Date and time that this object statement relation type 
	 * became effective. This is a similar concept to the effective date on 
	 * enumerated values. When an expiration date has been specified, 
	 * this field must be less than or equal to the expiration date.
	 * 
	 * @return Statement relation type effective date
	 */
	public Date getEffectiveDate() {
		return effectiveDate;
	}

	/**
	 * Sets the Date and time that this object statement relation type 
	 * became effective. This is a similar concept to the effective date on 
	 * enumerated values. When an expiration date has been specified, 
	 * this field must be less than or equal to the expiration date.
	 * 
	 * @param effectiveDate Statement relation type effective date
	 */
	public void setEffectiveDate(Date effectiveDate) {
		this.effectiveDate = effectiveDate;
	}

	/**
	 * Sets the date and time that this object statement relation type expires. 
	 * This is a similar concept to the expiration date on enumerated values. 
	 * If specified, this should be greater than or equal to the effective date. 
	 * If this field is not specified, then no expiration date has been 
	 * currently defined and should automatically be considered greater than 
	 * the effective date.
	 * 
	 * @return Statement relation type expiration date
	 */
	public Date getExpirationDate() {
		return expirationDate;
	}

	/**
	 * Gets the date and time that this object statement relation type expires. 
	 * This is a similar concept to the expiration date on enumerated values. 
	 * If specified, this should be greater than or equal to the effective date. 
	 * If this field is not specified, then no expiration date has been 
	 * currently defined and should automatically be considered greater than 
	 * the effective date.
	 * 
	 * @param expirationDate Statement relation type expiration date
	 */
	public void setExpirationDate(Date expirationDate) {
		this.expirationDate = expirationDate;
	}

	/**
	 * Gets the list of key/value pairs, typically used for dynamic attributes.
	 * 
	 * @return Map of attributes
	 */
	public Map<String, String> getAttributes() {

						addError(results, element, FLOAT);
					}
					
	
					if (d != null) {
	    				Double min = getLargestMinValueDouble(meta);
	    				Double max = getSmallestMaxValueDouble(meta);
	    				
	    				if (min != null && max != null) {
	    					if (d < min || d > max) {
	    						addRangeError(results, element, OUT_OF_RANGE,  min, max);
	    					}
	    				} else if (min != null && d < min) {
	    					addError(results, element, MIN_VALUE, min);
	    				} else if (max != null && d > max) {
	    					addError(results, element, MAX_VALUE, max);
	    				}
					}
				}
			}
		}
	}
	
	private void doValidateDate(DataModel model, Metadata meta,

						addError(results, element, LONG);
					}
					
					
					if (i != null) {
	    				Long min = getLargestMinValue(meta);
	    				Long max = getSmallestMaxValue(meta);
	    				
	    				if (min != null && max != null) {
	    					if (i < min || i > max) {
	    						addRangeError(results, element, OUT_OF_RANGE, min, max);
	    					}
	    				} else if (min != null && i < min) {
	    					addError(results, element, MIN_VALUE, min);
	    				} else if (max != null && i > max) {
	    					addError(results, element, MAX_VALUE, max);
	    				}
					}
				}
			}
		}
	}
	
	private void doValidateDouble(DataModel model, Metadata meta,

        configurer.addField(section, ProgramConstants.SHORT_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleShort()));
        return section;
    }

    private VerticalSection createDatesSection() {
        VerticalSection section = new VerticalSection(SectionTitle.generateH3Title(ProgramProperties.get().programInformation_dates()));
        configurer.addField(section, ProgramConstants.START_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_startTerm()));
        configurer.addField(section, ProgramConstants.END_PROGRAM_ENTRY_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_entryTerm()));
        configurer.addField(section, ProgramConstants.END_PROGRAM_ENROLL_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_enrollTerm()));
        return section;
    }

    private VerticalSection createOtherInformationSection() {

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for the LU to LU relation type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * Identifier for the current status of a CLU to CLU relationship. The values for this field are constrained to those in the luLuRelationState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a CLU to CLU relationship. This is optional, due to the identifier being set at the time of creation. Once the relation has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

            samlProperties.put("proxies", "");
            samlProperties.put("samlIssuerForUser", samlIssuerForUser.trim());
            
            SamlUtils.setSamlProperties(samlProperties);
            SAMLAssertion samlAssertion = SamlUtils.createAssertion();
            
            Document signedSAML = SamlUtils.signAssertion(samlAssertion);
            
            // transform the saml DOM into a writer, and return as a string response
            DOMSource domSource = new DOMSource(signedSAML);
            StringWriter writer = new StringWriter();
            StreamResult result = new StreamResult(writer);
            
            TransformerFactory tf = TransformerFactory.newInstance();
            Transformer transformer;
            
            transformer = tf.newTransformer();
            transformer.transform(domSource, result);
            
            writer.flush();
            
            return writer.toString();
            
        } catch (final Exception e) {
            throw new KSSecurityException(e);
        } 

			return value == null || (value != null && "".equals(value));
		}

		@Override
		public void setModelValue(KSTextBox widget, DataModel model, String path) {
			String 	diplomaTitle = 	widget.getText();
			if(diplomaTitle != null)
				model.set(QueryPath.concat(null, "/" + ProgramConstants.DIPLOMA), diplomaTitle);
		}

		@Override
		public void setWidgetValue(KSTextBox widget, DataModel model, String path) {
			String diplomaTitle = model.get("/" + ProgramConstants.DIPLOMA);
			if(isEmpty(diplomaTitle)){
				String programTitle = model.get("/" + ProgramConstants.LONG_TITLE);
				if (!isEmpty(programTitle))

        final KSLightBox saveWindow = new KSLightBox();
        final KSLabel saveMessage = new KSLabel(saveActionEvent.getMessage() + "...");
        final OkGroup buttonGroup = new OkGroup(new Callback<OkEnum>(){

            @Override
            public void exec(OkEnum result) {
                saveWindow.hide();
                saveActionEvent.doActionComplete();                
            }
        });

        buttonGroup.setWidth("250px");
        buttonGroup.getButton(OkEnum.Ok).setEnabled(false);
        buttonGroup.setContent(saveMessage);


        if (saveActionEvent.isAcknowledgeRequired()){
            saveWindow.setWidget(buttonGroup);
        } else {
            saveWindow.setWidget(saveMessage);
        }
        saveWindow.show();

	private StylishDropDown navDropDown = new StylishDropDown("Select an area\u2026");
	private Anchor versionAnchor = new Anchor(" ( Version ) ");
	//private Widget headerCustomWidget = Theme.INSTANCE.getCommonWidgets().getHeaderWidget();

	private SimplePanel content = new SimplePanel();
	private KSLightBox docSearchDialog = new KSLightBox();

	private Frame docSearch;
    private String docSearchUrl = "";
    private String appUrl = "..";
    private String lumAppUrl = "..";
    private String riceURL ="..";
    private String riceLinkLabel="Rice";
    private String appVersion = "";
    private String codeServer = "";

    private boolean loaded = false;

    private static class WrapperNavigationHandler extends NavigationHandler{
		public WrapperNavigationHandler(String url) {
			super(url);
		}

		@Override
		public void beforeNavigate(Callback<Boolean> callback) {
			//FIXME notify current controller of the page change so it can perform an action
			//FIXME before navigation event
			callback.exec(true);
		}
    }
	public ApplicationHeader(){

  return calcSimpleName (fd.getDataObjectStructure ().getName ());
 }

 private String calcSimpleName (String name)
 {
  if (name.lastIndexOf (".") != -1)
  {
   name = name.substring (name.lastIndexOf (".") + 1);
  }
  return name;
 }

 private String calcNotSoSimpleName (String name)
 {
  if (name.lastIndexOf (".") == -1)
  {
   return name;
  }
  String simpleName = calcSimpleName (name);
  String fieldName = calcSimpleName (name.substring (0, name.length ()
                                                        - simpleName.length ()
                                                        - 1));
  return fieldName + "." + simpleName;
 }

 private String calcRequired (FieldDefinition fd)

        } catch (final Exception e) {
            throw new KSSecurityException(e);
        } finally {
            if (conn != null) {
                conn.disconnect();
            }
        }
    }
    
    private String constructUrl(String proxyTicketId, String proxyTargetService) throws KSSecurityException{
        try {
            return this.casServerUrl + (this.casServerUrl.endsWith("/") ? "" : "/") + "proxyValidate" + "?ticket=" 
            + proxyTicketId + "&service=" + URLEncoder.encode(proxyTargetService, "UTF-8") 
            + "&pgtUrl=" + URLEncoder.encode(proxyCallBackUrl, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            throw new KSSecurityException(e);
        }
    }

        layout.add(programWidget);
    }

    protected MessageKeyInfo generateMessageInfo(String labelKey) {
        return new MessageKeyInfo("clusetmanagement", "clusetmanagement", "draft", labelKey);
    }

	@Override
	public void addValueChangeCallback(Callback<Data.Value> callback) {
	}

	@Override
	public void setValue(Data.Value value) {    
	}

    @Override
    public void getValue(Callback<String> doneSaveCallback) { 
    }

    @Override
    public void setValue(final String id) {
        if (id != null) {
            getCluNameCallback.exec(id);
        }        
    }

    public void setLabelContent(String id, final String code) {
        layout.clear();

			results = coreProgramAssembler.disassemble(originalCoreProgram, NodeOperation.UPDATE);

			// Use the results to make the appropriate service calls here
			programServiceMethodInvoker.invokeServiceCalls(results);

			return results.getBusinessDTORef();
		} catch(AssemblyException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (AlreadyExistsException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (DependentObjectsExistException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (CircularRelationshipException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (UnsupportedActionException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		} catch (CircularReferenceException e) {
			throw new OperationFailedException("Error creating new MajorDiscipline version",e);
		}
	}

            Metadata metadata = searchMetadata.getProperties().get("findMajor");
            searchWidget = new KSPicker(metadata.getInitialLookup(), metadata.getAdditionalLookups());
            SearchPanel panel = ((KSPicker) searchWidget).getSearchPanel();
            if (panel != null) {
                panel.setMutipleSelect(false);
            }
            ((KSPicker) searchWidget).setAdvancedSearchCallback(new Callback<List<SelectedResults>>() {

                @Override
                public void exec(List<SelectedResults> result) {
                    SelectedResults value = result.get(0);
                    ViewContext viewContext = new ViewContext();
                    viewContext.setId(value.getResultRow().getId());

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this Object Doc Relation became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this Object Doc Relation expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {

	public Widget getReadOnlyWidget(Metadata meta){
		WidgetConfigInfo config = new WidgetConfigInfo();
		if (meta != null) {
			config.access = meta.getWriteAccess();
			config.isMultiLine = MetadataInterrogator.isMultilined(meta);
			config.isRepeating = MetadataInterrogator.isRepeating(meta);
			config.isRichText = MetadataInterrogator.hasConstraint(meta, ConstraintIds.RICH_TEXT);
			config.maxLength = MetadataInterrogator.getSmallestMaxLength(meta);
			config.type = meta.getDataType();
			config.metadata = meta;
			config.lookupMeta = meta.getInitialLookup();
			config.additionalLookups = meta.getAdditionalLookups();
			config.canEdit = false;

    public void setDescr(RichTextInfo descr) {
        this.descr = descr;
    }

    /**
     * Date and time that this CLU Set became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this CLU Set expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

//    /**
//     * Specifies a search for CLU identifiers. Present for dynamic CLU Sets
//     */
//    public CluCriteriaInfo getCluCriteria() {
//        return cluCriteria;
//    }
//
//    public void setCluCriteria(CluCriteriaInfo cluCriteria) {
//        this.cluCriteria = cluCriteria;
//    }


    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {

    public void setDesc(RichTextInfo desc) {
        this.desc = desc;
    }

    /**
     * Date and time that this Object Doc Relation became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this Object Doc Relation expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {

        configurer.addReadOnlyField(section, ProgramConstants.CREDENTIAL_PROGRAM_LEVEL, new MessageKeyInfo(ProgramProperties.get().programInformation_level()));
        return section;
    }

	private Widget configureSearch(String fieldKey) {	    
		Widget searchWidget;
		QueryPath path = QueryPath.concat(null, fieldKey);
		Metadata meta = configurer.getModelDefinition().getMetadata(path);
	        
		searchWidget = new KSPicker(meta.getInitialLookup(), meta.getAdditionalLookups());
		SearchPanel panel = ((KSPicker) searchWidget).getSearchPanel();
        if (panel != null) {
            panel.setMutipleSelect(false);
        }
        
		return searchWidget;
	}
	
    public class DiplomaBinding extends ModelWidgetBindingSupport<KSTextBox> {
		private boolean isEmpty(String value){
			return value == null || (value != null && "".equals(value));

    public void setId(String id) {
        this.id = id;
    }

    /**
     * Abbreviated name of the Credential program   
     */
    public String getShortTitle() {
        return shortTitle;
    }

    public void setShortTitle(String shortTitle) {
        this.shortTitle = shortTitle;
    }

    /**
     * Full name of the Credential Program  
     */
    public String getLongTitle() {
        return longTitle;
    }

    public void setLongTitle(String longTitle) {
        this.longTitle = longTitle;
    }

    /*
     * Information related to the official identification of the credential program, typically in human readable form. Used to officially reference or publish.  
     */
    public String getTranscriptTitle() {
        return transcriptTitle;
    }

    public void setTranscriptTitle(String transcriptTitle) {
        this.transcriptTitle = transcriptTitle;
    }

    @Override
    public String getDiplomaTitle() {
        return null;  //To change body of implemented methods use File | Settings | File Templates.
    }

    @Override
    public void setDiplomaTitle(String diplomaTitle) {
        //To change body of implemented methods use File | Settings | File Templates.
    }

    /**
     * A code that indicates whether this is Graduate, Undergraduage etc    
     */
    public String getProgramLevel() {

    	if(fireEvents == true){
    		
	    	if(id == null || id.equals("")){
	        	currentSuggestion = new IdableSuggestion();
	        	currentSuggestion.setId("");
	        	currentSuggestion.setDisplayString("");
	        	currentSuggestion.setReplacementString("");
	        	KSSuggestBox.this.setText("");
	        	currentId = KSSuggestBox.this.getSelectedId();
	    	}
	    	else
	    	{
		        oracle.getSuggestionByIdSearch(id, new Callback<IdableSuggestion>(){
		
		            @Override
		            public void exec(IdableSuggestion result) {
		                currentSuggestion = result;
		                KSSuggestBox.this.setText((currentSuggestion == null) ? "" : currentSuggestion.getReplacementString());         

        block.addSummaryMultiplicity(formatsConfig);
        //Fees
        MultiplicityConfiguration feesConfig = getMultiplicityConfig(COURSE + QueryPath.getPathSeparator() + FEES,
        		LUUIConstants.FEE,
		        Arrays.asList(
		                Arrays.asList("rateType", "Rate Type"),
		                Arrays.asList("feeType", "Fee Type")));
        //Note the use of empty string to remove the additional row from display in the summary table
        MultiplicityConfiguration amountsConfig = getMultiplicityConfig(COURSE + QueryPath.getPathSeparator() + FEES + QueryPath.getPathSeparator()
        		+ QueryPath.getWildCard() + QueryPath.getPathSeparator() + "feeAmounts",
        		"",
		        Arrays.asList(
		                Arrays.asList("currencyQuantity", "Amount")));
		feesConfig.setNestedConfig(amountsConfig);
		block.addSummaryMultiplicity(feesConfig);

                    okToChange.exec(true);
                    return;
                }

                //user is moving to another course proposal section and no changes were made to the rules so allow it to happen
                if (!((SectionView) getCurrentView()).isDirty()) {
                    okToChange.exec(true);
                    return;
                }

                //user is moving to another course proposal section and rules have been changed, user needs to either save rules or abondon changes before proceeding
                ButtonGroup<ButtonEnumerations.YesNoCancelEnum> buttonGroup = new YesNoCancelGroup();
                final ButtonMessageDialog<ButtonEnumerations.YesNoCancelEnum> dialog =
                        new ButtonMessageDialog<ButtonEnumerations.YesNoCancelEnum>("Warning", "You may have unsaved changes.  Save changes?", buttonGroup);
                buttonGroup.addCallback(new Callback<ButtonEnumerations.YesNoCancelEnum>() {

                    @Override
                    public void exec(ButtonEnumerations.YesNoCancelEnum result) {
                        switch (result) {
                            case YES:
                                dialog.hide();
                                preview.storeRules(true, new Callback<Boolean>() {

        configurer.addReadOnlyField(section, ProgramConstants.PROGRAM_CLASSIFICATION, new MessageKeyInfo(ProgramProperties.get().programInformation_classification()));
        configurer.addReadOnlyField(section, ProgramConstants.DEGREE_TYPE, new MessageKeyInfo(ProgramProperties.get().programInformation_degreeType()));
        return section;
    }

    private TableSection createProgramTitleSection() {
        TableSection section = new TableSection(SectionTitle.generateH4Title(ProgramProperties.get().programInformation_programTitle()));
        configurer.addReadOnlyField(section, ProgramConstants.LONG_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleFull()));
        configurer.addReadOnlyField(section, ProgramConstants.SHORT_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleShort()));

        configurer.addReadOnlyField(section, ProgramConstants.SHORT_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleShort()));
        return section;
    }

    private TableSection createDatesSection() {
        TableSection section = new TableSection(SectionTitle.generateH4Title(ProgramProperties.get().programInformation_dates()));
        configurer.addReadOnlyField(section, ProgramConstants.START_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_startTerm()));
        configurer.addReadOnlyField(section, ProgramConstants.END_PROGRAM_ENTRY_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_entryTerm()));
        configurer.addReadOnlyField(section, ProgramConstants.END_PROGRAM_ENROLL_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_enrollTerm()));

            currentRelations.remove(relatedCluId);
        }
        
        if(currentRelations != null && currentRelations.size() > 0){
	        for (Map.Entry<String, String> entry : currentRelations.entrySet()) {
	            // Create a new relation with the id of the relation we want to
	            // delete
	            CluCluRelationInfo relationToDelete = new CluCluRelationInfo();
	            relationToDelete.setId( entry.getValue() );
	            BaseDTOAssemblyNode<Object, CluCluRelationInfo> relationToDeleteNode = new BaseDTOAssemblyNode<Object, CluCluRelationInfo>(
	                    null);
	            relationToDeleteNode.setNodeData(relationToDelete);
	            relationToDeleteNode.setOperation(NodeOperation.DELETE);
	            results.add(relationToDeleteNode);
	        }
        }
        return results;
    }
    public List<BaseDTOAssemblyNode<?, ?>> addAllRelationNodes(String cluId, String relatedCluId, String relationType, NodeOperation operation, Map<String, String> currentRelations)throws AssemblyException{

    private boolean checkEndParenthesis(List<String> errorMessages, List<Token> tokenList, int currentIndex) {
        Token prevToken = (tokenList == null || currentIndex - 1 < 0)? null :
            tokenList.get(currentIndex - 1);
        Token nextToken = (tokenList == null || currentIndex + 1 >= tokenList.size())? null :
            tokenList.get(currentIndex + 1);
        boolean validToken = true;
        if (prevToken != null && (prevToken.type == Token.Condition || prevToken.type == Token.EndParenthesis) == false) {
            errorMessages.add("only condition and ) could sit before )");

    public CourseRequirementsManageView(CourseRequirementsViewController parentController, Enum<?> viewEnum, String name, String modelId) {
        super(viewEnum, name, modelId);
        this.parentController = parentController;
    }

    @Override
    public void beforeShow(final Callback<Boolean> onReadyCallback) {

        retrieveAndSetupReqCompTypes(); //TODO cache it for each statement type?
        if (!isInitialized) {
            setupHandlers();
            draw();
            isInitialized = true;
        }

        onReadyCallback.exec(true);
    }

    private void setupHandlers() {
        editReqCompWidget.setReqCompConfirmButtonClickCallback(actionButtonClickedReqCompCallback);
        editReqCompWidget.setNewReqCompSelectedCallbackCallback(newReqCompSelectedCallbackCallback);
        editReqCompWidget.setRetrieveCompositionTemplateCallback(retrieveCompositionTemplateCallback);
        editReqCompWidget.setRetrieveFieldsMetadataCallback(retrieveFieldsMetadataCallback);
        editReqCompWidget.setRetrieveCustomWidgetCallback(retrieveCustomWidgetCallback);

        configurer.addReadOnlyField(section, ProgramConstants.INSTITUTION + "/" + ProgramConstants.ORG_ID, new MessageKeyInfo(ProgramProperties.get().programInformation_institution()));
        return section;
    }

    public VerticalSection createActivateProgramSection(){
        VerticalSection section = new VerticalSection(SectionTitle.generateH2Title(ProgramProperties.get().programInformation_activateProgram()));
        section.setInstructions("<br>" + ProgramProperties.get().programInformation_activateInstructions() + "<br><br>");
        configurer.addField(section, ProgramConstants.PREV_END_PROGRAM_ENTRY_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_entryTerm()));
        configurer.addField(section, ProgramConstants.PREV_END_PROGRAM_ENROLL_TERM, new MessageKeyInfo(ProgramProperties.get().programInformation_enrollTerm()));
        return section;
    }    
}

    private Map<String, Object> toMap(Constraint c) {
        Map<String, Object> result = new HashMap<String, Object>();
        result.put("minOccurs", c.getMinOccurs());
        result.put("maxOccurs", c.getMaxOccurs());
        result.put("minLength", c.getMinLength());
        result.put("maxLength", c.getMaxLength());
        result.put("minValue", c.getExclusiveMin());
        result.put("maxValue", c.getInclusiveMax());
        // result.put("dataType", c.getDataType());

        return result;
    }

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    @Override
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    @Override
    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }
    
    
    public VersionInfo getVersionInfo() {
		return versionInfo;
	}

	public void setVersionInfo(VersionInfo versionInfo) {
		this.versionInfo = versionInfo;
	}

    public void setProposalReference(List<ProposalReference> proposalReference) {
        this.proposalReference = proposalReference;
    }

    public String getRationale() {
        return rationale;
    }

    public void setRationale(String rationale) {
        this.rationale = rationale;
    }

    public String getDetailDesc() {
        return detailDesc;
    }

    public void setDetailDesc(String detailDesc) {
        this.detailDesc = detailDesc;
    }

    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    public ProposalType getType() {

 }

 public String getRowSeperator ()
 {
  return rowSeperator;
 }

 public void setRowSeperator (String rowSeperator)
 {
  this.rowSeperator = rowSeperator;
 }

 public String getColSeparator ()
 {
  return colSeperator;
 }

 public void setColSeparator (String separator)
 {
  this.colSeperator = separator;
 }

 private String pad (String str, int size)
 {
  StringBuilder padStr = new StringBuilder (size);
  padStr.append (str);
  while (padStr.length () < size)
  {
   padStr.append (' ');
  }
  return padStr.toString ();
 }

 public String formatForWiki ()
 {

    SimpleDateFormat[] formats = {new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ"), new SimpleDateFormat("yyyy-MM-dd")};
    
    public Date parseDate(String input) {
        Date result = null;
        
        for (SimpleDateFormat format : formats) {
                try {
                    result = format.parse(input);
                } catch (Exception e) {
                    // just eat it
                }
                if (result != null) {
                    break;
                }
            
        }
        
        if (result == null) {
            throw new DateParseException("Invalid date value: " + input);
        }
        
        return result;
    }

    /**
     * @see org.kuali.student.common.validator.old.DateParser#toString(java.util.Date)
     */
    @Override
    public String toString(Date date) {
        String result = null;
        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-ddTHH:mm:ss,SSS");
        result = format.format(date);

        return result;        
    }
}

    @XmlElementRef(name = "XPath", namespace = "http://www.w3.org/2000/09/xmldsig#", type = JAXBElement.class)
    @XmlMixed
    @XmlAnyElement(lax = true)
    protected List<Object> content;
    @XmlAttribute(name = "Algorithm", required = true)
    @XmlSchemaType(name = "anyURI")
    protected String algorithm;

    /**
     * Gets the value of the content property.
     * 
     * <p>
     * This accessor method returns a reference to the live list,
     * not a snapshot. Therefore any modification you make to the
     * returned list will be present inside the JAXB object.
     * This is why there is not a <CODE>set</CODE> method for the content property.
     * 
     * <p>
     * For example, to add a new item, do as follows:
     * <pre>
     *    getContent().add(newItem);
     * </pre>
     * 
     * 
     * <p>
     * Objects of the following type(s) are allowed in the list
     * {@link Object }
     * {@link Element }
     * {@link String }
     * {@link JAXBElement }{@code <}{@link String }{@code >}
     * 
     * 
     */
    public List<Object> getContent() {
        if (content == null) {
            content = new ArrayList<Object>();
        }
        return this.content;
    }

    /**
     * Gets the value of the algorithm property.
     * 
     * @return
     *     possible object is
     *     {@link String }
     *     
     */
    public String getAlgorithm() {
        return algorithm;
    }

    /**
     * Sets the value of the algorithm property.
     * 
     * @param value
     *     allowed object is
     *     {@link String }
     *     
     */
    public void setAlgorithm(String value) {
        this.algorithm = value;
    }

}

    public MajorInformationEditConfiguration() {
        rootSection = new VerticalSectionView(ProgramSections.PROGRAM_DETAILS_EDIT, ProgramProperties.get().program_menu_sections_programInformation(), ProgramConstants.PROGRAM_MODEL_ID);
    }

    @Override
    protected void buildLayout() {
        HorizontalSection horizontalSection = new HorizontalSection();
        horizontalSection.addSection(createLeftSection());
        horizontalSection.addSection(createRightSection());
        rootSection.addSection(horizontalSection);
    }

    private VerticalSection createLeftSection() {
        VerticalSection section = new VerticalSection();
        section.addSection(createKeyProgramInformationSection());
        section.addSection(createProgramTitleSection());
        section.addSection(createDatesSection());

            }
        });

    }

    private void throwAfterSaveEvent() {
        eventBus.fireEvent(new AfterSaveEvent(programModel, this));
    }

    @Override
    public void onModelLoadedEvent() {
        Enum<?> changeSection = ProgramRegistry.getSection();
        if (changeSection != null) {
            showView(changeSection);
            ProgramRegistry.setSection(null);
        } else {
            String id = (String) programModel.get(ProgramConstants.ID);
            if (id == null) {
                showView(ProgramSections.PROGRAM_DETAILS_EDIT);
            } else {
                showView(ProgramSections.SUMMARY);
            }
        }
    }
}

    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a clu learning result object type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the CLU Result. The values for this field are constrained to those in the cluResultState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a CLU result. This is optional, due to the identifier being set at the time of creation. Once the result set has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
    	return "CluResultInfo[id=" + id + ", cluId=" + cluId + ", type=" + type + "]";

    public void setRepeatTime(TimeAmount repeatTime) {
        this.repeatTime = repeatTime;
    }

    public String getRepeatUnits() {
        return repeatUnits;
    }

    public void setRepeatUnits(String repeatUnits) {
        this.repeatUnits = repeatUnits;
    }

    public Integer getMinTotalUnits() {
        return minTotalUnits;
    }

    public void setMinTotalUnits(Integer minTotalUnits) {
        this.minTotalUnits = minTotalUnits;
    }

    public Integer getMaxTotalUnits() {
        return maxTotalUnits;
    }

    public void setMaxTotalUnits(Integer maxTotalUnits) {
        this.maxTotalUnits = maxTotalUnits;
    }

    public Integer getInstructorUnits() {
        return instructorUnits;
    }

    public void setInstructorUnits(Integer instructorUnits) {
        this.instructorUnits = instructorUnits;
    }

    public TimeAmount getMinTimeToComplete() {

    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a clu learning result object type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the CLU Result. The values for this field are constrained to those in the cluResultState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a CLU result. This is optional, due to the identifier being set at the time of creation. Once the result set has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
    	return "CluResultInfo[id=" + id + ", cluId=" + cluId + ", type=" + type + "]";

    @XmlElement
    private RichTextInfo descr;
    
    @XmlElement
    @XmlJavaTypeAdapter(JaxbAttributeMapListAdapter.class)
    private Map<String, String> attributes;

    @XmlElement
    private MetaInfo metaInfo;

    @XmlAttribute
    private String id;

    /**
     * A code that identifies the type of the fee. For example: Lab Fee or Tuition Fee or CMF for Course Materials Fee.
     */
    public String getFeeType() {
        return feeType;
    }

    public void setFeeType(String feeType) {
        this.feeType = feeType;
    }

    /**
     * Indicates the structure and interpretation of the fee amounts, i.e. Fixed, Variable, Multiple.
     */
    public String getRateType() {
		return rateType;
	}

	public void setRateType(String rateType) {
		this.rateType = rateType;
	}

	/**
     * The amount or amounts associated with the fee. The number fee amounts and interpretation depends on the rate type.
     */
    public List<CurrencyAmountInfo> getFeeAmounts() {
    	if(feeAmounts==null){
    		feeAmounts = new ArrayList<CurrencyAmountInfo>();

    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a clu learning result object type.
     */
    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    /**
     * The current status of the CLU Result. The values for this field are constrained to those in the cluResultState enumeration. A separate setup operation does not exist for retrieval of the meta data around this value.
     */
    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    /**
     * Unique identifier for a CLU result. This is optional, due to the identifier being set at the time of creation. Once the result set has been created, this should be seen as required.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    @Override
    public String toString() {
    	return "CluResultInfo[id=" + id + ", cluId=" + cluId + ", type=" + type + "]";

 public String getRowSeperator ()
 {
  return rowSeperator;
 }

 public void setRowSeperator (String rowSeperator)
 {
  this.rowSeperator = rowSeperator;
 }

 public String getColSeparator ()
 {
  return colSeperator;
 }

 public void setColSeparator (String separator)
 {
  this.colSeperator = separator;
 }

 private String pad (String str, int size)
 {
  StringBuilder padStr = new StringBuilder (size);
  padStr.append (str);
  while (padStr.length () < size)
  {
   padStr.append (' ');
  }
  return padStr.toString ();
 }

 public String formatForWiki ()
 {

    private void handleSelection(){
        List<String> selected  = SwitchSection.this.selectableWidget.getSelectedItems();
        for(int i = 0; i < selected.size(); i++){
            String key = selected.get(i);
            showSwappableSection(key);
        }
        
        Iterator<String> it = swapSectionMap.keySet().iterator();
        while(it.hasNext()){
            String key = it.next();
            if(!selected.contains(key)){
                removeSwappableSection(key);
            }
        }
    }
    
    private void showSwappableSection(String key){

    public StoreSpecRequirementIDsEvent(String programId, String programType, List<String> programRequirementIds) {
        this.programId = programId;
        this.programType = programType;
        this.programRequirementIds = programRequirementIds;        
    }

    @Override
    public Type<Handler> getAssociatedType() {
        return TYPE;
    }

    @Override
    protected void dispatch(Handler handler) {
        handler.onEvent(this);
    }

    public String getProgramId() {
        return programId;
    }

    public String getProgramType() {
        return programType;
    }

    public List<String> getProgramRequirementIds() {
        return programRequirementIds;
    }

    public static interface Handler extends EventHandler {
        void onEvent(StoreSpecRequirementIDsEvent event);

    }

    /**
     * Date and time that this credential value became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this credential value expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a credential type.
     */
    public String getType() {

        return new OrgorgRelationHelper(data);
    }
	
	public Data getData(){
	    return data;
	}
	
	public void setId(String id){
	    data.set(Properties.ID.getKey(), id);
	}
	
    public String getId() {
        return data.get(Properties.ID.getKey());
    }
    
    public void setOrgId(String orgId){
        data.set(Properties.ORG_ID.getKey(), orgId);
    }
    
    public String getOrgId() {
        return data.get(Properties.ORG_ID.getKey());
    }
    
    public void setRelatedOrgId(String relatedOrgId){

    }

    /**
     * Date and time that this credential value became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this credential value expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a credential type.
     */
    public String getType() {

    public void addCallback(Callback<T> callback) {
        callbacks.add(callback);
    }

    public List<Callback<T>> getCallbacks() {
        return callbacks;
    }
    
    protected void sendCallbacks(T type){
        for(Callback<T> c: getCallbacks()){
            c.exec(type);
        }
    }
    
    public void setButtonText(T key, String text){
        buttonMap.get(key).setText(text);
    }
    
    public KSButton getButton(T key){
        return buttonMap.get(key);
    }

    }

    /**
     * Date and time that this credential value became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this credential value expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a credential type.
     */
    public String getType() {

    	rpcServiceAsync.getData(courseId, new KSAsyncCallback<Data>(){

            @Override
            public void handleFailure(Throwable caught) {
                Window.alert("Error loading Course: "+caught.getMessage());
                createNewCluModel(callback, workCompleteCallback);
                KSBlockingProgressIndicator.removeTask(loadDataTask);
            }

            @Override
            public void onSuccess(Data result) {
                cluModel.setRoot(result);
                //getContainer().setTitle(getSectionTitle());
                setHeaderTitle();
                updateCourseActionItems();
                callback.onModelReady(cluModel);
                workCompleteCallback.exec(true);
                KSBlockingProgressIndicator.removeTask(loadDataTask);
            }

        });
    }
    
    @SuppressWarnings("unchecked")
    private void createNewCluModel(final ModelRequestCallback callback, final Callback<Boolean> workCompleteCallback){

    }

    private TableSection createProgramTitleSection() {
        TableSection section = new TableSection(SectionTitle.generateH4Title(ProgramProperties.get().programInformation_programTitle()));
        configurer.addReadOnlyField(section, ProgramConstants.LONG_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleFull()));
        configurer.addReadOnlyField(section, ProgramConstants.SHORT_TITLE, new MessageKeyInfo(ProgramProperties.get().programInformation_titleShort()));
        configurer.addReadOnlyField(section, ProgramConstants.TRANSCRIPT, new MessageKeyInfo(ProgramProperties.get().programInformation_titleTranscript()));

		for(LoDisplayInfo loDisplay : loInfos){

			// If this is a clu create/new lo update then all los will be created
		    if (NodeOperation.CREATE == operation
		            || (NodeOperation.UPDATE == operation &&  !currentCluLoRelations.containsKey(loDisplay.getLoInfo().getId()))) {

                // the lo does not exist, so create
                // Assemble and add the lo
		    	loDisplay.getLoInfo().setId(null);
                BaseDTOAssemblyNode<LoDisplayInfo, LoInfo> loNode = loAssembler
                        .disassemble(loDisplay, NodeOperation.CREATE);
                results.add(loNode);

                // Create the relationship and add it as well
                CluLoRelationInfo relation = new CluLoRelationInfo();
                relation.setCluId(cluId);
                relation.setLoId(loNode.getNodeData().getId());
                relation.setType(CluAssemblerConstants.CLU_LO_CLU_SPECIFIC_RELATION);

    }

    /**
     * Date and time that this LU document relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this LU document relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * The page luDocumentTypeKey Structure does not exist.
     */
    public String getId() {

	}

	/**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    
    /**
	 * Create and last update info for the structure. This is optional and treated as read only since the 
	 * data is set by the internals of the service during maintenance operations.     
	 */
    public MetaInfo getMetaInfo() {
		return metaInfo;
	}

	public void setMetaInfo(MetaInfo metaInfo) {
		this.metaInfo = metaInfo;
	}

	/**
     * Identifier for the clu fee record.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Date and time that this result component became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this result component expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {

	}

	/**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    
    /**
	 * Create and last update info for the structure. This is optional and treated as read only since the 
	 * data is set by the internals of the service during maintenance operations.     
	 */
    public MetaInfo getMetaInfo() {
		return metaInfo;
	}

	public void setMetaInfo(MetaInfo metaInfo) {
		this.metaInfo = metaInfo;
	}

	/**
     * Identifier for the clu fee record.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Date and time that this learning objective category type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this learning objective category type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a learning objective category type.
     */
    public String getId() {

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for a learning objective repository.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    public Boolean isAuthorizedAddReviewer(String docId) throws OperationFailedException{
		if (docId != null && (!"".equals(docId.trim()))) {
			AttributeSet permissionDetails = new AttributeSet();
			AttributeSet roleQuals = new AttributeSet();
			roleQuals.put(StudentIdentityConstants.DOCUMENT_NUMBER,docId);
			return Boolean.valueOf(getPermissionService().isAuthorizedByTemplateName(SecurityUtils.getCurrentUserId(), PermissionType.ADD_ADHOC_REVIEWER.getPermissionNamespace(), 
					PermissionType.ADD_ADHOC_REVIEWER.getPermissionTemplateName(), permissionDetails, roleQuals));
		}
		return Boolean.FALSE;
    }

	public Boolean isAuthorizedRemoveReviewers(String docId) throws OperationFailedException {

                    map.put("REV_" + info.getId(), info.getRevName());
                }
                orgRelTypeList = new ListItems() {

                    @Override
                    public List<String> getAttrKeys() {
                        return null; //apparently unused
                    }

                    @Override
                    public String getItemAttribute(String id, String attrkey) {
                        return null; //apparently unused
                    }

                    @Override
                    public int getItemCount() {
                        return map.size();
                    }

                    @Override
                    public List<String> getItemIds() {
                        return new ArrayList<String>(map.keySet());
                    }

                    @Override
                    public String getItemText(String id) {
                        return map.get(id);
                    }
                };

    }

    /**
     * Date that this person to person relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date that this person to person relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Identifier for a person to person relationship type.
     */
    public String getId() {

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Identifier for the clu fee record.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Date that this person to person relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date that this person to person relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Identifier for a person to person relationship type.
     */
    public String getId() {

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for the citizenship record. This is set by the service to be able to determine changes and alterations to the structure as well as provides a handle for searches. This structure is not accessible through unique operations, and it is strongly recommended that no external references to this particular identifier be maintained. Once this identifier is set by the service, it should be seen as required and readonly.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Date that this person to person relationship type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date that this person to person relationship type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Identifier for a person to person relationship type.
     */
    public String getId() {

    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {
        return metaInfo;
    }

    public void setMetaInfo(MetaInfo metaInfo) {
        this.metaInfo = metaInfo;
    }

    /**
     * Unique identifier for the organization position restriction record. This is set by the service to be able to determine changes and alterations to the structure as well as provides a handle for searches. Once set by the service, this should be seen as read-only and immutable. This structure is not retrievable by this identifier to limit the number of active organization position restriction records visible through the service. It is strongly recommended that this identifier not be referenced by outside consumers.
     */
    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }
}

    }

    /**
     * Date and time that this comment type became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this comment type expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Unique identifier for a comment type.
     */
    public String getId() {

	public ModBeanDefinitionVisitor(StringValueResolver valueResolver) {
		super(valueResolver);
		this.valueResolver=(PlaceholderResolvingStringValueResolver) valueResolver;
	}
	

	@Override
	protected Object resolveValue(Object value) {
		value = super.resolveValue(value);
		String strValue = null;
		
		if(value instanceof String){
			strValue=(String)value;
		}else if(value instanceof TypedStringValue){
			strValue=((TypedStringValue)value).getValue();
		}
		
		if(strValue!=null&&strValue.startsWith("$[") && strValue.endsWith("]")){
			value = valueResolver.resolvePropertyValue(strValue.substring(2, strValue.length()-1));

			String header = r.getName ();
			String key = r.getKey ();
			if ( ! r.isHidden ())
			{
				columnDefs.add (new SearchColumnDefinition (header, key));
			}
		}
		if (columnDefs.size () == 1)
		{
			columnDefs.get (0).setMinimumColumnWidth (370);
		}
		builder.columnDefinitions (columnDefs);
		tableModel.setColumnDefs (columnDefs);

		redraw ();
	}

	public void redraw ()
	{
		tableModel.setRows (resultRows);
		pagingScrollTable = builder.build (tableModel); 
		pagingScrollTable.setResizePolicy (ResizePolicy.FILL_WIDTH);

    }

    /**
     * Date and time that this comment became effective. This is a similar concept to the effective date on enumerated values. When an expiration date has been specified, this field must be less than or equal to the expiration date.
     */
    public Date getEffectiveDate() {
        return effectiveDate;
    }

    public void setEffectiveDate(Date effectiveDate) {
        this.effectiveDate = effectiveDate;
    }

    /**
     * Date and time that this comment expires. This is a similar concept to the expiration date on enumerated values. If specified, this should be greater than or equal to the effective date. If this field is not specified, then no expiration date has been currently defined and should automatically be considered greater than the effective date.
     */
    public Date getExpirationDate() {
        return expirationDate;
    }

    public void setExpirationDate(Date expirationDate) {
        this.expirationDate = expirationDate;
    }

    /**
     * List of key/value pairs, typically used for dynamic attributes.
     */
    public Map<String, String> getAttributes() {
        if (attributes == null) {
            attributes = new HashMap<String, String>();
        }
        return attributes;
    }

    public void setAttributes(Map<String, String> attributes) {
        this.attributes = attributes;
    }

    /**
     * Create and last update info for the structure. This is optional and treated as read only since the data is set by the internals of the service during maintenance operations.
     */
    public MetaInfo getMetaInfo() {