cmdoc.cpp

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

{
       m_McdSoyCost=value;
}
void __fastcall TsdMcd:: SetMcdSoyDiff(double  value)
{
       m_McdSoyDiff=value;
}
void __fastcall TsdMcd:: SetMcdRdc(double  value)
{
       m_McdRdc=value;
}
//---------------------------------------------------------------------------
AnsiString TsdMcd::GetFieldValue(euMcd sdFieldName)
{
    switch(sdFieldName)
    {
      case fiMcdFmonth:
           return McdFmonth;
      case fiMcdGoods:
           return McdGoods;
      case fiMcdBopCost:
           return McdBopCost;
      case fiMcdBopDiff:
           return McdBopDiff;
      case fiMcdIopCost:
           return McdIopCost;
      case fiMcdIopDiff:
           return McdIopDiff;
      case fiMcdSopCost:
           return McdSopCost;
      case fiMcdSopDiff:
           return McdSopDiff;
      case fiMcdNopCost:
           return McdNopCost;
      case fiMcdNopDiff:
           return McdNopDiff;
      case fiMcdFopCost:
           return McdFopCost;
      case fiMcdFopDiff:
           return McdFopDiff;
      case fiMcdIoyCost:
           return McdIoyCost;
      case fiMcdIoyDiff:
           return McdIoyDiff;
      case fiMcdSoyCost:
           return McdSoyCost;
      case fiMcdSoyDiff:
           return McdSoyDiff;
      case fiMcdRdc:
           return McdRdc;
      default:
           throw Exception("当前未定义可取值");
     }
}
//---------------------------------------------------------------------------
void TsdMcd::SetFieldValue(euMcd sdFieldName, AnsiString value)
{
    switch(sdFieldName)
     {
    case fiMcdFmonth:
         McdFmonth=value;
          break;
    case fiMcdGoods:  
         McdGoods=value;
          break;
    case fiMcdBopCost:  
         McdBopCost=value.ToDouble();
          break;
    case fiMcdBopDiff:  
         McdBopDiff=value.ToDouble();
          break;
    case fiMcdIopCost:  
         McdIopCost=value.ToDouble();
          break;
    case fiMcdIopDiff:  
         McdIopDiff=value.ToDouble();
          break;
    case fiMcdSopCost:
         McdSopCost=value.ToDouble();
          break;
    case fiMcdSopDiff:
         McdSopDiff=value.ToDouble();
          break;
    case fiMcdNopCost:  
         McdNopCost=value.ToDouble();
          break;
    case fiMcdNopDiff:  
         McdNopDiff=value.ToDouble();
          break;
    case fiMcdFopCost:  
         McdFopCost=value.ToDouble();
          break;
    case fiMcdFopDiff:  
         McdFopDiff=value.ToDouble();
          break;
    case fiMcdIoyCost:
         McdIoyCost=value.ToDouble();
          break;
    case fiMcdIoyDiff:  
         McdIoyDiff=value.ToDouble();
          break;
    case fiMcdSoyCost:
         McdSoyCost=value.ToDouble();
          break;
    case fiMcdSoyDiff:  
         McdSoyDiff=value.ToDouble();
          break;
    case fiMcdRdc:  
         McdRdc=value.ToDouble();
          break;
    default:
         throw Exception("当前字段未定义可赋值");
      }
}
//---------------------------------------------------------------------------
TsdMcd::TsdMcd(TDataComm *DC)
                :TsdStandard(DC)
{
    try
    {
        EmptyValue(0);
        EmptyValue(1);
        QueryString="SELECT * FROM sdMcd";
        FilterString="";
        OrderString="McdFmonth,McdGoods";
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TsdMcd::TsdMcd()
       :TsdStandard()
{
    try
    {
        EmptyValue(0);
        EmptyValue(1);
        QueryString="SELECT * FROM sdMcd";
        FilterString="";
        OrderString="McdFmonth,McdGoods";
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TsdMcd::~TsdMcd()
{
  try{
     }
  catch(...)
    {
     throw Exception("析构函数出错");
    }
}
//---------------------------------------------------------------------------
void TsdMcd::BackupValue()
{
      b_McdFmonth=m_McdFmonth;
      b_McdGoods=m_McdGoods;
      b_McdBopCost=m_McdBopCost;
      b_McdBopDiff=m_McdBopDiff;
      b_McdIopCost=m_McdIopCost;
      b_McdIopDiff=m_McdIopDiff;
      b_McdSopCost=m_McdSopCost;
      b_McdSopDiff=m_McdSopDiff;
      b_McdNopCost=m_McdNopCost;
      b_McdNopDiff=m_McdNopDiff;
      b_McdFopCost=m_McdFopCost;
      b_McdFopDiff=m_McdFopDiff;
      b_McdIoyCost=m_McdIoyCost;
      b_McdIoyDiff=m_McdIoyDiff;
      b_McdSoyCost=m_McdSoyCost;
      b_McdSoyDiff=m_McdSoyDiff;
      b_McdRdc=m_McdRdc;
}
//---------------------------------------------------------------------------
void TsdMcd::RestoreValue()
{
      m_McdFmonth=b_McdFmonth;
      m_McdGoods=b_McdGoods;
      m_McdBopCost=b_McdBopCost;
      m_McdBopDiff=b_McdBopDiff;
      m_McdIopCost=b_McdIopCost;
      m_McdIopDiff=b_McdIopDiff;
      m_McdSopCost=b_McdSopCost;
      m_McdSopDiff=b_McdSopDiff;
      m_McdNopCost=b_McdNopCost;
      m_McdNopDiff=b_McdNopDiff;
      m_McdFopCost=b_McdFopCost;
      m_McdFopDiff=b_McdFopDiff;
      m_McdIoyCost=b_McdIoyCost;
      m_McdIoyDiff=b_McdIoyDiff;
      m_McdSoyCost=b_McdSoyCost;
      m_McdSoyDiff=b_McdSoyDiff;
      m_McdRdc=b_McdRdc;
}
//---------------------------------------------------------------------------
void TsdMcd::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
        m_McdFmonth="";
        m_McdGoods="";
        m_McdBopCost=0;
        m_McdBopDiff=0;
        m_McdIopCost=0;
        m_McdIopDiff=0;
        m_McdSopCost=0;
        m_McdSopDiff=0;
        m_McdNopCost=0;
        m_McdNopDiff=0;
        m_McdFopCost=0;
        m_McdFopDiff=0;
        m_McdIoyCost=0;
        m_McdIoyDiff=0;
        m_McdSoyCost=0;
        m_McdSoyDiff=0;
        m_McdRdc=0;
    break;
    case 1:
        b_McdFmonth="";
        b_McdGoods="";
        b_McdBopCost=0;
        b_McdBopDiff=0;
        b_McdIopCost=0;
        b_McdIopDiff=0;
        b_McdSopCost=0;
        b_McdSopDiff=0;
        b_McdNopCost=0;
        b_McdNopDiff=0;
        b_McdFopCost=0;
        b_McdFopDiff=0;
        b_McdIoyCost=0;
        b_McdIoyDiff=0;
        b_McdSoyCost=0;
        b_McdSoyDiff=0;
        b_McdRdc=0;
      break;
     }
}
//---------------------------------------------------------------------------
void TsdMcd::BatchLetValue()
{
    m_McdFmonth=m_Query->FieldValues["McdFmonth"];
    m_McdGoods=m_Query->FieldValues["McdGoods"];
    m_McdBopCost=m_Query->FieldValues["McdBopCost"];
    m_McdBopDiff=m_Query->FieldValues["McdBopDiff"];
    m_McdIopCost=m_Query->FieldValues["McdIopCost"];
    m_McdIopDiff=m_Query->FieldValues["McdIopDiff"];
    m_McdSopCost=m_Query->FieldValues["McdSopCost"];
    m_McdSopDiff=m_Query->FieldValues["McdSopDiff"];
    m_McdNopCost=m_Query->FieldValues["McdNopCost"];
    m_McdNopDiff=m_Query->FieldValues["McdNopDiff"];
    m_McdFopCost=m_Query->FieldValues["McdFopCost"];
    m_McdFopDiff=m_Query->FieldValues["McdFopDiff"];
    m_McdIoyCost=m_Query->FieldValues["McdIoyCost"];
    m_McdIoyDiff=m_Query->FieldValues["McdIoyDiff"];
    m_McdSoyCost=m_Query->FieldValues["McdSoyCost"];
    m_McdSoyDiff=m_Query->FieldValues["McdSoyDiff"];
    m_McdRdc=m_Query->FieldValues["McdRdc"];
    BackupValue();
}
//---------------------------------------------------------------------------
void TsdMcd::Update()
{
    if(CurStatus==0||CurStatus==1)
        throw Exception("当前不是编辑状态,不能进行存盘操作!");
    if(m_McdGoods.IsEmpty()==true)
        throw Exception("物料编码不能为空!");
    m_StoredProc->Close();
    if(CurStatus==2||CurStatus==4)
      {
        m_StoredProc->ProcedureName="sdMcd_Insert";
        m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@McdFmonth",ftString,pdInput,6,m_McdFmonth);
        m_StoredProc->Parameters->CreateParameter("@McdGoods",ftString,pdInput,18,m_McdGoods);
        m_StoredProc->Parameters->CreateParameter("@McdBopCost",ftFloat,pdInput,12,m_McdBopCost);
        m_StoredProc->Parameters->CreateParameter("@McdBopDiff",ftFloat,pdInput,12,m_McdBopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdIopCost",ftFloat,pdInput,12,m_McdIopCost);
        m_StoredProc->Parameters->CreateParameter("@McdIopDiff",ftFloat,pdInput,12,m_McdIopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdSopCost",ftFloat,pdInput,12,m_McdSopCost);
        m_StoredProc->Parameters->CreateParameter("@McdSopDiff",ftFloat,pdInput,12,m_McdSopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdNopCost",ftFloat,pdInput,12,m_McdNopCost);
        m_StoredProc->Parameters->CreateParameter("@McdNopDiff",ftFloat,pdInput,12,m_McdNopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdFopCost",ftFloat,pdInput,12,m_McdFopCost);
        m_StoredProc->Parameters->CreateParameter("@McdFopDiff",ftFloat,pdInput,12,m_McdFopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdIoyCost",ftFloat,pdInput,12,m_McdIoyCost);
        m_StoredProc->Parameters->CreateParameter("@McdIoyDiff",ftFloat,pdInput,12,m_McdIoyDiff);
        m_StoredProc->Parameters->CreateParameter("@McdSoyCost",ftFloat,pdInput,12,m_McdSoyCost);
        m_StoredProc->Parameters->CreateParameter("@McdSoyDiff",ftFloat,pdInput,12,m_McdSoyDiff);
        m_StoredProc->Parameters->CreateParameter("@McdRdc",ftFloat,pdInput,12,m_McdRdc);

        m_StoredProc->ExecProc();
        m_StoredProc->Close();
   }
  else
    {
        m_StoredProc->ProcedureName="sdMcd_Update";
        m_StoredProc->Parameters->Clear();

        m_StoredProc->Parameters->CreateParameter("@W_McdFmonth",ftString,pdInput,6,b_McdFmonth);
        m_StoredProc->Parameters->CreateParameter("@W_McdGoods",ftString,pdInput,18,b_McdGoods);
        m_StoredProc->Parameters->CreateParameter("@McdFmonth",ftString,pdInput,6,m_McdFmonth);
        m_StoredProc->Parameters->CreateParameter("@McdGoods",ftString,pdInput,18,m_McdGoods);
        m_StoredProc->Parameters->CreateParameter("@McdBopCost",ftFloat,pdInput,12,m_McdBopCost);
        m_StoredProc->Parameters->CreateParameter("@McdBopDiff",ftFloat,pdInput,12,m_McdBopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdIopCost",ftFloat,pdInput,12,m_McdIopCost);
        m_StoredProc->Parameters->CreateParameter("@McdIopDiff",ftFloat,pdInput,12,m_McdIopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdSopCost",ftFloat,pdInput,12,m_McdSopCost);
        m_StoredProc->Parameters->CreateParameter("@McdSopDiff",ftFloat,pdInput,12,m_McdSopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdNopCost",ftFloat,pdInput,12,m_McdNopCost);
        m_StoredProc->Parameters->CreateParameter("@McdNopDiff",ftFloat,pdInput,12,m_McdNopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdFopCost",ftFloat,pdInput,12,m_McdFopCost);
        m_StoredProc->Parameters->CreateParameter("@McdFopDiff",ftFloat,pdInput,12,m_McdFopDiff);
        m_StoredProc->Parameters->CreateParameter("@McdIoyCost",ftFloat,pdInput,12,m_McdIoyCost);
        m_StoredProc->Parameters->CreateParameter("@McdIoyDiff",ftFloat,pdInput,12,m_McdIoyDiff);
        m_StoredProc->Parameters->CreateParameter("@McdSoyCost",ftFloat,pdInput,12,m_McdSoyCost);
        m_StoredProc->Parameters->CreateParameter("@McdSoyDiff",ftFloat,pdInput,12,m_McdSoyDiff);
        m_StoredProc->Parameters->CreateParameter("@McdRdc",ftFloat,pdInput,12,m_McdRdc);

       m_StoredProc->ExecProc();
       m_StoredProc->Close();
   }
  TsdMcd *p=new TsdMcd();
  if(CurStatus==2)
    {
     SetActionID(1);
     p->Assign(this);
     AddRecord((void *)p,p->McdFmonth+p->McdGoods);
     }
  else
    {
     SetActionID(1);
     p->Assign(this);
     ChangeRecord((void *)p,p->McdFmonth+p->McdGoods,this->b_McdFmonth+this->b_McdGoods);
    }
}
//---------------------------------------------------------------------------
void TsdMcd::Delete()
{
    if(CurStatus!=1)
        throw Exception("当前状态不能进行删除操作!");
    if(m_McdGoods.IsEmpty()==true)
        throw Exception("当前没有记录可以删除!");
    m_StoredProc->Close();
    m_StoredProc->ProcedureName="sdMcd_Delete";
    m_StoredProc->Parameters->Clear();
    m_StoredProc->Parameters->CreateParameter("@W_McdFmonth",ftString,pdInput,6,b_McdFmonth);
    m_StoredProc->Parameters->CreateParameter("@W_McdGoods",ftString,pdInput,18,b_McdGoods);
    m_StoredProc->ExecProc();
    m_StoredProc->Close();
    DeleteRecord(this->b_McdFmonth+this->b_McdGoods);
}
//---------------------------------------------------------------------------
void TsdMcd::Assign(TsdMcd *p)
{
    this->SetActionID(p->CurStatus);
    this->m_McdFmonth=p->m_McdFmonth;
    this->m_McdGoods=p->m_McdGoods;
    this->m_McdBopCost=p->m_McdBopCost;
    this->m_McdBopDiff=p->m_McdBopDiff;
    this->m_McdIopCost=p->m_McdIopCost;
    this->m_McdIopDiff=p->m_McdIopDiff;
    this->m_McdSopCost=p->m_McdSopCost;
    this->m_McdSopDiff=p->m_McdSopDiff;
    this->m_McdNopCost=p->m_McdNopCost;
    this->m_McdNopDiff=p->m_McdNopDiff;
    this->m_McdFopCost=p->m_McdFopCost;
    this->m_McdFopDiff=p->m_McdFopDiff;
    this->m_McdIoyCost=p->m_McdIoyCost;
    this->m_McdIoyDiff=p->m_McdIoyDiff;
    this->m_McdSoyCost=p->m_McdSoyCost;
    this->m_McdSoyDiff=p->m_McdSoyDiff;
    this->m_McdRdc=p->m_McdRdc;
    this->BackupValue();
}
//---------------------------------------------------------------------------
void TsdMcd::AssignValue()
{
    TsdMcd *p=(TsdMcd *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------
int TsdMcd::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();
            TsdMcd *p=new TsdMcd();
            SetActionID(1);
            p->Assign(this);
            AddRecord((void *)p,p->McdFmonth+p->McdGoods);
            m_Query->Next();
        }
        MoveFirst();
    }
    m_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TsdMcd::Find(AnsiString WhereStr)
{
    AnsiString m_SqlStr;
    if(WhereStr.IsEmpty()==true)
        throw Exception("查找表达式不能为空");
    m_SqlStr="select * from sdMcd 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;
    }
}