org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression クラス

org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression 連携図

公開メンバ関数
	SimpleExpression (String attribute, ScimOperator operator, CompValueType type, String attributeValue)
Boolean	evaluate (Map< String, Object > item)
void	setParentAttribute (String parentAttribute)
void	setResourceClass (Class<? extends BaseScimResource > resourceClass)

非公開メンバ関数
Boolean	evaluateDateTimeAttribute (Type attrType, Object valueInItemObj)
Boolean	evaluateBooleanAttribute (Type attrType, Object valueInItemObj)
Boolean	evaluateNumericAttribute (Type attrType, Object valueInItemObj)
Boolean	evaluateStringAttribute (boolean caseExact, Object valueInItemObj)
Attribute	getAttributeAnnotation ()

非公開変数類
Logger	log = LogManager.getLogger(getClass())
ExtensionService	extService
String	attribute
ScimOperator	operator
CompValueType	type
String	attributeValue
String	parentAttribute
Class<? extends BaseScimResource >	resourceClass

詳解

Created by jgomer on 2017-12-10.

構築子と解体子

SimpleExpression()

org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.SimpleExpression ( String  attribute, ScimOperator  operator, CompValueType  type, String  attributeValue  )

inline

                                                                                                               {
        this.attribute = attribute;
        this.operator=operator;
        this.attributeValue=attributeValue;
        this.type=type;
        //Extension service is not needed since this class deals with evaluating subatributes living inside complex attributes
        //but Gluu server does not support complex custom attributes
        //extService= CdiUtil.bean(ExtensionService.class);
    }

関数詳解

evaluate()

Boolean org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.evaluate ( Map< String, Object >  item )

inline

                                                     {
        /*
        There are 3 categories for attribute operators:
        - eq, ne (applicable to all types)
        - co, sw, ew (applicable to STRING, REFERENCE)
        - gt, ge, lt, le (applicable to STRING, DECIMAL, REFERENCE, DATETIME)
         */
        Boolean val=null;
        Type attrType=null;

        log.trace("SimpleExpression.evaluate.");
        String msg=String.format("%s%s",
                StringUtils.isEmpty(parentAttribute) ? "" : (parentAttribute + "."), resourceClass.getSimpleName());

        Attribute attrAnnot=getAttributeAnnotation();
        if (attrAnnot==null) {
            if (extService != null) {
                ExtensionField field=extService.getFieldOfExtendedAttribute(resourceClass, attribute);

                if (field == null)
                    log.error("SimpleExpression.evaluate. Attribute '{}' is not recognized in {}", attribute, msg);
                else
                    attrType = field.getAttributeDefinitionType();
            }
        }
        else
            attrType = attrAnnot.type();

        if (attrType==null) {
            log.error("SimpleExpression.evaluate. Could not determine type of attribute '{}' in {}", attribute, msg);
        }
        else {
            String errMsg=FilterUtil.checkFilterConsistency(attribute, attrType, type, operator);

            if (errMsg==null){
                Object currentAttrValue=item.get(attribute);

                if (type.equals(CompValueType.NULL)) {   //implies attributeValue==null
                    log.trace("SimpleExpression.evaluate. Using null as compare value");
                    val=operator.equals(ScimOperator.EQUAL) ? currentAttrValue==null : currentAttrValue!=null;
                }
                else
                if (currentAttrValue==null){
                    //If value is absent, filter won't match against anything (only when comparing with null as in previous case)
                    log.trace("SimpleExpression.evaluate. Attribute \"{}\" is absent in resource data", attribute);
                    val=false;
                }
                else
                if (Type.STRING.equals(attrType) || Type.REFERENCE.equals(attrType))    //check it's a string or reference
                    val = evaluateStringAttribute(attrAnnot!=null && attrAnnot.isCaseExact(), currentAttrValue);
                else
                if (Type.INTEGER.equals(attrType) || Type.DECIMAL.equals(attrType))
                    val = evaluateNumericAttribute(attrType, currentAttrValue);
                else
                if (Type.BOOLEAN.equals(attrType))
                    val = evaluateBooleanAttribute(attrType, currentAttrValue);
                else
                if (Type.DATETIME.equals(attrType))
                    val = evaluateDateTimeAttribute(attrType, currentAttrValue);
            }
            else
                log.error("SimpleExpression.evaluate. {}", errMsg);
        }
        return val;

    }

evaluateBooleanAttribute()

Boolean org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.evaluateBooleanAttribute ( Type  attrType, Object  valueInItemObj  )

inlineprivate

                                                                                  {

        Boolean val=null;
        log.trace("SimpleExpression.evaluateBooleanAttribute");

        boolean valueInItem=Boolean.valueOf(valueInItemObj.toString());
        boolean compareAgainst=Boolean.valueOf(attributeValue);

        if (operator.equals(ScimOperator.EQUAL))
            val=valueInItem==compareAgainst;
        else
        if (operator.equals(ScimOperator.NOT_EQUAL))
            val=valueInItem!=compareAgainst;
        else
            FilterUtil.logOperatorInconsistency(operator.getValue(), attrType.toString(), attribute);

        return val;

    }

evaluateDateTimeAttribute()

Boolean org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.evaluateDateTimeAttribute ( Type  attrType, Object  valueInItemObj  )

