cmdoc.cpp

述达erp原代码 述达erp原代码

    }
    m_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TsdRwt::Find(AnsiString WhereStr)
{
    AnsiString m_SqlStr;
    if(WhereStr.IsEmpty()==true)
        throw Exception("查找表达式不能为空");
    m_SqlStr="select * from sdRwt 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;
    }
}

//===================================================
//      (TsdEquc)约当产量系数
//===================================================
void __fastcall TsdEquc:: SetEqucGoods(AnsiString value)
{
    if (value.IsEmpty() )
       throw Exception("产品编码不能为空!");
    if(value.Length()>18)
       throw Exception("产品编码长度不能超过18");
    if (value!=m_EqucGoods)
    {
      m_Query->Close();
      m_Query->SQL->Clear();
      m_Query->SQL->Add("SELECT GoodsCode FROM sdGoods WHERE GoodsCode='" +value+"'");
      m_Query->Open();
      if(m_Query->RecordCount<=0)
      {
        m_Query->Close();
        throw Exception("产品编码"+value+"'未定义");
      }
      m_Query->Close();
    }
    m_EqucGoods=value;
}
void __fastcall TsdEquc:: SetEqucProcess(AnsiString value)
{
    if(value.IsEmpty())
      throw Exception("工序编码不能为空");
    if(value.Length()>18)
      throw Exception("工序编码长度不能大于18");
    if(value!=m_EqucProcess)
    {
      m_Query->Close();
      m_Query->SQL->Clear();
      m_Query->SQL->Add("SELECT PROCESSCODE FROM sdProcess WHERE PROCESSCODE='" +value+"'");
      m_Query->Open();
      if(m_Query->RecordCount<=0)
      {
        m_Query->Close();
        throw Exception("工序编码:"+value+"'未定义");
      }
      m_Query->Close();
    }
    m_EqucProcess=value;
}
void __fastcall TsdEquc:: SetEqucValue(double  value)
{
    if(value<0 )
      throw Exception("约当系数不能小于零");
     m_EqucValue=value;
}
void __fastcall TsdEquc:: SetEqucUser(AnsiString value)
{
  if(value.IsEmpty())
    throw Exception("操作员编码不能为空");
  if(value.Length()>18)
    throw Exception("操作员编码长度不能大于18");
  if(value!=m_EqucUser)
    {
      m_Query->Close();
      m_Query->SQL->Clear();
      m_Query->SQL->Add("SELECT UserCODE FROM SDUser WHERE UserCODE='" +value+"'");
      m_Query->Open();
      if(m_Query->RecordCount<=0)
      {
        m_Query->Close();
        throw Exception("操作员编码"+value+"'未定义");
      }
      m_Query->Close();
    }
    m_EqucUser=value;
}
//---------------------------------------------------------------------------
AnsiString TsdEquc::GetFieldValue(euEquc sdFieldName)
{
    switch(sdFieldName)
    {
      case fiEqucGoods:
           return EqucGoods;
      case fiEqucProcess:
           return EqucProcess;
      case fiEqucValue:
           return EqucValue;
      case fiEqucUser:
           return EqucUser;
      case fiEqucSysDate:
           return EqucSysDate;
      default:
           throw Exception("当前未定义可取值");
     }
}
//---------------------------------------------------------------------------
void TsdEquc::SetFieldValue(euEquc sdFieldName, AnsiString value)
{
    switch(sdFieldName)
     {
    case fiEqucGoods:  
         EqucGoods=value;
          break;
    case fiEqucProcess:  
         EqucProcess=value;
          break;
    case fiEqucValue:  
         EqucValue=value.ToDouble();
          break;
    case fiEqucUser:  
         EqucUser=value;
          break;
    default:
         throw Exception("当前字段未定义可赋值");
      }
}
//---------------------------------------------------------------------------
TsdEquc::TsdEquc(TDataComm *DC)
                :TsdStandard(DC)
{
    try
    {
        EmptyValue(0);
        EmptyValue(1);
        QueryString="SELECT * FROM sdEquc";
        FilterString="";
        OrderString="EqucGoods,EqucProcess";
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TsdEquc::TsdEquc()
        :TsdStandard()
{
    try
    {
        EmptyValue(0);
        EmptyValue(1);
        QueryString="SELECT * FROM sdEquc";
        FilterString="";
        OrderString="EqucGoods,EqucProcess";
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TsdEquc::~TsdEquc()
{
  try{
     }
  catch(...)
    {
     throw Exception("析构函数出错");
    }
}
//---------------------------------------------------------------------------
void TsdEquc::BackupValue()
{
      b_EqucGoods=m_EqucGoods;
      b_EqucProcess=m_EqucProcess;
      b_EqucValue=m_EqucValue;
      b_EqucUser=m_EqucUser;
      b_EqucSysDate=m_EqucSysDate;
}
//---------------------------------------------------------------------------
void TsdEquc::RestoreValue()
{
      m_EqucGoods=b_EqucGoods;
      m_EqucProcess=b_EqucProcess;
      m_EqucValue=b_EqucValue;
      m_EqucUser=b_EqucUser;
      m_EqucSysDate=b_EqucSysDate;
}
//---------------------------------------------------------------------------
void TsdEquc::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
        m_EqucGoods="";
        m_EqucProcess="";
        m_EqucValue=0;
        m_EqucUser="";
        m_EqucSysDate="";
    break;
    case 1:
        b_EqucGoods="";
        b_EqucProcess="";
        b_EqucValue=0;
        b_EqucUser="";
        b_EqucSysDate="";
      break;
     }
}
//---------------------------------------------------------------------------
void TsdEquc::BatchLetValue()
{
    m_EqucGoods=m_Query->FieldValues["EqucGoods"];
    m_EqucProcess=m_Query->FieldValues["EqucProcess"];
    m_EqucValue=m_Query->FieldValues["EqucValue"];
    m_EqucUser=m_Query->FieldValues["EqucUser"];
    m_EqucSysDate=m_Query->FieldValues["EqucSysDate"];
    BackupValue();
}
//---------------------------------------------------------------------------
void TsdEquc::Update()
{
    if(CurStatus==0||CurStatus==1)
        throw Exception("当前不是编辑状态,不能进行存盘操作!");
    if(m_EqucGoods.IsEmpty()==true)
        throw Exception("产品编码不能为空!");
    m_StoredProc->Close();
    if(CurStatus==2||CurStatus==4)
      {
        RecordDoubuleCh();
        m_StoredProc->ProcedureName="sdEquc_Insert";
        m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@EqucGoods",ftString,pdInput,18,m_EqucGoods);
        m_StoredProc->Parameters->CreateParameter("@EqucProcess",ftString,pdInput,18,m_EqucProcess);
        m_StoredProc->Parameters->CreateParameter("@EqucValue",ftFloat,pdInput,12,m_EqucValue);
        m_StoredProc->Parameters->CreateParameter("@EqucUser",ftString,pdInput,18,m_EqucUser);
        m_StoredProc->Parameters->CreateParameter("@EqucSysDate",ftString,pdOutput,40,m_EqucSysDate);

        m_StoredProc->ExecProc();
        m_StoredProc->Close();
        m_EqucSysDate=m_StoredProc->Parameters->ParamValues["@EqucSysDate"];
    }
    else
    {
        if(m_EqucGoods!=b_EqucGoods)
        RecordDoubuleCh();
        m_StoredProc->ProcedureName="sdEquc_Update";
        m_StoredProc->Parameters->Clear();

        m_StoredProc->Parameters->CreateParameter("@W_EqucGoods",ftString,pdInput,18,b_EqucGoods);
        m_StoredProc->Parameters->CreateParameter("@W_EqucProcess",ftString,pdInput,18,b_EqucProcess);
        m_StoredProc->Parameters->CreateParameter("@EqucGoods",ftString,pdInput,18,m_EqucGoods);
        m_StoredProc->Parameters->CreateParameter("@EqucProcess",ftString,pdInput,18,m_EqucProcess);
        m_StoredProc->Parameters->CreateParameter("@EqucValue",ftFloat,pdInput,12,m_EqucValue);
        m_StoredProc->Parameters->CreateParameter("@EqucUser",ftString,pdInput,18,m_EqucUser);
        m_StoredProc->Parameters->CreateParameter("@EqucSysDate",ftString,pdOutput,40,m_EqucSysDate);

       m_StoredProc->ExecProc();
       m_StoredProc->Close();
       m_EqucSysDate=m_StoredProc->Parameters->ParamValues["@EqucSysDate"];

   }
  TsdEquc *p=new TsdEquc();
  if(CurStatus==2)
    {
     SetActionID(1);
     p->Assign(this);
     AddRecord((void *)p,p->EqucGoods+p->EqucProcess);
     }
  else
    {
     SetActionID(1);
     p->Assign(this);
     ChangeRecord((void *)p,p->EqucGoods+p->EqucProcess,this->b_EqucGoods+this->b_EqucProcess);
    }
}
//---------------------------------------------------------------------------
void  TsdEquc::RecordDoubuleCh()
{
        m_Query->Close();
        m_Query->SQL->Clear();
        m_Query->SQL->Add("SELECT EQUCGOODS,EQUCPROCESS FROM sdEquc WHERE EQUCGOODS='"+m_EqucGoods+"' and EQUCPROCESS='"+m_EqucProcess+"'");
        m_Query->Open();
        if(m_Query->RecordCount>0)
        {
          m_Query->Close();
          throw Exception("该记录已存在! 请重新输入");
        }
}
void TsdEquc::Delete()
{
    if(CurStatus!=1)
        throw Exception("当前状态不能进行删除操作!");
    if(m_EqucGoods.IsEmpty()==true)
        throw Exception("当前没有记录可以删除!");
    m_StoredProc->Close();
    m_StoredProc->ProcedureName="sdEquc_Delete";
    m_StoredProc->Parameters->Clear();
    m_StoredProc->Parameters->CreateParameter("@W_EqucGoods",ftString,pdInput,18,b_EqucGoods);
    m_StoredProc->Parameters->CreateParameter("@W_EqucProcess",ftString,pdInput,18,b_EqucProcess);
    m_StoredProc->ExecProc();
    m_StoredProc->Close();
    DeleteRecord(this->b_EqucGoods+this->b_EqucProcess);
}
//---------------------------------------------------------------------------
void TsdEquc::Assign(TsdEquc *p)
{
    this->SetActionID(p->CurStatus);
    this->m_EqucGoods=p->m_EqucGoods;
    this->m_EqucProcess=p->m_EqucProcess;
    this->m_EqucValue=p->m_EqucValue;
    this->m_EqucUser=p->m_EqucUser;
    this->m_EqucSysDate=p->m_EqucSysDate;
    this->BackupValue();
}
//---------------------------------------------------------------------------
void TsdEquc::AssignValue()
{
    TsdEquc *p=(TsdEquc *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------
int TsdEquc::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();
            TsdEquc *p=new TsdEquc();
            SetActionID(1);
            p->Assign(this);
            AddRecord((void *)p,p->m_EqucGoods+p->m_EqucProcess);
            m_Query->Next();
        }
        MoveFirst();
    }
    m_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TsdEquc::Find(AnsiString WhereStr)
{
    AnsiString m_SqlStr;
    if(WhereStr.IsEmpty()==true)
        throw Exception("查找表达式不能为空");
    m_SqlStr="select * from sdEquc 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;
    }
}
//**************************************
//     TsdMcd   成本差异
//**************************************
//--------------------------------------------------------------
void __fastcall TsdMcd:: SetMcdFmonth(AnsiString value)
{
       m_McdFmonth=value;
}
void __fastcall TsdMcd:: SetMcdGoods(AnsiString value)
{
       m_McdGoods=value;
}
void __fastcall TsdMcd:: SetMcdBopCost(double  value)
{
       m_McdBopCost=value;
}
void __fastcall TsdMcd:: SetMcdBopDiff(double  value)
{
       m_McdBopDiff=value;
}
void __fastcall TsdMcd:: SetMcdIopCost(double  value)
{
       m_McdIopCost=value;
}
void __fastcall TsdMcd:: SetMcdIopDiff(double  value)
{
       m_McdIopDiff=value;
}
void __fastcall TsdMcd:: SetMcdSopCost(double  value)
{
       m_McdSopCost=value;
}
void __fastcall TsdMcd:: SetMcdSopDiff(double  value)
{
       m_McdSopDiff=value;
}
void __fastcall TsdMcd:: SetMcdNopCost(double  value)
{
       m_McdNopCost=value;
}
void __fastcall TsdMcd:: SetMcdNopDiff(double  value)
{
       m_McdNopDiff=value;
}
void __fastcall TsdMcd:: SetMcdFopCost(double  value)
{
       m_McdFopCost=value;
}
void __fastcall TsdMcd:: SetMcdFopDiff(double  value)
{
       m_McdFopDiff=value;
}
void __fastcall TsdMcd:: SetMcdIoyCost(double  value)
{
       m_McdIoyCost=value;
}
void __fastcall TsdMcd:: SetMcdIoyDiff(double  value)
{
       m_McdIoyDiff=value;
}
void __fastcall TsdMcd:: SetMcdSoyCost(double  value)