imhdl.cpp

邮 电 公 司 erp源码

  }
  catch(...)
  {
    throw Exception("析构函数出错");
  }
}

//---------------------------------------------------------------------------

void TsdAlfh::Update()
{
    if(CurStatus==0||CurStatus==1)
        throw Exception("当前不是编辑状态,不能进行存盘操作!");
    if(m_AlfhCode.IsEmpty()==true)
    throw Exception("调拨单号不能为空!");
    if(ItemCount<=0)
        throw Exception("调拨单没有定义明细字段");
    m_StoredProc->Close();
    switch(CurStatus)
    {
    case 2:
    case 4:
        m_StoredProc->ProcedureName="sdAlfh_Insert";
        m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@AlfhCode",ftString,pdInputOutput,18,m_AlfhCode);
        m_StoredProc->Parameters->CreateParameter("@AlfhDate",ftString,pdInput,10,m_AlfhDate);
        m_StoredProc->Parameters->CreateParameter("@AlfhODept",ftString,pdInput,18,m_AlfhODept);
        m_StoredProc->Parameters->CreateParameter("@AlfhPosType",ftString,pdInput,18,m_AlfhPosType);
        m_StoredProc->Parameters->CreateParameter("@AlfhIDept",ftString,pdInput,18,m_AlfhIDept);
        m_StoredProc->Parameters->CreateParameter("@AlfhDesc",ftString,pdInput,40,m_AlfhDesc);
        m_StoredProc->Parameters->CreateParameter("@AlfhInvFlg",ftInteger,pdInput,1,m_AlfhInvFlg);
        m_StoredProc->Parameters->CreateParameter("@AlfhFmonth",ftString,pdInput,6,m_AlfhFmonth);
        m_StoredProc->Parameters->CreateParameter("@AlfhUser",ftString,pdInput,18,m_AlfhUser);
        m_StoredProc->Parameters->CreateParameter("@AlfhKeeper",ftString,pdInput,18,m_AlfhKeeper);
        m_StoredProc->Parameters->CreateParameter("@AlfhType",ftInteger,pdInput,1,m_AlfhType);
        m_StoredProc->Parameters->CreateParameter("@AlfhSysDate",ftString,pdOutput,40,m_AlfhSysDate);

        m_StoredProc->ExecProc();
        m_AlfhCode=m_StoredProc->Parameters->ParamValues["@AlfhCode"];
        m_AlfhSysDate=m_StoredProc->Parameters->ParamValues["@AlfhSysDate"];

        for(int i=0;i<ItemCount;i++)
        {
            LocateItemByIndex(i);
            m_sdAlfd->SetFieldValue(fiAlfdCode,m_AlfhCode);
            AddToObject();
            m_sdAlfd->Update();
        }
        break;
    case 3:
        m_StoredProc->ProcedureName="sdAlfh_Update";
        m_StoredProc->Parameters->Clear();

        m_StoredProc->Parameters->CreateParameter("@W_AlfhCode",ftString,pdInput,18,b_AlfhCode);
        m_StoredProc->Parameters->CreateParameter("@AlfhDate",ftString,pdInput,10,m_AlfhDate);
        m_StoredProc->Parameters->CreateParameter("@AlfhODept",ftString,pdInput,18,m_AlfhODept);
        m_StoredProc->Parameters->CreateParameter("@AlfhPosType",ftString,pdInput,18,m_AlfhPosType);
        m_StoredProc->Parameters->CreateParameter("@AlfhIDept",ftString,pdInput,18,m_AlfhIDept);
        m_StoredProc->Parameters->CreateParameter("@AlfhDesc",ftString,pdInput,40,m_AlfhDesc);
        m_StoredProc->Parameters->CreateParameter("@AlfhCheck",ftInteger,pdInput,1,m_AlfhCheck);
        m_StoredProc->Parameters->CreateParameter("@AlfhChecker",ftString,pdInput,18,m_AlfhChecker);
        m_StoredProc->Parameters->CreateParameter("@AlfhCheckDate",ftString,pdInput,10,m_AlfhCheckDate);
        m_StoredProc->Parameters->CreateParameter("@AlfhFmonth",ftString,pdInput,6,m_AlfhFmonth);
        m_StoredProc->Parameters->CreateParameter("@AlfhUser",ftString,pdInput,18,m_AlfhUser);
        m_StoredProc->Parameters->CreateParameter("@AlfhKeeper",ftString,pdInput,18,m_AlfhKeeper);
        m_StoredProc->Parameters->CreateParameter("@AlfhCancel",ftInteger,pdInput,1,m_AlfhCancel);
        m_StoredProc->Parameters->CreateParameter("@AlfhCancelDate",ftString,pdInput,10,m_AlfhCancelDate);
        m_StoredProc->Parameters->CreateParameter("@AlfhSysDate",ftString,pdOutput,40,m_AlfhSysDate);
        m_StoredProc->Parameters->CreateParameter("@AlfhType",ftInteger,pdInput,1,m_AlfhType);

       m_StoredProc->ExecProc();
       m_AlfhSysDate=m_StoredProc->Parameters->ParamValues["@AlfhSysDate"];
      break;
    case 5:
    case 6:
        for(int i=0;i<ItemCount;i++)
        {
          LocateItemByIndex(i);
          if(m_sdAlfd->CurStatus==2||m_sdAlfd->CurStatus==3)
           m_sdAlfd->Update();
        }
        break;
    }
    TsdAlfh *p=new TsdAlfh();
    if(CurStatus==2)
    {
      SetActionID(1);
      p->Assign(this);
      AddRecord((void *)p,p->AlfhCode);
    }
    else
    {
      SetActionID(1);
      p->Assign(this);
      ChangeRecord((void *)p,p->AlfhCode,this->b_AlfhCode);
    }
}

