home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / rpc / soap / SOAPEncoder.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  18.2 KB  |  538 lines
  1. package mx.rpc.soap
  2. {
  3.    import flash.xml.XMLDocument;
  4.    import flash.xml.XMLNode;
  5.    import mx.logging.ILogger;
  6.    import mx.logging.Log;
  7.    import mx.resources.IResourceManager;
  8.    import mx.resources.ResourceManager;
  9.    import mx.rpc.soap.types.ICustomSOAPType;
  10.    import mx.rpc.wsdl.WSDLEncoding;
  11.    import mx.rpc.wsdl.WSDLMessagePart;
  12.    import mx.rpc.wsdl.WSDLOperation;
  13.    import mx.rpc.xml.SchemaConstants;
  14.    import mx.rpc.xml.SchemaDatatypes;
  15.    import mx.rpc.xml.SchemaMarshaller;
  16.    import mx.rpc.xml.XMLEncoder;
  17.    
  18.    public class SOAPEncoder extends XMLEncoder implements ISOAPEncoder
  19.    {
  20.       private var log:ILogger;
  21.       
  22.       private var _ignoreWhitespace:Boolean = true;
  23.       
  24.       private var _wsdlOperation:WSDLOperation;
  25.       
  26.       private var isSOAPEncoding:Boolean = false;
  27.       
  28.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  29.       
  30.       public function SOAPEncoder()
  31.       {
  32.          super();
  33.          log = Log.getLogger("mx.rpc.soap.SOAPEncoder");
  34.       }
  35.       
  36.       override protected function deriveXSIType(param1:XML, param2:QName, param3:*) : void
  37.       {
  38.          var _loc4_:SchemaDatatypes = null;
  39.          var _loc5_:QName = null;
  40.          var _loc6_:String = null;
  41.          if(isSOAPEncoding)
  42.          {
  43.             _loc4_ = schemaManager.schemaDatatypes;
  44.             if(param2 == _loc4_.anyTypeQName || param2 == _loc4_.anySimpleTypeQName)
  45.             {
  46.                if(isSimpleValue(param3) || param2 == _loc4_.anySimpleTypeQName)
  47.                {
  48.                   _loc6_ = SchemaMarshaller.guessSimpleType(param3);
  49.                   _loc5_ = new QName(schemaConstants.xsdURI,_loc6_);
  50.                }
  51.             }
  52.             else
  53.             {
  54.                _loc5_ = param2;
  55.             }
  56.             if(_loc5_ != null)
  57.             {
  58.                param1[schemaConstants.getXSIToken(schemaConstants.typeAttrQName)] = schemaConstants.getXSDToken(_loc5_);
  59.             }
  60.          }
  61.       }
  62.       
  63.       public function get soapConstants() : SOAPConstants
  64.       {
  65.          return wsdlOperation.soapConstants;
  66.       }
  67.       
  68.       public function set wsdlOperation(param1:WSDLOperation) : void
  69.       {
  70.          _wsdlOperation = param1;
  71.          schemaManager = _wsdlOperation.schemaManager;
  72.       }
  73.       
  74.       protected function encodePartValue(param1:WSDLMessagePart, param2:*) : XMLList
  75.       {
  76.          var _loc3_:XMLList = null;
  77.          if(param1.element != null)
  78.          {
  79.             _loc3_ = encode(param2,param1.element);
  80.          }
  81.          else
  82.          {
  83.             _loc3_ = encode(param2,param1.name,param1.type,param1.definition);
  84.          }
  85.          return _loc3_;
  86.       }
  87.       
  88.       protected function encodeOperationAsRPCEncoded(param1:*, param2:XML) : void
  89.       {
  90.          isSOAPEncoding = true;
  91.          var _loc3_:XML = new XML("<" + wsdlOperation.name + "/>");
  92.          var _loc4_:String = inputEncoding.namespaceURI;
  93.          var _loc5_:String = schemaManager.getOrCreatePrefix(_loc4_);
  94.          var _loc6_:Namespace = new Namespace(_loc5_,_loc4_);
  95.          _loc3_.setNamespace(_loc6_);
  96.          encodeMessage(param1,_loc3_);
  97.          param2.appendChild(_loc3_);
  98.          param2[SOAPConstants.SOAP_ENV_PREFIX + ":encodingStyle"] = soapConstants.encodingURI;
  99.       }
  100.       
  101.       protected function encodeEnvelope(param1:*, param2:Array) : XML
  102.       {
  103.          log.debug("Encoding SOAP request envelope");
  104.          var _loc3_:XML = new XML("<" + soapConstants.envelopeQName.localName + "/>");
  105.          _loc3_.setNamespace(soapConstants.envelopeNamespace);
  106.          _loc3_.addNamespace(schemaConstants.xsdNamespace);
  107.          _loc3_.addNamespace(schemaConstants.xsiNamespace);
  108.          schemaManager.namespaces[soapConstants.envelopeNamespace.prefix] = soapConstants.envelopeNamespace;
  109.          encodeHeaders(param2,_loc3_);
  110.          encodeBody(param1,_loc3_);
  111.          return _loc3_;
  112.       }
  113.       
  114.       protected function encodeHeaders(param1:Array, param2:XML) : void
  115.       {
  116.          var _loc3_:uint = 0;
  117.          var _loc4_:XML = null;
  118.          var _loc5_:uint = 0;
  119.          if(param1 != null)
  120.          {
  121.             _loc3_ = param1.length;
  122.             if(_loc3_ > 0)
  123.             {
  124.                _loc4_ = new XML("<" + soapConstants.headerQName.localName + "/>");
  125.                _loc4_.setNamespace(soapConstants.envelopeNamespace);
  126.                param2.appendChild(_loc4_);
  127.                _loc5_ = 0;
  128.                while(_loc5_ < _loc3_)
  129.                {
  130.                   encodeHeaderElement(param1[_loc5_],_loc4_);
  131.                   _loc5_++;
  132.                }
  133.             }
  134.          }
  135.       }
  136.       
  137.       protected function encodeOperationAsDocumentLiteral(param1:Object, param2:XML) : void
  138.       {
  139.          var _loc4_:QName = null;
  140.          var _loc5_:XML = null;
  141.          var _loc6_:String = null;
  142.          var _loc7_:Namespace = null;
  143.          var _loc3_:Array = wsdlOperation.inputMessage.parts;
  144.          if(wsdlOperation.inputMessage.isWrapped)
  145.          {
  146.             _loc4_ = wsdlOperation.inputMessage.wrappedQName;
  147.             _loc5_ = new XML("<" + _loc4_.localName + "/>");
  148.             if(_loc4_.uri != null && _loc4_.uri != "")
  149.             {
  150.                _loc6_ = schemaManager.getOrCreatePrefix(_loc4_.uri);
  151.                _loc7_ = new Namespace(_loc6_,_loc4_.uri);
  152.                _loc5_.setNamespace(_loc7_);
  153.             }
  154.             encodeMessage(param1,_loc5_);
  155.             param2.appendChild(_loc5_);
  156.          }
  157.          else
  158.          {
  159.             encodeMessage(param1,param2);
  160.          }
  161.       }
  162.       
  163.       override public function encode(param1:*, param2:QName = null, param3:QName = null, param4:XML = null) : XMLList
  164.       {
  165.          var _loc5_:XMLList = null;
  166.          var _loc6_:uint = 0;
  167.          var _loc7_:uint = 0;
  168.          var _loc8_:XMLList = null;
  169.          var _loc9_:Boolean = false;
  170.          if(param4 != null)
  171.          {
  172.             _loc5_ = new XMLList();
  173.             _loc6_ = getMaxOccurs(param4);
  174.             _loc7_ = getMinOccurs(param4);
  175.             if(_loc6_ == 0)
  176.             {
  177.                return _loc5_;
  178.             }
  179.             if(param1 == null && _loc7_ == 0)
  180.             {
  181.                return _loc5_;
  182.             }
  183.             if(_loc6_ > 1)
  184.             {
  185.                _loc8_ = new XMLList();
  186.                _loc9_ = schemaManager.pushNamespaceInScope(param2.uri);
  187.                encodeGroupElement(param4,_loc8_,param2,param1);
  188.                if(_loc9_)
  189.                {
  190.                   schemaManager.releaseScope();
  191.                }
  192.                return _loc5_ + _loc8_;
  193.             }
  194.          }
  195.          return super.encode(param1,param2,param3,param4);
  196.       }
  197.       
  198.       protected function encodeMessage(param1:*, param2:XML) : void
  199.       {
  200.          var _loc3_:Array = null;
  201.          var _loc6_:String = null;
  202.          var _loc8_:WSDLMessagePart = null;
  203.          var _loc9_:* = undefined;
  204.          var _loc10_:String = null;
  205.          var _loc11_:XMLList = null;
  206.          var _loc12_:String = null;
  207.          if(wsdlOperation.inputMessage != null)
  208.          {
  209.             _loc3_ = wsdlOperation.inputMessage.parts;
  210.          }
  211.          if(_loc3_ == null)
  212.          {
  213.             return;
  214.          }
  215.          var _loc4_:Object = {};
  216.          var _loc5_:int = 0;
  217.          var _loc7_:uint = 0;
  218.          while(_loc7_ < _loc3_.length)
  219.          {
  220.             _loc8_ = _loc3_[_loc7_];
  221.             _loc9_ = undefined;
  222.             if(param1 is Array)
  223.             {
  224.                _loc9_ = param1[_loc7_];
  225.                if(_loc9_ === undefined)
  226.                {
  227.                   if(!_loc8_.optional)
  228.                   {
  229.                      _loc6_ = resourceManager.getString("rpc","missingInputParameter",[_loc7_]);
  230.                      throw new Error(_loc6_);
  231.                   }
  232.                   _loc5_++;
  233.                }
  234.             }
  235.             else
  236.             {
  237.                _loc10_ = _loc8_.name.localName;
  238.                if(param1 != null)
  239.                {
  240.                   _loc9_ = param1[_loc10_];
  241.                }
  242.                _loc4_[_loc10_] = _loc9_;
  243.                if(_loc9_ === undefined || param1 != null && !param1.hasOwnProperty(_loc10_))
  244.                {
  245.                   if(!_loc8_.optional)
  246.                   {
  247.                      _loc6_ = resourceManager.getString("rpc","missingInputParameterWithName",[_loc10_]);
  248.                      throw new Error(_loc6_);
  249.                   }
  250.                   _loc5_++;
  251.                }
  252.             }
  253.             if(_loc9_ !== undefined)
  254.             {
  255.                _loc11_ = encodePartValue(_loc8_,_loc9_);
  256.                param2.appendChild(_loc11_);
  257.             }
  258.             _loc7_++;
  259.          }
  260.          if(param1 != null)
  261.          {
  262.             if(param1 is Array)
  263.             {
  264.                if(param1.length < _loc3_.length - _loc5_)
  265.                {
  266.                   _loc6_ = resourceManager.getString("rpc","tooFewInputParameters",[_loc3_.length,param1.length]);
  267.                   throw new Error(_loc6_);
  268.                }
  269.             }
  270.             else
  271.             {
  272.                for(_loc12_ in param1)
  273.                {
  274.                   if(!_loc4_.hasOwnProperty(_loc12_))
  275.                   {
  276.                      _loc6_ = resourceManager.getString("rpc","unexpectedInputParameter",[_loc12_]);
  277.                      throw new Error(_loc6_);
  278.                   }
  279.                }
  280.             }
  281.          }
  282.       }
  283.       
  284.       protected function preEncodedCheck(param1:*) : Object
  285.       {
  286.          var _loc3_:XMLDocument = null;
  287.          var _loc4_:XMLNode = null;
  288.          var _loc2_:Object = null;
  289.          if(param1 != null)
  290.          {
  291.             if(param1 is XMLList)
  292.             {
  293.                _loc2_ = param1 as XMLList;
  294.             }
  295.             else if(param1 is XML)
  296.             {
  297.                _loc2_ = param1 as XML;
  298.             }
  299.             else if(param1 is XMLDocument)
  300.             {
  301.                _loc3_ = param1 as XMLDocument;
  302.                _loc2_ = new XML(_loc3_.firstChild.toString());
  303.             }
  304.             else if(param1 is XMLNode)
  305.             {
  306.                _loc4_ = param1 as XMLNode;
  307.                _loc2_ = new XML(_loc4_.toString());
  308.             }
  309.          }
  310.          return _loc2_;
  311.       }
  312.       
  313.       protected function encodeBody(param1:*, param2:XML) : void
  314.       {
  315.          log.debug("Encoding SOAP request body");
  316.          var _loc3_:XML = new XML("<" + soapConstants.bodyQName.localName + "/>");
  317.          _loc3_.setNamespace(soapConstants.envelopeNamespace);
  318.          var _loc4_:Object = preEncodedCheck(param1);
  319.          if(_loc4_ != null)
  320.          {
  321.             _loc3_.appendChild(_loc4_);
  322.          }
  323.          else if(wsdlOperation.style == SOAPConstants.DOC_STYLE)
  324.          {
  325.             if(inputEncoding.useStyle != SOAPConstants.USE_LITERAL)
  326.             {
  327.                throw new Error("WSDL 1.1 supports operations with binding style \'document\' only if use style is \'literal\'.");
  328.             }
  329.             encodeOperationAsDocumentLiteral(param1,_loc3_);
  330.          }
  331.          else
  332.          {
  333.             if(wsdlOperation.style != SOAPConstants.RPC_STYLE)
  334.             {
  335.                throw new Error("Unrecognized binding style \'" + wsdlOperation.style + "\'. Only \'document\' and \'rpc\' styles are supported.");
  336.             }
  337.             if(inputEncoding.useStyle == SOAPConstants.USE_LITERAL)
  338.             {
  339.                encodeOperationAsRPCLiteral(param1,_loc3_);
  340.             }
  341.             else
  342.             {
  343.                if(inputEncoding.useStyle != SOAPConstants.USE_ENCODED)
  344.                {
  345.                   throw new Error("WSDL 1.1 does not support operations with binding style \'rpc\' and use style " + inputEncoding.useStyle + ".");
  346.                }
  347.                encodeOperationAsRPCEncoded(param1,_loc3_);
  348.             }
  349.          }
  350.          param2.appendChild(_loc3_);
  351.       }
  352.       
  353.       public function encodeRequest(param1:* = null, param2:Array = null) : XML
  354.       {
  355.          var oldPrettyPrinting:Boolean;
  356.          var oldIgnoreWhitespace:Boolean;
  357.          var envelopeXML:XML = null;
  358.          var args:* = param1;
  359.          var headers:Array = param2;
  360.          reset();
  361.          oldIgnoreWhitespace = Boolean(XML.ignoreWhitespace);
  362.          oldPrettyPrinting = Boolean(XML.prettyPrinting);
  363.          try
  364.          {
  365.             XML.ignoreWhitespace = ignoreWhitespace;
  366.             XML.prettyPrinting = false;
  367.             envelopeXML = encodeEnvelope(args,headers);
  368.          }
  369.          finally
  370.          {
  371.             XML.ignoreWhitespace = oldIgnoreWhitespace;
  372.             XML.prettyPrinting = oldPrettyPrinting;
  373.          }
  374.          return envelopeXML;
  375.       }
  376.       
  377.       public function set ignoreWhitespace(param1:Boolean) : void
  378.       {
  379.          _ignoreWhitespace = param1;
  380.       }
  381.       
  382.       public function get wsdlOperation() : WSDLOperation
  383.       {
  384.          return _wsdlOperation;
  385.       }
  386.       
  387.       protected function encodeOperationAsRPCLiteral(param1:Object, param2:XML) : void
  388.       {
  389.          var _loc3_:XML = new XML("<" + wsdlOperation.name + "/>");
  390.          var _loc4_:String = schemaManager.getOrCreatePrefix(inputEncoding.namespaceURI);
  391.          var _loc5_:Namespace = new Namespace(_loc4_,inputEncoding.namespaceURI);
  392.          _loc3_.setNamespace(_loc5_);
  393.          encodeMessage(param1,_loc3_);
  394.          param2.appendChild(_loc3_);
  395.       }
  396.       
  397.       public function get schemaConstants() : SchemaConstants
  398.       {
  399.          return schemaManager.schemaConstants;
  400.       }
  401.       
  402.       override public function encodeType(param1:QName, param2:XML, param3:QName, param4:*, param5:XML = null) : void
  403.       {
  404.          var _loc9_:String = null;
  405.          var _loc10_:String = null;
  406.          var _loc6_:SchemaDatatypes = schemaManager.schemaDatatypes;
  407.          var _loc7_:QName = getXSIType(param4);
  408.          if(_loc7_ != null)
  409.          {
  410.             param1 = _loc7_;
  411.          }
  412.          if(isSOAPEncoding)
  413.          {
  414.             _loc7_ = param1;
  415.             if(SOAPConstants.isSOAPEncodedType(param1))
  416.             {
  417.                if(param1 == soapConstants.soapBase64QName)
  418.                {
  419.                   param1 = _loc6_.base64BinaryQName;
  420.                }
  421.                else
  422.                {
  423.                   _loc9_ = param1.localName;
  424.                   if(_loc9_ != "Array" && _loc9_ != "arrayType")
  425.                   {
  426.                      param1 = schemaConstants.getQName(_loc9_);
  427.                   }
  428.                }
  429.             }
  430.          }
  431.          var _loc8_:ICustomSOAPType = SOAPConstants.getCustomSOAPType(param1);
  432.          if(_loc8_ != null)
  433.          {
  434.             _loc8_.encode(this,param2,param3,param4,param5);
  435.          }
  436.          else
  437.          {
  438.             super.encodeType(param1,param2,param3,param4,param5);
  439.          }
  440.          if(_loc7_ != null)
  441.          {
  442.             _loc10_ = param2[schemaConstants.getXSIToken(schemaConstants.typeAttrQName)];
  443.             if(_loc10_ == null || _loc10_ == "")
  444.             {
  445.                super.setXSIType(param2,_loc7_);
  446.             }
  447.          }
  448.       }
  449.       
  450.       override public function encodeComplexRestriction(param1:XML, param2:XML, param3:QName, param4:*) : void
  451.       {
  452.          var _loc8_:ICustomSOAPType = null;
  453.          var _loc5_:SchemaConstants = schemaManager.schemaConstants;
  454.          var _loc6_:String = param1.@base;
  455.          var _loc7_:QName = schemaManager.getQNameForPrefixedName(_loc6_,param1);
  456.          if(_loc7_ == soapConstants.soapencArrayQName)
  457.          {
  458.             _loc8_ = SOAPConstants.getCustomSOAPType(_loc7_);
  459.             if(_loc8_ != null)
  460.             {
  461.                _loc8_.encode(this,param2,param3,param4,param1);
  462.                return;
  463.             }
  464.          }
  465.          super.encodeComplexRestriction(param1,param2,param3,param4);
  466.       }
  467.       
  468.       public function get ignoreWhitespace() : Boolean
  469.       {
  470.          return _ignoreWhitespace;
  471.       }
  472.       
  473.       protected function encodeHeaderElement(param1:Object, param2:XML) : void
  474.       {
  475.          var _loc4_:XMLList = null;
  476.          var _loc5_:XML = null;
  477.          var _loc6_:String = null;
  478.          var _loc7_:String = null;
  479.          var _loc8_:Namespace = null;
  480.          var _loc3_:* = preEncodedCheck(param1);
  481.          if(_loc3_ != null)
  482.          {
  483.             param2.appendChild(param1);
  484.          }
  485.          else
  486.          {
  487.             _loc4_ = new XMLList();
  488.             if(param1.content != null && Boolean(param1.content.hasOwnProperty(param1.qname.localName)))
  489.             {
  490.                param1.content = param1.content[param1.qname.localName];
  491.             }
  492.             _loc3_ = preEncodedCheck(param1.content);
  493.             if(_loc3_ != null)
  494.             {
  495.                if(_loc3_ is XMLList)
  496.                {
  497.                   _loc4_ = _loc3_ as XMLList;
  498.                }
  499.                else
  500.                {
  501.                   _loc4_ = new XMLList(_loc3_);
  502.                }
  503.             }
  504.             else
  505.             {
  506.                _loc4_ = encode(param1.content,param1.qname);
  507.             }
  508.             for each(_loc5_ in _loc4_)
  509.             {
  510.                if(param1.qname.uri != null && param1.qname.uri.length > 0 && _loc5_.namespace().uri != param1.qname.uri)
  511.                {
  512.                   _loc7_ = schemaManager.getOrCreatePrefix(param1.qname.uri);
  513.                   _loc8_ = new Namespace(_loc7_,param1.qname.uri);
  514.                   _loc5_.setNamespace(_loc8_);
  515.                }
  516.                if(param1.mustUnderstand)
  517.                {
  518.                   _loc6_ = schemaManager.getOrCreatePrefix(soapConstants.mustUnderstandQName.uri);
  519.                   _loc5_[_loc6_ + ":" + soapConstants.mustUnderstandQName.localName] = "1";
  520.                }
  521.                if(param1.role != null)
  522.                {
  523.                   _loc6_ = schemaManager.getOrCreatePrefix(soapConstants.actorQName.uri);
  524.                   _loc5_[_loc6_ + ":" + soapConstants.actorQName.localName] = param1.role;
  525.                }
  526.             }
  527.             param2.appendChild(_loc4_);
  528.          }
  529.       }
  530.       
  531.       protected function get inputEncoding() : WSDLEncoding
  532.       {
  533.          return _wsdlOperation.inputMessage.encoding;
  534.       }
  535.    }
  536. }
  537.  
  538.