pmhdl.cpp

邮 电 公 司 erp源码

   else
     m_sdPod->Delete();
}
//---------------------------------------------------------------------------
void TsdPoh::ClearItem()
{
   int iCount;
   if(CurStatus==2)
     m_sdPod->ClearRecord();
   else
   {
     iCount=m_sdPod->Count;
     for(int i=0;i<iCount;i++)
     {
       m_sdPod->LocateByIndex(0);
       m_sdPod->Delete();
     }
   }
}
//---------------------------------------------------------------------------

void TsdPoh::CancelItem()
{
    m_sdPod->Cancel();
}
//---------------------------------------------------------------------------
void TsdPoh::AddToObject()
{
    TsdPod *p=new TsdPod();
    p->Assign(m_sdPod);
    if(m_sdPod->FindKey(m_sdPod->GetOldFieldValue(fiPodLine)))
      m_sdPod->ChangeRecord((void *)p,p->GetFieldValue(fiPodLine),m_sdPod->GetOldFieldValue(fiPodLine));
    else
      m_sdPod->AddRecord((void *)p,p->GetFieldValue(fiPodLine));
}
//---------------------------------------------------------------------------
bool TsdPoh::LocateItemByIndex(int Index)
{
    return m_sdPod->LocateByIndex(Index);
}
//---------------------------------------------------------------------------

bool TsdPoh::LocateItemByKey(AnsiString Key)
{
    return m_sdPod->LocateByKey(Key);
}
//---------------------------------------------------------------------------
void TsdPoh::BackupValue()
{
    b_sdPod=m_sdPod;
    b_PohCode=m_PohCode;
    b_PohSupply=m_PohSupply;
    b_PohDate=m_PohDate;
    b_PohCurrency=m_PohCurrency;
    b_PohEnrate=m_PohEnrate;
    b_PohTaxCode=m_PohTaxCode;
    b_PohPmode=m_PohPmode;
    b_PohContract=m_PohContract;
    b_PohSettleMode=m_PohSettleMode;
    b_PohSugDate=m_PohSugDate;
    b_PohBuyer=m_PohBuyer;
    b_PohDesc=m_PohDesc;
    b_PohAmt=m_PohAmt;
    b_PohPayTerm=m_PohPayTerm;
    b_PohPrePayAmt=m_PohPrePayAmt;
    b_PohCarriage=m_PohCarriage;
    b_PohCancel=m_PohCancel;
    b_PohCanceler=m_PohCanceler;
    b_PohCancelDate=m_PohCancelDate;
    b_PohCancel=m_PohCancel;
    b_PohCanceler=m_PohCanceler;
    b_PohCancelDate=m_PohCancelDate;
    b_PohStop=m_PohStop;
    b_PohClose=m_PohClose;
    b_PohPsite=m_PohPsite;
    b_PohDeliver=m_PohDeliver;
    b_PohTransMode=m_PohTransMode;
    b_PohUser=m_PohUser;
    b_PohSysDate=m_PohSysDate;
}
//---------------------------------------------------------------------------

void TsdPoh::RestoreValue()
{
    m_sdPod=b_sdPod;
    m_PohCode=b_PohCode;
    m_PohSupply=b_PohSupply;
    m_PohDate=b_PohDate;
    m_PohCurrency=b_PohCurrency;
    m_PohEnrate=b_PohEnrate;
    m_PohTaxCode=b_PohTaxCode;
    m_PohPmode=b_PohPmode;
    m_PohContract=b_PohContract;
    m_PohSettleMode=b_PohSettleMode;
    m_PohSugDate=b_PohSugDate;
    m_PohBuyer=b_PohBuyer;
    m_PohDesc=b_PohDesc;
    m_PohAmt=b_PohAmt;
    m_PohPayTerm=b_PohPayTerm;
    m_PohPrePayAmt=b_PohPrePayAmt;
    m_PohCarriage=b_PohCarriage;
    m_PohCheck=b_PohCheck;
    m_PohChecker=b_PohChecker;
    m_PohCheckDate=b_PohCheckDate;
    m_PohCancel=b_PohCancel;
    m_PohCanceler=b_PohCanceler;
    m_PohCancelDate=b_PohCancelDate;
    m_PohClose=b_PohClose;
    m_PohStop=b_PohStop;
    m_PohPsite=b_PohPsite;
    m_PohDeliver=b_PohDeliver;
    m_PohTransMode=b_PohTransMode;
    m_PohUser=b_PohUser;
    m_PohSysDate=b_PohSysDate;
}
//---------------------------------------------------------------------------

