diff --git a/NOTICE b/NOTICE index bfaa082cfe1..bf9911626a0 100644 --- a/NOTICE +++ b/NOTICE @@ -26,11 +26,6 @@ Bitstream Vera is a trademark of Bitstream, Inc. For details, see http://dejavu-fonts.org and http://dejavu-fonts.org/wiki/License -This product includes JasperReports Library -Copyright (c) 2001-2016 TIBCO Software Inc. -JasperReports Library is distributed under the terms of -GNU Lesser General Public Licenses (LGPL) - This product includes AdminLTE template Copyright (c) 2014-2016 Abdullah Almsaeed AdminLTE is distributed under the terms of The MIT License diff --git a/config/initial-objects/000-system-configuration.xml b/config/initial-objects/000-system-configuration.xml index 3d6814bd377..dfa28d0f829 100644 --- a/config/initial-objects/000-system-configuration.xml +++ b/config/initial-objects/000-system-configuration.xml @@ -54,11 +54,6 @@ OFF org.hibernate.internal.ExceptionMapperStandardImpl - - - OFF - net.sf.jasperreports.engine.fill.JRFillDataset - diff --git a/config/initial-objects/080-report-audit.xml b/config/initial-objects/080-report-audit.xml deleted file mode 100644 index 42194b59555..00000000000 --- a/config/initial-objects/080-report-audit.xml +++ /dev/null @@ -1,21 +0,0 @@ - - - - - All audit records report - Report made from all audit records. - - - - - - - - - diff --git a/config/initial-objects/090-report-audit-jasper.xml b/config/initial-objects/090-report-audit-jasper.xml deleted file mode 100644 index 5ec1a4d1e28..00000000000 --- a/config/initial-objects/090-report-audit-jasper.xml +++ /dev/null @@ -1,25 +0,0 @@ - - - - Audit logs report (Jasper) - Report made from audit records. - - true - <?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="reportAuditLogs" pageWidth="1162" pageHeight="595" orientation="Landscape" whenNoDataType="AllSectionsNoDetail" columnWidth="1122" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20" uuid="67e465c5-46ea-40d2-bea0-469c6cf38937">
	<property name="net.sf.jasperreports.awt.ignore.missing.font" value="true"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.1" value="title"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.pdf.force.linebreak.policy" value="true"/>
	<import value="org.apache.commons.lang.StringUtils"/>
	<import value="com.evolveum.midpoint.report.impl.ReportUtils"/>
	<subDataset name="entryDeltas" uuid="64894005-d0f7-41ba-a047-1a1abea9f55f">
		<field name="executionResult" class="com.evolveum.midpoint.xml.ns._public.common.common_3.OperationResultType"/>
		<field name="objectDelta" class="com.evolveum.prism.xml.ns._public.types_3.ObjectDeltaType"/>
		<field name="objectName" class="java.lang.Object"/>
		<field name="resourceName" class="java.lang.Object"/>
	</subDataset>
	<parameter name="from" class="javax.xml.datatype.XMLGregorianCalendar">
		<property name="multivalue" value="false"/>
	</parameter>
	<parameter name="to" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<parameter name="eventType" class="java.util.List" nestedType="com.evolveum.midpoint.xml.ns._public.common.audit_3.AuditEventTypeType">
		<property name="multivalue" value="true"/>
	</parameter>
	<parameter name="eventStage" class="java.util.List" nestedType="com.evolveum.midpoint.xml.ns._public.common.audit_3.AuditEventStageType">
		<property name="multivalue" value="true"/>
	</parameter>
	<parameter name="outcome" class="java.util.List" nestedType="com.evolveum.midpoint.xml.ns._public.common.common_3.OperationResultStatusType">
		<property name="multivalue" value="true"/>
	</parameter>
	<parameter name="initiatorName" class="java.lang.String"/>
	<parameter name="targetName" class="java.util.List" nestedType="java.lang.String"/>
	<queryString language="mql">
		<![CDATA[<code>
    import java.util.GregorianCalendar;
    import javax.xml.datatype.DatatypeFactory;
    import javax.xml.datatype.XMLGregorianCalendar; 
    
    query = "select * from m_audit_event as aer where 1=1 and ";
        
    if (auditParams.get('from').getValue() != null) {
        query += "(aer.timestampValue >= :from) and ";
    } else {
        auditParams.remove('from').getValue();
    }
    if (auditParams.get('to').getValue() != null) {
        query += "(aer.timestampValue <= :to) and ";
    } else {
        auditParams.remove('to').getValue();
    }
    if (auditParams.get('eventType').getValue() != null) {
        query += "(aer.eventType in (:eventType)) and ";
    } else {
        auditParams.remove('eventType').getValue();
    }
    if (auditParams.get('eventStage').getValue() != null) {
        query += "(aer.eventStage in (:eventStage)) and ";
    } else {
        auditParams.remove('eventStage').getValue();
    }
    if (auditParams.get('outcome').getValue() != null) {
        query += "(aer.outcome in (:outcome)) and ";
    } else {
        auditParams.remove('outcome').getValue();
    }
    if (auditParams.get('initiatorName').getValue() != null) {
        query += "(aer.initiatorName = :initiatorName) and ";
    } else {
        auditParams.remove('initiatorName').getValue();
    }
    if (auditParams.get('targetName').getValue() != null) {
        query += "(aer.targetName in (:targetName)) and ";
    } else {
        auditParams.remove('targetName').getValue();
    }
    
    query = query.substring(0, query.length()-5); // remove trailing and 
    query += " order by aer.timestampValue asc";
    
    report.searchAuditRecords(query, auditParams);
</code>]]>
	</queryString>
	<field name="timestamp" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<field name="eventType" class="com.evolveum.midpoint.xml.ns._public.common.audit_3.AuditEventTypeType"/>
	<field name="eventStage" class="com.evolveum.midpoint.xml.ns._public.common.audit_3.AuditEventStageType"/>
	<field name="targetRef" class="com.evolveum.midpoint.prism.PrismReferenceValue"/>
	<field name="initiatorRef" class="com.evolveum.midpoint.prism.PrismReferenceValue"/>
	<field name="outcome" class="com.evolveum.midpoint.xml.ns._public.common.common_3.OperationResultStatusType"/>
	<field name="message" class="java.lang.String"/>
	<field name="delta" class="java.util.ArrayList"/>
	<background>
		<band splitType="Stretch"/>
	</background>
	<title>
		<band height="198" splitType="Stretch">
			<frame>
				<reportElement style="Title" mode="Opaque" x="0" y="0" width="1120" height="67" backcolor="#267994" uuid="44bedacc-fa23-4fe1-b71f-e5afa943f553"/>
				<staticText>
					<reportElement style="Title" x="10" y="13" width="266" height="38" uuid="f2d99cad-9d84-4f50-b455-453c87f62c4c"/>
					<textElement verticalAlignment="Middle"/>
					<text><![CDATA[Audit Log Report]]></text>
				</staticText>
			</frame>
			<staticText>
				<reportElement style="Page header" x="2" y="85" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Date From:]]></text>
			</staticText>
			<textField pattern="dd.MM.yyyy, HH:mm:ss">
				<reportElement style="Page header" isPrintRepeatedValues="false" x="110" y="85" width="244" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils; 
				$P{from} != null ? ReportUtils.convertDateTime($P{from}) : "Any"]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="2" y="115" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Date To:]]></text>
			</staticText>
			<textField pattern="dd.MM.yyyy, HH:mm:ss">
				<reportElement style="Page header" isPrintRepeatedValues="false" x="110" y="115" width="244" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
				$P{to} != null ? ReportUtils.convertDateTime($P{to}) : "Any"]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="2" y="145" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Event Type:]]></text>
			</staticText>
			<textField>
				<reportElement style="Page header" isPrintRepeatedValues="false" x="110" y="145" width="244" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
				ReportUtils.getPropertyString("AuditEventType.", $P{eventType}, "Any")]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="2" y="175" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Event Stage:]]></text>
			</staticText>
			<textField isBlankWhenNull="true">
				<reportElement style="Page header" isPrintRepeatedValues="false" x="110" y="175" width="244" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
				ReportUtils.getPropertyString("AuditEventStage.", $P{eventStage}, "Any")]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="400" y="85" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Outcome:]]></text>
			</staticText>
			<textField>
				<reportElement style="Page header" isPrintRepeatedValues="false" x="510" y="85" width="244" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
				ReportUtils.getPropertyString("OperationResultStatusType.", $P{outcome}, "Any")]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="400" y="115" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Initiator Name:]]></text>
			</staticText>
			<textField>
				<reportElement style="Page header" isPrintRepeatedValues="false" x="510" y="115" width="244" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$P{initiatorName} != null ? $P{initiatorName} : "Any"]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="400" y="145" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Target Name:]]></text>
			</staticText>
			<textField>
				<reportElement style="Page header" isPrintRepeatedValues="false" x="510" y="145" width="244" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[import org.apache.commons.lang.StringUtils;
				$P{targetName} != null ? StringUtils.join($P{targetName}, ", ") : "Any"]]></textFieldExpression>
			</textField>
		</band>
	</title>
	<pageHeader>
		<band splitType="Stretch"/>
	</pageHeader>
	<columnHeader>
		<band height="24" splitType="Stretch">
			<frame>
				<reportElement style="Column header" mode="Transparent" x="0" y="1" width="1120" height="19" isRemoveLineWhenBlank="true" uuid="3e8fdd6d-a6ff-4407-9a1e-5d6b4706300a"/>
				<staticText>
					<reportElement style="Column header" x="0" y="0" width="120" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Timestamp]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="120" y="0" width="80" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Initiator]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="200" y="0" width="90" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Event Type]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="290" y="0" width="90" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Event Stage]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="380" y="0" width="100" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Target]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="480" y="0" width="80" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Outcome]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="560" y="0" width="160" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Message]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="720" y="0" width="400" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Delta]]></text>
				</staticText>
			</frame>
		</band>
	</columnHeader>
	<detail>
		<band height="15" splitType="Stretch">
			<frame>
				<reportElement style="Detail" mode="Opaque" x="0" y="0" width="1120" height="14" uuid="3e8fdd6d-a6ff-4407-9a1e-5d6b4706300a"/>
				<textField isStretchWithOverflow="true" pattern="dd.MM.yyyy, HH:mm:ss">
					<reportElement style="Detail" x="0" y="0" width="120" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
					ReportUtils.convertDateTime($F{timestamp})]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Detail" x="120" y="0" width="80" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8">
						<printWhenExpression><![CDATA[import com.evolveum.midpoint.prism.PrismReferenceValue;
					$F{initiatorRef} instanceof PrismReferenceValue]]></printWhenExpression>
					</reportElement>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[$F{initiatorRef}.getTargetName()]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Detail" x="200" y="0" width="90" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
					$F{eventType} != null ? ReportUtils.getPropertyString("AuditEventType."+$F{eventType}) : null]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Detail" x="290" y="0" width="90" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
					$F{eventStage} != null ? ReportUtils.getPropertyString("AuditEventStageType."+$F{eventStage}) : null]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Detail" x="380" y="0" width="100" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8">
						<printWhenExpression><![CDATA[!$F{targetRef}.equals(null)]]></printWhenExpression>
					</reportElement>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[import com.evolveum.midpoint.prism.PrismReferenceValue;
					if(!($F{targetRef} instanceof PrismReferenceValue)){
					   return null
					}
					
					if($F{targetRef} != null){
					   $F{targetRef}.getTargetType().getLocalPart()+": "+$F{targetRef}.getTargetName()
					}]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Detail" x="480" y="0" width="80" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
					$F{outcome} != null ? ReportUtils.getPropertyString("OperationResultStatusType."+$F{outcome}) : null]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Code" x="560" y="0" width="160" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[$F{message}]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Code" x="720" y="0" width="400" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[import com.evolveum.midpoint.report.impl.ReportUtils;
					                        import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectDeltaOperationType;
					
					                        if($F{delta} == null){
					                           return null
					                        }
					                        String ret = "";
					                        for(ObjectDeltaOperationType objectDelta : $F{delta}){
					                           ret = ret + ReportUtils.printDelta(objectDelta.getObjectDelta(), (objectDelta.getObjectName()==null)?null:objectDelta.getObjectName().toString(), (objectDelta.getResourceName()==null)?null:objectDelta.getResourceName().toString()) + "\n"
					                        }
					                        if (ret != null && ret.length() > 0) {
                                          ret = ret.substring(0, ret.length() - 1);
                                       }
					                        return ret]]></textFieldExpression>
				</textField>
				<line>
					<reportElement positionType="FixRelativeToBottom" mode="Opaque" x="0" y="13" width="1120" height="1" forecolor="#333333" uuid="47f91801-cf5f-4bed-b19c-ca3931cbf98d"/>
				</line>
			</frame>
		</band>
	</detail>
	<columnFooter>
		<band height="7" splitType="Stretch">
			<line>
				<reportElement positionType="FixRelativeToBottom" x="0" y="3" width="1120" height="1" uuid="a591d4c1-1cad-4da2-9f9d-081f539e9043"/>
				<graphicElement>
					<pen lineWidth="0.5" lineColor="#999999"/>
				</graphicElement>
			</line>
		</band>
	</columnFooter>
	<pageFooter>
		<band height="32" splitType="Stretch">
			<frame>
				<reportElement style="Page footer" mode="Transparent" x="0" y="1" width="1120" height="24" forecolor="#000000" backcolor="#267994" uuid="fbe8aae4-6500-468a-b1e8-700b569139a1"/>
				<textField pattern="EEEEE dd MMMMM yyyy">
					<reportElement style="Page footer" x="2" y="1" width="197" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[new java.util.Date()]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement style="Page footer" x="1000" y="1" width="80" height="20" uuid="5c062c66-ba45-4288-9dcd-246e28c5af75"/>
					<textElement textAlignment="Right" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA["Page "+$V{PAGE_NUMBER}+" of"]]></textFieldExpression>
				</textField>
				<textField evaluationTime="Report">
					<reportElement style="Page footer" x="1080" y="1" width="40" height="20" uuid="934b16e8-c3eb-4017-866a-0b7735bf2917"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</pageFooter>
	<summary>
		<band splitType="Stretch"/>
	</summary>
</jasperReport>
 - PD94bWwgdmVyc2lvbj0iMS4wIj8+DQo8IURPQ1RZUEUgamFzcGVyVGVtcGxhdGUNCiAgUFVCTElDICItLy9KYXNwZXJSZXBvcnRzLy9EVEQgVGVtcGxhdGUvL0VOIg0KICAiaHR0cDovL2phc3BlcnJlcG9ydHMuc291cmNlZm9yZ2UubmV0L2R0ZHMvamFzcGVydGVtcGxhdGUuZHRkIj4NCjxqYXNwZXJUZW1wbGF0ZT4NCiAgICAgICAgCTxzdHlsZSBmb250TmFtZT0iRGVqYVZ1IFNhbnMiIGZvbnRTaXplPSIxMCIgaEFsaWduPSJMZWZ0IiBpc0RlZmF1bHQ9InRydWUiIGlzUGRmRW1iZWRkZWQ9InRydWUiIA0KCQkJCSAgIG5hbWU9IkJhc2UiIHBkZkVuY29kaW5nPSJJZGVudGl0eS1IIiBwZGZGb250TmFtZT0iRGVqYVZ1U2Fucy50dGYiIHZBbGlnbj0iTWlkZGxlIj4NCgkJCTwvc3R5bGU+DQoJCQk8c3R5bGUgYmFja2NvbG9yPSIjMjY3OTk0IiBmb250U2l6ZT0iMjYiIGZvcmVjb2xvcj0iI0ZGRkZGRiIgaXNEZWZhdWx0PSJmYWxzZSINCiAgICAgICAgICAgICAgICAgICBtb2RlPSJPcGFxdWUiIG5hbWU9IlRpdGxlIiBzdHlsZT0iQmFzZSIvPiANCgkJCTxzdHlsZSBmb250U2l6ZT0iMTIiIGZvcmVjb2xvcj0iIzAwMDAwMCIgaXNEZWZhdWx0PSJmYWxzZSIgbmFtZT0iUGFnZSBoZWFkZXIiDQogICAgICAgICAgICAgICAgICAgc3R5bGU9IkJhc2UiLz4NCgkJCTxzdHlsZSBiYWNrY29sb3I9IiMzMzMzMzMiIGZvbnRTaXplPSIxMiIgZm9yZWNvbG9yPSIjRkZGRkZGIiBoQWxpZ249IkNlbnRlciINCiAgICAgICAgICAgICAgICAgICBpc0RlZmF1bHQ9ImZhbHNlIiBtb2RlPSJPcGFxdWUiIG5hbWU9IkNvbHVtbiBoZWFkZXIiIHN0eWxlPSJCYXNlIi8+DQoJCQk8c3R5bGUgaXNCb2xkPSJmYWxzZSIgaXNEZWZhdWx0PSJmYWxzZSIgbmFtZT0iRGV0YWlsIiBzdHlsZT0iQmFzZSIvPg0KICAgICAgICAgICAgPHN0eWxlIGlzQm9sZD0iZmFsc2UiIGlzRGVmYXVsdD0iZmFsc2UiIG5hbWU9IkNvZGUiIHN0eWxlPSJCYXNlIiBmb250U2l6ZT0iOSIvPg0KCQkJPHN0eWxlIGZvbnRTaXplPSI5IiBmb3JlY29sb3I9IiMwMDAwMDAiIGlzRGVmYXVsdD0iZmFsc2UiIG5hbWU9IlBhZ2UgZm9vdGVyIg0KICAgICAgICAgICAgICAgICAgIHN0eWxlPSJCYXNlIi8+DQoJCTwvamFzcGVyVGVtcGxhdGU+ - html - JRSwapFileVirtualizer - 300 - 10000 - 300000 - - - prismReference - - diff --git a/config/initial-objects/090-report-audit.xml b/config/initial-objects/090-report-audit.xml new file mode 100644 index 00000000000..1704e9025ea --- /dev/null +++ b/config/initial-objects/090-report-audit.xml @@ -0,0 +1,227 @@ + + + + + All audit records report + Report made from all audit records. + + + + + + + + + + + + targetRef + + filterAll + + + + + initiatorRef + + filterAll + + + + + outcome + + filterAll + + + + + eventType + + filterAll + + + + + eventStage + + filterAll + + + + + timestamp + + filterAll + + + + + timestamp + + filterAll + + + + + + + + outcome + OperationResultStatusType + + + outcome + + AuditEventRecordType.outcome + + + + + + eventType + AuditEventTypeType + + + eventType + + AuditEventRecordType.eventType + + + + + + eventStage + AuditEventStageType + + + eventStage + + AuditEventRecordType.eventStage + + + + + + from + dateTime + + + from + + AuditPopupPanel.dateFrom + + + + + + to + dateTime + + + to + + AuditPopupPanel.dateTo + + + + + + target + c:ObjectReferenceType + + + targetRef + + AuditEventRecordType.targetRef + + + + + + initiator + c:ObjectReferenceType + + + initiatorRef + + AuditEventRecordType.initiatorRef + + + + + + diff --git a/config/initial-objects/100-report-reconciliation.xml b/config/initial-objects/100-report-reconciliation.xml index 32f521d5f4d..147ab42051e 100644 --- a/config/initial-objects/100-report-reconciliation.xml +++ b/config/initial-objects/100-report-reconciliation.xml @@ -1,22 +1,215 @@ - - Reconciliation report (Jasper) - Reconciliation report for selected resource. - - true - <?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="reportReconciliation" pageWidth="1042" pageHeight="595" orientation="Landscape" whenNoDataType="AllSectionsNoDetail" columnWidth="1002" leftMargin="20" rightMargin="20" topMargin="20" bottomMargin="20" uuid="67e465c5-46ea-40d2-bea0-469c6cf38937">
	<property name="net.sf.jasperreports.awt.ignore.missing.font" value="true"/>
	<property name="net.sf.jasperreports.export.pdf.force.linebreak.policy" value="true"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.1" value="title"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.2" value="pageFooter"/>
	<subDataset name="ownerDataset" uuid="b81b8dff-587b-43e6-acdc-0b9748f47610">
		<parameter name="shadowOid" class="java.lang.String"/>
		<queryString language="mql">
			<![CDATA[<code>
                import com.evolveum.midpoint.schema.GetOperationOptions;
                import com.evolveum.midpoint.schema.SelectorOptions;
                import com.evolveum.midpoint.xml.ns._public.common.common_3.*;
                import com.evolveum.midpoint.prism.query.*
                
                query = midpoint.getPrismContext().queryFor(FocusType.class)
				.item(FocusType.F_LINK_REF).ref(shadowOid)
				.build();
                
                options = SelectorOptions.createCollection(GetOperationOptions.createRaw())
                midpoint.searchObjects(FocusType.class, query, options);
            </code>]]>
		</queryString>
		<field name="name" class="com.evolveum.midpoint.prism.polystring.PolyString"/>
	</subDataset>
	<parameter name="resource" class="java.lang.String">
		<property name="targetType" value="com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceType"/>
		<property name="key" value="name"/>
		<property name="label" value="name"/>
		<property name="mandatory" value="true"/>
	</parameter>
	<parameter name="intent" class="java.lang.String"/>
	<parameter name="objectClass" class="java.lang.String"/>
	<parameter name="kind" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowKindType"/>
	<parameter name="situation" class="com.evolveum.midpoint.xml.ns._public.common.common_3.SynchronizationSituationType"/>
	<queryString language="mql">
		<![CDATA[<filter>
    <type>
        <type>ShadowType</type>
        <filter>
            <and>
                <ref>
                    <path>resourceRef</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <script>
                            <code>
                                import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceType;
                                import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType;
                            
                                ObjectReferenceType ort = new ObjectReferenceType();                                            
                                ResourceType resObj;
                                
                                if (resource != null) {
                                    resObj = midpoint.searchObjectByName(ResourceType.class, resource);
                                    if (resObj != null) {
                                        ort.setOid(resObj.getOid());
                                    }
                                }                                

                                ort.setType(ResourceType.COMPLEX_TYPE);
                                return ort;
                            </code>
                        </script>
                    </expression>                               
                </ref>                             
                <equal>
                    <path>synchronizationSituation</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <path>$situation</path>
                    </expression>
                </equal>              
                <equal>
                    <path>objectClass</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <script>
                            <code>
                                import javax.xml.namespace.QName;
                                if (objectClass != null)
                                    return new QName("http://midpoint.evolveum.com/xml/ns/public/resource/instance-3", objectClass)
                            </code>
                        </script>
                    </expression>                               
                </equal>                
                <equal>
                    <path>kind</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <path>$kind</path>
                    </expression>
                </equal>
                <equal>
                    <path>intent</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <path>$intent</path>
                    </expression>
                </equal>                              
            </and>                                
        </filter>
    </type>
</filter>]]>
	</queryString>
	<field name="oid" class="java.lang.String"/>
	<field name="name" class="com.evolveum.midpoint.prism.polystring.PolyString"/>
	<field name="synchronizationSituation" class="com.evolveum.midpoint.xml.ns._public.common.common_3.SynchronizationSituationType"/>
	<field name="synchronizationTimestamp" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<field name="resourceRef" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType"/>
	<background>
		<band splitType="Stretch"/>
	</background>
	<title>
		<band height="138" splitType="Stretch">
			<frame>
				<reportElement style="Title" mode="Opaque" x="0" y="0" width="1000" height="67" backcolor="#267994" uuid="44bedacc-fa23-4fe1-b71f-e5afa943f553"/>
				<staticText>
					<reportElement style="Title" x="10" y="13" width="266" height="38" uuid="f2d99cad-9d84-4f50-b455-453c87f62c4c"/>
					<textElement verticalAlignment="Middle"/>
					<text><![CDATA[Reconciliation Report]]></text>
				</staticText>
			</frame>
			<staticText>
				<reportElement style="Page header" x="2" y="70" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Resource:]]></text>
			</staticText>
			<textField isBlankWhenNull="true">
				<reportElement style="Page header" x="102" y="70" width="280" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$P{resource}]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="2" y="90" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Intent:]]></text>
			</staticText>
			<textField isBlankWhenNull="true">
				<reportElement style="Page header" x="102" y="90" width="150" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$P{intent}]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="2" y="110" width="100" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Object Class:]]></text>
			</staticText>
			<textField isBlankWhenNull="true">
				<reportElement style="Page header" x="102" y="110" width="150" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$P{objectClass}]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="400" y="70" width="150" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Report generated on:]]></text>
			</staticText>
			<textField pattern="EEEEE dd MMMMM yyyy, HH:mm:ss">
				<reportElement style="Page header" x="550" y="70" width="250" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement textAlignment="Right" verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[new java.util.Date()]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="400" y="90" width="150" height="20" uuid="8599b2c5-3a24-4594-98b9-5b3f38f39e24"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Number of records:]]></text>
			</staticText>
			<textField evaluationTime="Report" isBlankWhenNull="true">
				<reportElement style="Page header" x="550" y="90" width="250" height="20" uuid="f6b01016-2406-4195-8b3b-35dca232ce68"/>
				<textElement textAlignment="Right" verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$V{REPORT_COUNT}]]></textFieldExpression>
			</textField>
		</band>
	</title>
	<pageHeader>
		<band splitType="Stretch"/>
	</pageHeader>
	<columnHeader>
		<band height="24" splitType="Stretch">
			<frame>
				<reportElement style="Column header" mode="Transparent" x="0" y="1" width="1000" height="19" isRemoveLineWhenBlank="true" uuid="3e8fdd6d-a6ff-4407-9a1e-5d6b4706300a"/>
				<staticText>
					<reportElement style="Column header" x="0" y="0" width="300" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Name]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="300" y="0" width="200" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Resource]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="500" y="0" width="150" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Situation]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="650" y="0" width="200" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Owner]]></text>
				</staticText>
				<staticText>
					<reportElement style="Column header" x="850" y="0" width="150" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<text><![CDATA[Timestamp]]></text>
				</staticText>
			</frame>
		</band>
	</columnHeader>
	<detail>
		<band height="17" splitType="Stretch">
			<frame>
				<reportElement style="Detail" stretchType="RelativeToTallestObject" mode="Opaque" x="0" y="0" width="1000" height="14" uuid="3e8fdd6d-a6ff-4407-9a1e-5d6b4706300a"/>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Detail" stretchType="RelativeToTallestObject" x="0" y="0" width="300" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[$F{name}.getOrig()]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Detail" stretchType="RelativeToTallestObject" x="300" y="0" width="200" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[$F{resourceRef}.getName().getOrig()]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement style="Detail" stretchType="RelativeToTallestObject" x="500" y="0" width="150" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[$F{synchronizationSituation}]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" pattern="dd.MM.yy, HH:mm:ss" isBlankWhenNull="true">
					<reportElement style="Detail" stretchType="RelativeToTallestObject" x="850" y="0" width="150" height="13" isPrintWhenDetailOverflows="true" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement textAlignment="Center" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[$F{synchronizationTimestamp}.toGregorianCalendar().getTime()]]></textFieldExpression>
				</textField>
				<componentElement>
					<reportElement x="650" y="1" width="200" height="13" uuid="fc60dc05-a06d-41ac-8238-e527e5a705dc"/>
					<jr:list xmlns:jr="http://jasperreports.sourceforge.net/jasperreports/components" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports/components http://jasperreports.sourceforge.net/xsd/components.xsd" printOrder="Vertical">
						<datasetRun subDataset="ownerDataset" uuid="70b20e30-ab60-4126-8c28-1820f0ea99d3">
							<parametersMapExpression><![CDATA[new HashMap($P{REPORT_PARAMETERS_MAP})]]></parametersMapExpression>
							<datasetParameter name="shadowOid">
								<datasetParameterExpression><![CDATA[$F{oid}]]></datasetParameterExpression>
							</datasetParameter>
							<connectionExpression><![CDATA[$P{REPORT_CONNECTION}]]></connectionExpression>
						</datasetRun>
						<jr:listContents height="12" width="200">
							<textField isStretchWithOverflow="true" isBlankWhenNull="true">
								<reportElement x="0" y="0" width="200" height="12" uuid="51ac34cd-1ecf-49ab-bb9f-cedfc5f1c56e"/>
								<textElement textAlignment="Center" verticalAlignment="Middle"/>
								<textFieldExpression><![CDATA[$F{name}.getOrig()]]></textFieldExpression>
							</textField>
						</jr:listContents>
					</jr:list>
				</componentElement>
				<line>
					<reportElement positionType="FixRelativeToBottom" mode="Opaque" x="0" y="13" width="1000" height="1" forecolor="#333333" uuid="47f91801-cf5f-4bed-b19c-ca3931cbf98d"/>
				</line>
			</frame>
		</band>
	</detail>
	<columnFooter>
		<band height="7" splitType="Stretch">
			<line>
				<reportElement positionType="FixRelativeToBottom" x="0" y="3" width="1000" height="1" uuid="a591d4c1-1cad-4da2-9f9d-081f539e9043"/>
				<graphicElement>
					<pen lineWidth="0.5" lineColor="#999999"/>
				</graphicElement>
			</line>
		</band>
	</columnFooter>
	<pageFooter>
		<band height="32" splitType="Stretch">
			<frame>
				<reportElement style="Page footer" mode="Transparent" x="0" y="1" width="1000" height="24" forecolor="#000000" backcolor="#267994" uuid="fbe8aae4-6500-468a-b1e8-700b569139a1"/>
				<textField>
					<reportElement style="Page footer" x="880" y="1" width="80" height="20" uuid="5c062c66-ba45-4288-9dcd-246e28c5af75"/>
					<textElement textAlignment="Right" verticalAlignment="Middle">
						<font size="9" isBold="true"/>
					</textElement>
					<textFieldExpression><![CDATA["Page "+$V{PAGE_NUMBER}+" of"]]></textFieldExpression>
				</textField>
				<textField pattern="EEEEE dd MMMMM yyyy">
					<reportElement style="Page footer" x="2" y="1" width="197" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle">
						<font size="9" isBold="true"/>
					</textElement>
					<textFieldExpression><![CDATA[new java.util.Date()]]></textFieldExpression>
				</textField>
				<textField evaluationTime="Report">
					<reportElement style="Page footer" x="960" y="1" width="40" height="20" uuid="934b16e8-c3eb-4017-866a-0b7735bf2917"/>
					<textElement verticalAlignment="Middle">
						<font size="9" isBold="true"/>
					</textElement>
					<textFieldExpression><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</pageFooter>
	<summary>
		<band splitType="Stretch"/>
	</summary>
