Read File


	


    File Name:  

    File Size:  

    

function readFileContents() {

    var temp = document.getElementById("local_file");
    var file = temp.files[0];
    var contents = "";

	document.getElementById("fileName").innerHTML = file.fileName;
	document.getElementById("fileSize").innerHTML = file.fileSize;

	// Try using the firefox method first.
    if (file.getAsBinary) {
        contents = file.getAsText("utf8");
        // Or; file.getAsBinary()
    }
    else {
        // try the IE method instead
	    try {
	        var fso = new ActiveXObject("Scripting.FileSystemObject");
	        var handle = fso.OpenTextFile(file.fileName, 1);
	        contents = fh.ReadAll();
	        fh.Close();
	    }
	    catch (Exception) {
	        alert('Counld not read file using IE method!!');
	    }

    }

    document.getElementById("fileContents").innerHTML = contents;

    return false;
}

package
{
    import flash.display.Sprite;
    import flash.events.*;
    import flash.net.FileFilter;
    import flash.net.FileReference;
    import flash.net.URLRequest;
    import flash.utils.ByteArray;
	import flash.external.ExternalInterface;

    public class LocalFileReader extends Sprite
    {
        private var fileRef:FileReference; 

        public function LocalFileReader()
        {
			ExternalInterface.call('LocalFileReader.onMessage','LocalFileReader...');
            fileRef = new FileReference();
            fileRef.addEventListener(Event.SELECT, onFileSelected);
            fileRef.addEventListener(Event.CANCEL, onCancel);
            fileRef.addEventListener(IOErrorEvent.IO_ERROR, onIOError);
            fileRef.addEventListener(SecurityErrorEvent.SECURITY_ERROR, onSecurityError);
            var textTypeFilter:FileFilter = new FileFilter("Data Files (*.txt, *.rtf, *.xml. *.csv)", "*.txt;*.rtf; *.xml; *.csv");
			ExternalInterface.call('LocalFileReader.onMessage','Calling browse...');

			try {
				fileRef.browse([textTypeFilter]);
			}
			catch (error:SecurityError) {
				ExternalInterface.call('LocalFileReader.onError','Security error...'+error.toString());
			}
			catch (error:Error) {
				ExternalInterface.call('LocalFileReader.onError','Error...'+error.toString());
			}		

        } 

        public function onFileSelected(evt:Event):void
        {
            fileRef.addEventListener(ProgressEvent.PROGRESS, onProgress);
            fileRef.addEventListener(Event.COMPLETE, onComplete);
			ExternalInterface.call("LocalFileReader.onFileSelected", fileRef.name, fileRef.size, fileRef.type);
            fileRef.load();
        } 

        public function onProgress(evt:ProgressEvent):void
        {
			ExternalInterface.call("LocalFileReader.onProgress", evt.bytesLoaded, evt.bytesTotal);
        } 

        public function onComplete(evt:Event):void
        {
			// Get the data from the file as a ByteArray
			var data:ByteArray = fileRef.data;

			ExternalInterface.call("LocalFileReader.onLoaded", data.readUTFBytes(data.bytesAvailable));
        } 

        public function onCancel(evt:Event):void
        {
            trace("The browse request was canceled by the user.");
        } 

        public function onIOError(evt:IOErrorEvent):void
        {
			ExternalInterface.call("LocalFileReader.onError", "There was an IO Error.");
        }

        public function onSecurityError(evt:Event):void
        {
			ExternalInterface.call("LocalFileReader.onError", "There was a security error.");

        }
    }
}

// Requires a Button component instance on the Stage with an instance name of "browseButton".
browseButton.addEventListener(MouseEvent.CLICK, clickHandler);

function clickHandler(eventObj:MouseEvent):void {
    var fr = new LocalFileReader();
}

var LocalFileReader = {

	// ////////////////////////////////////////////////////////////////////////

	paint : function(targetDiv){

		var flash_url = defines.code_url + "flash/LocalFileReader.swf";

		var flashvars = {};
		var params = {
		  bgcolor: "#ffffff",
		  quality: "high",
		  menu: "false",
		  allowScriptAccess: "sameDomain"
		};
		var attributes = {
		  id: "localFileReader",
		  name: "localFileReader"
		};

		swfobject.embedSWF(flash_url, targetDiv, "80", "22", "10.0.0","expressInstall.swf", flashvars, params, attributes);

	},

	// ////////////////////////////////////////////////////////////////////////

	onFileSelected : function(name, size, type){
		LocalFileReader.onMessage(name + " " + size + "kb " + type);
	},

	onProgress : function(bytes, total){
		LocalFileReader.onMessage(bytes + " / " + total);
	},

	onLoaded : function(content){
		$('#fileContents').html(content);
	},

	// ////////////////////////////////////////////////////////////////////////

	onMessage : function(msg){
		$('#msg').append(msg + "");
	},

	onError : function(msg){
		$('#msg').append(""+msg + "");
	}

	// ////////////////////////////////////////////////////////////////////////

}