void TsdPoh::RestoreItem()
{
 m_sdPod->RestoreValue();
}
//---------------------------------------------------------------------------
void TsdPoh::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
      m_PohCode="";
      m_PohSupply="";
      m_PohDate="";
      m_PohCurrency="";
      m_PohEnrate=0;
      m_PohTaxCode="";
      m_PohPmode="";
      m_PohContract="";
      m_PohSettleMode="";
      m_PohSugDate="";
      m_PohBuyer="";
      m_PohDesc="";
      m_PohAmt=0;
      m_PohPayTerm=0;
      m_PohPrePayAmt=0;
      m_PohCarriage =0;
      m_PohCheck=0;
      m_PohChecker="";
      m_PohCheckDate="";
      m_PohCancel=0;
      m_PohCanceler="";
      m_PohCancelDate="";
      m_PohStop =0;
      m_PohClose=0;
      m_PohPsite="";
      m_PohDeliver="";
      m_PohTransMode="";
      m_PohUser="";
      m_PohSysDate="";
      break;
    case 1:
      b_PohCode="";
      b_PohSupply="";
      b_PohDate="";
      b_PohCurrency="";
      b_PohEnrate=0;
      b_PohTaxCode="";
      b_PohPmode="";
      b_PohContract="";
      b_PohSettleMode="";
      b_PohSugDate="";
      b_PohBuyer="";
      b_PohDesc="";
      b_PohAmt=0;
      b_PohPayTerm=0;
      b_PohPrePayAmt=0;
      b_PohCarriage =0;
      b_PohCheck=0;
      b_PohChecker="";
      b_PohCheckDate="";
      b_PohCancel=0;
      b_PohCanceler="";
      b_PohCancelDate="";
      b_PohStop =0;
      b_PohClose=0;
      b_PohPsite="";
      b_PohDeliver="";
      b_PohTransMode="";
      b_PohUser="";
      b_PohSysDate="";
      break;
    }
}
//---------------------------------------------------------------------------

void TsdPoh::BatchLetValue()
{
    m_PohCode=m_Query->FieldValues["PohCode"];
    m_PohSupply=m_Query->FieldValues["PohSupply"];
    m_PohDate=m_Query->FieldValues["PohDate"];
    m_PohCurrency=m_Query->FieldValues["PohCurrency"];
    m_PohEnrate=m_Query->FieldValues["PohEnrate"];
    m_PohTaxCode=m_Query->FieldValues["PohTaxCode"];
    m_PohPmode=m_Query->FieldValues["PohPmode"];
    m_PohContract=m_Query->FieldValues["PohContract"];
    m_PohSettleMode=m_Query->FieldValues["PohSettleMode"];
    m_PohSugDate=m_Query->FieldValues["PohSugDate"];
    m_PohBuyer=m_Query->FieldValues["PohBuyer"];
    m_PohDesc=m_Query->FieldValues["PohDesc"];
    m_PohAmt=m_Query->FieldValues["PohAmt"];
    m_PohPayTerm=m_Query->FieldValues["PohPayTerm"];
    m_PohPrePayAmt=m_Query->FieldValues["PohPrePayAmt"];
    m_PohCarriage=m_Query->FieldValues["PohCarriage"];
    m_PohCheck=m_Query->FieldValues["PohCheck"];
    m_PohChecker=m_Query->FieldValues["PohChecker"];
    m_PohCheckDate=m_Query->FieldValues["PohCheckDate"];
    m_PohCancel=m_Query->FieldValues["PohCancel"];
    m_PohCanceler=m_Query->FieldValues["PohCanceler"];
    m_PohCancelDate=m_Query->FieldValues["PohCancelDate"];
    m_PohClose=m_Query->FieldValues["PohClose"];
    m_PohStop =m_Query->FieldValues["PohStop"];
    m_PohPsite =m_Query->FieldValues["PohPsite"];
    m_PohDeliver=m_Query->FieldValues["PohDeliver"];
    m_PohTransMode =m_Query->FieldValues["PohTransMode"];
    m_PohUser =m_Query->FieldValues["PohUser"];
    m_PohSysDate =m_Query->FieldValues["PohSysDate"];
    BackupValue();
}
//---------------------------------------------------------------------------

