smdoc.cpp

邮 电 公 司 erp源码

        m_Query->Close();
        throw Exception("该客户的币种为:'"+value+"'已有定义");
      }
      m_Query->Close();
    }
    m_SsdCurrency = value;
}

//---------------------------------------------------------------------------
void __fastcall TsdSsd::SetSsdBankName(AnsiString value)
{
   if(value.IsEmpty())
   throw Exception("银行名称不能为空");
   m_SsdBankName =   value;
}
//---------------------------------------------------------------------------
void __fastcall TsdSsd::SetSsdBankNo(AnsiString value)
{
   if(value.IsEmpty())
   throw Exception("银行帐号不能为空");
    m_SsdBankNo   =   value;
}
void __fastcall TsdSsd:: SetSsdPrimary(int    value)
{
       if(value!=m_SsdPrimary)
       {
        if(value==1)
          {
            m_Query->Close();
            m_Query->SQL->Clear();
            m_Query->SQL->Add("Select * from sdSsd where SsdClient='"+m_SsdClient+"' and SsdPrimary=1 and SsdCurrency<>'"+m_SsdCurrency+"'");
            m_Query->Open();
            if(m_Query->RecordCount>0)
            {
              m_Query->Close();
              throw Exception("该客户已有默认主币种");
            }
            m_Query->Close();
          }
        m_SsdPrimary=value;
       }
}
//---------------------------------------------------------------------------
AnsiString TsdSsd::GetFieldValue(euSsd sdFieldName)
{
    switch(sdFieldName)
    {
      case fiSsdClient:
           return SsdClient;
      case fiSsdCurrency:
           return SsdCurrency;
      case fiSsdBankNo:
           return SsdBankNo;
      case fiSsdBankName:
           return SsdBankName;
      case fiSsdPrimary:
           return SsdPrimary;
      default:
         throw Exception("当前字段未定义可取值");
     }
}
//---------------------------------------------------------------------------
void TsdSsd::SetFieldValue(euSsd sdFieldName, AnsiString value)
{
    value=Trim(value);
    switch(sdFieldName)
     {
    case fiSsdClient:
         SsdClient=value;
          break;
    case fiSsdCurrency:
         SsdCurrency=value;
          break;
    case fiSsdBankNo:  
         SsdBankNo=value;
          break;
    case fiSsdBankName:  
         SsdBankName=value;
          break;
    case fiSsdPrimary:  
         SsdPrimary=value.ToInt();
          break;
      default:
         throw Exception("当前字段未定义可赋值");
      }
}
//---------------------------------------------------------------------------
TsdSsd::TsdSsd(TDataComm *DC)
                :TsdStandard(DC)
{
    try
    {
        QueryString="SELECT * FROM sdSsd";
        FilterString="";
        OrderString="SsdClient,SsdCurrency";
        EmptyValue(0);
        EmptyValue(1);
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}
TsdSsd::TsdSsd()
          :TsdStandard()
{
    try
    {
        QueryString="SELECT * FROM sdSsd";
        FilterString="";
        OrderString="SsdClient,SsdCurrency";
        EmptyValue(0);
        EmptyValue(1);
    }
    catch(Exception &e)
    {
        ShowMessage(e.Message);
    }
}

//---------------------------------------------------------------------------
TsdSsd::~TsdSsd()
{
  try{
     }
  catch(...)
    {
     throw Exception("析构函数出错");
    }
}
//---------------------------------------------------------------------------
void TsdSsd::BackupValue()
{
      b_SsdClient=m_SsdClient;
      b_SsdCurrency=m_SsdCurrency;
      b_SsdBankNo=m_SsdBankNo;
      b_SsdBankName=m_SsdBankName;
      b_SsdPrimary=m_SsdPrimary;
}
//---------------------------------------------------------------------------
void TsdSsd::RestoreValue()
{
      m_SsdClient=b_SsdClient;
      m_SsdCurrency=b_SsdCurrency;
      m_SsdBankNo=b_SsdBankNo;
      m_SsdBankName=b_SsdBankName;
      m_SsdPrimary=b_SsdPrimary;
}
//---------------------------------------------------------------------------
void TsdSsd::EmptyValue(int Index)
{
   switch(Index)
   {
    case 0:
        m_SsdClient="";
        m_SsdCurrency="";
        m_SsdBankNo="";
        m_SsdBankName="";
        m_SsdPrimary=0;
    break;
    case 1:
        b_SsdClient="";
        b_SsdCurrency="";
        b_SsdBankNo="";
        b_SsdBankName="";
        b_SsdPrimary=0;
      break;
     }
}
//---------------------------------------------------------------------------
void TsdSsd::BatchLetValue()
{
    m_SsdClient=m_Query->FieldValues["SsdClient"];
    m_SsdCurrency=m_Query->FieldValues["SsdCurrency"];
    m_SsdBankNo=m_Query->FieldValues["SsdBankNo"];
    m_SsdBankName=m_Query->FieldValues["SsdBankName"];
    m_SsdPrimary=m_Query->FieldValues["SsdPrimary"];
    BackupValue();
}
//---------------------------------------------------------------------------
void TsdSsd::Update()
{
    if(CurStatus==0||CurStatus==1)
        throw Exception("当前不是编辑状态,不能进行存盘操作!");
    if(m_SsdCurrency.IsEmpty()==true)
        throw Exception("币种不能为空!");
    if(m_SsdClient.IsEmpty()==true)
        throw Exception("客户代码不能为空!");
    m_StoredProc->Close();
    if(CurStatus==2||CurStatus==4)
      {
        m_StoredProc->ProcedureName="sdSsd_Insert";
        m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@SsdClient",ftString,pdInput,18,m_SsdClient);
        m_StoredProc->Parameters->CreateParameter("@SsdCurrency",ftString,pdInput,18,m_SsdCurrency);
        m_StoredProc->Parameters->CreateParameter("@SsdBankNo",ftString,pdInput,30,m_SsdBankNo);
        m_StoredProc->Parameters->CreateParameter("@SsdBankName",ftString,pdInput,20,m_SsdBankName);
        m_StoredProc->Parameters->CreateParameter("@SsdPrimary",ftInteger,pdInput,1,m_SsdPrimary);
 
        m_StoredProc->ExecProc();


   }
  else
    {
        m_StoredProc->ProcedureName="sdSsd_Update";
        m_StoredProc->Parameters->Clear();

        m_StoredProc->Parameters->CreateParameter("@W_SsdClient",ftString,pdInput,18,b_SsdClient);
        m_StoredProc->Parameters->CreateParameter("@W_SsdCurrency",ftString,pdInput,18,b_SsdCurrency);
        m_StoredProc->Parameters->CreateParameter("@SsdCurrency",ftString,pdInput,18,m_SsdCurrency);
        m_StoredProc->Parameters->CreateParameter("@SsdBankNo",ftString,pdInput,30,m_SsdBankNo);
        m_StoredProc->Parameters->CreateParameter("@SsdBankName",ftString,pdInput,20,m_SsdBankName);
        m_StoredProc->Parameters->CreateParameter("@SsdPrimary",ftInteger,pdInput,1,m_SsdPrimary);
 
       m_StoredProc->ExecProc();


   }
    m_StoredProc->Close();
  TsdSsd *p=new TsdSsd();
  if(CurStatus==2)
    {
     SetActionID(1);
     p->Assign(this);
     AddRecord((void *)p,p->SsdClient+p->SsdCurrency);
     }
  else
    {
     SetActionID(1);
     p->Assign(this);
     ChangeRecord((void *)p,p->SsdClient+p->SsdCurrency,this->b_SsdClient+this->b_SsdCurrency);
    }
}
//---------------------------------------------------------------------------
void TsdSsd::Delete()
{
    if(CurStatus!=1)
        throw Exception("当前状态不能进行删除操作!");
    if(m_SsdCurrency.IsEmpty()||m_SsdClient.IsEmpty())
        throw Exception("当前没有记录可以删除!");
    m_StoredProc->Close();
    m_StoredProc->ProcedureName="sdSsd_Delete";
    m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@W_SsdClient",ftString,pdInput,18,b_SsdClient);
        m_StoredProc->Parameters->CreateParameter("@W_SsdCurrency",ftString,pdInput,18,b_SsdCurrency);
    m_StoredProc->ExecProc();
    m_StoredProc->Close();
    DeleteRecord(this->b_SsdClient+this->b_SsdCurrency);
}
//---------------------------------------------------------------------------
void TsdSsd::Assign(TsdSsd *p)
{
    this->SetActionID(p->CurStatus);
    this->m_SsdClient=p->m_SsdClient;
    this->m_SsdCurrency=p->m_SsdCurrency;
    this->m_SsdBankNo=p->m_SsdBankNo;
    this->m_SsdBankName=p->m_SsdBankName;
    this->m_SsdPrimary=p->m_SsdPrimary;
    this->BackupValue();
}
//---------------------------------------------------------------------------
void TsdSsd::AssignValue()
{
    TsdSsd *p=(TsdSsd *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------
int TsdSsd::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();
            TsdSsd *p=new TsdSsd();
            SetActionID(1);
            p->Assign(this);
            AddRecord((void *)p,p->SsdClient+p->SsdCurrency);
            m_Query->Next();
        }
        MoveFirst();
    }
    m_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TsdSsd::Find(AnsiString WhereStr)
{
    AnsiString m_SqlStr;
    if(WhereStr.IsEmpty()==true)
        throw Exception("查找表达式不能为空");
    m_SqlStr="select * from sdSsd 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;
    }
}

