plndoc.cpp

速达开源ERP系统

//---------------------------------------------------------------------------
#include <vcl.h>
#pragma hdrstop
#define _YW_SDERP_DLL
#include "Plndoc.h"

//---------------------------------------------------------------------------
#pragma package(smart_init)

//====================================================================
//                           (TsdPlanner)计划员资料
//===================================================================

void __fastcall TsdPlanner::SetPlannerCode(AnsiString value)
{
    if (value.IsEmpty() )
       throw Exception("计划员编码不能为空!");
    if(value.Length()>18)
      throw Exception("计划员编码长度不能大于18");
    if (value!=m_PlannerCode)
    {
        m_Query->Close();
        m_Query->SQL->Clear();
        m_Query->SQL->Add("SELECT PlannerCode FROM SDPlanner WHERE PlannerCODE='" +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 usercode from sduser where usercode='"+value+"'");
        m_Query->Open();
        if(m_Query->RecordCount<=0)
        {
          m_Query->Close();
          throw Exception("操作员:'"+value+"'未定义");
        }
        m_Query->Close();
    }
    m_PlannerCode = value;
}
//---------------------------------------------------------------------------
void __fastcall TsdPlanner::SetPlannerCheck(int value)
{
    if(value!=0 && value!=1)
      throw Exception("审核标志只能取值0-无审核权限1-有审核权限");
    m_PlannerCheck = value;
}
//---------------------------------------------------------------------------
void __fastcall TsdPlanner::SetPlannerStop(int value)
{
    if(value!=0 && value!=1)
      throw Exception("中止权限只能取值0-无中止权限1-有中止权限");
    m_PlannerStop = value;
}
//---------------------------------------------------------------------------
void __fastcall TsdPlanner::SetPlannerCancel(int value)
{
    if(value!=0 && value!=1)
      throw Exception("取消权限只能取值 0-无取消权限1-有取消权限");
    m_PlannerCancel = value;
}
//---------------------------------------------------------------------------
void __fastcall TsdPlanner::SetPlannerClose(int value)
{
    if(value!=0 && value!=1)
      throw Exception("结清权限只能取值 0-无结清权限1-有结清权限");
    m_PlannerClose = value;
}
//---------------------------------------------------------------------------
void __fastcall TsdPlanner::SetPlannerTel(AnsiString value)
{
  if(value.Length()>20)
    throw Exception("电话长度不能大于20");
  m_PlannerTel=value;
}

void __fastcall TsdPlanner::SetPlannerBeepPage(AnsiString value)
{
  if(value.Length()>20)
    throw Exception("呼机长度不能大于20");
  m_PlannerBeepPage=value;
}


//---------------------------------------------------------------------------
TsdPlanner::TsdPlanner(TDataComm *DC)
                :TsdStandard(DC)
{
    try
    {
        QueryString="SELECT * FROM SDPlanner";
        FilterString="";
        OrderString="PlannerCODE";
    }
    catch(Exception &e)
    {
        throw Exception("构造函数出错");
    }
}
//---------------------------------------------------------------------------
TsdPlanner::TsdPlanner()
                :TsdStandard()
{
    try
    {
        QueryString="SELECT * FROM SDPlanner";
        FilterString="";
        OrderString="PlannerCODE";
    }
    catch(Exception &e)
    {
        throw Exception("构造函数出错");
    }
}
//---------------------------------------------------------------------------
AnsiString TsdPlanner::GetFieldValue(euPlanner sdFieldName)
{
    switch(sdFieldName)
    {
      case fiPlannerCode:
        return PlannerCode;
      case fiPlannerCheck:
        return AnsiString(PlannerCheck);
      case fiPlannerStop:
        return AnsiString(PlannerStop);
      case fiPlannerCancel:
        return AnsiString(PlannerCancel);
      case fiPlannerClose:
        return AnsiString(PlannerClose);
      case fiPlannerTel:
        return PlannerTel;
      case fiPlannerBeepPage:
        return PlannerBeepPage;
      default:
        return NULL;
    }
}
//---------------------------------------------------------------------------
void TsdPlanner::SetFieldValue(euPlanner sdFieldName, AnsiString Value)
{
    switch(sdFieldName)
    {
    case fiPlannerCode:
        PlannerCode   =   Value;
        break;
    case fiPlannerCheck:
        PlannerCheck  =   Value.ToInt();
        break;
    case fiPlannerStop:
        PlannerStop   =   Value.ToInt();
        break;
    case fiPlannerCancel:
        PlannerCancel =   Value.ToInt();
        break;
    case fiPlannerClose:
        PlannerClose =   Value.ToInt();
        break;
    case fiPlannerTel:
        PlannerTel=Value;
        break;
    case fiPlannerBeepPage:
        PlannerBeepPage=Value;
        break;
    }
}
//---------------------------------------------------------------------------
void TsdPlanner::Update()
{
    if(CurStatus==0||CurStatus==1)
        throw Exception("当前不是编辑状态,不能进行存盘操作!");
    if(m_PlannerCode.IsEmpty()==true)
        throw Exception("计划员编码不能为空!");
    m_StoredProc->Close();
    if(CurStatus==2||CurStatus==4)
    {
        m_StoredProc->ProcedureName="SDPlanner_Insert";
        m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@PlannerCode",ftString,pdInput,18,m_PlannerCode);
        m_StoredProc->Parameters->CreateParameter("@PlannerCheck",ftInteger,pdInput,10,m_PlannerCheck);
        m_StoredProc->Parameters->CreateParameter("@PlannerStop",ftInteger,pdInput,10,m_PlannerStop);
        m_StoredProc->Parameters->CreateParameter("@PlannerCancel",ftInteger,pdInput,10,m_PlannerCancel);
        m_StoredProc->Parameters->CreateParameter("@PlannerClose",ftInteger,pdInput,10,m_PlannerClose);
        m_StoredProc->Parameters->CreateParameter("@PlannerTel",ftString,pdInput,20,m_PlannerTel);
        m_StoredProc->Parameters->CreateParameter("@PlannerBeepPage",ftString,pdInput,20,m_PlannerBeepPage);

        m_StoredProc->ExecProc();
        m_StoredProc->Close();
    }
    else
    {
        m_StoredProc->ProcedureName="SDPlanner_Update";
        m_StoredProc->Parameters->Clear();
        m_StoredProc->Parameters->CreateParameter("@W_PlannerCode",ftString,pdInput,18,b_PlannerCode);
        m_StoredProc->Parameters->CreateParameter("@PlannerCode",ftString,pdInput,18,m_PlannerCode);
        m_StoredProc->Parameters->CreateParameter("@PlannerCheck",ftInteger,pdInput,10,m_PlannerCheck);
        m_StoredProc->Parameters->CreateParameter("@PlannerStop",ftInteger,pdInput,10,m_PlannerStop);
        m_StoredProc->Parameters->CreateParameter("@PlannerCancel",ftInteger,pdInput,10,m_PlannerCancel);
        m_StoredProc->Parameters->CreateParameter("@PlannerClose",ftInteger,pdInput,10,m_PlannerClose);
        m_StoredProc->Parameters->CreateParameter("@PlannerTel",ftString,pdInput,20,m_PlannerTel);
        m_StoredProc->Parameters->CreateParameter("@PlannerBeepPage",ftString,pdInput,20,m_PlannerBeepPage);

        m_StoredProc->ExecProc();
        m_StoredProc->Close();
    }
    TsdPlanner *p=new TsdPlanner();
    if(CurStatus==2)
    {
      SetActionID(1);
      p->Assign(this);
      AddRecord((void *)p,p->PlannerCode);
    }
    else
    {
      SetActionID(1);
      p->Assign(this);
      ChangeRecord((void *)p,p->PlannerCode,this->b_PlannerCode);
    }
}


//---------------------------------------------------------------------------
void TsdPlanner::Delete()
{
    if(CurStatus!=1)
        throw Exception("当前状态不能进行删除操作!");
    if(m_PlannerCode.IsEmpty()==true)
        throw Exception("当前没有记录可以删除!");
    m_StoredProc->ProcedureName="sdPlanner_Delete";
    m_StoredProc->Parameters->Clear();
    m_StoredProc->Parameters->CreateParameter("@W_PlannerCode",ftString,pdInput,18,b_PlannerCode);
    m_StoredProc->ExecProc();
    m_StoredProc->Close();
    DeleteRecord(this->b_PlannerCode);
}
//---------------------------------------------------------------------------
void TsdPlanner::BackupValue()
{
    b_PlannerCode     =   m_PlannerCode;
    b_PlannerCheck    =   m_PlannerCheck;
    b_PlannerStop     =   m_PlannerStop;
    b_PlannerCancel   =   m_PlannerCancel;
    b_PlannerClose   =   m_PlannerClose;
    b_PlannerTel=m_PlannerTel;
    b_PlannerBeepPage=m_PlannerBeepPage;
}
//---------------------------------------------------------------------------
void TsdPlanner::RestoreValue()
{
    m_PlannerCode     =   b_PlannerCode;
    m_PlannerCheck    =   b_PlannerCheck;
    m_PlannerStop     =   b_PlannerStop;
    m_PlannerCancel   =   b_PlannerCancel;
    m_PlannerClose   =   b_PlannerClose;
    m_PlannerTel=b_PlannerTel;
    m_PlannerBeepPage=b_PlannerBeepPage;
}
//---------------------------------------------------------------------------
void TsdPlanner::EmptyValue(int Index)
{
    switch(Index)
    {
    case 0:
        m_PlannerCode     =   "";
        m_PlannerCheck    =   0;
        m_PlannerStop     =   0;
        m_PlannerCancel   =   0;
        m_PlannerClose   =   0;
        m_PlannerTel="";
        m_PlannerBeepPage="";
        break;
    case 1:
        b_PlannerCode     =   "";
        b_PlannerCheck    =   0;
        b_PlannerStop     =   0;
        b_PlannerCancel   =   0;
        b_PlannerClose   =   0;
        b_PlannerTel="";
        b_PlannerBeepPage="";
        break;
    }
}
//---------------------------------------------------------------------------
void TsdPlanner::BatchLetValue()
{
    m_PlannerCode     =   m_Query->FieldValues["PlannerCode"];
    m_PlannerCheck    =   m_Query->FieldValues["PlannerCheck"];
    m_PlannerStop     =   m_Query->FieldValues["PlannerStop"];
    m_PlannerCancel   =   m_Query->FieldValues["PlannerCancel"];
    m_PlannerClose   =   m_Query->FieldValues["PlannerClose"];
    m_PlannerTel=m_Query->FieldValues["PlannerTel"];
    m_PlannerBeepPage=m_Query->FieldValues["PlannerBeepPage"];

    BackupValue();
}
//---------------------------------------------------------------------------
void TsdPlanner::Assign(TsdPlanner *p)
{
    this->SetActionID(p->CurStatus);
    this->m_PlannerCode=p->m_PlannerCode;
    this->m_PlannerCheck=p->m_PlannerCheck;
    this->m_PlannerStop=p->m_PlannerStop;
    this->m_PlannerCancel=p->m_PlannerCancel;
    this->m_PlannerClose=p->m_PlannerClose;
    this->m_PlannerTel=p->m_PlannerTel;
    this->m_PlannerBeepPage=p->m_PlannerBeepPage;
    this->BackupValue();
}
//---------------------------------------------------------------------------
void TsdPlanner::AssignValue()
{
    TsdPlanner *p=(TsdPlanner *)Records(CurRecNo);
    Assign(p);
}
//---------------------------------------------------------------------------
int TsdPlanner::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();
            TsdPlanner *p=new TsdPlanner();
            SetActionID(1);
            p->Assign(this);
            AddRecord((void *)p,p->PlannerCode);
            m_Query->Next();
        }
        MoveFirst();
    }
    m_Query->Close();
    return Count;
}
//---------------------------------------------------------------------------
bool TsdPlanner::Find(AnsiString WhereStr)
{
    AnsiString m_SqlStr;
    if(WhereStr.IsEmpty()==true)
        throw Exception("查找表达式不能为空");
    m_SqlStr="SELECT * FROM SDPlanner 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;
    }
}
//---------------------------------------------------------------------------
TsdPlanner::~TsdPlanner()
{
  try{
  }
  catch(...)
  {
    throw Exception("析构函数出错");
  }
}