//---------------------------------------------------------------------------

void TsdAlfh::Delete()
{
    if(CurStatus!=1)
        throw Exception("当前状态不能进行删除操作!");
    if(m_AlfhCode.IsEmpty()==true)
        throw Exception("当前没有记录可以删除!");
    m_StoredProc->Close();
    m_StoredProc->ProcedureName="sdAlfh_Delete";
    m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@W_AlfhCode",ftString,pdInput,18,b_AlfhCode);
    m_StoredProc->ExecProc();
    delete m_sdAlfd;
    DeleteRecord(this->b_AlfhCode);
}


void TsdAlfh::NewDetail()
{
    m_sdAlfd=new TsdAlfd(DataComm);
    m_sdAlfd->sdParent=this;
}

void TsdAlfh::DeleteDetail()
{
    delete m_sdAlfd;
    m_sdAlfd=NULL;
}

//---------------------------------------------------------------------------

void TsdAlfh::AddItem()
{
    m_sdAlfd->AddNew();
    if(CurStatus!=2)
        SetActionID(5);
}

//---------------------------------------------------------------------------

void TsdAlfh::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 TsdAlfh::EditItem()
{
    m_sdAlfd->Edit();
    if(CurStatus==1)
    {
     SetActionID(6);
    }
}
//---------------------------------------------------------------------------

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

void TsdAlfh::RemoveItem()
{
    if(CurStatus==2||CurStatus==5)
        m_sdAlfd->RemoveRecord(m_sdAlfd->Index);
    else
        m_sdAlfd->Delete();
}
//---------------------------------------------------------------------------

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

void TsdAlfh::CancelItem()
{
    m_sdAlfd->Cancel();
}

//---------------------------------------------------------------------------

void TsdAlfh::AddToObject()
{
    TsdAlfd *p=new TsdAlfd();
    p->Assign(m_sdAlfd);
    if(m_sdAlfd->FindKey(m_sdAlfd->GetOldFieldValue(fiAlfdLine)))
      m_sdAlfd->ChangeRecord((void *)p,p->GetFieldValue(fiAlfdLine),m_sdAlfd->GetOldFieldValue(fiAlfdLine));
    else
      m_sdAlfd->AddRecord((void *)p,p->GetFieldValue(fiAlfdLine));
//    if(CurStatus==5)
//        Update();
}

//---------------------------------------------------------------------------

bool TsdAlfh::LocateItemByIndex(int Index)

{
  return m_sdAlfd->LocateByIndex(Index);
}

//---------------------------------------------------------------------------

bool TsdAlfh::LocateItemByKey(AnsiString Key)
{
  return m_sdAlfd->LocateByKey(Key);
}
//---------------------------------------------------------------------------

