public string CheckUserLogin(string sUser, string sTNom, ref int nR)
{
string sErr = "";
MainF.ServerExchange xSE = new MainF.ServerExchange(xMF);
if (xMF.xPars.ReLogon > 0)
{
sErr = String.Format("(KSK={0},REG={1},TABN={2})", xSm.nSklad,
(nCurReg == AppC.AVT_LOGON) ? "SMSTART" :
(nCurReg == AppC.AVT_TOUT) ? "SMCONT" : "SMOVER", sTNom);
LoadFromSrv dgL = new LoadFromSrv(Time2SmEnd);
//Cursor crsOld = Cursor.Current;
//Cursor.Current = Cursors.WaitCursor;
sErr = xSE.ExchgSrv(AppC.COM_LOGON, sErr, sUser, dgL, null, ref nR);
///Cursor.Current = crsOld;
nR = xSE.ServerRet;
}
else
{
xSm.tMinutes2SmEnd = TimeSpan.FromMinutes(60 * 24);
//xSm.dtSmEnd = DateTime.Now + xSm.tMinutes2SmEnd;
}
return(sErr);
}
public int ConvertSSCC2Lst(ServerExchange xSE, string sSSCC, ref PSC_Types.ScDat scD, bool bInfoOnEmk, DataTable dtResult)
{
int nRec,
nRet = AppC.RC_OK;
string
sP;
DataSet
dsTrans = null;
// вместе с командой отдаем заголовок документа
xCUpLoad = new CurUpLoad(xPars);
xCUpLoad.sCurUplCommand = AppC.COM_ZSC2LST;
if (xCDoc.drCurRow is DataRow)
{
dsTrans = xNSI.MakeWorkDataSet(xNSI.DT[NSI.BD_DOCOUT].dt, dtResult, new DataRow[] { xCDoc.drCurRow }, null, xSm, xCUpLoad);
}
MakeTempDOUTD(dtResult);
LoadFromSrv dgL = new LoadFromSrv(LstFromSSCC);
xCLoad = new CurLoad();
xCLoad.sSSCC = sSSCC;
xCLoad.xLP.lSysN = xCDoc.nId;
xCLoad.dtZ = dtL;
sP = String.Format("(SSCC={0},TYPE={1})", sSSCC, "ROW");
string sL = xSE.ExchgSrv(AppC.COM_ZSC2LST, sP, "", dgL, dsTrans, ref nRet, 20);
if (dtL.Rows.Count > 0)
{
nRet = TestProdBySrv(xSE, nRet);
if (nRet == AppC.RC_OK)
{
nRec = xCLoad.dtZ.Rows.Count;
if (nRec == 1)
{// будем изображивать сканирование
SetVirtScan(xCLoad.dtZ.Rows[0], ref scD, true, bInfoOnEmk);
scD.sSSCC = sSSCC;
}
else
{// добавление группы ???
nRet = AppC.RC_MANYEAN;
}
}
}
else
{// просто сохраним запись ??? - если была сетевая ошибка! при ошибке сервера ничего сохранять не надо!
if (xSE.ServerRet != AppC.RC_OK)
{
Srv.ErrorMsg(sL);
}
}
return(nRet);
}
public LoadNSISrv(NSI x_NSI, string sTName_Ind, bool bMD5)
{
xNSI = x_NSI;
sTName = sTName_Ind;
bMD_5 = bMD5;
//sDop = (bMD5 == true) ? "MD5=" + xNSI.DT[sTName].MD5 + ";" : "";
sDop = (bMD5 == true) ? "MD5=" + (string)xNSI.BD_TINF_RW(sTName)["MD5"] + ";" : "";
dgL = new LoadFromSrv(NsiFromSrv);
}
public LoadNSISrv(NSI x_NSI, string sTName_Ind, bool bMD5)
{
xNSI = x_NSI;
sTName = sTName_Ind;
dt = xNSI.DT[sTName].dt;
bMD_5 = bMD5;
object xSearch = sTName;
drMD5 = xNSI.DT[NSI.BD_TINF].dt.Rows.Find(xSearch);
if (drMD5 != null)
{
sMD5Old = (string)drMD5["MD5"];
sDop = (bMD5 == true) ? "MD5=" + sMD5Old + ";" : "";
}
dgL = new LoadFromSrv(NsiFromSrv);
}
private void LoadAvtoList(bool bUsePropusk)
{
int nRet = AppC.RC_OK;
string sPar,
sErr = "";
LoadFromSrv dgRead;
xSE = new MainF.ServerExchange(xMainF);
dgRead = new LoadFromSrv(AvtoList);
sPar = String.Format("(IO={0},NSH={1},KSK={2}", xPark.ParkIO, xPark.NShl, xMainF.xSm.nSklad);
if (xPark.NSm > 0)
{
sPar += ",KSMEN=" + xPark.NSm.ToString();
}
if (xPark.NPtvList > 0)
{
sPar += ",NPL=" + xPark.NPtvList.ToString();
}
if (xPark.Propusk.Length > 0)
{
sPar += ",PRPSK=" + xPark.Propusk.Trim();
}
sPar += ")";
//Cursor crsOld = Cursor.Current;
//Cursor.Current = Cursors.WaitCursor;
sErr = xSE.ExchgSrv(AppC.COM_ZOTG, sPar, "", dgRead, null, ref nRet);
//FakeEx();
//Cursor.Current = crsOld;
bsSh.RemoveFilter();
if (nRet == AppC.RC_OK)
{
xPark.SaveOldPars();
IsParkAvail();
//lAvtoCount.Text = bsSh.Count.ToString();
//xPark.SaveOldPars();
}
else
{
((DataView)bsSh.DataSource).Table.Rows.Clear();
Srv.ErrorMsg(sErr, true);
if (nRet == 24)
{// неверный шлюз
BeginEditP(tShlAddr);
}
}
}
// обмен данными с сервером в формате XML
// nCom - номер команды
// sPar1
// nTOutRead - таймаут на ожидание ответа от сервера
public string ExchgSrv(string nCom, string sPar1, string sDop,
LoadFromSrv dgRead, DataSet dsTrans, ref int ret, int nTOutRead, int nBufSize)
{
string
sOutFileXML = "",
sC,
sHost,
sAdr,
sErr;
int
nPort;
SocketStream.ASRWERROR
nRErr;
System.IO.Stream
stm = null;
ret = AppC.RC_CANCEL;
ServerRet = AppC.EMPTY_INT;
if (xMF.xCLoad != null)
{
xMF.xCLoad.xLastSE = this;
xMF.xCLoad.sFileFromSrv = "";
}
SelSrvPort(nCom, sPar1, out sHost, out nPort);
sAdr = sHost + ":" + nPort.ToString();
sErr = sAdr + "-нет соединения!";
Cursor.Current = Cursors.WaitCursor;
try
{
CurSocket = new SocketStream(sHost, nPort);
if (!TestConn(false, xMF.xBCScanner, xMF.xFPan))
{
TraiceWiFi(sErr);
//throw new System.Net.Sockets.SocketException(11053);
}
else
{
//MessageBox.Show("Good reset!");
}
//TraiceWiFi(nCom + " - перед Connect");
stm = CurSocket.Connect();
// поток создан, отправка команды
sErr = sAdr + "-команда не отправлена";
byte[] baCom = SetCommand2Srv(nCom, sPar1, sDop);
//stm.Write(baCom, 0, baCom.Length);
//stm.Write(AppC.baTermCom, 0, AppC.baTermCom.Length);
// 20 секунд на запись команды
CurSocket.ASWriteS.TimeOutWrite = 1000 * 10;
CurSocket.ASWriteS.BeginAWrite(baCom, baCom.Length);
if ((dsTrans != null) || (XMLPars != null))
{// передача данных при выгрузке
//sErr = sAdr + "-ошибка выгрузки";
//dsTrans.WriteXml(stm, XmlWriteMode.IgnoreSchema);
//sErr = sAdr + "-ошибка завершения";
sErr = sAdr + "-ошибка выгрузки";
MemoryStream mst = new MemoryStream();
if (dsTrans != null)
{
dsTrans.WriteXml(mst, XmlWriteMode.IgnoreSchema);
}
if (XMLPars != null)
{
mst.Write(XMLPars, 0, XMLPars.Length);
}
// терминатор сообщения
mst.Write(AppC.baTermMsg, 0, AppC.baTermMsg.Length);
byte[] bm1 = mst.ToArray();
mst.Close();
// 60 секунд на запись данных
CurSocket.ASWriteS.TimeOutWrite = 1000 * 180;
CurSocket.ASWriteS.BeginAWrite(bm1, bm1.Length);
}
else
{
sErr = sAdr + "-ошибка завершения";
// 10 секунд на запись терминатора сообщения
CurSocket.ASWriteS.TimeOutWrite = 1000 * 30;
// терминатор сообщения
CurSocket.ASWriteS.BeginAWrite(AppC.baTermMsg, AppC.baTermMsg.Length);
}
//int nCommLen = 0;
//byte[] bAns = ReadAnswerCommand(stm, ref nCommLen);
//sC = Encoding.UTF8.GetString(bAns, 0, nCommLen - AppC.baTermCom.Length);
sErr = sAdr + "-нет ответа сервера!";
// 120 секунд на чтение ответа
//m_ssExchg.ASReadS.TimeOutRead = 1000 * 120;
//m_ssExchg.ASReadS.BufSize = 256;
//nRErr = m_ssExchg.ASReadS.BeginARead(bUseFileAsBuf, 1000 * nTOutRead);
if (nBufSize > 0)
{
CurSocket.ASReadS.BufSize = nBufSize;
}
nRErr = CurSocket.ASReadS.BeginARead(1000 * nTOutRead);
switch (nRErr)
{
case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
sErr = " длинная команда";
throw new System.Net.Sockets.SocketException(10061);
case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
sC = CurSocket.ASReadS.GetMsg();
break;
default:
TraiceWiFi("Сетевая ошибка (чтение ответа)");
throw new System.Net.Sockets.SocketException(10061);
}
sErr = sAdr + "-ошибка чтения";
//Dictionary<string, string> aComm = SrvCommandParse(sC);
ServerAnswer = Srv.SrvAnswerParParse(sC);
SyncTimeWithSrv();
if (ServerAnswer.ContainsKey("PAR"))
{
StringAnsPars = ServerAnswer["PAR"];
StringAnsPars = StringAnsPars.Substring(1, StringAnsPars.Length - 2);
AnswerPars = Srv.SrvAnswerParParse(StringAnsPars, new char[] { ',' });
}
//TraiceWiFi("Ответ получен...");
ServerRet = int.Parse(ServerAnswer["RET"]);
if ((ServerAnswer["COM"] == nCom) &&
((ServerRet == AppC.RC_OK) ||
(ServerRet == AppC.RC_NEEDPARS) ||
(ServerRet == AppC.RC_HALFOK)))
{
CurSocket.ASReadS.OutFile = "";
if (ServerRet == AppC.RC_NEEDPARS)
{
CurSocket.ASReadS.TermDat = AppC.baTermMsg;
if (CurSocket.ASReadS.BeginARead(true, 1000 * nTOutRead) == SocketStream.ASRWERROR.RET_FULLMSG)
{
//TraiceWiFi("Доп.Данные получены...");
sOutFileXML = CurSocket.ASReadS.OutFile;
}
else
{
TraiceWiFi("Сетевая ошибка (чтение данных)");
throw new System.Net.Sockets.SocketException(10061);
}
}
if (dgRead != null)
{
dgRead(CurSocket, ServerAnswer, dsTrans, ref sErr, ServerRet);
}
try
{
sErr = ServerAnswer["MSG"];
}
catch { sErr = "OK"; }
//dgRead(m_ssExchg, aComm, dsTrans, ref sErr, nRetSrv);
//else
//{
// sErr = "OK";
//}
}
else
{
if (ServerAnswer["MSG"] != "")
{
sErr = ServerAnswer["MSG"];
}
else
{
sErr = sAdr + "\n Отложено выполнение";
}
}
ret = ServerRet;
}
catch (Exception e)
{
//sC = e.Message;
sErr = e.Message;
TraiceWiFi(sErr);
ret = 3;
}
finally
{
CurSocket.Disconnect();
Cursor.Current = Cursors.Default;
if (ServerRet == AppC.RC_NEEDPARS)
{
if (Srv.ExchangeContext.ExchgReason == AppC.EXCHG_RSN.NO_EXCHG)
{
Srv.ExchangeContext.ExchgReason = AppC.EXCHG_RSN.SRV_INIT;
Srv.ExchangeContext.CMD_EXCHG = nCom;
DialogResult xDRslt = xMF.CallDllForm(xMF.sExeDir + "SGPF-Univ.dll", true,
new object[] { this, nCom, AppC.R_PARS, sOutFileXML });
Srv.ExchangeContext.ExchgReason = AppC.EXCHG_RSN.NO_EXCHG;
if (xDRslt == DialogResult.OK)
{
}
}
}
}
return(sErr);
}
public string ExchgSrv(string nCom, string sPar1, string sDop,
LoadFromSrv dgRead, DataSet dsTrans, ref int ret, int nTimeOutR)
{
return(ExchgSrv(nCom, sPar1, sDop, dgRead, dsTrans, ref ret, nTimeOutR, -2));
}
public string ExchgSrv(string nCom, string sPar1, string sDop,
LoadFromSrv dgRead, DataSet dsTrans, ref int ret)
{
//return (ExchgSrv(nCom, sPar1, sDop, dgRead, dsTrans, ref ret, 60, -2));
return(ExchgSrv(nCom, sPar1, sDop, dgRead, dsTrans, ref ret, 180, -2));
}
private string UpLoadDoc(ServerExchange xSExch, ref int nR)
{
int i,
nRet = AppC.RC_OK;
string nComm,
sErr = "",
sAllErr = "";
DataSet dsTrans;
DataRow[] drAUpL = null;
LoadFromSrv
dgL = null;
try
{
drAUpL = PrepDataArrForUL(xCUpLoad.ilUpLoad.CurReg);
if (drAUpL != null)
{
if (xCUpLoad.sCurUplCommand != AppC.COM_CKCELL)
{
dgL = new LoadFromSrv(SetUpLoadState);
}
for (i = 0; i < drAUpL.Length; i++)
{
nRet = AppC.RC_OK;
nComm = (xCUpLoad.naComms[i] == AppC.TYPD_INV) ? AppC.COM_VINV :
(xCUpLoad.naComms[i] == AppC.TYPD_VPER) ? AppC.COM_VVPER :
(xCUpLoad.naComms[i] == AppC.TYPD_OPR) ? AppC.COM_VOPR : AppC.COM_VTTN;
switch ((int)(drAUpL[i]["TYPOP"]))
{
case AppC.TYPOP_MARK:
nComm = AppC.COM_VMRK;
break;
case AppC.TYPOP_OTGR:
case AppC.TYPOP_KMPL:
nComm = AppC.COM_VKMPL;
break;
}
if (xCUpLoad.sCurUplCommand.Length == 0)
{
xCUpLoad.sCurUplCommand = nComm;
}
dsTrans = xNSI.MakeWorkDataSet(xNSI.DT[NSI.BD_DOCOUT].dt,
xNSI.DT[NSI.BD_DOUTD].dt, new DataRow[] { drAUpL[i] }, null, xSm, xCUpLoad);
sErr = xSExch.ExchgSrv(xCUpLoad.sCurUplCommand, "", "", dgL, dsTrans, ref nRet, 300);
if ((xSExch.ServerRet == AppC.RC_OK) && (sErr != "OK"))
{
nRet = AppC.RC_HALFOK;
}
if (nRet != AppC.RC_OK)
{
nR = nRet;
sAllErr += sErr + "\n";
}
}
}
else
{
nRet = AppC.RC_NODATA;
sErr = "Нет данных для передачи";
}
}
catch (Exception)
{
nRet = AppC.RC_NODATA;
sErr = "Ошибка подготовки";
}
if (sAllErr.Length == 0)
{
nR = nRet;
sAllErr = sErr;
}
return(sAllErr);
}
private string UpLoadDoc(ServerExchange xSExch, ref int nR)
{
int i,
nRet = AppC.RC_OK;
string nComm,
sErr = "",
sAllErr = "";
DataSet dsTrans;
DataRow[] drAUpL = null;
LoadFromSrv
dgL = null;
try
{
drAUpL = PrepDataArrForUL(xCUpLoad.ilUpLoad.CurReg);
if (drAUpL != null)
{
if (xCUpLoad.sCurUplCommand != AppC.COM_CKCELL)
{
dgL = new LoadFromSrv(SetUpLoadState);
}
for (i = 0; i < drAUpL.Length; i++)
{
dsTrans = xNSI.MakeWorkDataSet(xNSI.DT[NSI.BD_DOCOUT].dt,
xNSI.DT[NSI.BD_DOUTD].dt, new DataRow[] { drAUpL[i] }, null, xSm, xCUpLoad);
if (dsTrans.Tables[NSI.BD_DOUTD].Rows.Count > 0)
{
nRet = AppC.RC_OK;
nComm = AppC.COM_VDOC;
if (xCUpLoad.sCurUplCommand.Length == 0)
{
xCUpLoad.sCurUplCommand = nComm;
}
sErr = xSExch.ExchgSrv(xCUpLoad.sCurUplCommand, "", "", dgL, dsTrans, ref nRet, 600);
if ((xSExch.ServerRet == AppC.RC_OK) && (sErr != "OK"))
{
nRet = AppC.RC_HALFOK;
}
if (nRet != AppC.RC_OK)
{
nR = nRet;
sAllErr += sErr + "\n";
}
}
else
{
Srv.ErrorMsg(String.Format("Тип {0} №{1} от {2} -\nнет данных!", drAUpL[i]["TD"], drAUpL[i]["NOMD"], drAUpL[i]["DT"]));
}
}
}
else
{
nRet = AppC.RC_NODATA;
sErr = "Нет данных для передачи";
}
}
catch (Exception)
{
nRet = AppC.RC_NODATA;
sErr = "Ошибка подготовки";
}
if (sAllErr.Length == 0)
{
nR = nRet;
sAllErr = sErr;
}
return(sAllErr);
}
private int GetAvtInf(int nCom)
{
int i,
nRet = AppC.RC_OK;
string sErr, sSys = "";
List <DataRow> aDR = new List <DataRow>();
DataView dv = null;
LoadFromSrv dgL = null;
if (xCUpLoad == null)
{
xCUpLoad = new CurUpLoad();
if (xCLoad != null)
{
xCUpLoad.xLP = xCLoad.xLP;
}
xDP = xCUpLoad.xLP;
}
xCUpLoad.ilUpLoad.SetAllAvail(true);
xCUpLoad.ilUpLoad.CurReg = AppC.UPL_ALL;
switch (nCom)
{
case AppC.COM_ZOPEN:
sErr = "";
foreach (object s in lbTTN.Items)
{
sErr += (string)s + " ";
}
sSys = String.Format("AVT={4},MASSA={0},SUMMA={1},MEST={2},TTN={3}",
xAvt.Massa, xAvt.Summa, xAvt.Mest, sErr, xAvt.Avto);
dgL = new LoadFromSrv(AvtFromSrv);
break;
case AppC.COM_ZPL:
dgL = new LoadFromSrv(InfoFromPL);
break;
case AppC.COM_ZCONTR:
// по всем невыгруженным документам
dv = new DataView(xNSI.DT[NSI.TBD_DOC].dt,
String.Format("SOURCE={0}", NSI.DOCSRC_CRTD), "", DataViewRowState.CurrentRows);
if (dv.Count <= 0)
{
ServClass.ErrorMsg("Нет данных !");
return(AppC.RC_OK);
}
for (i = 0; i < dv.Count; i++)
{
if (i > 0)
{
sSys += ",";
}
sSys += dv[i].Row["IDSER2D"].ToString();
aDR.Add(dv[i].Row);
}
xCUpLoad.sComPar = sSys;
dgL = new LoadFromSrv(AvtFromSrv);
break;
}
xFPan.ShowP(6, 60, "Запрос данных", xCUpLoad.ilUpLoad.CurRegName);
xFPan.UpdateHelp("Обмен с сервером...");
Cursor crsOld = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
sErr = ExchgSrv(nCom, sSys, "", dgL, null, ref nRet);
Cursor.Current = crsOld;
xFPan.HideP();
if (nRet == AppC.RC_OK)
{
}
else
{
MessageBox.Show("Результат - " + sErr, "Код - " + nRet.ToString());
}
if (tcMain.SelectedIndex != PG_DIR)
{
tcMain.SelectedIndex = PG_DIR;
}
switch (nCom)
{
case AppC.COM_ZPL:
break;
case AppC.COM_ZCONTR:
for (i = 0; i < dv.Count; i++)
{
//aDR[i]["SOURCE"] = NSI.DOCSRC_UPLD;
}
break;
}
return(nRet);
}
private string ExchgSrv(int nCom, string sPar1, string sDop,
LoadFromSrv dgRead, DataSet dsTrans, ref int ret)
{
string sC;
string sAdr = xPars.sHostSrv + ":" + xPars.nSrvPort.ToString();
string sErr = sAdr + "-нет связи с сервером";
int nRetSrv;
byte[] bAns = { };
//SocketStream.ASRWERROR nRErr;
System.IO.Stream stm = null;
ret = 0;
try
{
ssWrite = new SocketStream(xPars.sHostSrv, xPars.nSrvPort);
if (!TestConnection())
{
//throw new System.Net.Sockets.SocketException(11053);
}
stm = ssWrite.Connect();
// поток создан, отправка команды
sErr = sAdr + "-команды не отправлена";
byte[] baCom = SetUpLoadCommand(nCom, sPar1, sDop);
// 20 секунд на запись команды
ssWrite.ASWriteS.TimeOutWrite = 1000 * 20;
ssWrite.ASWriteS.BeginAWrite(baCom, baCom.Length);
sErr = sAdr + "-ошибка завершения";
// 10 секунд на запись терминатора сообщения
ssWrite.ASWriteS.TimeOutWrite = 1000 * 10;
// терминатор сообщения
ssWrite.ASWriteS.BeginAWrite(AppC.baTermMsg, AppC.baTermMsg.Length);
sErr = sAdr + "-ошибка чтения";
/*
* // 120 секунд на чтение ответа
* ssWrite.ASReadS.TimeOutRead = 1000 * 120;
* ssWrite.ASReadS.TermMsg = AppC.baTermCom;
* nRErr = ssWrite.ASReadS.BeginARead();
* switch (nRErr)
* {
* case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
* sErr = " длинная команда";
* throw new System.Net.Sockets.SocketException(10061);
* case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
* sC = ssWrite.ASReadS.GetMsg();
* break;
* default:
* throw new System.Net.Sockets.SocketException(10061);
* }
*/
//============
int nCommLen = 0;
bAns = ReadAnswerCommand(stm, ref nCommLen);
sC = Encoding.UTF8.GetString(bAns, 0, nCommLen - AppC.baTermCom.Length);
//================
Dictionary <string, string> aComm = SrvCommParse(sC, new char[] { ';' });
nRetSrv = int.Parse(aComm["RET"]);
if (aComm["COM"] == AppC.saComms[nCom])
{
if (nRetSrv == AppC.RC_OK)
{
sErr = "OK";
if (dgRead != null)
{
dgRead(stm, aComm, dsTrans, ref sErr, nRetSrv);
}
else
{//
//sErr = sAdr + "-завершение";
//// 5 секунд на чтение ответа
//ssWrite.ASReadS.TimeOutRead = 1000 * 5;
//ssWrite.ASReadS.TermMsg = AppC.baTermMsg;
//nRErr = ssWrite.ASReadS.BeginARead(256);
//switch (nRErr)
//{
// case SocketStream.ASRWERROR.RET_FULLBUF: // переполнение буфера
// sErr = " длинная команда";
// throw new System.Net.Sockets.SocketException(10061);
// case SocketStream.ASRWERROR.RET_FULLMSG: // сообщение полностью получено
// break;
// default:
// throw new System.Net.Sockets.SocketException(10061);
//}
}
}
else
{
if (aComm["MSG"] != "")
{
sErr = sAdr + " - ошибка:\r\n" + aComm["MSG"];
}
else
{
sErr = sAdr + "\r\n Отложено выполнение";
}
}
}
ret = nRetSrv;
}
catch (Exception e)
{
sC = e.Message;
ret = 3;
}
finally
{
ssWrite.Disconnect();
}
return(sErr);
}
// Обработка сканирования на панели Документов
private void ProceedScanDoc(ScanVarGP xSc, ref PSC_Types.ScDat s)
{
int
nRet = AppC.RC_OK;
string
sH,
sPar,
sErr = "";
CurLoad
ret;
ServerExchange
xSE = new ServerExchange(this);
if ((xSc.bcFlags & ScanVarGP.BCTyp.SP_SSCC_INT) > 0)
{
xCLoad = new CurLoad(AppC.UPL_ALL);
xCLoad.sSSCC = xSc.Dat;
xCLoad.drPars4Load = xNSI.DT[NSI.BD_KMPL].dt.NewRow();
LoadKomplLst(xCLoad.drPars4Load, AppC.F_LOADKPL);
}
else
{
ret = TransDocCode(ref s, xSE);
if (ret != null)
{
xCLoad = ret;
if (xSE.FullCOM2Srv.Length == 0)
{
if (bInLoad == true)
{
W32.keybd_event(W32.VK_ESC, W32.VK_ESC, 0, 0);
W32.keybd_event(W32.VK_ESC, W32.VK_ESC, 0, 0);
W32.keybd_event(W32.VK_ESC, W32.VK_ESC, W32.KEYEVENTF_KEYUP, 0);
W32.keybd_event(W32.VK_ESC, W32.VK_ESC, W32.KEYEVENTF_KEYUP, 0);
}
else
{
LoadDocFromServer(AppC.F_INITRUN, new KeyEventArgs(Keys.Enter), ref ehCurrFunc);
}
}
else
{
AutoSaveDat();
LoadFromSrv dgL = new LoadFromSrv(DocFromSrv);
xCLoad.nCommand = AppC.F_LOAD_DOC;
xCLoad.sComLoad = AppC.COM_ZZVK;
sErr = xSE.ExchgSrv(AppC.COM_ZZVK, "", "", dgL, null, ref nRet);
MessageBox.Show("Загрузка окончена - " + sErr, "Код - " + nRet.ToString());
PosOnLoaded(nRet);
Back2Main();
}
}
else
{
xCUpLoad = new CurUpLoad();
if (xSE.FullCOM2Srv.Length == 0)
{
sPar = String.Format("BC={0};BCT={1}", xSc.Dat, xSc.Id.ToString().ToUpper());
sErr = xSE.ExchgSrv(AppC.COM_UNKBC, sPar, "", null, null, ref nRet);
}
else
{
AutoSaveDat();
LoadFromSrv dgL = new LoadFromSrv(DocFromSrv);
xCLoad.nCommand = AppC.F_LOAD_DOC;
xCLoad.sComLoad = AppC.COM_ZZVK;
sErr = xSE.ExchgSrv(AppC.COM_ZZVK, "", "", dgL, null, ref nRet);
MessageBox.Show("Загрузка окончена - " + sErr, "Код - " + nRet.ToString());
PosOnLoaded(nRet);
Back2Main();
}
if (nRet != AppC.RC_OK)
{
nRet = xSE.ServerRet;
if (nRet != AppC.RC_NEEDPARS)
{
}
Srv.PlayMelody(W32.MB_4HIGH_FLY);
sH = "Ошибка!";
}
else
{
sH = "Код отправлен";
}
Srv.ErrorMsg(sErr, sH, false);
}
}
}