</jasperReport>
 - PD94bWwgdmVyc2lvbj0iMS4wIj8+DQo8IURPQ1RZUEUgamFzcGVyVGVtcGxhdGUNCiAgUFVCTElDICItLy9KYXNwZXJSZXBvcnRzLy9EVEQgVGVtcGxhdGUvL0VOIg0KICAiaHR0cDovL2phc3BlcnJlcG9ydHMuc291cmNlZm9yZ2UubmV0L2R0ZHMvamFzcGVydGVtcGxhdGUuZHRkIj4NCjxqYXNwZXJUZW1wbGF0ZT4NCiAgICAgICAgCTxzdHlsZSBmb250TmFtZT0iRGVqYVZ1IFNhbnMiIGZvbnRTaXplPSIxMCIgaEFsaWduPSJMZWZ0IiBpc0RlZmF1bHQ9InRydWUiIGlzUGRmRW1iZWRkZWQ9InRydWUiIA0KCQkJCSAgIG5hbWU9IkJhc2UiIHBkZkVuY29kaW5nPSJJZGVudGl0eS1IIiBwZGZGb250TmFtZT0iRGVqYVZ1U2Fucy50dGYiIHZBbGlnbj0iTWlkZGxlIj4NCgkJCTwvc3R5bGU+DQoJCQk8c3R5bGUgYmFja2NvbG9yPSIjMjY3OTk0IiBmb250U2l6ZT0iMjYiIGZvcmVjb2xvcj0iI0ZGRkZGRiIgaXNEZWZhdWx0PSJmYWxzZSINCiAgICAgICAgICAgICAgICAgICBtb2RlPSJPcGFxdWUiIG5hbWU9IlRpdGxlIiBzdHlsZT0iQmFzZSIvPiANCgkJCTxzdHlsZSBmb250U2l6ZT0iMTIiIGZvcmVjb2xvcj0iIzAwMDAwMCIgaXNEZWZhdWx0PSJmYWxzZSIgbmFtZT0iUGFnZSBoZWFkZXIiDQogICAgICAgICAgICAgICAgICAgc3R5bGU9IkJhc2UiLz4NCgkJCTxzdHlsZSBiYWNrY29sb3I9IiMzMzMzMzMiIGZvbnRTaXplPSIxMiIgZm9yZWNvbG9yPSIjRkZGRkZGIiBoQWxpZ249IkNlbnRlciINCiAgICAgICAgICAgICAgICAgICBpc0RlZmF1bHQ9ImZhbHNlIiBtb2RlPSJPcGFxdWUiIG5hbWU9IkNvbHVtbiBoZWFkZXIiIHN0eWxlPSJCYXNlIi8+DQoJCQk8c3R5bGUgaXNCb2xkPSJmYWxzZSIgaXNEZWZhdWx0PSJmYWxzZSIgbmFtZT0iRGV0YWlsIiBzdHlsZT0iQmFzZSIvPg0KICAgICAgICAgICAgPHN0eWxlIGlzQm9sZD0iZmFsc2UiIGlzRGVmYXVsdD0iZmFsc2UiIG5hbWU9IkNvZGUiIHN0eWxlPSJCYXNlIiBmb250U2l6ZT0iOSIvPg0KCQkJPHN0eWxlIGZvbnRTaXplPSI5IiBmb3JlY29sb3I9IiMwMDAwMDAiIGlzRGVmYXVsdD0iZmFsc2UiIG5hbWU9IlBhZ2UgZm9vdGVyIg0KICAgICAgICAgICAgICAgICAgIHN0eWxlPSJCYXNlIi8+DQoJCTwvamFzcGVyVGVtcGxhdGU+ - pdf - JRSwapFileVirtualizer - 300 - 10000 - 300000 - + + + Reconciliation report + Reconciliation report for selected resource. + + + + + + + + + + + + resourceRef + + filterAll + + + + + synchronizationSituation + + filterAll + + + + + objectClass + + filterAll + + + + + kind + + filterAll + + + + + intent + + filterAll + + + + + + + + intent + string + + + intent + + ShadowType.intent + + + + + + objectClass + string + + + objectClass + + ShadowType.objectClass + + + + + + kind + ShadowKindType + + + kind + + ShadowType.kind + + + + + + situation + SynchronizationSituationType + + + situation + + ShadowType.synchronizationSituation + + + + + + resource + c:ObjectReferenceType + c:ResourceType + + + resource + + ObjectTypeGuiDescriptor.resource + + + + + + ShadowType + + nameColumn + name + + + resourceColumn + resourceRef + nameColumn + + + situationColumn + synchronizationSituation + resourceColumn + + + ownerColumn + + Owner + + + + + + + situationColumn + + + synchTimestampColumn + synchronizationTimestamp + ownerColumn + + + diff --git a/config/initial-objects/110-report-user-list.xml b/config/initial-objects/110-report-user-list.xml index e1e6395cf7a..1d4c9ca25fb 100644 --- a/config/initial-objects/110-report-user-list.xml +++ b/config/initial-objects/110-report-user-list.xml @@ -1,21 +1,257 @@ - - Users in MidPoint (Jasper) + + + Users in MidPoint Users listed in MidPoint. - - <?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="reportUserList" pageWidth="1120" pageHeight="595" orientation="Landscape" whenNoDataType="AllSectionsNoDetail" columnWidth="1080" leftMargin="20" rightMargin="20" topMargin="30" bottomMargin="30" uuid="67e465c5-46ea-40d2-bea0-469c6cf38937">
	<property name="net.sf.jasperreports.print.keep.full.text" value="true"/>
	<property name="net.sf.jasperreports.export.xls.remove.empty.space.between.columns" value="true"/>
	<property name="net.sf.jasperreports.export.xls.remove.empty.space.between.rows" value="true"/>
	<property name="net.sf.jasperreports.export.pdf.force.linebreak.policy" value="true"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.1" value="title"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.band.1" value="pageHeader"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.keep.first.band.2" value="columnHeader"/>
	<property name="net.sf.jasperreports.export.xls.detect.cell.type" value="true"/>
	<property name="net.sf.jasperreports.export.xls.wrap.text" value="true"/>
	<property name="net.sf.jasperreports.export.xls.auto.fit.row" value="true"/>
	<property name="net.sf.jasperreports.export.xls.auto.fit.column" value="true"/>
	<property name="net.sf.jasperreports.awt.ignore.missing.font" value="true"/>
	<property name="ireport.zoom" value="1.0"/>
	<property name="ireport.x" value="16"/>
	<property name="ireport.y" value="14"/>
	<property name="com.jaspersoft.studio.data.defaultdataadapter" value="mql"/>
	<import value="com.evolveum.midpoint.report.impl.ReportUtils"/>
	<subDataset name="rolesDataset" uuid="659d3fba-d03d-43bc-8dcd-502d03443ebe">
		<parameter name="assignment" class="java.util.List"/>
		<queryString language="mql">
			<![CDATA[<code>if (assignment != null){report.resolveRoles(assignment)}</code>]]>
		</queryString>
		<field name="name" class="java.lang.String"/>
	</subDataset>
	<subDataset name="orgsDataset" uuid="64a5c94a-cbc6-4268-bcb3-0cef33aa5e02">
		<parameter name="assignment" class="java.util.List"/>
		<queryString language="mql">
			<![CDATA[<code>
					if (assignment != null){
					report.resolveOrgs(assignment)
					}
				</code>]]>
		</queryString>
		<field name="name" class="java.lang.String"/>
	</subDataset>
	<subDataset name="accountsDataset" uuid="c4d844e7-14c4-49b8-bf11-c921d58a1d40">
		<parameter name="objectRef" class="java.util.ArrayList"/>
		<queryString language="mql">
			<![CDATA[<code>
			import com.evolveum.midpoint.xml.ns._public.common.common_3.ShadowType;
			
			if (objectRef != null){
					report.resolveLinkRefs(objectRef, ShadowType.class)
					}
			</code>]]>
		</queryString>
		<field name="name" class="java.lang.String"/>
		<field name="resourceRef" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType"/>
	</subDataset>
	<parameter name="activation" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ActivationStatusType"/>
	<parameter name="organization" class="java.lang.String"/>
	<parameter name="role" class="java.lang.String"/>
	<parameter name="resource" class="java.lang.String">
		<property name="key" value="oid"/>
		<property name="label" value="name"/>
		<property name="targetType" value="com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceType"/>
	</parameter>
	<queryString language="mql">
		<![CDATA[<filter>
    <type>
        <type>UserType</type>
        <filter>
            <and>
                <equal>
                    <path>activation/administrativeStatus</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <path>$activation</path>
                    </expression>
                </equal>
                <ref>
                    <path>assignment/targetRef</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <script>
                            <code>
                                import com.evolveum.midpoint.xml.ns._public.common.common_3.OrgType;
                                import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType;
                                
                                if (!organization) {
                                    return null;
                                }
                                
                                ObjectReferenceType ort = new ObjectReferenceType();                                            
                                ort.setOid(organization);
                                ort.setType(OrgType.COMPLEX_TYPE);
                                return ort;
                            </code>      
                        </script>
                    </expression>
                </ref>
                <ref>
                    <path>assignment/targetRef</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <script>
                            <code>
                                import com.evolveum.midpoint.xml.ns._public.common.common_3.RoleType;
                                import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType;
                                
                                if (!role) {
                                    return null;
                                }
                                
                                ObjectReferenceType ort = new ObjectReferenceType();                                            
                                ort.setOid(role);
                                ort.setType(RoleType.COMPLEX_TYPE);
                                return ort;
                            </code>      
                        </script>
                    </expression>
                </ref>  
                <ref>
                    <path>assignment/construction/resourceRef</path>
                    <expression>
                        <queryInterpretationOfNoValue>filterAll</queryInterpretationOfNoValue>
                        <script>
                            <code>
                                import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceType;
                                import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType;
                                
                                if (!resource) {
                                    return null;
                                }
                                
                                ObjectReferenceType ort = new ObjectReferenceType();                                            
                                ort.setOid(resource);
                                ort.setType(ResourceType.COMPLEX_TYPE);
                                return ort;
                            </code>      
                        </script>
                    </expression>
                </ref>  
            </and>                                
        </filter>
    </type>
</filter>]]>
	</queryString>
	<field name="oid" class="java.lang.String"/>
	<field name="name" class="java.lang.String"/>
	<field name="linkRef" class="java.util.ArrayList"/>
	<field name="assignment" class="java.util.List"/>
	<field name="activation" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ActivationType"/>
	<field name="fullName" class="java.lang.String"/>
	<background>
		<band height="30" splitType="Stretch"/>
	</background>
	<title>
		<band height="145" splitType="Stretch">
			<frame>
				<reportElement style="Title" mode="Opaque" x="0" y="0" width="1080" height="67" backcolor="#267994" uuid="44bedacc-fa23-4fe1-b71f-e5afa943f553"/>
				<staticText>
					<reportElement style="Title" x="10" y="13" width="266" height="38" uuid="f2d99cad-9d84-4f50-b455-453c87f62c4c"/>
					<textElement verticalAlignment="Middle"/>
					<text><![CDATA[User Report]]></text>
				</staticText>
			</frame>
			<staticText>
				<reportElement style="Page header" x="2" y="85" width="150" height="20" uuid="b0b9714f-96f5-4f58-824b-c81fd4d321f7"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Report generated on:]]></text>
			</staticText>
			<textField pattern="dd.MMMM.yyyy, HH:mm:ss">
				<reportElement style="Page header" x="160" y="85" width="250" height="20" uuid="09a7e272-204e-4078-8a5e-e472757424c1"/>
				<textElement textAlignment="Right" verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[new java.util.Date()]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="2" y="115" width="150" height="20" uuid="3ff78fbf-8fce-4072-b691-7af047ea92a7"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Number of records:]]></text>
			</staticText>
			<textField evaluationTime="Report" isBlankWhenNull="true">
				<reportElement style="Page header" x="160" y="115" width="250" height="20" uuid="89251211-3f49-471d-b88d-5564c1bd04d1"/>
				<textElement textAlignment="Right" verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$V{REPORT_COUNT}]]></textFieldExpression>
			</textField>
		</band>
	</title>
	<pageHeader>
		<band splitType="Stretch"/>
	</pageHeader>
	<columnHeader>
		<band height="19" splitType="Stretch">
			<staticText>
				<reportElement style="Column header" x="0" y="0" width="240" height="18" uuid="0498909b-d3c5-4ee3-b8c9-f00a808efa7a"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Name]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="240" y="0" width="220" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Full name]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="460" y="0" width="100" height="18" uuid="86c74beb-bddd-48cc-945a-167b261b1e0b"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Activation]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="560" y="0" width="140" height="18" uuid="2ffd228b-8b87-4bc6-a9d2-31e8a2d5dbb7"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Role]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="700" y="0" width="140" height="18" uuid="2c4faeb3-d19c-4c1e-bfbf-1b10cece8ae8"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Organization]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="840" y="0" width="240" height="18" uuid="3e4e2319-2502-4a53-a6b4-c7968521f6b8"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Account]]></text>
			</staticText>
		</band>
	</columnHeader>
	<detail>
		<band height="25" splitType="Stretch">
			<frame>
				<reportElement style="Detail" stretchType="RelativeToTallestObject" mode="Opaque" x="0" y="0" width="1080" height="24" uuid="86db6537-81f0-42b1-b74a-d2be709271cd"/>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement x="0" y="0" width="280" height="20" uuid="3c668eee-cd3e-4697-afe3-edb7894525cc"/>
					<textFieldExpression><![CDATA[$F{name}]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement x="280" y="0" width="180" height="20" uuid="c8948c85-ec31-4b39-889a-43cbce70f7f8"/>
					<textFieldExpression><![CDATA[$F{fullName}]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true" isBlankWhenNull="true">
					<reportElement x="460" y="0" width="100" height="20" uuid="899b066d-d8cf-4594-83b4-1a35a9541648"/>
					<textFieldExpression><![CDATA[$F{activation}.getAdministrativeStatus()]]></textFieldExpression>
				</textField>
				<componentElement>
					<reportElement x="560" y="0" width="140" height="19" uuid="42a7f01f-358a-4a0d-a6aa-4c9c093be3c6"/>
					<jr:list xmlns:jr="http://jasperreports.sourceforge.net/jasperreports/components" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports/components http://jasperreports.sourceforge.net/xsd/components.xsd" printOrder="Horizontal">
						<datasetRun subDataset="rolesDataset" uuid="300586d6-0f32-4af9-b27f-ab99167501d5">
							<parametersMapExpression><![CDATA[new HashMap($P{REPORT_PARAMETERS_MAP})]]></parametersMapExpression>
							<datasetParameter name="assignment">
								<datasetParameterExpression><![CDATA[$F{assignment}]]></datasetParameterExpression>
							</datasetParameter>
							<connectionExpression><![CDATA[$P{REPORT_CONNECTION}]]></connectionExpression>
						</datasetRun>
						<jr:listContents height="18" width="140">
							<textField isStretchWithOverflow="true" isBlankWhenNull="true">
								<reportElement x="0" y="0" width="140" height="18" uuid="61dc940e-1df4-473d-a1f5-c21df666e8a1"/>
								<textFieldExpression><![CDATA[$F{name}]]></textFieldExpression>
							</textField>
						</jr:listContents>
					</jr:list>
				</componentElement>
				<componentElement>
					<reportElement x="700" y="0" width="140" height="19" uuid="e7f668f3-9664-4660-8b16-0d25df7d3e2d"/>
					<jr:list xmlns:jr="http://jasperreports.sourceforge.net/jasperreports/components" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports/components http://jasperreports.sourceforge.net/xsd/components.xsd" printOrder="Horizontal">
						<datasetRun subDataset="orgsDataset" uuid="af64c17c-02ee-4044-a9ce-91a90a7a4e08">
							<parametersMapExpression><![CDATA[new HashMap($P{REPORT_PARAMETERS_MAP})]]></parametersMapExpression>
							<datasetParameter name="assignment">
								<datasetParameterExpression><![CDATA[$F{assignment}]]></datasetParameterExpression>
							</datasetParameter>
							<connectionExpression><![CDATA[$P{REPORT_CONNECTION}]]></connectionExpression>
						</datasetRun>
						<jr:listContents height="19" width="140">
							<textField isStretchWithOverflow="true" isBlankWhenNull="true">
								<reportElement x="0" y="0" width="140" height="19" uuid="9f4894f3-4dac-4813-80cf-ad970836c0ea"/>
								<textFieldExpression><![CDATA[$F{name}]]></textFieldExpression>
							</textField>
						</jr:listContents>
					</jr:list>
				</componentElement>
				<componentElement>
					<reportElement x="840" y="0" width="240" height="19" uuid="a8ce2500-d799-48cc-a331-4c13a2af6744"/>
					<jr:list xmlns:jr="http://jasperreports.sourceforge.net/jasperreports/components" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports/components http://jasperreports.sourceforge.net/xsd/components.xsd" printOrder="Horizontal">
						<datasetRun subDataset="accountsDataset" uuid="6f185f48-dbc0-4703-8cf2-5f9c2c740d97">
							<parametersMapExpression><![CDATA[new HashMap($P{REPORT_PARAMETERS_MAP})]]></parametersMapExpression>
							<datasetParameter name="objectRef">
								<datasetParameterExpression><![CDATA[$F{linkRef}]]></datasetParameterExpression>
							</datasetParameter>
							<connectionExpression><![CDATA[$P{REPORT_CONNECTION}]]></connectionExpression>
						</datasetRun>
						<jr:listContents height="19" width="240">
							<textField isStretchWithOverflow="true" isBlankWhenNull="true">
								<reportElement x="0" y="0" width="240" height="19" uuid="4e5989df-734c-41ad-8472-b6a6f8939b28"/>
								<textFieldExpression><![CDATA[$F{name}+" (Resource: "+$F{resourceRef}.getName().getOrig()+")"]]></textFieldExpression>
							</textField>
						</jr:listContents>
					</jr:list>
				</componentElement>
				<line>
					<reportElement positionType="FixRelativeToBottom" mode="Opaque" x="0" y="19" width="1080" height="1" forecolor="#333333" uuid="47f91801-cf5f-4bed-b19c-ca3931cbf98d"/>
				</line>
			</frame>
		</band>
	</detail>
	<columnFooter>
		<band height="7" splitType="Stretch">
			<line>
				<reportElement positionType="FixRelativeToBottom" x="0" y="3" width="1080" height="1" uuid="a591d4c1-1cad-4da2-9f9d-081f539e9043"/>
				<graphicElement>
					<pen lineWidth="0.5" lineColor="#999999"/>
				</graphicElement>
			</line>
		</band>
	</columnFooter>
	<pageFooter>
		<band height="32" splitType="Stretch">
			<frame>
				<reportElement style="Page footer" mode="Transparent" x="0" y="1" width="1080" height="24" uuid="fbe8aae4-6500-468a-b1e8-700b569139a1"/>
				<textField pattern="dd.MMMMM.yyyy">
					<reportElement style="Page footer" x="2" y="1" width="197" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[new java.util.Date()]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement style="Page footer" x="960" y="1" width="80" height="20" uuid="5c062c66-ba45-4288-9dcd-246e28c5af75"/>
					<textElement textAlignment="Right" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA["Page "+$V{PAGE_NUMBER}+" of"]]></textFieldExpression>
				</textField>
				<textField evaluationTime="Report">
					<reportElement style="Page footer" x="1040" y="1" width="40" height="20" uuid="934b16e8-c3eb-4017-866a-0b7735bf2917"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</pageFooter>
</jasperReport>
 - PD94bWwgdmVyc2lvbj0iMS4wIj8+DQo8IURPQ1RZUEUgamFzcGVyVGVtcGxhdGUNCiAgUFVCTElDICItLy9KYXNwZXJSZXBvcnRzLy9EVEQgVGVtcGxhdGUvL0VOIg0KICAiaHR0cDovL2phc3BlcnJlcG9ydHMuc291cmNlZm9yZ2UubmV0L2R0ZHMvamFzcGVydGVtcGxhdGUuZHRkIj4NCjxqYXNwZXJUZW1wbGF0ZT4NCiAgICAgICAgCTxzdHlsZSBmb250TmFtZT0iRGVqYVZ1IFNhbnMiIGZvbnRTaXplPSIxMCIgaEFsaWduPSJMZWZ0IiBpc0RlZmF1bHQ9InRydWUiIGlzUGRmRW1iZWRkZWQ9InRydWUiIA0KCQkJCSAgIG5hbWU9IkJhc2UiIHBkZkVuY29kaW5nPSJJZGVudGl0eS1IIiBwZGZGb250TmFtZT0iRGVqYVZ1U2Fucy50dGYiIHZBbGlnbj0iTWlkZGxlIj4NCgkJCTwvc3R5bGU+DQoJCQk8c3R5bGUgYmFja2NvbG9yPSIjMjY3OTk0IiBmb250U2l6ZT0iMjYiIGZvcmVjb2xvcj0iI0ZGRkZGRiIgaXNEZWZhdWx0PSJmYWxzZSINCiAgICAgICAgICAgICAgICAgICBtb2RlPSJPcGFxdWUiIG5hbWU9IlRpdGxlIiBzdHlsZT0iQmFzZSIvPiANCgkJCTxzdHlsZSBmb250U2l6ZT0iMTIiIGZvcmVjb2xvcj0iIzAwMDAwMCIgaXNEZWZhdWx0PSJmYWxzZSIgbmFtZT0iUGFnZSBoZWFkZXIiDQogICAgICAgICAgICAgICAgICAgc3R5bGU9IkJhc2UiLz4NCgkJCTxzdHlsZSBiYWNrY29sb3I9IiMzMzMzMzMiIGZvbnRTaXplPSIxMiIgZm9yZWNvbG9yPSIjRkZGRkZGIiBoQWxpZ249IkNlbnRlciINCiAgICAgICAgICAgICAgICAgICBpc0RlZmF1bHQ9ImZhbHNlIiBtb2RlPSJPcGFxdWUiIG5hbWU9IkNvbHVtbiBoZWFkZXIiIHN0eWxlPSJCYXNlIi8+DQoJCQk8c3R5bGUgaXNCb2xkPSJmYWxzZSIgaXNEZWZhdWx0PSJmYWxzZSIgbmFtZT0iRGV0YWlsIiBzdHlsZT0iQmFzZSIvPg0KICAgICAgICAgICAgPHN0eWxlIGlzQm9sZD0iZmFsc2UiIGlzRGVmYXVsdD0iZmFsc2UiIG5hbWU9IkNvZGUiIHN0eWxlPSJCYXNlIiBmb250U2l6ZT0iOSIvPg0KCQkJPHN0eWxlIGZvbnRTaXplPSI5IiBmb3JlY29sb3I9IiMwMDAwMDAiIGlzRGVmYXVsdD0iZmFsc2UiIG5hbWU9IlBhZ2UgZm9vdGVyIg0KICAgICAgICAgICAgICAgICAgIHN0eWxlPSJCYXNlIi8+DQoJCTwvamFzcGVyVGVtcGxhdGU+ - pdf - JRSwapFileVirtualizer - 300 - 10000 - 300000 - + + + + + + + + + activation/administrativeStatus + + filterAll + + + + + assignment/targetRef + + filterAll + + + + + assignment/targetRef + + filterAll + + + + + assignment/construction/resourceRef + + filterAll + + + + + + + + activation + ActivationStatusType + + + activation + + ActivationType.administrativeStatus + + + + + + organization + c:ObjectReferenceType + c:OrgType + + + organization + + ObjectTypeGuiDescriptor.org + + + + + + role + c:ObjectReferenceType + c:RoleType + + + role + + ObjectTypeGuiDescriptor.role + + + + + + resource + c:ObjectReferenceType + c:ResourceType + + + resource + + ObjectTypeGuiDescriptor.resource + + + + + + + nameColumn + name + + + fullNameColumn + fullName + nameColumn + + + activationColumn + activation/administrativeStatus + fullNameColumn + + + roleColumn + assignment + + Role + + + + + + + activationColumn + + + orgColumn + assignment + + Organization + + + + + + + roleColumn + + + accountColumn + linkRef + + Account + + + + + + + orgColumn + + UserType + + diff --git a/config/initial-objects/130-report-certification-definitions.xml b/config/initial-objects/130-report-certification-definitions.xml index 9795729d665..575014f957a 100644 --- a/config/initial-objects/130-report-certification-definitions.xml +++ b/config/initial-objects/130-report-certification-definitions.xml @@ -7,6 +7,7 @@ --> Certification definitions report All certification definitions with basic information on related campaigns. @@ -15,15 +16,14 @@ - + + + nameColumn name - - Name - ownerColumn @@ -43,21 +43,12 @@ + number openCampaignsColumn @@ -74,7 +65,6 @@ oid = object.getOid(); numberOfCampaigns = 0; - campaigns = midpoint.searchObjects(AccessCertificationCampaignType.class, prismContext.queryFor(AccessCertificationCampaignType.class).build(), null); for (AccessCertificationCampaignType campaign : campaigns) { if (oid.equals(campaign.getDefinitionRef().getOid())) { AccessCertificationCampaignStateType state = campaign.getState(); @@ -89,6 +79,7 @@ + number lastStartedColumn @@ -124,8 +115,26 @@ + + ascending + name + AccessCertificationDefinitionType + + campaigns + AccessCertificationCampaignType + + + + true diff --git a/config/initial-objects/140-report-certification-campaigns.xml b/config/initial-objects/140-report-certification-campaigns.xml index 78b2853c93e..51afc737483 100644 --- a/config/initial-objects/140-report-certification-campaigns.xml +++ b/config/initial-objects/140-report-certification-campaigns.xml @@ -7,19 +7,180 @@ --> - Certification campaigns report (Jasper) - All certification campaigns along with their state. - - true - <?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="reportUserList" pageWidth="1200" pageHeight="595" orientation="Landscape" whenNoDataType="AllSectionsNoDetail" columnWidth="1160" leftMargin="20" rightMargin="20" topMargin="30" bottomMargin="30" uuid="67e465c5-46ea-40d2-bea0-469c6cf38937">
	<property name="net.sf.jasperreports.print.keep.full.text" value="true"/>
	<property name="net.sf.jasperreports.export.xls.remove.empty.space.between.columns" value="true"/>
	<property name="net.sf.jasperreports.export.xls.remove.empty.space.between.rows" value="true"/>
	<property name="net.sf.jasperreports.export.pdf.force.linebreak.policy" value="true"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.1" value="title"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.band.1" value="pageHeader"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.keep.first.band.2" value="columnHeader"/>
	<property name="net.sf.jasperreports.export.xls.detect.cell.type" value="true"/>
	<property name="net.sf.jasperreports.export.xls.wrap.text" value="true"/>
	<property name="net.sf.jasperreports.export.xls.auto.fit.row" value="true"/>
	<property name="net.sf.jasperreports.export.xls.auto.fit.column" value="true"/>
	<property name="net.sf.jasperreports.awt.ignore.missing.font" value="true"/>
	<property name="ireport.zoom" value="1.0"/>
	<property name="ireport.x" value="16"/>
	<property name="ireport.y" value="14"/>
	<property name="com.jaspersoft.studio.data.defaultdataadapter" value="mql.xml"/>
	<import value="com.evolveum.midpoint.xml.ns._public.common.common_3.*"/>
	<import value="com.evolveum.midpoint.report.impl.ReportUtils"/>
	<import value="com.evolveum.midpoint.schema.util.CertCampaignTypeUtil"/>
	<style name="Base" isDefault="true" hTextAlign="Left" hImageAlign="Left" vTextAlign="Middle" vImageAlign="Middle" fontName="DejaVu Sans" fontSize="10" pdfFontName="DejaVuSans.ttf" pdfEncoding="Identity-H" isPdfEmbedded="true"/>
	<style name="Title" style="Base" mode="Opaque" forecolor="#FFFFFF" backcolor="#267994" fontSize="26"/>
	<style name="Page header" style="Base" forecolor="#000000" fontSize="12"/>
	<style name="Column header" style="Base" mode="Opaque" forecolor="#FFFFFF" backcolor="#333333" hTextAlign="Center" hImageAlign="Center" fontSize="12"/>
	<style name="Detail" style="Base" isBold="false"/>
	<style name="Code" style="Base" fontSize="9" isBold="false"/>
	<style name="Page footer" style="Base" forecolor="#000000" fontSize="9"/>
	<parameter name="alsoClosedCampaigns" class="java.lang.Boolean">
		<parameterDescription><![CDATA[Should we show also campaigns that were already closed? (default is false)]]></parameterDescription>
	</parameter>
	<queryString language="mql">
		<![CDATA[<code>        
    report.getCertificationCampaigns(alsoClosedCampaigns)
</code>]]>
	</queryString>
	<field name="oid" class="java.lang.String"/>
	<field name="name" class="java.lang.String"/>
	<field name="ownerRef" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType"/>
	<field name="startTimestamp" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<field name="endTimestamp" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<field name="state" class="com.evolveum.midpoint.xml.ns._public.common.common_3.AccessCertificationCampaignStateType"/>
	<field name="stageNumber" class="java.lang.Integer"/>
	<field name="_this_" class="com.evolveum.midpoint.prism.PrismContainerValue"/>
	<background>
		<band height="68" splitType="Stretch"/>
	</background>
	<title>
		<band height="123" splitType="Stretch">
			<frame>
				<reportElement style="Title" mode="Opaque" x="0" y="0" width="1160" height="67" backcolor="#267994" uuid="44bedacc-fa23-4fe1-b71f-e5afa943f553"/>
				<staticText>
					<reportElement style="Title" x="10" y="14" width="1140" height="38" uuid="f2d99cad-9d84-4f50-b455-453c87f62c4c"/>
					<textElement verticalAlignment="Middle"/>
					<text><![CDATA[Certification Campaigns Report]]></text>
				</staticText>
			</frame>
		</band>
	</title>
	<pageHeader>
		<band splitType="Stretch"/>
	</pageHeader>
	<columnHeader>
		<band height="20" splitType="Stretch">
			<property name="com.jaspersoft.studio.unit.height" value="pixel"/>
			<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.HorizontalRowLayout"/>
			<staticText>
				<reportElement style="Column header" x="0" y="0" width="360" height="20" uuid="0498909b-d3c5-4ee3-b8c9-f00a808efa7a"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Name]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="360" y="0" width="145" height="20" uuid="c530556b-e674-47c6-a799-6f1d5b5bce61"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Owner]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="505" y="0" width="115" height="20" uuid="bbf94f0d-535f-4b7f-a2f2-7ad3ec50f0ef"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Start]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="620" y="0" width="115" height="20" uuid="3b54722a-99bf-4c7c-b649-bb03ec53329e">
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Finish]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="735" y="0" width="60" height="20" uuid="421d39bd-6af0-4c1c-839f-06c1cf3cf130">
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Cases]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="795" y="0" width="175" height="20" uuid="c1439c0d-6580-4d96-8c8a-e986224696f3"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[State and stage]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="970" y="0" width="90" height="20" uuid="a8be1fb9-e714-423f-b349-42a220494b61"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Stage cases]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="1060" y="0" width="100" height="20" uuid="3319e59b-5201-454d-9296-722c557b8460"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[% complete]]></text>
			</staticText>
		</band>
	</columnHeader>
	<detail>
		<band height="24" splitType="Stretch">
			<property name="com.jaspersoft.studio.unit.height" value="pixel"/>
			<frame>
				<reportElement style="Detail" stretchType="RelativeToTallestObject" mode="Opaque" x="0" y="0" width="1160" height="24" uuid="86db6537-81f0-42b1-b74a-d2be709271cd">
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.HorizontalRowLayout"/>
				</reportElement>
				<textField>
					<reportElement x="0" y="0" width="360" height="24" uuid="c8948c85-ec31-4b39-889a-43cbce70f7f8">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textFieldExpression><![CDATA[$F{name}]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="360" y="0" width="145" height="24" uuid="75bfd4a0-5800-47a5-a53c-458025730bb3">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{ownerRef}, false)]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="505" y="0" width="115" height="24" uuid="f9b8bb68-7dc3-47bf-8611-802b8368f224">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{startTimestamp})]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="620" y="0" width="115" height="24" uuid="b5de6003-cc64-4ee4-9b25-9927e7379f57">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{endTimestamp})]]></textFieldExpression>
				</textField>
				<textField isBlankWhenNull="true">
					<reportElement x="735" y="0" width="60" height="24" uuid="b91b3f45-252d-4e71-951c-9e120aaf7c5a">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[$F{_this_}.getCase().size()]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="795" y="0" width="130" height="24" uuid="104430f7-fd60-4f98-8927-39b23e77cf4f">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					</reportElement>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{state})]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="925" y="0" width="45" height="24" uuid="4f0982f3-4895-4605-a5aa-f6402b4aeab8">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[$F{state} == com.evolveum.midpoint.xml.ns._public.common.common_3.AccessCertificationCampaignStateType.IN_REVIEW_STAGE ||
			$F{state} == com.evolveum.midpoint.xml.ns._public.common.common_3.AccessCertificationCampaignStateType.REVIEW_STAGE_DONE 
				? $F{stageNumber} : ""]]></textFieldExpression>
				</textField>
				<textField isBlankWhenNull="true">
					<reportElement x="970" y="0" width="90" height="24" uuid="8c09b787-2392-44e9-890f-46dd0f3b3b68">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.schema.util.CertCampaignTypeUtil.getActiveCases($F{_this_}.getCase(), $F{stageNumber}, $F{state})]]></textFieldExpression>
				</textField>
				<textField isBlankWhenNull="true">
					<reportElement x="1060" y="0" width="100" height="24" uuid="994a1e0f-ce28-4e44-bb4d-470c8bc2c65d">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.schema.util.CertCampaignTypeUtil.getCasesDecidedPercentageAllStagesAllIterations($F{_this_})+"%"]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</detail>
	<pageFooter>
		<band height="32" splitType="Stretch">
			<frame>
				<reportElement style="Page footer" mode="Transparent" x="0" y="1" width="1120" height="24" forecolor="#000000" backcolor="#267994" uuid="fbe8aae4-6500-468a-b1e8-700b569139a1"/>
				<textField pattern="EEEEE dd MMMMM yyyy">
					<reportElement style="Page footer" x="2" y="1" width="197" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[new java.util.Date()]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement style="Page footer" x="1000" y="1" width="80" height="20" uuid="5c062c66-ba45-4288-9dcd-246e28c5af75"/>
					<textElement textAlignment="Right" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA["Page "+$V{PAGE_NUMBER}+" of"]]></textFieldExpression>
				</textField>
				<textField evaluationTime="Report">
					<reportElement style="Page footer" x="1080" y="1" width="40" height="20" uuid="934b16e8-c3eb-4017-866a-0b7735bf2917"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</pageFooter>
