plnhdl.cpp

邮 电 公 司 erp源码

          m_sdForeCastd->Delete();
       }
    }
}
//---------------------------------------------------------------------------
void TsdForeCasth::CancelItem()
{
    m_sdForeCastd->Cancel();
}
//---------------------------------------------------------------------------
void TsdForeCasth::AddToObject()
{
    TsdForeCastd *p=new TsdForeCastd();
    p->Assign(m_sdForeCastd);
    if(m_sdForeCastd->FindKey(m_sdForeCastd->GetOldFieldValue(fiForeCastdLine)))
       m_sdForeCastd->ChangeRecord((void*)p,p->GetFieldValue(fiForeCastdLine),m_sdForeCastd->GetOldFieldValue(fiForeCastdLine));
    else
       m_sdForeCastd->AddRecord((void *)p,p->GetFieldValue(fiForeCastdLine));
}
//---------------------------------------------------------------------------
bool TsdForeCasth::LocateItemByIndex(int Index)
{
    return m_sdForeCastd->LocateByIndex(Index);
}
//---------------------------------------------------------------------------
bool TsdForeCasth::LocateItemByKey(AnsiString Key)
{
    return m_sdForeCastd->LocateByKey(Key);
}
//---------------------------------------------------------------------------
void TsdForeCasth::BackupValue()
{
     b_sdForeCastd=m_sdForeCastd;
     b_ForeCasthCode=m_ForeCasthCode;
     b_ForeCasthDate=m_ForeCasthDate;
     b_ForeCasthPlanner=m_ForeCasthPlanner;
     b_ForeCasthCheck=m_ForeCasthCheck;
     b_ForeCasthChecker=m_ForeCasthChecker;
     b_ForeCasthCheckDate=m_ForeCasthCheckDate;
     b_ForeCasthDesc=m_ForeCasthDesc;
     b_ForeCasthSysDate=m_ForeCasthSysDate;
}
//---------------------------------------------------------------------------
void TsdForeCasth::RestoreItem()
{
    m_sdForeCastd->RestoreValue();
}
//---------------------------------------------------------------------------
void TsdForeCasth::RestoreValue()
{
    m_sdForeCastd=b_sdForeCastd;
    m_ForeCasthCode=b_ForeCasthCode;
    m_ForeCasthDate=b_ForeCasthDate;
    m_ForeCasthPlanner=b_ForeCasthPlanner;
    m_ForeCasthCheck=b_ForeCasthCheck;
    m_ForeCasthChecker=b_ForeCasthChecker;
    m_ForeCasthCheckDate=b_ForeCasthCheckDate;
    m_ForeCasthDesc=b_ForeCasthDesc;
    m_ForeCasthSysDate=b_ForeCasthSysDate;
}
//---------------------------------------------------------------------------
void TsdForeCasth::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
      m_ForeCasthCode="";
      m_ForeCasthDate="";
      m_ForeCasthPlanner="";
      m_ForeCasthCheck=0;
      m_ForeCasthChecker="";
      m_ForeCasthCheckDate="";
      m_ForeCasthDesc="";
      m_ForeCasthSysDate="";
      break;
    case 1:
      b_ForeCasthCode="";
      b_ForeCasthDate="";
      b_ForeCasthPlanner="";
      b_ForeCasthCheck=0;
      b_ForeCasthChecker="";
      b_ForeCasthCheckDate="";
      b_ForeCasthDesc="";
      b_ForeCasthSysDate="";
      break;
    }
}
//---------------------------------------------------------------------------
void TsdForeCasth::BatchLetValue()
{
     m_ForeCasthCode=m_Query->FieldValues["ForeCasthCode"];
     m_ForeCasthDate=m_Query->FieldValues["ForeCasthDate"];
     m_ForeCasthPlanner=m_Query->FieldValues["ForeCasthPlanner"];
     m_ForeCasthCheck=m_Query->FieldValues["ForeCasthCheck"];
     m_ForeCasthChecker=m_Query->FieldValues["ForeCasthChecker"];
     m_ForeCasthCheckDate=m_Query->FieldValues["ForeCasthCheckDate"];
     m_ForeCasthDesc=m_Query->FieldValues["ForeCasthDesc"];
     m_ForeCasthSysDate=m_Query->FieldValues["ForeCasthSysDate"];
     BackupValue();
}
//---------------------------------------------------------------------------
void TsdForeCasth::Assign(TsdForeCasth *p)
{
     this->SetActionID(p->CurStatus);
     this->m_sdForeCastd=p->m_sdForeCastd;
     this->m_ForeCasthCode=p->m_ForeCasthCode;
     this->m_ForeCasthDate=p->m_ForeCasthDate;
     this->m_ForeCasthPlanner=p->m_ForeCasthPlanner;
     this->m_ForeCasthCheck=p->m_ForeCasthCheck;
     this->m_ForeCasthChecker=p->m_ForeCasthChecker;
     this->m_ForeCasthCheckDate=p->m_ForeCasthCheckDate;
     this->m_ForeCasthDesc=p->m_ForeCasthDesc;
     this->m_ForeCasthSysDate=p->m_ForeCasthSysDate;
     if(this->CurStatus==3)
     {
       this->b_sdForeCastd=p->b_sdForeCastd;
       this->b_ForeCasthCode=p->b_ForeCasthCode;
       this->b_ForeCasthDate=p->b_ForeCasthDate;
       this->b_ForeCasthPlanner=p->b_ForeCasthPlanner;
       this->b_ForeCasthCheck=p->b_ForeCasthCheck;
       this->b_ForeCasthChecker=p->b_ForeCasthChecker;
       this->b_ForeCasthCheckDate=p->b_ForeCasthCheckDate;
       this->b_ForeCasthDesc=p->b_ForeCasthDesc;
       this->b_ForeCasthSysDate=p->b_ForeCasthSysDate;
     }
     else
       this->BackupValue();
}
//---------------------------------------------------------------------------
void TsdForeCasth::AssignValue()
{
    TsdForeCasth *p=(TsdForeCasth *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------
int TsdForeCasth::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_sdForeCastd;
      }

    ClearRecord();
    if(m_Query->RecordCount>0)
    {
        m_Query->First();
        while(!m_Query->Eof)
        {
            BatchLetValue();
            NewDetail();
            m_sdForeCastd->FilterString="ForeCastdCode='"+m_ForeCasthCode+"'";
            m_sdForeCastd->OrderString="ForeCastdLine";
            m_sdForeCastd->Query();
            TsdForeCasth *p=new TsdForeCasth();
            SetActionID(1);
            p->Assign(this);
            AddRecord((void *)p,p->ForeCasthCode);
            m_Query->Next();
        }
        MoveFirst();
    }
    m_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TsdForeCasth::Find(AnsiString WhereStr)
{
    AnsiString m_SqlStr;
    if(WhereStr.IsEmpty()==true)
       throw Exception("查找表达式不能为空!");
    m_SqlStr="select * from sdForeCasth 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_sdForeCastd->FilterString="ForeCastdCode='"+m_ForeCasthCode+"'";
        m_sdForeCastd->OrderString="ForeCastdLine";
        m_sdForeCastd->Query();
        m_Query->Close();
        return true;
    }
}
//---------------------------------------------------------------------------
AnsiString TsdForeCasth::GetItemValue(euForeCastd FieldName)
{
    return m_sdForeCastd->GetFieldValue(FieldName);
}
//---------------------------------------------------------------------------
void TsdForeCasth::SetItemValue(euForeCastd FieldName, AnsiString value)
{
    m_sdForeCastd->SetFieldValue(FieldName,value);
}
//---------------------------------------------------------------------------
int __fastcall TsdForeCasth::GetItemCount()
{
  return m_sdForeCastd->Count;
}
//---------------------------------------------------------------------------
int __fastcall TsdForeCasth::GetCurItemNo()
{
    return m_sdForeCastd->CurRecNo;
}
//---------------------------------------------------------------------------
char __fastcall TsdForeCasth::GetCurItemStatus()
{
    return m_sdForeCastd->CurStatus;
}
//---------------------------------------------------------------------------
AnsiString __fastcall TsdForeCasth::GetItemBookMark()
{
    return m_sdForeCastd->BookMark;
}
//---------------------------------------------------------------------------
void TsdForeCasth::NewDetail()
{
  m_sdForeCastd=new TsdForeCastd(DataComm);
  m_sdForeCastd->sdParent=this;
}
//---------------------------------------------------------------------------
void TsdForeCasth::DeleteDetail()
{
  delete m_sdForeCastd;
  m_sdForeCastd=NULL;
}
//---------------------------------------------------------------------------

