cmdoc.cpp

科思ERP部分源码及控件

{
       l_McdSoyCost=value;
}
void __fastcall TKSMcd:: SetMcdSoyDiff(double  value)
{
       l_McdSoyDiff=value;
}
void __fastcall TKSMcd:: SetMcdRdc(double  value)
{
       l_McdRdc=value;
}
//---------------------------------------------------------------------------
AnsiString TKSMcd::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 TKSMcd::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("当前字段未定义可赋值");
      }
}
//---------------------------------------------------------------------------
TKSMcd::TKSMcd(TDataComm *DC)
                :TKSStandard(DC)
{
    try
    {
        EmptyValue(0);
        EmptyValue(1);
        QueryString="SELECT * FROM sdMcd";
        FilterString="";
        OrderString="McdFmonth,McdGoods";
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TKSMcd::TKSMcd()
       :TKSStandard()
{
    try
    {
        EmptyValue(0);
        EmptyValue(1);
        QueryString="SELECT * FROM sdMcd";
        FilterString="";
        OrderString="McdFmonth,McdGoods";
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
//---------------------------------------------------------------------------
TKSMcd::~TKSMcd()
{
  try{
     }
  catch(...)
    {
     throw Exception("析构函数出错");
    }
}
//---------------------------------------------------------------------------
void TKSMcd::BackupValue()
{
      b_McdFmonth=l_McdFmonth;
      b_McdGoods=l_McdGoods;
      b_McdBopCost=l_McdBopCost;
      b_McdBopDiff=l_McdBopDiff;
      b_McdIopCost=l_McdIopCost;
      b_McdIopDiff=l_McdIopDiff;
      b_McdSopCost=l_McdSopCost;
      b_McdSopDiff=l_McdSopDiff;
      b_McdNopCost=l_McdNopCost;
      b_McdNopDiff=l_McdNopDiff;
      b_McdFopCost=l_McdFopCost;
      b_McdFopDiff=l_McdFopDiff;
      b_McdIoyCost=l_McdIoyCost;
      b_McdIoyDiff=l_McdIoyDiff;
      b_McdSoyCost=l_McdSoyCost;
      b_McdSoyDiff=l_McdSoyDiff;
      b_McdRdc=l_McdRdc;
}
//---------------------------------------------------------------------------
void TKSMcd::RestoreValue()
{
      l_McdFmonth=b_McdFmonth;
      l_McdGoods=b_McdGoods;
      l_McdBopCost=b_McdBopCost;
      l_McdBopDiff=b_McdBopDiff;
      l_McdIopCost=b_McdIopCost;
      l_McdIopDiff=b_McdIopDiff;
      l_McdSopCost=b_McdSopCost;
      l_McdSopDiff=b_McdSopDiff;
      l_McdNopCost=b_McdNopCost;
      l_McdNopDiff=b_McdNopDiff;
      l_McdFopCost=b_McdFopCost;
      l_McdFopDiff=b_McdFopDiff;
      l_McdIoyCost=b_McdIoyCost;
      l_McdIoyDiff=b_McdIoyDiff;
      l_McdSoyCost=b_McdSoyCost;
      l_McdSoyDiff=b_McdSoyDiff;
      l_McdRdc=b_McdRdc;
}
//---------------------------------------------------------------------------
void TKSMcd::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
        l_McdFmonth="";
        l_McdGoods="";
        l_McdBopCost=0;
        l_McdBopDiff=0;
        l_McdIopCost=0;
        l_McdIopDiff=0;
        l_McdSopCost=0;
        l_McdSopDiff=0;
        l_McdNopCost=0;
        l_McdNopDiff=0;
        l_McdFopCost=0;
        l_McdFopDiff=0;
        l_McdIoyCost=0;
        l_McdIoyDiff=0;
        l_McdSoyCost=0;
        l_McdSoyDiff=0;
        l_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 TKSMcd::BatchLetValue()
{
    l_McdFmonth=l_Query->FieldValues["McdFmonth"];
    l_McdGoods=l_Query->FieldValues["McdGoods"];
    l_McdBopCost=l_Query->FieldValues["McdBopCost"];
    l_McdBopDiff=l_Query->FieldValues["McdBopDiff"];
    l_McdIopCost=l_Query->FieldValues["McdIopCost"];
    l_McdIopDiff=l_Query->FieldValues["McdIopDiff"];
    l_McdSopCost=l_Query->FieldValues["McdSopCost"];
    l_McdSopDiff=l_Query->FieldValues["McdSopDiff"];
    l_McdNopCost=l_Query->FieldValues["McdNopCost"];
    l_McdNopDiff=l_Query->FieldValues["McdNopDiff"];
    l_McdFopCost=l_Query->FieldValues["McdFopCost"];
    l_McdFopDiff=l_Query->FieldValues["McdFopDiff"];
    l_McdIoyCost=l_Query->FieldValues["McdIoyCost"];
    l_McdIoyDiff=l_Query->FieldValues["McdIoyDiff"];
    l_McdSoyCost=l_Query->FieldValues["McdSoyCost"];
    l_McdSoyDiff=l_Query->FieldValues["McdSoyDiff"];
    l_McdRdc=l_Query->FieldValues["McdRdc"];
    BackupValue();
}
//---------------------------------------------------------------------------
void TKSMcd::Update()
{
    if(CurStatus==0||CurStatus==1)
        throw Exception("当前不是编辑状态,不能进行存盘操作!");
    if(l_McdGoods.IsEmpty()==true)
        throw Exception("物料编码不能为空!");
    l_StoredProc->Close();
    if(CurStatus==2||CurStatus==4)
      {
        l_StoredProc->ProcedureName="sdMcd_Insert";
        l_StoredProc->Parameters->Clear();
        l_StoredProc->Parameters->CreateParameter("@McdFmonth",ftString,pdInput,6,l_McdFmonth);
        l_StoredProc->Parameters->CreateParameter("@McdGoods",ftString,pdInput,18,l_McdGoods);
        l_StoredProc->Parameters->CreateParameter("@McdBopCost",ftFloat,pdInput,12,l_McdBopCost);
        l_StoredProc->Parameters->CreateParameter("@McdBopDiff",ftFloat,pdInput,12,l_McdBopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdIopCost",ftFloat,pdInput,12,l_McdIopCost);
        l_StoredProc->Parameters->CreateParameter("@McdIopDiff",ftFloat,pdInput,12,l_McdIopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdSopCost",ftFloat,pdInput,12,l_McdSopCost);
        l_StoredProc->Parameters->CreateParameter("@McdSopDiff",ftFloat,pdInput,12,l_McdSopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdNopCost",ftFloat,pdInput,12,l_McdNopCost);
        l_StoredProc->Parameters->CreateParameter("@McdNopDiff",ftFloat,pdInput,12,l_McdNopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdFopCost",ftFloat,pdInput,12,l_McdFopCost);
        l_StoredProc->Parameters->CreateParameter("@McdFopDiff",ftFloat,pdInput,12,l_McdFopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdIoyCost",ftFloat,pdInput,12,l_McdIoyCost);
        l_StoredProc->Parameters->CreateParameter("@McdIoyDiff",ftFloat,pdInput,12,l_McdIoyDiff);
        l_StoredProc->Parameters->CreateParameter("@McdSoyCost",ftFloat,pdInput,12,l_McdSoyCost);
        l_StoredProc->Parameters->CreateParameter("@McdSoyDiff",ftFloat,pdInput,12,l_McdSoyDiff);
        l_StoredProc->Parameters->CreateParameter("@McdRdc",ftFloat,pdInput,12,l_McdRdc);

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

        l_StoredProc->Parameters->CreateParameter("@W_McdFmonth",ftString,pdInput,6,b_McdFmonth);
        l_StoredProc->Parameters->CreateParameter("@W_McdGoods",ftString,pdInput,18,b_McdGoods);
        l_StoredProc->Parameters->CreateParameter("@McdFmonth",ftString,pdInput,6,l_McdFmonth);
        l_StoredProc->Parameters->CreateParameter("@McdGoods",ftString,pdInput,18,l_McdGoods);
        l_StoredProc->Parameters->CreateParameter("@McdBopCost",ftFloat,pdInput,12,l_McdBopCost);
        l_StoredProc->Parameters->CreateParameter("@McdBopDiff",ftFloat,pdInput,12,l_McdBopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdIopCost",ftFloat,pdInput,12,l_McdIopCost);
        l_StoredProc->Parameters->CreateParameter("@McdIopDiff",ftFloat,pdInput,12,l_McdIopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdSopCost",ftFloat,pdInput,12,l_McdSopCost);
        l_StoredProc->Parameters->CreateParameter("@McdSopDiff",ftFloat,pdInput,12,l_McdSopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdNopCost",ftFloat,pdInput,12,l_McdNopCost);
        l_StoredProc->Parameters->CreateParameter("@McdNopDiff",ftFloat,pdInput,12,l_McdNopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdFopCost",ftFloat,pdInput,12,l_McdFopCost);
        l_StoredProc->Parameters->CreateParameter("@McdFopDiff",ftFloat,pdInput,12,l_McdFopDiff);
        l_StoredProc->Parameters->CreateParameter("@McdIoyCost",ftFloat,pdInput,12,l_McdIoyCost);
        l_StoredProc->Parameters->CreateParameter("@McdIoyDiff",ftFloat,pdInput,12,l_McdIoyDiff);
        l_StoredProc->Parameters->CreateParameter("@McdSoyCost",ftFloat,pdInput,12,l_McdSoyCost);
        l_StoredProc->Parameters->CreateParameter("@McdSoyDiff",ftFloat,pdInput,12,l_McdSoyDiff);
        l_StoredProc->Parameters->CreateParameter("@McdRdc",ftFloat,pdInput,12,l_McdRdc);

       l_StoredProc->ExecProc();
       l_StoredProc->Close();
   }
  TKSMcd *p=new TKSMcd();
  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 TKSMcd::Delete()
{
    if(CurStatus!=1)
        throw Exception("当前状态不能进行删除操作!");
    if(l_McdGoods.IsEmpty()==true)
        throw Exception("当前没有记录可以删除!");
    l_StoredProc->Close();
    l_StoredProc->ProcedureName="sdMcd_Delete";
    l_StoredProc->Parameters->Clear();
    l_StoredProc->Parameters->CreateParameter("@W_McdFmonth",ftString,pdInput,6,b_McdFmonth);
    l_StoredProc->Parameters->CreateParameter("@W_McdGoods",ftString,pdInput,18,b_McdGoods);
    l_StoredProc->ExecProc();
    l_StoredProc->Close();
    DeleteRecord(this->b_McdFmonth+this->b_McdGoods);
}
//---------------------------------------------------------------------------
void TKSMcd::Assign(TKSMcd *p)
{
    this->SetActionID(p->CurStatus);
    this->l_McdFmonth=p->l_McdFmonth;
    this->l_McdGoods=p->l_McdGoods;
    this->l_McdBopCost=p->l_McdBopCost;
    this->l_McdBopDiff=p->l_McdBopDiff;
    this->l_McdIopCost=p->l_McdIopCost;
    this->l_McdIopDiff=p->l_McdIopDiff;
    this->l_McdSopCost=p->l_McdSopCost;
    this->l_McdSopDiff=p->l_McdSopDiff;
    this->l_McdNopCost=p->l_McdNopCost;
    this->l_McdNopDiff=p->l_McdNopDiff;
    this->l_McdFopCost=p->l_McdFopCost;
    this->l_McdFopDiff=p->l_McdFopDiff;
    this->l_McdIoyCost=p->l_McdIoyCost;
    this->l_McdIoyDiff=p->l_McdIoyDiff;
    this->l_McdSoyCost=p->l_McdSoyCost;
    this->l_McdSoyDiff=p->l_McdSoyDiff;
    this->l_McdRdc=p->l_McdRdc;
    this->BackupValue();
}
//---------------------------------------------------------------------------
void TKSMcd::AssignValue()
{
    TKSMcd *p=(TKSMcd *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------
int TKSMcd::Query()
{
    AnsiString l_SqlStr;
    l_SqlStr=QueryString;
    if(FilterString.IsEmpty()==false)
        l_SqlStr=l_SqlStr+" where  "+FilterString;
    if(OrderString.IsEmpty()==false)
        l_SqlStr=l_SqlStr+" Order by "+OrderString;
    l_Query->Close();
    l_Query->SQL->Clear();
    l_Query->SQL->Add(l_SqlStr);
    l_Query->Open();
    ClearRecord();
    if(l_Query->RecordCount>0)
    {
        l_Query->First();
        while(!l_Query->Eof)
        {
            BatchLetValue();
            TKSMcd *p=new TKSMcd();
            SetActionID(1);
            p->Assign(this);
            AddRecord((void *)p,p->McdFmonth+p->McdGoods);
            l_Query->Next();
        }
        MoveFirst();
    }
    l_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TKSMcd::Find(AnsiString WhereStr)
{
    AnsiString l_SqlStr;
    if(WhereStr.IsEmpty()==true)
        throw Exception("查找表达式不能为空");
    l_SqlStr="select * from sdMcd where  "+WhereStr;
    l_Query->Close();
    l_Query->SQL->Clear();
    l_Query->SQL->Add(l_SqlStr);
    l_Query->Open();
    if(l_Query->RecordCount!=1)
    {
        l_Query->Close();
        return false;
    }
    else
    {
        BatchLetValue();
        l_Query->Close();
        return true;
    }
}