rpt.cpp

邮 电 公 司 erp源码

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#define _YW_SDERP_DLL

#include "Rpt.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)
//**************************************
//     TsdRptType
//**************************************
//--------------------------------------------------------------
void __fastcall TsdRptType:: SetRptTypeCode(AnsiString value)
{
        m_RptTypeCode=value;
}
void __fastcall TsdRptType:: SetRptTypeName(AnsiString value)
{
       if(value.IsEmpty())
       throw Exception("报表类型名称不能为空");
        m_RptTypeName=value;
}
void __fastcall TsdRptType:: SetRptTypeDesc(AnsiString value)
{
       m_RptTypeDesc=value;
}
void __fastcall TsdRptType:: SetRptTypeUpperCode(AnsiString value)
{
//       if(value.IsEmpty())
//       throw Exception("报表类型上级代码不能为空");
       m_RptTypeUpperCode=value;
       m_RptTypeCode=Trim(m_RptTypeUpperCode)+Trim(m_RptTypeItem);
}
void __fastcall TsdRptType:: SetRptTypeItem(AnsiString value)
{
      if(value.IsEmpty())
       throw Exception("报表类型节点代码不能为空");
       if(value!=m_RptTypeItem)
       {
        m_Query->Close();
        m_Query->SQL->Clear();
        m_Query->SQL->Add("select * from sdRptType where RptTypeUpperCode='"+m_RptTypeUpperCode+"' and RptTypeItem='"+value+"'");
        m_Query->Open();
        if(m_Query->RecordCount>0)
        {
           m_Query->Close();
           throw Exception("该结点编号:'"+m_RptTypeUpperCode+value+"'已经存在!");
        }
        m_Query->Close();
        m_RptTypeItem=value;
        m_RptTypeCode=Trim(m_RptTypeUpperCode)+Trim(m_RptTypeItem);
       }
}
void __fastcall TsdRptType:: SetRptTypeLevel(int    value)
{
       if(value>7||value<0)
       throw Exception("本级级别应在[0,7]");
       m_RptTypeLevel=value;
}
void __fastcall TsdRptType:: SetRptTypeEnd(int    value)
{
       m_RptTypeEnd=value;
}
//---------------------------------------------------------------------------
AnsiString TsdRptType::GetFieldValue(euRptType sdFieldName)
{
    switch(sdFieldName)
    {
      case fiRptTypeCode:
           return RptTypeCode;
      case fiRptTypeName:
           return RptTypeName;
      case fiRptTypeDesc:
           return RptTypeDesc;
      case fiRptTypeUpperCode:
           return RptTypeUpperCode;
      case fiRptTypeItem:
           return RptTypeItem;
      case fiRptTypeLevel:
           return RptTypeLevel;
      case fiRptTypeEnd:
           return RptTypeEnd;
     }
         throw Exception("当前字段未定义可取值");  
}
//---------------------------------------------------------------------------
void TsdRptType::SetFieldValue(euRptType sdFieldName, AnsiString value)
{
     value=Trim(value);
    switch(sdFieldName)
     {
    case fiRptTypeCode:  
         RptTypeCode=value;
          break;
    case fiRptTypeName:  
         RptTypeName=value;
          break;
    case fiRptTypeDesc:  
         RptTypeDesc=value;
          break;
    case fiRptTypeUpperCode:  
         RptTypeUpperCode=value;
          break;
    case fiRptTypeItem:  
         RptTypeItem=value;
          break;
    case fiRptTypeLevel:  
         RptTypeLevel=value.ToInt();
          break;
    case fiRptTypeEnd:  
         RptTypeEnd=value.ToInt();
          break;
      default: 
        throw Exception("当前字段未定义可赋值");  
          
      }
}
//---------------------------------------------------------------------------
TsdRptType::TsdRptType(TDataComm *DC)
                :TsdStandard(DC)
{
    try
    {
/*        m_Query=new TQuery(Application);
        m_Query->SessionName=pSessionName;
        m_Query->DatabaseName=pDatabaseName;

        m_StoredProc=new TStoredProc(Application);
        m_StoredProc->SessionName =pSessionName;
        m_StoredProc->DatabaseName=pDatabaseName;

        m_SessionName=pSessionName;
        m_DatabaseName=pDatabaseName;*/
        QueryString="SELECT * FROM sdRptType";
        FilterString="";
        OrderString="RptTypeCode";
        EmptyValue(0);
        EmptyValue(1);
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
TsdRptType::TsdRptType()
            :TsdStandard()
{
    try
    {
        QueryString="SELECT * FROM sdRptType";
        FilterString="";
        OrderString="RptTypeCode";
        EmptyValue(0);
        EmptyValue(1);
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}

//---------------------------------------------------------------------------
TsdRptType::~TsdRptType()
{
  try{
//    delete m_Query;
//    delete m_StoredProc;
     }
  catch(...)
    {
     throw Exception("析构函数出错");
    }
}
//---------------------------------------------------------------------------
void TsdRptType::BackupValue()
{
      b_RptTypeCode=m_RptTypeCode;
      b_RptTypeName=m_RptTypeName;
      b_RptTypeDesc=m_RptTypeDesc;
      b_RptTypeUpperCode=m_RptTypeUpperCode;
      b_RptTypeItem=m_RptTypeItem;
      b_RptTypeLevel=m_RptTypeLevel;
      b_RptTypeEnd=m_RptTypeEnd;
}
//---------------------------------------------------------------------------
void TsdRptType::RestoreValue()
{
      m_RptTypeCode=b_RptTypeCode;
      m_RptTypeName=b_RptTypeName;
      m_RptTypeDesc=b_RptTypeDesc;
      m_RptTypeUpperCode=b_RptTypeUpperCode;
      m_RptTypeItem=b_RptTypeItem;
      m_RptTypeLevel=b_RptTypeLevel;
      m_RptTypeEnd=b_RptTypeEnd;
}
//---------------------------------------------------------------------------
void TsdRptType::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
        m_RptTypeCode="";
        m_RptTypeName="";
        m_RptTypeDesc="";
        m_RptTypeUpperCode="";
        m_RptTypeItem="";
        m_RptTypeLevel=0;
        m_RptTypeEnd=0;
    break;
    case 1:
        b_RptTypeCode="";
        b_RptTypeName="";
        b_RptTypeDesc="";
        b_RptTypeUpperCode="";
        b_RptTypeItem="";
        b_RptTypeLevel=0;
        b_RptTypeEnd=0;
      break;
     }
}
//---------------------------------------------------------------------------
void TsdRptType::BatchLetValue()
{
    m_RptTypeCode=m_Query->FieldValues["RptTypeCode"];
    m_RptTypeName=m_Query->FieldValues["RptTypeName"];
    m_RptTypeDesc=m_Query->FieldValues["RptTypeDesc"];
    m_RptTypeUpperCode=m_Query->FieldValues["RptTypeUpperCode"];
    m_RptTypeItem=m_Query->FieldValues["RptTypeItem"];
    m_RptTypeLevel=m_Query->FieldValues["RptTypeLevel"];
    m_RptTypeEnd=m_Query->FieldValues["RptTypeEnd"];
    BackupValue();
}
//---------------------------------------------------------------------------
void TsdRptType::Update()
{
    if(CurStatus==0||CurStatus==1)
        throw Exception("当前不是编辑状态,不能进行存盘操作!");
    if(m_RptTypeCode.IsEmpty()==true)
        throw Exception("分类码不能为空!");
    m_StoredProc->Close();
    if(CurStatus==2||CurStatus==4)
      {
        m_StoredProc->ProcedureName="sdRptType_Insert";
        m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@RptTypeCode",ftString,pdInput,18,m_RptTypeCode);
        m_StoredProc->Parameters->CreateParameter("@RptTypeName",ftString,pdInput,20,m_RptTypeName);
        m_StoredProc->Parameters->CreateParameter("@RptTypeDesc",ftString,pdInput,40,m_RptTypeDesc);
        m_StoredProc->Parameters->CreateParameter("@RptTypeUpperCode",ftString,pdInput,18,m_RptTypeUpperCode);
        m_StoredProc->Parameters->CreateParameter("@RptTypeItem",ftString,pdInput,18,m_RptTypeItem);
        m_StoredProc->Parameters->CreateParameter("@RptTypeLevel",ftInteger,pdInput,10,m_RptTypeLevel);
        m_StoredProc->Parameters->CreateParameter("@RptTypeEnd",ftInteger,pdInput,1,m_RptTypeEnd);

        m_StoredProc->ExecProc();
       }
   else
       {
        m_StoredProc->ProcedureName="sdRptType_Update";
        m_StoredProc->Parameters->Clear();

        m_StoredProc->Parameters->CreateParameter("@W_RptTypeCode",ftString,pdInput,18,b_RptTypeCode);
        m_StoredProc->Parameters->CreateParameter("@RptTypeCode",ftString,pdInput,18,m_RptTypeCode);
        m_StoredProc->Parameters->CreateParameter("@RptTypeName",ftString,pdInput,20,m_RptTypeName);
        m_StoredProc->Parameters->CreateParameter("@RptTypeDesc",ftString,pdInput,40,m_RptTypeDesc);
        m_StoredProc->Parameters->CreateParameter("@RptTypeItem",ftString,pdInput,18,m_RptTypeItem);
        m_StoredProc->Parameters->CreateParameter("@RptTypeLevel",ftInteger,pdInput,10,m_RptTypeLevel);
        m_StoredProc->Parameters->CreateParameter("@RptTypeEnd",ftInteger,pdInput,1,m_RptTypeEnd);

       m_StoredProc->ExecProc();


   }
  TsdRptType *p=new TsdRptType();
  if(CurStatus==2)
    {
     SetActionID(1);
     p->Assign(this);
     AddRecord((void *)p,p->RptTypeCode);
     }
  else
    {
     SetActionID(1);
     p->Assign(this);
     ChangeRecord((void *)p,p->RptTypeCode,this->b_RptTypeCode);
    }
}
//---------------------------------------------------------------------------
void TsdRptType::Delete()
{
    if(CurStatus!=1)
        throw Exception("当前状态不能进行删除操作!");
    if(m_RptTypeCode.IsEmpty()==true)
        throw Exception("当前没有记录可以删除!");
    m_StoredProc->Close();
    m_StoredProc->ProcedureName="sdRptType_Delete";
    m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@W_RptTypeCode",ftString,pdInput,18,b_RptTypeCode);
    m_StoredProc->ExecProc();
    DeleteRecord(this->b_RptTypeCode);
}
//---------------------------------------------------------------------------
void TsdRptType::Assign(TsdRptType *p)
{
    this->SetActionID(p->CurStatus);
    this->m_RptTypeCode=p->m_RptTypeCode;
    this->m_RptTypeName=p->m_RptTypeName;
    this->m_RptTypeDesc=p->m_RptTypeDesc;
    this->m_RptTypeUpperCode=p->m_RptTypeUpperCode;
    this->m_RptTypeItem=p->m_RptTypeItem;
    this->m_RptTypeLevel=p->m_RptTypeLevel;
    this->m_RptTypeEnd=p->m_RptTypeEnd;
    this->BackupValue();
}
//---------------------------------------------------------------------------
void TsdRptType::AssignValue()
{
    TsdRptType *p=(TsdRptType *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------
int TsdRptType::Query()
{
    AnsiString m_SqlStr;
    m_SqlStr=QueryString;
    if(FilterString.IsEmpty()==false)
        m_SqlStr=m_SqlStr+" where  "+FilterString;
    if(OrderString.IsEmpty()==false)
        m_SqlStr=m_SqlStr+" Order by "+OrderString;
    m_Query->Close();
    m_Query->SQL->Clear();
    m_Query->SQL->Add(m_SqlStr);
    m_Query->Open();
    ClearRecord();
    if(m_Query->RecordCount>0)
    {
        m_Query->First();
        while(!m_Query->Eof)
        {
            BatchLetValue();
            TsdRptType *p=new TsdRptType();
            SetActionID(1);
            p->Assign(this);
            AddRecord((void *)p,p->RptTypeCode);
            m_Query->Next();
        }
        MoveFirst();
    }
    m_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TsdRptType::Find(AnsiString WhereStr)
{
    AnsiString m_SqlStr;
    if(WhereStr.IsEmpty()==true)
        throw Exception("查找表达式不能为空");
    m_SqlStr="select * from sdRptType where  "+WhereStr;
    m_Query->Close();
    m_Query->SQL->Clear();
    m_Query->SQL->Add(m_SqlStr);
    m_Query->Open();
    if(m_Query->RecordCount!=1)
    {
        m_Query->Close();
        return false;
    }
    else
    {
        BatchLetValue();
        m_Query->Close();
        return true;
    }
}
//**************************************
//     TsdReport
//**************************************
//--------------------------------------------------------------
void __fastcall TsdReport:: SetReportCode(AnsiString value)
{
      if(value.IsEmpty())
       throw Exception("报表代码不能为空");
      if(value.Length()>18)
       throw Exception("报表代码长度不能大于18字节");
      if(value.UpperCase()!=m_ReportCode.UpperCase())
      {
        m_Query->Close();
        m_Query->SQL->Clear();
        m_Query->SQL->Add("select ReportCode from sdReport where ReportCode='"+value+"'");