// Initialize the session, and use php's standard session management
Session::init(false);

// ... or, initialize the session, and use the a database to store the session data
Session::init(true);

// If we're using a database, then you must have a table with the following fields;
//
// id varchar(32) {primary key}
// access int (10)
// data text

// Set a session variable
Session::set('session_variable', 5);

// Get a session variable
$val = Session::get('session_variable');

// Clear a session variable
Session::clear('session_variable');

// Check to see if a session variable exists
if (Session::exists('session_variable')){
Logger::debug("Session variable exists!");
}

// Set your database credentials, I typically do this in a file called 'settings.php.sticky'
// as this is server-specific and I don't include this file in the repo. You can also
// just add the credentials into the DatabaseManager class and dispense with these defines.
define("database_user", "dbuser");
define("database_pass", "dbpass");
define("database_name", "dbname");
define("database_host", "localhost");
define("database_verbose", false); // If set to true, the database will log activity using the Logger

// Though you don't need to setup or explicitly create the connection (the class will check for connection and connect if
// needed when you call any of its methods.
DatabaseManager::connect();

// Prepare a sql statement
$sql = DatabaseManager::prepare("SELECT id FROM sometable WHERE textField = %s AND numericField = %d",  $string, $number );

// Get a single variable
$id = DatabaseManager::getResults($sql);

// Get a result returned in a associative array
$sql = DatabaseManager::prepare("SELECT * FROM sometable WHERE textField = %s AND numericField = %d",  $string, $number );
$data = DatabaseManager::getResults($sql);

// Do a insert, and get the inserted row id
$id = DatabaseManager::insert($sql);

// Do an update
DatabaseManager::update($sql);

// Do a generic sql query and return the result object
DatabaseManager::submitQuery($sql);

// You can manually close the connection
DatabaseManager::close();

// Tell the logger to catch system errors
Logger::catchSysErrors();

// To the logger to echo the log as HTML
Logger::echoLog();

// Set the logger level
Logger::setLevelDebug();
Logger::setLevelInfo();
Logger::setLevelWarning();
Logger::setLevelError();
Logger::setLevelFatal();

// Or set the level using the Logger constants
Logger::setLevel(Logger::$DEBUG);
Logger::setLevel(Logger::$INFO);
Logger::setLevel(Logger::$WARNING);
Logger::setLevel(Logger::$ERROR);
Logger::setLevel(Logger::$FATAL);

// Log a message
Logger::debug("some message");
Logger::warning("some message");
Logger::warn("some message");
Logger::error("some message");
Logger::info("some message");
Logger::fatal("some message");

// (Optional) detect if the browser is IE6, if so turn off gzipping of any data sent back to the user's browser.
// Or you can just set CommandHelper::$ZIP_MESSAGE yourself to turn gzipping on or off.
CommandHelper::init();

// Validation examples;

// To validate a $POST or $GET para called 'myParaName' that is required and you expect to be numeric call;
$para = CommandHelper::getPara('myParaName', true, CommandHelper::$PARA_TYPE_NUMERIC);

// To validate a $POST or $GET para called 'myParaName' that is required and you expect to be a string call;
$para = CommandHelper::getPara('myParaName', true, CommandHelper::$PARA_TYPE_STRING);

// To validate a $POST or $GET para called 'myParaName' that is NOT required and you expect to be a json encoded object call;
$para = CommandHelper::getPara('myParaName', false, CommandHelper::$PARA_TYPE_JSON);

// If validation fails, the class will send a JSON message in the form
// {"result":"fail","data":"Validation failure: Parameter not set, expecting 'cmd'"}

// An example of sending a message back to the user, from an php object, which is sent as JSON;

$data = array(4);

