Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one
   * or more contributor license agreements. See the NOTICE file
   * distributed with this work for additional information
   * regarding copyright ownership. The ASF licenses this file
   * to you under the Apache License, Version 2.0 (the
   * "License"); you may not use this file except in compliance
   * with the License. You may obtain a copy of the License at
   *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
  * software distributed under the License is distributed on an
  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  * KIND, either express or implied. See the License for the
  * specific language governing permissions and limitations under the License.
  */
 package org.apache.shindig.gadgets.spec;
 
 
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
 
 import  javax.el.ELContext;
 import  javax.el.ELException;
 import  javax.el.ELResolver;
 import  javax.el.PropertyNotFoundException;
 import  javax.el.ValueExpression;
 
 import  org.json.JSONArray;
 import  org.json.JSONException;
 import  org.json.JSONObject;
 
 import  com.google.common.collect.ImmutableMap;
 import  com.google.common.collect.ImmutableSet;
 import  com.google.common.collect.Lists;
 import  com.google.common.collect.Maps;

Parsing code for <os:*> elements.
 
 public class PipelinedData {
   private final Map<StringSocialDatasocialPreloads;
   private final Map<StringHttpDatahttpPreloads;
 
   private boolean needsViewer;
   private boolean needsOwner;
 
   public static final String OPENSOCIAL_NAMESPACE = "http://ns.opensocial.org/2008/markup";
 
   public PipelinedData(Element elementUri basethrows SpecParserException {
     Map<StringSocialDatasocialPreloads = Maps.newHashMap();
     Map<StringHttpDatahttpPreloads = Maps.newHashMap();
 
     // TODO: extract this loop into XmlUtils.getChildrenWithNamespace
     for (Node node = element.getFirstChild(); node != nullnode = node.getNextSibling()) {
       if (!(node instanceof Element)) {
         continue;
       }
 
       Element child = (Elementnode;
       // Ignore elements not in the namespace
       if (!.equals(child.getNamespaceURI())) {
         continue;
       }
 
       String elementName = child.getLocalName();
 
       String key = child.getAttribute("key");
       if (key == null) {
         throw new SpecParserException("Missing key attribute on os:" + elementName);
       }
 
       try {
         if ("PeopleRequest".equals(elementName)) {
           socialPreloads.put(keycreatePeopleRequest(child));
         } else if ("ViewerRequest".equals(elementName)) {
           socialPreloads.put(keycreateViewerRequest(child));
         } else if ("OwnerRequest".equals(elementName)) {
           socialPreloads.put(keycreateOwnerRequest(child));
         } else if ("PersonAppDataRequest".equals(elementName)) {
           // TODO: delete when 0.9 app data retrieval is supported
           socialPreloads.put(keycreatePersonAppDataRequest(child));
         } else if ("ActivitiesRequest".equals(elementName)) {
           socialPreloads.put(keycreateActivityRequest(child));
         } else if ("DataRequest".equals(elementName)) {
           socialPreloads.put(keycreateDataRequest(child));
        } else if ("HttpRequest".equals(elementName)) {
          httpPreloads.put(keycreateHttpRequest(childbase));
        } else {
          // TODO: This is wrong - the spec should parse, but should preload
          // notImplemented
          throw new SpecParserException("Unknown element <os:" + elementName + '>');
        }
      } catch (ELException ele) {
        throw new SpecParserException(new XmlException(ele));
      }
    }
    this. = Collections.unmodifiableMap(socialPreloads);
    this. = Collections.unmodifiableMap(httpPreloads);
  }
  private PipelinedData(PipelinedData socialDataSubstitutions substituter) {
    Map<StringSocialDatasocialPreloads = Maps.newHashMap();
    Map<StringHttpDatahttpPreloads = Maps.newHashMap();
    // TODO: support hangman substitutions for social preloads?
    socialPreloads.putAll(socialData.socialPreloads);
    for (Map.Entry<StringHttpDatahttpPreload : socialData.httpPreloads.entrySet()) {
      httpPreloads.put(httpPreload.getKey(), httpPreload.getValue().substitute(substituter));
    }
    this. = Collections.unmodifiableMap(socialPreloads);
    this. = Collections.unmodifiableMap(httpPreloads);
  }

  
Allows the creation of a view from an existing view so that localization can be performed.
  public PipelinedData substitute(Substitutions substituter) {
    return new PipelinedData(thissubstituter);
  }
  public interface Batch {
    Batch getNextBatch(ELResolver rootObjects);
  }

  
Gets the first batch of preload requests. Preloads that require root objects not yet available will not be executed in this batch, but may become available in subsequent batches.

Parameters:
rootObjects an ELResolver that can evaluate currently available root objects.
Returns:
a batch, or null if no batch could be created
See also:
GadgetELResolver
  public Batch getBatch(Expressions expressions, ELResolver rootObjects) {
    return getBatch(expressionsrootObjects);
  }

  
Create a Batch of preload requests

Parameters:
expressions expressions instance for parsing expressions
rootObjects an ELResolver that can evaluate currently available root objects.
currentSocialPreloads the remaining social preloads
currentHttpPreloads the remaining http preloads
  private Batch getBatch(Expressions expressions, ELResolver rootObjects,
      Map<StringSocialDatacurrentSocialPreloads,
      Map<StringHttpDatacurrentHttpPreloads) {
    ELContext elContext = expressions.newELContext(rootObjects);
    // Evaluate all existing social preloads
    Map<StringObjectevaluatedSocialPreloads = Maps.newHashMap();
    Map<StringSocialDatapendingSocialPreloads = null;
    if (currentSocialPreloads != null) {
      for (Map.Entry<StringSocialDatapreload : currentSocialPreloads.entrySet()) {
        try {
          Object value = preload.getValue().toJson(expressionselContext);
          evaluatedSocialPreloads.put(preload.getKey(), value);
        } catch (PropertyNotFoundException pnfe) {
          // Missing top-level property: put it in the pending set
          if (pendingSocialPreloads == null) {
            pendingSocialPreloads = Maps.newHashMap();
          }
          pendingSocialPreloads.put(preload.getKey(), preload.getValue());
        } catch (ELException e) {
          // TODO: Handle!?!
          throw new RuntimeException(e);
        }
      }
    }
    // And evaluate all existing HTTP preloads
    Map<StringRequestAuthenticationInfoevaluatedHttpPreloads = Maps.newHashMap();
    Map<StringHttpDatapendingHttpPreloads = null;
    if (currentHttpPreloads != null) {
      for (Map.Entry<StringHttpDatapreload : currentHttpPreloads.entrySet()) {
        try {
          RequestAuthenticationInfo value = preload.getValue().evaluate(expressionselContext);
          evaluatedHttpPreloads.put(preload.getKey(), value);
        } catch (PropertyNotFoundException pnfe) {
          if (pendingHttpPreloads == null) {
            pendingHttpPreloads = Maps.newHashMap();
          }
          pendingHttpPreloads.put(preload.getKey(), preload.getValue());
        } catch (ELException e) {
          // TODO: Handle!?!
          throw new RuntimeException(e);
        }
      }
    }
    // Nothing evaluated or pending;  return null for the batch.  Note that
    // there may be multiple PipelinedData objects (e.g., from multiple
    // <script type="text/os-data"> elements), so even if all evaluations
    // fail here, evaluations might succeed elsewhere and free up pending preloads
    if (evaluatedSocialPreloads.isEmpty() && evaluatedHttpPreloads.isEmpty() &&
        pendingHttpPreloads == null && pendingSocialPreloads == null) {
      return null;
    }
    return new BatchImpl(expressionsevaluatedSocialPreloadsevaluatedHttpPreloads,
        pendingSocialPreloadspendingHttpPreloads);
  }

  
Batch implementation
  class BatchImpl implements Batch {
    private final Expressions expressions;
    private final Map<StringObjectevaluatedSocialPreloads;
    private final Map<StringSocialDatapendingSocialPreloads;
    private final Map<StringHttpDatapendingHttpPreloads;
    public BatchImpl(Expressions expressions,
        Map<StringObjectevaluatedSocialPreloads,
        Map<StringRequestAuthenticationInfoevaluatedHttpPreloads,
        Map<StringSocialDatapendingSocialPreloadsMap<StringHttpDatapendingHttpPreloads) {
      this. = expressions;
      this. = evaluatedSocialPreloads;
      this. = evaluatedHttpPreloads;
      this. = pendingSocialPreloads;
      this. = pendingHttpPreloads;
    }
    public Map<StringObjectgetSocialPreloads() {
      return ;
    }
      return ;
    }
    public Batch getNextBatch(ELResolver rootObjects) {
      return getBatch(rootObjects);
    }
  }
  public boolean needsViewer() {
    return ;
  }
  public boolean needsOwner() {
    return ;
  }

  
Handle the os:PeopleRequest element
  private SocialData createPeopleRequest(Element childthrows ELException {
    SocialData expression = new SocialData(child.getAttribute("key"), "people.get");
    copyAttribute("groupId"childexpressionString.class);
    copyAttribute("userId"childexpression, JSONArray.class);
    updateUserArrayState("userId"child);
    copyAttribute("personId"childexpression, JSONArray.class);
    updateUserArrayState("personId"child);
    copyAttribute("startIndex"childexpressionInteger.class);
    copyAttribute("count"childexpressionInteger.class);
    copyAttribute("sortBy"childexpressionString.class);
    copyAttribute("sortOrder"childexpressionString.class);
    copyAttribute("filterBy"childexpressionString.class);
    copyAttribute("filterOperation"childexpressionString.class);
    copyAttribute("filterValue"childexpressionString.class);
    copyAttribute("fields"childexpression, JSONArray.class);
    return expression;
  }

  
Handle the os:ViewerRequest element
  private SocialData createViewerRequest(Element childthrows ELException {
    return createPersonRequest(child"@viewer");
  }

  
Handle the os:OwnerRequest element
  private SocialData createOwnerRequest(Element childthrows ELException {
    return createPersonRequest(child"@owner");
  }
  private SocialData createPersonRequest(Element childString userIdthrows ELException {
    SocialData expression = new SocialData(child.getAttribute("key"), "people.get");
    expression.addProperty("userId"userId, JSONArray.class);
    updateUserState(userId);
    copyAttribute("fields"childexpression, JSONArray.class);
    return expression;
  }

  
Handle the os:PersonAppDataRequest element
  private SocialData createPersonAppDataRequest(Element childthrows ELException {
    SocialData expression = new SocialData(child.getAttribute("key"), "appdata.get");
    copyAttribute("groupId"childexpressionString.class);
    copyAttribute("userId"childexpression, JSONArray.class);
    updateUserArrayState("userId"child);
    copyAttribute("appId"childexpressionString.class);
    copyAttribute("fields"childexpression, JSONArray.class);
    return expression;
  }

  
Handle the os:ActivitiesRequest element
  private SocialData createActivityRequest(Element childthrows ELException {
    SocialData expression = new SocialData(child.getAttribute("key"), "activities.get");
    copyAttribute("groupId"childexpressionString.class);
    copyAttribute("userId"childexpression, JSONArray.class);
    updateUserArrayState("userId"child);
    copyAttribute("appId"childexpressionString.class);
    // TODO: SHINDIG-711 should be activityIds?
    copyAttribute("activityId"childexpression, JSONArray.class);
    copyAttribute("fields"childexpression, JSONArray.class);
    // TODO: add activity paging support
    return expression;
  }

  
Handle the os:DataRequest element
  private SocialData createDataRequest(Element childthrows ELException, SpecParserException {
    String method = child.getAttribute("method");
    if (method == null) {
      throw new SpecParserException("Missing @method attribute on os:DataRequest");
    }
    // TODO: should we support anything that doesn't end in .get?
    // i.e, should this be a whitelist not a blacklist?
    if (method.endsWith(".update")
        || method.endsWith(".create")
        || method.endsWith(".delete")) {
      throw new SpecParserException("Unsupported @method attribute \"" + method + "\" on os:DataRequest");
    }
    SocialData expression = new SocialData(child.getAttribute("key"), method);
    NamedNodeMap nodeMap = child.getAttributes();
    for (int i = 0; i < nodeMap.getLength(); i++) {
      Node attrNode = nodeMap.item(i);
      // Skip namespaced attributes
      if (attrNode.getNamespaceURI() != null) {
        continue;
      }
      // Use getNodeName() instead of getLocalName().  NekoHTML has an incorrect
      // implementation of node name that returns null.
      String name = attrNode.getNodeName();
      // Skip the built-in names
      if ("method".equals(name) || "key".equals(name)) {
        continue;
      }
      String value = attrNode.getNodeValue();
      expression.addProperty(namevalueObject.class);
    }
    return expression;
  }

  
Handle an os:HttpRequest element
  private HttpData createHttpRequest(Element childUri basethrows ELException {
    HttpData data = new HttpData(childbase);
    // Update needsOwner and needsViewer
    if (data.authz != .) {
      if (data.signOwner) {
         = true;
      }
      if (data.signViewer) {
         = true;
      }
    }
    return data;
  }
  private void copyAttribute(String nameElement elementSocialData expressionClass<?> type)
    throws ELException {
    if (element.hasAttribute(name)) {
      expression.addProperty(nameelement.getAttribute(name), type);
    }
  }

  
Look for

Viewer:
Owner:
within a userId attribute
  private void updateUserArrayState(String nameElement element) {
    if (element.hasAttribute(name)) {
      // TODO: check after Expression evaluation?
      StringTokenizer tokens = new StringTokenizer(element.getAttribute(name), ",");
      while (tokens.hasMoreTokens()) {
        updateUserState(tokens.nextToken());
      }
    }
  }

  
Updates whether this batch of SocialData needs owner or viewer data
  private void updateUserState(String userId) {
    if ("@owner".equals(userId)) {
       = true;
    } else if ("@viewer".equals(userId) || "@me".equals(userId)) {
       = true;
    }
  }

  
A single pipelined HTTP makerequest.
  private static class HttpData {
    private final AuthType authz;
    private final Uri base;
    private final String href;
    private final boolean signOwner;
    private final boolean signViewer;
    private final Map<StringStringattributes;
    private static final Set<StringKNOWN_ATTRIBUTES =
          ImmutableSet.of("authz""href""sign_owner""sign_viewer");

    
Create an HttpData off an <os:makeRequest> element.
    public HttpData(Element elementUri basethrows ELException {
      this. = base;
      this. = element.hasAttribute("authz") ?
          AuthType.parse(element.getAttribute("authz")) : .;
      // TODO: Spec question;  should EL values be URL escaped?
      this. = element.getAttribute("href");
      // TODO: Spec question;  should sign_* default to true?
      this. = booleanValue(element"sign_owner"true);
      this. = booleanValue(element"sign_viewer"true);
      // TODO: many of these attributes should not be EL enabled
      ImmutableMap.Builder<StringStringattributes = ImmutableMap.builder();
      for (int i = 0; i < element.getAttributes().getLength(); i++) {
        Node attr = element.getAttributes().item(i);
        if (!.contains(attr.getNodeName())) {
          attributes.put(attr.getNodeName(), attr.getNodeValue());
        }
      }
      this. = attributes.build();
    }
    private HttpData(HttpData dataSubstitutions substituter) {
      this. = data.base;
      this. = data.authz;
      this. = substituter.substituteString(data.href);
      this. = data.signOwner;
      this. = data.signViewer;
      this. = data.attributes;
    }

    
Run substitutions over an HttpData
    public HttpData substitute(Substitutions substituter) {
      return new HttpData(thissubstituter);
    }

    
Evaluate expressions and return a RequestAuthenticationInfo.

Throws:
ELException if expression evaluation fails.
    public RequestAuthenticationInfo evaluate(Expressions expressions, ELContext context)
        throws ELException {
      String hrefString = String.valueOf(expressions.parse(String.class)
          .getValue(context));
      final Uri evaluatedHref = .resolve(Uri.parse(hrefString));
      final Map<StringStringevaluatedAttributes = Maps.newHashMap();
      for (Map.Entry<StringStringattr : .entrySet()) {
        ValueExpression expression = expressions.parse(attr.getValue(), String.class);
        evaluatedAttributes.put(attr.getKey(),
            String.valueOf(expression.getValue(context)));
      }
      return new RequestAuthenticationInfo() {
        public Map<StringStringgetAttributes() {
          return evaluatedAttributes;
        }
        public AuthType getAuthType() {
          return ;
        }
        public Uri getHref() {
          return evaluatedHref;
        }
        public boolean isSignOwner() {
          return ;
        }
        public boolean isSignViewer() {
          return ;
        }
      };
    }

    
Parse a boolean expression off an XML attribute.
    private boolean booleanValue(Element elementString attrName,
        boolean defaultValue) {
      if (!element.hasAttribute(attrName)) {
        return defaultValue;
      }
      return "true".equalsIgnoreCase(element.getAttribute(attrName));
    }
  }

  
A single social data request.
  private static class SocialData {
    private final List<Propertyproperties = Lists.newArrayList();
    private final String id;
    private final String method;
    public SocialData(String idString method) {
      this. = id;
      this. = method;
    }
    public void addProperty(String nameString valueClass<?> typethrows ELException {
      .add(new Property(namevaluetype));
    }

    
Create the JSON request form for the social data
    public JSONObject toJson(Expressions expressions, ELContext elContextthrows ELException {
      JSONObject object = new JSONObject();
      try {
        object.put("method");
        object.put("id");
        JSONObject params = new JSONObject();
        for (Property property : ) {
          property.set(expressionselContextparams);
        }
        object.put("params"params);
      } catch (JSONException je) {
        throw new ELException(je);
      }
      return object;
    }

    
Single property for an expression
    private static class Property {
      private final String name;
      private final String value;
      private final Class<?> type;
      public Property(String nameString valueClass<?> type) {
        this. = name;
        this. = value;
        this. = type;
      }
      public void set(Expressions expressions, ELContext elContext, JSONObject object)
          throws ELException {
        ValueExpression expression = expressions.parse();
        Object value = expression.getValue(elContext);
        try {
          if (value != null) {
            object.put(value);
          }
        } catch (JSONException e) {
          throw new ELException("Error parsing property \"" +  + '\"'e);
        }
      }
    }
  }
New to GrepCode? Check out our FAQ X