//根据 DataTable 产生提供给报表需要的XML数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(HttpContext DataPage, DataTable mydt, ResponseDataType DataType)
{
DataSet ds = new DataSet();
ds.Tables.Add(mydt);
GenDetailData(DataPage, ds, DataType);
}
//根据 DataTable 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
public static void GenDataTable(System.Web.UI.Page DataPage, DataTable dt, ResponseDataType DataType)
{
DataSet ds = new DataSet();
ds.Tables.Add(dt);
GenDataSet(DataPage, ds, DataType);
}
//根据查询SQL,产生提供给报表生成需要的 或 JSON 数据，采用 Oracle 数据引擎, 根据RecordsetQuerySQL获取报表明细数据，根据ParameterQuerySQL获取报表参数数据
protected static void DoGenEntireData(System.Web.UI.Page DataPage, string RecordsetQuerySQL, string ParameterQuerySQL, ResponseDataType DataType, bool IsJSON)
{
OracleConnection myConn = new OracleConnection(OracleConnStr);
myConn.Open();
OracleDataAdapter myda = new OracleDataAdapter(RecordsetQuerySQL, myConn);
DataSet myds = new DataSet();
myda.Fill(myds);
OracleCommand mycmd = new OracleCommand(ParameterQuerySQL, myConn);
OracleDataReader mydr = mycmd.ExecuteReader(CommandBehavior.CloseConnection);
if (IsJSON)
{
string ParameterPart = JSONReportData.GenParameterText(mydr);
JSONReportData.GenEntireData(DataPage, myds, ref ParameterPart, DataType);
}
else
{
string ParameterPart = XMLReportData.GenParameterText(mydr);
XMLReportData.GenEntireData(DataPage, myds, ref ParameterPart, DataType);
}
myConn.Close();
}
public const ResponseDataType DefaultDataType = ResponseDataType.PlainText; //PlainText ZipBinary ZipBase64
//将报表XML数据文本输出到HTTP请求
public static void Response(HttpResponse Response, string DataText, ResponseDataType DataType)
{
//报表XML数据的前后不能附加任何其它数据，否则XML数据将不能成功解析，所以调用ClearContent方法清理网页中前面多余的数据
Response.ClearContent();
if (ResponseDataType.PlainText == DataType)
{
// 把xml对象发送给客户端
//Response.ContentType = "text/xml";
Response.Write(DataText);
}
else
{
//将string数据转换为byte[]，以便进行压缩
System.Text.UTF8Encoding converter = new System.Text.UTF8Encoding();
byte[] XmlBytes = converter.GetBytes(DataText);
//在 HTTP 头信息中写入报表数据压缩信息
Response.AppendHeader("gr_zip_type", "deflate"); //指定压缩方法
Response.AppendHeader("gr_zip_size", XmlBytes.Length.ToString()); //指定数据的原始长度
Response.AppendHeader("gr_zip_encode", converter.HeaderName); //指定数据的编码方式 utf-8 utf-16 ...
// 把压缩后的xml数据发送给客户端
if (ResponseDataType.ZipBinary == DataType)
{
DeflateStream compressedzipStream = new DeflateStream(Response.OutputStream, CompressionMode.Compress, true);
compressedzipStream.Write(XmlBytes, 0, XmlBytes.Length);
compressedzipStream.Close();
}
else //ResponseDataType.ZipBase64
{
MemoryStream memStream = new MemoryStream();
DeflateStream compressedzipStream = new DeflateStream(memStream, CompressionMode.Compress, true);
compressedzipStream.Write(XmlBytes, 0, XmlBytes.Length);
compressedzipStream.Close(); //这句很重要，这样数据才能全部写入 MemoryStream
// Read bytes from the stream.
memStream.Seek(0, SeekOrigin.Begin); // Set the position to the beginning of the stream.
int count = (int)memStream.Length;
byte[] byteArray = new byte[count];
count = memStream.Read(byteArray, 0, count);
string Base64Text = Convert.ToBase64String(byteArray);
Response.Write(Base64Text);
}
}
//报表XML数据的前后不能附加任何其它数据，否则XML数据将不能成功解析，所以调用End方法放弃网页中后面不必要的数据
Response.End();
}
//<<protected function
//根据查询SQL,产生提供给报表生成需要的 XML 或 JSON 数据，采用 Oracle 数据引擎
protected static void DoGenDetailData(System.Web.UI.Page DataPage, string QuerySQL, ResponseDataType DataType, bool IsJSON)
{
OracleConnection myConn = new OracleConnection(OracleConnStr);
OracleDataAdapter myda = new OracleDataAdapter(QuerySQL, myConn);
DataSet myds = new DataSet();
myConn.Open();
myda.Fill(myds);
myConn.Close();
if (IsJSON)
JSONReportData.GenDetailData(DataPage, myds, DataType);
else
XMLReportData.GenDetailData(DataPage, myds, DataType);
}
public const ResponseDataType DefaultDataType = ResponseDataType.ZipBase64; //PlainText ZipBinary ZipBase64
//将报表XML数据文本输出到HTTP请求
public static void ResponseData(HttpContext DataPage, ref string DataText, ResponseDataType DataType)
{
//报表XML数据的前后不能附加任何其它数据，否则XML数据将不能成功解析，所以调用ClearContent方法清理网页中前面多余的数据
DataPage.Response.ClearContent();
if (ResponseDataType.PlainText == DataType)
{
// 把xml对象发送给客户端
//DataPage.Response.ContentType = "text/xml";
DataPage.Response.Write(DataText);
}
else
{
//将string数据转换为byte[]，以便进行压缩
System.Text.UTF8Encoding converter = new System.Text.UTF8Encoding();
byte[] XmlBytes = converter.GetBytes(DataText);
//在 HTTP 头信息中写入报表数据压缩信息
DataPage.Response.AppendHeader("gr_zip_type", "deflate"); //指定压缩方法
DataPage.Response.AppendHeader("gr_zip_size", XmlBytes.Length.ToString()); //指定数据的原始长度
DataPage.Response.AppendHeader("gr_zip_encode", converter.HeaderName); //指定数据的编码方式 utf-8 utf-16 ...
// 把压缩后的xml数据发送给客户端
if (ResponseDataType.ZipBinary == DataType)
{
DeflateStream compressedzipStream = new DeflateStream(DataPage.Response.OutputStream, CompressionMode.Compress, true);
compressedzipStream.Write(XmlBytes, 0, XmlBytes.Length);
compressedzipStream.Close();
}
else //ResponseDataType.ZipBase64
{
MemoryStream memStream = new MemoryStream();
DeflateStream compressedzipStream = new DeflateStream(memStream, CompressionMode.Compress, true);
compressedzipStream.Write(XmlBytes, 0, XmlBytes.Length);
compressedzipStream.Close(); //这句很重要，这样数据才能全部写入 MemoryStream
// Read bytes from the stream.
memStream.Seek(0, SeekOrigin.Begin); // Set the position to the beginning of the stream.
int count = (int)memStream.Length;
byte[] byteArray = new byte[count];
count = memStream.Read(byteArray, 0, count);
string Base64Text = Convert.ToBase64String(byteArray);
DataPage.Response.Write(Base64Text);
}
}
//报表XML数据的前后不能附加任何其它数据，否则XML数据将不能成功解析，所以调用End方法放弃网页中后面不必要的数据
//DataPage.Response.End();
}
async public Task <IActionResult> UpdateFolderTypeName([FromBody] ResponseDataType model, string folderId, string dataTypeId)
{
string userId = User.GetUserId();
if (await CanManageFolder(userId, folderId, true) == false)
{
return(BadRequest("Cannot Manage Folder"));
}
var type = await _db.DataTypes.Where(d => d.FolderId == folderId && d.Id == dataTypeId).FirstOrDefaultAsync();
type.Name = model.Name;
await _db.SaveChangesAsync();
return(Ok(new ResponseId()
{
Id = type.Id
}));
}
async public Task <IActionResult> CreateFolderType([FromBody] ResponseDataType model, string folderId)
{
string userId = User.GetUserId();
if (await CanManageFolder(userId, folderId, true) == false)
{
return(BadRequest("Cannot Manage Folder"));
}
DataType newType = new DataType()
{
Name = model.Name,
FolderId = folderId
};
_db.DataTypes.Add(newType);
await _db.SaveChangesAsync();
return(Ok(new ResponseId()
{
Id = newType.Id
}));
}
//产生报表明细记录数据，数据将被加载到明细网格的记录集中
public static void GenDetailData(System.Web.UI.Page DataPage, string QuerySQL, ResponseDataType DataType)
{
OracleReportData.DoGenDetailData(DataPage, QuerySQL, DataType, true);
}
//根据 DataSet 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(HttpContext DataPage, DataSet myds, ResponseDataType DataType)
{
GenDetailData(DataPage, myds.Tables[0], DataType);
}
//根据 DataSet 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(System.Web.UI.Page DataPage, DataSet myds, ResponseDataType DataType)
{
GenDetailData(DataPage, myds.Tables[0], DataType);
}
//根据 DataSet 产生提供给报表需要的JSON数据，并同时将ParamterPart中的报表参数数据一起打包，参数DataType指定压缩编码数据的形式
public static void GenEntireData(System.Web.UI.Page DataPage, DataSet myds, ref string ParameterPart, ResponseDataType DataType)
{
string JSONText = GenDetailText(myds.Tables[0]);
StringBuilder sb = new StringBuilder(JSONText, 0, JSONText.Length - 1, JSONText.Length + ParameterPart.Length + 2); //去掉最后一个“}”
sb.Append(',');
sb.Append(ParameterPart);
sb.Append('}');
string Out = sb.ToString();
ReportDataBase.ResponseData(DataPage, ref Out, DataType);
}
//根据 DataTable 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(HttpContext DataPage, DataTable dt, ResponseDataType DataType)
{
string Out = GenDetailText(dt);
ReportDataBase.ResponseData(DataPage, ref Out, DataType);
}
//根据 DataSet 产生提供给报表需要的XML数据，并同时将ParamterPart中的报表参数数据一起打包，参数DataType指定压缩编码数据的形式
public static void GenEntireData(System.Web.UI.Page DataPage, DataSet myds, ref string ParameterPart, ResponseDataType DataType)
{
string RecordsetPart = myds.GetXml();
string XMLText = "<report>\r\n" + RecordsetPart + ParameterPart + "</report>";
ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
}
/// <summary>
/// 根据IDataReader, 产生提供给报表需要的XML数据，其中的空值字段也会产生XML节点，参数DataType指定压缩编码数据的形式
/// </summary>
/// <param name="DataPage"></param>
/// <param name="dr"></param>
/// <param name="DataType"></param>
public static void GenNodeXmlDataFromReader(System.Web.UI.Page DataPage, IDataReader dr, ResponseDataType DataType)
{
string XMLText = "<xml>\n";
while (dr.Read())
{
XMLText += "<row>";
for (int i = 0; i < dr.FieldCount; ++i)
{
string FldName = dr.GetName(i);
if (FldName == "")
FldName = "Fld" + i;
XMLText += String.Format("<{0}>{1}</{0}>", FldName, HttpUtility.HtmlEncode(dr.GetValue(i).ToString()));
}
XMLText += "</row>\n";
}
XMLText += "</xml>\n";
ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
}
//<<protected function
//根据查询SQL,产生提供给报表生成需要的 XML 或 JSON 数据
protected static void DoGenDetailData(System.Web.UI.Page DataPage, string QuerySQL, ResponseDataType DataType, bool IsJSON)
{
SqlConnection ReportConn = new SqlConnection(SqlConnStr);
SqlDataAdapter ReportDataAdapter = new SqlDataAdapter(QuerySQL, ReportConn);
DataSet ReportDataSet = new DataSet();
ReportConn.Open();
ReportDataAdapter.Fill(ReportDataSet);
ReportConn.Close();
if (IsJSON)
{
JSONReportData.GenDataSet(DataPage, ReportDataSet, DataType);
}
else
{
XMLReportData.GenDataSet(DataPage, ReportDataSet, DataType);
}
}
//根据 DataTable 产生提供给报表需要的XML数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(HttpContext DataPage, DataTable mydt, ResponseDataType DataType)
{
DataSet ds = new DataSet();
ds.Tables.Add(mydt);
GenDetailData(DataPage, ds, DataType);
}
/// <summary>
/// 根据 DataSet 产生提供给报表需要的XML数据，参数DataType指定压缩编码数据的形式
/// </summary>
/// <param name="DataPage"></param>
/// <param name="ReportDataSet"></param>
/// <param name="DataType"></param>
public static void GenDataSet(System.Web.UI.Page DataPage, DataSet ReportDataSet, ResponseDataType DataType)
{
string XMLText = ReportDataSet.GetXml();
ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
}
//根据 DataSet 产生提供给报表需要的XML数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(HttpContext DataPage, DataSet myds, ResponseDataType DataType)
{
string XMLText = myds.GetXml();
ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
}
//根据 DataSet 产生提供给报表需要的XML数据，并同时将ParamterPart中的报表参数数据一起打包，参数DataType指定压缩编码数据的形式
public static void GenEntireData(HttpContext DataPage, DataSet myds, ref string ParameterPart, ResponseDataType DataType)
{
string RecordsetPart = myds.GetXml();
string XMLText = "<report>\r\n" + RecordsetPart + ParameterPart + "</report>";
ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
}
//根据 DataSet 产生提供给报表需要的JSON数据，并同时将ParamterPart中的报表参数数据一起打包，参数DataType指定压缩编码数据的形式
public static void GenEntireData(HttpContext DataPage, DataSet myds, ref string ParameterPart, ResponseDataType DataType)
{
string JSONText = GenDetailText(myds.Tables[0]);
StringBuilder sb = new StringBuilder(JSONText, 0, JSONText.Length - 1, JSONText.Length + ParameterPart.Length + 2); //去掉最后一个“}”
sb.Append(',');
sb.Append(ParameterPart);
sb.Append('}');
string Out = sb.ToString();
ReportDataBase.ResponseData(DataPage, ref Out, DataType);
}
//根据 DataTable 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(HttpContext DataPage, DataTable dt, ResponseDataType DataType)
{
string Out = GenDetailText(dt);
ReportDataBase.ResponseData(DataPage, ref Out, DataType);
}
/// <summary>
/// 根据 DataSet 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
/// </summary>
/// <param name="DataPage"></param>
/// <param name="ReportDataSet"></param>
/// <param name="DataType"></param>
public static void GenDataSet(System.Web.UI.Page DataPage, DataSet ReportDataSet, ResponseDataType DataType)
{
string Out = GenDetailText(ReportDataSet);
ReportDataBase.ResponseData(DataPage, ref Out, DataType);
}
//根据RecordsetQuerySQL获取报表明细数据，对应数据加载到报表的明细网格的记录集中
//根据ParameterQuerySQL获取报表参数数据，对应数据加载到报表参数、非明细网格中的部件框中
public static void GenEntireData(System.Web.UI.Page DataPage, string RecordsetQuerySQL, string ParameterQuerySQL, ResponseDataType DataType)
{
ArrayList QueryList = new ArrayList();
QueryList.Add(new ReportQueryItem(RecordsetQuerySQL, "Detail"));
QueryList.Add(new ReportQueryItem(ParameterQuerySQL, "Master"));
GenMultiRecordset(DataPage, QueryList);
}
/// <summary>
/// 根据 DataTable 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
/// </summary>
/// <param name="DataPage"></param>
/// <param name="dt"></param>
/// <param name="DataType"></param>
public static void GenDataTable(System.Web.UI.Page DataPage, DataTable dt, ResponseDataType DataType)
{
DataSet ds = new DataSet();
ds.Tables.Add(dt);
GenDataSet(DataPage, ds, DataType);
}
//根据 DataSet 产生提供给报表需要的XML数据，参数DataType指定压缩编码数据的形式
public static void GenDataSet(System.Web.UI.Page DataPage, DataSet ReportDataSet, ResponseDataType DataType)
{
string XMLText = ReportDataSet.GetXml();
ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
}
//产生报表明细记录数据，数据将被加载到明细网格的记录集中
public static void GenDetailData(System.Web.UI.Page DataPage, string QuerySQL, ResponseDataType DataType)
{
OledbReportData.DoGenDetailData(DataPage, QuerySQL, DataType, true);
}
public WebResponseData(ResponseDataType responseType, string text, byte[] binary)
{
this.responseType = responseType;
this.text = text;
this.binary = binary;
}
async public Task <ResponseId> UpdateFolderTypeName(string folderId, string dataTypeId, ResponseDataType content)
{
return(await PostAsync <ResponseId>($"api/v1/folder/{folderId}/type/{dataTypeId}", content));
}
//根据IDataReader, 产生提供给报表需要的XML数据，其中的空值字段也会产生XML节点，参数DataType指定压缩编码数据的形式
public static void GenNodeXmlDataFromReader(System.Web.UI.Page DataPage, IDataReader dr, ResponseDataType DataType)
{
string XMLText = "<xml>\n";
while (dr.Read())
{
XMLText += "<row>";
for (int i = 0; i < dr.FieldCount; ++i)
{
string FldName = dr.GetName(i);
if (FldName == "")
{
FldName = "Fld" + i;
}
XMLText += String.Format("<{0}>{1}</{0}>", FldName, HttpUtility.HtmlEncode(dr.GetValue(i).ToString()));
}
XMLText += "</row>\n";
}
XMLText += "</xml>\n";
ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
}
//<<protected function
//根据查询SQL,产生提供给报表生成需要的 XML 或 JSON 数据
protected static void DoGenDetailData(System.Web.UI.Page DataPage, string QuerySQL, ResponseDataType DataType, bool IsJSON)
{
OleDbConnection myConn = new OleDbConnection(OleDbConnStr);
OleDbDataAdapter myda = new OleDbDataAdapter(QuerySQL, myConn);
DataSet myds = new DataSet();
myConn.Open();
myda.Fill(myds);
myConn.Close();
if (IsJSON)
{
JSONReportData.GenDetailData(DataPage, myds, DataType);
}
else
{
XMLReportData.GenDetailData(DataPage, myds, DataType);
}
}
//根据 DataTable 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(System.Web.UI.Page DataPage, DataTable dt, ResponseDataType DataType)
{
string Out = GenDetailText(dt);
ReportDataBase.ResponseData(DataPage, ref Out, DataType);
}
//根据查询SQL,产生提供给报表生成需要的 或 JSON 数据，根据RecordsetQuerySQL获取报表明细数据，根据ParameterQuerySQL获取报表参数数据
protected static void DoGenEntireData(System.Web.UI.Page DataPage, string RecordsetQuerySQL, string ParameterQuerySQL, ResponseDataType DataType, bool IsJSON)
{
OleDbConnection myConn = new OleDbConnection(OleDbConnStr);
myConn.Open();
OleDbDataAdapter myda = new OleDbDataAdapter(RecordsetQuerySQL, myConn);
DataSet myds = new DataSet();
myda.Fill(myds);
OleDbCommand mycmd = new OleDbCommand(ParameterQuerySQL, myConn);
OleDbDataReader mydr = mycmd.ExecuteReader(CommandBehavior.CloseConnection);
if (IsJSON)
{
string ParameterPart = JSONReportData.GenParameterText(mydr);
JSONReportData.GenEntireData(DataPage, myds, ref ParameterPart, DataType);
}
else
{
string ParameterPart = XMLReportData.GenParameterText(mydr);
XMLReportData.GenEntireData(DataPage, myds, ref ParameterPart, DataType);
}
myConn.Close();
}
//根据 DataSet 产生提供给报表需要的XML数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(System.Web.UI.Page DataPage, DataSet myds, ResponseDataType DataType)
{
string XMLText = myds.GetXml();
ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
}
async public Task <ResponseId> CreateFolderType(string folderId, ResponseDataType content)
{
return(await PostAsync <ResponseId>($"api/v1/folder/{folderId}/type", content));
}
//根据RecordsetQuerySQL获取报表明细数据，对应数据加载到报表的明细网格的记录集中
//根据ParameterQuerySQL获取报表参数数据，对应数据加载到报表参数、非明细网格中的部件框中
public static void GenEntireData(System.Web.UI.Page DataPage, string RecordsetQuerySQL, string ParameterQuerySQL, ResponseDataType DataType)
{
OracleReportData.DoGenEntireData(DataPage, RecordsetQuerySQL, ParameterQuerySQL, DataType, true);
}
/// <summary>
/// 根据查询SQL,产生提供给报表生成需要的 XML 或 JSON 数据
/// </summary>
/// <param name="DataPage">需要处理的页面文件按</param>
/// <param name="QuerySQL">获取报表数据的SQL查询</param>
/// <param name="DataType">报表数据的格式类型</param>
/// <param name="IsJSON">是否使用JSON格式</param>
protected static void DoGenDetailData(System.Web.UI.Page DataPage, string QuerySQL, ResponseDataType DataType, bool IsJSON)
{
SqlConnection ReportConn = new SqlConnection(SqlConnStr);
SqlDataAdapter ReportDataAdapter = new SqlDataAdapter(QuerySQL, ReportConn);
DataSet ReportDataSet = new DataSet();
ReportConn.Open();
ReportDataAdapter.Fill(ReportDataSet);
ReportConn.Close();
if (IsJSON)
JSONReportData.GenDataSet(DataPage, ReportDataSet, DataType);
else
XMLReportData.GenDataSet(DataPage, ReportDataSet, DataType);
}
//根据RecordsetQuerySQL获取报表明细数据，对应数据加载到报表的明细网格的记录集中
//根据ParameterQuerySQL获取报表参数数据，对应数据加载到报表参数、非明细网格中的部件框中
public static void GenEntireData(System.Web.UI.Page DataPage, string RecordsetQuerySQL, string ParameterQuerySQL, ResponseDataType DataType)
{
OledbReportData.DoGenEntireData(DataPage, RecordsetQuerySQL, ParameterQuerySQL, DataType, true);
}
//根据 DataSet 产生提供给报表需要的JSON数据，参数DataType指定压缩编码数据的形式
public static void GenDetailData(HttpContext DataPage, DataSet myds, ResponseDataType DataType)
{
GenDetailData(DataPage, myds.Tables[0], DataType);
}