</jasperReport>
 - html - JRSwapFileVirtualizer - 300 - 10000 - 300000 - - - prismReference - + Certification campaigns report + All certification campaigns along with their state. + + + + + + + + + state + + filterAll + + + + + state + inReviewStage + + + state + reviewStageDone + + + state + inRemediation + + + + + + + + + + nameColumn + name + + Name + + + + ownerColumn + ownerRef + + Owner + + nameColumn + + + startTimestampColumn + startTimestamp + + Start + + ownerColumn + + + + + + + + endTimestampColumn + endTimestamp + + Finish + + startTimestampColumn + + + + + + + + casesColumn + case + + Cases + + endTimestampColumn + number + + + stateColumn + state + + State + + casesColumn + + + stageNumberColumn + stageNumber + + Actual stage + + stateColumn + + + stageCasesColumn + stageNumberColumn + + Stage cases + + + + + + + + + percentageCompleteColumn + stageCasesColumn + + % complete + + + + + + + + + ascending + name + + AccessCertificationCampaignType + + true + + alsoClosedCampaigns + boolean + + + alsoClosedCampaigns + + runReportPopupContent.param.name.alsoClosedCampaigns + + + + + diff --git a/config/initial-objects/150-report-certification-cases.xml b/config/initial-objects/150-report-certification-cases.xml index b0f6c1478a5..86868f09e65 100644 --- a/config/initial-objects/150-report-certification-cases.xml +++ b/config/initial-objects/150-report-certification-cases.xml @@ -6,19 +6,197 @@ ~ and European Union Public License. See LICENSE file for details. --> - Certification cases report (Jasper) - Cases within a given certification campaign. - - true - <?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="reportUserList" pageWidth="1260" pageHeight="595" orientation="Landscape" whenNoDataType="AllSectionsNoDetail" columnWidth="1220" leftMargin="20" rightMargin="20" topMargin="30" bottomMargin="30" uuid="67e465c5-46ea-40d2-bea0-469c6cf38937">
	<property name="net.sf.jasperreports.print.keep.full.text" value="true"/>
	<property name="net.sf.jasperreports.export.xls.remove.empty.space.between.columns" value="true"/>
	<property name="net.sf.jasperreports.export.xls.remove.empty.space.between.rows" value="true"/>
	<property name="net.sf.jasperreports.export.pdf.force.linebreak.policy" value="true"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.1" value="title"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.band.1" value="pageHeader"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.keep.first.band.2" value="columnHeader"/>
	<property name="net.sf.jasperreports.export.xls.detect.cell.type" value="true"/>
	<property name="net.sf.jasperreports.export.xls.wrap.text" value="true"/>
	<property name="net.sf.jasperreports.export.xls.auto.fit.row" value="true"/>
	<property name="net.sf.jasperreports.export.xls.auto.fit.column" value="true"/>
	<property name="net.sf.jasperreports.awt.ignore.missing.font" value="true"/>
	<property name="ireport.zoom" value="1.0"/>
	<property name="ireport.x" value="16"/>
	<property name="ireport.y" value="14"/>
	<property name="com.jaspersoft.studio.data.defaultdataadapter" value="mql.xml"/>
	<style name="Base" isDefault="true" hTextAlign="Left" hImageAlign="Left" vTextAlign="Middle" vImageAlign="Middle" fontName="DejaVu Sans" fontSize="10" pdfFontName="DejaVuSans.ttf" pdfEncoding="Identity-H" isPdfEmbedded="true"/>
	<style name="Title" style="Base" mode="Opaque" forecolor="#FFFFFF" backcolor="#267994" fontSize="26"/>
	<style name="Page header" style="Base" forecolor="#000000" fontSize="12"/>
	<style name="Column header" style="Base" mode="Opaque" forecolor="#FFFFFF" backcolor="#333333" hTextAlign="Center" hImageAlign="Center" fontSize="12"/>
	<style name="Detail" style="Base" isBold="false"/>
	<style name="Code" style="Base" fontSize="9" isBold="false"/>
	<style name="Page footer" style="Base" forecolor="#000000" fontSize="9"/>
	<parameter name="campaignName" class="java.lang.String">
		<property name="key" value="name"/>
		<property name="label" value="name"/>
		<property name="targetType" value="com.evolveum.midpoint.xml.ns._public.common.common_3.AccessCertificationCampaignType"/>
		<parameterDescription><![CDATA[Name of certification campaign whose cases are to be reported on.]]></parameterDescription>
	</parameter>
	<queryString language="mql">
		<![CDATA[<code>        
    report.getCertificationCampaignCases(campaignName)
</code>]]>
	</queryString>
	<field name="_this_" class="com.evolveum.midpoint.prism.PrismContainerValue"/>
	<field name="objectRef" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType"/>
	<field name="targetRef" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType"/>
	<field name="currentReviewRequestedTimestamp" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<field name="currentReviewDeadline" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<field name="outcome" class="java.lang.String"/>
	<field name="iteration" class="java.lang.Integer"/>
	<field name="stageNumber" class="java.lang.Integer"/>
	<field name="remediedTimestamp" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<background>
		<band height="68" splitType="Stretch">
			<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.FreeLayout"/>
		</band>
	</background>
	<title>
		<band height="123" splitType="Stretch">
			<frame>
				<reportElement style="Title" mode="Opaque" x="0" y="0" width="1220" height="67" backcolor="#267994" uuid="44bedacc-fa23-4fe1-b71f-e5afa943f553"/>
				<staticText>
					<reportElement style="Title" x="10" y="14" width="1200" height="38" uuid="f2d99cad-9d84-4f50-b455-453c87f62c4c"/>
					<textElement verticalAlignment="Middle"/>
					<text><![CDATA[Certification Cases Report]]></text>
				</staticText>
			</frame>
			<staticText>
				<reportElement style="Page header" x="0" y="85" width="120" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43">
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Campaign name:]]></text>
			</staticText>
			<textField pattern="dd.MM.yyyy, HH:mm:ss">
				<reportElement style="Page header" isPrintRepeatedValues="false" x="120" y="85" width="437" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$P{campaignName}]]></textFieldExpression>
			</textField>
		</band>
	</title>
	<pageHeader>
		<band splitType="Stretch"/>
	</pageHeader>
	<columnHeader>
		<band height="20" splitType="Stretch">
			<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.HorizontalRowLayout"/>
			<staticText>
				<reportElement style="Column header" x="0" y="0" width="195" height="20" uuid="0498909b-d3c5-4ee3-b8c9-f00a808efa7a">
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Object]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="195" y="0" width="195" height="20" uuid="c530556b-e674-47c6-a799-6f1d5b5bce61">
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Target]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="390" y="0" width="128" height="20" uuid="3b54722a-99bf-4c7c-b649-bb03ec53329e">
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Reviewers]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="518" y="0" width="129" height="20" uuid="421d39bd-6af0-4c1c-839f-06c1cf3cf130">
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Last reviewed on]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="647" y="0" width="128" height="20" uuid="c1439c0d-6580-4d96-8c8a-e986224696f3"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Reviewed by]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="775" y="0" width="60" height="20" uuid="ef16cc84-cca7-4204-9bc8-d08680b5067d">
					<property name="com.jaspersoft.studio.unit.height" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Iteration]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="835" y="0" width="66" height="20" uuid="a8be1fb9-e714-423f-b349-42a220494b61">
					<property name="com.jaspersoft.studio.unit.height" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[In stage]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="901" y="0" width="63" height="20" uuid="3319e59b-5201-454d-9296-722c557b8460">
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Result]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="964" y="0" width="128" height="20" uuid="53c59170-f78a-41a5-9399-e4129d3d6df8">
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Comments]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="1092" y="0" width="128" height="20" uuid="80b6e1bd-8b2e-4774-b512-7d4c23a58211"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Remedied on]]></text>
			</staticText>
		</band>
	</columnHeader>
	<detail>
		<band height="24" splitType="Stretch">
			<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.HorizontalRowLayout"/>
			<frame>
				<reportElement style="Detail" stretchType="RelativeToTallestObject" mode="Opaque" x="0" y="0" width="1220" height="24" uuid="86db6537-81f0-42b1-b74a-d2be709271cd">
					<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.HorizontalRowLayout"/>
				</reportElement>
				<textField isStretchWithOverflow="true">
					<reportElement x="0" y="0" width="195" height="24" uuid="c8948c85-ec31-4b39-889a-43cbce70f7f8">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{objectRef})]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true">
					<reportElement x="195" y="0" width="195" height="24" uuid="75bfd4a0-5800-47a5-a53c-458025730bb3">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					</reportElement>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{targetRef})]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true">
					<reportElement x="390" y="0" width="128" height="24" uuid="b5de6003-cc64-4ee4-9b25-9927e7379f57">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintUsersForReport(com.evolveum.midpoint.schema.util.CertCampaignTypeUtil.getCurrentlyAssignedReviewers($F{_this_}.asPrismContainerValue()))]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="518" y="0" width="129" height="24" uuid="b91b3f45-252d-4e71-951c-9e120aaf7c5a">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport(com.evolveum.midpoint.schema.util.CertCampaignTypeUtil.getLastReviewedOn($F{_this_}.asPrismContainerValue()))]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true">
					<reportElement x="647" y="0" width="128" height="24" uuid="104430f7-fd60-4f98-8927-39b23e77cf4f">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintUsersForReport(com.evolveum.midpoint.schema.util.CertCampaignTypeUtil.getReviewedBy($F{_this_}.asPrismContainerValue()))]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="775" y="0" width="60" height="24" uuid="2d36c528-4784-40b2-9b53-3a2535d779f6">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[$F{stageNumber}]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="835" y="0" width="66" height="24" uuid="8c09b787-2392-44e9-890f-46dd0f3b3b68">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[$F{stageNumber}]]></textFieldExpression>
				</textField>
				<textField isBlankWhenNull="true">
					<reportElement x="901" y="0" width="63" height="24" uuid="994a1e0f-ce28-4e44-bb4d-470c8bc2c65d">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintCertOutcomeForReport($F{outcome})]]></textFieldExpression>
				</textField>
				<textField isStretchWithOverflow="true">
					<reportElement x="964" y="0" width="128" height="24" uuid="a9aad576-69db-47c1-b49b-44793a4e6a07">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.join(com.evolveum.midpoint.schema.util.CertCampaignTypeUtil.getComments($F{_this_}.asPrismContainerValue()))]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="1092" y="0" width="128" height="24" uuid="477c9964-d82c-450e-b4ee-273b1bdd8e6f">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.height" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{remediedTimestamp})]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</detail>
	<pageFooter>
		<band height="32" splitType="Stretch">
			<frame>
				<reportElement style="Page footer" mode="Transparent" x="0" y="1" width="1180" height="24" forecolor="#000000" backcolor="#267994" uuid="fbe8aae4-6500-468a-b1e8-700b569139a1"/>
				<textField pattern="EEEEE dd MMMMM yyyy">
					<reportElement style="Page footer" x="2" y="1" width="197" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[new java.util.Date()]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement style="Page footer" x="1060" y="1" width="80" height="20" uuid="5c062c66-ba45-4288-9dcd-246e28c5af75"/>
					<textElement textAlignment="Right" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA["Page "+$V{PAGE_NUMBER}+" of"]]></textFieldExpression>
				</textField>
				<textField evaluationTime="Report">
					<reportElement style="Page footer" x="1140" y="1" width="40" height="20" uuid="934b16e8-c3eb-4017-866a-0b7735bf2917"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</pageFooter>