void TsdPoh::Assign(TsdPoh *p)
{
    this->SetActionID(p->CurStatus);
    this->m_sdPod=p->m_sdPod;
    this->m_PohCode=p->m_PohCode;
    this->m_PohSupply=p->m_PohSupply;
    this->m_PohDate=p->m_PohDate;
    this->m_PohCurrency=p->m_PohCurrency;
    this->m_PohEnrate=p->m_PohEnrate;
    this->m_PohTaxCode=p->m_PohTaxCode;
    this->m_PohPmode=p->m_PohPmode;
    this->m_PohContract=p->m_PohContract;
    this->m_PohSettleMode=p->m_PohSettleMode;
    this->m_PohSugDate=p->m_PohSugDate;
    this->m_PohBuyer=p->m_PohBuyer;
    this->m_PohDesc=p->m_PohDesc;
    this->m_PohAmt=p->m_PohAmt;
    this->m_PohPayTerm=p->m_PohPayTerm;
    this->m_PohPrePayAmt=p->m_PohPrePayAmt;
    this->m_PohCarriage=p->m_PohCarriage;
    this->m_PohCheck=p->m_PohCheck;
    this->m_PohChecker=p->m_PohChecker;
    this->m_PohCheckDate=p->m_PohCheckDate;
    this->m_PohCancel=p->m_PohCancel;
    this->m_PohCanceler=p->m_PohCanceler;
    this->m_PohCancelDate=p->m_PohCancelDate;
    this->m_PohClose=p->m_PohClose;
    this->m_PohStop=p->m_PohStop;
    this->m_PohPsite=p->m_PohPsite;
    this->m_PohDeliver=p->m_PohDeliver;
    this->m_PohTransMode=p->m_PohTransMode;
    this->m_PohUser=p->m_PohUser;
    this->m_PohSysDate=p->m_PohSysDate;
    
    if(this->CurStatus==3)
    {
        this->b_sdPod=p->b_sdPod;
        this->b_PohCode=p->b_PohCode;
        this->b_PohSupply=p->b_PohSupply;
        this->b_PohDate=p->b_PohDate;
        this->b_PohCurrency=p->b_PohCurrency;
        this->b_PohEnrate=p->b_PohEnrate;
        this->b_PohTaxCode=p->b_PohTaxCode;
        this->b_PohPmode=p->b_PohPmode;
        this->b_PohContract=p->b_PohContract;
        this->b_PohSettleMode=p->b_PohSettleMode;
        this->b_PohSugDate=p->b_PohSugDate;
        this->b_PohBuyer=p->b_PohBuyer;
        this->b_PohDesc=p->b_PohDesc;
        this->b_PohAmt=p->b_PohAmt;
        this->b_PohPayTerm=p->b_PohPayTerm;
        this->b_PohPrePayAmt=p->b_PohPrePayAmt;
        this->b_PohCarriage=p->b_PohCarriage;
        this->b_PohCheck=p->b_PohCheck;
        this->b_PohChecker=p->b_PohChecker;
        this->b_PohCheckDate=p->b_PohCheckDate;
        this->b_PohCancel=p->b_PohCancel;
        this->b_PohCanceler=p->b_PohCanceler;
        this->b_PohCancelDate=p->b_PohCancelDate;
        this->b_PohClose=p->b_PohClose;
        this->b_PohStop=p->b_PohStop;
        this->b_PohPsite=p->b_PohPsite;
        this->b_PohDeliver=p->b_PohDeliver;
        this->b_PohTransMode=p->b_PohTransMode;
        this->b_PohUser=p->b_PohUser;
        this->b_PohSysDate=p->b_PohSysDate;
    }
    else
      this->BackupValue();
}
//---------------------------------------------------------------------------

