mmhdl.cpp

邮 电 公 司 erp源码

      m_StoredProc->Parameters->CreateParameter("@RoutehUser",ftString,pdInput,18,m_RoutehUser);
      m_StoredProc->Parameters->CreateParameter("@RoutehProducter",ftString,pdInput,18,m_RoutehProducter);
      m_StoredProc->Parameters->CreateParameter("@RoutehSysDate",ftString,pdOutput,40,m_RoutehSysDate);
      m_StoredProc->ExecProc();
      m_RoutehCode=m_StoredProc->Parameters->ParamValues["@RoutehCode"];
      m_RoutehSysDate=m_StoredProc->Parameters->ParamValues["@RoutehSysDate"];
      m_StoredProc->Close();
      for(int i=0;i<ItemCount;i++)
      {
         LocateItemByIndex(i);
         m_sdRouted->SetFieldValue(fiRoutedCode,m_RoutehCode);
         AddToObject();
         m_sdRouted->Update();
      }
      break;
    case 3:
      m_StoredProc->ProcedureName="sdRouteh_Update";
      m_StoredProc->Parameters->Clear();
      m_StoredProc->Parameters->CreateParameter("@W_RoutehCode",ftString,pdInput,18,b_RoutehCode);
      m_StoredProc->Parameters->CreateParameter("@RoutehName",ftString,pdInput,20,m_RoutehName);
      m_StoredProc->Parameters->CreateParameter("@RoutehGoods",ftString,pdInput,18,m_RoutehGoods);
      m_StoredProc->Parameters->CreateParameter("@RoutehKey",ftInteger,pdInput,1,m_RoutehKey);
      m_StoredProc->Parameters->CreateParameter("@RoutehEdate",ftString,pdInput,10,m_RoutehEdate);
      m_StoredProc->Parameters->CreateParameter("@RoutehIdate",ftString,pdInput,10,m_RoutehIdate);
      m_StoredProc->Parameters->CreateParameter("@RoutehDesc",ftString,pdInput,40,m_RoutehDesc);
      m_StoredProc->Parameters->CreateParameter("@RoutehUser",ftString,pdInput,18,m_RoutehUser);
      m_StoredProc->Parameters->CreateParameter("@RoutehProducter",ftString,pdInput,18,m_RoutehProducter);
      m_StoredProc->Parameters->CreateParameter("@RoutehCancel",ftInteger,pdInput,1,m_RoutehCancel);
      m_StoredProc->Parameters->CreateParameter("@RoutehCancelDate",ftString,pdInput,10,m_RoutehCancelDate);
      m_StoredProc->Parameters->CreateParameter("@RoutehSysDate",ftString,pdOutput,40,m_RoutehSysDate);
      m_StoredProc->ExecProc();
      m_RoutehSysDate=m_StoredProc->Parameters->ParamValues["@RoutehSysDate"];
      m_StoredProc->Close();
      break;
    case 5:
    case 6:
    case 7:
      for(int i=0;i<ItemCount;i++)
      {
        LocateItemByIndex(i);
        if(m_sdRouted->CurStatus==2 || m_sdRouted->CurStatus==3)
          m_sdRouted->Update();
      }
      break;
  }
  TsdRouteh *p=new TsdRouteh();
  if(CurStatus==2)
  {
      SetActionID(1);
      p->Assign(this);
      AddRecord((void *)p,p->RoutehCode);
  }
  else
  {
      SetActionID(1);
      p->Assign(this);
      ChangeRecord((void *)p,p->RoutehCode,this->b_RoutehCode);
  }
}
//---------------------------------------------------------------------------
void TsdRouteh::Delete()
{
    if(CurStatus!=1)
      throw Exception("当前状态不能进行删除操作!");
    if(m_RoutehCode.IsEmpty()==true)
      throw Exception("当前没有记录可以删除!");
    m_StoredProc->Close();
    m_StoredProc->ProcedureName="sdRouteh_Delete";
    m_StoredProc->Parameters->Clear();
    m_StoredProc->Parameters->CreateParameter("@W_RoutehCode",ftString,pdInput,18,b_RoutehCode);
    m_StoredProc->ExecProc();
    m_StoredProc->Close();
    delete m_sdRouted;
    DeleteRecord(this->b_RoutehCode);
}
//---------------------------------------------------------------------------
void TsdRouteh::NewDetail()
{
    m_sdRouted=new TsdRouted(DataComm);
    m_sdRouted->sdParent=this;
}

void TsdRouteh::DeleteDetail()
{
    delete m_sdRouted;
    m_sdRouted=NULL;
}
//---------------------------------------------------------------------------
void TsdRouteh::AddItem()
{
    m_sdRouted->AddNew();
    if(CurStatus!=2)
       SetActionID(5);
}
//---------------------------------------------------------------------------