//====================================================================
//                           (TsdSgd)客户物品资料
//===================================================================

void __fastcall TsdSgd::SetSgdClientCode(AnsiString value)
{
    if(value.IsEmpty() )
      throw Exception("客户编码不能为空!");
    if(value.Length()>18)
      throw Exception("客户编码长度不能大于18");
    if (value!=m_SgdClientCode)
    {
      m_Query->Close();
      m_Query->SQL->Clear();
      m_Query->SQL->Add("SELECT ClientCODE FROM SDClient WHERE ClientCODE='" +value+"'");
      m_Query->Open();
      if(m_Query->RecordCount<=0)
      {
        m_Query->Close();
        throw Exception("客户编码'"+value+"'不存在");
      }
      m_Query->Close();
    }
    m_SgdClientCode = value;
}

//---------------------------------------------------------------------------
void __fastcall TsdSgd::SetSgdCode(AnsiString value)
{
    if (value.IsEmpty() )
       throw Exception("客户货物编码不能为空!");
    if(value.Length()>18)
      throw Exception("客户货物编码长度不能大于18");
    m_SgdCode = value;
}
//---------------------------------------------------------------------------
void __fastcall TsdSgd::SetSgdName(AnsiString value)
{
    if(value.IsEmpty())
      throw Exception("客户货物名称不能为空");
    if(value.Length()>20)
      throw Exception("客户货物名称长度不能大于20");
    m_SgdName = value;
}
//---------------------------------------------------------------------------
void __fastcall TsdSgd::SetSgdGoodsCode(AnsiString value)
{
    if(value.IsEmpty())
      throw Exception("物料编码不能为空");
    if(value.Length()>18)
      throw Exception("物料编码长度不能大于18");
    if(value!=m_SgdGoodsCode)
    {
      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_Query->SQL->Clear();
      m_Query->SQL->Add("Select SgdGoodsCode from SdSGd where SgdgoodsCode='"+value+"' and SgdClientCode='"+m_SgdClientCode+"'");
      m_Query->Open();
      if(m_Query->RecordCount>0)
      {
        m_Query->Close();
        throw Exception("物料编码:'"+value+"'已存在");
      }
      m_Query->Close();
    }
    m_SgdGoodsCode = value;
}

//---------------------------------------------------------------------------
TsdSgd::TsdSgd(TDataComm *DC)
            :TsdStandard(DC)
{
  try
  {
    QueryString="SELECT * FROM SDSgd";
    FilterString="";
    OrderString="SgdClientCode,SgdCODE";
        EmptyValue(0);
        EmptyValue(1);

  }
  catch(Exception &e)
  {
    ShowMessage(e.Message);
  }
}
TsdSgd::TsdSgd()
        :TsdStandard()
{
  try
  {
    QueryString="SELECT * FROM SDSgd";