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 org.jivesoftware.smack.util.NumberUtil;

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

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

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

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

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

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

  75.     /**
  76.      * Creates a new fall-through privacy item.
  77.      *
  78.      * This is usually the last item in a privacy list and has no 'type' attribute.
  79.      *
  80.      * @param allow true if this is an allow item
  81.      * @param order the order of this privacy item
  82.      */
  83.     public PrivacyItem(boolean allow, long order) {
  84.         this(null, null, allow, order);
  85.     }

  87.     /**
  88.      * Creates a new privacy item.
  89.      *
  90.      * If the type is "jid", then the 'value' attribute MUST contain a valid Jabber ID.
  91.      * If the type is "group", then the 'value' attribute SHOULD contain the name of a group
  92.      * in the user's roster.
  93.      * If the type is "subscription", then the 'value' attribute MUST be one of "both", "to",
  94.      * "from", or "none".
  95.      *
  96.      * @param type the type.
  97.      * @param value the value of the privacy item
  98.      * @param allow true if this is an allow item
  99.      * @param order the order of this privacy item
  100.      */
  101.     public PrivacyItem(Type type, String value, boolean allow, long order) {
  102.         NumberUtil.checkIfInUInt32Range(order);
  103.         this.type = type;
  104.         this.value = value;
  105.         this.allow = allow;
  106.         this.order = order;
  107.     }

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

  127.     /**
  128.      * Returns the action associated with the item, it MUST be filled and will allow or deny
  129.      * the communication.
  130.      *
  131.      * @return the allow communication status.
  132.      */
  133.     public boolean isAllow() {
  134.         return allow;
  135.     }

  137.     /**
  138.      * Returns whether the receiver allow or deny incoming IQ stanzas or not.
  139.      *
  140.      * @return the iq filtering status.
  141.      */
  142.     public boolean isFilterIQ() {
  143.         return filterIQ;
  144.     }

  146.     /**
  147.      * Sets whether the receiver allows or denies incoming IQ stanzas or not.
  148.      *
  149.      * @param filterIQ indicates if the receiver allows or denies incoming IQ stanzas.
  150.      */
  151.     public void setFilterIQ(boolean filterIQ) {
  152.         this.filterIQ = filterIQ;
  153.     }

  155.     /**
  156.      * Returns whether the receiver allows or denies incoming messages or not.
  157.      *
  158.      * @return the message filtering status.
  159.      */
  160.     public boolean isFilterMessage() {
  161.         return filterMessage;
  162.     }

  164.     /**
  165.      * Sets wheather the receiver allows or denies incoming messages or not.
  166.      *
  167.      * @param filterMessage indicates if the receiver allows or denies incoming messages or not.
  168.      */
  169.     public void setFilterMessage(boolean filterMessage) {
  170.         this.filterMessage = filterMessage;
  171.     }

  173.     /**
  174.      * Returns whether the receiver allows or denies incoming presence or not.
  175.      *
  176.      * @return the iq filtering incoming presence status.
  177.      */
  178.     public boolean isFilterPresenceIn() {
  179.         return filterPresenceIn;
  180.     }

  182.     /**
  183.      * Sets whether the receiver allows or denies incoming presence or not.
  184.      *
  185.      * @param filterPresenceIn indicates if the receiver allows or denies filtering incoming presence.
  186.      */
  187.     public void setFilterPresenceIn(boolean filterPresenceIn) {
  188.         this.filterPresenceIn = filterPresenceIn;
  189.     }

  191.     /**
  192.      * Returns whether the receiver allows or denies incoming presence or not.
  193.      *
  194.      * @return the iq filtering incoming presence status.
  195.      */
  196.     public boolean isFilterPresenceOut() {
  197.         return filterPresenceOut;
  198.     }

  200.     /**
  201.      * Sets whether the receiver allows or denies outgoing presence or not.
  202.      *
  203.      * @param filterPresenceOut indicates if the receiver allows or denies filtering outgoing presence
  204.      */
  205.     public void setFilterPresenceOut(boolean filterPresenceOut) {
  206.         this.filterPresenceOut = filterPresenceOut;
  207.     }

  209.     /**
  210.      * Returns the order where the receiver is processed. List items are processed in
  211.      * ascending order.
  212.      *
  213.      * The order MUST be filled and its value MUST be a non-negative integer
  214.      * that is unique among all items in the list.
  215.      *
  216.      * @return the order number.
  217.      */
  218.     public long getOrder() {
  219.         return order;
  220.     }

  222.     /**
  223.      * Returns the type hold the kind of communication it will allow or block.
  224.      * It MUST be filled with one of these values: jid, group or subscription.
  225.      *
  226.      * @return the type of communication it represent.
  227.      */
  228.     public Type getType() {
  229.         return type;
  230.     }

  232.     /**
  233.      * Returns the element identifier to apply the action.
  234.      *
  235.      * If the type is "jid", then the 'value' attribute MUST contain a valid Jabber ID.
  236.      * If the type is "group", then the 'value' attribute SHOULD contain the name of a group
  237.      * in the user's roster.
  238.      * If the type is "subscription", then the 'value' attribute MUST be one of "both", "to",
  239.      * "from", or "none".
  240.      *
  241.      * @return the identifier to apply the action.
  242.      */
  243.     public String getValue() {
  244.         return value;
  245.     }

  247.     /**
  248.      * Returns whether the receiver allows or denies every kind of communication.
  249.      *
  250.      * When filterIQ, filterMessage, filterPresenceIn and filterPresenceOut are not set
  251.      * the receiver will block all communications.
  252.      *
  253.      * @return the all communications status.
  254.      */
  255.     public boolean isFilterEverything() {
  256.         return !(this.isFilterIQ() || this.isFilterMessage() || this.isFilterPresenceIn()
  257.                 || this.isFilterPresenceOut());
  258.     }

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

  301.     /**
  302.      * Type defines if the rule is based on JIDs, roster groups or presence subscription types.
  303.      */
  304.     public static enum Type {
  305.         /**
  306.          * JID being analyzed should belong to a roster group of the list's owner.
  307.          */
  308.         group,
  309.         /**
  310.          * JID being analyzed should have a resource match, domain match or bare JID match.
  311.          */
  312.         jid,
  313.         /**
  314.          * JID being analyzed should belong to a contact present in the owner's roster with the
  315.          * specified subscription status.
  316.          */
  317.         subscription
  318.     }
  319. }
Created with JaCoCo 0.7.4.201502262128