void TsdRouteh::InsertItem()
{
    //m_sdField->AddNew();
    //TsdField *p=new TsdField(m_SessionName,m_DatabaseName);
    //p->Assign(m_sdField);
    //if(CurStatus==2)
    //   m_sdField->AddRecord((void *)p,p->GetFieldValue(fiFieldName));
    //else
    //   m_sdField->Update();
}
//---------------------------------------------------------------------------

void TsdRouteh::EditItem()
{
    m_sdRouted->Edit();
    if(CurStatus==1)
    {
       SetActionID(6);
    }
}
//---------------------------------------------------------------------------

void TsdRouteh::DeleteItem()
{
   if(CurStatus==2 || CurStatus==5)
      m_sdRouted->DeleteRecord(m_sdRouted->Key);
   else
      m_sdRouted->Delete();
}
//---------------------------------------------------------------------------

void TsdRouteh::RemoveItem()
{
   if(CurStatus==2 || CurStatus==5)
      m_sdRouted->RemoveRecord(m_sdRouted->Index);
   else
      m_sdRouted->Delete();
}
//---------------------------------------------------------------------------
void TsdRouteh::ClearItem()
{
   int iCount;
   if(CurStatus==2)
     m_sdRouted->ClearRecord();
   else
   {
     iCount=m_sdRouted->Count;
     for(int i=0;i<iCount;i++)
     {
       m_sdRouted->LocateByIndex(0);
       m_sdRouted->Delete();
     }
   }
}
//---------------------------------------------------------------------------

void TsdRouteh::CancelItem()
{
    m_sdRouted->Cancel();
}
//---------------------------------------------------------------------------

void TsdRouteh::RestoreItem()
{
    m_sdRouted->RestoreValue();
}
//---------------------------------------------------------------------------

void TsdRouteh::AddToObject()
{
  TsdRouted *p=new TsdRouted();
  p->Assign(m_sdRouted);
  if(m_sdRouted->FindKey(m_sdRouted->GetOldFieldValue(fiRoutedProcess)))
    m_sdRouted->ChangeRecord((void *)p,p->GetFieldValue(fiRoutedProcess),m_sdRouted->GetOldFieldValue(fiRoutedProcess));
  else
    m_sdRouted->AddRecord((void *)p,p->GetFieldValue(fiRoutedProcess));
}
//---------------------------------------------------------------------------
bool TsdRouteh::LocateItemByIndex(int Index)
{
   return m_sdRouted->LocateByIndex(Index);
}
//---------------------------------------------------------------------------

bool TsdRouteh::LocateItemByKey(AnsiString Key)
{
   return m_sdRouted->LocateByKey(Key);
}
//---------------------------------------------------------------------------

void TsdRouteh::BackupValue()
{
    b_sdRouted=m_sdRouted;
    b_RoutehCode=m_RoutehCode;
    b_RoutehName=m_RoutehName;
    b_RoutehGoods=m_RoutehGoods;
    b_RoutehKey=m_RoutehKey;
    b_RoutehEdate=m_RoutehEdate;
    b_RoutehIdate=m_RoutehIdate;
    b_RoutehCancel=m_RoutehCancel;
    b_RoutehCancelDate=m_RoutehCancelDate;
    b_RoutehUser=m_RoutehUser;
    b_RoutehProducter=m_RoutehProducter;
    b_RoutehDesc=m_RoutehDesc;
    b_RoutehSysDate=m_RoutehSysDate;
}
//---------------------------------------------------------------------------
void TsdRouteh::RestoreValue()
{
    m_sdRouted=b_sdRouted;
    m_RoutehCode=b_RoutehCode;
    m_RoutehName=b_RoutehName;
    m_RoutehGoods=b_RoutehGoods;
    m_RoutehKey=b_RoutehKey;
    m_RoutehEdate=b_RoutehEdate;
    m_RoutehIdate=b_RoutehIdate;
    m_RoutehCancel=b_RoutehCancel;
    m_RoutehCancelDate=b_RoutehCancelDate;
    m_RoutehUser=b_RoutehUser;
    m_RoutehProducter=b_RoutehProducter;
    m_RoutehDesc=b_RoutehDesc;
    m_RoutehSysDate=b_RoutehSysDate;
}
//---------------------------------------------------------------------------

