qry.cpp

速达开源ERP系统

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

#define _YW_SDERP_DLL
#include "Qry.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)

//**************************************
//     TsdQuType 查询分类码
//**************************************
//--------------------------------------------------------------
void __fastcall TsdQuType:: SetQuTypeCode(AnsiString value)
{
 if(value.IsEmpty() )
  throw Exception("分类码不能为空");
 if(value.Length()>18)
  throw Exception("编码长度不能大于18");
 if(value!=m_QuTypeCode)
 {
  m_Query->Close();
  m_Query->SQL->Clear();
  m_Query->SQL->Add("SELECT QuTypeCode FROM sdQuType WHERE QuTypeCode='"+value+"'");
  m_Query->Open();
  if(m_Query->RecordCount>0)
  {
   m_Query->Close();
   throw Exception("分类码'"+value+"'已存在");
  }
  m_Query->Close();
 }
 m_QuTypeCode=value;
}
void __fastcall TsdQuType:: SetQuTypeName(AnsiString value)
{
 if(value.IsEmpty() )
  throw Exception("分类码名称不能为空");
 m_QuTypeName=value;
}
void __fastcall TsdQuType:: SetQuTypeDesc(AnsiString value)
{
 m_QuTypeDesc=value;
}
void __fastcall TsdQuType:: SetQuTypeUpperCode(AnsiString value)
{
 m_QuTypeUpperCode=value;
}
void __fastcall TsdQuType:: SetQuTypeItem(AnsiString value)
{
 if(value.IsEmpty() )
  throw Exception("本级编码不能为空");
 m_QuTypeItem=value;
}
void __fastcall TsdQuType:: SetQuTypeLevel(int    value)
{
 m_QuTypeLevel=value;
}
void __fastcall TsdQuType:: SetQuTypeEnd(int    value)
{
 m_QuTypeEnd=value;
}
//---------------------------------------------------------------------------
AnsiString TsdQuType::GetFieldValue(euQuType sdFieldName)
{
    switch(sdFieldName)
    {
      case fiQuTypeCode:
           return QuTypeCode;
      case fiQuTypeName:
           return QuTypeName;
      case fiQuTypeDesc:
           return QuTypeDesc;
      case fiQuTypeUpperCode:
           return QuTypeUpperCode;
      case fiQuTypeItem:
           return QuTypeItem;
      case fiQuTypeLevel:
           return QuTypeLevel;
      case fiQuTypeEnd:
           return QuTypeEnd;
      default:
        throw Exception("当前未定义可取值");
     }
}
//---------------------------------------------------------------------------
void TsdQuType::SetFieldValue(euQuType sdFieldName, AnsiString value)
{
    switch(sdFieldName)
     {
    case fiQuTypeCode:  
         QuTypeCode=value;
          break;
    case fiQuTypeName:  
         QuTypeName=value;
          break;
    case fiQuTypeDesc:  
         QuTypeDesc=value;
          break;
    case fiQuTypeUpperCode:  
         QuTypeUpperCode=value;
          break;
    case fiQuTypeItem:  
         QuTypeItem=value;
          break;
    case fiQuTypeLevel:  
         QuTypeLevel=value.ToInt();
          break;
    case fiQuTypeEnd:  
         QuTypeEnd=value.ToInt();
          break;
    default:
        throw Exception("当前字段未定义可赋值");  
      }
}
//---------------------------------------------------------------------------
TsdQuType::TsdQuType(TDataComm *DC)
                :TsdStandard(DC)
{
    try
    {
        QueryString="SELECT * FROM sdQuType";
        FilterString="";
        OrderString="QuTypeCode";
        EmptyValue(0);
        EmptyValue(1);
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TsdQuType::TsdQuType()
                :TsdStandard()
{
    try
    {
        QueryString="SELECT * FROM sdQuType";
        FilterString="";
        OrderString="QuTypeCode";
        EmptyValue(0);
        EmptyValue(1);
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TsdQuType::~TsdQuType()
{
  try{
     }
  catch(...)
    {
     throw Exception("析构函数出错");
    }
}
//---------------------------------------------------------------------------
void TsdQuType::BackupValue()
{
      b_QuTypeCode=m_QuTypeCode;
      b_QuTypeName=m_QuTypeName;
      b_QuTypeDesc=m_QuTypeDesc;
      b_QuTypeUpperCode=m_QuTypeUpperCode;
      b_QuTypeItem=m_QuTypeItem;
      b_QuTypeLevel=m_QuTypeLevel;
      b_QuTypeEnd=m_QuTypeEnd;
}
//---------------------------------------------------------------------------
void TsdQuType::RestoreValue()
{
      m_QuTypeCode=b_QuTypeCode;
      m_QuTypeName=b_QuTypeName;
      m_QuTypeDesc=b_QuTypeDesc;
      m_QuTypeUpperCode=b_QuTypeUpperCode;
      m_QuTypeItem=b_QuTypeItem;
      m_QuTypeLevel=b_QuTypeLevel;
      m_QuTypeEnd=b_QuTypeEnd;
}
//---------------------------------------------------------------------------
void TsdQuType::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
        m_QuTypeCode="";
        m_QuTypeName="";
        m_QuTypeDesc="";
        m_QuTypeUpperCode="";
        m_QuTypeItem="";
        m_QuTypeLevel=0;
        m_QuTypeEnd=0;
    break;
    case 1:
        b_QuTypeCode="";
        b_QuTypeName="";
        b_QuTypeDesc="";
        b_QuTypeUpperCode="";
        b_QuTypeItem="";
        b_QuTypeLevel=0;
        b_QuTypeEnd=0;
      break;
     }
}
//---------------------------------------------------------------------------
void TsdQuType::BatchLetValue()
{
    m_QuTypeCode=m_Query->FieldValues["QuTypeCode"];
    m_QuTypeName=m_Query->FieldValues["QuTypeName"];
    m_QuTypeDesc=m_Query->FieldValues["QuTypeDesc"];
    m_QuTypeUpperCode=m_Query->FieldValues["QuTypeUpperCode"];
    m_QuTypeItem=m_Query->FieldValues["QuTypeItem"];
    m_QuTypeLevel=m_Query->FieldValues["QuTypeLevel"];
    m_QuTypeEnd=m_Query->FieldValues["QuTypeEnd"];
    BackupValue();
}
//---------------------------------------------------------------------------
void TsdQuType::Update()
{
    if(CurStatus==0||CurStatus==1)
        throw Exception("当前不是编辑状态,不能进行存盘操作!");
    if(m_QuTypeCode.IsEmpty()==true)
        throw Exception("分类码不能为空!");
    m_StoredProc->Close();
    if(CurStatus==2||CurStatus==4)
      {
        m_StoredProc->ProcedureName="sdQuType_Insert";
        m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@QuTypeCode",ftString,pdInput,18,m_QuTypeCode);
        m_StoredProc->Parameters->CreateParameter("@QuTypeName",ftString,pdInput,20,m_QuTypeName);
        m_StoredProc->Parameters->CreateParameter("@QuTypeDesc",ftString,pdInput,40,m_QuTypeDesc);
        m_StoredProc->Parameters->CreateParameter("@QuTypeUpperCode",ftString,pdInput,18,m_QuTypeUpperCode);
        m_StoredProc->Parameters->CreateParameter("@QuTypeItem",ftString,pdInput,18,m_QuTypeItem);
        m_StoredProc->Parameters->CreateParameter("@QuTypeLevel",ftInteger,pdInput,10,m_QuTypeLevel);
        m_StoredProc->Parameters->CreateParameter("@QuTypeEnd",ftInteger,pdInput,1,m_QuTypeEnd);
 
        m_StoredProc->ExecProc();
   }
  else
    {
        m_StoredProc->ProcedureName="sdQuType_Update";
        m_StoredProc->Parameters->Clear();

        m_StoredProc->Parameters->CreateParameter("@W_QuTypeCode",ftString,pdInput,18,b_QuTypeCode);
        m_StoredProc->Parameters->CreateParameter("@QuTypeCode",ftString,pdInput,18,m_QuTypeCode);
        m_StoredProc->Parameters->CreateParameter("@QuTypeName",ftString,pdInput,20,m_QuTypeName);
        m_StoredProc->Parameters->CreateParameter("@QuTypeDesc",ftString,pdInput,40,m_QuTypeDesc);
        m_StoredProc->Parameters->CreateParameter("@QuTypeUpperCode",ftString,pdInput,18,m_QuTypeUpperCode);
        m_StoredProc->Parameters->CreateParameter("@QuTypeItem",ftString,pdInput,18,m_QuTypeItem);
        m_StoredProc->Parameters->CreateParameter("@QuTypeLevel",ftInteger,pdInput,10,m_QuTypeLevel);
        m_StoredProc->Parameters->CreateParameter("@QuTypeEnd",ftInteger,pdInput,1,m_QuTypeEnd);
 
       m_StoredProc->ExecProc();
   }
  TsdQuType *p=new TsdQuType();
  if(CurStatus==2)
    {
     SetActionID(1);
     p->Assign(this);
     AddRecord((void *)p,p->QuTypeCode);
     }
  else
    {
     SetActionID(1);
     p->Assign(this);
     ChangeRecord((void *)p,p->QuTypeCode,this->b_QuTypeCode);
    }
}
//---------------------------------------------------------------------------
void TsdQuType::Delete()
{
    if(CurStatus!=1)
        throw Exception("当前状态不能进行删除操作!");
    if(m_QuTypeCode.IsEmpty()==true)
        throw Exception("当前没有记录可以删除!");
    m_StoredProc->Close();
    m_StoredProc->ProcedureName="sdQuType_Delete";
    m_StoredProc->Parameters->Clear();
    m_StoredProc->Parameters->CreateParameter("@W_QuTypeCode",ftString,pdInput,18,b_QuTypeCode);
    m_StoredProc->ExecProc();
    DeleteRecord(this->b_QuTypeCode);
}
//---------------------------------------------------------------------------
void TsdQuType::Assign(TsdQuType *p)
{
    this->SetActionID(p->CurStatus);
    this->m_QuTypeCode=p->m_QuTypeCode;
    this->m_QuTypeName=p->m_QuTypeName;
    this->m_QuTypeDesc=p->m_QuTypeDesc;
    this->m_QuTypeUpperCode=p->m_QuTypeUpperCode;
    this->m_QuTypeItem=p->m_QuTypeItem;
    this->m_QuTypeLevel=p->m_QuTypeLevel;
    this->m_QuTypeEnd=p->m_QuTypeEnd;
    this->BackupValue();
}
//---------------------------------------------------------------------------
void TsdQuType::AssignValue()
{
    TsdQuType *p=(TsdQuType *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------
int TsdQuType::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();
            TsdQuType *p=new TsdQuType();
            SetActionID(1);
            p->Assign(this);
            AddRecord((void *)p,p->QuTypeCode);
            m_Query->Next();
        }
        MoveFirst();
    }
    m_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TsdQuType::Find(AnsiString WhereStr)
{
    AnsiString m_SqlStr;
    if(WhereStr.IsEmpty()==true)
        throw Exception("查找表达式不能为空");
    m_SqlStr="select * from sdQuType 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;
    }
}

//**************************************
//     TsdQuery 查询维护
//**************************************
//--------------------------------------------------------------
void __fastcall TsdQuery:: SetQueryCode(AnsiString value)
{
 if(value.IsEmpty() )
  throw Exception("查询编码不能为空");
 if(value.Length()>18)
  throw Exception("编码长度不能大于18");
 if(value!=m_QueryCode)
 {
  m_Query->Close();
  m_Query->SQL->Clear();
  m_Query->SQL->Add("SELECT QueryCode FROM sdQuery WHERE QueryCode='"+value+"'");
  m_Query->Open();
  if(m_Query->RecordCount>0)
  {
   m_Query->Close();
   throw Exception("编码'"+value+"'已存在");
  }
  m_Query->Close();
 }
 m_QueryCode=value;
}
void __fastcall TsdQuery:: SetQueryType(AnsiString value)
{
 if(value.IsEmpty() )
  throw Exception("分类编码不能为空");
 m_QueryType=value;
}
void __fastcall TsdQuery:: SetQueryName(AnsiString value)
{
 if(value.IsEmpty() )
  throw Exception("查询名称不能为空");
 m_QueryName=value;
}
void __fastcall TsdQuery:: SetQueryDesc(AnsiString value)
{
 m_QueryDesc=value;