//*********************************
//  ClassName:TsdMps             //
//  Description:主生产计划       //
//  Created on:20001/01/03       //
//*********************************

void __fastcall TsdMps:: SetMpsGoods(AnsiString value)
{
   if(value.IsEmpty())
     throw Exception("物料编码不能为空！");
   m_MpsGoods=value;
}
void __fastcall TsdMps:: SetMpsRDate(AnsiString value)
{
      m_MpsRDate=Validate(value);
}
void __fastcall TsdMps:: SetMpsRQty(double  value)
{
      if(value<=0)
       throw Exception("需求数量不能小于等于零");
       m_MpsRQty=value;
}
void __fastcall TsdMps:: SetMpsGQty(double  value)
{
      if(value<0)
       throw Exception("生成数量不能小于零");
       m_MpsGQty=value;
}
void __fastcall TsdMps:: SetMpsDate(AnsiString value)
{
       m_MpsDate=value;
}
void __fastcall TsdMps:: SetMpsPlanner(AnsiString value)
{
       m_MpsPlanner=value;
}
void __fastcall TsdMps:: SetMpsCheck(int    value)
{
       m_MpsCheck=value;
}
void __fastcall TsdMps:: SetMpsChecker(AnsiString value)
{
       m_MpsChecker=value;
}
void __fastcall TsdMps:: SetMpsCheckDate(AnsiString value)
{
       m_MpsCheckDate=value;
}
void __fastcall TsdMps:: SetMpsState(int    value)
{
       m_MpsState=value;
}
//---------------------------------------------------------------------------
AnsiString TsdMps::GetFieldValue(euMps sdFieldName)
{
    switch(sdFieldName)
    {
      case fiMpsGoods:
           return MpsGoods;
      case fiMpsRDate:
           return MpsRDate;
      case fiMpsRQty:
           return MpsRQty;
      case fiMpsGQty:
           return MpsGQty;
      case fiMpsDate:
           return MpsDate;
      case fiMpsPlanner:
           return MpsPlanner;
      case fiMpsCheck:
           return MpsCheck;
      case fiMpsChecker:
           return MpsChecker;
      case fiMpsCheckDate:
           return MpsCheckDate;
      case fiMpsState:
           return MpsState;
      case fiMpsSysDate:
           return MpsSysDate;
     }
         return NULL;
}
//---------------------------------------------------------------------------
void TsdMps::SetFieldValue(euMps sdFieldName, AnsiString value)
{
    value=Trim(value);
    switch(sdFieldName)
     {
    case fiMpsGoods:
         MpsGoods=value;
          break;
    case fiMpsRDate:
         MpsRDate=value;
          break;
    case fiMpsRQty:
         MpsRQty=value.ToDouble();
          break;
    case fiMpsGQty:
         MpsGQty=value.ToDouble();
          break;
    case fiMpsDate:
         MpsDate=value;
          break;
    case fiMpsPlanner:
         MpsPlanner=value;
          break;
    case fiMpsCheck:
         MpsCheck=value.ToInt();
          break;
    case fiMpsChecker:
         MpsChecker=value;
          break;
    case fiMpsCheckDate:
         MpsCheckDate=value;
          break;
    case fiMpsState:
         MpsState=value.ToInt();
          break;
      }
}
//---------------------------------------------------------------------------
TsdMps::TsdMps(TDataComm *DC)
                :TsdStandard(DC)
{
    try
    {
        QueryString="SELECT * FROM sdMps";
        FilterString="";
        OrderString="MpsGoods,MpsRDate";
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TsdMps::TsdMps()
                :TsdStandard()
{
    try
    {
        QueryString="SELECT * FROM sdMps";
        FilterString="";
        OrderString="MpsGoods,MpsRDate";
    }