PrivacyItem.java

  1. /**
  2.  *
  3.  * Copyright the original author or authors
  4.  *
  5.  * Licensed under the Apache License, Version 2.0 (the "License");
  6.  * you may not use this file except in compliance with the License.
  7.  * You may obtain a copy of the License at
  8.  *
  9.  *     http://www.apache.org/licenses/LICENSE-2.0
  10.  *
  11.  * Unless required by applicable law or agreed to in writing, software
  12.  * distributed under the License is distributed on an "AS IS" BASIS,
  13.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14.  * See the License for the specific language governing permissions and
  15.  * limitations under the License.
  16.  */
  17. package org.jivesoftware.smackx.privacy.packet;

  19. import java.util.Objects;

  21. import org.jivesoftware.smack.datatypes.UInt32;

  23. /**
  24.  * A privacy item acts a rule that when matched defines if a stanza should be blocked or not.
  25.  *
  26.  * Privacy Items can handle different kind of blocking communications based on JID, group,
  27.  * subscription type or globally by:<ul>
  28.  * <li>Allowing or blocking messages.
  29.  * <li>Allowing or blocking inbound presence notifications.
  30.  * <li>Allowing or blocking outbound presence notifications.
  31.  * <li>Allowing or blocking IQ stanzas.
  32.  * <li>Allowing or blocking all communications.
  33.  * </ul>
  34.  * @author Francisco Vives
  35.  */
  36. public class PrivacyItem {
  37.     /**
  38.      * Value for subscription type rules.
  39.      */
  40.     public static final String SUBSCRIPTION_BOTH = "both";
  41.     public static final String SUBSCRIPTION_TO = "to";
  42.     public static final String SUBSCRIPTION_FROM = "from";
  43.     public static final String SUBSCRIPTION_NONE = "none";

  45.     /** allow is the action associated with the item, it can allow or deny the communication. */
  46.     private final boolean allow;

  48.     /**
  49.      * order is a unsigned 32-bit integer that is unique among all items in the list.
  50.      **/
  51.     private final UInt32 order;

  53.     /**
  54.      * Type defines if the rule is based on JIDs, roster groups or presence subscription types.
  55.      * Available values are: [jid|group|subscription]
  56.      */
  57.     private final Type type;

  59.     /**
  60.      * The value hold the element identifier to apply the action. If the type is "jid", then the
  61.      * 'value' attribute MUST contain a valid Jabber ID. If the type is "group", then the
  62.      * 'value' attribute SHOULD contain the name of a group in the user's roster. If the type is
  63.      * "subscription", then the 'value' attribute MUST be one of "both", "to", "from", or
  64.      * "none".
  65.      */
  66.     private final String value;

  68.     /** blocks incoming IQ stanzas. */
  69.     private boolean filterIQ = false;
  70.     /** filterMessage blocks incoming message stanzas. */
  71.     private boolean filterMessage = false;
  72.     /** blocks incoming presence notifications. */
  73.     private boolean filterPresenceIn = false;
  74.     /** blocks outgoing presence notifications. */
  75.     private boolean filterPresenceOut = false;

  77.     public PrivacyItem(boolean allow, long order) {
  78.         this(null, null, allow, UInt32.from(order));
  79.     }

  81.     /**
  82.      * Creates a new fall-through privacy item.
  83.      *
  84.      * This is usually the last item in a privacy list and has no 'type' attribute.
  85.      *
  86.      * @param allow true if this is an allow item
  87.      * @param order the order of this privacy item
  88.      */
  89.     public PrivacyItem(boolean allow, UInt32 order) {
  90.         this(null, null, allow, order);
  91.     }

  93.     public PrivacyItem(Type type, String value, boolean allow, long order) {
  94.         this(type, value, allow, UInt32.from(order));
  95.     }

  97.     /**
  98.      * Creates a new privacy item.
  99.      *
  100.      * If the type is "jid", then the 'value' attribute MUST contain a valid Jabber ID.
  101.      * If the type is "group", then the 'value' attribute SHOULD contain the name of a group
  102.      * in the user's roster.
  103.      * If the type is "subscription", then the 'value' attribute MUST be one of "both", "to",
  104.      * "from", or "none".
  105.      *
  106.      * @param type the type.
  107.      * @param value the value of the privacy item
  108.      * @param allow true if this is an allow item
  109.      * @param order the order of this privacy item
  110.      */
  111.     public PrivacyItem(Type type, String value, boolean allow, UInt32 order) {
  112.         this.type = type;
  113.         this.value = value;
  114.         this.allow = allow;
  115.         this.order = Objects.requireNonNull(order);
  116.     }

  118.     /**
  119.      * Creates a new privacy item.
  120.      *
  121.      * If the type is "jid", then the 'value' attribute MUST contain a valid Jabber ID.
  122.      * If the type is "group", then the 'value' attribute SHOULD contain the name of a group
  123.      * in the user's roster.
  124.      * If the type is "subscription", then the 'value' attribute MUST be one of "both", "to",
  125.      * "from", or "none".
  126.      *
  127.      * @param type the type.
  128.      * @param value the value of the privacy item
  129.      * @param allow true if this is an allow item
  130.      * @param order the order of this privacy item
  131.      */
  132.     public PrivacyItem(Type type, CharSequence value, boolean allow, long order) {
  133.         this(type, value != null ? value.toString() : null, allow, order);
  134.     }

  136.     /**
  137.      * Returns the action associated with the item, it MUST be filled and will allow or deny
  138.      * the communication.
  139.      *
  140.      * @return the allow communication status.
  141.      */
  142.     public boolean isAllow() {
  143.         return allow;
  144.     }

  146.     /**
  147.      * Returns whether the receiver allow or deny incoming IQ stanzas or not.
  148.      *
  149.      * @return the iq filtering status.
  150.      */
  151.     public boolean isFilterIQ() {
  152.         return filterIQ;
  153.     }

  155.     /**
  156.      * Sets whether the receiver allows or denies incoming IQ stanzas or not.
  157.      *
  158.      * @param filterIQ indicates if the receiver allows or denies incoming IQ stanzas.
  159.      */
  160.     public void setFilterIQ(boolean filterIQ) {
  161.         this.filterIQ = filterIQ;
  162.     }

  164.     /**
  165.      * Returns whether the receiver allows or denies incoming messages or not.
  166.      *
  167.      * @return the message filtering status.
  168.      */
  169.     public boolean isFilterMessage() {
  170.         return filterMessage;
  171.     }

  173.     /**
  174.      * Sets whether the receiver allows or denies incoming messages or not.
  175.      *
  176.      * @param filterMessage indicates if the receiver allows or denies incoming messages or not.
  177.      */
  178.     public void setFilterMessage(boolean filterMessage) {
  179.         this.filterMessage = filterMessage;
  180.     }

  182.     /**
  183.      * Returns whether the receiver allows or denies incoming presence or not.
  184.      *
  185.      * @return the iq filtering incoming presence status.
  186.      */
  187.     public boolean isFilterPresenceIn() {
  188.         return filterPresenceIn;
  189.     }

  191.     /**
  192.      * Sets whether the receiver allows or denies incoming presence or not.
  193.      *
  194.      * @param filterPresenceIn indicates if the receiver allows or denies filtering incoming presence.
  195.      */
  196.     public void setFilterPresenceIn(boolean filterPresenceIn) {
  197.         this.filterPresenceIn = filterPresenceIn;
  198.     }

  200.     /**
  201.      * Returns whether the receiver allows or denies incoming presence or not.
  202.      *
  203.      * @return the iq filtering incoming presence status.
  204.      */
  205.     public boolean isFilterPresenceOut() {
  206.         return filterPresenceOut;
  207.     }

  209.     /**
  210.      * Sets whether the receiver allows or denies outgoing presence or not.
  211.      *
  212.      * @param filterPresenceOut indicates if the receiver allows or denies filtering outgoing presence
  213.      */
  214.     public void setFilterPresenceOut(boolean filterPresenceOut) {
  215.         this.filterPresenceOut = filterPresenceOut;
  216.     }

  218.     /**
  219.      * Returns the order where the receiver is processed. List items are processed in
  220.      * ascending order.
  221.      *
  222.      * The order MUST be filled and its value MUST be a non-negative integer
  223.      * that is unique among all items in the list.
  224.      *
  225.      * @return the order number.
  226.      */
  227.     public UInt32 getOrder() {
  228.         return order;
  229.     }

  231.     /**
  232.      * Returns the type hold the kind of communication it will allow or block.
  233.      * It MUST be filled with one of these values: jid, group or subscription.
  234.      *
  235.      * @return the type of communication it represent.
  236.      */
  237.     public Type getType() {
  238.         return type;
  239.     }

  241.     /**
  242.      * Returns the element identifier to apply the action.
  243.      *
  244.      * If the type is "jid", then the 'value' attribute MUST contain a valid Jabber ID.
  245.      * If the type is "group", then the 'value' attribute SHOULD contain the name of a group
  246.      * in the user's roster.
  247.      * If the type is "subscription", then the 'value' attribute MUST be one of "both", "to",
  248.      * "from", or "none".
  249.      *
  250.      * @return the identifier to apply the action.
  251.      */
  252.     public String getValue() {
  253.         return value;
  254.     }

  256.     /**
  257.      * Returns whether the receiver allows or denies every kind of communication.
  258.      *
  259.      * When filterIQ, filterMessage, filterPresenceIn and filterPresenceOut are not set
  260.      * the receiver will block all communications.
  261.      *
  262.      * @return the all communications status.
  263.      */
  264.     public boolean isFilterEverything() {
  265.         return !(this.isFilterIQ() || this.isFilterMessage() || this.isFilterPresenceIn()
  266.                 || this.isFilterPresenceOut());
  267.     }

  269.     /**
  270.      * Answer an xml representation of the receiver according to the RFC 3921.
  271.      *
  272.      * @return the text xml representation.
  273.      */
  274.     public String toXML() {
  275.         StringBuilder buf = new StringBuilder();
  276.         buf.append("<item");
  277.         if (this.isAllow()) {
  278.             buf.append(" action=\"allow\"");
  279.         } else {
  280.             buf.append(" action=\"deny\"");
  281.         }
  282.         buf.append(" order=\"").append(getOrder()).append('"');
  283.         if (getType() != null) {
  284.             buf.append(" type=\"").append(getType()).append('"');
  285.         }
  286.         if (getValue() != null) {
  287.             buf.append(" value=\"").append(getValue()).append('"');
  288.         }
  289.         if (isFilterEverything()) {
  290.             buf.append("/>");
  291.         } else {
  292.             buf.append('>');
  293.             if (this.isFilterIQ()) {
  294.                 buf.append("<iq/>");
  295.             }
  296.             if (this.isFilterMessage()) {
  297.                 buf.append("<message/>");
  298.             }
  299.             if (this.isFilterPresenceIn()) {
  300.                 buf.append("<presence-in/>");
  301.             }
  302.             if (this.isFilterPresenceOut()) {
  303.                 buf.append("<presence-out/>");
  304.             }
  305.             buf.append("</item>");
  306.         }
  307.         return buf.toString();
  308.     }

  310.     /**
  311.      * Type defines if the rule is based on JIDs, roster groups or presence subscription types.
  312.      */
  313.     public enum Type {
  314.         /**
  315.          * JID being analyzed should belong to a roster group of the list's owner.
  316.          */
  317.         group,
  318.         /**
  319.          * JID being analyzed should have a resource match, domain match or bare JID match.
  320.          */
  321.         jid,
  322.         /**
  323.          * JID being analyzed should belong to a contact present in the owner's roster with the
  324.          * specified subscription status.
  325.          */
  326.         subscription
  327.     }
  328. }
Created with JaCoCo 0.8.6.202009150832