void TsdPoh::AssignValue()
{
    TsdPoh *p=(TsdPoh *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------

int TsdPoh::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();
  for(int i=0;i<this->Count;i++)
  {
    this->LocateByIndex(i);
    this->AssignValue();
    delete m_sdPod;
  }
  ClearRecord();
  if(m_Query->RecordCount>0)
  {
    m_Query->First();
    while(!m_Query->Eof)
    {
      BatchLetValue();
      NewDetail();
      m_sdPod->FilterString=" PodCode='"+m_PohCode+"'";
      m_sdPod->OrderString=" PodLine ";
      m_sdPod->Query();
      TsdPoh *p=new TsdPoh();
      SetActionID(1);
      p->Assign(this);
      AddRecord((void *)p,p->PohCode);
      m_Query->Next();
    }
    MoveFirst();
  }
  m_Query->Close();
  return Count;
}
//---------------------------------------------------------------------------

bool TsdPoh::Find(AnsiString WhereStr)
{
   AnsiString m_SqlStr;
   if(WhereStr.IsEmpty()==true)
     throw Exception("查找的条件表达式不能为空!");
   m_SqlStr="select * from sdPoh 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_sdPod->FilterString=" PodCode='"+m_PohCode+"'";
     m_sdPod->OrderString=" PodLine ";
     m_sdPod->Query();
     m_Query->Close();
     return true;
   }
}
//---------------------------------------------------------------------------

void TsdPoh::Check(int IsCheck)
{
    if(this->Count>0)
    {
      try
      {
        m_StoredProc->ProcedureName="sdPoh_Check";
        m_StoredProc->Parameters->Clear();


        if(IsCheck==1)
        {
          PohCheck=1;
          PohChecker=g_sdUserCode;
          PohCheckDate=g_sdCurDate;
          m_StoredProc->Parameters->CreateParameter("@W_PohCode",ftString,pdInput,20,b_PohCode);
          m_StoredProc->Parameters->CreateParameter("@PohCheck",ftSmallint,pdInput,2,1);
          m_StoredProc->Parameters->CreateParameter("@PohChecker",ftString,pdInput,20,g_sdUserCode);
          m_StoredProc->Parameters->CreateParameter("@PohCheckDate",ftString,pdInput,10,g_sdCurDate);

          m_StoredProc->ExecProc();
          m_StoredProc->Close();
         }
         else
         {
          PohCheck=0;
          PohChecker="";
          PohCheckDate="";
          AnsiString temp="";
          m_StoredProc->Parameters->CreateParameter("@W_PohCode",ftString,pdInput,20,b_PohCode);
          m_StoredProc->Parameters->CreateParameter("@PohCheck",ftSmallint,pdInput,2,0);
          m_StoredProc->Parameters->CreateParameter("@PohChecker",ftString,pdInput,20,temp);
          m_StoredProc->Parameters->CreateParameter("@PohCheckDate",ftString,pdInput,10,temp);

          m_StoredProc->ExecProc();
          m_StoredProc->Close();
          }
         TsdPoh *p=(TsdPoh*)Records(CurRecNo);
         p->Assign(this);
         BackupValue();
       }
       catch(Exception &e)
       {