</jasperReport>
 - html - JRSwapFileVirtualizer - 300 - 10000 - 300000 - - - prismReference - + Certification cases report + Cases within a given certification campaign. + + + + + + + + ../name + + filterAll + + + + + + + + objectColumn + objectRef + + Object + + + + + + + + + targetColumn + targetRef + + Target + + objectColumn + + + + + + + + reviewersColumn + + Reviewers + + targetColumn + + + + + + + + lastReviewedOnColumn + + Last reviewed on + + reviewersColumn + + + + + + + + reviewedByColumn + + Reviewed by + + lastReviewedOnColumn + + + + + + + + iterationColumn + iteration + + Iteration + + reviewedByColumn + + + inStageNumberColumn + stageNumber + + In stage + + iterationColumn + + + outcomeColumn + outcome + + Result + + inStageNumberColumn + + + commentsColumn + + Comments + + outcomeColumn + + + + + + + + remediedTimestampColumn + remediedTimestamp + + Remedied on + + commentsColumn + + AccessCertificationCaseType + + objectRef/@/name + + + + campaignName + c:ObjectReferenceType + c:AccessCertificationCampaignType + + + campaignName + + runReportPopupContent.param.name.campaignName + + + + + diff --git a/config/initial-objects/160-report-certification-decisions.xml b/config/initial-objects/160-report-certification-decisions.xml index 86cb0f2e414..386cfd4cbbc 100644 --- a/config/initial-objects/160-report-certification-decisions.xml +++ b/config/initial-objects/160-report-certification-decisions.xml @@ -6,19 +6,182 @@ ~ and European Union Public License. See LICENSE file for details. --> - Certification decisions report (Jasper) - Decisions of individual reviewers for a certification campaign as a whole or for a given campaign stage. - - true - <?xml version="1.0" encoding="UTF-8"?>
<jasperReport xmlns="http://jasperreports.sourceforge.net/jasperreports" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://jasperreports.sourceforge.net/jasperreports http://jasperreports.sourceforge.net/xsd/jasperreport.xsd" name="reportUserList" pageWidth="1260" pageHeight="615" orientation="Landscape" whenNoDataType="AllSectionsNoDetail" columnWidth="1220" leftMargin="20" rightMargin="20" topMargin="30" bottomMargin="30" uuid="67e465c5-46ea-40d2-bea0-469c6cf38937">
	<property name="net.sf.jasperreports.print.keep.full.text" value="true"/>
	<property name="net.sf.jasperreports.export.xls.remove.empty.space.between.columns" value="true"/>
	<property name="net.sf.jasperreports.export.xls.remove.empty.space.between.rows" value="true"/>
	<property name="net.sf.jasperreports.export.pdf.force.linebreak.policy" value="true"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.1" value="title"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.csv.exclude.origin.keep.first.band.2" value="columnHeader"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.band.1" value="pageHeader"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.xls.exclude.origin.keep.first.band.2" value="columnHeader"/>
	<property name="net.sf.jasperreports.export.xls.detect.cell.type" value="true"/>
	<property name="net.sf.jasperreports.export.xls.wrap.text" value="true"/>
	<property name="net.sf.jasperreports.export.xls.auto.fit.row" value="true"/>
	<property name="net.sf.jasperreports.export.xls.auto.fit.column" value="true"/>
	<property name="net.sf.jasperreports.awt.ignore.missing.font" value="true"/>
	<property name="net.sf.jasperreports.export.xlsx.exclude.origin.band.1" value="pageHeader"/>
	<property name="net.sf.jasperreports.export.xlsx.exclude.origin.band.2" value="pageFooter"/>
	<property name="net.sf.jasperreports.export.xlsx.exclude.origin.keep.first.band.2" value="columnHeader"/>
	<property name="net.sf.jasperreports.export.xlsx.exclude.origin.keep.first.band.1" value="pageHeader"/>
	<property name="ireport.zoom" value="1.0"/>
	<property name="ireport.x" value="16"/>
	<property name="ireport.y" value="14"/>
	<property name="com.jaspersoft.studio.data.defaultdataadapter" value="mql.xml"/>
	<style name="Base" isDefault="true" hTextAlign="Left" hImageAlign="Left" vTextAlign="Middle" vImageAlign="Middle" fontName="DejaVu Sans" fontSize="10" pdfFontName="DejaVuSans.ttf" pdfEncoding="Identity-H" isPdfEmbedded="true"/>
	<style name="Title" style="Base" mode="Opaque" forecolor="#FFFFFF" backcolor="#267994" fontSize="26"/>
	<style name="Page header" style="Base" forecolor="#000000" fontSize="12"/>
	<style name="Column header" style="Base" mode="Opaque" forecolor="#FFFFFF" backcolor="#333333" hTextAlign="Center" hImageAlign="Center" fontSize="12"/>
	<style name="Detail" style="Base" isBold="false"/>
	<style name="Code" style="Base" fontSize="9" isBold="false"/>
	<style name="Page footer" style="Base" forecolor="#000000" fontSize="9"/>
	<parameter name="campaignName" class="java.lang.String">
		<property name="key" value="name"/>
		<property name="label" value="name"/>
		<property name="targetType" value="com.evolveum.midpoint.xml.ns._public.common.common_3.AccessCertificationCampaignType"/>
		<parameterDescription><![CDATA[Name of certification campaign whose decisions are to be reported on.]]></parameterDescription>
	</parameter>
	<parameter name="stageNumber" class="java.lang.Integer">
		<parameterDescription><![CDATA[Number of stage to report decisions for (if not specified, all stages are taken into account)]]></parameterDescription>
	</parameter>
	<parameter name="iteration" class="java.lang.Integer">
		<parameterDescription><![CDATA[Iteration to report decisions for (if not specified, all iterations are taken into account)]]></parameterDescription>
	</parameter>
	<queryString language="mql">
		<![CDATA[<code>
    report.getCertificationCampaignDecisions(campaignName, stageNumber, iteration)
</code>]]>
	</queryString>
	<field name="stageNumber" class="java.lang.Integer"/>
	<field name="iteration" class="java.lang.Integer"/>
	<field name="performerRef" class="com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType"/>
	<field name="output" class="com.evolveum.midpoint.xml.ns._public.common.common_3.AbstractWorkItemOutputType"/>
	<field name="outputChangeTimestamp" class="javax.xml.datatype.XMLGregorianCalendar"/>
	<field name="_parent_" class="com.evolveum.midpoint.prism.PrismContainerValue"/>
	<field name="_this_" class="com.evolveum.midpoint.prism.PrismContainerValue"/>
	<background>
		<band height="68" splitType="Stretch">
			<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.FreeLayout"/>
		</band>
	</background>
	<title>
		<band height="143" splitType="Stretch">
			<frame>
				<reportElement style="Title" mode="Opaque" x="0" y="0" width="1220" height="67" backcolor="#267994" uuid="44bedacc-fa23-4fe1-b71f-e5afa943f553"/>
				<staticText>
					<reportElement style="Title" x="10" y="14" width="1200" height="38" uuid="f2d99cad-9d84-4f50-b455-453c87f62c4c"/>
					<textElement verticalAlignment="Middle"/>
					<text><![CDATA[Certification Decisions Report]]></text>
				</staticText>
			</frame>
			<staticText>
				<reportElement style="Page header" x="0" y="85" width="120" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43">
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Campaign name:]]></text>
			</staticText>
			<textField>
				<reportElement style="Page header" isPrintRepeatedValues="false" x="120" y="85" width="437" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$P{campaignName}]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="964" y="85" width="186" height="20" uuid="e035dbd5-dc2f-45cb-936c-a08e9c011e43"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Stage number:]]></text>
			</staticText>
			<textField>
				<reportElement style="Page header" isPrintRepeatedValues="false" x="1160" y="85" width="60" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$P{stageNumber} != null ? $P{stageNumber} : "Any"]]></textFieldExpression>
			</textField>
			<staticText>
				<reportElement style="Page header" x="964" y="105" width="186" height="20" uuid="199953f1-e9bc-4d71-9797-00d9cc54a70c"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Iteration:]]></text>
			</staticText>
			<textField>
				<reportElement style="Page header" isPrintRepeatedValues="false" x="1160" y="105" width="60" height="20" uuid="7a1ed8cc-952a-4259-83e1-fc9cca4927b4"/>
				<textElement verticalAlignment="Middle">
					<font isBold="false"/>
				</textElement>
				<textFieldExpression><![CDATA[$P{iteration} != null ? $P{iteration} : "Any"]]></textFieldExpression>
			</textField>
		</band>
	</title>
	<pageHeader>
		<band splitType="Stretch"/>
	</pageHeader>
	<columnHeader>
		<band height="20" splitType="Stretch">
			<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.HorizontalRowLayout"/>
			<staticText>
				<reportElement style="Column header" x="0" y="0" width="273" height="20" uuid="0498909b-d3c5-4ee3-b8c9-f00a808efa7a">
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Object]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="273" y="0" width="272" height="20" uuid="c530556b-e674-47c6-a799-6f1d5b5bce61">
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Target]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="545" y="0" width="165" height="20" uuid="3b54722a-99bf-4c7c-b649-bb03ec53329e">
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Reviewed by]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="710" y="0" width="130" height="20" uuid="421d39bd-6af0-4c1c-839f-06c1cf3cf130"/>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Reviewed on]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="840" y="0" width="60" height="20" uuid="e9638617-541e-43aa-9aa3-fd99af0b40fa">
					<property name="com.jaspersoft.studio.unit.height" value="pixel"/>
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Iteration]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="900" y="0" width="75" height="20" uuid="a8be1fb9-e714-423f-b349-42a220494b61">
					<property name="com.jaspersoft.studio.unit.height" value="pixel"/>
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[In stage]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="975" y="0" width="80" height="20" uuid="3319e59b-5201-454d-9296-722c557b8460">
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Result]]></text>
			</staticText>
			<staticText>
				<reportElement style="Column header" x="1055" y="0" width="165" height="20" uuid="53c59170-f78a-41a5-9399-e4129d3d6df8">
					<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
				</reportElement>
				<textElement verticalAlignment="Middle"/>
				<text><![CDATA[Comment]]></text>
			</staticText>
		</band>
	</columnHeader>
	<detail>
		<band height="24" splitType="Stretch">
			<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.HorizontalRowLayout"/>
			<frame>
				<reportElement style="Detail" stretchType="RelativeToTallestObject" mode="Opaque" x="0" y="0" width="1220" height="24" uuid="86db6537-81f0-42b1-b74a-d2be709271cd">
					<property name="com.jaspersoft.studio.layout" value="com.jaspersoft.studio.editor.layout.HorizontalRowLayout"/>
				</reportElement>
				<textField>
					<reportElement x="0" y="0" width="273" height="24" uuid="c8948c85-ec31-4b39-889a-43cbce70f7f8">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{_parent_}.getObjectRef())]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="273" y="0" width="272" height="24" uuid="75bfd4a0-5800-47a5-a53c-458025730bb3">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					</reportElement>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintForReport($F{_parent_}.getTargetRef())]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="545" y="0" width="165" height="24" uuid="b5de6003-cc64-4ee4-9b25-9927e7379f57">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintPerformerOrAssigneesForReport($F{_this_}.asPrismContainerValue())]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="710" y="0" width="130" height="24" uuid="b91b3f45-252d-4e71-951c-9e120aaf7c5a">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintOutputChangeForReport($F{_this_}.asPrismContainerValue())]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="840" y="0" width="60" height="24" uuid="6ffcffdb-8513-485b-9d19-ceab931e7517">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[$F{stageNumber}]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement x="900" y="0" width="75" height="24" uuid="8c09b787-2392-44e9-890f-46dd0f3b3b68">
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[$F{stageNumber}]]></textFieldExpression>
				</textField>
				<textField isBlankWhenNull="true">
					<reportElement x="975" y="0" width="80" height="24" uuid="994a1e0f-ce28-4e44-bb4d-470c8bc2c65d">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
						<property name="com.jaspersoft.studio.unit.width" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintCertOutcomeForReport((com.evolveum.midpoint.xml.ns._public.common.common_3.AbstractWorkItemOutputType)$F{output}, true)]]></textFieldExpression>
				</textField>
				<textField isBlankWhenNull="true">
					<reportElement x="1055" y="0" width="165" height="24" uuid="a9aad576-69db-47c1-b49b-44793a4e6a07">
						<property name="com.jaspersoft.studio.unit.x" value="pixel"/>
					</reportElement>
					<textElement textAlignment="Center"/>
					<textFieldExpression><![CDATA[com.evolveum.midpoint.report.impl.ReportUtils.prettyPrintCertCommentForReport($F{output})]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</detail>
	<pageFooter>
		<band height="32" splitType="Stretch">
			<frame>
				<reportElement style="Page footer" mode="Transparent" x="0" y="1" width="1180" height="24" forecolor="#000000" backcolor="#267994" uuid="fbe8aae4-6500-468a-b1e8-700b569139a1"/>
				<textField pattern="EEEEE dd MMMMM yyyy">
					<reportElement style="Page footer" x="2" y="1" width="197" height="20" uuid="28bb9b47-a69c-48e1-9073-d54d926242e8"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[new java.util.Date()]]></textFieldExpression>
				</textField>
				<textField>
					<reportElement style="Page footer" x="1060" y="1" width="80" height="20" uuid="5c062c66-ba45-4288-9dcd-246e28c5af75"/>
					<textElement textAlignment="Right" verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA["Page "+$V{PAGE_NUMBER}+" of"]]></textFieldExpression>
				</textField>
				<textField evaluationTime="Report">
					<reportElement style="Page footer" x="1140" y="1" width="40" height="20" uuid="934b16e8-c3eb-4017-866a-0b7735bf2917"/>
					<textElement verticalAlignment="Middle"/>
					<textFieldExpression><![CDATA[" " + $V{PAGE_NUMBER}]]></textFieldExpression>
				</textField>
			</frame>
		</band>
	</pageFooter>
