X-Git-Url: https://git.mdrn.pl/redakcja.git/blobdiff_plain/04b05946ab640eaf9135a73772b704dd41c323e7..717c14c014e3c988bcb392599a47ffa92630da78:/platforma/static/filebrowser/uploadify/com/adobe/protocols/dict/Dict.as diff --git a/platforma/static/filebrowser/uploadify/com/adobe/protocols/dict/Dict.as b/platforma/static/filebrowser/uploadify/com/adobe/protocols/dict/Dict.as new file mode 100755 index 00000000..07d2530c --- /dev/null +++ b/platforma/static/filebrowser/uploadify/com/adobe/protocols/dict/Dict.as @@ -0,0 +1,328 @@ +package com.adobe.protocols.dict +{ + import com.adobe.protocols.dict.events.*; + import com.adobe.protocols.dict.util.*; + + import flash.events.Event; + import flash.events.EventDispatcher; + import flash.events.IOErrorEvent; + import flash.events.ProgressEvent; + import flash.events.SecurityErrorEvent; + import flash.net.Socket; + import mx.rpc.http.HTTPService; + import mx.rpc.events.ResultEvent; + import mx.rpc.events.FaultEvent; + import flash.xml.XMLNode; + import mx.utils.StringUtil; + + public class Dict + extends EventDispatcher + { + // Event type names. + public static var CONNECTED:String = "connected"; + public static var DISCONNECTED:String = "disconnected"; + public static var IO_ERROR:String = IOErrorEvent.IO_ERROR; + public static var ERROR:String = "error"; + public static var SERVERS:String = "servers"; + public static var DATABASES:String = "databases"; + public static var MATCH_STRATEGIES:String = "matchStrategies"; + public static var DEFINITION:String = "definition"; + public static var DEFINITION_HEADER:String = "definitionHeader"; + public static var MATCH:String = "match"; + public static var NO_MATCH:String = "noMatch"; + + public static var FIRST_MATCH:uint = 0; + public static var ALL_DATABASES:uint = 1; + + private var socket:SocketHelper; + + private var dbShortList:Boolean; + + public function Dict() + { + this.socket = new SocketHelper(); + this.socket.addEventListener(Event.CONNECT, connected); + this.socket.addEventListener(Event.CLOSE, disconnected); + this.socket.addEventListener(SocketHelper.COMPLETE_RESPONSE, incomingData); + this.socket.addEventListener(IOErrorEvent.IO_ERROR, ioError); + this.socket.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityError); + } + + public function connect(server:String, port:uint = 2628):void + { + if (this.socket.connected) + { + this.socket.close(); + } + this.socket.connect(server, port); + } + + public function connectThroughProxy(proxyServer:String, + proxyPort:int, + server:String, + port:uint = 2628):void + { + if (this.socket.connected) + { + this.socket.close(); + } + this.socket.setProxyInfo(proxyServer, proxyPort); + this.socket.connect(server, port); + } + + public function disconnect():void + { + this.socket.close(); + this.disconnected(null); + } + + public function getServers():void + { + var http:HTTPService = new HTTPService(); + http.url = "http://luetzschena-stahmeln.de/dictd/xmllist.php"; + http.addEventListener(ResultEvent.RESULT, incomingServerXML); + http.addEventListener(FaultEvent.FAULT, httpError); + http.resultFormat = HTTPService.RESULT_FORMAT_E4X; + http.send(); + } + + public function getDatabases(shortList:Boolean=true):void + { + this.dbShortList = shortList; + this.socket.writeUTFBytes("show db\r\n"); + this.socket.flush(); + } + + public function getMatchStrategies():void + { + this.socket.writeUTFBytes("show strat\r\n"); + this.socket.flush(); + } + + public function match(database:String, term:String, scope:String="prefix"):void + { + this.socket.writeUTFBytes("match " + database + " " + scope + " \"" + term + "\"\r\n"); + this.socket.flush(); + } + + public function define(database:String, term:String):void + { + this.socket.writeUTFBytes("define " + database + " \"" + term + "\"\r\n"); + this.socket.flush(); + } + + public function lookup(term:String, scope:uint):void + { + var flag:String; + if (scope == Dict.ALL_DATABASES) + { + flag = "*"; + } + else if (scope == Dict.FIRST_MATCH) + { + flag = "!"; + } + this.socket.writeUTFBytes("define " + flag + " \"" + term + "\"\r\n"); + this.socket.flush(); + } + + //// Private functions //// + + private function connected(event:Event):void + { + // Wait to dispatch an event until we get the 220 response. + } + + private function disconnected(event:Event):void + { + dispatchEvent(new DisconnectedEvent()); + } + + private function incomingServerXML(event:ResultEvent):void + { + var dictd:Namespace = new Namespace("http://www.luetzschena-stahmeln.de/dictd/"); + var result:XML = event.result as XML; + var server:String, description:String; + var servers:Array = new Array(); + for each (var serverNode:XML in result.dictd::server) + { + server = serverNode.dictd::dictdurl; + description = serverNode.dictd::description; + if (StringUtil.trim(server).length != 0 && + StringUtil.trim(description).length != 0) + { + var dServer:DictionaryServer = new DictionaryServer(); + dServer.server = server.replace("dict://", ""); + dServer.description = description; + servers.push(dServer); + } + } + var dEvent:DictionaryServerEvent = new DictionaryServerEvent(); + dEvent.servers = servers; + dispatchEvent(dEvent); + } + + private function incomingData(event:CompleteResponseEvent):void + { + var rawResponse:String = event.response; + var response:Response = this.parseRawResponse(rawResponse); + var responseCode:uint = response.code; + if (responseCode == 552) // no matches + { + throwNoMatchEvent(response); + } + else if (responseCode >= 400 && responseCode <= 599) // error + { + throwErrorEvent(response); + } + else if (responseCode == 220) // successful connection + { + dispatchEvent(new ConnectedEvent()); + } + else if (responseCode == 110) // databases are being returned + { + throwDatabasesEvent(response); + } + else if (responseCode == 111) // matches strategies + { + throwMatchStrategiesEvent(response); + } + else if (responseCode == 152) // matches + { + throwMatchEvent(response); + } + else if (responseCode == 150) + { + throwDefinitionHeaderEvent(response); + } + else if (responseCode == 151) + { + throwDefinitionEvent(response); + } + } + + private function ioError(event:IOErrorEvent):void + { + dispatchEvent(event); + } + + private function httpError(event:FaultEvent):void + { + trace("httpError!"); + } + + private function securityError(event:SecurityErrorEvent):void + { + trace("security error!"); + trace(event.text); + } + + // Dispatch new events. + + private function throwDatabasesEvent(response:Response):void + { + var databases:Array = new Array(); + var responseArray:Array = response.body.split("\r\n"); + for each (var line:String in responseArray) + { + var name:String = line.substring(0, line.indexOf(" ")); + if (name == "--exit--") + { + if (this.dbShortList) + { + break; + } + continue; + } + var description:String = line.substring(line.indexOf(" ")+1, line.length).replace(/\"/g,""); + databases.push(new Database(name, description)); + } + var event:DatabaseEvent = new DatabaseEvent(); + event.databases = databases; + dispatchEvent(event); + } + + private function throwMatchStrategiesEvent(response:Response):void + { + var strategies:Array = new Array(); + var responseArray:Array = response.body.split("\r\n"); + for each (var line:String in responseArray) + { + var name:String = line.substring(0, line.indexOf(" ")); + var description:String = line.substring(line.indexOf(" ")+1, line.length).replace(/\"/g,""); + strategies.push(new MatchStrategy(name, description)); + } + var event:MatchStrategiesEvent = new MatchStrategiesEvent(); + event.strategies = strategies; + dispatchEvent(event); + } + + private function throwMatchEvent(response:Response):void + { + var matches:Array = new Array(); + var responseArray:Array = response.body.split("\r\n"); + for each (var line:String in responseArray) + { + var match:String = line.substring(line.indexOf(" ")+1, line.length).replace(/\"/g,""); + matches.push(match); + } + var event:MatchEvent = new MatchEvent(); + event.matches = matches; + dispatchEvent(event); + } + + private function throwErrorEvent(response:Response):void + { + var event:ErrorEvent = new ErrorEvent(); + event.code = response.code; + event.message = response.headerText; + dispatchEvent(event); + } + + private function throwNoMatchEvent(response:Response):void + { + dispatchEvent(new NoMatchEvent()); + } + + private function throwDefinitionHeaderEvent(response:Response):void + { + var event:DefinitionHeaderEvent = new DefinitionHeaderEvent(); + event.definitionCount = uint(response.headerText.substring(0, response.headerText.indexOf(" "))); + dispatchEvent(event); + } + + private function throwDefinitionEvent(response:Response):void + { + var event:DefinitionEvent = new DefinitionEvent(); + var def:Definition = new Definition(); + var headerText:String = response.headerText; + var tokens:Array = headerText.match(/"[^"]+"/g); + def.term = String(tokens[0]).replace(/"/g, ""); + def.database = String(tokens[1]).replace(/"/g, ""); + def.definition = response.body; + event.definition = def; + dispatchEvent(event); + } + + private function parseRawResponse(rawResponse:String):Response + { + var response:Response = new Response(); + var fullHeader:String; + if (rawResponse.indexOf("\r\n") != -1) + { + fullHeader = rawResponse.substring(0, rawResponse.indexOf("\r\n")); + } + else + { + fullHeader = rawResponse; + } + var responseCodeMatch:Array = fullHeader.match(/^\d{3}/); + response.code = uint(responseCodeMatch[0]); + response.headerText = fullHeader.substring(fullHeader.indexOf(" ")+1, fullHeader.length); + var body:String = rawResponse.substring(rawResponse.indexOf("\r\n")+2, rawResponse.length); + body = body.replace(/\r\n\.\./, "\r\n."); + response.body = body; + return response; + } + } +} \ No newline at end of file