$data['stat1'] = DatabaseManager::getVar("SELECT COUNT(stat1) AS no FROM statTable");
$data['stat2'] = DatabaseManager::getVar("SELECT COUNT(stat2) AS no FROM statTable");
$data['stat3'] = DatabaseManager::getVar("SELECT COUNT(stat3) AS no FROM statTable");
$data['stat4'] = DatabaseManager::getVar("SELECT COUNT(stat4) AS no FROM statTable");

$msg['cmd'] = 'getStats';
$msg['result'] = 'ok';
$msg['data'] = $data;

CommandHelper::sendMessage($msg);

// Or you can send any string that you'd like
CommandHelper::sendTextMessage("Undefined command!");

// There are also pre-defined error messages that can be sent;

// Check that a user is logged in, and that they have access to this site
if (!SecurityUtils::isLoggedInForSite($site_id)){
CommandHelper::sendAuthorizationFailMessage("You are not authorized for this site!");
die();
}

require_once("Logger.class.php");

// This tells the logger to echo html
Logger::echoLog();

// Tells the Logger to catch and log system errors
Logger::catchSysErrors();

// This tells the logger to email you fatal errors. The email will contain the error
// message as well as a dump of the POST, GET and SESSION variables
Logger::setupEmail($email, $projectName, $logLevel = self::$FATAL)  

// You can set the logging level (the default is debug)
// Level can be (in order);
// Logger::$DEBUG, Logger::$INFO, Logger::$ERROR, Logger::FATAL
// e.g., if you set the level to ERROR, only ERROR and FATAL messages would be outputted
// e.g., if you set the level to INFO, only INFO, ERROR & FATAL messages would be outputted
Logger::setLevel(Logger::$DEBUG);

// To use, call any of these
Logger::fatal("Some error message");
Logger::error("Some error message");
Logger::debug("Some error message");
Logger::info("Some error message");

// You can also dump a variable, array or object's contents with
Logger::dump($variable);

/**
* Logging class, use for all trace commands
*
*/
class Logger {

	public static $DEBUG	 	= 0;
	public static $INFO 		= 1;
	public static $WARNING 		= 2;
	public static $ERROR	 	= 3;
	public static $FATAL	 	= 4;

	private static $debugLevel = 0;

	private static $echoLog = false;

	private static $email		= "dev@adastrasystems.com";
	private static $project     = "Adastra Project";
	private static $sendEmail   = true;
	private static $emailLevel  = 4;

	// //////////////////////////////////////////////////////////////////////////////////////

	/**
	* Class constructor
	*/
	public function __construct(){
		self::init();
	}

	// //////////////////////////////////////////////////////////////////////////////////////

	public static function echoLog(){
		self::$echoLog = true;
	}

    // //////////////////////////////////////////////////////////////////////////////////////

    /**
     * Let the Logger catch any system errors
     */
    public static function catchSysErrors(){
        set_error_handler("Logger::sysErrorHandler");
    }

	// //////////////////////////////////////////////////////////////////////////////////////

	/**
	*
	*/
	private static function trace($level, $msg){

		if ($level < self::$debugLevel){
			return;
		}

		$bt = debug_backtrace();

		$class = "";
		$function = "";

		// get class, function called by caller of caller of caller
		if (isset($bt[2]['class'])){
			$class = $bt[2]['class'];
			$function = "." . $bt[2]['function'];
		}

		// get file, line where call to caller of caller was made
		$file = $bt[1]['file'];
		$line = $bt[1]['line'];

		$file_name = basename($file);

		if (self::$echoLog){

			switch($level){
				case self::$DEBUG: 	$levMsg = "debug"; break;
				case self::$INFO:  	$levMsg = "info"; break;
				case self::$WARNING:$levMsg = "warning"; break;
				case self::$ERROR: 	$levMsg = "error"; break;
				case self::$FATAL: 	$levMsg = "fatal"; break;
			}

			$msg = "[$levMsg $class$function] $msg";
			$msg .= " on line $line of $file_name";
			if (isset($bt[2]['file'])){
				$fname = basename($bt[2]['file']);
				$msg .= ", called from line ".$bt[2]['line']." of $fname";
			}
			$msg .= "\n";

			echo $msg;

			flush();

		}
		else {

			// Get IP address....

			// Translate level into text...
			$levMsg = "????";
			switch($level){
				case self::$DEBUG: 	$levMsg = "DEBUG"; break;
				case self::$INFO:  	$levMsg = "INFO"; break;
				case self::$WARNING:$levMsg = "WARNING"; break;
				case self::$ERROR: 	$levMsg = "ERROR"; break;
				case self::$FATAL: 	$levMsg = "FATAL"; break;
			}

			$msg = "[$levMsg] $class$function $msg";
			$msg .= " {on line $line of $file_name";
			if (isset($bt[2]['file'])){
				$fname = basename($bt[2]['file']);
				$msg .= ", called from line ".$bt[2]['line']." of $fname";
			}
			if (isset($bt[3]['file'])){
				$fname = basename($bt[3]['file']);
				$msg .= ", called from line ".$bt[3]['line']." of $fname";
			}
			$msg .= "}";

			error_log($msg);
		}

        if (self::$sendEmail){
			self::sendEmail($msg, $level);
        }		

	}