</jasperReport>
 - html - JRSwapFileVirtualizer - 300 - 10000 - 300000 - - - prismReference - + Certification decisions report + Decisions of individual reviewers for a certification campaign as a whole or for a given campaign stage. + + + + + + + + ../name + + filterAll + + + + + + + + + + + objectColumn + objectRef + + Object + + + + + + + + + targetColumn + targetRef + + Target + + objectColumn + + + + + + + + workItemColumn + workItem + + Reviewed by - Reviewed on - Iteration - In stage - Result (Comment) + + targetColumn + + + + + + + + objectRef/@/name + + c:AccessCertificationCaseType + + + campaignName + c:ObjectReferenceType + c:AccessCertificationCampaignType + + + campaignName + + runReportPopupContent.param.name.campaignName + + + + + + stageNumber + string + + + stageNumber + + runReportPopupContent.param.name.stageNumber + + + + + + iteration + string + + + iteration + + runReportPopupContent.param.name.iteration + + + + + diff --git a/config/initial-objects/280-object-collection-resource-up.xml b/config/initial-objects/251-object-collection-resource-up.xml similarity index 100% rename from config/initial-objects/280-object-collection-resource-up.xml rename to config/initial-objects/251-object-collection-resource-up.xml diff --git a/config/initial-objects/270-object-collection-task-active.xml b/config/initial-objects/261-object-collection-task-active.xml similarity index 100% rename from config/initial-objects/270-object-collection-task-active.xml rename to config/initial-objects/261-object-collection-task-active.xml diff --git a/config/initial-objects/284-object-collection-audit.xml b/config/initial-objects/270-object-collection-audit.xml similarity index 100% rename from config/initial-objects/284-object-collection-audit.xml rename to config/initial-objects/270-object-collection-audit.xml diff --git a/config/initial-objects/285-object-collection-audit-24h.xml b/config/initial-objects/271-object-collection-audit-24h.xml similarity index 100% rename from config/initial-objects/285-object-collection-audit-24h.xml rename to config/initial-objects/271-object-collection-audit-24h.xml diff --git a/config/initial-objects/290-object-collection-audit-errors-24h.xml b/config/initial-objects/272-object-collection-audit-errors-24h.xml similarity index 100% rename from config/initial-objects/290-object-collection-audit-errors-24h.xml rename to config/initial-objects/272-object-collection-audit-errors-24h.xml diff --git a/config/initial-objects/300-object-collection-audit-modifications-24h.xml b/config/initial-objects/273-object-collection-audit-modifications-24h.xml similarity index 100% rename from config/initial-objects/300-object-collection-audit-modifications-24h.xml rename to config/initial-objects/273-object-collection-audit-modifications-24h.xml diff --git a/config/initial-objects/280-object-collection-certification-campaign-all.xml b/config/initial-objects/280-object-collection-certification-campaign-all.xml new file mode 100644 index 00000000000..a92f8c21f25 --- /dev/null +++ b/config/initial-objects/280-object-collection-certification-campaign-all.xml @@ -0,0 +1,27 @@ + + + + + All certification campaigns + AccessCertificationCampaignType + + + + + + + case + + + include + + + + diff --git a/gui/admin-gui/src/main/resources/initial-objects/255-object-collection-certification-definition-all.xml b/config/initial-objects/290-object-collection-shadow-all.xml similarity index 72% rename from gui/admin-gui/src/main/resources/initial-objects/255-object-collection-certification-definition-all.xml rename to config/initial-objects/290-object-collection-shadow-all.xml index 330c41f246c..c08274cd3d9 100644 --- a/gui/admin-gui/src/main/resources/initial-objects/255-object-collection-certification-definition-all.xml +++ b/config/initial-objects/290-object-collection-shadow-all.xml @@ -1,6 +1,6 @@ - - - net.sf.jasperreports - jasperreports - - - bouncycastle - bcmail-jdk14 - - - bouncycastle - bcprov-jdk14 - - - bouncycastle - bctsp-jdk14 - - - org.bouncycastle - bcprov-jdk15on - - - org.apache.poi diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/component/ObjectListPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/component/ObjectListPanel.java index 9da81c40ca4..0e7396559c8 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/component/ObjectListPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/component/ObjectListPanel.java @@ -9,6 +9,10 @@ import java.util.*; import java.util.function.Supplier; +import com.evolveum.midpoint.gui.impl.component.ContainerableListPanel; +import com.evolveum.midpoint.web.component.search.*; + +import com.evolveum.midpoint.xml.ns._public.common.common_3.GuiObjectColumnType; import com.evolveum.midpoint.prism.query.ObjectOrdering; import com.evolveum.midpoint.web.component.util.SerializableFunction; @@ -22,26 +26,17 @@ import org.apache.wicket.util.string.StringValue; import org.jetbrains.annotations.NotNull; -import com.evolveum.midpoint.gui.api.model.LoadableModel; import com.evolveum.midpoint.gui.api.page.PageBase; import com.evolveum.midpoint.gui.api.util.WebComponentUtil; -import com.evolveum.midpoint.gui.impl.component.ContainerableListPanel; import com.evolveum.midpoint.model.api.authentication.CompiledObjectCollectionView; import com.evolveum.midpoint.prism.path.ItemPath; import com.evolveum.midpoint.prism.query.ObjectQuery; import com.evolveum.midpoint.schema.GetOperationOptions; import com.evolveum.midpoint.schema.SelectorOptions; -import com.evolveum.midpoint.schema.constants.ObjectTypes; -import com.evolveum.midpoint.util.DisplayableValue; -import com.evolveum.midpoint.web.component.data.ISelectableDataProvider; import com.evolveum.midpoint.web.component.data.SelectableBeanObjectDataProvider; import com.evolveum.midpoint.web.component.data.column.ColumnUtils; import com.evolveum.midpoint.web.component.data.column.ObjectNameColumn; import com.evolveum.midpoint.web.component.menu.cog.InlineMenuItem; -import com.evolveum.midpoint.web.component.search.ContainerTypeSearchItem; -import com.evolveum.midpoint.web.component.search.Search; -import com.evolveum.midpoint.web.component.search.SearchFactory; -import com.evolveum.midpoint.web.component.search.SearchValue; import com.evolveum.midpoint.web.component.util.SelectableBean; import com.evolveum.midpoint.web.component.util.SerializableSupplier; import com.evolveum.midpoint.web.session.PageStorage; @@ -145,7 +140,7 @@ public void addPerformed(AjaxRequestTarget target, List selected) { } @Override - protected IColumn, String> createNameColumn(IModel displayModel, String itemPath, ExpressionType expression) { + protected IColumn, String> createNameColumn(IModel displayModel, GuiObjectColumnType customColumn, String itemPath, ExpressionType expression) { return new ObjectNameColumn<>(displayModel == null ? createStringResource("ObjectType.name") : displayModel, itemPath, expression, getPageBase(), StringUtils.isEmpty(itemPath)) { private static final long serialVersionUID = 1L; diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/component/tabs/PanelTab.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/component/tabs/PanelTab.java index 8b238752a60..a17f3cba00e 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/component/tabs/PanelTab.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/component/tabs/PanelTab.java @@ -58,4 +58,8 @@ public boolean isVisible() { return visible.isVisible(); } + + public void resetPanel(){ + panel = null; + } } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/page/PageBase.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/page/PageBase.java index 19c3c04ca1e..feb01e78447 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/page/PageBase.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/page/PageBase.java @@ -16,6 +16,8 @@ import com.evolveum.midpoint.gui.impl.component.menu.LeftMenuPanel; +import com.evolveum.midpoint.report.api.ReportService; + import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.StringUtils; import org.apache.commons.lang3.Validate; diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/util/WebComponentUtil.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/util/WebComponentUtil.java index cca055a367e..c226865f24d 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/util/WebComponentUtil.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/api/util/WebComponentUtil.java @@ -23,6 +23,8 @@ import javax.xml.datatype.XMLGregorianCalendar; import javax.xml.namespace.QName; +import com.evolveum.midpoint.web.component.util.SelectableBean; + import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.*; import org.apache.commons.lang3.math.NumberUtils; @@ -867,6 +869,8 @@ public static List createContainerableTypesQnameList() { List qnameList = types.stream().map(type -> type.getTypeQName()).collect(Collectors.toList()); //todo create enum for containerable types? qnameList.add(AuditEventRecordType.COMPLEX_TYPE); + qnameList.add(AccessCertificationCaseType.COMPLEX_TYPE); + qnameList.add(CaseWorkItemType.COMPLEX_TYPE); return qnameList.stream().sorted((type1, type2) -> { Validate.notNull(type1); Validate.notNull(type2); @@ -2412,11 +2416,12 @@ public static void setCurrentPage(Table table, ObjectPaging paging) { return; } - if (paging == null) { + if (paging == null || paging.getOffset() == null) { table.getDataTable().setCurrentPage(0); return; } + long itemsPerPage = table.getDataTable().getItemsPerPage(); long page = ((paging.getOffset() + itemsPerPage) / itemsPerPage) - 1; if (page < 0) { @@ -2601,6 +2606,7 @@ protected void onSubmit(AjaxRequestTarget target) { if (target != null) { target.add(findParent(TabbedPanel.class)); } + target.add(parentPage.getFeedbackPanel()); } }; @@ -5085,6 +5091,71 @@ public static String countLinkFroNonDeadShadows(Collection return Integer.toString(count); } + public static List> getAllowedValues(SearchFilterParameterType parameter, PageBase pageBase) { + List> allowedValues = new ArrayList<>(); + + if (parameter == null || parameter.getAllowedValuesExpression() == null) { + return allowedValues; + } + Task task = pageBase.createSimpleTask("evaluate expression for allowed values"); + ExpressionType expression = parameter.getAllowedValuesExpression(); + Object value = null; + try { + + value = ExpressionUtil.evaluateExpression(new VariablesMap(), null, + expression, MiscSchemaUtil.getExpressionProfile(), + pageBase.getExpressionFactory(), "evaluate expression for allowed values", task, task.getResult()); + } catch (Exception e) { + LOGGER.error("Couldn't execute expression " + expression, e); + pageBase.error(pageBase.createStringResource("FilterSearchItem.message.error.evaluateAllowedValuesExpression", expression).getString()); + return allowedValues; + } + if (value instanceof PrismPropertyValue) { + value = ((PrismPropertyValue) value).getRealValue(); + } + + if (!(value instanceof List)) { + LOGGER.error("Exception return unexpected type, expected List, but was " + (value == null ? null : value.getClass())); + pageBase.error(pageBase.createStringResource("FilterSearchItem.message.error.wrongType", expression).getString()); + return allowedValues; + } + + if (!((List>) value).isEmpty()) { + if (!(((List>) value).get(0) instanceof DisplayableValue)) { + LOGGER.error("Exception return unexpected type, expected List, but was " + (value == null ? null : value.getClass())); + pageBase.error(pageBase.createStringResource("FilterSearchItem.message.error.wrongType", expression).getString()); + return allowedValues; + } + return (List>) value; + } + return allowedValues; + } + + public static DropDownChoicePanel createDropDownChoices(String id, IModel> model, IModel>> choices, + boolean allowNull, PageBase pageBase) { + return new DropDownChoicePanel(id, model, choices, new IChoiceRenderer() { + private static final long serialVersionUID = 1L; + + @Override + public Object getDisplayValue(DisplayableValue val) { + if (val.getValue() instanceof Enum) { + return pageBase.createStringResource((Enum>) val.getValue()).getString(); + } + return pageBase.createStringResource(val.getLabel()).getString(); + } + + @Override + public String getIdValue(DisplayableValue val, int index) { + return Integer.toString(index); + } + + @Override + public DisplayableValue getObject(String id, IModel extends List extends DisplayableValue>> choices) { + return StringUtils.isNotBlank(id) ? choices.getObject().get(Integer.parseInt(id)) : null; + } + }, allowNull); + } + public static Map createMainButtonLayerIcon(DisplayType mainButtonDisplayType) { if (mainButtonDisplayType.getIcon() != null && mainButtonDisplayType.getIcon().getCssClass() != null && mainButtonDisplayType.getIcon().getCssClass().contains(GuiStyleConstants.CLASS_ADD_NEW_OBJECT)) { @@ -5094,4 +5165,23 @@ public static Map createMainButtonLayerIcon(DisplayType layerIconMap.put(IconCssStyle.BOTTOM_RIGHT_STYLE, WebComponentUtil.createIconType(GuiStyleConstants.CLASS_PLUS_CIRCLE, "green")); return layerIconMap; } + + public static void addNewArchetype(PrismObjectWrapper object, String archetypeOid, AjaxRequestTarget target, PageBase pageBase){ + try { + PrismContainerWrapper archetypeAssignment = object.findContainer(TaskType.F_ASSIGNMENT); + PrismContainerValue archetypeAssignmentValue = archetypeAssignment.getItem().createNewValue(); + AssignmentType newArchetypeAssignment = archetypeAssignmentValue.asContainerable(); + newArchetypeAssignment.setTargetRef(ObjectTypeUtil.createObjectRef(archetypeOid, ObjectTypes.ARCHETYPE)); + WebPrismUtil.createNewValueWrapper(archetypeAssignment, archetypeAssignmentValue, pageBase, target); + } catch (SchemaException e) { + LOGGER.error("Exception during assignment lookup, reason: {}", e.getMessage(), e); + pageBase.error("Cannot set selected handler: " + e.getMessage()); + return; + } + } + + public static boolean isImportReport(ReportType report) { + ReportBehaviorType behavior = report.getBehavior(); + return behavior != null && DirectionTypeType.IMPORT.equals(behavior.getDirection()); + } } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/AssignmentConstructionPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/AssignmentConstructionPanel.java index 7e48b3ab1e0..3e8453a4cd5 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/AssignmentConstructionPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/AssignmentConstructionPanel.java @@ -7,6 +7,7 @@ package com.evolveum.midpoint.gui.impl.component; import com.evolveum.midpoint.gui.api.component.BasePanel; +import com.evolveum.midpoint.gui.api.prism.wrapper.ItemWrapper; import com.evolveum.midpoint.gui.api.prism.wrapper.PrismContainerWrapper; import com.evolveum.midpoint.gui.impl.prism.panel.ResourceAttributePanel; import com.evolveum.midpoint.gui.impl.prism.panel.SingleContainerPanel; @@ -41,7 +42,8 @@ private void initLayout() { SingleContainerPanel baseConstructionPanel = new SingleContainerPanel<>(ID_BASIC, getModel(), ConstructionType.COMPLEX_TYPE) { @Override - protected ItemVisibility getVisibility(ItemPath itemPath) { + protected ItemVisibility getVisibility(ItemWrapper itemWrapper) { + ItemPath itemPath = itemWrapper.getPath(); if (isAssociation(itemPath)) { return ItemVisibility.HIDDEN; } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/AssignmentsDetailsPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/AssignmentsDetailsPanel.java index 88092234bee..18c5dc2abe4 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/AssignmentsDetailsPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/AssignmentsDetailsPanel.java @@ -232,7 +232,8 @@ public WebMarkupContainer createPanel(String panelId) { PrismContainerWrapperModel.fromContainerValueWrapper(getModel(), AssignmentType.F_ACTIVATION), ActivationType.COMPLEX_TYPE) { @Override - protected ItemVisibility getVisibility(ItemPath itemPath) { + protected ItemVisibility getVisibility(ItemWrapper itemWrapper) { + ItemPath itemPath = itemWrapper.getPath(); if (ItemPath.create(AssignmentHolderType.F_ASSIGNMENT, AssignmentType.F_ACTIVATION, ActivationType.F_LOCKOUT_EXPIRATION_TIMESTAMP).equivalent(itemPath.namedSegmentsOnly())) { return ItemVisibility.HIDDEN; } @@ -249,7 +250,7 @@ protected ItemVisibility getVisibility(ItemPath itemPath) { return ItemVisibility.HIDDEN; } - return super.getVisibility(itemPath); + return super.getVisibility(itemWrapper); } }; } @@ -264,9 +265,10 @@ public WebMarkupContainer createPanel(String panelId) { return new SingleContainerPanel<>(panelId, PrismContainerWrapperModel.fromContainerValueWrapper(getModel(), AssignmentType.F_CONDITION), MappingType.COMPLEX_TYPE) { @Override - protected ItemVisibility getVisibility(ItemPath itemPath) { + protected ItemVisibility getVisibility(ItemWrapper itemWrapper) { ItemPath assignmentConditionExpressionPath = ItemPath.create(AssignmentHolderType.F_ASSIGNMENT, AssignmentType.F_CONDITION, MappingType.F_EXPRESSION); ItemPath inducementConditionExpressionPath = ItemPath.create(AbstractRoleType.F_INDUCEMENT, AssignmentType.F_CONDITION, MappingType.F_EXPRESSION); + ItemPath itemPath = itemWrapper.getPath(); if (itemPath.namedSegmentsOnly().equivalent(assignmentConditionExpressionPath) || itemPath.namedSegmentsOnly().equivalent(inducementConditionExpressionPath)) { return ItemVisibility.AUTO; } else { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/BasicMultivalueContainerListPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/BasicMultivalueContainerListPanel.java new file mode 100644 index 00000000000..62943a73a83 --- /dev/null +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/BasicMultivalueContainerListPanel.java @@ -0,0 +1,123 @@ +/* + * Copyright (c) 2018 Evolveum and contributors + * + * This work is dual-licensed under the Apache License 2.0 + * and European Union Public License. See LICENSE file for details. + */ +package com.evolveum.midpoint.gui.impl.component; + +import com.evolveum.midpoint.gui.api.component.DisplayNamePanel; +import com.evolveum.midpoint.gui.api.component.tabs.PanelTab; +import com.evolveum.midpoint.gui.api.prism.wrapper.ItemWrapper; +import com.evolveum.midpoint.gui.api.prism.wrapper.PrismContainerValueWrapper; +import com.evolveum.midpoint.gui.api.prism.wrapper.PrismContainerWrapper; +import com.evolveum.midpoint.gui.api.util.WebComponentUtil; +import com.evolveum.midpoint.gui.impl.component.icon.CompositedIconBuilder; +import com.evolveum.midpoint.gui.impl.component.icon.IconCssStyle; +import com.evolveum.midpoint.gui.impl.factory.panel.ItemRealValueModel; +import com.evolveum.midpoint.gui.impl.prism.panel.SingleContainerPanel; +import com.evolveum.midpoint.model.api.AssignmentObjectRelation; +import com.evolveum.midpoint.prism.Containerable; +import com.evolveum.midpoint.prism.PrismContainerValue; +import com.evolveum.midpoint.prism.path.ItemPath; +import com.evolveum.midpoint.web.component.AjaxButton; +import com.evolveum.midpoint.web.component.CompositedIconButtonDto; +import com.evolveum.midpoint.web.component.data.column.CheckBoxHeaderColumn; +import com.evolveum.midpoint.web.component.menu.cog.InlineMenuItem; +import com.evolveum.midpoint.web.component.prism.ItemVisibility; +import com.evolveum.midpoint.web.component.util.VisibleBehaviour; +import com.evolveum.midpoint.web.component.util.VisibleEnableBehaviour; + +import com.evolveum.midpoint.web.model.PrismContainerWrapperModel; +import com.evolveum.midpoint.web.page.admin.reports.component.EngineReportTabPanel; +import com.evolveum.midpoint.web.session.UserProfileStorage; +import com.evolveum.midpoint.xml.ns._public.common.common_3.DisplayType; +import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectCollectionReportEngineConfigurationType; +import com.evolveum.midpoint.xml.ns._public.common.common_3.ReportType; +import com.evolveum.midpoint.xml.ns._public.common.common_3.SearchFilterParameterType; + +import org.apache.wicket.Component; +import org.apache.wicket.ajax.AjaxRequestTarget; +import org.apache.wicket.extensions.markup.html.repeater.data.table.IColumn; +import org.apache.wicket.extensions.markup.html.tabs.ITab; +import org.apache.wicket.markup.html.WebMarkupContainer; +import org.apache.wicket.markup.html.list.ListItem; +import org.apache.wicket.markup.html.list.ListView; +import org.apache.wicket.model.IModel; +import org.apache.wicket.model.Model; +import org.jetbrains.annotations.NotNull; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +/** + * @author skublik + */ + +public abstract class BasicMultivalueContainerListPanel + extends MultivalueContainerListPanelWithDetailsPanel { + + private static final long serialVersionUID = 1L; + + public BasicMultivalueContainerListPanel(String id, Class type) { + super(id, type); + } + + protected String createHeaderClassIcon(){ + return "fa fa-sliders"; + }; + + @Override + protected boolean isCreateNewObjectVisible() { + return true; + } + + @Override + protected List createNewButtonDescription() { + String title = getPageBase().createStringResource("PageAdminObjectDetails.title.new", getContainerNameForNewButton()).getString(); + DisplayType defaultButtonDisplayType = WebComponentUtil.createDisplayType("fa fa-plus", "green", title); + CompositedIconButtonDto defaultButton = new CompositedIconButtonDto(); + CompositedIconBuilder builder = new CompositedIconBuilder(); + builder.setBasicIcon(WebComponentUtil.getIconCssClass(defaultButtonDisplayType), IconCssStyle.IN_ROW_STYLE) + .appendColorHtmlValue(WebComponentUtil.getIconColor(defaultButtonDisplayType)); + + defaultButton.setAdditionalButtonDisplayType(defaultButtonDisplayType); + defaultButton.setCompositedIcon(builder.build()); + return Collections.singletonList(defaultButton); + } + + protected String getContainerNameForNewButton(){ + return ""; + } + + @Override + protected UserProfileStorage.TableId getTableId() { + return null; + } + + @Override + protected Component createHeader(String headerId) { + return new WebMarkupContainer(headerId); + } + + @Override + protected IColumn, String> createCheckboxColumn() { + return new CheckBoxHeaderColumn<>(); + } + + @Override + protected List createInlineMenu() { + return getDefaultMenuActions(); + } + + @Override + protected void newItemPerformed(AjaxRequestTarget target, AssignmentObjectRelation relationSepc) { + PrismContainerValue newParameter = getContainerModel().getObject().getItem().createNewValue(); + createNewItemContainerValueWrapper(newParameter, getContainerModel().getObject(), target); + refreshTable(target); + reloadSavePreviewButtons(target); + } + +} diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/ContainerableListPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/ContainerableListPanel.java index b4a4ebfef2d..043af036301 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/ContainerableListPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/ContainerableListPanel.java @@ -7,15 +7,16 @@ package com.evolveum.midpoint.gui.impl.component; import java.io.Serializable; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; +import java.util.*; import java.util.Objects; import java.util.stream.Collectors; import javax.xml.namespace.QName; import com.evolveum.midpoint.gui.api.util.ModelServiceLocator; +import com.evolveum.midpoint.prism.path.ItemName; +import com.evolveum.prism.xml.ns._public.query_3.OrderDirectionType; +import com.evolveum.prism.xml.ns._public.query_3.PagingType; import com.evolveum.midpoint.web.component.CompositedIconButtonDto; import org.apache.commons.collections4.CollectionUtils; @@ -26,11 +27,14 @@ import org.apache.wicket.extensions.markup.html.repeater.data.grid.ICellPopulator; import org.apache.wicket.extensions.markup.html.repeater.data.table.IColumn; import org.apache.wicket.extensions.markup.html.repeater.data.table.export.AbstractExportableColumn; +import org.apache.wicket.extensions.markup.html.repeater.util.SortParam; +import org.apache.wicket.extensions.markup.html.repeater.util.SortableDataProvider; import org.apache.wicket.markup.html.WebMarkupContainer; import org.apache.wicket.markup.html.basic.Label; import org.apache.wicket.markup.html.list.ListItem; import org.apache.wicket.markup.html.list.ListView; import org.apache.wicket.markup.html.panel.Fragment; +import org.apache.wicket.markup.repeater.RepeatingView; import org.apache.wicket.model.IModel; import org.apache.wicket.model.Model; import org.apache.wicket.model.StringResourceModel; @@ -64,6 +68,7 @@ import com.evolveum.midpoint.schema.result.OperationResult; import com.evolveum.midpoint.schema.util.MiscSchemaUtil; import com.evolveum.midpoint.schema.util.ObjectTypeUtil; +import com.evolveum.midpoint.schema.util.ObjectQueryUtil; import com.evolveum.midpoint.task.api.Task; import com.evolveum.midpoint.util.QNameUtil; import com.evolveum.midpoint.util.exception.*; @@ -103,7 +108,7 @@ public abstract class ContainerableListPanel load() { if (isCollectionViewPanel()) { - search.setCollectionSearchItem(new ObjectCollectionSearchItem(search, getObjectCollectionView())); + CompiledObjectCollectionView view = getObjectCollectionView(); + search.setCollectionSearchItem(new ObjectCollectionSearchItem(search, view)); search.setCollectionItemVisible(isCollectionViewPanelForWidget()); + if (storage != null && view.getPaging() != null) { + ObjectPaging paging = ObjectQueryUtil.convertToObjectPaging(view.getPaging(), getPrismContext()); + if (storage.getPaging() == null) { + storage.setPaging(paging); + } + if (getTableId() != null && paging.getMaxSize() != null + && !getPageBase().getSessionStorage().getUserProfile().isExistPagingSize(getTableId())) { + getPageBase().getSessionStorage().getUserProfile().setPagingSize(getTableId(), paging.getMaxSize()); + } + } } if (storage != null) { storage.setSearch(search); @@ -235,7 +251,7 @@ protected boolean isListPanelVisible() { return true; } - protected WebMarkupContainer createHeader(String headerId) { + protected Component createHeader(String headerId) { return initSearch(headerId); } @@ -243,13 +259,14 @@ protected BoxedTablePanel initItemTable() { List> columns = createColumns(); ISelectableDataProvider provider = createProvider(); + setDefaultSorting(provider); BoxedTablePanel itemTable = new BoxedTablePanel<>(ID_ITEMS_TABLE, provider, columns, getTableId()) { private static final long serialVersionUID = 1L; @Override - protected WebMarkupContainer createHeader(String headerId) { - WebMarkupContainer header = ContainerableListPanel.this.createHeader(headerId); + protected Component createHeader(String headerId) { + Component header = ContainerableListPanel.this.createHeader(headerId); header.add(new VisibleBehaviour(() -> isHeaderVisible())); return header; @@ -269,6 +286,7 @@ public String getObject() { } })); } + customProcessNewRowItem(item, model); return item; } @@ -312,6 +330,9 @@ public boolean enableSavePageSize() { return itemTable; } + protected void customProcessNewRowItem(org.apache.wicket.markup.repeater.Item item, IModel model) { + } + protected abstract UserProfileStorage.TableId getTableId(); protected boolean isHeaderVisible() { @@ -384,7 +405,12 @@ private List> createColumns() { addCustomActions(menuItems, this::getSelectedRealObjects); if (!menuItems.isEmpty()) { - InlineMenuButtonColumn actionsColumn = new InlineMenuButtonColumn<>(menuItems, getPageBase()); + InlineMenuButtonColumn actionsColumn = new InlineMenuButtonColumn<>(menuItems, getPageBase()){ + @Override + public String getCssClass() { + return "col-md-1"; + } + }; columns.add(actionsColumn); } return columns; @@ -405,6 +431,7 @@ private List> initViewColumns() { LOGGER.trace("Finished to init custom columns, created columns {}", columns); return columns; } + private void addingCheckAndIconColumnIfExists(List> columns){ IColumn checkboxColumn = createCheckboxColumn(); if (checkboxColumn != null) { @@ -430,7 +457,7 @@ protected List> getViewColumnsTransformed(List> getViewColumnsTransformed(List columnDisplayModel = createColumnDisplayModel(customColumn); if (customColumns.indexOf(customColumn) == 0) { // TODO what if a complex path is provided here? - column = createNameColumn(columnDisplayModel, customColumn.getPath() == null ? "" : customColumn.getPath().toString(), expression); + column = createNameColumn(columnDisplayModel, customColumn, customColumn.getPath() == null ? "" : customColumn.getPath().toString(), expression); } else { column = createCustomExportableColumn(columnDisplayModel, customColumn, columnPath, expression); } - - columns.add(column); + if (column != null) { + columns.add(column); + } } } return columns; @@ -477,14 +505,23 @@ private IModel createColumnDisplayModel(GuiObjectColumnType customColumn Model.of(customColumn.getName()))); } - private IColumn createCustomExportableColumn(IModel columnDisplayModel, GuiObjectColumnType customColumn, ItemPath columnPath, ExpressionType expression) { + protected IColumn createCustomExportableColumn(IModel columnDisplayModel, GuiObjectColumnType customColumn, ItemPath columnPath, ExpressionType expression) { return new AbstractExportableColumn<>(columnDisplayModel, getSortProperty(customColumn, columnPath, expression)) { private static final long serialVersionUID = 1L; @Override public void populateItem(org.apache.wicket.markup.repeater.Item> item, String componentId, IModel rowModel) { - item.add(new Label(componentId, getDataModel(rowModel))); + IModel> model = getDataModel(rowModel); + if (model != null && model.getObject() instanceof Collection){ + RepeatingView listItems = new RepeatingView(componentId); + for (Object object : (Collection)model.getObject()) { + listItems.add(new Label(listItems.newChildId(), (IModel) () -> object)); + } + item.add(listItems); + } else { + item.add(new Label(componentId, model)); + } } @Override @@ -555,21 +592,22 @@ private IModel> getExportableColumnDataModel(IModel rowModel, GuiObjectCol return new ReadOnlyModel<>(() -> loadExportableColumnDataModel(rowModel, customColumn, columnPath, expression)); } - private String loadExportableColumnDataModel(IModel rowModel, GuiObjectColumnType customColumn, ItemPath columnPath, ExpressionType expression) { + private Collection loadExportableColumnDataModel(IModel rowModel, GuiObjectColumnType customColumn, ItemPath columnPath, ExpressionType expression) { C value = getRowRealValue(rowModel.getObject()); if (value == null) { - return ""; + return Collections.singletonList(""); } Item, ?> item = findItem(value, columnPath); if (expression != null) { - return evaluateExpression(value, item, expression, customColumn); + Collection collection = evaluateExpression(value, item, expression, customColumn); + return getValuesString(collection, customColumn.getDisplayValue()); } if (item != null) { return evaluateItemValues(item, customColumn.getDisplayValue()); } - return ""; + return Collections.singletonList(""); } protected abstract C getRowRealValue(PO rowModelObject); @@ -581,7 +619,7 @@ private String loadExportableColumnDataModel(IModel rowModel, GuiObjectColum return null; } - private String evaluateExpression(C rowValue, Item, ?> columnItem, ExpressionType expression, GuiObjectColumnType customColumn) { + protected Collection evaluateExpression(C rowValue, Item, ?> columnItem, ExpressionType expression, GuiObjectColumnType customColumn) { Task task = getPageBase().createSimpleTask(OPERATION_EVALUATE_EXPRESSION); OperationResult result = task.getResult(); try { @@ -593,61 +631,94 @@ private String evaluateExpression(C rowValue, Item, ?> columnItem, ExpressionT Collection evaluatedValues = ExpressionUtil.evaluateStringExpression(variablesMap, getPageBase().getPrismContext(), expression, MiscSchemaUtil.getExpressionProfile(), getPageBase().getExpressionFactory(), "evaluate column expression", task, result); - String stringValue = null; - if (evaluatedValues != null) { - stringValue = evaluatedValues.iterator().next(); // TODO: what if more than one value is returned? - } - - return stringValue; + return evaluatedValues; } catch (Exception e) { LOGGER.error("Couldn't execute expression for {} column. Reason: {}", customColumn, e.getMessage(), e); result.recomputeStatus(); OperationResultStatusPresentationProperties props = OperationResultStatusPresentationProperties.parseOperationalResultStatus(result.getStatus()); - return getPageBase().createStringResource(props.getStatusLabelKey()).getString(); //TODO: this is not entirely correct + return Collections.singletonList(getPageBase().createStringResource(props.getStatusLabelKey()).getString()); //TODO: this is not entirely correct } } - private String evaluateItemValues(Item, ?> item, DisplayValueType displayValue) { - return getItemValuesString(item, displayValue, loadLookupTable(item)); + private List evaluateItemValues(Item, ?> item, DisplayValueType displayValue) { + return getValuesString(item, displayValue, loadLookupTable(item)); } - private String getItemValuesString(Item, ?> item, DisplayValueType displayValue, PrismObject lookupTable){ + private List getValuesString(Item, ?> item, DisplayValueType displayValue, PrismObject lookupTable){ if (DisplayValueType.NUMBER.equals(displayValue)) { + String number; //This is really ugly HACK FIXME TODO if (item.getDefinition() != null && UserType.F_LINK_REF.equivalent(item.getDefinition().getItemName())) { - return WebComponentUtil.countLinkFroNonDeadShadows((Collection) item.getRealValues()); + number = WebComponentUtil.countLinkFroNonDeadShadows((Collection) item.getRealValues()); + } else { + number = String.valueOf(item.getValues().size()); } - return String.valueOf(item.getValues().size()); + return Collections.singletonList(number); } return item.getValues().stream() .filter(Objects::nonNull) - .map(itemValue -> getStringValue(itemValue,lookupTable)) - .collect(Collectors.joining(", ")); + .map(itemValue -> getStringValue(itemValue, lookupTable)) + .collect(Collectors.toList()); } - private String getStringValue(PrismValue itemValue, PrismObject lookupTable) { - if (!(itemValue instanceof PrismPropertyValue)) { - return itemValue.toString(); + private List getValuesString(Collection collection, DisplayValueType displayValue){ + if (DisplayValueType.NUMBER.equals(displayValue)) { + return Collections.singletonList(String.valueOf(collection.size())); } - PrismPropertyValue> prismPropertyValue = (PrismPropertyValue>) itemValue; - if (lookupTable == null) { - if (isPolyString(prismPropertyValue.getTypeName())) { - return WebComponentUtil.getTranslatedPolyString((PolyString) prismPropertyValue.getValue()); - } - return String.valueOf(prismPropertyValue.getValue()); + return (List) collection.stream() + .filter(Objects::nonNull) + .map(object -> getStringValue(object, null)) + .collect(Collectors.toList()); + } + + private String getStringValue(Object object, PrismObject lookupTable) { + if (object == null) { + return ""; } - String lookupTableKey = prismPropertyValue.getValue().toString(); - LookupTableType lookupTableObject = lookupTable.asObjectable(); - String rowLabel = ""; - for (LookupTableRowType lookupTableRow : lookupTableObject.getRow()){ - if (lookupTableRow.getKey().equals(lookupTableKey)){ - return lookupTableRow.getLabel() != null ? lookupTableRow.getLabel().getOrig() : lookupTableRow.getValue(); + if (object instanceof PrismPropertyValue) { + PrismPropertyValue> prismPropertyValue = (PrismPropertyValue>) object; + if (lookupTable == null) { + if (isPolyString(prismPropertyValue.getTypeName())) { + return WebComponentUtil.getTranslatedPolyString((PolyString) prismPropertyValue.getValue()); + } + if (prismPropertyValue.getValue() instanceof Enum) { + return getPageBase().createStringResource((Enum)prismPropertyValue.getValue()).getString(); + } + return String.valueOf(prismPropertyValue.getValue()); + } + + String lookupTableKey = prismPropertyValue.getValue().toString(); + LookupTableType lookupTableObject = lookupTable.asObjectable(); + String rowLabel = ""; + for (LookupTableRowType lookupTableRow : lookupTableObject.getRow()) { + if (lookupTableRow.getKey().equals(lookupTableKey)) { + return lookupTableRow.getLabel() != null ? lookupTableRow.getLabel().getOrig() : lookupTableRow.getValue(); + } } + return rowLabel; } - return rowLabel; + if (object instanceof Enum) { + return getPageBase().createStringResource((Enum)object).getString(); + } + if (object instanceof ObjectType){ + return WebComponentUtil.getDisplayName(((ObjectType)object).asPrismObject()); + } + if (object instanceof PrismObject){ + return WebComponentUtil.getDisplayName((PrismObject) object); + } + if (object instanceof PrismObjectValue){ + return WebComponentUtil.getDisplayName(((PrismObjectValue) object).asPrismObject()); + } + if (object instanceof PrismReferenceValue) { + return WebComponentUtil.getDisplayName(((PrismReferenceValue) object).getRealValue(), true); + } + if (object instanceof ObjectReferenceType) { + return WebComponentUtil.getDisplayName(((ObjectReferenceType) object)); + } + return object.toString(); } private boolean isPolyString(QName typeName) { @@ -693,7 +764,7 @@ private List> initColumns() { if (others == null) { return columns; } else { - IColumn nameColumn = createNameColumn(null, null, null); + IColumn nameColumn = createNameColumn(null, null, null, null); if (nameColumn != null) { columns.add(nameColumn); } @@ -712,7 +783,7 @@ protected IColumn createCheckboxColumn(){ protected abstract IColumn createIconColumn(); - protected IColumn createNameColumn(IModel displayModel, String itemPath, ExpressionType expression) { + protected IColumn createNameColumn(IModel displayModel, GuiObjectColumnType customColumn, String itemPath, ExpressionType expression) { return null; } @@ -833,7 +904,7 @@ protected int getAutoRefreshInterval() { return 0; } - protected final CompiledObjectCollectionView getObjectCollectionView() { + protected CompiledObjectCollectionView getObjectCollectionView() { CompiledObjectCollectionView view = getWidgetCollectionView(); if (view != null) { return view; @@ -932,18 +1003,26 @@ protected Collection> getOptions(){ public void refreshTable(AjaxRequestTarget target) { BoxedTablePanel table = getTable(); if (searchModel.getObject().isTypeChanged()){ - table.getDataTable().getColumns().clear(); - //noinspection unchecked - table.getDataTable().getColumns().addAll(createColumns()); - ((WebMarkupContainer) table.get("box")).addOrReplace(initSearch("header")); - resetSearchModel(); - table.setCurrentPage(null); + resetTable(target); } else { saveSearchModel(getCurrentTablePaging()); } - target.add(table); - target.add(getPageBase().getFeedbackPanel()); + target.add(getFeedbackPanel()); + } + + public void resetTable(AjaxRequestTarget target) { + BoxedTablePanel table = getTable(); + table.getDataTable().getColumns().clear(); + //noinspection unchecked + table.getDataTable().getColumns().addAll(createColumns()); + ((WebMarkupContainer) table.get("box")).addOrReplace(initSearch("header")); + resetSearchModel(); + table.setCurrentPage(null); + } + + protected Component getFeedbackPanel() { + return getPageBase().getFeedbackPanel(); } public void resetSearchModel(){ @@ -1115,4 +1194,19 @@ protected void createReportPerformed(AjaxRequestTarget target) { protected GuiObjectListViewType getDefaultView() { return DefaultColumnUtils.getDefaultView(getType()); } + + protected void setDefaultSorting(ISelectableDataProvider provider){ + if (provider instanceof SortableDataProvider + && isCollectionViewPanel() && getObjectCollectionView().getPaging() != null + && getObjectCollectionView().getPaging().getOrderBy() != null) { + PagingType paging = getObjectCollectionView().getPaging(); + boolean ascending = !OrderDirectionType.DESCENDING.equals(paging.getOrderDirection()); + ItemPath orderBy = paging.getOrderBy().getItemPath(); + ItemName name = orderBy.lastName(); + if (name == null) { + return; + } + ((SortableDataProvider)provider).setSort(new SortParam(name.getLocalPart(), ascending)); + } + } } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/data/column/AbstractItemWrapperColumn.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/data/column/AbstractItemWrapperColumn.java index 7560f078232..1d77b665186 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/data/column/AbstractItemWrapperColumn.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/data/column/AbstractItemWrapperColumn.java @@ -31,7 +31,8 @@ public abstract class AbstractItemWrapperColumn> mainModel, ItemPath itemName, ColumnType columnType) { super(null); Validate.notNull(mainModel, "no model"); - Validate.notNull(mainModel.getObject(), "no ContainerWrappe from model"); + Validate.notNull(mainModel.getObject(), "no ContainerWrapper from model"); Validate.notNull(itemName, "no qName"); this.mainModel = mainModel; this.itemName = itemName; diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/data/column/AbstractItemWrapperColumnPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/data/column/AbstractItemWrapperColumnPanel.java index ba856284ce4..9b66f897748 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/data/column/AbstractItemWrapperColumnPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/data/column/AbstractItemWrapperColumnPanel.java @@ -18,6 +18,7 @@ import org.apache.wicket.markup.html.list.ListView; import org.apache.wicket.markup.html.panel.Panel; import org.apache.wicket.model.IModel; +import org.apache.wicket.model.Model; import org.apache.wicket.model.PropertyModel; import com.evolveum.midpoint.gui.api.component.BasePanel; @@ -89,10 +90,22 @@ protected void populate(ListItem item) { case VALUE: item.add(createValuePanel(ID_VALUE, getModel(), item.getModelObject())); break; + case EXISTENCE_OF_VALUE: + IModel labelModel = Model.of(""); + if (existenceOfValue(item.getModelObject())) { + labelModel = getPageBase().createStringResource("AbstractItemWrapperColumnPanel.existValue"); + } + Label existence = new Label(ID_VALUE, labelModel); + item.add(existence); + break; } } protected abstract String createLabel(VW object); protected abstract Panel createLink(String id, IModel object); protected abstract Panel createValuePanel(String id, IModel model, VW object); + protected boolean existenceOfValue(VW object) { + Object realValue = object.getRealValue(); + return realValue != null; + } } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/menu/LeftMenuPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/menu/LeftMenuPanel.java index 98fcb25e46c..8e4b3bca426 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/menu/LeftMenuPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/menu/LeftMenuPanel.java @@ -381,36 +381,11 @@ private MainMenuItem createNodesItems() { } private MainMenuItem createReportsItems() { - MainMenuItem reportsMenu = createMainMenuItem("PageAdmin.menu.top.reports", GuiStyleConstants.CLASS_REPORT_ICON); - reportsMenu.addMenuItem(new MenuItem("PageAdmin.menu.top.reports.list", GuiStyleConstants.CLASS_REPORT_ICON, PageReports.class)); - - if (WebComponentUtil.isAuthorized(AuthorizationConstants.AUTZ_UI_REPORTS_ALL_URL, AuthorizationConstants.AUTZ_GUI_ALL_URL, - AuthorizationConstants.AUTZ_UI_REPORTS_VIEW_URL)) { - - addCollectionsMenuItems(reportsMenu, ReportType.COMPLEX_TYPE, PageReports.class); - } - - if (classMatches(PageReport.class)) { - MenuItem edit = new MenuItem("PageAdmin.menu.top.reports.edit", - PageReport.class); - reportsMenu.addMenuItem(edit); - } - - if (classMatches(PageJasperReport.class)) { - MenuItem configure = new MenuItem("PageAdmin.menu.top.reports.configure", - PageJasperReport.class); - reportsMenu.addMenuItem(configure); - } - - reportsMenu.addMenuItem(new MenuItem("PageAdmin.menu.top.reports.created", PageCreatedReports.class)); - reportsMenu.addMenuItem(new MenuItem("PageAdmin.menu.top.reports.new", PageNewReport.class)); - - -// if (WebComponentUtil.isAuthorized(ModelAuthorizationAction.AUDIT_READ.getUrl())) { - reportsMenu.addMenuItem(new MenuItem("PageAuditLogViewer.menuName", PageAuditLogViewer.class)); -// } - - return reportsMenu; + MainMenuItem reportMenu = createMainMenuItem("PageAdmin.menu.top.reports", GuiStyleConstants.CLASS_REPORT_ICON); + createBasicAssignmentHolderMenuItems(reportMenu, PageTypes.REPORT); + reportMenu.addMenuItem(new MenuItem("PageAdmin.menu.top.reports.created", PageCreatedReports.class)); + reportMenu.addMenuItem(new MenuItem("PageAuditLogViewer.menuName", PageAuditLogViewer.class)); + return reportMenu; } private SideBarMenuItem createConfigurationMenu(boolean experimentalFeaturesEnabled) { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/menu/PageTypes.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/menu/PageTypes.java index a3e3669c1bf..4b7d0673129 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/menu/PageTypes.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/component/menu/PageTypes.java @@ -12,6 +12,8 @@ import com.evolveum.midpoint.web.page.admin.cases.PageCases; import com.evolveum.midpoint.web.page.admin.orgs.PageOrgUnit; import com.evolveum.midpoint.web.page.admin.orgs.PageOrgs; +import com.evolveum.midpoint.web.page.admin.reports.PageReport; +import com.evolveum.midpoint.web.page.admin.reports.PageReports; import com.evolveum.midpoint.web.page.admin.resources.PageResource; import com.evolveum.midpoint.web.page.admin.resources.PageResourceWizard; import com.evolveum.midpoint.web.page.admin.resources.PageResources; @@ -35,7 +37,8 @@ public enum PageTypes { ORG("orgs", GuiStyleConstants.CLASS_OBJECT_ORG_ICON, PageOrgs.class, PageOrgUnit.class, OrgType.COMPLEX_TYPE), TASK("tasks", GuiStyleConstants.CLASS_OBJECT_TASK_ICON, PageTasks.class, PageTask.class, TaskType.COMPLEX_TYPE), RESOURCE("resources", GuiStyleConstants.CLASS_OBJECT_RESOURCE_ICON, PageResources.class, PageResourceWizard.class, ResourceType.COMPLEX_TYPE), - CASE("cases", GuiStyleConstants.EVO_CASE_OBJECT_ICON, PageCases.class, null, CaseType.COMPLEX_TYPE); + CASE("cases", GuiStyleConstants.EVO_CASE_OBJECT_ICON, PageCases.class, null, CaseType.COMPLEX_TYPE), + REPORT("reports", GuiStyleConstants.CLASS_REPORT_ICON, PageReports .class, PageReport.class, ReportType.COMPLEX_TYPE); private String identifier; private String icon; diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/AutoCompleteReferencePanelFactory.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/AutoCompleteReferencePanelFactory.java new file mode 100644 index 00000000000..aeee61092c6 --- /dev/null +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/AutoCompleteReferencePanelFactory.java @@ -0,0 +1,73 @@ +/* + * Copyright (C) 2010-2020 Evolveum and contributors + * + * This work is dual-licensed under the Apache License 2.0 + * and European Union Public License. See LICENSE file for details. + */ +package com.evolveum.midpoint.gui.impl.factory.panel; + +import com.evolveum.midpoint.gui.api.component.autocomplete.AutoCompleteReferenceRenderer; +import com.evolveum.midpoint.gui.api.factory.GuiComponentFactory; +import com.evolveum.midpoint.gui.api.prism.wrapper.ItemWrapper; +import com.evolveum.midpoint.gui.api.prism.wrapper.PrismReferenceWrapper; +import com.evolveum.midpoint.gui.api.registry.GuiComponentRegistry; +import com.evolveum.midpoint.gui.api.util.WebComponentUtil; +import com.evolveum.midpoint.gui.impl.prism.wrapper.PrismReferenceValueWrapperImpl; +import com.evolveum.midpoint.report.api.ReportConstants; +import com.evolveum.midpoint.util.QNameUtil; +import com.evolveum.midpoint.util.exception.SchemaException; +import com.evolveum.midpoint.util.logging.Trace; +import com.evolveum.midpoint.util.logging.TraceManager; +import com.evolveum.midpoint.web.component.data.LinkedReferencePanel; +import com.evolveum.midpoint.web.component.search.ReferenceAutocomplete; +import com.evolveum.midpoint.web.component.search.ReferenceValueSearchPopupPanel; +import com.evolveum.midpoint.xml.ns._public.common.common_3.CaseType; +import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType; + +import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType; + +import org.apache.wicket.behavior.AttributeAppender; +import org.apache.wicket.model.Model; +import org.springframework.beans.factory.annotation.Autowired; +import org.springframework.stereotype.Component; + +import javax.annotation.PostConstruct; + +/** + * @author lskublik + */ +@Component +public class AutoCompleteReferencePanelFactory + implements GuiComponentFactory> { + + private static final Trace LOGGER = TraceManager.getTrace(AutoCompleteReferencePanelFactory.class); + + @Autowired private GuiComponentRegistry registry; + + @PostConstruct + public void register() { + registry.addToRegistry(this); + } + + @Override + public Integer getOrder() { + return 100; + } + + @Override + public > boolean match(IW wrapper) { + return QNameUtil.match(ObjectReferenceType.COMPLEX_TYPE, wrapper.getTypeName()) + && ReportConstants.NS_EXTENSION.equals(wrapper.getNamespace()) + && wrapper.getParent() == null; + } + + @Override + public org.apache.wicket.Component createPanel(PrismReferencePanelContext panelCtx) { + ReferenceAutocomplete panel = new ReferenceAutocomplete(panelCtx.getComponentId(), panelCtx.getRealValueModel(), + new AutoCompleteReferenceRenderer(), + panelCtx.getPageBase()); + panel.setOutputMarkupId(true); + panel.add(AttributeAppender.append("style", "padding-top:5px")); //ugly hack to be aligned with prism-property-label + return panel; + } +} diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/DropDownChoicePanelFactory.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/DropDownChoicePanelFactory.java index a2db6bf3f08..98fa8e16097 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/DropDownChoicePanelFactory.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/DropDownChoicePanelFactory.java @@ -10,6 +10,8 @@ import javax.annotation.PostConstruct; import javax.xml.namespace.QName; +import com.evolveum.midpoint.xml.ns._public.common.common_3.GuiObjectListViewType; + import org.apache.wicket.model.Model; import org.springframework.stereotype.Component; @@ -44,9 +46,10 @@ protected InputPanel getPanel(PrismPropertyPanelContext panelCtx) { List typesList; if (AssignmentType.F_FOCUS_TYPE.equals(panelCtx.getDefinitionName())) { typesList = WebComponentUtil.createFocusTypeList(); - } else if (ObjectCollectionType.F_TYPE.equals(panelCtx.getDefinitionName()) && - panelCtx.unwrapWrapperModel().getParent().getDefinition() != null && - ObjectCollectionType.class.equals(panelCtx.unwrapWrapperModel().getParent().getDefinition().getTypeClass())) { + } else if ((ObjectCollectionType.F_TYPE.equals(panelCtx.getDefinitionName()) || GuiObjectListViewType.F_TYPE.equals(panelCtx.getDefinitionName())) + && panelCtx.unwrapWrapperModel().getParent().getDefinition() != null && + (ObjectCollectionType.class.equals(panelCtx.unwrapWrapperModel().getParent().getDefinition().getTypeClass()) + || GuiObjectListViewType.class.equals(panelCtx.unwrapWrapperModel().getParent().getDefinition().getTypeClass()))) { typesList = WebComponentUtil.createContainerableTypesQnameList(); } else { typesList = WebComponentUtil.createObjectTypeList(); diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/ParameterTypePanelFactory.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/ParameterTypePanelFactory.java new file mode 100644 index 00000000000..127a24b95bc --- /dev/null +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/ParameterTypePanelFactory.java @@ -0,0 +1,86 @@ +/* + * Copyright (C) 2010-2020 Evolveum and contributors + * + * This work is dual-licensed under the Apache License 2.0 + * and European Union Public License. See LICENSE file for details. + */ +package com.evolveum.midpoint.gui.impl.factory.panel; + +import java.io.Serializable; +import java.util.List; +import javax.annotation.PostConstruct; +import javax.xml.namespace.QName; + +import com.evolveum.midpoint.util.QNameUtil; +import com.evolveum.midpoint.web.component.input.TextPanel; +import com.evolveum.midpoint.xml.ns._public.common.common_3.*; + +import org.apache.commons.lang3.StringUtils; +import org.apache.wicket.model.IModel; +import org.apache.wicket.model.Model; +import org.springframework.stereotype.Component; + +import com.evolveum.midpoint.gui.api.prism.wrapper.ItemWrapper; +import com.evolveum.midpoint.gui.api.util.WebComponentUtil; +import com.evolveum.midpoint.util.DOMUtil; +import com.evolveum.midpoint.web.component.input.DropDownChoicePanel; +import com.evolveum.midpoint.web.component.input.QNameObjectTypeChoiceRenderer; +import com.evolveum.midpoint.web.component.prism.InputPanel; +import com.evolveum.midpoint.web.page.admin.configuration.component.EmptyOnChangeAjaxFormUpdatingBehavior; + +/** + * @author katkav + */ +@Component +public class ParameterTypePanelFactory extends DropDownChoicePanelFactory implements Serializable { + + @Override + public > boolean match(IW wrapper) { + return DOMUtil.XSD_QNAME.equals(wrapper.getTypeName()) + && SearchFilterParameterType.F_TYPE.equals(wrapper.getItemName()) + && wrapper.getParent().getDefinition() != null + && ParameterType.class.isAssignableFrom(wrapper.getParent().getDefinition().getTypeClass()); + } + + @Override + protected InputPanel getPanel(PrismPropertyPanelContext panelCtx) { + IModel qNameModel = new IModel() { + @Override + public String getObject() { + if (panelCtx.getRealValueModel().getObject() != null) { + return panelCtx.getRealValueModel().getObject().getLocalPart(); + } + return null; + } + + @Override + public void setObject(String object) { + if (StringUtils.isNotEmpty(object)){ + QName objectQName = getQName(object); + if (!QNameUtil.match(objectQName, panelCtx.getRealValueModel().getObject())) { + panelCtx.getRealValueModel().setObject(objectQName); + } + } else { + panelCtx.getRealValueModel().setObject(null); + } + } + }; + return new TextPanel(panelCtx.getComponentId(), qNameModel, String.class, false); + } + + private QName getQName(String object){ + if (QNameUtil.match(ObjectReferenceType.COMPLEX_TYPE, new QName(object))) { + return ObjectReferenceType.COMPLEX_TYPE; + } + if (QNameUtil.isUriQName(object)) { + return QNameUtil.uriToQName(object); + } + return new QName(object); + } + + @Override + public Integer getOrder() { + return 9000; + } + +} diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/PrismPropertyPanelContext.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/PrismPropertyPanelContext.java index 2f47d5b5cef..b88d355f427 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/PrismPropertyPanelContext.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/PrismPropertyPanelContext.java @@ -8,9 +8,11 @@ import com.evolveum.midpoint.gui.api.model.ReadOnlyModel; import com.evolveum.midpoint.gui.api.prism.wrapper.PrismPropertyWrapper; +import com.evolveum.midpoint.util.DisplayableValue; import com.evolveum.midpoint.xml.ns._public.common.common_3.LookupTableType; import org.apache.wicket.model.IModel; -import org.apache.wicket.model.StringResourceModel; + +import java.util.Collection; /** * @author katka @@ -27,6 +29,10 @@ public LookupTableType getPredefinedValues() { return unwrapWrapperModel().getPredefinedValues(); } + public Collection extends DisplayableValue> getAllowedValues() { + return unwrapWrapperModel().getAllowedValues(); + } + public boolean hasValueEnumerationRef() { return unwrapWrapperModel().getValueEnumerationRef() != null; } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/TextPanelFactory.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/TextPanelFactory.java index eee4d69107d..109bd26ddb2 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/TextPanelFactory.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/factory/panel/TextPanelFactory.java @@ -7,11 +7,24 @@ package com.evolveum.midpoint.gui.impl.factory.panel; import java.io.Serializable; +import java.util.ArrayList; +import java.util.Collection; import java.util.Iterator; import java.util.List; +import java.util.stream.Collectors; import javax.annotation.PostConstruct; import javax.xml.namespace.QName; +import com.evolveum.midpoint.util.DisplayableValue; + +import com.evolveum.midpoint.web.component.search.FilterSearchItem; +import com.evolveum.midpoint.web.page.admin.configuration.component.EmptyOnChangeAjaxFormUpdatingBehavior; + +import org.apache.commons.collections4.CollectionUtils; +import org.apache.wicket.ajax.AjaxRequestTarget; +import org.apache.wicket.model.IModel; +import org.apache.wicket.model.Model; +import org.apache.wicket.model.PropertyModel; import org.springframework.stereotype.Component; import com.evolveum.midpoint.common.LocalizationService; @@ -43,21 +56,44 @@ public void register() { @Override protected InputPanel getPanel(PrismPropertyPanelContext panelCtx) { LookupTableType lookupTable = panelCtx.getPredefinedValues(); - if (lookupTable == null) { - return new TextPanel<>(panelCtx.getComponentId(), - panelCtx.getRealValueModel(), panelCtx.getTypeClass(), false); + if (lookupTable != null) { + return new AutoCompleteTextPanel(panelCtx.getComponentId(), + panelCtx.getRealValueModel(), panelCtx.getTypeClass(), panelCtx.hasValueEnumerationRef(), lookupTable) { + + private static final long serialVersionUID = 1L; + + @Override + public Iterator getIterator(String input) { + return (Iterator) prepareAutoCompleteList(input, lookupTable, panelCtx.getPageBase().getLocalizationService()).iterator(); + } + }; } - return new AutoCompleteTextPanel(panelCtx.getComponentId(), - panelCtx.getRealValueModel(), panelCtx.getTypeClass(), panelCtx.hasValueEnumerationRef(), lookupTable) { + Collection extends DisplayableValue> allowedValues = panelCtx.getAllowedValues(); + if (CollectionUtils.isNotEmpty(allowedValues)) { + IModel>> choices = Model.ofList(allowedValues.stream().collect(Collectors.toCollection(ArrayList::new))); + IModel convertModel = new IModel>(){ + @Override + public DisplayableValue getObject() { + Object value = panelCtx.getRealValueModel().getObject(); + for (DisplayableValue dispValue : choices.getObject()) { + if (dispValue.getValue().equals(value)) { + return dispValue; + } + } + return null; + } - private static final long serialVersionUID = 1L; + @Override + public void setObject(DisplayableValue object) { + panelCtx.getRealValueModel().setObject(object.getValue()); + } + }; + return WebComponentUtil.createDropDownChoices(panelCtx.getComponentId(), convertModel, choices, true, panelCtx.getPageBase()); + } - @Override - public Iterator getIterator(String input) { - return (Iterator) prepareAutoCompleteList(input, lookupTable, panelCtx.getPageBase().getLocalizationService()).iterator(); - } - }; + return new TextPanel<>(panelCtx.getComponentId(), + panelCtx.getRealValueModel(), panelCtx.getTypeClass(), false); } protected List prepareAutoCompleteList(String input, LookupTableType lookupTable, LocalizationService localizationService) { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/model/JasperTemplateModel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/model/JasperTemplateModel.java deleted file mode 100644 index 47695d2bb5d..00000000000 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/model/JasperTemplateModel.java +++ /dev/null @@ -1,57 +0,0 @@ -/* - * Copyright (c) 2010-2019 Evolveum and contributors - * - * This work is dual-licensed under the Apache License 2.0 - * and European Union Public License. See LICENSE file for details. - */ - -package com.evolveum.midpoint.gui.impl.model; - -import com.evolveum.midpoint.util.exception.SystemException; - -import org.apache.commons.codec.binary.Base64; -import org.apache.wicket.model.IModel; - -import java.nio.charset.StandardCharsets; - -/** - * @author skublik - */ -public class JasperTemplateModel implements IModel { - - private IModel model; - - public JasperTemplateModel(IModel model) { - this.model = model; - } - - @Override - public String getObject() { - if (model.getObject() == null) { - return null; - } - byte[] obj; - if (Base64.isBase64(model.getObject())) { - obj = Base64.decodeBase64(model.getObject()); - } else { - obj = model.getObject(); - } - - return new String(obj, StandardCharsets.UTF_8); - } - - @Override - public void setObject(String object) { - if (object == null) { - model.setObject(null); - return; - } - - byte[] val = object.getBytes(StandardCharsets.UTF_8); - model.setObject(val); - } - - @Override - public void detach() { - } -} diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismContainerPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismContainerPanel.java index c9068926551..451275ecff2 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismContainerPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismContainerPanel.java @@ -78,7 +78,7 @@ protected Component createValuePanel(ListItem> ite PrismContainerValuePanel> panel = new PrismContainerValuePanel>("value", item.getModel(), settings) { @Override - protected void removeValue(PrismContainerValueWrapper valueToRemove, AjaxRequestTarget target) throws SchemaException { + protected void remove(PrismContainerValueWrapper valueToRemove, AjaxRequestTarget target) throws SchemaException { PrismContainerPanel.this.removeValue(valueToRemove, target); } }; diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismContainerValuePanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismContainerValuePanel.java index 79f2226eb27..349187095b3 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismContainerValuePanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismContainerValuePanel.java @@ -283,7 +283,7 @@ public boolean isOn() { } @Override - protected void removeValue(CVW valueToRemove, AjaxRequestTarget target) throws SchemaException { + protected void remove(CVW valueToRemove, AjaxRequestTarget target) throws SchemaException { throw new UnsupportedOperationException("Must be implemented in calling panel"); } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismPropertyPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismPropertyPanel.java index 94b14552588..5929211a7f1 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismPropertyPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismPropertyPanel.java @@ -53,8 +53,8 @@ protected Component createValuePanel(ListItem> item PrismPropertyValuePanel panel = new PrismPropertyValuePanel("value", item.getModel(), getSettings()) { @Override - protected void removeValue(PrismPropertyValueWrapper valueToRemove, AjaxRequestTarget target) throws SchemaException { - PrismPropertyPanel.this.removeValue(valueToRemove, target); + protected void remove(PrismPropertyValueWrapper valueToRemove, AjaxRequestTarget target) throws SchemaException { + removeValue(valueToRemove, target); } }; item.add(panel); diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismPropertyValuePanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismPropertyValuePanel.java index df83520838f..c90f502710f 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismPropertyValuePanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismPropertyValuePanel.java @@ -51,7 +51,7 @@ protected PV createNewValue(PrismPropertyWrapper item } @Override - protected void removeValue(PrismPropertyValueWrapper valueToRemove, AjaxRequestTarget target) throws SchemaException { + protected void remove(PrismPropertyValueWrapper valueToRemove, AjaxRequestTarget target) throws SchemaException { throw new UnsupportedOperationException("Must be implemented in calling panel"); } } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismReferencePanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismReferencePanel.java index 6a6578347f4..18ea1ed1697 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismReferencePanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismReferencePanel.java @@ -47,7 +47,7 @@ protected void refreshPanel(AjaxRequestTarget target) { protected Component createValuePanel(ListItem> item) { PrismReferenceValuePanel valuePanel = new PrismReferenceValuePanel(ID_VALUE, item.getModel(), getSettings()) { @Override - protected void removeValue( + protected void remove( PrismReferenceValueWrapperImpl valueToRemove, AjaxRequestTarget target) throws SchemaException { PrismReferencePanel.this.removeValue(valueToRemove, target); diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismReferenceValuePanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismReferenceValuePanel.java index d048965fd10..87588775e4d 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismReferenceValuePanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismReferenceValuePanel.java @@ -118,7 +118,7 @@ private PrismReferenceWrapper getParentWrapper() { } @Override - protected void removeValue(PrismReferenceValueWrapperImpl valueToRemove, AjaxRequestTarget target) throws SchemaException { + protected void remove(PrismReferenceValueWrapperImpl valueToRemove, AjaxRequestTarget target) throws SchemaException { throw new UnsupportedOperationException("Must be implemented in calling panel"); } } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismValuePanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismValuePanel.java index 76f0ea2a8ea..79d2923a491 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismValuePanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/PrismValuePanel.java @@ -87,7 +87,7 @@ private WebMarkupContainer createHeaderPanel() { @Override public void onClick(AjaxRequestTarget target) { try { - removeValue(PrismValuePanel.this.getModelObject(), target); + PrismValuePanel.this.remove(PrismValuePanel.this.getModelObject(), target); } catch (SchemaException e) { LOGGER.error("Cannot remove value: {}", getModelObject()); getSession().error("Cannot remove value " + getModelObject()); @@ -272,7 +272,7 @@ private O getObject() { protected abstract PV createNewValue(IW itemWrapper); //TODO move to the ItemPanel, exception handling - protected abstract void removeValue(VW valueToRemove, AjaxRequestTarget target) throws SchemaException; + protected abstract void remove(VW valueToRemove, AjaxRequestTarget target) throws SchemaException; private void showMetadataPerformed(VW value, AjaxRequestTarget target) { boolean showMetadata = !value.isShowMetadata(); diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/SingleContainerPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/SingleContainerPanel.java index 53b086acd2d..a5bd4205a9f 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/SingleContainerPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/SingleContainerPanel.java @@ -9,6 +9,8 @@ import javax.xml.namespace.QName; +import com.evolveum.midpoint.gui.api.prism.wrapper.ItemWrapper; + import org.apache.wicket.markup.html.panel.Panel; import org.apache.wicket.model.IModel; @@ -45,7 +47,7 @@ private void initLayout() { try { ItemPanelSettingsBuilder builder = new ItemPanelSettingsBuilder() - .visibilityHandler(wrapper -> getVisibility(wrapper.getPath())) + .visibilityHandler(wrapper -> getVisibility(wrapper)) .editabilityHandler(getEditabilityHandler()) .mandatoryHandler(getMandatoryHandler()); Panel panel = getPageBase().initItemPanel(ID_CONTAINER, getTypeName(), getModel(), builder.build()); @@ -62,7 +64,7 @@ protected QName getTypeName() { return typeName; } - protected ItemVisibility getVisibility(ItemPath itemPath) { + protected ItemVisibility getVisibility(ItemWrapper itemWrapper) { return ItemVisibility.AUTO; } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/ValueMetadataPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/ValueMetadataPanel.java index 0b5abd8f78c..ce0625cfe85 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/ValueMetadataPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/gui/impl/prism/panel/ValueMetadataPanel.java @@ -84,7 +84,7 @@ protected PV createNewValue(PrismContainerWrapper ite } @Override - protected void removeValue(CVW valueToRemove, AjaxRequestTarget target) { + protected void remove(CVW valueToRemove, AjaxRequestTarget target) { } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/init/InitialDataImport.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/init/InitialDataImport.java index 9af2c76d0ea..77bc05f795c 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/init/InitialDataImport.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/init/InitialDataImport.java @@ -28,7 +28,6 @@ import com.evolveum.midpoint.schema.SelectorOptions; import com.evolveum.midpoint.schema.constants.SchemaConstants; import com.evolveum.midpoint.schema.result.OperationResult; -import com.evolveum.midpoint.schema.util.ReportTypeUtil; import com.evolveum.midpoint.task.api.Task; import com.evolveum.midpoint.util.MiscUtil; import com.evolveum.midpoint.util.exception.ObjectNotFoundException; @@ -37,7 +36,6 @@ import com.evolveum.midpoint.util.logging.Trace; import com.evolveum.midpoint.util.logging.TraceManager; import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType; -import com.evolveum.midpoint.xml.ns._public.common.common_3.ReportType; /** * Imports initial data objects as needed, ignoring already imported objects. @@ -103,10 +101,6 @@ private ImportResult importInitialObjectsResource( String objectText = IOUtils.toString(resourceInputStream, StandardCharsets.UTF_8); object = prismContext.parseObject(objectText); } - if (ReportType.class.equals(object.getCompileTimeClass())) { - //noinspection unchecked - ReportTypeUtil.applyDefinition((PrismObject) object, prismContext); - } return importObject(object, resource.getFilename(), task, mainResult, overwrite); } catch (Exception ex) { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/data/BaseSearchDataProvider.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/data/BaseSearchDataProvider.java index bc8b44d36d3..fe8e249d808 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/data/BaseSearchDataProvider.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/data/BaseSearchDataProvider.java @@ -49,6 +49,10 @@ IModel> getSearchModel() { @Override public ObjectQuery getQuery() { + return search.getObject() == null ? null : search.getObject().createObjectQuery(getVariables(), getPageBase(), getCustomizeContentQuery()); + } + + protected VariablesMap getVariables() { VariablesMap expVariables = new VariablesMap(); for (Map.Entry entry : variables.entrySet()) { if (entry.getValue() == null) { @@ -57,7 +61,7 @@ public ObjectQuery getQuery() { expVariables.put(entry.getKey(), entry.getValue(), entry.getValue().getClass()); } } - return search.getObject() == null ? null : search.getObject().createObjectQuery(expVariables.isEmpty() ? null : expVariables, getPageBase(), getCustomizeContentQuery()); + return expVariables.isEmpty() ? null : expVariables; } protected ObjectQuery getCustomizeContentQuery() { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/data/BoxedTablePanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/data/BoxedTablePanel.java index d7c85361d03..86443a8f18b 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/data/BoxedTablePanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/data/BoxedTablePanel.java @@ -228,7 +228,7 @@ public WebMarkupContainer getFooter() { return (WebMarkupContainer) get(ID_BOX).get(ID_FOOTER); } - protected WebMarkupContainer createHeader(String headerId) { + protected Component createHeader(String headerId) { WebMarkupContainer header = new WebMarkupContainer(headerId); header.setVisible(false); return header; diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/AbstractSearchItemPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/AbstractSearchItemPanel.java index 535e1b69a57..cb1cd20b1d6 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/AbstractSearchItemPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/AbstractSearchItemPanel.java @@ -157,30 +157,6 @@ protected IModel>> createBooleanChoices() { return Model.ofList(list); } - protected DropDownChoicePanel createDropDownChoices(String id, IModel model, IModel>> choices, boolean allowNull) { - return new DropDownChoicePanel(id, model, choices, new IChoiceRenderer() { - private static final long serialVersionUID = 1L; - - @Override - public Object getDisplayValue(DisplayableValue val) { - if (val.getValue() instanceof Enum) { - return getPageBase().createStringResource((Enum>) val.getValue()).getString(); - } - return getPageBase().createStringResource(val.getLabel()).getString(); - } - - @Override - public String getIdValue(DisplayableValue val, int index) { - return Integer.toString(index); - } - - @Override - public DisplayableValue getObject(String id, IModel extends List extends DisplayableValue>> choices) { - return StringUtils.isNotBlank(id) ? choices.getObject().get(Integer.parseInt(id)) : null; - } - }, allowNull); - } - protected AutoCompleteTextPanel createAutoCompetePanel(String id, IModel model, LookupTableType lookupTable) { AutoCompleteTextPanel autoCompletePanel = new AutoCompleteTextPanel(id, model, String.class, true, lookupTable) { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/FilterSearchItem.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/FilterSearchItem.java index 779c097c487..9a0432fbf46 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/FilterSearchItem.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/FilterSearchItem.java @@ -7,6 +7,7 @@ package com.evolveum.midpoint.web.component.search; import java.io.Serializable; +import java.util.Collections; import java.util.List; import org.apache.commons.collections4.CollectionUtils; @@ -131,48 +132,17 @@ public List> getAllowedValues(PageBase pageBase) { if (allowedValues != null) { return allowedValues; } - - if (predefinedFilter == null || predefinedFilter.getParameter() == null - || predefinedFilter.getParameter().getAllowedValuesExpression() == null) { - return null; - } - Task task = pageBase.createSimpleTask("evaluate expression for allowed values"); - ExpressionType expression = predefinedFilter.getParameter().getAllowedValuesExpression(); - Object value = null; - try { - - value = ExpressionUtil.evaluateExpression(new VariablesMap(), null, - expression, MiscSchemaUtil.getExpressionProfile(), - pageBase.getExpressionFactory(), "evaluate expression for allowed values", task, task.getResult()); - } catch (Exception e) { - LOGGER.error("Couldn't execute expression " + expression, e); - pageBase.error(pageBase.createStringResource("FilterSearchItem.message.error.evaluateAllowedValuesExpression", expression).getString()); - return null; - } - if (value instanceof PrismPropertyValue) { - value = ((PrismPropertyValue) value).getRealValue(); - } - - if (!(value instanceof List)) { - LOGGER.error("Exception return unexpected type, expected List, but was " + (value == null ? null : value.getClass())); - pageBase.error(pageBase.createStringResource("FilterSearchItem.message.error.wrongType", expression).getString()); - return null; - } - - if (!((List>) value).isEmpty()) { - if (!(((List>) value).get(0) instanceof DisplayableValue)) { - LOGGER.error("Exception return unexpected type, expected List, but was " + (value == null ? null : value.getClass())); - pageBase.error(pageBase.createStringResource("FilterSearchItem.message.error.wrongType", expression).getString()); - return null; - } + if (predefinedFilter == null) { + return Collections.EMPTY_LIST; } - this.allowedValues = (List>) value; - return (List>) value; + List> values = WebComponentUtil.getAllowedValues(predefinedFilter.getParameter(), pageBase); + return values; } public LookupTableType getLookupTable(PageBase pageBase) { if (predefinedFilter != null && predefinedFilter.getParameter() != null - && predefinedFilter.getParameter().getAllowedValuesLookupTable() != null) { + && predefinedFilter.getParameter().getAllowedValuesLookupTable() != null + && predefinedFilter.getParameter().getAllowedValuesLookupTable().getOid() != null) { PrismObject lokupTable = WebComponentUtil.findLookupTable(predefinedFilter.getParameter().getAllowedValuesLookupTable().asReferenceValue(), pageBase); if (lokupTable != null) { return lokupTable.asObjectable(); diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceAutocomplete.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceAutocomplete.java index 04ec0521258..d81662e78f0 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceAutocomplete.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceAutocomplete.java @@ -11,6 +11,7 @@ import java.util.Iterator; import java.util.List; +import com.evolveum.midpoint.gui.api.util.WebComponentUtil; import com.evolveum.midpoint.xml.ns._public.common.common_3.ResourceType; import org.apache.commons.lang3.StringUtils; @@ -36,14 +37,16 @@ /** * @author honchar */ -public abstract class ReferenceAutocomplete extends AutoCompleteTextPanel { +public class ReferenceAutocomplete extends AutoCompleteTextPanel { private static final long serialVersionUID = 1L; private final PageBase pageBase; + private final IModel model; public ReferenceAutocomplete(String id, final IModel model, IAutoCompleteRenderer renderer, PageBase pageBase) { super(id, model, ObjectReferenceType.class, renderer); this.pageBase = pageBase; + this.model = model; } @Override @@ -82,7 +85,10 @@ protected boolean isAllowedNotFoundObjectRef() { } protected Class getReferenceTargetObjectType(){ - return (Class) AbstractRoleType.class; + if (model.getObject() == null || model.getObject().getType() == null) { + return (Class) ObjectType.class; + } + return (Class) WebComponentUtil.qnameToClass(pageBase.getPrismContext(), model.getObject().getType()); } protected int getMaxRowsCount() { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceValueSearchPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceValueSearchPanel.java index 91e418e9c68..fbd73726e83 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceValueSearchPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceValueSearchPanel.java @@ -6,9 +6,12 @@ */ package com.evolveum.midpoint.web.component.search; +import java.util.Collections; import java.util.List; import javax.xml.namespace.QName; +import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectType; + import org.apache.wicket.ajax.AjaxRequestTarget; import org.apache.wicket.model.IModel; @@ -46,7 +49,10 @@ protected List getAllowedRelations() { @Override protected List getSupportedTargetList() { - return WebComponentUtil.createSupportedTargetTypeList((referenceDef).getTargetTypeName()); + if (referenceDef != null) { + return WebComponentUtil.createSupportedTargetTypeList(referenceDef.getTargetTypeName()); + } + return Collections.singletonList(ObjectType.COMPLEX_TYPE); } @Override diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceValueSearchPopupPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceValueSearchPopupPanel.java index e1367088571..fbcad782935 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceValueSearchPopupPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/ReferenceValueSearchPopupPanel.java @@ -28,6 +28,7 @@ import org.apache.wicket.ajax.AjaxRequestTarget; import org.apache.wicket.ajax.form.AjaxFormComponentUpdatingBehavior; import org.apache.wicket.feedback.ComponentFeedbackMessageFilter; +import org.apache.wicket.markup.html.WebMarkupContainer; import org.apache.wicket.markup.html.form.TextField; import org.apache.wicket.model.IModel; import org.apache.wicket.model.Model; @@ -86,14 +87,6 @@ public void setObject(String object) { private static final long serialVersionUID = 1L; - @Override - protected Class getReferenceTargetObjectType() { - if (getModelObject().getType() == null) { - return (Class) ObjectType.class; - } - return (Class) WebComponentUtil.qnameToClass(getPageBase().getPrismContext(), getModelObject().getType()); - } - @Override protected boolean isAllowedNotFoundObjectRef() { return ReferenceValueSearchPopupPanel.this.isAllowedNotFoundObjectRef(); @@ -188,6 +181,7 @@ protected void onSelectPerformed(AjaxRequestTarget target, O object) { getPageBase().showMainPopup(objectBrowserPanel, target); } }; + selectObject.add(new VisibleBehaviour(() -> getPageBase().getMainPopup() instanceof WebMarkupContainer)); midpointForm.add(selectObject); } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/Search.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/Search.java index f0aa95cba97..47473ae364a 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/Search.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/Search.java @@ -266,6 +266,16 @@ public SearchItem addItem(SearchItemType predefinedFilter) { FilterSearchItem item = new FilterSearchItem(this, predefinedFilter); item.setDefinition(def); + if (predefinedFilter != null && predefinedFilter.getParameter() != null + && QNameUtil.match(predefinedFilter.getParameter().getType(), ObjectReferenceType.COMPLEX_TYPE)) { + ObjectReferenceType ref = new ObjectReferenceType(); + List supportedTargets = WebComponentUtil.createSupportedTargetTypeList(predefinedFilter.getParameter().getTargetType()); + if (supportedTargets.size() == 1) { + ref.setType(supportedTargets.iterator().next()); + } + item.setInput(new SearchValue<>(ref)); + } + items.add(item); availableDefinitions.remove(def); return item; @@ -438,15 +448,7 @@ private ObjectQuery createObjectQuerySimple(VariablesMap defaultVariables, PageB } } - VariablesMap variables = defaultVariables == null ? new VariablesMap() : defaultVariables; - for (FilterSearchItem item : getFilterItems()) { - SearchFilterParameterType functionParameter = item.getPredefinedFilter().getParameter(); - if (functionParameter != null && functionParameter.getType() != null) { - Class> inputClass = pageBase.getPrismContext().getSchemaRegistry().determineClassForType(functionParameter.getType()); - TypedValue value = new TypedValue(item.getInput() != null ? item.getInput().getValue() : null, inputClass); - variables.put(functionParameter.getName(), value); - } - } + VariablesMap variables = getFilterVariables(defaultVariables, pageBase); for (FilterSearchItem item : getFilterItems()) { if (item.isEnabled() && item.isApplyFilter()) { @@ -500,6 +502,19 @@ private ObjectQuery createObjectQuerySimple(VariablesMap defaultVariables, PageB return query; } + public VariablesMap getFilterVariables(VariablesMap defaultVariables, PageBase pageBase) { + VariablesMap variables = defaultVariables == null ? new VariablesMap() : defaultVariables; + for (FilterSearchItem item : getFilterItems()) { + SearchFilterParameterType functionParameter = item.getPredefinedFilter().getParameter(); + if (functionParameter != null && functionParameter.getType() != null) { + Class> inputClass = pageBase.getPrismContext().getSchemaRegistry().determineClassForType(functionParameter.getType()); + TypedValue value = new TypedValue(item.getInput() != null ? item.getInput().getValue() : null, inputClass); + variables.put(functionParameter.getName(), value); + } + } + return variables; + } + private ObjectFilter createFilterForSearchItem(PropertySearchItem item, PrismContext ctx) { if (!(item instanceof DateSearchItem) && (item.getValue() == null || item.getValue().getValue() == null)) { return null; diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchFactory.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchFactory.java index ccc9c5121c1..ff15c3039c7 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchFactory.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchFactory.java @@ -238,7 +238,7 @@ public static Search createSearch( panelType, false ); } - public static Search createSearch( + private static Search createSearch( ContainerTypeSearchItem type, String collectionViewName, List fixedSearchItems, ResourceShadowDiscriminator discriminator, ModelServiceLocator modelServiceLocator, List availableItemPath, boolean useDefsFromSuperclass, boolean useObjectCollection, Search.PanelType panelType, boolean isOidSearchEnabled) { @@ -283,7 +283,38 @@ public static Search createSearch( return search; } - public static void processSearchItemDefFromCompiledView(List configuredSearchItemDefs, Search search, PrismContainerDefinition containerDef) { + public static Search createSearchForReport(Class type, List parameters, ModelServiceLocator modelServiceLocator) { + ContainerTypeSearchItem typeItem = new ContainerTypeSearchItem<>(new SearchValue<>(type, "")); + Search search = new Search(typeItem, new ArrayList<>(), false, SearchBoxModeType.BASIC, Collections.singletonList(SearchBoxModeType.BASIC), false); + + SchemaRegistry registry = modelServiceLocator.getPrismContext().getSchemaRegistry(); + PrismContainerDefinition objDef = registry.findContainerDefinitionByCompileTimeClass(type); + + final List configuredSearchItemDefs = new ArrayList<>(); + parameters.forEach(parameter -> { + SearchItemType searchItemType = new SearchItemType(); + searchItemType.setParameter(parameter); + searchItemType.setVisibleByDefault(true); + if (parameter.getDisplay() != null) { + if (parameter.getDisplay().getLabel() != null) { + searchItemType.setDisplayName(parameter.getDisplay().getLabel()); + } else { + searchItemType.setDisplayName(new PolyStringType(parameter.getName())); + } + if (parameter.getDisplay().getHelp() != null) { + searchItemType.setDescription( + modelServiceLocator.getLocalizationService().translate(parameter.getDisplay().getHelp().toPolyString())); + } + } + configuredSearchItemDefs.add(new SearchItemDefinition(searchItemType)); + return; + }); + processSearchItemDefFromCompiledView(configuredSearchItemDefs, search, objDef); + search.setCanConfigure(false); + return search; + } + + private static void processSearchItemDefFromCompiledView(List configuredSearchItemDefs, Search search, PrismContainerDefinition containerDef) { configuredSearchItemDefs.forEach(searchItemDef -> { search.addItemToAllDefinitions(searchItemDef); if (searchItemDef.isVisibleByDefault()) { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchFilterPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchFilterPanel.java index b03ae95109a..41105383128 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchFilterPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchFilterPanel.java @@ -8,10 +8,15 @@ import com.evolveum.midpoint.gui.api.component.autocomplete.AutoCompleteTextPanel; import com.evolveum.midpoint.gui.api.util.WebComponentUtil; +import com.evolveum.midpoint.prism.MutableItemDefinition; +import com.evolveum.midpoint.prism.MutablePrismReferenceDefinition; +import com.evolveum.midpoint.prism.Referencable; +import com.evolveum.midpoint.report.api.ReportConstants; import com.evolveum.midpoint.util.DisplayableValue; import com.evolveum.midpoint.web.component.input.CheckPanel; import com.evolveum.midpoint.web.component.input.TextPanel; import com.evolveum.midpoint.web.component.prism.InputPanel; +import com.evolveum.midpoint.web.component.util.VisibleBehaviour; import com.evolveum.midpoint.web.page.admin.configuration.component.EmptyOnBlurAjaxFormUpdatingBehaviour; import com.evolveum.midpoint.web.page.admin.configuration.component.EmptyOnChangeAjaxFormUpdatingBehavior; @@ -19,6 +24,8 @@ import com.evolveum.midpoint.xml.ns._public.common.common_3.ObjectReferenceType; import com.evolveum.midpoint.xml.ns._public.common.common_3.ParameterType; +import com.evolveum.midpoint.xml.ns._public.common.common_3.SearchFilterParameterType; + import org.apache.commons.collections4.CollectionUtils; import org.apache.commons.lang3.Validate; import org.apache.wicket.Component; @@ -59,6 +66,7 @@ protected void onUpdate(AjaxRequestTarget ajaxRequestTarget) { } }); checkPanel.getBaseFormComponent().add(new EmptyOnBlurAjaxFormUpdatingBehaviour()); + checkPanel.add(new VisibleBehaviour(() -> canRemoveSearchItem())); checkPanel.setOutputMarkupId(true); searchItemContainer.add(checkPanel); @@ -75,10 +83,18 @@ protected void onUpdate(AjaxRequestTarget ajaxRequestTarget) { IModel>> choices = null; switch (inputType) { case REFERENCE: - getModelObject().setInput(new SearchValue<>(new ObjectReferenceType())); + SearchFilterParameterType parameter = getModelObject().getPredefinedFilter().getParameter(); + MutablePrismReferenceDefinition def = null; + if (parameter != null) { + Class> clazz = getPrismContext().getSchemaRegistry().determineClassForType(parameter.getType()); + QName type = getPrismContext().getSchemaRegistry().determineTypeForClass(clazz); + def = getPrismContext().definitionFactory().createReferenceDefinition( + new QName(parameter.getName()), type); + def.setTargetTypeName(parameter.getTargetType()); + } inputPanel = new ReferenceValueSearchPanel(ID_SEARCH_ITEM_FIELD, new PropertyModel<>(getModel(), FilterSearchItem.F_INPUT_VALUE), - null){ + def){ @Override protected void referenceValueUpdated(ObjectReferenceType ort, AjaxRequestTarget target) { searchPerformed(target); @@ -94,7 +110,8 @@ protected void referenceValueUpdated(ObjectReferenceType ort, AjaxRequestTarget createEnumChoices((Class extends Enum>) inputClass) : Model.ofList(getModelObject().getAllowedValues(getPageBase())); } if (choices != null) { - inputPanel = createDropDownChoices(ID_SEARCH_ITEM_FIELD, new PropertyModel<>(getModel(), FilterSearchItem.F_INPUT), choices, false); + inputPanel = WebComponentUtil.createDropDownChoices( + ID_SEARCH_ITEM_FIELD, new PropertyModel(getModel(), FilterSearchItem.F_INPUT), (IModel)choices, true, getPageBase()); ((InputPanel) inputPanel).getBaseFormComponent().add(new EmptyOnChangeAjaxFormUpdatingBehavior() { @Override protected void onUpdate(AjaxRequestTarget target) { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPanel.html b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPanel.html index bd7469de101..836dcacf3d1 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPanel.html +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPanel.html @@ -7,31 +7,30 @@ --> - - - - - - - - Toggle Dropdown - - - - - - - + + + + + + + Toggle Dropdown + + + + + + + - + @@ -41,8 +40,8 @@ - + @@ -81,7 +80,9 @@ - + + + diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPanel.java index 505bf3235ec..9ae336abf11 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPanel.java @@ -271,7 +271,7 @@ protected IModel createHelpModel() { form.add(oidItem); WebMarkupContainer moreGroup = new WebMarkupContainer(ID_MORE_GROUP); - moreGroup.add(new VisibleBehaviour(() -> createVisibleBehaviour(SearchBoxModeType.BASIC).isVisible() && getModelObject().isCanConfigure())); + moreGroup.add(new VisibleBehaviour(() -> createVisibleBehaviour(SearchBoxModeType.BASIC).isVisible())); form.add(moreGroup); AjaxLink more = new AjaxLink(ID_MORE) { @@ -348,6 +348,16 @@ public boolean isEnabled() { } return true; } + + @Override + public boolean isVisible() { + Search search = getModelObject(); + if (search.getAllowedSearchType().size() == 1 + && SearchBoxModeType.BASIC.equals(search.getAllowedSearchType().get(0))) { + return !search.getItems().isEmpty() || !search.getAvailableDefinitions().isEmpty(); + } + return true; + } }); searchButtonBeforeDropdown.setOutputMarkupId(true); searchContainer.add(searchButtonBeforeDropdown); diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPropertyPanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPropertyPanel.java index 7e2d7551fae..a3dc1a35e13 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPropertyPanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchPropertyPanel.java @@ -92,7 +92,8 @@ protected boolean isAllowedNotFoundObjectRef() { if (choices == null) { choices = new ListModel(item.getAllowedValues(getPageBase())); } - searchItemField = createDropDownChoices(ID_SEARCH_ITEM_FIELD, new PropertyModel<>(getModel(), "value"), choices, true); + searchItemField = WebComponentUtil.createDropDownChoices( + ID_SEARCH_ITEM_FIELD, new PropertyModel(getModel(), "value"), (IModel)choices, true, getPageBase()); ((InputPanel) searchItemField).getBaseFormComponent().add(new EmptyOnChangeAjaxFormUpdatingBehavior() { @Override protected void onUpdate(AjaxRequestTarget target) { diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchTypePanel.java b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchTypePanel.java index a5fc6256971..60ba6e517ca 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchTypePanel.java +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/component/search/SearchTypePanel.java @@ -8,6 +8,8 @@ import java.util.List; +import com.evolveum.midpoint.gui.api.util.WebComponentUtil; + import org.apache.wicket.Component; import org.apache.wicket.ajax.AjaxRequestTarget; import org.apache.wicket.ajax.form.OnChangeAjaxBehavior; @@ -42,7 +44,8 @@ protected void initSearchItemField(WebMarkupContainer searchItemContainer) { List>> allowedValues = item.getAllowedValues(); if (allowedValues != null && !allowedValues.isEmpty()) { IModel>> choices = new ListModel(item.getAllowedValues()); - searchItemField = createDropDownChoices(ID_SEARCH_ITEM_FIELD, new PropertyModel<>(getModel(), ContainerTypeSearchItem.F_TYPE), choices, false); + searchItemField = WebComponentUtil.createDropDownChoices( + ID_SEARCH_ITEM_FIELD, new PropertyModel(getModel(), ContainerTypeSearchItem.F_TYPE), (IModel)choices, false, getPageBase()); } } diff --git a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/page/admin/PageAdminObjectDetails.html b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/page/admin/PageAdminObjectDetails.html index 9cecaa995b1..097b44150b3 100644 --- a/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/page/admin/PageAdminObjectDetails.html +++ b/gui/admin-gui/src/main/java/com/evolveum/midpoint/web/page/admin/PageAdminObjectDetails.html @@ -14,8 +14,8 @@ - + [Status indicator here]