Пример #1
0
        //根据 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);
        }
Пример #2
0
    //根据 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();
    }
Пример #4
0
        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);
    }
Пример #6
0
        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();
        }
Пример #7
0
        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
            }));
        }
Пример #8
0
        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);
 }
Пример #10
0
 //根据 DataSet 产生提供给报表需要的JSON数据,参数DataType指定压缩编码数据的形式
 public static void GenDetailData(HttpContext DataPage, DataSet myds, ResponseDataType DataType)
 {
     GenDetailData(DataPage, myds.Tables[0], DataType);
 }
Пример #11
0
 //根据 DataSet 产生提供给报表需要的JSON数据,参数DataType指定压缩编码数据的形式
 public static void GenDetailData(System.Web.UI.Page DataPage, DataSet myds, ResponseDataType DataType)
 {
     GenDetailData(DataPage, myds.Tables[0], DataType);
 }
Пример #12
0
        //根据 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);
        }
Пример #13
0
        //根据 DataTable 产生提供给报表需要的JSON数据,参数DataType指定压缩编码数据的形式
        public static void GenDetailData(HttpContext DataPage, DataTable dt, ResponseDataType DataType)
        {
            string Out = GenDetailText(dt);

            ReportDataBase.ResponseData(DataPage, ref Out, DataType);
        }
Пример #14
0
        //根据 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);
        }
Пример #15
0
    /// <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);
    }
Пример #16
0
    //<<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);
        }
    }
Пример #17
0
 //根据 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);
 }
Пример #18
0
 /// <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);
 }
Пример #19
0
 //根据 DataSet 产生提供给报表需要的XML数据,参数DataType指定压缩编码数据的形式
 public static void GenDetailData(HttpContext DataPage, DataSet myds, ResponseDataType DataType)
 {
     string XMLText = myds.GetXml();
     ReportDataBase.ResponseData(DataPage, ref XMLText, DataType);
 }
Пример #20
0
 //根据 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);
 }
Пример #21
0
        //根据 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);
        }
Пример #22
0
 //根据 DataTable 产生提供给报表需要的JSON数据,参数DataType指定压缩编码数据的形式
 public static void GenDetailData(HttpContext DataPage, DataTable dt, ResponseDataType DataType)
 {
     string Out = GenDetailText(dt);
     ReportDataBase.ResponseData(DataPage, ref Out, DataType);
 }
Пример #23
0
 /// <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);
 }
Пример #24
0
    //根据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);
    }
Пример #25
0
 /// <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);
 }
Пример #26
0
    //根据 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);
    }
Пример #27
0
 //产生报表明细记录数据,数据将被加载到明细网格的记录集中
 public static void GenDetailData(System.Web.UI.Page DataPage, string QuerySQL, ResponseDataType DataType)
 {
     OledbReportData.DoGenDetailData(DataPage, QuerySQL, DataType, true);
 }
Пример #28
0
 public WebResponseData(ResponseDataType responseType, string text, byte[] binary)
 {
     this.responseType = responseType;
     this.text         = text;
     this.binary       = binary;
 }
Пример #29
0
 async public Task <ResponseId> UpdateFolderTypeName(string folderId, string dataTypeId, ResponseDataType content)
 {
     return(await PostAsync <ResponseId>($"api/v1/folder/{folderId}/type/{dataTypeId}", content));
 }
Пример #30
0
        //根据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);
        }
Пример #31
0
    //<<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);
        }
    }
Пример #32
0
        //根据 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);
        }
Пример #33
0
    //根据查询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();
    }
Пример #34
0
        //根据 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);
        }
Пример #35
0
 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);
 }
Пример #37
0
        /// <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);
        }
Пример #38
0
 //根据RecordsetQuerySQL获取报表明细数据,对应数据加载到报表的明细网格的记录集中
 //根据ParameterQuerySQL获取报表参数数据,对应数据加载到报表参数、非明细网格中的部件框中
 public static void GenEntireData(System.Web.UI.Page DataPage, string RecordsetQuerySQL, string ParameterQuerySQL, ResponseDataType DataType)
 {
     OledbReportData.DoGenEntireData(DataPage, RecordsetQuerySQL, ParameterQuerySQL, DataType, true);
 }
Пример #39
0
 //根据 DataSet 产生提供给报表需要的JSON数据,参数DataType指定压缩编码数据的形式
 public static void GenDetailData(HttpContext DataPage, DataSet myds, ResponseDataType DataType)
 {
     GenDetailData(DataPage, myds.Tables[0], DataType);
 }