private void TestEmm()
{
int
nE,
nWithNE;
DataTable
dtM = xNSI.DT[NSI.NS_MC].dt;
DataRelation
myRelation = dtM.ChildRelations[NSI.REL2EMK];
DataRow[]
childRows;
WriteProt(String.Format("========== Test NS_MC & EMK {0}", DateTime.Now));
nWithNE = 0;
foreach (DataRow dr in dtM.Rows)
{
childRows = dr.GetChildRows(myRelation);
nE = childRows.Length;
if ((nE > 1) || (nE < 1))
{
nWithNE++;
WriteProt(String.Format("KRKMC={0} E={1} EAN={3} {2} ", dr["KRKMC"], nE, dr["SNM"], dr["EAN13"]));
}
}
WriteProt(String.Format("========== Total = {0}", nWithNE));
Srv.ErrorMsg(nWithNE.ToString());
}
private void tKrkB_Validated(object sender, EventArgs e)
{
int i = 0;
string s = ((TextBox)sender).Text.Trim();
if (s.Length > 0)
{
DataView dvR = ((DataTable)cmbReasons.DataSource).DefaultView;
for (i = 0; i < dvR.Count; i++)
{
if (dvR[i].Row["KRK"].ToString() == s)
{// краткий код обнаружен
if (cmbReasons.SelectedIndex == i)
{
cmbReasons.SelectedIndex = i - 1;
}
cmbReasons.SelectedIndex = i;
//UpdateFullKodPr(dvR[i].Row["KPR"].ToString(), dvR[i].Row["SNM"].ToString());
if (nDocType == AppC.TYPD_BRK)
{// для актов забраковки на этом все заканчивается
EndEditB(true);
this.Close();
}
//aEd.TryNext(AppC.CC_NEXT);
break;
}
}
if (i >= dvR.Count)
{
Srv.ErrorMsg("Не найден!", "Код " + s, true);
//((TextBox)sender).Text = "";
}
}
}
// добавление в список SSCC отмаркированного поддона
public DataRow AddSSCC2SSCCTable(string sSSCC, int nPP, CurDoc xCDoc, bool bAddNew)
{
DataRow
ret = null;
int
nKey = (int)xCDoc.drCurRow["SYSN"];
try
{
bAddNew = false;
ret = FindSCCTInSSCCList(sSSCC, nKey, ref nPP);
if (ret == null)
{
bAddNew = true;
ret = xNSI.DT[NSI.BD_SSCC].dt.NewRow();
ret["SYSN"] = nKey;
ret["NPODDZ"] = nPP;
ret["SSCC"] = sSSCC;
ret["STATE"] = 1;
}
ret["IN_TTN"] = 1;
if (bAddNew)
{
xNSI.DT[NSI.BD_SSCC].dt.Rows.Add(ret);
}
}
catch
{
Srv.ErrorMsg("Ошибка добавления SSCC!");
}
return(ret);
}
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);
}
private void tParty_Validating(object sender, CancelEventArgs e)
{
if (bInScanProceed)
{
return;
}
string sT = ((TextBox)sender).Text.Trim();
if (sT.Length > 0)
{
try
{
if (sT.Length > 4)
{
Srv.ErrorMsg("Партия - 4 знака!", true);
e.Cancel = true;
}
}
catch
{
e.Cancel = true;
}
}
if (!e.Cancel)
{
xMark.ScanFirst.nParty = sT;
((TextBox)sender).Text = sT;
}
}
// допустимость ввода продукции
private bool CanSetOperObj()
{
bool
bSrcNeed = AppC.xDocTInf[xCDoc.xDocP.nTypD].AdrFromNeed,
bDstNeed = AppC.xDocTInf[xCDoc.xDocP.nTypD].AdrToNeed,
ret = true;
if (xPars.UseAdr4DocMode)
{
if (bSrcNeed)
{// адрес-источник нужен ?
if (AppC.xDocTInf[xCDoc.xDocP.nTypD].MoveType == AppC.MOVTYPE.MOVEMENT)
{
if ((xSm.xAdrFix1 != null) && (!xCDoc.xOper.IsFillSrc()))
{// зафиксирован адрес
xCDoc.xOper.SetOperSrc(xSm.xAdrFix1, xCDoc.xDocP.nTypD, true);
}
}
if ((xCDoc.xOper.GetSrc(false).Length > 0) ||
((xCDoc.drCurRow["CHKSSCC"] is int) && ((int)xCDoc.drCurRow["CHKSSCC"] > 0)) ||
(IsDoc4Check()))
{
}
else
{
ret = false;
Srv.ErrorMsg("Не указан адрес!");
}
}
}
return(ret);
}
// проверка пароля для непустого пользователя
public bool ValidUserPass(string sUser, string sPass, string sTabN, string sUN)
{
bool ret = false;
int nRet = AppC.RC_OK;
if (sUser.Length > 0)
{
if ((sUser != AppC.SUSER) && (sUser != AppC.GUEST))
{
try
{
if (sTabN.Length > 0)
{// отсканирован штрихкод с табельным
ret = true;
}
else
{
DataView dv = new DataView(xNSI.DT[NSI.NS_USER].dt,
String.Format("KP='{0}'", sUser), "", DataViewRowState.CurrentRows);
if (dv.Count == 1)
{
if (sPass == (string)dv[0].Row["PP"])
{
ret = true;
sUN = (string)dv[0].Row["NMP"];
sTabN = (string)dv[0].Row["TABN"];
}
}
}
string sE = CheckUserLogin(sUser, sTabN, ref nRet);
if (nRet != AppC.RC_OK)
{
ret = false;
Srv.ErrorMsg(sE, true);
}
}
catch { }
}
else
{
ret = true;
sUN = (sUser == AppC.SUSER) ? "Admin" : "Работник склада";
}
if (ret)
{
xSm.sUser = sUser;
xSm.sUName = sUN;
xSm.sUserPass = sPass;
xSm.sUserTabNom = sTabN;
xSm.urCur = (sUser == AppC.SUSER) ? Smena.USERRIGHTS.USER_SUPER :
Smena.USERRIGHTS.USER_KLAD;
}
}
return(ret);
}
// Выгрузить настройки клавиатуры
private void MMenuClick_LoadControl(object sender, EventArgs e)
{
if (xSm.sUser == AppC.SUSER)
{
if (xFuncs.SaveKMap() == AppC.RC_OK)
{
MessageBox.Show("Файл выгружен");
}
}
else
{
Srv.ErrorMsg("Только Admin!", true);
}
CreateMMenu();
}
// Корректность введенного
private AppC.VerRet VerifyB()
{
int
n = 0;
AppC.VerRet
v;
v.nRet = AppC.RC_CANCEL;
v.cWhereFocus = null;
try
{
if (xMark.ScanFirst.sKMC.Length > 0)
{
if (xMark.ScanFirst.nMest > 0)
{
if (xMark.ScanFirst.nParty.Length > 0)
{
if (xMark.ScanFirst.dDataIzg != DateTime.MinValue)
{
v.nRet = AppC.RC_OK;
}
else
{
Srv.ErrorMsg("Введите дату");
v.cWhereFocus = tDTV;
}
}
else
{
Srv.ErrorMsg("Введите партию");
v.cWhereFocus = tParty;
}
}
else
{
Srv.ErrorMsg("Нулевое количество");
v.cWhereFocus = tMest;
}
}
}
catch
{
n = 0;
}
return(v);
}
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);
}
}
}
// проверка типа
private void tKT_p_Validating(object sender, CancelEventArgs e)
{
string
sT = tKT_p.Text.Trim();
if (bEditMode)
{
if (xDP.nNumTypD == AppC.EMPTY_INT)
{
if (!aEdVvod.Fict4Next.Focused)
{
Srv.ErrorMsg("Укажите тип!", true);
}
e.Cancel = true;
}
}
}
// Корректность введенного
private AppC.VerRet VerifyAvt()
{
AppC.VerRet v;
bool bGoodUser = false;
try
{
if (nCurReg != AppC.AVT_TOUT)
{
//if (tUser.Enabled)
// bGoodUser = ValidUserPass(xSm.sUser, xSm.sUserPass, "", "");
//else
// bGoodUser = true;
bGoodUser = ValidUserPass(xSm.sUser, xSm.sUserPass, "", "");
}
else
{
if (nCurReg != AppC.AVT_PARS)
{
bGoodUser = (tPass.Text == xSm.sUserPass) ? true : false;
}
else
{
bGoodUser = true;
}
}
}
catch
{
bGoodUser = false;
}
if (!bGoodUser)
{
v.nRet = AppC.RC_CANCEL;
Srv.ErrorMsg("Неверный пользователь или пароль!");
}
else
{
v.nRet = AppC.RC_OK;
}
v.cWhereFocus = null;
return(v);
}
private int TrySend2Serv(string sSSCC)
{
int
ret = AppC.RC_NOSSCC;
AppC.VerRet
xR;
if (sSSCC.Length > 0)
{
xR = VerifyB();
ret = xR.nRet;
if (ret == AppC.RC_OK)
{
xMark.ScanFirst.sSSCC = sSSCC;
ret = SendCOMMark(sSSCC);
WrappSet(xNSI.DT[NSI.NS_MC].dt, xMark.ScanFirst, 1);
if (ret == AppC.RC_OK)
{
Srv.ErrorMsg(sSSCC, "Отправлено!", false);
if (bAutoMark)
{
EndEditB(false, sSSCC);
}
else
{
ret = AppC.RC_QUIT;
BeginEditB(false);
}
}
}
else
{
aEd.SetCur(xR.cWhereFocus);
}
}
else
{
Srv.ErrorMsg("Нет SSCC!", true);
}
return(ret);
}
// Корректность введенного
private AppC.VerRet VerifyB()
{
AppC.VerRet v;
tKrkB.DataBindings[0].WriteValue();
tKolMB.DataBindings[0].WriteValue();
tKolEB.DataBindings[0].WriteValue();
EvalTotal();
DataRow dr = ((DataRowView)bsB.Current).Row;
DataRow drReas = xNSI.DT[NSI.NS_PRPR].dt.Rows.Find(dr["KPR"]);
v.nRet = AppC.RC_CANCEL;
v.cWhereFocus = null;
if (drReas != null)
{
if (fTotE > fMaxEd)
{
Srv.ErrorMsg("Превышение количества!", true);
tKolEB.Text = fTotE.ToString();
tKolEB.SelectAll();
v.cWhereFocus = (tKolMB.Enabled) ? tKolMB : tKolEB;
}
else
{
if ((fTotE != 0) || (nTotM != 0))
{
v.nRet = AppC.RC_OK;
}
else
{
Srv.ErrorMsg("Нулевые количества!", true);
}
}
}
else
{
Srv.ErrorMsg("Причина не указана!", true);
}
return(v);
}
private bool CanProd(ref PSC_Types.ScDat sc)
{
bool
ret = true;
if (xPars.UseAdr4DocMode)
{
if (xCDoc.xDocP.DType.AdrFromNeed)
{// адрес-источник нужен ?
if ((xCDoc.xOper.GetSrc(false).Length > 0) || ((xCDoc.drCurRow["CHKSSCC"] is int) && ((int)xCDoc.drCurRow["CHKSSCC"] > 0)))
{
}
else
{
ret = false;
Srv.ErrorMsg("Не указан адрес!");
}
}
if (xCDoc.xDocP.DType.MoveType == AppC.MOVTYPE.PRIHOD)
{
if (xCDoc.xOper.bObjOperScanned && !xCDoc.xOper.IsFillDst())
{
DialogResult drQ = MessageBox.Show("Заменить продукцию(ENT)?\n(ESC) - отменить ввод",
"Ожидается адрес!",
MessageBoxButtons.OKCancel,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
if (drQ != DialogResult.OK)
{
ret = false;
}
else
{
sc.bReWrite = true;
}
}
}
}
return(ret);
}
// добавление очередного SSCC в список SSCC
public DataRow AddSSCC2SSCCTable(string sSSCC, int nPP, CurDoc xCDoc, int SQUs, int FromSRV, int FromTTN)
{
bool
bAddNew;
DataRow
ret = null;
int
nKey = (int)xCDoc.drCurRow["SYSN"];
try
{
bAddNew = false;
ret = FindSCCTInSSCCList(sSSCC, nKey, ref nPP);
if (ret == null)
{
bAddNew = true;
ret = xNSI.DT[NSI.BD_SSCC].dt.NewRow();
ret["SYSN"] = nKey;
ret["SSCC"] = sSSCC;
ret["MONO"] = SQUs;
ret["STATE"] = 1;
if (nPP == 0)
{
nPP = GetMaxInRows(xNSI.DT[NSI.BD_SSCC].dt, "NPODDZ", xCDoc.DefDetFilter()) + 1;
}
ret["NPODDZ"] = nPP;
}
ret["IN_ZVK"] = FromSRV;
ret["IN_TTN"] = FromTTN;
if (bAddNew)
{
xNSI.DT[NSI.BD_SSCC].dt.Rows.Add(ret);
}
}
catch
{
Srv.ErrorMsg("Ошибка добавления SSCC!");
}
return(ret);
}
public bool StoreSSCC(ScanVarRM xSc, int nPoddonN, bool bNeedWrite, out DataView dv)
{
int n = 0;
string
s, sRf,
sF,
sD = xSc.Dat;
bool
//bIsExt,
bRet = AppC.RC_CANCELB;
DataView dvZ;
DialogResult dRez;
if (sD.Substring(2, 1) == "1")
{
//bIsExt = true;
sF = "SSCC";
}
else
{
//bIsExt = false;
sF = "SSCCINT";
}
/// 14.02.18
sF = "SSCC";
dv = null;
if (xCDoc.drCurRow == null)
{
return(bRet);
}
try
{
if ((int)xCDoc.drCurRow["TYPOP"] == AppC.TYPOP_KMPL)
{
if (nPoddonN > 0)
{
//string sRf = xCDoc.DefDetFilter() + String.Format(" AND (SSCC='{0}')", sSSCC);
//dv = new DataView(xNSI.DT[NSI.BD_DOUTD].dt, sRf, "", DataViewRowState.CurrentRows);
//n = dv.Count;
if (IsUsedSSCC(sD))
{
dRez = MessageBox.Show(
String.Format("SSCC={0}\nОтменить (Enter)?\n(ESC)-проставить SSCC", sD),
"Уже использовался!", MessageBoxButtons.OKCancel,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
n = (dRez == DialogResult.OK) ? 1 : 0;
}
if (n == 0)
{// такой SSCC еще не использовался
sRf = xCDoc.DefDetFilter() + String.Format(" AND (NPODDZ={0})", nPoddonN);
dv = new DataView(xNSI.DT[NSI.BD_DOUTD].dt, sRf, "", DataViewRowState.CurrentRows);
if (dv.Count > 0)
{
foreach (DataRowView drv in dv)
{
if ((drv.Row[sF]) != System.DBNull.Value)
{
s = (drv.Row[sF]).ToString();
if ((s.Length > 0) && (s != sD))
{
dRez = MessageBox.Show(
String.Format("SSCC={0} уже установлен\nОтменить (Enter)?\n(ESC)-проставить SSCC", drv.Row["SSCC"]),
String.Format("Поддон {0}", nPoddonN),
MessageBoxButtons.OKCancel,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
n = (dRez == DialogResult.OK) ? 1 : 0;
break;
}
}
}
if (n == 0)
{// поддон еще не отмечался
// добавим фильтр на выполненные
sRf += String.Format("AND(READYZ<>{0})", (int)NSI.READINESS.FULL_READY);
dvZ = new DataView(xNSI.DT[NSI.BD_DIND].dt, sRf, "", DataViewRowState.CurrentRows);
n = dvZ.Count;
if (n > 0)
{// не вся заявка закрыта
if (!xCDoc.bFreeKMPL)
{
dRez = MessageBox.Show(
"Заявка не выполнена!\nОтменить (Enter)?\r\n(ESC)-проставить SSCC",
String.Format("Поддон {0}", nPoddonN),
MessageBoxButtons.OKCancel,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
n = (dRez == DialogResult.OK) ? 1 : 0;
}
else
{
n = 0;
}
}
if (n == 0)
{
bRet = AppC.RC_OKB;
if (bNeedWrite)
{
SetSSCCForPoddon(xSc.Dat, dv, nPoddonN);
}
//foreach (DataRowView drv in dv)
//{
// (drv.Row[sF]) = sSSCC;
//}
//MessageBox.Show(String.Format("Поддон {0} подготовлен ({1}) позиций",
// xCDoc.xNPs.Current, dv.Count));
//xCDoc.xNPs.TryNextPoddon(true);
//tCurrPoddon.Text = xCDoc.xNPs.Current.ToString();
}
}
}
else
{
Srv.ErrorMsg("Нет отсканированных!");
}
}
else
{
Srv.ErrorMsg("SSCC поддона уже использовался!");
}
}
else
{
Srv.ErrorMsg("№ поддона не установлен!");
}
}
else
{
Srv.ErrorMsg("Только для комплектации!");
}
}
catch (Exception e)
{
Srv.ErrorMsg("Только для комплектации!");
}
return(bRet);
}
private int ProceedSSCC(ScanVarGP xS, ref PSC_Types.ScDat scD, Control xCCur)
{
int
ret = AppC.RC_OK;
string
sSSCC = xS.Dat;
MainF.ServerExchange
xSE = new MainF.ServerExchange(xMF);
switch (InFocus())
{
case "tKrKMC":
xSE.FullCOM2Srv = String.Format("COM={0};KSK={6};MAC={1};KP={2};PAR=(KSK={3},DT={4},SSCC={5},TYPOP=MARK);",
AppC.COM_ZSC2LST,
xMF.xSm.MACAdr,
xMF.xSm.sUser,
xMF.xCDoc.xDocP.nSklad,
xMF.xCDoc.xDocP.dDatDoc.ToString("yyyyMMdd"),
sSSCC,
xMF.xCDoc.xDocP.nSklad
);
try
{
//ret = xMF.ConvertSSCC2Lst(xSE, sSSCC, true, true, ref scD);
ret = xMF.ConvertSSCC2Lst(xSE, sSSCC, ref scD, true);
if ((ret == AppC.RC_OK) && (scD.sKMC.Length > 0))
{
scD.tTyp = ((xS.bcFlags & ScanVarGP.BCTyp.SP_SSCC_PRT) > 0)?
AppC.TYP_TARA.TARA_TRANSP:AppC.TYP_TARA.TARA_PODDON;
if (scD.bVes)
{
if (scD.nKolSht == 0)
{
// определить количество в штуках
SetDefEmk(ref scD);
}
if (scD.nKolG == 0)
{
scD.nKolG = scD.nMest * scD.nKolSht;
}
scD.fVsego = scD.nKolG;
}
xMark.ScanFirst = scD;
//EvalTot(xMark.ScanFirst.nMestPal);
ret = AppC.RC_HALFOK;
}
else
{
throw new Exception("Bad SSCC");
}
}
catch
{
Srv.ErrorMsg("Недопустимое содержимое", sSSCC, true);
ret = AppC.RC_CANCEL;
}
break;
case "tSSCC":
xMark.SSCC = sSSCC;
tSSCC.Text = sSSCC;
ret = TrySend2Serv(sSSCC);
break;
}
//scCur = scD;
return(ret);
}
// продукция на какой-то из наших этикеток
private int ProceedProd(ScanVarGP xSc, ref PSC_Types.ScDat sc, bool bDupScan, bool bEasyEd)
{
//bool
// bDopValuesNeed = true;
int
nRet = AppC.RC_CANCEL;
#region Обработка скана продукции
do
{
if (!bDupScan)
{// первичный скан штрихкода, предыдущий был другой
}
else
{// повторный скан того же штрихкода - это, как правило, подтверждение ввода
}
//scCur = sc;
if (!sc.bFindNSI)
{
Srv.ErrorMsg("Код не найден! Обновите НСИ!", true);
}
nRet = AppC.RC_OK;
if (sc.bVes == true)
{
//scCur.fVsego = scCur.fVes;
//FRACT fE = scCur.fVes;
// 11.07.14 взято в коммент
if (sc.nRecSrc != (int)NSI.SRCDET.SSCCT)
{
if (!xScan.dicSc.ContainsKey("37") && (xScan.dicSc.Count == 4))
{
sc.tTyp = AppC.TYP_TARA.TARA_POTREB;
sc.fEmk = sc.fEmk_s = 0;
}
// нужно по-другому
if ((sc.tTyp == AppC.TYP_TARA.TARA_PODDON) && (sc.nMestPal > 0))
{
PSC_Types.ScDat
scTmp = sc;
bool
bSetEmk = xMF.TrySetEmk(xNSI.DT[NSI.NS_MC].dt, xNSI.DT[NSI.NS_SEMK].dt,
ref scTmp, scTmp.fVes / scTmp.nMestPal);
if ((bSetEmk == true) && (scTmp.tTyp == AppC.TYP_TARA.TARA_TRANSP))
{
sc.fEmk = scTmp.fEmk;
sc.nMest = sc.nMestPal;
}
}
else
{
xMF.TrySetEmk(xNSI.DT[NSI.NS_MC].dt, xNSI.DT[NSI.NS_SEMK].dt, ref sc, sc.fVes);
}
}
}
else
{
if (sc.nMestPal <= 0)
{
StrAndInt si;
for (int i = 0; i < sc.xEmks.Count; i++)
{
sc.xEmks.CurrIndex = i;
si = (StrAndInt )sc.xEmks.Current;
if (si.DecDat == sc.fEmk)
{
sc.nMestPal = si.IntCode;
sc.nTara = si.SNameAdd1;
sc.nKolSht = si.IntCodeAdd1;
}
}
}
}
if (AppC.RC_OK == nRet)
{
sc.nMest = sc.nMestPal;
xMark.ScanFirst = sc;
xMark.NumberOfScans = 1;
EvalTot(xMark.ScanFirst.nMestPal);
}
} while (false);
#endregion
return(nRet);
}
private void TryLoadSSCC(string sSSCC, int nRet)
{
int
nM,
nRec,
nNPP;
DataRow
dr = null;
DataTable
dtD = xNSI.DT[NSI.BD_DIND].dt;
DataSet
ds;
ServerExchange
xSE = new ServerExchange(this);
PSC_Types.ScDat
scD = new PSC_Types.ScDat(new BarcodeScannerEventArgs(BCId.Code128, ""));
//nRet = ConvertSSCC2Lst(xSE, sSSCC, ref scD, true, xNSI.DT[NSI.BD_DIND].dt);
if ((nRet == AppC.RC_OK) || (nRet == AppC.RC_MANYEAN))
{
xCDoc.drCurRow["CHKSSCC"] = 1;
// для контроля удаляем все предыдущие
DataRow[] drMDet = xCDoc.drCurRow.GetChildRows(xNSI.dsM.Relations[NSI.REL2TTN]);
foreach (DataRow drDel in drMDet)
{
xNSI.dsM.Tables[NSI.BD_DOUTD].Rows.Remove(drDel);
}
DataRow[] drMDetZ = xCDoc.drCurRow.GetChildRows(xNSI.dsM.Relations[NSI.REL2ZVK]);
foreach (DataRow drDel in drMDetZ)
{
xNSI.dsM.Tables[NSI.BD_DIND].Rows.Remove(drDel);
}
ds = xCLoad.dsZ;
Cursor.Current = Cursors.WaitCursor;
try
{
nRec = xCLoad.dtZ.Rows.Count;
nM = 0;
nNPP = 1;
foreach (DataRow drA in dtL.Rows)
{
scD = new PSC_Types.ScDat(new BarcodeScannerEventArgs(BCId.Code128, ""));
nM += SetOneDetZ(ref scD, dtD, ds, drA, xCDoc.drCurRow, ref nNPP);
nNPP++;
}
scCur = new PSC_Types.ScDat(new BarcodeScannerEventArgs(BCId.Code128, ""));
SetDetFields(true);
Srv.ErrorMsg(String.Format("{0} строк загружено", nRec), String.Format("SSCC...{0}", sSSCC.Substring(15, 5)), false);
}
catch (Exception exx)
{
Srv.ErrorMsg(exx.Message, "Ошибка загрузки!", true);
}
finally
{
Cursor.Current = Cursors.Default;
}
}
}
private int ProceedProd(ScanVarRM xSc, ref PSC_Types.ScDat sc, bool bDupScan)
{
bool
bDopValuesNeed = true;
int
nRet = AppC.RC_CANCEL;
#region Обработка скана продукции
do
{
if (!CanProd(ref sc))
{
break;
}
if (!AvailKMC4PartInvent(sc.sKMC, true))
{
break;
}
xCDoc.bConfScan = (ConfScanOrNot(xCDoc.drCurRow, xPars.ConfScan) > 0) ? true : false;
if (xCDoc.bConfScan)
{// документ требует подтверждения ввода для каждой продукции
//if ((sc.nRecSrc != (int)NSI.SRCDET.FROMADR) &&
// (sc.nRecSrc != (int)NSI.SRCDET.SSCCT))
// {// полученную с сервера не проверяем
// if (TestProdBySrv(ref sc) != AppC.RC_OK)
// break;
//}
// полученную с сервера ПОКА! проверяем
if (TestProdBySrv(ref sc) != AppC.RC_OK)
{
break;
}
}
if (xCDoc.drCurRow != null)
{
scCur = sc;
//if (!sc.bFindNSI)
// Srv.ErrorMsg(String.Format("Код {0} не найден!\nОбновите НСИ!", sc.sEAN), true);
bDopValuesNeed = true;
nRet = AppC.RC_OK;
if (scCur.bVes == true)
{
scCur.fVsego = scCur.fVes;
// убрано 05.07.18
//if (scCur.nRecSrc != (int)NSI.SRCDET.SSCCT)
//{
// //if (!xScan.dicSc.ContainsKey("37") && (scCur.tTyp != AppC.TYP_TARA.TARA_POTREB))
// //{
// // scCur.tTyp = AppC.TYP_TARA.TARA_POTREB;
// // scCur.fEmk = scCur.fEmk_s = 0;
// //}
//}
if ((xCDoc.xDocP.DType.MoveType == AppC.MOVTYPE.MOVEMENT) && (scCur.tTyp == AppC.TYP_TARA.TARA_PODDON))
{
bDopValuesNeed = false;
scCur.nMest = scCur.nMestPal;
}
if (AppPars.bVesNeedConfirm == false)
{// подтверждение ввода отключено
if ((scCur.tTyp != AppC.TYP_TARA.UNKNOWN) ||
((scCur.tTyp == AppC.TYP_TARA.TARA_POTREB) && (scCur.nParty.Length > 0)))
{
bDopValuesNeed = false;
}
}
if ((scCur.fVes == fDefVes) && (scCur.fVes > 0))
{
DialogResult dr = MessageBox.Show("Отменить ввод (Enter)?\r\n(ESC) - продолжить ввод",
String.Format("Тот же вес-{0}!", scCur.fVes), MessageBoxButtons.OKCancel,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
if (dr == DialogResult.OK)
{
nRet = AppC.RC_CANCEL;
}
}
fDefVes = scCur.fVes;
}
else
{
if ((scCur.tTyp == AppC.TYP_TARA.TARA_PODDON))
{
if (AppPars.bVesNeedConfirm == false)
{
bDopValuesNeed = false;
}
}
else
{
nRet = AppC.RC_OK;
}
}
if ((AppC.RC_OK == nRet) &&
(AppC.RC_OK == EvalZVKMest(ref scCur, null, 0, 0)))
{
nRet = Prep4Ed(ref scCur, ref bDopValuesNeed, 0);
SetDopFieldsForEnter(false);
if (nRet == AppC.RC_OK)
{
PInfReady();
SetDetFields(false);
//ShowDopInfKMPL(scCur.nKolM_alr + scCur.nKolM_alrT);
//if (bDopValuesNeed == false)
if ((bDopValuesNeed == false) && (bEditMode))
{ // редактирование пока отменяется, но есть ли все данные?
bDopValuesNeed = (VerifyVvod().nRet == AppC.RC_CANCEL) ? true : false;
}
if ((bDopValuesNeed == true))
{// будет редактирование
int nR = IsGeneralEdit(ref scCur);
if (nR == AppC.RC_OK)
{
AddOrChangeDet(AppC.F_ADD_SCAN);
}
else if (nR == AppC.RC_CANCEL)
{
//Srv.ErrorMsg("Неоднозначность!\r\nПерейдите в обычный режим!");
ZVKeyDown(AppC.F_PODD, null, ref ehCurrFunc);
}
else if (nR == AppC.RC_BADTABLE)
{
Srv.ErrorMsg("Переключаюсь в заявку...\r\nПовторите сканирование");
ChgDetTable(null, "");
}
else if (nR == AppC.RC_ZVKONLY)
{
Srv.ErrorMsg("Только с заявкой!");
}
}
else
{
AddDet1(ref scCur);
SetDopFieldsForEnter(true);
}
}
}
}
} while (false);
#endregion
return(nRet);
}
public int SendCOMMark(string sSSCC)
{
int
nRet = AppC.RC_OK;
string
sAddPars = "",
sL,
sScanProd;
DataSet dsTrans;
//CurUpLoad
// xCUpLoad;
MainF.ServerExchange
xSE = new MainF.ServerExchange(xMF);
// вместе с командой отдаем заголовок документа
//xCUpLoad = new CurUpLoad();
//xCUpLoad.sCurUplCommand = AppC.COM_MARKWMS;
dsTrans = MakeWorkDataSet1Det(null, xNSI.DT[NSI.BD_DOUTD].dt, xMark.ScanFirst, sSSCC);
sScanProd = (xMark.NumberOfScans > 1)?xMark.ScanFirst.s : "";
sAddPars = String.Format(",DEVID={0}{1}",
sDevID,
(chNewDoc.Checked)?",ND=1":"");
//if (bAskWrapMandatory)
if (enWrapMode.CurMode == AppC.WRAP_MODES.WRP_ASK_EVERY)
{
DialogResult dr = MessageBox.Show("Застрейчеван - (ENT)\n" +
"Без стрейча - (ESC)",
"Стрейчевание ?", MessageBoxButtons.OKCancel,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
chWrapp.Checked = (dr == DialogResult.OK) ? true : false;
}
xMark.WrapFlag = (chWrapp.Checked) ? "Y" : "N";
xSE.FullCOM2Srv = String.Format("COM={0};KSK={8};MAC={1};KP={2};PAR=(BARCODE={3},SSCC={4},TYPOP={5}{6},TG={7});",
AppC.COM_MARKWMS,
xMF.xSm.MACAdr,
xMF.xSm.sUser,
sScanProd,
sSSCC,
(chMsg2WMS.Checked)?"PRIHOD":"MARK",
sAddPars,
xMark.WrapFlag,
xMF.xSm.nSklad
);
sL = xSE.ExchgSrv(AppC.COM_MARKWMS, "", "", null, dsTrans, ref nRet, 60);
if (nRet == AppC.RC_OK)
{
SuccNewDoc();
}
else
{ // просто сохраним запись ??? - если была сетевая ошибка! при ошибке сервера ничего сохранять не надо!
if (xSE.ServerRet == AppC.RC_OK)
{ // сервер против этой записи ничего не имеет
SuccNewDoc();
}
Srv.ErrorMsg(sL);
}
//lHelp.Text = GetDopInf();
xBattInf.BIUserText = GetDopInf();
return(nRet);
}
private void tKrKMC_Validating(object sender, CancelEventArgs e)
{
if (bInScanProceed)
{
return;
}
string sT = ((TextBox)sender).Text.Trim();
if (sT.Length > 0)
{
try
{
int nM = int.Parse(sT);
PSC_Types.ScDat sTmp = new PSC_Types.ScDat(new ScannerAll.BarcodeScannerEventArgs(BCId.Unknown, ""));
if (true == xNSI.GetMCData("", ref sTmp, nM, true))
{
xMark.ScanFirst = sTmp;
xMark.ScanFirst.nMest = xMark.ScanFirst.nMestPal;
xMark.NumberOfScans = 1;
EvalTot(xMark.ScanFirst.nMestPal);
xMark.ScanFirst.nRecSrc = (int)NSI.SRCDET.HANDS;
if (xMark.ScanFirst.bVes)
{
xMF.TrySetEmk(xNSI.DT[NSI.NS_MC].dt, xNSI.DT[NSI.NS_SEMK].dt, ref xMark.ScanFirst, 0);
}
if (xMark.ScanFirst.bVes)
{
tVes.Visible = true;
}
SetDetFields(ref xMark.ScanFirst, false);
SetAvailDopFields(true);
if (enWrapMode.CurMode == AppC.WRAP_MODES.WRP_BY_NSI)
{
chWrapp.Checked = WrappSet(xNSI.DT[NSI.NS_MC].dt, xMark.ScanFirst, 0);
}
}
else
{
e.Cancel = true;
Srv.ErrorMsg("Нет в справочнике!", "Код " + nM.ToString(), true);
}
}
catch
{
e.Cancel = true;
}
}
else
{
// scCur.nKrKMC = 0;
//if (e.Cancel || (scCur.nKrKMC == 0))
//{
// bSetByHand = false;
//}
xMark.ScanFirst.nKrKMC = 0;
}
//if (e.Cancel || (xMark.ScanFirst.nKrKMC == 0))
//{
// bSetByHand = false;
//}
}
private void OnScanBage(object sender, BarcodeScannerEventArgs e)
{
bool
bGoodPass;
int
i,
nSklad,
nTab = 0;
string
sSklad,
sLogin,
sP;
bScanProceed = true;
if (e.nID == BCId.Code128)
{
if ((e.Data.Length == 10) && (e.Data.Substring(0, 3) == "777"))
{// бэджик ОАО Савушкин
try
{
nTab = int.Parse(e.Data.Substring(3));
if (nTab > 0)
{
if (nCurReg != AppC.AVT_TOUT)
{
DataView dv = new DataView(xNSI.DT[NSI.NS_USER].dt,
String.Format("TABN='{0}'", nTab), "", DataViewRowState.CurrentRows);
if (dv.Count > 0)
{
sP = (string)dv[0].Row["PP"];
if (ValidUserPass((string)dv[0].Row["KP"], (string)dv[0].Row["PP"],
(string)dv[0].Row["TABN"], (string)dv[0].Row["NMP"]))
{
bUserChanged = false;
aEd.SetAvail(tPass, false);
tPass.Text = sP;
aEd.SetAvail(tUser, false);
tUser.Text = xSm.sUName;
aEd.SetCur(tDefKSKL);
}
else
{
bUserChanged = true;
aEd.SetAvail(tPass, true);
tPass.Text = "";
aEd.SetAvail(tUser, true);
tUser.Text = "";
aEd.SetCur(tUser);
}
}
}
else
{
if (nTab.ToString() == xSm.sUserTabNom)
{
EndEditAvt(true);
}
else
{
Srv.ErrorMsg("Другой пользователь!", true);
}
}
}
}
catch
{
nTab = 0;
}
}
else if (e.Data.IndexOf('#') >= 0)
{// возможно, Русское море
try
{
int
nPassStart = e.Data.IndexOf('#');
sLogin = e.Data.Substring(0, nPassStart);
sP = e.Data.Substring(nPassStart + 1);
if (sLogin.Length > 0)
{
if (nCurReg != AppC.AVT_TOUT)
{
DataView dv = new DataView(xNSI.DT[NSI.NS_USER].dt,
String.Format("KP='{0}'", sLogin), "", DataViewRowState.CurrentRows);
if (dv.Count > 0)
{
//sP = (string)dv[0].Row["PP"];
if ((sP == (string)dv[0].Row["PP"]) || (sP == (string)dv[0].Row["TABN"]))
{
bGoodPass = ValidUserPass(sLogin, (string)dv[0].Row["PP"], (string)dv[0].Row["TABN"], (string)dv[0].Row["NMP"]);
}
else
{
bGoodPass = false;
}
if (bGoodPass)
{
bUserChanged = false;
aEd.SetAvail(tPass, false);
tPass.Text = sP;
aEd.SetAvail(tUser, false);
tUser.Text = xSm.sUName;
nSklad = (dv[0].Row["KSK"] == System.DBNull.Value)?0:(int)(dv[0].Row["KSK"]);
if (nSklad > 0)
{
tDefKSKL.Text = nSklad.ToString();
tDefKSKL_Validating(tDefKSKL, new CancelEventArgs());
//tDefKSKL.DataBindings[0].WriteValue();
//tDefNameSkl.Text = "";
//xSm.nSklad = nSklad;
//aEd.SetAvail(tDefKSKL, false);
aEd.SetCur(tDefDateDoc);
}
else
{
aEd.SetAvail(tDefKSKL, true);
aEd.SetCur(tDefKSKL);
}
}
else
{
bUserChanged = true;
aEd.SetAvail(tPass, true);
tPass.Text = "";
aEd.SetAvail(tUser, true);
tUser.Text = "";
aEd.SetCur(tUser);
}
}
}
else
{
if (sLogin == xSm.sUser)
{
EndEditAvt(true);
}
else
{
Srv.ErrorMsg("Другой пользователь!", true);
}
}
}
}
catch
{
nTab = 0;
}
}
}
bScanProceed = false;
}
// Обработка клавиш
private void NPodd2Sscc_KeyDown(object sender, KeyEventArgs e)
{
int nFunc = 0;
bool
ret = false;// клавиша еще не обработана
bSkipKey = false;
nFunc = xMF.xFuncs.TryGetFunc(e);
try
{
if (ehCurrFunc != null)
{// клавиши ловит одна из функций
ret = ehCurrFunc(nFunc, e, ref ehCurrFunc);
}
}
catch
{
Srv.ErrorMsg("Ошибка обработки", true);
ret = true;
}
if (sDevID.Length == 0)
{
if ((nFunc == AppC.F_QUIT) ||
(nFunc == AppC.F_MARKWMS) ||
(nFunc == AppC.F_HELP))
{
}
else
{
if ((nFunc <= 0) && (e.KeyValue == W32.VK_ENTER))
{
chMsg2WMS.Focus();
}
return;
}
}
if ((nFunc > 0) && (ret == false))
{//в режиме просмотра
ret = true;
switch (nFunc)
{
case AppC.F_HELP:
// вывод панели c окном помощи
xHelpS.ShowInfo(lstHelp, ref ehCurrFunc);
break;
case AppC.F_UPLD_DOC:
// повторная выгрузка
if (tSSCC.Text.Length == 20)
{
if (tSSCC.Text != xMark.SSCC)
{
xMark.SSCC = tSSCC.Text;
}
TrySend2Serv(xMark.SSCC);
}
break;
case AppC.F_CHG_REC:
// новый поддон
BeginEditB(false);
break;
case AppC.F_KMCINF:
// снять/установить флаг телеграмм для WMS
chMsg2WMS.Checked = !chMsg2WMS.Checked;
break;
case AppC.F_EASYEDIT:
// снять/установить флаг нового документа
chNewDoc.Checked = !chNewDoc.Checked;
break;
case AppC.F_LOAD_DOC:
// снять/установить флаг стрейчевания
chWrapp.Checked = !chWrapp.Checked;
break;
case AppC.F_A4MOVE:
// снять/установить флаг запроса о стрейчевании
//bAskWrapMandatory = !bAskWrapMandatory;
//Srv.ErrorMsg("Запрос о стрейче\n" + ((bAskWrapMandatory)?"включен":"выключен") + "...", "Смена параметра", true);
enWrapMode.SwitchNext();
Srv.ErrorMsg("Стрейчевание паллеты:\n" + enWrapMode.ToString(), "Смена параметра", true);
SetWrapp();
break;
case AppC.F_QUIT:
EndEditB(true);
break;
case AppC.F_MARKWMS:
EndEditB(false);
break;
default:
nFunc = 0;
ret = false;
break;
}
}
if ((nFunc <= 0) && (ret == false))
{// для режима редактирования
ret = true;
switch (e.KeyValue)
{
case W32.VK_UP:
aEd.TryNext(AppC.CC_PREV);
break;
case W32.VK_DOWN:
aEd.TryNext(AppC.CC_NEXT);
break;
case W32.VK_ENTER:
aEd.TryNext(AppC.CC_NEXTOVER);
break;
case W32.VK_ESC:
//EndEditB(false);
break;
case W32.VK_LEFT:
case W32.VK_RIGHT:
if (
(((aEd.Current == tEmk) || (aEd.Current == tParty) || tVsego.Enabled) &&
(xMark.ScanFirst.xEmks.Count > 1) &&
(aEd.Current != tSSCC))
)
{
StrAndInt xS = null;
if (xMark.ScanFirst.xEmks.Current == null)
{
xS = xMark.ScanFirst.xEmks.MoveEx(Srv.Collect4Show <StrAndInt> .DIR_MOVE.FORWARD);
}
else
{
if (e.KeyValue == W32.VK_LEFT)
{
xS = xMark.ScanFirst.xEmks.MoveEx(Srv.Collect4Show <StrAndInt> .DIR_MOVE.BACK);
}
else
{
xS = xMark.ScanFirst.xEmks.MoveEx(Srv.Collect4Show <StrAndInt> .DIR_MOVE.FORWARD);
}
}
//if (scCur.xEmks.Current != null)
//{
xMark.ScanFirst.fEmk = xS.DecDat;
xMark.ScanFirst.nTara = xS.SNameAdd1;
xMark.ScanFirst.nKolSht = xS.IntCodeAdd1;
//xMark.ScanFirst.nMestPal = xMark.ScanFirst.nMest = xS.IntCode;
//tEmk.Text = xMark.ScanFirst.fEmk.ToString();
EvalTot(xMark.ScanFirst.nMest);
this.tEmk.Text = ((xMark.ScanFirst.bVes) ? xMark.ScanFirst.nKolSht : (int)xMark.ScanFirst.fEmk).ToString();
//tVsego.Text = xMark.ScanFirst.fVsego.ToString();
//}
ret = true;
}
break;
default:
ret = false;
break;
}
}
e.Handled = bSkipKey = ret;
}
// Корректность введенного
private AppC.VerRet VerifyB()
{
string
sSavedNom = tNomPoddon.Text;
int
n = 0;
AppC.VerRet
v;
DialogResult dRez;
v.nRet = AppC.RC_CANCEL;
try
{
//if (!bDocIsKMPL)
//{
// if (tSSCC.Text.Length == 20)
// v.nRet = AppC.RC_OK;
// v.cWhereFocus = null;
// return (v);
//}
if (tSSCC.Text.Length == 20)
{
if (!bDocIsKMPL)
{
v.nRet = AppC.RC_OK;
n = 1;
}
else
{
n = int.Parse(tNomPoddon.Text);
if (!xMF.xCDoc.xNPs.ContainsKey(n))
{
if (n > 0)
{
if (!xMF.xCDoc.bFreeKMPL)
{
dRez = MessageBox.Show("Отменить (Enter)?\n(ESC)-добавить №",
String.Format("Поддона №{0} нет!", n),
MessageBoxButtons.OKCancel,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
n = (dRez != DialogResult.OK) ? n : 0;
}
if (n > 0)
{
xMF.xCDoc.xNPs.Add(n, new PoddonInfo());
v.nRet = AppC.RC_OK;
}
}
}
else
{
v.nRet = AppC.RC_OK;
}
}
}
else
{
n = 1;
Srv.ErrorMsg("Нет SSCC!");
}
}
catch
{
n = 0;
}
if (n == 0)
{
Srv.ErrorMsg("Нет такого номера!");
}
v.cWhereFocus = null;
tNomPoddon.Text = sSavedNom;
return(v);
}
private void LoadAllSSCC()
{
int
nRet = AppC.RC_OK,
nK,
nRezCtrl;
string
sE,
sSSCC = "";
PSC_Types.ScDat
scD = scCur;
ServerExchange
xSE = new ServerExchange(this);
DelTTN4Doc(xCDoc.drCurRow);
DataRow[] drSSCCAll = xCDoc.drCurRow.GetChildRows(xNSI.dsM.Relations[NSI.REL2SSCC]);
foreach (DataRow drSSCC in drSSCCAll)
{
if ((int)drSSCC["IN_TTN"] > 0)
{
sSSCC = (string)drSSCC["SSCC"];
nRet = ConvertSSCC2Lst(xSE, sSSCC, ref scD, false);
if ((nRet == AppC.RC_OK) || (nRet == AppC.RC_MANYEAN))
{
//if (nRet == AppC.RC_MANYEAN)
// nRet = AddGroupDet(AppC.RC_MANYEAN, (int)NSI.SRCDET.SSCCT, sSSCC);
nRet = AddGroupDet(AppC.RC_MANYEAN, (int)NSI.SRCDET.SSCCT, sSSCC, false);
}
if (nRet != AppC.RC_OK)
{
Srv.ErrorMsg("Ошибка загрузки " + sSSCC, "Код-" + nRet.ToString(), true);
DelTTN4Doc(xCDoc.drCurRow);
break;
}
}
}
if (nRet == AppC.RC_OK)
{
if (bZVKPresent)
{
Cursor.Current = Cursors.WaitCursor;
xNSI.DT[NSI.BD_DIND].dt.AcceptChanges();
List <DataRow>
lDD = new List <DataRow>();
DataView
dvZ = new DataView(xNSI.DT[NSI.BD_DIND].dt, xCDoc.DefDetFilter(), "KMC", DataViewRowState.CurrentRows);
//for (int i = 0; i < dvZ.Count; i++)
//{
// if ( PSC_Types.IsTara((string)dvZ[i].Row["EAN13"], (int)dvZ[i].Row["KRKMC"]) )
// {
// lDD.Add(dvZ[i].Row);
// dvZ[i].Row.Delete();
// }
//}
foreach (DataRowView drv in dvZ)
{
if (PSC_Types.IsTara((string)drv.Row["EAN13"], (int)drv.Row["KRKMC"]))
{
lDD.Add(drv.Row);
drv.Row.Delete();
}
}
try
{
xInf = new List <string>();
nRezCtrl = ControlDocZVK(null, xInf, "");
}
finally
{
Cursor.Current = Cursors.Default;
foreach (DataRow dr in lDD)
{
dr.RejectChanges();
}
}
xHelpS.ShowInfo(xInf, ref ehCurrFunc);
}
}
}
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);
}
public int ProceedSSCC(ScanVarGP xSc, ref PSC_Types.ScDat scD, ServerExchange xSE)
{
int
ret = AppC.RC_OK; // по умолчанию - обработку скана заканчиваем
bool
bExt,
bCallExch = false,
bMaySet = true;
string
sSSCC = "";
DataRow
dr = null;
RowObj
xR;
DialogResult
dRez;
//ServerExchange
// xSE = new ServerExchange(this);
if (xSE == null)
{
xSE = new ServerExchange(this);
bCallExch = true;
}
// Внешние SSCC
bExt = ((xSc.bcFlags & ScanVarGP.BCTyp.SP_SSCC_EXT) > 0) ? true : false;
sSSCC =
scD.sSSCC =
xCDoc.xOper.SSCC = xSc.Dat;
if (bCallExch)
{
ret = ConvertSSCC2Lst(xSE, xSc.Dat, ref scD, false);
}
else
{
ret = (xCLoad.dtZ.Rows.Count == 1) ? AppC.RC_OK : AppC.RC_MANYEAN;
}
if (xSE.AnswerPars.ContainsKey("ADRCELL"))
{
AddrInfo xA = new AddrInfo(xSE.AnswerPars["ADRCELL"], xSm.nSklad);
if (xA.Addr.Length > 0)
{
if (!xCDoc.xOper.IsFillSrc())
{
xCDoc.xOper.SetOperSrc(xA, xCDoc.xDocP.nTypD, true);
}
}
}
switch (xCDoc.xDocP.TypOper)
{
case AppC.TYPOP_PRMK:
case AppC.TYPOP_MARK:
if (!bExt && (xCDoc.xDocP.TypOper == AppC.TYPOP_MARK))
{
// будет маркировка сборного поддона
dr = AddDetSSCC(xSc, xCDoc.nId, ScanVarGP.BCTyp.SP_SSCC_INT, "");
if (dr != null)
{
drDet = dr;
}
break;
}
if (drDet != null)
{
xR = new RowObj(drDet);
if (xR.IsSSCC)
{
dRez = MessageBox.Show(
String.Format("SSCC={0}\nОтменить (Enter)?\n(ESC)-изменить SSCC", xR.sSSCC),
"Уже маркирован!", MessageBoxButtons.OKCancel,
MessageBoxIcon.Question, MessageBoxDefaultButton.Button1);
bMaySet = (dRez == DialogResult.OK) ? false : true;
}
if (bMaySet)
{
drDet["SSCC"] = xSc.Dat;
SetOverOPR(false, drDet);
}
}
break;
case AppC.TYPOP_MOVE:
// операция перемещения
if (!xCDoc.xOper.IsFillSrc() && !xCDoc.xOper.IsFillDst() &&
(xSm.xAdrFix1 == null))
{
Srv.ErrorMsg("Адрес не указан!", true);
return(ret);
}
if ((ret == AppC.RC_OK) || (ret == AppC.RC_MANYEAN))
{
if (xCLoad.dtZ.Rows.Count == 1)
{ // однородный поддон
if (xCDoc.xOper.IsFillSrc() && ((xCDoc.xOper.xAdrSrc.nType & ADR_TYPE.SSCC) > 0))
{
Srv.ErrorMsg("SSCC-Адрес недопустим!", true);
break;
}
else
{
// 090.08.18
//AddDet1(ref scD, out dr);
ret = AppC.RC_WARN;
}
}
else
{ // сборный поддон идет одной строкой
dr = AddDetSSCC(xSc, xCDoc.nId, ScanVarGP.BCTyp.SP_SSCC_EXT, "");
if (dr is DataRow)
{
ret = AppC.RC_OK;
if (AppPars.ShowSSCC)
{
ShowSSCCContent(xCLoad.dtZ, xSc.Dat, xSE, xCDoc.xOper.xAdrSrc, ref ehCurrFunc);
}
}
}
}
else
{ // получить расшифровку SSCC от сервера не удалось
if ((xSE.ServerRet == AppC.EMPTY_INT) ||
(xSE.ServerRet == AppC.RC_OK))
{ // но это не ошибка на сервере, возможно, сетевая ошибка
dr = AddDetSSCC(xSc, xCDoc.nId, ScanVarGP.BCTyp.SP_SSCC_EXT, "");
ret = AppC.RC_OK;
}
}
if (dr != null)
{
drDet = dr;
}
//IsOperReady(dr);
IsOperReady();
break;
case AppC.TYPOP_DOCUM:
case AppC.TYPOP_KMPL:
// документ или комплектация
if ((!xCDoc.xOper.IsFillSrc() &&
(xPars.UseAdr4DocMode) &&
(AppC.xDocTInf[xCDoc.xDocP.nTypD].MoveType == AppC.MOVTYPE.RASHOD)))
{
Srv.ErrorMsg("Адрес не указан!", true);
return(ret);
}
if (ret == AppC.RC_OK)
{
if (xCLoad.dtZ.Rows.Count == 1)
{ // монопаллет, продолжается обычная обработка скана
if (!bCallExch)
{
AddDet1(ref scD, out dr);
}
else
{
ret = AppC.RC_WARN;
}
}
}
else if (ret == AppC.RC_MANYEAN)
{ // для сборного поддона
if (AppC.xDocTInf[xCDoc.xDocP.nTypD].MoveType == AppC.MOVTYPE.AVAIL)
{
// в инвентаризацию - добавление без запроса
ret = AddGroupDet(ret, (int)NSI.SRCDET.SSCCT, xSc.Dat);
}
else
{
if (AppPars.ShowSSCC)
{
WaitScan4Func(AppC.F_CNTSSCC, "Содержимое SSCC", "Отсканируйте SSCC", xSc);
}
}
// в любом случае обработку скана заканчиваем
ret = AppC.RC_OK;
}
break;
case AppC.TYPOP_OTGR:
ret = SSCC4OTG(xSE, xSc, ref scD, (bExt) ? ScanVarGP.BCTyp.SP_SSCC_EXT :
ScanVarGP.BCTyp.SP_SSCC_INT);
break;
}
return(ret);
}
private void SetFilterOnSSCCC(bool bSetOnePoddon)
{
int
nRet;
string
sFP = "",
sRf,
sSSCC = "";
DataRow
drZ;
DataView
dvM;
dgDet.SuspendLayout();
try
{
if (tcMain.SelectedIndex == PG_SCAN)
{
// циклическое переключение на следующий режим (установка/сброс)
if (bSetOnePoddon)
{// выполняется установка
try
{
if (bShowTTN == false)
{// пока в заявке, но найдем в ТТН
drZ = drDet;
sRf = xCDoc.DefDetFilter() + String.Format("AND(KMC='{0}')", (string)drDet["KMC"]);
dvM = new DataView(xNSI.DT[NSI.BD_DOUTD].dt, sRf, "", DataViewRowState.CurrentRows);
if (dvM.Count > 0)
{
ChgDetTable(dvM[0].Row, NSI.BD_DOUTD);
}
else
{
Srv.ErrorMsg(String.Format("Код {} в ТТН не найден!", drZ["KRKMC"]), true);
}
}
sSSCC = (string)drDet["SSCC"];
if (sSSCC.Length > 0)
{
sFP = String.Format("AND(SSCC={0})", sSSCC);
}
else
{
sFP = "AND(LEN(SSCC)=0)";
}
}
catch { }
xNSI.DT[NSI.BD_DOUTD].sTFilt = sFP;
xSm.FilterTTN = NSI.FILTRDET.SSCC;
Srv.ErrorMsg(String.Format("Установлен для:\nSSCC='{0}'", sSSCC), "Фильтр по SSCC", false);
}
else
{// выполняется сброс
xNSI.DT[NSI.BD_DOUTD].sTFilt = "";
xSm.FilterTTN = NSI.FILTRDET.UNFILTERED;
Srv.ErrorMsg("Сброшен!", "Фильтр по SSCC", false);
}
//xNSI.DT[NSI.BD_DOUTD].dt.DefaultView.RowFilter = xCDoc.DefDetFilter() + xNSI.DT[NSI.BD_DOUTD].sTFilt;
sFP =
xCDoc.DefDetFilter() + xNSI.DT[NSI.BD_DOUTD].sTFilt;
xNSI.DT[NSI.BD_DOUTD].dt.DefaultView.RowFilter = sFP;
ShowStatDoc();
xNSI.SortName(bShowTTN, ref sFP);
lSortInf.Text = sFP;
}
}
catch { }
finally
{
dgDet.ResumeLayout();
}
}
