|
Server : Apache/2.2.17 (Unix) mod_ssl/2.2.17 OpenSSL/0.9.8e-fips-rhel5 DAV/2 PHP/5.2.17 System : Linux localhost 2.6.18-419.el5 #1 SMP Fri Feb 24 22:47:42 UTC 2017 x86_64 User : nobody ( 99) PHP Version : 5.2.17 Disable Function : NONE Directory : /home/queenjbs/www/FusionChart/Code/CS/Export_Handler/ |
Upload File : |
/**
*
* FusionCharts Exporter is an ASP.NET C# script that handles
* FusionCharts (since v3.1) Server Side Export feature.
* This in conjuncture with various export classes would
* process FusionCharts Export Data POSTED to it from FusionCharts
* and convert the data to image or PDF and subsequently save to the
* server or response back as http response to client side as download.
*
* This script might be called as the FusionCharts Exporter - main module
*
* @author FusionCharts
* @description FusionCharts Exporter (Server-Side - ASP.NET C#)
* @version 2.0 [ 22 February 2009 ]
*
*/
/**
* ChangeLog / Version History:
* ----------------------------
*
* 2.0 [ 12 February 2009 ]
* - Integrated with new Export feature of FusionCharts 3.1
* - can save to server side directory
* - can provide download or open in popup window.
* - can report back to chart
* - can save as PDF/JPG/PNG/GIF
*
* 1.0 [ 16 August 2007 ]
* - can process chart data to jpg image and response back to client side as download.
*
*/
/**
* Copyright (c) 2009 InfoSoft Global Private Limited. All Rights Reserved
*
*/
/**
* GENERAL NOTES
* -------------
*
* Chart would POST export data (which consists of encoded image data stream,
* width, height, background color and various other export parameters like
* exportFormat, exportFileName, exportAction, exportTargetWindow) to this script.
*
* The script would process this data using appropriate resource classes & build
* export binary (PDF/image)
*
* It either saves the binary as file to a server side directory or push it as
* Download to client side.
*
*
* ISSUES
* ------
* Q. What if someone wishes to open in the same page where the chart existed as postback
* replacing the old page?
*
* A. Not directly supported using any chart attribute or parameter but can do by
* removing/commenting the line containing 'header( content-disposition ...'
*
*/
/**
*
* @requires FCIMGGenerator Class to export FusionCharts image data to JPG, PNG, GIF binary
* @requires FCPDFGenerator Class to export FusionCharts image data to PDF binary
*
*/
using System;
using System.IO;
using System.Web;
using System.Drawing;
using System.Collections;
using System.Drawing.Imaging;
using System.Text.RegularExpressions;
/// <summary>
/// FusionCharts Exporter is an ASP.NET C# script that handles
/// FusionCharts (since v3.1) Server Side Export feature.
/// This in conjuncture with other resource classses would
/// process FusionCharts Export Data POSTED to it from FusionCharts
/// and convert the data to an image or a PDF. Subsequently, it would save
/// to the server or respond back as an HTTP response to client side as download.
///
/// This script might be called as the FusionCharts Exporter - main module
/// </summary>
///
public partial class FCExporter : System.Web.UI.Page
{
/// <summary>
/// IMPORTANT: You need to change the location of folder where
/// the exported chart images/PDFs will be saved on your
/// server. Please specify the path to a folder with
/// write permissions in the constant SAVE_PATH below.
///
/// Please provide the path as per ASP.NET path conventions.
/// You can use relative or absolute path.
///
/// Special Cases:
/// '/' means 'wwwroot' directory.
/// '. /' ( without the space after .) is the directory where the FCExporter.aspx file recides.
///
/// Absolute Path :
///
/// can be like this : "C:\\myFolders\\myImages"
/// ( Please never use single backslash as that would stop execution of the code instantly)
/// or "C:/myFolders/myImages"
///
/// You may have a // or \ at end : "C:\\myFolders\\myImages\\" or "C:/myFolders/myImages/"
///
/// You can also have mixed slashes : "C:\\myFolders/myImages"
///
///
/// </summary>
/// directory where the FCExporter.aspx file recides
private const string SAVE_PATH = "../Export/Exported_Images/";
/// <summary>
/// IMPORTANT: This constant HTTP_URI stores the HTTP reference to
/// the folder where exported charts will be saved.
/// Please enter the HTTP representation of that folder
/// in this constant e.g., http://www.yourdomain.com/images/
/// </summary>
private const string HTTP_URI = "Exported_Images/";
/// <summary>
/// OVERWRITEFILE sets whether the export handler would overwrite an existing file
/// the newly created exported file. If it is set to false the export handler would
/// not overwrite. In this case, if INTELLIGENTFILENAMING is set to true the handler
/// would add a suffix to the new file name. The suffix is a randomly generated GUID.
/// Additionally, you add a timestamp or a random number as additional suffix.
/// </summary>
private bool OVERWRITEFILE = false;
private bool INTELLIGENTFILENAMING = true;
private string FILESUFFIXFORMAT = "TIMESTAMP";// // value can be either 'TIMESTAMP' or 'RANDOM'
/// <summary>
/// This is a constant list of the MIME types related to each export format this resource handles
/// The value is semicolon separated key value pair for each format
/// Each key is the format and value is the MIME type
/// </summary>
private const string MIMETYPES = "pdf=application/pdf;jpg=image/jpeg;jpeg=image/jpeg;gif=image/gif;png=image/png";
/// <summary>
/// This is a constant list of all the file extensions for the export formats
/// The value is semicolon separated key value pair for each format
/// Each key is the format and value is the file extension
/// </summary>
private const string EXTENSIONS = "pdf=pdf;jpg=jpg;jpeg=jpg;gif=gif;png=png";
/// <summary>
/// Lists the default exportParameter values taken, if not provided by chart
/// </summary>
private const string DEFAULTPARAMS = "exportfilename=FusionCharts;exportformat=PDF;exportaction=download;exporttargetwindow=_self";
/// <summary>
/// Stores server notices, if any as string [ to be sent back to chart after save ]
/// </summary>
private string notices = "";
/// <summary>
/// Whether the export action is download. Default value. Would change as per setting retrieved from chart.
/// </summary>
private bool isDownload = true;
/// <summary>
/// DOMId of the chart
/// </summary>
private string DOMId;
/// <summary>
/// The main function that handles all Input - Process - Output of this Export Architecture
/// </summary>
/// <param name="sender">FusionCharts chart SWF</param>
/// <param name="e"></param>
protected void Page_Load(object sender, EventArgs e)
{
/**
* Retrieve export data from POST Request sent by chart
* Parse the Request stream into export data readable by this script
*/
Hashtable exportData = parseExportRequestStream();
// process export data and get the processed data (image/PDF) to be exported
MemoryStream exportObject = exportProcessor(((Hashtable)exportData["parameters"])["exportformat"].ToString(), exportData["stream"].ToString(), (Hashtable)exportData["meta"]);
/*
* Send the export binary to output module which would either save to a server directory
* or send the export file to download. Download terminates the process while
* after save the output module sends back export status
*/
object exportedStatus = outputExportObject(exportObject, (Hashtable)exportData["parameters"]);
// Dispose export object
exportObject.Close();
exportObject.Dispose();
/*
* Build Appropriate Export Status and send back to chart by flushing the
* procesed status to http response. This returns status back to chart.
* [ This is not applicable when Download action took place ]
*/
flushStatus(exportedStatus, (Hashtable)exportData["meta"]);
}
/// <summary>
/// Parses POST stream from chart and builds a Hashtable containing
/// export data and parameters in a format readable by other functions.
/// The Hashtable contains keys 'stream' (contains encoded
/// image data) ; 'meta' ( Hashtable with 'width', 'height' and 'bgColor' keys) ;
/// and 'parameters' ( Hashtable of all export parameters from chart as keys, like - exportFormat,
/// exportFileName, exportAction etc.)
/// </summary>
/// <returns>Hashtable of processed export data and parameters.</returns>
private Hashtable parseExportRequestStream()
{
// store all export data
Hashtable exportData = new Hashtable();
//String of compressed image data
exportData["stream"] = Request["stream"];
//Halt execution if image stream is not provided.
if (Request["stream"] == null || Request["stream"].Trim() == "") raise_error("100", true);
//Get all export parameters into a Hastable
Hashtable parameters = parseParams(Request["parameters"]);
exportData["parameters"] = parameters;
//get width and height of the chart
Hashtable meta = new Hashtable();
meta["width"] = Request["meta_width"];
//Halt execution on error
if (Request["meta_width"] == null || Request["meta_width"].Trim() == "") raise_error("101", true);
meta["height"] = Request["meta_height"];
//Halt execution on error
if (Request["meta_height"] == null || Request["meta_height"].Trim() == "") raise_error("101", true);
//Background color of chart
meta["bgcolor"] = Request["meta_bgColor"];
if (Request["meta_bgColor"] == null || Request["meta_bgColor"].Trim() == "")
{
// Send notice if BgColor is not provided
raise_error(" Background color not specified. Taking White (FFFFFF) as default background color.");
// Set White as Default Background color
meta["bgcolor"] = meta["bgcolor"].ToString().Trim() == "" ? "FFFFFF" : meta["bgcolor"];
}
// DOMId of the chart
meta["DOMId"] = Request["meta_DOMId"] == null ? "" : Request["meta_DOMId"];
DOMId = meta["DOMId"].ToString();
exportData["meta"] = meta;
return exportData;
}
/// <summary>
/// Parse export 'parameters' string into a Hashtable
/// Also synchronise default values from defaultparameterValues Hashtable
/// </summary>
/// <param name="strParams">A string with parameters (key=value pairs) separated by | (pipe)</param>
/// <returns>Hashtable containing parsed key = value pairs.</returns>
private Hashtable parseParams(string strParams)
{
//default parameter values
Hashtable defaultParameterValues = bang(DEFAULTPARAMS);
// get parameters
Hashtable parameters = bang(strParams, new char[] { '|', '=' });
// sync with default values
// iterate through each default parameter value
foreach (DictionaryEntry param in defaultParameterValues)
{
// if a parameter from the defaultParameterValues Hashtable is not present
// in the parameters hashtable take the parameter and value from default
// parameter hashtable and add it to params hashtable
// This is needed to ensure proper export
if (parameters[param.Key] == null) parameters[param.Key] = param.Value.ToString();
}
// set a global flag which denotes whether the export is download or not
// this is needed in many a functions
isDownload = parameters["exportaction"].ToString().ToLower() == "download";
// return parameters
return parameters;
}
/// <summary>
/// Get Export data from and build the export binary/objct.
/// </summary>
/// <param name="strFormat">(string) Export format</param>
/// <param name="stream">(string) Export image data in FusionCharts compressed format</param>
/// <param name="meta">{Hastable)Image meta data in keys "width", "heigth" and "bgColor"</param>
/// <returns></returns>
private MemoryStream exportProcessor(string strFormat, string stream, Hashtable meta)
{
strFormat = strFormat.ToLower();
// initilize memeory stream object to store output bytes
MemoryStream exportObjectStream = new MemoryStream();
// Handle Export class as per export format
switch (strFormat)
{
case "pdf":
// Instantiate Export class for PDF, build Binary stream and store in stream object
FCPDFGenerator PDFGEN = new FCPDFGenerator(stream, meta["width"].ToString(), meta["height"].ToString(), meta["bgcolor"].ToString());
exportObjectStream = PDFGEN.getBinaryStream(strFormat);
break;
case "jpg":
case "jpeg":
case "png":
case "gif":
// Instantiate Export class for Images, build Binary stream and store in stream object
FCIMGGenerator IMGGEN = new FCIMGGenerator(stream, meta["width"].ToString(), meta["height"].ToString(), meta["bgcolor"].ToString());
exportObjectStream = IMGGEN.getBinaryStream(strFormat);
break;
default:
// In case the format is not recognized
raise_error(" Invalid Export Format.", true);
break;
}
return exportObjectStream;
}
/// <summary>
/// Checks whether the export action is download or save.
/// If action is 'download', send export parameters to 'setupDownload' function.
/// If action is not-'download', send export parameters to 'setupServer' function.
/// In either case it gets exportSettings and passes the settings along with
/// processed export binary (image/PDF) to the output handler function if the
/// export settings return a 'ready' flag set to 'true' or 'download'. The export
/// process would stop here if the action is 'download'. In the other case,
/// it gets back success status from output handler function and returns it.
/// </summary>
/// <param name="exportObj">Export binary/object in memery stream</param>
/// <param name="exportParams">Hashtable of export parameters</param>
/// <returns>Export success status ( filename if success, false if not)</returns>
private object outputExportObject(MemoryStream exportObj, Hashtable exportParams)
{
//pass export paramters and get back export settings as per export action
Hashtable exportActionSettings = (isDownload ? setupDownload(exportParams) : setupServer(exportParams));
// set default export status to true
bool status = true;
// filepath returned by server setup would be a string containing the file path
// where the export file is to be saved.
// If filepath is a boolean (i.e. false) the server setup must have failed. Hence, terminate process.
if (exportActionSettings["filepath"] is bool)
{
status = false;
raise_error(" Failed to export.", true);
}
else
{
// When 'filepath' is a sting write the binary to output stream
try
{
// Write export binary stream to output stream
Stream outStream = (Stream)exportActionSettings["outStream"];
exportObj.WriteTo(outStream);
outStream.Flush();
outStream.Close();
exportObj.Close();
}
catch (ArgumentNullException e)
{
raise_error(" Failed to export. Error:" + e.Message);
status = false;
}
catch (ObjectDisposedException e)
{
raise_error(" Failed to export. Error:" + e.Message);
status = false;
}
if (isDownload)
{
// If 'download'- terminate imediately
// As nothing is to be written to response now.
Response.End();
}
}
// This is the response after save action
// If status remains true return the 'filepath'. Otherwise return false to denote failure.
return (status ? exportActionSettings["filepath"] : false);
}
/// <summary>
/// Flushes exported status message/or any status message to the chart or the output stream.
/// It parses the exported status through parser function parseExportedStatus,
/// builds proper response string using buildResponse function and flushes the response
/// string to the output stream and terminates the program.
/// </summary>
/// <param name="filename">Name of the exported file or false on failure</param>
/// <param name="meta">Image's meta data</param>
/// <param name="msg">Additional messages</param>
private void flushStatus(object filename, Hashtable meta, string msg)
{
// Process and flush message to response stream and terminate
Response.Output.Write(buildResponse(parseExportedStatus(filename, meta, msg)));
Response.Flush();
Response.End();
}
/// <summary>
/// Flushes exported status message/or any status message to the chart or the output stream.
/// It parses the exported status through parser function parseExportedStatus,
/// builds proper response string using buildResponse function and flushes the response
/// string to the output stream and terminates the program.
/// </summary>
/// <param name="filename">Name of the exported file or false on failure</param>
/// <param name="meta">Image's meta data</param>
/// <param name="meta"></param>
private void flushStatus(object filename, Hashtable meta)
{
flushStatus(filename, meta, "");
}
/// <summary>
/// Parses the exported status and builds an array of export status information. As per
/// status it builds a status array which contains statusCode (0/1), statusMesage, fileName,
/// width, height and notice in some cases.
/// </summary>
/// <param name="filename">exported status ( false if failed/error, filename as stirng if success)</param>
/// <param name="meta">Hastable containing meta descriptions of the chart like width, height</param>
/// <param name="msg">custom message to be added as statusMessage.</param>
/// <returns></returns>
private ArrayList parseExportedStatus(object filename, Hashtable meta, string msg)
{
ArrayList arrStatus = new ArrayList();
// get status
bool status = (filename is string ? true : false);
// add notices
if (notices.Trim() != "") arrStatus.Add("notice=" + notices.Trim());
// DOMId of the chart
arrStatus.Add("DOMId=" + (meta["DOMId"]==null? DOMId : meta["DOMId"].ToString()));
// add width and height
// provide 0 as width and height on failure
if (meta["width"] == null) meta["width"] = "0";
if (meta["height"] == null) meta["height"] = "0";
arrStatus.Add("height=" + (status ? meta["height"].ToString() : "0"));
arrStatus.Add("width=" + (status ? meta["width"].ToString() : "0"));
// add file URI
arrStatus.Add("fileName=" + (status ? (Regex.Replace(HTTP_URI, @"([^\/]$)", "${1}/") + filename) : ""));
arrStatus.Add("statusMessage=" + (msg.Trim() != "" ? msg.Trim() : (status ? "Success" : "Failure")));
arrStatus.Add("statusCode=" + (status ? "1" : "0"));
return arrStatus;
}
/// <summary>
/// Builds response from an array of status information. Joins the array to a string.
/// Each array element should be a string which is a key=value pair. This array are either joined by
/// a & to build a querystring (to pass to chart) or joined by a HTML <BR> to show neat
/// and clean status informaton in Browser window if download fails at the processing stage.
/// </summary>
/// <param name="arrMsg">Array of string containing status data as [key=value ]</param>
/// <returns>A string to be written to output stream</returns>
private string buildResponse(ArrayList arrMsg)
{
// Join export status array elements into querystring key-value pairs in case of 'save' action
// or separate with <BR> in case of 'download' action. This would make the imformation readable in browser window.
string msg = isDownload ? "" : "&";
msg += string.Join((isDownload ? "<br>" : "&"), (string[])arrMsg.ToArray(typeof(string)));
return msg;
}
/// <summary>
/// Finds if a directory is writable
/// </summary>
/// <param name="path">String Path</param>
/// <returns></returns>
private bool isDirectoryWritable(string path)
{
DirectoryInfo info = new DirectoryInfo(path);
return (info.Attributes & FileAttributes.ReadOnly) != FileAttributes.ReadOnly;
}
/// <summary>
/// check server permissions and settings and return ready flag to exportSettings
/// </summary>
/// <param name="exportParams">Various export parameters</param>
/// <returns>Hashtable containing various export settings</returns>
private Hashtable setupServer(Hashtable exportParams)
{
//get export file name
string exportFile = exportParams["exportfilename"].ToString();
// get extension related to specified type
string ext = getExtension(exportParams["exportformat"].ToString());
Hashtable retServerStatus = new Hashtable();
//set server status to true by default
retServerStatus["ready"] = true;
// Open a FileStream to be used as outpur stream when the file would be saved
FileStream fos;
// process SAVE_PATH : the path where export file would be saved
// add a / at the end of path if / is absent at the end
string path = SAVE_PATH;
// if path is null set it to folder where FCExporter.aspx is present
if (path.Trim() == "") path = "./";
path = Regex.Replace(path, @"([^\/]$)", "${1}/");
try
{
// check if the path is relative if so assign the actual path to path
path = HttpContext.Current.Server.MapPath(path);
}
catch (HttpException e)
{
raise_error(e.Message);
}
// check whether directory exists
// raise error and halt execution if directory does not exists
if (!Directory.Exists(path)) raise_error(" Server Directory does not exist.", true);
// check if directory is writable or not
bool dirWritable = isDirectoryWritable(path);
// build filepath
retServerStatus["filepath"] = exportFile + "." + ext;
// check whether file exists
if (!File.Exists(path + retServerStatus["filepath"].ToString()))
{
// need to create a new file if does not exists
// need to check whether the directory is writable to create a new file
if (dirWritable)
{
// if directory is writable return with ready flag
// open the output file in FileStream
fos = File.Open(path + retServerStatus["filepath"].ToString(), FileMode.Create, FileAccess.Write);
// set the output stream to the FileStream object
retServerStatus["outStream"] = fos;
return retServerStatus;
}
else
{
// if not writable halt and raise error
raise_error("403", true);
}
}
// add notice that file exists
raise_error(" File already exists.");
//if overwrite is on return with ready flag
if (OVERWRITEFILE)
{
// add notice while trying to overwrite
raise_error(" Export handler's Overwrite setting is on. Trying to overwrite.");
// see whether the existing file is writable
// if not halt raising error message
if ((new FileInfo(path + retServerStatus["filepath"].ToString())).IsReadOnly)
raise_error(" Overwrite forbidden. File cannot be overwritten.", true);
// if writable return with ready flag
// open the output file in FileStream
// set the output stream to the FileStream object
fos = File.Open(path + retServerStatus["filepath"].ToString(), FileMode.Create, FileAccess.Write);
retServerStatus["outStream"] = fos;
return retServerStatus;
}
// raise error and halt execution when overwrite is off and intelligent naming is off
if (!INTELLIGENTFILENAMING)
{
raise_error(" Export handler's Overwrite setting is off. Cannot overwrite.", true);
}
raise_error(" Using intelligent naming of file by adding an unique suffix to the exising name.");
// Intelligent naming
// generate new filename with additional suffix
exportFile = exportFile + "_" + generateIntelligentFileId();
retServerStatus["filepath"] = exportFile + "." + ext;
// return intelligent file name with ready flag
// need to check whether the directory is writable to create a new file
if (dirWritable)
{
// if directory is writable return with ready flag
// add new filename notice
// open the output file in FileStream
// set the output stream to the FileStream object
raise_error(" The filename has changed to " + retServerStatus["filepath"].ToString() + ".");
fos = File.Open(path + retServerStatus["filepath"].ToString(), FileMode.Create, FileAccess.Write);
// set the output stream to the FileStream object
retServerStatus["outStream"] = fos;
return retServerStatus;
}
else
{
// if not writable halt and raise error
raise_error("403", true);
}
// in any unknown case the export should not execute
retServerStatus["ready"] = false;
raise_error(" Not exported due to unknown reasons.");
return retServerStatus;
}
/// <summary>
/// setup download headers and return ready flag in exportSettings
/// </summary>
/// <param name="exportParams">Various export parameters</param>
/// <returns>Hashtable containing various export settings</returns>
private Hashtable setupDownload(Hashtable exportParams)
{
//get export filename
string exportFile = exportParams["exportfilename"].ToString();
//get extension
string ext = getExtension(exportParams["exportformat"].ToString());
//get mime type
string mime = getMime(exportParams["exportformat"].ToString());
// get target window
string target = exportParams["exporttargetwindow"].ToString().ToLower();
// set content-type header
Response.ContentType = mime;
// set content-disposition header
// when target is _self the type is 'attachment'
// when target is other than self type is 'inline'
// NOTE : you can comment this line in order to replace present window (_self) content with the image/PDF
Response.AddHeader("Content-Disposition", (target == "_self" ? "attachment" : "inline") + "; filename=\"" + exportFile + "." + ext + "\"");
// return exportSetting array. 'Ready' key should be set to 'download'
Hashtable retStatus = new Hashtable();
retStatus["filepath"] = "";
// set the output strem to Response stream as the file is going to be downloaded
retStatus["outStream"] = Response.OutputStream;
return retStatus;
}
/// <summary>
/// gets file extension checking the export type.
/// </summary>
/// <param name="exportType">(string) export format</param>
/// <returns>string extension name</returns>
private string getExtension(string exportType)
{
// get a Hashtable array of [type=> extension]
// from EXTENSIONS constant
Hashtable extensionList = bang(EXTENSIONS);
exportType = exportType.ToLower();
// if extension type is present in $extensionList return it, otherwise return the type
return (extensionList[exportType].ToString() != null ? extensionList[exportType].ToString() : exportType);
}
/// <summary>
/// gets mime type for an export type
/// </summary>
/// <param name="exportType">Export format</param>
/// <returns>Mime type as stirng</returns>
private string getMime(string exportType)
{
// get a Hashtable array of [type=> extension]
// from MIMETYPES constant
Hashtable mimelist = bang(MIMETYPES);
string ext = getExtension(exportType);
// get mime type asociated to extension
string mime = mimelist[ext].ToString() != null ? mimelist[ext].ToString() : "";
return mime;
}
/// <summary>
/// generates a file suffix for a existing file name to apply smart file naming
/// </summary>
/// <returns>a string containing GUID and random number /timestamp</returns>
private string generateIntelligentFileId()
{
// Generate Guid
string guid = System.Guid.NewGuid().ToString("D");
// check FILESUFFIXFORMAT type
if (FILESUFFIXFORMAT.ToLower() == "timestamp")
{
// Add time stamp with file name
guid += "_" + DateTime.Now.ToString("ddMMyyyyHHmmssff");
}
else
{
// Add Random Number with fileName
guid += "_" + (new Random()).Next().ToString();
}
return guid;
}
/// <summary>
/// Helper function that splits a string containing delimiter separated key value pairs
/// into hashtable
/// </summary>
/// <param name="str">delimiter separated key value pairs</param>
/// <param name="delimiterList">List of delimiters</param>
/// <returns></returns>
private Hashtable bang(string str, char[] delimiterList)
{
Hashtable retArray = new Hashtable();
// split string as per first delimiter
if (str == null || str.Trim() == "") return retArray;
string[] tmpArray = str.Split(delimiterList[0]);
// iterate through each element of split string
for (int i = 0; i < tmpArray.Length; i++)
{
// split each element as per second delimiter
string[] tmp2Array = tmpArray[i].Split(delimiterList[1]);
if (tmp2Array.Length >= 2)
{
// if the secondary split creats at-least 2 array elements
// make the fisrt element as the key and the second as the value
// of the resulting array
retArray[tmp2Array[0].ToLower()] = tmp2Array[1];
}
}
return retArray;
}
private Hashtable bang(string str)
{
return bang(str, new char[2] { ';', '=' });
}
private void raise_error(string msg)
{
raise_error(msg, false);
}
/// <summary>
/// Error reporter function that has a list of error messages. It can terminate the execution
/// and send successStatus=0 along with a error message. It can also append notice to a global variable
/// and continue execution of the program.
/// </summary>
/// <param name="msg">error code as Integer (referring to the index of the errMessages
/// array containing list of error messages) OR, it can be a string containing the error message/notice</param>
/// <param name="halt">Whether to halt execution</param>
private void raise_error(string msg, bool halt)
{
Hashtable errMessages = new Hashtable();
//list of defined error messages
errMessages["100"] = " Insufficient data.";
errMessages["101"] = " Width/height not provided.";
errMessages["102"] = " Insufficient export parameters.";
errMessages["400"] = " Bad request.";
errMessages["401"] = " Unauthorized access.";
errMessages["403"] = " Directory write access forbidden.";
errMessages["404"] = " Export Resource class not found.";
// Find whether error message is passed in msg or it is a custom error string.
string err_message = ((msg == null || msg.Trim() == "") ? "ERROR!" :
(errMessages[msg] == null ? msg : errMessages[msg].ToString())
);
// Halt executon after flushing the error message to response (if halt is true)
if (halt)
{
flushStatus(false, new Hashtable(), err_message);
}
// add error to notices global variable
else
{
notices += err_message;
}
}
}
/// <summary>
/// FusionCharts Image Generator Class
/// FusionCharts Exporter - 'Image Resource' handles
/// FusionCharts (since v3.1) Server Side Export feature that
/// helps FusionCharts exported as Image files in various formats.
/// </summary>
public class FCIMGGenerator
{
//Array - Stores multiple chart export data
private ArrayList arrExportData = new ArrayList();
//stores number of pages = length of $arrExportData array
private int numPages = 0;
/// <summary>
/// Generates bitmap data for the image from a FusionCharts export format
/// the height and width of the original export needs to be specified
/// the default background color can also be specified
/// </summary>
public FCIMGGenerator(string imageData_FCFormat, string width, string height, string bgcolor)
{
setBitmapData(imageData_FCFormat, width, height, bgcolor);
}
/// <summary>
/// Gets the binary data stream of the image
/// The passed parameter determines the file format of the image
/// to be exported
/// </summary>
public MemoryStream getBinaryStream(string strFormat)
{
// the image object
Bitmap exportObj = getImageObject();
// initiates a new binary data sream
MemoryStream outStream = new MemoryStream();
// determines the image format
switch (strFormat)
{
case "jpg":
case "jpeg":
exportObj.Save(outStream, ImageFormat.Jpeg);
break;
case "png":
exportObj.Save(outStream, ImageFormat.Png);
break;
case "gif":
exportObj.Save(outStream,ImageFormat.Gif);
break;
case "tiff":
exportObj.Save(outStream, ImageFormat.Tiff);
break;
default:
exportObj.Save(outStream, ImageFormat.Bmp);
break;
}
exportObj.Dispose();
return outStream;
}
/// <summary>
/// Generates bitmap data for the image from a FusionCharts export format
/// the height and width of the original export needs to be specified
/// the default background color can also be specified
/// </summary>
private void setBitmapData(string imageData_FCFormat, string width, string height, string bgcolor)
{
Hashtable chartExportData = new Hashtable();
chartExportData["width"] = width;
chartExportData["height"] = height;
chartExportData["bgcolor"] = bgcolor;
chartExportData["imagedata"] = imageData_FCFormat;
arrExportData.Add(chartExportData);
numPages++;
}
/// <summary>
/// Generates bitmap data for the image from a FusionCharts export format
/// the height and width of the original export needs to be specified
/// the default background color should also be specified
/// </summary>
private Bitmap getImageObject(int id)
{
Hashtable rawImageData = (Hashtable)arrExportData[id];
// create blank bitmap object which would store image pixel data
Bitmap image = new Bitmap(Convert.ToInt16(rawImageData["width"]), Convert.ToInt16(rawImageData["height"]), System.Drawing.Imaging.PixelFormat.Format24bppRgb);
// drwaing surface
Graphics gr = Graphics.FromImage(image);
// set background color
gr.Clear(ColorTranslator.FromHtml("#" + rawImageData["bgcolor"].ToString()));
string[] rows = rawImageData["imagedata"].ToString().Split(';');
for (int yPixel = 0; yPixel < rows.Length; yPixel++)
{
//Split each row into 'color_count' columns.
String[] color_count = rows[yPixel].Split(',');
//Set horizontal row index to 0
int xPixel = 0;
for (int col = 0; col < color_count.Length; col++)
{
//Now, if it's not empty, we process it
//Split the 'color_count' into color and repeat factor
String[] split_data = color_count[col].Split('_');
//Reference to color
string hexColor = split_data[0];
//refer to repeat factor
int fRepeat = int.Parse(split_data[1]);
//If color is not empty (i.e. not background pixel)
if (hexColor != "")
{
//If the hexadecimal code is less than 6 characters, pad with 0
hexColor = hexColor.Length < 6 ? hexColor.PadLeft(6, '0') : hexColor;
for (int k = 1; k <= fRepeat; k++)
{
//draw pixel with specified color
image.SetPixel(xPixel, yPixel, ColorTranslator.FromHtml("#" + hexColor));
//Increment horizontal row count
xPixel++;
}
}
else
{
//Just increment horizontal index
xPixel += fRepeat;
}
}
}
gr.Dispose();
return image;
}
/// <summary>
/// Retreives the bitmap image object
/// </summary>
private Bitmap getImageObject()
{
return getImageObject(0);
}
}
/// <summary>
/// FusionCharts Exporter - 'PDF Resource' handles
/// FusionCharts (since v3.1) Server Side Export feature that
/// helps FusionCharts exported as PDF file.
/// </summary>
public class FCPDFGenerator
{
//Array - Stores multiple chart export data
private ArrayList arrExportData = new ArrayList();
//stores number of pages = length of $arrExportData array
private int numPages = 0;
/// <summary>
/// Generates a PDF file with the given parameters
/// The imageData_FCFormat parameter is the FusionCharts export format data
/// width, height are the respective width and height of the original image
/// bgcolor determines the default background colour
/// </summary>
public FCPDFGenerator(string imageData_FCFormat, string width, string height, string bgcolor)
{
setBitmapData(imageData_FCFormat, width, height, bgcolor);
}
/// <summary>
/// Gets the binary data stream of the image
/// The passed parameter determines the file format of the image
/// to be exported
/// </summary>
public MemoryStream getBinaryStream(string strFormat)
{
byte[] exportObj = getPDFObjects(true);
MemoryStream outStream = new MemoryStream();
outStream.Write(exportObj, 0, exportObj.Length);
return outStream;
}
/// <summary>
/// Generates bitmap data for the image from a FusionCharts export format
/// the height and width of the original export needs to be specified
/// the default background color should also be specified
/// </summary>
private void setBitmapData(string imageData_FCFormat, string width, string height, string bgcolor)
{
Hashtable chartExportData = new Hashtable();
chartExportData["width"] = width;
chartExportData["height"] = height;
chartExportData["bgcolor"] = bgcolor;
chartExportData["imagedata"] = imageData_FCFormat;
arrExportData.Add(chartExportData);
numPages++;
}
//create image PDF object containing the chart image
private byte[] addImageToPDF(int id, bool isCompressed)
{
MemoryStream imgObj = new MemoryStream();
//PDF Object number
int imgObjNo = 6 + id * 3;
//Get chart Image binary
byte[] imgBinary = getBitmapData24(id, isCompressed);
//get the length of the image binary
int len = imgBinary.Length;
string width = getMeta("width", id);
string height = getMeta("height", id);
//Build PDF object containing the image binary and other formats required
//string strImgObjHead = imgObjNo.ToString() + " 0 obj\n<<\n/Subtype /Image /ColorSpace /DeviceRGB /BitsPerComponent 8 /HDPI 72 /VDPI 72 " + (isCompressed ? "" : "") + "/Width " + width + " /Height " + height + " /Length " + len.ToString() + " >>\nstream\n";
string strImgObjHead = imgObjNo.ToString() + " 0 obj\n<<\n/Subtype /Image /ColorSpace /DeviceRGB /BitsPerComponent 8 /HDPI 72 /VDPI 72 " + (isCompressed ? "/Filter /RunLengthDecode " : "") + "/Width " + width + " /Height " + height + " /Length " + len.ToString() + " >>\nstream\n";
imgObj.Write(stringToBytes(strImgObjHead), 0, strImgObjHead.Length);
imgObj.Write(imgBinary, 0, (int)imgBinary.Length);
string strImgObjEnd = "endstream\nendobj\n";
imgObj.Write(stringToBytes(strImgObjEnd), 0, strImgObjEnd.Length);
imgObj.Close();
return imgObj.ToArray();
}
private byte[] addImageToPDF(int id)
{
return addImageToPDF(id, true);
}
private byte[] addImageToPDF()
{
return addImageToPDF(0, true);
}
//Main PDF builder function
private byte[] getPDFObjects()
{
return getPDFObjects(true);
}
private byte[] getPDFObjects(bool isCompressed)
{
MemoryStream PDFBytes = new MemoryStream();
//Store all PDF objects in this temporary string to be written to ByteArray
string strTmpObj = "";
//start xref array
ArrayList xRefList = new ArrayList();
xRefList.Add("xref\n0 ");
xRefList.Add("0000000000 65535 f \n"); //Address Refenrece to obj 0
//Build PDF objects sequentially
//version and header
strTmpObj = "%PDF-1.3\n%{FC}\n";
PDFBytes.Write(stringToBytes(strTmpObj), 0, strTmpObj.Length);
//OBJECT 1 : info (optional)
strTmpObj = "1 0 obj<<\n/Author (FusionCharts)\n/Title (FusionCharts)\n/Creator (FusionCharts)\n>>\nendobj\n";
xRefList.Add(calculateXPos((int)PDFBytes.Length)); //refenrece to obj 1
PDFBytes.Write(stringToBytes(strTmpObj), 0, strTmpObj.Length);
//OBJECT 2 : Starts with Pages Catalogue
strTmpObj = "2 0 obj\n<< /Type /Catalog /Pages 3 0 R >>\nendobj\n";
xRefList.Add(calculateXPos((int)PDFBytes.Length)); //refenrece to obj 2
PDFBytes.Write(stringToBytes(strTmpObj), 0, strTmpObj.Length);
//OBJECT 3 : Page Tree (reference to pages of the catalogue)
strTmpObj = "3 0 obj\n<< /Type /Pages /Kids [";
for (int i = 0; i < numPages; i++)
{
strTmpObj += (((i + 1) * 3) + 1) + " 0 R\n";
}
strTmpObj += "] /Count " + numPages + " >>\nendobj\n";
xRefList.Add(calculateXPos((int)PDFBytes.Length)); //refenrece to obj 3
PDFBytes.Write(stringToBytes(strTmpObj), 0, strTmpObj.Length);
//Each image page
for (int itr = 0; itr < numPages; itr++)
{
string iWidth = getMeta("width", itr);
string iHeight = getMeta("height", itr);
//OBJECT 4..7..10..n : Page config
strTmpObj = (((itr + 2) * 3) - 2) + " 0 obj\n<<\n/Type /Page /Parent 3 0 R \n/MediaBox [ 0 0 " + iWidth + " " + iHeight + " ]\n/Resources <<\n/ProcSet [ /PDF ]\n/XObject <</R" + (itr + 1) + " " + ((itr + 2) * 3) + " 0 R>>\n>>\n/Contents [ " + (((itr + 2) * 3) - 1) + " 0 R ]\n>>\nendobj\n";
xRefList.Add(calculateXPos((int)PDFBytes.Length)); //refenrece to obj 4,7,10,13,16...
PDFBytes.Write(stringToBytes(strTmpObj), 0, strTmpObj.Length);
//OBJECT 5...8...11...n : Page resource object (xobject resource that transforms the image)
xRefList.Add(calculateXPos((int)PDFBytes.Length)); //refenrece to obj 5,8,11,14,17...
string xObjR = getXObjResource(itr);
PDFBytes.Write(stringToBytes(xObjR), 0, xObjR.Length);
//OBJECT 6...9...12...n : Binary xobject of the page (image)
byte[] imgBA = addImageToPDF(itr, isCompressed);
xRefList.Add(calculateXPos((int)PDFBytes.Length));//refenrece to obj 6,9,12,15,18...
PDFBytes.Write(imgBA, 0, imgBA.Length);
}
//xrefs compilation
xRefList[0] += ((xRefList.Count - 1) + "\n");
//get trailer
string trailer = getTrailer((int)PDFBytes.Length, xRefList.Count - 1);
//write xref and trailer to PDF
string strXRefs = string.Join("", (string[])xRefList.ToArray(typeof(string)));
PDFBytes.Write(stringToBytes(strXRefs), 0, strXRefs.Length);
//
PDFBytes.Write(stringToBytes(trailer), 0, trailer.Length);
//write EOF
string strEOF = "%%EOF\n";
PDFBytes.Write(stringToBytes(strEOF), 0, strEOF.Length);
PDFBytes.Close();
return PDFBytes.ToArray();
}
//Build Image resource object that transforms the image from First Quadrant system to Second Quadrant system
private string getXObjResource()
{
return getXObjResource(0);
}
private string getXObjResource(int itr)
{
string width = getMeta("width", itr);
string height = getMeta("height", itr);
return (((itr + 2) * 3) - 1) + " 0 obj\n<< /Length " + (24 + (width + height).Length) + " >>\nstream\nq\n" + width + " 0 0 " + height + " 0 0 cm\n/R" + (itr + 1) + " Do\nQ\nendstream\nendobj\n";
}
private string calculateXPos(int posn)
{
return posn.ToString().PadLeft(10, '0') + " 00000 n \n";
}
private string getTrailer(int xrefpos)
{
return getTrailer(xrefpos, 7);
}
private string getTrailer(int xrefpos, int numxref)
{
return "trailer\n<<\n/Size " + numxref.ToString() + "\n/Root 2 0 R\n/Info 1 0 R\n>>\nstartxref\n" + xrefpos.ToString() + "\n";
}
private byte[] getBitmapData24()
{
return getBitmapData24(0, true);
}
private byte[] getBitmapData24(int id, bool isCompressed)
{
string rawImageData = getMeta("imagedata", id);
string bgColor = getMeta("bgcolor", id);
MemoryStream imageData24 = new MemoryStream();
// Split the data into rows using ; as separator
string[] rows = rawImageData.Split(';');
for (int yPixel = 0; yPixel < rows.Length; yPixel++)
{
//Split each row into 'color_count' columns.
string[] color_count = rows[yPixel].Split(',');
for (int col = 0; col < color_count.Length; col++)
{
//Now, if it's not empty, we process it
//Split the 'color_count' into color and repeat factor
string[] split_data = color_count[col].Split('_');
//Reference to color
string hexColor = split_data[0] != "" ? split_data[0] : bgColor;
//If the hexadecimal code is less than 6 characters, pad with 0
hexColor = hexColor.Length < 6 ? hexColor.PadLeft(6, '0') : hexColor;
//refer to repeat factor
int fRepeat = int.Parse(split_data[1]);
// convert color string to byte[] array
byte[] rgb = hexToBytes(hexColor);
// Set the repeated pixel in MemoryStream
for (int cRepeat = 0; cRepeat < fRepeat; cRepeat++)
{
imageData24.Write(rgb, 0, 3);
}
}
}
int len = (int)imageData24.Length;
imageData24.Close();
//Compress image binary
if (isCompressed)
{
return new PDFCompress(imageData24.ToArray()).RLECompress();
}
else
{
return imageData24.ToArray();
}
}
// converts a hexadecimal colour string to it's respective byte value
private byte[] hexToBytes(string strHex)
{
if (strHex == null || strHex.Trim().Length == 0) strHex = "00";
strHex = Regex.Replace(strHex, @"[^0-9a-fA-f]", "");
if (strHex.Length % 2 != 0) strHex = "0" + strHex;
int len = strHex.Length / 2;
byte[] bytes = new byte[len];
for (int i = 0; i < len; i++)
{
string hex = strHex.Substring(i * 2, 2);
bytes[i] = byte.Parse(hex, System.Globalization.NumberStyles.HexNumber);
}
return bytes;
}
private string getMeta(string metaName)
{
return getMeta(metaName, 0);
}
private string getMeta(string metaName, int id)
{
if (metaName == null) metaName = "";
Hashtable chartData = (Hashtable)arrExportData[id];
return (chartData[metaName] == null ? "" : chartData[metaName].ToString());
}
private byte[] stringToBytes(string str)
{
if (str == null) str = "";
return System.Text.Encoding.ASCII.GetBytes(str);
}
}
/// <summary>
/// This is an ad-hoc class to compress PDF stream.
/// Currently this class compresses binary (byte) stream using RLE which
/// PDF 1.3 specification has thus formulated:
///
/// The RunLengthDecode filter decodes data that has been encoded in a simple
/// byte-oriented format based on run length. The encoded data is a sequence of
/// runs, where each run consists of a length byte followed by 1 to 128 bytes of data. If
/// the length byte is in the range 0 to 127, the following length + 1 (1 to 128) bytes
/// are copied literally during decompression. If length is in the range 129 to 255, the
/// following single byte is to be copied 257 - length (2 to 128) times during decompression.
/// A length value of 128 denotes EOD.
///
/// The chart image compression ratio comes to around 10:3
///
/// </summary>
public class PDFCompress
{
/// <summary>
/// stores the output compressed data in MemoryStream object later to be converted to byte[] array
/// </summary>
private MemoryStream _Compressed = new MemoryStream();
/// <summary>
/// Uncompresses data as byte[] array
/// </summary>
private byte[] _UnCompressed;
/// <summary>
/// Takes the uncompressed byte array
/// </summary>
/// <param name="UnCompressed">uncompressed data</param>
public PDFCompress(byte[] UnCompressed)
{
_UnCompressed = UnCompressed;
}
/// <summary>
/// Write compressed data as RunLength
/// </summary>
/// <param name="length">The length of repeated data</param>
/// <param name="encodee">The byte to be repeated</param>
/// <returns></returns>
private int WriteRunLength(int length, byte encodee)
{
// write the repeat length
_Compressed.WriteByte((byte)(257 - length));
// write the byte to be repeated
_Compressed.WriteByte(encodee);
//re-set repeat length
length = 1;
return length;
}
private void WriteNoRepeater(MemoryStream NoRepeatBytes)
{
// write the length of non repeted data
_Compressed.WriteByte((byte)((int)NoRepeatBytes.Length - 1));
// write the non repeated data put literally
_Compressed.Write(NoRepeatBytes.ToArray(), 0, (int)NoRepeatBytes.Length);
// re-set non repeat byte storage stream
NoRepeatBytes.SetLength(0);
}
/// <summary>
/// compresses uncompressed data to compressed data in byte array
/// </summary>
/// <returns></returns>
public byte[] RLECompress()
{
// stores non repeatable data
MemoryStream NoRepeat = new MemoryStream();
// repeat counter
int _RL = 1;
// 2 consecutive bytes to compare
byte preByte = 0, postByte = 0;
// iterate through the uncompressed bytes
for (int i = 0; i < _UnCompressed.Length - 1; i++)
{
// get 2 consecutive bytes
preByte = _UnCompressed[i];
postByte = _UnCompressed[i + 1];
// if both are same there is scope for repitition
if (preByte == postByte)
{
// but flush the non repeatable data (if present) to compressed stream
if (NoRepeat.Length > 0) WriteNoRepeater(NoRepeat);
// increase repeat count
_RL++;
// if repeat count reaches limit of repeat i.e. 128
// write the repeat data and reset the repeat counter
if (_RL > 128) _RL = WriteRunLength(_RL-1,preByte);
}
else
{
// when consecutive bytes do not match
// store non-repeatable data
if (_RL == 1) NoRepeat.WriteByte(preByte);
// write repeated length and byte (if present ) to output stream
if (_RL > 1) _RL = WriteRunLength(_RL, preByte);
// write non repeatable data to out put stream if the length reaches limit
if (NoRepeat.Length == 128) WriteNoRepeater(NoRepeat);
}
}
// at the end of iteration
// take care of the last byte
// if repeated
if (_RL > 1)
{
// write run length and byte (if present ) to output stream
_RL = WriteRunLength(_RL, preByte);
}
else
{
// if non repeated byte is left behind
// write non repeatable data to output stream
NoRepeat.WriteByte(postByte);
WriteNoRepeater(NoRepeat);
}
// wrote EOD
_Compressed.WriteByte((byte)128);
//close streams
NoRepeat.Close();
_Compressed.Close();
// return compressed data in byte array
return _Compressed.ToArray();
}
}