void TsdAlfh::BackupValue()
{
  b_sdAlfd        =m_sdAlfd         ;
  b_AlfhCode      =m_AlfhCode       ;
  b_AlfhDate      =m_AlfhDate       ;
  b_AlfhODept     =m_AlfhODept      ;
  b_AlfhPosType   =m_AlfhPosType    ;
  b_AlfhIDept     =m_AlfhIDept      ;
  b_AlfhDesc      =m_AlfhDesc       ;
  b_AlfhCheck     =m_AlfhCheck      ;
  b_AlfhChecker   =m_AlfhChecker    ;
  b_AlfhCheckDate =m_AlfhCheckDate ;
  b_AlfhInvFlg    =m_AlfhInvFlg     ;
  b_AlfhFmonth    =m_AlfhFmonth     ;
  b_AlfhUser      =m_AlfhUser       ;
  b_AlfhKeeper    =m_AlfhKeeper;
  b_AlfhCancel    =m_AlfhCancel     ;
  b_AlfhCancelDate=m_AlfhCancelDate ;
  b_AlfhSysDate   =m_AlfhSysDate    ;
  b_AlfhType      =m_AlfhType       ;

}
//---------------------------------------------------------------------------

void TsdAlfh::RestoreValue()
{
  m_sdAlfd        =b_sdAlfd         ;
  m_AlfhCode      =b_AlfhCode       ;
  m_AlfhDate      =b_AlfhDate       ;
  m_AlfhODept     =b_AlfhODept      ;
  m_AlfhPosType   =b_AlfhPosType    ;
  m_AlfhIDept     =b_AlfhIDept      ;
  m_AlfhDesc      =b_AlfhDesc       ;
  m_AlfhCheck     =b_AlfhCheck      ;
  m_AlfhChecker   =b_AlfhChecker    ;
  m_AlfhCheckDate =b_AlfhCheckDate ;
  m_AlfhInvFlg    =b_AlfhInvFlg     ;
  m_AlfhFmonth    =b_AlfhFmonth     ;
  m_AlfhUser      =b_AlfhUser       ;
  m_AlfhKeeper    =b_AlfhKeeper;
  m_AlfhCancel    =b_AlfhCancel     ;
  m_AlfhCancelDate=b_AlfhCancelDate ;
  m_AlfhSysDate   =b_AlfhSysDate    ;
  m_AlfhType      =b_AlfhType       ;
}
//---------------------------------------------------------------------------

void TsdAlfh::RestoreItem()
{
 m_sdAlfd->RestoreValue();
}
//---------------------------------------------------------------------------

void TsdAlfh::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
        m_AlfhCode      ="";
        m_AlfhDate      ="";
        m_AlfhODept     ="";
        m_AlfhPosType   ="";
        m_AlfhIDept     ="";
        m_AlfhDesc      ="";
        m_AlfhCheck     =0;
        m_AlfhChecker   ="";
        m_AlfhCheckDate ="";
        m_AlfhInvFlg    =0;
        m_AlfhFmonth    ="";
        m_AlfhUser      ="";
        m_AlfhKeeper    ="";
        m_AlfhCancel    =0;
        m_AlfhCancelDate="";
        m_AlfhSysDate   ="";
        m_AlfhType      =0;
        break;
    case 1:
        b_AlfhCode      ="";
        b_AlfhDate      ="";
        b_AlfhODept     ="";
        b_AlfhPosType   ="";
        b_AlfhIDept     ="";
        b_AlfhDesc      ="";
        b_AlfhCheck     =0;
        b_AlfhChecker   ="";
        b_AlfhCheckDate ="";
        b_AlfhInvFlg    =0;
        b_AlfhFmonth    ="";
        b_AlfhUser      ="";
        b_AlfhKeeper    ="";
        b_AlfhCancel    =0;
        b_AlfhCancelDate="";
        b_AlfhSysDate   ="";
        b_AlfhType      =0;
      break;
    }
}
//---------------------------------------------------------------------------