void TsdRouteh::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
      m_sdRouted=NULL;
      m_RoutehCode="";
      m_RoutehName="";
      m_RoutehGoods="";
      m_RoutehKey=0;
      m_RoutehEdate="";
      m_RoutehIdate="";
      m_RoutehCancel=0;
      m_RoutehCancelDate="";
      m_RoutehDesc="";
      m_RoutehUser="";
      m_RoutehProducter="";
      m_RoutehSysDate="";
      break;
    case 1:
      b_sdRouted=NULL;
      b_RoutehCode="";
      b_RoutehName="";
      b_RoutehGoods="";
      b_RoutehKey=0;
      b_RoutehEdate="";
      b_RoutehIdate="";
      b_RoutehCancel=0;
      b_RoutehCancelDate="";
      b_RoutehDesc="";
      b_RoutehUser="";
      b_RoutehProducter="";
      b_RoutehSysDate="";
      break;
    }
}
//---------------------------------------------------------------------------
void TsdRouteh::BatchLetValue()
{
    m_RoutehCode=m_Query->FieldValues["RoutehCode"];
    m_RoutehName=m_Query->FieldValues["RoutehName"];
    m_RoutehGoods=m_Query->FieldValues["RoutehGoods"];
    m_RoutehKey=m_Query->FieldValues["RoutehKey"];
    m_RoutehEdate=m_Query->FieldValues["RoutehEdate"];
    m_RoutehIdate=m_Query->FieldValues["RoutehIdate"];
    m_RoutehCancel=m_Query->FieldValues["RoutehCancel"];
    m_RoutehCancelDate=m_Query->FieldValues["RoutehCancelDate"];
    m_RoutehUser=m_Query->FieldValues["RoutehUser"];
    m_RoutehProducter=m_Query->FieldValues["RoutehProducter"];
    m_RoutehDesc=m_Query->FieldValues["RoutehDesc"];
    m_RoutehSysDate=m_Query->FieldValues["RoutehSysDate"];
    BackupValue();
}
//---------------------------------------------------------------------------

void TsdRouteh::Assign(TsdRouteh *p)
{
    this->SetActionID(p->CurStatus);
    this->m_sdRouted=p->m_sdRouted;
    this->m_RoutehCode=p->m_RoutehCode;
    this->m_RoutehName=p->m_RoutehName;
    this->m_RoutehGoods=p->m_RoutehGoods;
    this->m_RoutehKey=p->m_RoutehKey;
    this->m_RoutehEdate=p->m_RoutehEdate;
    this->m_RoutehIdate=p->m_RoutehIdate;
    this->m_RoutehCancel=p->m_RoutehCancel;
    this->m_RoutehCancelDate=p->m_RoutehCancelDate;
    this->m_RoutehUser=p->m_RoutehUser;
    this->m_RoutehProducter=p->m_RoutehProducter;
    this->m_RoutehDesc=p->m_RoutehDesc;
    this->m_RoutehSysDate=p->m_RoutehSysDate;

    if(this->CurStatus==3)
    {
      this->b_sdRouted=p->b_sdRouted;
      this->b_RoutehCode=p->b_RoutehCode;
      this->b_RoutehName=p->b_RoutehName;
      this->b_RoutehGoods=p->b_RoutehGoods;
      this->b_RoutehKey=p->b_RoutehKey;
      this->b_RoutehEdate=p->b_RoutehEdate;
      this->b_RoutehIdate=p->b_RoutehIdate;
      this->b_RoutehCancel=p->b_RoutehCancel;
      this->b_RoutehCancelDate=p->b_RoutehCancelDate;
      this->b_RoutehUser=p->b_RoutehUser;
      this->b_RoutehProducter=p->b_RoutehProducter;
      this->b_RoutehDesc=p->b_RoutehDesc;
      this->b_RoutehSysDate=p->b_RoutehSysDate;
    }
    else
      this->BackupValue();
}
//---------------------------------------------------------------------------
void TsdRouteh::AssignValue()
{
    TsdRouteh *p=(TsdRouteh *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------

int TsdRouteh::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_sdRouted;
   }
   ClearRecord();
   m_sdRouted=NULL;
   if(m_Query->RecordCount>0)
   {
      m_Query->First();
      while(!m_Query->Eof)
      {
         BatchLetValue();
         NewDetail();
         m_sdRouted->FilterString=" RoutedCode='"+m_RoutehCode+"'";
         m_sdRouted->OrderString=" RoutedCode,RoutedSn ";
         m_sdRouted->Query();
         TsdRouteh *p=new TsdRouteh();
         SetActionID(1);
         p->Assign(this);
         AddRecord((void *)p,p->RoutehCode);
         m_Query->Next();
      }
      MoveFirst();
   }
   m_Query->Close();
   return Count;
}
//---------------------------------------------------------------------------

bool TsdRouteh::Find(AnsiString WhereStr)
{
   AnsiString m_SqlStr;
   if(WhereStr.IsEmpty()==true)
      throw Exception("查找的条件表达式不能为空!");
   m_SqlStr="select * from sdRouteh 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_sdRouted->FilterString=" RoutedCode='"+m_RoutehCode+"'";
      m_sdRouted->OrderString=" Routed