inlineprivate

                                                                                   {

        Boolean val=null;
        log.trace("SimpleExpression.evaluateDateTimeAttribute");

        try{
            DateTime dtStored=new DateTime(valueInItemObj.toString());
            DateTime dtProvided=new DateTime(attributeValue);
            long valueInItem=dtStored.getMillis();
            long compareAgainst=dtProvided.getMillis();

            switch (operator){
                case EQUAL:
                    val=valueInItem==compareAgainst;
                    break;
                case NOT_EQUAL:
                    val=valueInItem!=compareAgainst;
                    break;
                case GREATER_THAN:
                    val=valueInItem>compareAgainst;
                    break;
                case GREATER_THAN_OR_EQUAL:
                    val=valueInItem>=compareAgainst;
                    break;
                case LESS_THAN:
                    val=valueInItem<compareAgainst;
                    break;
                case LESS_THAN_OR_EQUAL:
                    val=valueInItem<=compareAgainst;
                    break;
                default:
                    FilterUtil.logOperatorInconsistency(operator.getValue(), attrType.toString(), attribute);
            }
        }
        catch (Exception e){
            log.error("SimpleExpression.evaluate. Date not in ISO format");
        }
        return val;

    }

evaluateNumericAttribute()

Boolean org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.evaluateNumericAttribute ( Type  attrType, Object  valueInItemObj  )

inlineprivate

                                                                                  {

        Boolean val=null;
        log.trace("SimpleExpression.evaluateNumericAttribute");

        BigDecimal valueInItem=new BigDecimal(valueInItemObj.toString());
        BigDecimal compareAgainst=new BigDecimal(attributeValue);

        switch (operator) {
            case EQUAL:
                val=valueInItem.equals(compareAgainst);
                break;
            case NOT_EQUAL:
                val=!valueInItem.equals(compareAgainst);
                break;
            case GREATER_THAN:
                val=valueInItem.compareTo(compareAgainst)>0;
                break;
            case GREATER_THAN_OR_EQUAL:
                val=valueInItem.equals(compareAgainst) || valueInItem.compareTo(compareAgainst)>0;
                break;
            case LESS_THAN:
                val=valueInItem.compareTo(compareAgainst)<0;
                break;
            case LESS_THAN_OR_EQUAL:
                val=valueInItem.equals(compareAgainst) || valueInItem.compareTo(compareAgainst)<0;
                break;
            default:
                FilterUtil.logOperatorInconsistency(operator.getValue(), attrType.toString(), attribute);
        }
        return val;

    }

evaluateStringAttribute()

Boolean org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.evaluateStringAttribute ( boolean  caseExact, Object  valueInItemObj  )

inlineprivate

                                                                                      {

        //Here attributeValue is never null
        Boolean val=null;
        log.trace("SimpleExpression.evaluateStringAttribute");

        String valueInItem=valueInItemObj.toString();

        if (!caseExact){
            valueInItem=valueInItem.toLowerCase();
            attributeValue=attributeValue.toLowerCase();
        }
        switch (operator){
            case EQUAL:
                val=valueInItem.equals(attributeValue);
                break;
            case NOT_EQUAL:
                val=!valueInItem.equals(attributeValue);
                break;
            case CONTAINS:
                val=valueInItem.contains(attributeValue);
                break;
            case STARTS_WITH:
                val=valueInItem.startsWith(attributeValue);
                break;
            case ENDS_WITH:
                val=valueInItem.endsWith(attributeValue);
                break;
            case GREATER_THAN:
                val=valueInItem.compareTo(attributeValue)>0;
                break;
            case GREATER_THAN_OR_EQUAL:
                val=valueInItem.equals(attributeValue) || valueInItem.compareTo(attributeValue)>0;
                break;
            case LESS_THAN:
                val=valueInItem.compareTo(attributeValue)<0;
                break;
            case LESS_THAN_OR_EQUAL:
                val=valueInItem.equals(attributeValue) || valueInItem.compareTo(attributeValue)<0;
                break;
        }
        return val;

    }

getAttributeAnnotation()

Attribute org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.getAttributeAnnotation ( )

inlineprivate

                                              {
        String attr= StringUtils.isEmpty(parentAttribute) ? attribute : parentAttribute + "." + attribute;
        return IntrospectUtil.getFieldAnnotation(attr, resourceClass==null ? BaseScimResource.class : resourceClass, Attribute.class);
    }

setParentAttribute()

void org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.setParentAttribute ( String  parentAttribute )

inline

                                                           {
        this.parentAttribute = parentAttribute;
    }

setResourceClass()

void org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.setResourceClass ( Class<? extends BaseScimResource >  resourceClass )

inline

                                                                                  {
        this.resourceClass = resourceClass;
    }

メンバ詳解

attribute

String org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.attribute

private

attributeValue

String org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.attributeValue

private

extService

ExtensionService org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.extService

private

log

Logger org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.log = LogManager.getLogger(getClass())

private

operator

ScimOperator org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.operator

private

parentAttribute

String org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.parentAttribute

private

resourceClass

Class<? extends BaseScimResource> org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.resourceClass

private

type

CompValueType org.gluu.oxtrust.service.antlr.scimFilter.util.SimpleExpression.type

private

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxTrust/server/src/main/java/org/gluu/oxtrust/service/antlr/scimFilter/util/SimpleExpression.java