void TsdAlfh::BatchLetValue()
{
  m_AlfhCode      =m_Query->FieldValues["AlfhCode"];
  m_AlfhDate      =m_Query->FieldValues["AlfhDate"];
  m_AlfhODept     =m_Query->FieldValues["AlfhODept"];
  m_AlfhPosType   =m_Query->FieldValues["AlfhPosType"];
  m_AlfhIDept     =m_Query->FieldValues["AlfhIDept"];
  m_AlfhDesc      =m_Query->FieldValues["AlfhDesc"];
  m_AlfhCheck     =m_Query->FieldValues["AlfhCheck"];
  m_AlfhChecker   =m_Query->FieldValues["AlfhChecker"];
  m_AlfhCheckDate =m_Query->FieldValues["AlfhCheckDate"];
  m_AlfhInvFlg    =m_Query->FieldValues["AlfhInvFlg"];
  m_AlfhFmonth    =m_Query->FieldValues["AlfhFmonth"];
  m_AlfhUser      =m_Query->FieldValues["AlfhUser"];
  m_AlfhCancel    =m_Query->FieldValues["AlfhCancel"];
  m_AlfhCancelDate=m_Query->FieldValues["AlfhCancelDate"];
  m_AlfhSysDate   =m_Query->FieldValues["AlfhSysDate"];
  m_AlfhType      =m_Query->FieldValues["AlfhType"];
  m_AlfhKeeper    =m_Query->FieldValues["AlfhKeeper"];
    BackupValue();
}

//---------------------------------------------------------------------------

void TsdAlfh::Assign(TsdAlfh *p)
{
    this->SetActionID(p->CurStatus);
    this->m_sdAlfd          =p->m_sdAlfd;
    this->m_AlfhCode          =p->m_AlfhCode       ;
    this->m_AlfhDate          =p->m_AlfhDate       ;
    this->m_AlfhODept         =p->m_AlfhODept      ;
    this->m_AlfhPosType       =p->m_AlfhPosType    ;
    this->m_AlfhIDept         =p->m_AlfhIDept      ;
    this->m_AlfhDesc          =p->m_AlfhDesc       ;
    this->m_AlfhCheck         =p->m_AlfhCheck      ;
    this->m_AlfhChecker     =p->m_AlfhChecker    ;
    this->m_AlfhCheckDate   =p->m_AlfhCheckDate  ;
    this->m_AlfhInvFlg        =p->m_AlfhInvFlg     ;
    this->m_AlfhFmonth        =p->m_AlfhFmonth     ;
    this->m_AlfhUser          =p->m_AlfhUser       ;
    this->m_AlfhKeeper        =p->m_AlfhKeeper;
    this->m_AlfhCancel        =p->m_AlfhCancel     ;
    this->m_AlfhCancelDate  =p->m_AlfhCancelDate ;
    this->m_AlfhSysDate     =p->m_AlfhSysDate    ;
    this->m_AlfhType          =p->m_AlfhType       ;
  if(this->CurStatus == 3)
  {
    this->b_sdAlfd          =p->b_sdAlfd;
    this->b_AlfhCode          =p->b_AlfhCode       ;
    this->b_AlfhDate          =p->b_AlfhDate       ;
    this->b_AlfhODept         =p->b_AlfhODept      ;
    this->b_AlfhPosType       =p->b_AlfhPosType    ;
    this->b_AlfhIDept         =p->b_AlfhIDept      ;
    this->b_AlfhDesc          =p->b_AlfhDesc       ;
    this->b_AlfhCheck         =p->b_AlfhCheck      ;
    this->b_AlfhChecker     =p->b_AlfhChecker    ;
    this->b_AlfhCheckDate   =p->b_AlfhCheckDate  ;
    this->b_AlfhInvFlg        =p->b_AlfhInvFlg     ;
    this->b_AlfhFmonth        =p->b_AlfhFmonth     ;
    this->b_AlfhUser          =p->b_AlfhUser       ;
    this->b_AlfhKeeper        =p->b_AlfhKeeper;
    this->b_AlfhCancel        =p->b_AlfhCancel     ;
    this->b_AlfhCancelDate  =p->b_AlfhCancelDate ;
    this->b_AlfhSysDate     =p->b_AlfhSysDate    ;
    this->b_AlfhType          =p->b_AlfhType       ;
  }
  else
    this->BackupValue();


}
//---------------------------------------------------------------------------

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

int TsdAlfh::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++)
    {
      LocateByIndex(i);
      AssignValue();
      delete m_sdAlfd;
    }
    ClearRecord();
    if(m_Query->RecordCount>0)
    {