	// //////////////////////////////////////////////////////////////////////////////////////

	private static function sendEmail($msg, $level){

		if ($level < self::$emailLevel){
			return;
		}

		$headers = 'From: ' . self::$email;
		$message = $msg . "\n\nPOST VARIABLES \n\n" . print_r($_POST, true) . "\nGET VARIABLES\n\n" . print_r($_GET, true) . "\nSESSION VARIABLES\n\n" . print_r($_SESSION, true);
		mail(self::$email, self::$project, $message, $headers);
   	}

	// //////////////////////////////////////////////////////////////////////////////////////

    /**
     * Use to replace system error handler, if desired. Use Logger::catchSysErrors() to
     * activate
     */
    public static function sysErrorHandler($errno, $errstr, $errfile, $errline){

        switch ($errno) {
            case E_USER_ERROR:
                $levMsg = "SYS_ERROR";
                break;

            case E_USER_WARNING:
                $levMsg = "SYS_WARNING";
                break;

            case E_USER_NOTICE:
                $levMsg = "SYS_NOTICE";
                break;

            default:
                $levMsg = "SYS_UNKNOWN";
               break;
        }

        if (self::$echoLog){

			switch($errno){
				case E_USER_NOTICE:  $levMsg = "info"; break;
				case E_USER_WARNING:$levMsg = "warning"; break;
				case E_USER_ERROR: 	$levMsg = "error"; break;
				default: $levMsg = "debug"; break;
			}

			$msg = "[$levMsg #$errno] $errstr";
			$msg .= " on line $errline of ".basename($errfile)."";
			$msg .= "\n";

			echo $msg;

			flush();

        }
        else {

            $msg = "[$levMsg] No: $errno Msg: $errstr";
            $msg .= " {on line $errline of ".basename($errfile)."}";

            error_log($msg);
        }

        /* Don't execute PHP internal error handler */
        return true;
    }

    // //////////////////////////////////////////////////////////////////////////////////////

	public static function setupEmail($email, $projectName, $logLevel = self::$FATAL) {
		self::$sendEmail = true;
		self::$emailLevel = $logLevel;
		self::$project = $projectName;
	}

    // //////////////////////////////////////////////////////////////////////////////////////

	public static function setLevel($newLevel) { $debugLevel = $newLevel; }

	public static function setLevelDebug() { self::$debugLevel = self::$DEBUG; }
	public static function setLevelInfo() { self::$debugLevel = self::$INFO; }
	public static function setLevelWarning() { self::$debugLevel = self::$WARNING; }
	public static function setLevelError() { self::$debugLevel = self::$ERROR; }
	public static function setLevelFatal() { self::$debugLevel = self::$FATAL; }

	// //////////////////////////////////////////////////////////////////////////////////////

	public static function dump($var) { self::debug(print_r($var, true)); }
	public static function debug($msg){ self::trace(self::$DEBUG, $msg);	}
	public static function warning($msg){ self::trace(self::$WARNING, $msg);	}
	public static function warn($msg){ self::trace(self::$WARNING, $msg);	}
	public static function error($msg){ self::trace(self::$ERROR, $msg);	}
	public static function info($msg){  self::trace(self::$INFO, $msg);	}
	public static function fatal($msg){ self::trace(self::$FATAL, $msg);	die(); }

	// //////////////////////////////////////////////////////////////////////////////////////
}

    
        
        
        
        
        
    
    



    
        
            
        
    
    



    
        
            
         
    
    


        
            
        

        
            
            
        
    



    Post clean
    
        
            
        
    

    
        
        

        
        

        
        

        
            MyCompany
        

        
            Copyright (c) 2009 MyCompany
        

        
            
                MyCompany
            

            
                MyApp.cod