1588 lines
51 KiB
C#
1588 lines
51 KiB
C#
/*********************************************************************************************
|
|
* Copyright 2004 - Volian Enterprises, Inc. All rights reserved.
|
|
* Volian Enterprises - Proprietary Information - DO NOT COPY OR DISTRIBUTE
|
|
* ------------------------------------------------------------------------------
|
|
* $Workfile: Proc.cs $ $Revision: 26 $
|
|
* $Author: Jsj $ $Date: 9/25/06 2:08p $
|
|
*
|
|
* $History: Proc.cs $
|
|
*
|
|
* ***************** Version 26 *****************
|
|
* User: Jsj Date: 9/25/06 Time: 2:08p
|
|
* Updated in $/LibSource/VEObject
|
|
* allow user to move a procedure in the approved list
|
|
*
|
|
* ***************** Version 25 *****************
|
|
* User: Jsj Date: 8/30/06 Time: 10:04a
|
|
* Updated in $/LibSource/VEObject
|
|
* Added Multi Procedure Data Checker
|
|
*
|
|
* ***************** Version 24 *****************
|
|
* User: Kathy Date: 5/01/06 Time: 11:17a
|
|
* Updated in $/LibSource/VEObject
|
|
* Fix B2006-018: single quote in proc number causes problem on data
|
|
* request
|
|
*
|
|
* ***************** Version 23 *****************
|
|
* User: Kathy Date: 2/23/06 Time: 10:52a
|
|
* Updated in $/LibSource/VEObject
|
|
* Fix B2006-006, use actual database field for column mode in set file
|
|
* during approve selected. Also, don't crash on saving of column mode
|
|
* from procedure properties if value was null
|
|
*
|
|
* ***************** Version 22 *****************
|
|
* User: Kathy Date: 8/16/05 Time: 2:56p
|
|
* Updated in $/LibSource/VEObject
|
|
* B2005-030: error if missing ndx
|
|
*
|
|
* ***************** Version 21 *****************
|
|
* User: Kathy Date: 7/28/05 Time: 2:08p
|
|
* Updated in $/LibSource/VEObject
|
|
* for mod proc number, copy data into/from correct file number for
|
|
* approve ind
|
|
*
|
|
* ***************** Version 20 *****************
|
|
* User: Kathy Date: 7/18/05 Time: 10:55a
|
|
* Updated in $/LibSource/VEObject
|
|
* Lib doc transition reference may be upper or lower case
|
|
*
|
|
* ***************** Version 19 *****************
|
|
* User: Kathy Date: 6/21/05 Time: 7:25a
|
|
* Updated in $/LibSource/VEObject
|
|
* clear variable for edit from approve
|
|
*
|
|
* ***************** Version 18 *****************
|
|
* User: Kathy Date: 5/25/05 Time: 10:32a
|
|
* Updated in $/LibSource/VEObject
|
|
* Allow edits for tmpchg
|
|
*
|
|
* ***************** Version 17 *****************
|
|
* User: Kathy Date: 5/19/05 Time: 11:07a
|
|
* Updated in $/LibSource/VEObject
|
|
* speed up approve
|
|
*
|
|
* ***************** Version 16 *****************
|
|
* User: Kathy Date: 5/11/05 Time: 9:29a
|
|
* Updated in $/LibSource/VEObject
|
|
* approve all selectinto
|
|
*
|
|
* ***************** Version 15 *****************
|
|
* User: Kathy Date: 4/26/05 Time: 10:23a
|
|
* Updated in $/LibSource/VEObject
|
|
* Check for dbnull on dates
|
|
*
|
|
* ***************** Version 14 *****************
|
|
* User: Kathy Date: 4/21/05 Time: 10:22a
|
|
* Updated in $/LibSource/VEObject
|
|
* remove upgrade2005 define
|
|
*
|
|
* ***************** Version 13 *****************
|
|
* User: Jsj Date: 4/15/05 Time: 9:44a
|
|
* Updated in $/LibSource/VEObject
|
|
* added check to see if proc number exists in set file before adding to
|
|
* dependency list
|
|
*
|
|
* ***************** Version 12 *****************
|
|
* User: Jsj Date: 4/08/05 Time: 10:55a
|
|
* Updated in $/LibSource/VEObject
|
|
* comment about enabling slave proc number/title changes
|
|
*
|
|
* ***************** Version 11 *****************
|
|
* User: Jsj Date: 4/07/05 Time: 11:17a
|
|
* Updated in $/LibSource/VEObject
|
|
* Unit Specific call
|
|
*
|
|
* ***************** Version 10 *****************
|
|
* User: Kathy Date: 3/22/05 Time: 10:03a
|
|
* Updated in $/LibSource/VEObject
|
|
* Remove chgbar
|
|
*
|
|
* ***************** Version 9 *****************
|
|
* User: Kathy Date: 3/08/05 Time: 1:50p
|
|
* Updated in $/LibSource/VEObject
|
|
* Approval
|
|
*
|
|
* ***************** Version 8 *****************
|
|
* User: Kathy Date: 1/31/05 Time: 11:06a
|
|
* Updated in $/LibSource/VEObject
|
|
* Fix B2005-005 (connection & delete directory errors). also, fix icon
|
|
*
|
|
* ***************** Version 7 *****************
|
|
* User: Kathy Date: 11/12/04 Time: 8:43a
|
|
* Updated in $/LibSource/VEObject
|
|
* B2004-056: no date update on set file record when procedure data change
|
|
*
|
|
* ***************** Version 6 *****************
|
|
* User: Jsj Date: 8/20/04 Time: 9:02a
|
|
* Updated in $/LibSource/VEObject
|
|
* Disable the main form when we spawn off to VFW.EXE so the user cannot
|
|
* select a different tree node while we are bringing up the procedure
|
|
* editor.
|
|
*
|
|
* ***************** Version 5 *****************
|
|
* User: Jsj Date: 8/19/04 Time: 11:37a
|
|
* Updated in $/LibSource/VEObject
|
|
* fixed typo in transition usage message displayed when trying to delete
|
|
* a procedure
|
|
*
|
|
* ***************** Version 4 *****************
|
|
* User: Jsj Date: 8/16/04 Time: 4:23p
|
|
* Updated in $/LibSource/VEObject
|
|
* RECID not incremented inserting new procdure
|
|
*
|
|
* ***************** Version 3 *****************
|
|
* User: Kathy Date: 8/10/04 Time: 3:42p
|
|
* Updated in $/LibSource/VEObject
|
|
* duplicate file names on new proc & proc has wrong rec ids on new
|
|
*
|
|
* ***************** Version 2 *****************
|
|
* User: Kathy Date: 8/04/04 Time: 11:12a
|
|
* Updated in $/LibSource/VEObject
|
|
* stop two vfw sessions from spawning on quick 2 double clicks
|
|
*
|
|
* ***************** Version 1 *****************
|
|
* User: Kathy Date: 7/27/04 Time: 8:53a
|
|
* Created in $/LibSource/VEObject
|
|
*********************************************************************************************/
|
|
|
|
using System;
|
|
using System.Windows.Forms;
|
|
using System.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Text;
|
|
using System.Data;
|
|
using System.IO;
|
|
using System.Messaging;
|
|
using System.Runtime.InteropServices;
|
|
using System.Collections;
|
|
using Utils;
|
|
using VDB;
|
|
using VDB_Proc;
|
|
using VDB_Set;
|
|
using VDB_TransUsage;
|
|
using VDB_ROUsage;
|
|
using VEMessageNS;
|
|
using ROFST_FILE;
|
|
|
|
namespace VEObject
|
|
{
|
|
/// <summary>
|
|
/// VEO_Proc support procedure functionality
|
|
/// </summary>
|
|
public class VEO_Proc: VEO_Base
|
|
{
|
|
public VEO_ProcExt procExt;
|
|
public string origDate;
|
|
public string origTime;
|
|
public string _Prcnum;
|
|
public string recid;
|
|
public ProcColumnOptions _ProcColumn;
|
|
public string _ProcCode;
|
|
public string origProcCode;
|
|
public DataRow pdatarow; // row from set file.
|
|
private string[] DBExtensions={"DBF","DBT","NDX","SCR","FIX","APL","PGN","TCX","LLF","RTF","INF"};
|
|
private bool[] AppExtensions={false,false,false,false,true,false,true,false,false,false,true};
|
|
public string _ModInfo;
|
|
protected string tmpTitle;
|
|
protected string tmpProcNum;
|
|
protected ProcColumnOptions tmpProcCol;
|
|
protected bool changeProcNum;
|
|
protected bool changeTitle;
|
|
protected bool changeProcCol;
|
|
private string PrevDirectory;
|
|
private Process myProcess;
|
|
private Form mainForm;
|
|
private bool activeEdit; // flag that vfw is currently being brought up - don't do twice, if delay
|
|
|
|
public VEO_Proc(string ilocaltitle, string ipath, string iprcnum, string irecid, VEO_Base.ProcColumnOptions format, string iprccode, DataRow dr, VEO_DummySet dset, bool inew)
|
|
{
|
|
activeEdit=false;
|
|
iconStates = new int[5] {26,26,26,26,26};
|
|
procExt=null;
|
|
_Title = ilocaltitle;
|
|
_Location = ipath;
|
|
_Prcnum = iprcnum;
|
|
_ProcCode = iprccode;
|
|
origProcCode = _ProcCode;
|
|
_ProcColumn=(VEO_Base.ProcColumnOptions)format;
|
|
recid = irecid;
|
|
pdatarow = dr;
|
|
parentObj = dset;
|
|
|
|
usrRunTime = dset.usrRunTime;
|
|
if(!inew)
|
|
{
|
|
if (dr["DATE"] is System.DBNull)
|
|
{
|
|
origDate = null;
|
|
origTime = null;
|
|
}
|
|
else
|
|
{
|
|
origDate = dr["DATE"].ToString().PadRight(8,' ');
|
|
origTime = dr["TIME"].ToString().PadRight(5,' ');
|
|
}
|
|
SetModString(dr["INITIALS"].ToString(),origDate,origTime);
|
|
DTI.SetDateTimeInit=origDate+origTime+dr["INITIALS"].ToString().PadRight(5,' ');
|
|
}
|
|
isNew = inew;
|
|
changeProcNum=false;
|
|
changeTitle=false;
|
|
changeProcCol=false;
|
|
VEObjectType = (int)VEObjectTypesDefs.Procedure;
|
|
LoadLockInfo();
|
|
icon = iconStates[(int) Lock.LockStatus];
|
|
}
|
|
|
|
[Description("FileName"),Category("Procedure"),ReadOnly(true)]public string File_Name
|
|
{
|
|
get{return _Location;}
|
|
set{_Location=value;}
|
|
}
|
|
|
|
[Description("Modification Information"),Category("Procedure"),ReadOnly(true)]public string Modification_Information
|
|
{
|
|
get{return _ModInfo;}
|
|
set{_ModInfo=value;}
|
|
}
|
|
|
|
[Description("Procedure Number"),Category("Procedure"),EditorAttribute(typeof(VESymbDlg), typeof(System.Drawing.Design.UITypeEditor))]public string Procedure_Number
|
|
{
|
|
get
|
|
{
|
|
if(!changeProcNum)
|
|
return _Prcnum;
|
|
else
|
|
return tmpProcNum;
|
|
}
|
|
set
|
|
{
|
|
changeProcNum=true;
|
|
tmpProcNum=value;
|
|
}
|
|
}
|
|
|
|
[Description("Procedure Title"),Category("Procedure"),EditorAttribute(typeof(VESymbDlg), typeof(System.Drawing.Design.UITypeEditor))]public string Title
|
|
{
|
|
get
|
|
{
|
|
if (!changeTitle)
|
|
return _Title;
|
|
else
|
|
return tmpTitle;
|
|
}
|
|
set
|
|
{
|
|
changeTitle=true;
|
|
tmpTitle=value;
|
|
}
|
|
}
|
|
|
|
[Description("Format"),Category("Procedure")]public ProcColumnOptions Procedure_Column
|
|
{
|
|
get
|
|
{
|
|
if(!changeProcCol)
|
|
return _ProcColumn;
|
|
else
|
|
return tmpProcCol;
|
|
}
|
|
set
|
|
{
|
|
changeProcCol=true;
|
|
tmpProcCol=value;
|
|
}
|
|
}
|
|
|
|
private void SetModString(string person, string sdt, string tm)
|
|
{
|
|
string outtm=null;
|
|
string outdt=null;
|
|
DateTime dt;
|
|
if (tm!=null && tm!="")outtm=tm.Substring(0,2)+":"+tm.Substring(2,2);
|
|
if (sdt !=null && sdt != "")
|
|
{
|
|
dt = System.Convert.ToDateTime(sdt);
|
|
outdt = dt.ToShortDateString();
|
|
}
|
|
_ModInfo = person + " " + outdt + " " + outtm;
|
|
}
|
|
|
|
private bool IsInSet(string fname)
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_Proc prc = null;
|
|
foreach (Object chld in ds.Children)
|
|
{
|
|
prc = (VEO_Proc)chld;
|
|
if (prc._Location == fname)return true;
|
|
}
|
|
return false;
|
|
}
|
|
private void SetUpNewFileName()
|
|
{
|
|
int i=0;
|
|
StringBuilder newname = new StringBuilder();
|
|
if(!isOpen) Open();
|
|
while(i==0 || (File.Exists(newname.ToString())||IsInSet(newname.ToString())))
|
|
{
|
|
newname.Remove(0,newname.Length);
|
|
newname.Append("PROC");
|
|
string tmp = i.ToString();
|
|
newname.Append(i.ToString("d3"));
|
|
newname.Append(".dbf");
|
|
i++;
|
|
}
|
|
this._Location = newname.ToString().Substring(0,7);
|
|
}
|
|
|
|
public override bool PropertiesDlg(Object parent)
|
|
{
|
|
bool retval = false;
|
|
PrcProperties propdlg;
|
|
if (isNew) SetUpNewFileName();
|
|
propdlg = new PrcProperties(parent, this, procExt);
|
|
if (propdlg.ShowDialog() == DialogResult.OK)
|
|
{
|
|
SetModString(pdatarow["INITIALS"].ToString(),pdatarow["DATE"].ToString(),pdatarow["TIME"].ToString());
|
|
retval=true;
|
|
}
|
|
else this.Restore();
|
|
propdlg = null;
|
|
return retval;
|
|
}
|
|
|
|
public override void Restore()
|
|
{
|
|
changeProcNum=false;
|
|
changeTitle=false;
|
|
changeProcCol=false;
|
|
}
|
|
|
|
public override string GetTreeNodeText()
|
|
{
|
|
VEO_DummySet dset = (VEO_DummySet) this.parentObj;
|
|
string UnitSpecPrcNum = ROFST_FILE.ROProcessTools.UnitSpecific(Procedure_Number,0,0,dset.LargestNumber);
|
|
// return Procedure_Number + " " + Title;
|
|
return UnitSpecPrcNum + " " + Title;
|
|
}
|
|
|
|
public override bool Open()
|
|
{
|
|
isOpen = true;
|
|
PrevDirectory = Directory.GetCurrentDirectory();
|
|
VEO_DummySet ps = (VEO_DummySet) this.parentObj;
|
|
Directory.SetCurrentDirectory(ps._Location);
|
|
return true;
|
|
}
|
|
|
|
// The close method resets, if necessary from any multi-user settings and
|
|
// positions back to the datapath directory (which is a level above the
|
|
// current level)
|
|
public override bool Close()
|
|
{
|
|
isOpen = false;
|
|
Directory.SetCurrentDirectory(PrevDirectory);
|
|
return true;
|
|
}
|
|
|
|
|
|
#if Upgrade2005_Print
|
|
public override bool Read(bool ChkForChldOnly)
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
string pth = ps._curDirectory + "\\" + ps._Location + "\\" + this._Location + ".dbf";
|
|
if (ChkForChldOnly)
|
|
{
|
|
try
|
|
{
|
|
// vdb_Proc dbprc = new vdb_Proc(pth);
|
|
// int cnt = dbprc.GetCount("WHERE [SEQUENCE] like ' %'");
|
|
// if (cnt>0)
|
|
// {
|
|
VEO_Section sct = new VEO_Section("XX", "XXXX", "TEMP", "XX", "0XXXXXXX"); //, this, true);
|
|
this.Children.Add(sct);
|
|
// }
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Could not get count of sections " + e.Message);
|
|
return false;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
vdb_Proc dbprc = new vdb_Proc(pth);
|
|
DataSet sectset = dbprc.GetSortedByStepSeqType("WHERE [SEQUENCE] like ' %'");
|
|
/* see if in order, assuming they are because of get sorted query.. */
|
|
foreach (DataRow row in sectset.Tables[0].Rows)
|
|
{
|
|
// get properties of section & then create a section.
|
|
string Step = row["STEP"].ToString();
|
|
string Sequence = row["SEQUENCE"].ToString();
|
|
string Txt = row["TEXT"].ToString();
|
|
string Type = row["TYPE"].ToString();
|
|
string RecID = row["RECID"].ToString();
|
|
VEO_Section sct = new VEO_Section(Step, Sequence, Txt, Type, RecID, this, false);
|
|
Children.Add(sct);
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Error reading sections for " + this._Prcnum + ", " + e.Message);
|
|
return false;
|
|
}
|
|
}
|
|
#else
|
|
public override bool Read(bool dummy)
|
|
{
|
|
//load procs from set.dbf
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
public override bool EditNode()
|
|
{
|
|
if(!isOpen) Open();
|
|
if (!activeEdit)
|
|
{
|
|
ExecVfw(null);
|
|
activeEdit=true;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public void ExecVfw(string appendarg)
|
|
{
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.Append("/c start /separate /w ");
|
|
sb.Append(this.usrRunTime.ExeAdjust("@vfw.exe"));
|
|
sb.Append(" /u-");
|
|
sb.Append(this.usrRunTime.UserID); //user login/initials
|
|
sb.Append(" -o");
|
|
sb.Append(this.usrRunTime.sec.userid.ToString());
|
|
sb.Append(" -i"); // do initials
|
|
sb.Append(this.usrRunTime.sec.initials);
|
|
sb.Append(" -s\"");
|
|
sb.Append(this.usrRunTime.syspath);
|
|
sb.Append("\\vesam.opt\" -w");
|
|
sb.Append(System.Convert.ToString(VEMessage.Handle_16bit,16));
|
|
if (appendarg !=null && appendarg=="t")
|
|
sb.Append(" -t");
|
|
else if (appendarg !=null && appendarg=="a")
|
|
sb.Append(" -a");
|
|
|
|
sb.Append(" -new");
|
|
|
|
// execute vfw using cmd because process was not creating the vfw process in
|
|
// its own memory space, i.e. only one copy of vfw came up even if two browsers
|
|
// tried to spawn it.
|
|
myProcess = new Process();
|
|
myProcess.StartInfo.WindowStyle = System.Diagnostics.ProcessWindowStyle.Hidden;
|
|
myProcess.StartInfo.FileName = "cmd";
|
|
myProcess.StartInfo.Arguments = sb.ToString();
|
|
myProcess.StartInfo.UseShellExecute = true;
|
|
myProcess.EnableRaisingEvents = true;
|
|
myProcess.Exited += new System.EventHandler(MyExitFunc);
|
|
// When vfw exits, 'MyExitFunc' method gets called from the above eventhandler
|
|
// where form is made visible again & locking/connecting is checked.
|
|
|
|
try
|
|
{
|
|
IntPtr handle =
|
|
System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle;
|
|
mainForm = (Form)Form.FromHandle(handle);
|
|
mainForm.Enabled = false;
|
|
|
|
myProcess.Start();
|
|
}
|
|
catch (Win32Exception e)
|
|
{
|
|
MessageBox.Show(e.Message + ". Error on load of vfw.");
|
|
}
|
|
}
|
|
|
|
private void MyExitFunc(object sender, System.EventArgs e)
|
|
{
|
|
mainForm.Visible = true;
|
|
mainForm.Enabled = true;
|
|
TreeView tv = null;
|
|
foreach (Control ctl in mainForm.Controls)
|
|
{
|
|
if (ctl is TreeView) tv = (TreeView)ctl;
|
|
}
|
|
if (tv != null) tv.Focus();
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
// enter the connection (reenter). This will check for changes in locking, etc.
|
|
ps.Connection.Enter(false);
|
|
if (ps.Lock.LockStatus==VENetwork.Status.LockPending) ps.Lock.LockStatus=VENetwork.Status.Locked;
|
|
ps.icon = ps.iconStates[(int)ps.Lock.LockStatus];
|
|
ps.treeNode.ImageIndex = ps.icon;
|
|
ps.treeNode.SelectedImageIndex = ps.icon;
|
|
mainForm = null;
|
|
activeEdit=false;
|
|
ps.AppSelForEdit=null;
|
|
}
|
|
|
|
// see if the procedure can be deleted...
|
|
private bool canDelete()
|
|
{
|
|
// check for transitions to this procedure. If they exist, make
|
|
// up a search result list & use vfw to resolve.
|
|
VEO_DummySet pds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) pds.parentObj;
|
|
string pth = ps._curDirectory+"\\"+ps.Location+"\\tran.dbf";
|
|
vdb_TransUsage transusg = new vdb_TransUsage(pth);
|
|
DataSet ds = transusg.GetSortedByToTrans("[TONUMBER] = \'"+this._Prcnum.Replace("'","''")+"\'");
|
|
if (ds.Tables[0].Rows.Count !=0)
|
|
{
|
|
bool is_ext=false;
|
|
foreach(DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
if (dr["FROMNUMBER"].ToString() != this._Prcnum)
|
|
{
|
|
is_ext=true;
|
|
break;
|
|
}
|
|
}
|
|
if (is_ext)
|
|
{
|
|
MessageBox.Show("Delete Operation failed!\n\nYou need to remove transition references to this procedure.\n\nThe procedure editor will now display with a list of the transition locations.");
|
|
ExecVfw("t");
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool Delete()
|
|
{
|
|
if (!isOpen) Open();
|
|
// first see if the procedure can be deleted (if the procedure has
|
|
// transitions to it, it cannot be deleted). If so, do it.
|
|
if (canDelete()==false) return false;
|
|
|
|
VEO_DummySet pds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) pds.parentObj;
|
|
|
|
//Remove the transitions 'from' in the usage file.
|
|
string pth = ps._curDirectory+"\\"+ps.Location+"\\tran.dbf";
|
|
vdb_TransUsage transusg = new vdb_TransUsage(pth);
|
|
DataSet ds = transusg.GetSortedByFromTrans("[FROMNUMBER] = \'"+this._Prcnum.Replace("'","''")+"\'");
|
|
int ndr = ds.Tables[0].Rows.Count;
|
|
foreach (DataRow dr in ds.Tables[0].Rows) dr.Delete();
|
|
// if deleted any, need to save data & pack database
|
|
if (ndr>0)
|
|
{
|
|
transusg.DB_Data = ds.Tables[0].DataSet;
|
|
transusg.Pack();
|
|
}
|
|
|
|
// now, do the same for RO references
|
|
pth = ps._curDirectory+"\\"+ps.Location+"\\usagero.dbf";
|
|
vdb_ROUsage rousg = new vdb_ROUsage(pth);
|
|
ds = rousg.GetSortedByProc("[NUMBER] = \'"+this._Prcnum.Replace("'","''")+"\'");
|
|
ndr = ds.Tables[0].Rows.Count;
|
|
foreach (DataRow dr in ds.Tables[0].Rows)dr.Delete();
|
|
if (ndr>0)
|
|
{
|
|
rousg.DB_Data = ds.Tables[0].DataSet;
|
|
rousg.Pack();
|
|
}
|
|
|
|
// remove procedure files & related rtffiles
|
|
foreach(string str in DBExtensions)
|
|
{
|
|
// status update function - count);
|
|
string filename = pds._Location + "\\" + this._Location + "." + str;
|
|
if (File.Exists(filename)) File.Delete(filename);
|
|
}
|
|
RemoveAccessoryFiles(this._Location,"wpfiles");
|
|
RemoveAccessoryFiles(this._Location,"rtffiles");
|
|
|
|
// delete the record if the above goes ok.
|
|
pdatarow.Delete();
|
|
VEO_DummySet dset = (VEO_DummySet) this.parentObj;
|
|
dset.vdbSet.DB_Data = pdatarow.Table.DataSet;
|
|
|
|
// if there was a set extension record. Delete it too.
|
|
if(ps.hasExtensions)
|
|
{
|
|
procExt.drow.Delete();
|
|
dset.vdbSetExt.DB_Data = procExt.drow.Table.DataSet;
|
|
procExt=null;
|
|
}
|
|
|
|
// if parent dummy set only has this child, set its icon to empty
|
|
if (dset.Children.Count<=1) IsEmpty = true;
|
|
|
|
// Note that the database is not getting packed - so pack it, and
|
|
// then re-read in the data for the procs (from the parent node).
|
|
int whichone=0;
|
|
for (int i=0;i<dset.Children.Count;i++)
|
|
{
|
|
if (dset.Children[i]==this) break;
|
|
whichone++;
|
|
}
|
|
dset.PackDB(whichone);
|
|
return true;
|
|
}
|
|
|
|
private void RemoveAccessoryFiles(string dbname,string dirpath)
|
|
{
|
|
if(Directory.Exists(dirpath)==false) return;
|
|
string curdir = Directory.GetCurrentDirectory();
|
|
Directory.SetCurrentDirectory(dirpath);
|
|
string path = dbname + ".*";
|
|
string[] filelist = Directory.GetFiles(".",path);
|
|
if (filelist==null) return;
|
|
foreach(string str in filelist)
|
|
{
|
|
File.Delete(str);
|
|
}
|
|
Directory.SetCurrentDirectory(curdir);
|
|
}
|
|
|
|
public override bool Write()
|
|
{
|
|
string oldnumber=null; // these two are used if the proc number changed
|
|
string newnumber=null;
|
|
bool dchange=false;
|
|
bool dchnglarge=false;
|
|
VEO_DummySet dset = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet pset = (VEO_ProcSet) dset.parentObj;
|
|
// use the row stored with the record, reset the fields, and
|
|
// write out to the database if any fields have changed.
|
|
// before, trim fields to max length possible in database &
|
|
// also check for largest string lengths to store in first record,
|
|
// in the 'Number' field.
|
|
if (changeTitle && (string)pdatarow["TITLE"]!=tmpTitle)
|
|
{
|
|
int ptlength = pset.UseLongProcTitles?249:78;
|
|
tmpTitle = tmpTitle.Substring(0,tmpTitle.Length>ptlength?ptlength:tmpTitle.Length);
|
|
pdatarow["TITLE"] = tmpTitle;
|
|
_Title = tmpTitle;
|
|
changeTitle=false;
|
|
dchange=true;
|
|
if (tmpTitle.Length+1 > dset.LargestTitleForMenu)
|
|
{
|
|
dset.LargestTitleForMenu = tmpTitle.Length+1;
|
|
dchnglarge=true;
|
|
}
|
|
}
|
|
if (changeProcNum && (string)pdatarow["NUMBER"]!=tmpProcNum)
|
|
{
|
|
if(tmpProcNum.Length>20) tmpProcNum= tmpProcNum.Substring(0,20);
|
|
oldnumber=_Prcnum;
|
|
newnumber=tmpProcNum;
|
|
pdatarow["NUMBER"] = tmpProcNum;
|
|
_Prcnum = tmpProcNum;
|
|
dchange=true;
|
|
if (tmpProcNum.Length+1 > dset.LargestNumber)
|
|
{
|
|
dset.LargestNumber = tmpProcNum.Length+1;
|
|
dchnglarge=true;
|
|
}
|
|
if ((tmpProcNum.Substring(0,1)!=" ") && tmpProcNum.Length+1>dset.LargestNumberForMenu)
|
|
{
|
|
dset.LargestNumberForMenu = tmpProcNum.Length+1;
|
|
dchnglarge= true;
|
|
}
|
|
}
|
|
|
|
int itmpcol = (int)Procedure_Column+1;
|
|
string stmpcol=itmpcol.ToString();
|
|
// check that the internal temporary column wasn't set to a default value of 2,
|
|
// this is set when the FORMAT field = null or 0. The Browser (and original DMAS)
|
|
// did not look at the format file value PMODE, as it should, to determine
|
|
// the default. This cannot be fixed at this time because during the format files
|
|
// are not read/parsed to get the value of PMODE.
|
|
bool deflt = (pdatarow["FORMAT"] is System.DBNull || (string)pdatarow["FORMAT"]=="0")&&stmpcol=="2";
|
|
bool datadiff=false;
|
|
if (pdatarow["FORMAT"] is System.DBNull)
|
|
{
|
|
if (stmpcol!="2") datadiff=true;
|
|
}
|
|
else
|
|
datadiff = (string)pdatarow["FORMAT"]!=stmpcol;
|
|
|
|
if (changeProcCol && datadiff && !deflt)
|
|
{
|
|
pdatarow["FORMAT"] = stmpcol;
|
|
_ProcColumn=Procedure_Column;
|
|
changeProcCol=false;
|
|
dchange=true;
|
|
}
|
|
|
|
if(origProcCode != _ProcCode)
|
|
{
|
|
pdatarow["PROCCODE"] = _ProcCode;
|
|
dchange=true;
|
|
}
|
|
if(dchange)
|
|
{
|
|
try
|
|
{
|
|
// modify the first record if the largest string length changed.
|
|
if (dchnglarge)
|
|
{
|
|
DataRow recidrow = pdatarow.Table.Rows[0];
|
|
string padstr1 = dset.LargestNumber.ToString("d2").PadLeft(2,'0');
|
|
string padstr2 = dset.LargestNumberForMenu.ToString("d2").PadLeft(2,'0');
|
|
string padstr3 = dset.LargestTitleForMenu.ToString("d2").PadLeft(2,'0');
|
|
recidrow["NUMBER"] = padstr1 + " " + padstr2 + " " + padstr3;
|
|
}
|
|
dset.vdbSet.DB_Data = pdatarow.Table.DataSet;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show(e.Message);
|
|
return false;
|
|
}
|
|
}
|
|
// see if this has a setext to save....
|
|
|
|
if (pset.hasExtensions)
|
|
{
|
|
bool ret = this.procExt.Write(dset);
|
|
if (!ret) return false;
|
|
}
|
|
|
|
// if the procedure number was changed, then need to update usage files
|
|
// with the new procnumber
|
|
if (changeProcNum && (newnumber != oldnumber))
|
|
{
|
|
//Remove the transitions 'from' in the usage file.
|
|
string pth = pset._curDirectory+"\\"+pset.Location+"\\tran.dbf";
|
|
vdb_TransUsage transusg = new vdb_TransUsage(pth);
|
|
transusg.UpdateProcNumber(oldnumber,newnumber);
|
|
transusg=null;
|
|
|
|
pth = pset._curDirectory+"\\"+pset.Location+"\\usagero.dbf";
|
|
vdb_ROUsage rousage = new vdb_ROUsage(pth);
|
|
rousage.UpdateProcNumber(oldnumber,newnumber);
|
|
rousage=null;
|
|
changeProcNum=false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
// Make an initial dummy step.
|
|
static void CreateInitStep(vdb_Proc prc)
|
|
{
|
|
// update the recid
|
|
DataTable tbl = prc.DB_Data.Tables[0];
|
|
DataRow recidrow = tbl.Rows[0];
|
|
string tmprecid = recidrow["RECID"].ToString();
|
|
int irecid = System.Convert.ToInt32(tmprecid.Substring(2,6));
|
|
irecid++;
|
|
tmprecid = tmprecid.Substring(0,2)+irecid.ToString("d6");
|
|
recidrow["RECID"]=tmprecid;
|
|
|
|
// add the new row for the first section
|
|
DataRow pdatarow = tbl.NewRow();
|
|
pdatarow["RECID"] = "00000002";
|
|
pdatarow["STEP"] = "A1";
|
|
pdatarow["SEQUENCE"] = "S";
|
|
pdatarow["TEXT"] = "Dummy Step";
|
|
pdatarow["TYPE"] = "01";
|
|
DateTime tm = System.DateTime.Now;
|
|
pdatarow["DATE"] = tm.ToString("MM/dd/yyyy");
|
|
pdatarow["TIME"] = tm.ToString("HHmm") + ":";
|
|
tbl.Rows.Add(pdatarow);
|
|
prc.DB_Data = pdatarow.Table.DataSet;
|
|
}
|
|
|
|
// Make an initial procedure step section.
|
|
static void CreateInitSection(vdb_Proc prc)
|
|
{
|
|
// update the recid
|
|
DataTable tbl = prc.DB_Data.Tables[0];
|
|
DataRow recidrow = tbl.Rows[0];
|
|
string tmprecid = recidrow["RECID"].ToString();
|
|
int irecid = System.Convert.ToInt32(tmprecid.Substring(2,6));
|
|
irecid++;
|
|
tmprecid = tmprecid.Substring(0,2)+irecid.ToString("d6");
|
|
recidrow["RECID"]=tmprecid;
|
|
|
|
// add the new row for the first section
|
|
DataRow pdatarow = tbl.NewRow();
|
|
pdatarow["RECID"] = "00000001";
|
|
pdatarow["STEP"] = "A0";
|
|
pdatarow["SEQUENCE"] = " 1X";
|
|
pdatarow["TEXT"] = "Procedure Steps";
|
|
pdatarow["TYPE"] = "01";
|
|
DateTime tm = System.DateTime.Now;
|
|
pdatarow["DATE"] = tm.ToString("MM/dd/yyyy");
|
|
pdatarow["TIME"] = tm.ToString("HHmm") + ":";
|
|
tbl.Rows.Add(pdatarow);
|
|
prc.DB_Data = pdatarow.Table.DataSet; //save the changed dataset info
|
|
}
|
|
|
|
// Create a new procedure.
|
|
public override bool SaveNew(string dummy)
|
|
{
|
|
try
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
// check for a valid name.
|
|
// create the new procedure file, create the initial section & initial step.
|
|
vdb_Proc newprc = new vdb_Proc("");
|
|
newprc.CreateTable(this._Location);
|
|
CreateInitSection(newprc); // Make procedure section
|
|
CreateInitStep(newprc); // Add a dummy step
|
|
|
|
// Add the record to the set file.
|
|
DataTable pdatatable = ds.vdbSet.DB_Data.Tables[0];
|
|
DataRow recidrow = pdatatable.Rows[0];
|
|
string currecid = recidrow["RECID"].ToString();
|
|
string tmprecid = currecid;
|
|
int irecid = System.Convert.ToInt32(tmprecid.Substring(2,6));
|
|
irecid++;
|
|
tmprecid = tmprecid.Substring(0,2)+irecid.ToString("d6");
|
|
recidrow["RECID"]=tmprecid;
|
|
pdatarow = pdatatable.NewRow();
|
|
|
|
// check whether to trim the number & title.
|
|
if (Procedure_Number.Length>20)Procedure_Number=Procedure_Number.Substring(0,20);
|
|
if (Title.Length>78)Title=Title.Substring(0,78);
|
|
pdatarow["RECID"] = currecid;
|
|
pdatarow["TITLE"] = Title;
|
|
pdatarow["NUMBER"] = Procedure_Number;
|
|
int itmpcol = (int)Procedure_Column+1;
|
|
pdatarow["FORMAT"] = itmpcol.ToString();
|
|
pdatarow["ENTRY"] = _Location;
|
|
DateTime tm = System.DateTime.Now;
|
|
pdatarow["DATE"] = tm.ToString("MM/dd/yyyy");
|
|
pdatarow["TIME"] = tm.ToString("HHmm") + ":";
|
|
pdatarow["PROCCODE"] = _ProcCode;
|
|
pdatatable.Rows.Add(pdatarow);
|
|
|
|
// See if this proc's data changes the largest numbers stored
|
|
// in the first record.
|
|
bool chg = false;
|
|
if (Procedure_Number.Length+1 > ds.LargestNumber)
|
|
{
|
|
chg=true;
|
|
ds.LargestNumber = Procedure_Number.Length+1;
|
|
}
|
|
if ((Procedure_Number.Substring(0,1)!=" ") && (Procedure_Number.Length+1>ds.LargestNumberForMenu))
|
|
{
|
|
chg=true;
|
|
ds.LargestNumberForMenu = Procedure_Number.Length+1;
|
|
}
|
|
if (Title.Length+1 > ds.LargestTitleForMenu)
|
|
{
|
|
chg=true;
|
|
ds.LargestTitleForMenu = Title.Length+1;
|
|
}
|
|
if (chg)
|
|
{
|
|
string padstr1 = ds.LargestNumber.ToString("d2").PadLeft(2,'0');
|
|
string padstr2 = ds.LargestNumberForMenu.ToString("d2").PadLeft(2,'0');
|
|
string padstr3 = ds.LargestTitleForMenu.ToString("d2").PadLeft(2,'0');
|
|
recidrow["NUMBER"] = padstr1 + " " + padstr2 + " " + padstr3;
|
|
}
|
|
ds.vdbSet.DB_Data = pdatarow.Table.DataSet;
|
|
_Title=Title;
|
|
_Prcnum=Procedure_Number;
|
|
_ProcColumn=Procedure_Column;
|
|
changeTitle=false;
|
|
changeProcCol=false;
|
|
changeProcNum=false;
|
|
|
|
if (ps.hasExtensions) this.procExt.SaveNew(this, tmprecid);
|
|
isNew=false;
|
|
ds.icon = ds.iconStates[0]; // in case it was empty
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show(e.Message,"Could not perform database functions required to add procedure.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public override bool updateROValues()
|
|
{
|
|
// update the ro values for this procset, so get parent's (dummy set), parent
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
return ps.updateROValues();
|
|
}
|
|
|
|
public override void CleanTransitionsAndROsUsages(int clntype,string ProcName)
|
|
{
|
|
// clean, send this procname to procedure set to spawn the clean
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
ps.CleanTransitionsAndROsUsages(clntype,this._Prcnum);
|
|
}
|
|
|
|
public override void ApproveProcedures(int aptype, ArrayList procs)
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (aptype == 0)
|
|
ps.ApproveProcedures(aptype,null);
|
|
else if (procs.Count>0)
|
|
ps.ApproveProcedures(aptype,procs);
|
|
else
|
|
{
|
|
ArrayList prcs = new ArrayList();
|
|
prcs.Add(this);
|
|
ps.ApproveProcedures(aptype,prcs);
|
|
}
|
|
}
|
|
|
|
public override void DataIntegrityCheck(string ProcName)
|
|
{
|
|
// send this procname to procedure set to spawn the DataCheck
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
ps.DataIntegrityCheck(this._Prcnum);
|
|
}
|
|
|
|
private void MoveFixFile(string apname, string appath, VEO_ProcSet ps)
|
|
{
|
|
string[] FxExt = {".FIX",".FX1",".FX2",".FX3",".FX4",".FX5",".FX6",".FX7",".FX8"};
|
|
string apvname = (apname==null || apname == "")?_Location:apname;
|
|
foreach (string str in FxExt)
|
|
ps.CopyAnyFileToApproved(_Location+str,apvname+str,appath);
|
|
}
|
|
|
|
private void FixProcDateAndTime(string apname, VEO_ProcSet ps)
|
|
{
|
|
string[] extensions = {".dbf",".dbt",".ndx"};
|
|
string appath = null;
|
|
string wd = null;
|
|
string apvname = (apname==null||apname=="")?_Location:apname;
|
|
foreach (string str in extensions)
|
|
{
|
|
appath = ps.GetApprovedDirectory("\\") + apvname + str;
|
|
wd = _Location + str;
|
|
FileInfo fi_app = new FileInfo(appath);
|
|
FileInfo fi_wd = new FileInfo(wd);
|
|
fi_app.LastWriteTime = fi_wd.LastWriteTime;
|
|
File.Copy(appath, wd, true);
|
|
fi_app = new FileInfo(appath);
|
|
fi_wd = new FileInfo(wd);
|
|
fi_app.LastWriteTime = fi_wd.LastWriteTime;
|
|
fi_wd.LastWriteTime = fi_app.LastWriteTime;
|
|
}
|
|
}
|
|
|
|
public void Copy(string srcdir, string destdir, string prcnum, string prcfile)
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
// if there is a new procedure to add for a modified proc number,
|
|
// prcfile will not == the _Location. Use it instead.
|
|
string loc=null;
|
|
if (prcfile != _Location)
|
|
loc = prcfile;
|
|
else
|
|
loc = _Location;
|
|
string destfile = destdir + "\\" + loc;
|
|
string srcfile = (srcdir==null)? _Location: srcdir + "\\" + _Location;
|
|
|
|
if (!File.Exists(srcfile+".dbf")) return;
|
|
if (File.Exists(destfile+".dbf")) File.Delete(destfile+".dbf");
|
|
if (File.Exists(destfile+".ndx")) File.Delete(destfile+".ndx");
|
|
if (File.Exists(destfile+".dbt")) File.Delete(destfile+".dbt");
|
|
|
|
vdb_Proc dbprc = null;
|
|
try
|
|
{
|
|
dbprc = new vdb_Proc(srcfile+".dbf");
|
|
// Use SelectIntoNewTable to create the table & copy it over using
|
|
// sql select * into ... Then just make an instance of the table, this
|
|
// will set up indexes and inf files as necessary.
|
|
dbprc.SelectIntoNewTable(srcdir+"\\"+destfile);
|
|
string cwd = Directory.GetCurrentDirectory();
|
|
Directory.SetCurrentDirectory(destdir);
|
|
vdb_Proc apprc = new vdb_Proc(loc+".dbf");
|
|
Directory.SetCurrentDirectory(cwd);
|
|
apprc=null;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Could not copy " + _Location + " to approved." + e.Message);
|
|
return;
|
|
}
|
|
|
|
// now copy over rtf files by finding the procedure records that are attachments.
|
|
DataSet accset=null;
|
|
try
|
|
{
|
|
accset = dbprc.GetSortedByStepSeqType("WHERE [SEQUENCE] like ' %'");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Could not copy over accessory page files " + this._Prcnum + ", " + e.Message);
|
|
return;
|
|
}
|
|
string rtfsrcdir = srcdir + "\\rtffiles\\" + this._Location + ".A";
|
|
string rtfdestdir = destdir + "\\rtffiles\\" + prcfile + ".A";
|
|
foreach (DataRow dr in accset.Tables[0].Rows)
|
|
{
|
|
bool accpage = (char.IsLetter(dr["STEP"].ToString()[1]))?true:false;
|
|
if (accpage)
|
|
{
|
|
string stpno = (string) dr["STEP"].ToString();
|
|
char accsect = stpno[0];
|
|
string tmpext = (accsect-'@').ToString("D2");
|
|
if (File.Exists(rtfsrcdir+tmpext))
|
|
File.Copy(rtfsrcdir+tmpext,rtfdestdir+tmpext,true);
|
|
}
|
|
}
|
|
|
|
for (int i=0;i<AppExtensions.Length;i++)
|
|
if (AppExtensions[i] && File.Exists(srcfile+"."+DBExtensions[i])) File.Copy(srcfile+"."+DBExtensions[i],destfile+"."+DBExtensions[i],true);
|
|
|
|
MoveFixFile(prcfile, null, ps);
|
|
if (ps.RmChgBarOnApp&&File.Exists(_Location+".scr"))File.Delete(_Location+".scr");
|
|
FixProcDateAndTime(prcfile, ps);
|
|
}
|
|
|
|
private AppIndItem InAppIndList(string prnum, ArrayList al)
|
|
{
|
|
AppIndItem cur=null;
|
|
foreach (object obal in al)
|
|
{
|
|
AppIndItem aiiobj = (AppIndItem) obal;
|
|
if (aiiobj.Proc._Prcnum == prnum)
|
|
{
|
|
cur=aiiobj;
|
|
break;
|
|
}
|
|
}
|
|
// if it is not in the list, add it.
|
|
if (cur==null)
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
foreach(VEO_Proc prc in ds.Children)
|
|
{
|
|
if (prc._Prcnum==prnum)
|
|
{
|
|
cur = new AppIndItem(prc);
|
|
al.Add(cur);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return cur;
|
|
}
|
|
|
|
private void FlagProcsUsingThisDoc(string ldname, ArrayList al)
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
|
|
// Library documents can be found in the transition file, in the 'to'
|
|
// field.
|
|
vdb_TransUsage transusg = new vdb_TransUsage(ps._curDirectory + "\\" + ps._Location + "\\tran.dbf");
|
|
DataSet trset = transusg.GetSortedByToTrans("[TONUMBER] = \'"+ldname.ToUpper().Replace("'","''")+"\' OR [TONUMBER] =\'"+ldname.ToLower().Replace("'","''")+"\'");
|
|
foreach(DataRow adr in trset.Tables[0].Rows)
|
|
{
|
|
// verify that this is not the current procedure. Add the procedure
|
|
// to the to-check list (if not in there, use InAppIndList) and then
|
|
// add the conflict. Also, check for transition type of 6 (outside),
|
|
// for those don't add them either.
|
|
string pnumFrom = adr["FROMNUMBER"].ToString();
|
|
string seq = adr["FROMSEQUEN"].ToString();
|
|
string typ = adr["TYPE"].ToString();
|
|
AppIndItem cur = null;
|
|
|
|
if (typ != "6" && ps.ProcedureNumberInSet(pnumFrom))
|
|
{
|
|
cur = InAppIndList(pnumFrom,al);
|
|
AppLibDocConflict ldc = new AppLibDocConflict(ds,pnumFrom, seq, ldname);
|
|
cur.AddConflict(ldc);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void CheckForUnusedDoc(ArrayList al, ArrayList ModLibDocs, ArrayList ModROs, string libdoc)
|
|
{
|
|
foreach (ModLibDoc ml in ModLibDocs)
|
|
{
|
|
int indx = ml.LibFile.IndexOf(".");
|
|
string lname=null;
|
|
if (indx==-1)
|
|
lname = ml.LibFile;
|
|
else
|
|
lname = ml.LibFile.Substring(0,indx);
|
|
if(ml.DocPages==0 && libdoc.ToUpper() == lname.ToUpper())
|
|
{
|
|
ml.DocPages=1;
|
|
FlagProcsUsingThisDoc(lname, al);
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
Usages.CheckRoReferences(ps, ps._curDirectory+"\\"+ps._Location,al,ModROs,lname);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// for this procedure, check if it has any library document references. If so,
|
|
// see if the library document used is in the modified list. If so, see if other
|
|
// procedures use it & add them to the list of procs to process.
|
|
public bool CheckLibraryDocReferences(ArrayList al, int indx, ArrayList ModLibDocs, ArrayList ModROs)
|
|
{
|
|
|
|
AppIndItem appitm = (AppIndItem) al[indx];
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
vdb_Proc dbprc = null;
|
|
DataSet accset = null;
|
|
|
|
// For this procedure, get any sections that are 'accessory pages'. Only
|
|
// those can reference a library document.
|
|
string pth = ps._curDirectory + "\\" + ps._Location + "\\" + this._Location + ".dbf";
|
|
try
|
|
{
|
|
dbprc = new vdb_Proc(pth);
|
|
accset = dbprc.GetSortedByStepSeqType("WHERE [SEQUENCE] like ' %'");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Could not get usages for the library document " + this._Prcnum + ", " + e.Message);
|
|
return false;
|
|
}
|
|
|
|
// for each accessory page, see if it has a library document.
|
|
foreach (DataRow dr in accset.Tables[0].Rows)
|
|
{
|
|
bool accpage = (char.IsLetter(dr["STEP"].ToString()[1]))?true:false;
|
|
if (accpage)
|
|
{
|
|
// check to see if this is using a library document, and if so
|
|
// check to see if it is one that was in the modified list.
|
|
vdb_TransUsage transusg = new vdb_TransUsage(ps._curDirectory + "\\" + ps._Location + "\\tran.dbf");
|
|
DataSet trset = transusg.GetSortedByFromTrans("[FROMNUMBER] = \'"+this._Prcnum.Replace("'","''")+"\' AND [FROMSEQUEN] = \'" + dr["STEP"].ToString()[0] + "\'");
|
|
if (trset.Tables[0].Rows.Count!=0)
|
|
{
|
|
foreach(DataRow adr in trset.Tables[0].Rows) CheckForUnusedDoc(al, ModLibDocs, ModROs, adr["TONUMBER"].ToString());
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
private void CheckForTransChange(string TransPtr, DataRow dr, ArrayList al)
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
// don't count internal transitions, i.e. transitions to myself
|
|
if (_Prcnum!=TransPtr)
|
|
{
|
|
// don't add if this is an outside transition.
|
|
string typ = dr["TYPE"].ToString();
|
|
if (typ=="6")return;
|
|
string OldToKey = dr["TONUMBER"].ToString().PadRight(20,' ') + dr["TOSEQUENCE"].ToString();
|
|
OldToKey = OldToKey.TrimEnd(" ".ToCharArray()); // needed extra trim if toseq is null (libdoc)
|
|
string tmp = dr["OLDTO"].ToString().TrimEnd(" ".ToCharArray());
|
|
if ((tmp!=null&&tmp!="") && (tmp!=OldToKey))
|
|
{
|
|
AppIndItem cur = InAppIndList(TransPtr,al);
|
|
AppTransConflict tc = new AppTransConflict(ds,dr["FROMNUMBER"].ToString(),dr["FROMSEQUEN"].ToString(),dr["TONUMBER"].ToString(),dr["TOSEQUENCE"].ToString(),dr["OLDTO"].ToString());
|
|
cur.AddConflict(tc);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
public bool CheckTransitionReferences(ArrayList al)
|
|
{
|
|
// first check transitions from this procedure...
|
|
VEO_DummySet pds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) pds.parentObj;
|
|
string pth = ps._curDirectory+"\\"+ps.Location+"\\tran.dbf";
|
|
vdb_TransUsage transusg = new vdb_TransUsage(pth);
|
|
DataSet ds = transusg.GetSortedByFromTrans("[FROMNUMBER] = \'"+this._Prcnum.Replace("'","''")+"\'");
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
CheckForTransChange(dr["TONUMBER"].ToString(),dr,al);
|
|
}
|
|
ds.Clear();
|
|
ds = transusg.GetSortedByToTrans("[TONUMBER] = \'"+this._Prcnum.Replace("'","''")+"\'");
|
|
foreach (DataRow dr in ds.Tables[0].Rows)
|
|
{
|
|
CheckForTransChange(dr["FROMNUMBER"].ToString(),dr,al);
|
|
}
|
|
ds.Dispose();
|
|
transusg=null;
|
|
return true;
|
|
}
|
|
|
|
private void SetUpNewApFileName(string ApprovedPath)
|
|
{
|
|
int i=0;
|
|
StringBuilder newname = new StringBuilder();
|
|
if(!isOpen) Open();
|
|
while(i==0 || (File.Exists(ApprovedPath+"\\"+newname.ToString())))
|
|
{
|
|
newname.Remove(0,newname.Length);
|
|
newname.Append("PROC");
|
|
string tmp = i.ToString();
|
|
newname.Append(i.ToString("d3"));
|
|
newname.Append(".dbf");
|
|
i++;
|
|
}
|
|
this._Location = newname.ToString().Substring(0,7);
|
|
}
|
|
|
|
public void GetApProcNumAndFile(string ApprovedPath, ref string ApProcFile, ref string ApProcNum)
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
vdb_Set vdbSet = new vdb_Set(ApprovedPath);
|
|
|
|
// get the total number of records in the Approved Set file
|
|
// and see if this is a new procedure number. If it is a new number,
|
|
// (cause is either new procedure or modified procedure number), we
|
|
// need a new database file name & need to save in the ApProcNum the
|
|
// number that will
|
|
int TotalRecs = vdbSet.DB_Data.Tables[0].Rows.Count;
|
|
DataRow foundRow = null;
|
|
foreach (DataRow dr in vdbSet.DB_Data.Tables[0].Rows)
|
|
{
|
|
if (dr["NUMBER"].ToString()==this._Prcnum)
|
|
{
|
|
foundRow=dr;
|
|
break;
|
|
}
|
|
}
|
|
ApProcNum = _Prcnum;
|
|
|
|
// This procedure number is not in the approved set, get a new file name
|
|
// for it. Othewise, just return current filename.
|
|
if (foundRow == null)
|
|
{
|
|
// save _Location temporarily, because setupnewfilename overwrites it.
|
|
string _Locationsav = _Location;
|
|
SetUpNewApFileName(ApprovedPath);
|
|
ApProcFile = _Location;
|
|
_Location = _Locationsav;
|
|
}
|
|
else
|
|
ApProcFile = foundRow["ENTRY"].ToString();
|
|
}
|
|
|
|
public void UpdateSetFile(string ApprovedPath, string ApProcNum, string ApProcFile)
|
|
{
|
|
string appath=ApprovedPath+"\\set.dbf";
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
vdb_Set vdbSet = new vdb_Set(appath);
|
|
DataRow foundRow = null;
|
|
DataRow recidrow = null;
|
|
string tmprecid = null;
|
|
|
|
if (ApProcNum == this._Prcnum)
|
|
{
|
|
// get the total number of records in the Approved Set file
|
|
// and see if this is a new procedure number. If so add it,
|
|
// otherwise we have a modify.
|
|
int TotalRecs = vdbSet.DB_Data.Tables[0].Rows.Count;
|
|
foreach (DataRow dr in vdbSet.DB_Data.Tables[0].Rows)
|
|
{
|
|
if (dr["NUMBER"].ToString()==this._Prcnum)
|
|
{
|
|
foundRow=dr;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// new procedure, add it.
|
|
if (foundRow==null)
|
|
{
|
|
DataTable tbl = vdbSet.DB_Data.Tables[0];
|
|
DataRow newdr = tbl.NewRow();
|
|
foundRow=newdr;
|
|
tbl.Rows.Add(foundRow);
|
|
ApProcNum=null;
|
|
// update the recid
|
|
recidrow = tbl.Rows[0];
|
|
tmprecid = recidrow["RECID"].ToString();
|
|
int irecid = System.Convert.ToInt32(tmprecid.Substring(2,6));
|
|
irecid++;
|
|
tmprecid = tmprecid.Substring(0,2)+irecid.ToString("d6");
|
|
recidrow["RECID"]=tmprecid;
|
|
foundRow["RECID"]=tmprecid;
|
|
}
|
|
|
|
// update the approved set file record with the date/time/init information, long
|
|
// proc title data, and number/entry/etc.
|
|
foundRow["DATE"] = pdatarow["DATE"];
|
|
foundRow["TIME"] = pdatarow["TIME"];
|
|
foundRow["INITIALS"] = pdatarow["INITIALS"];
|
|
|
|
int ptlength = ps.UseLongProcTitles?249:78;
|
|
foundRow["TITLE"] = _Title.Substring(0,_Title.Length>ptlength?ptlength:_Title.Length);
|
|
foundRow["NUMBER"] = _Prcnum;
|
|
foundRow["ENTRY"]= _Location==ApProcFile?_Location:ApProcFile;
|
|
|
|
foundRow["FORMAT"] = pdatarow["FORMAT"]; // if modified, pdatarow has current
|
|
foundRow["PROCCODE"] = _ProcCode;
|
|
|
|
// if removing change bars, update the working draft date/time stamp
|
|
// for this procedure.
|
|
if (ps.RmChgBarOnApp)
|
|
{
|
|
ps.UpdateSetDTI(false,pdatarow);
|
|
ds.vdbSet.DB_Data = pdatarow.Table.DataSet;
|
|
}
|
|
|
|
vdbSet.DB_Data = foundRow.Table.DataSet; // write it out
|
|
|
|
// now make sure we update the largestnumber data in the set header
|
|
|
|
recidrow = pdatarow.Table.Rows[0];
|
|
string tmplarge = recidrow["NUMBER"].ToString();
|
|
if (tmplarge == null || tmplarge == "") tmplarge = "00000000";
|
|
bool update=false;
|
|
if (ds.LargestNumber != System.Convert.ToInt32(tmplarge.Substring(0,2)))
|
|
{
|
|
update=true;
|
|
tmplarge = ds.LargestNumber.ToString("d2").PadLeft(2,'0') + tmplarge.Substring(2,tmplarge.Length-2);
|
|
}
|
|
if (ds.LargestNumberForMenu != System.Convert.ToInt32(tmplarge.Substring(3,2)))
|
|
{
|
|
update = true;
|
|
tmplarge = tmplarge.Substring(0,3) + ds.LargestNumberForMenu.ToString("d2").PadLeft(2,'0') + tmplarge.Substring(5,tmplarge.Length-5);
|
|
}
|
|
if (ds.LargestTitleForMenu != System.Convert.ToInt32(tmplarge.Substring(6,2)))
|
|
{
|
|
update = true;
|
|
tmplarge = tmplarge.Substring(0,6) + ds.LargestTitleForMenu.ToString("d2").PadLeft(2,'0');
|
|
}
|
|
if (update)
|
|
{
|
|
recidrow["NUMBER"] = tmplarge;
|
|
vdbSet.DB_Data = recidrow.Table.DataSet; // write it out
|
|
}
|
|
}
|
|
|
|
// pass in approved path & approved procedure number, i.e. original procedure
|
|
// number - if the proc number is modified, this stores original otherwise
|
|
// it is the current proc number. (if this is a new procedure then ApProcNum=null.
|
|
public void FixTransitionReferences(string ApprovedPath, string ApProcNum)
|
|
{
|
|
string appath=ApprovedPath+"\\tran.dbf";
|
|
VEO_DummySet ds = (VEO_DummySet) parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
try
|
|
{
|
|
vdb_TransUsage atransusg = new vdb_TransUsage(appath);
|
|
// if this procedure existed before this approval, then remove transitions-from
|
|
// approved version (they'll be added back later).
|
|
if (ApProcNum != null)
|
|
{
|
|
DataSet adset = atransusg.GetSortedByFromTrans("[FROMNUMBER] = \'"+ApProcNum.Replace("'","''")+"\'");
|
|
int ndr = adset.Tables[0].Rows.Count;
|
|
if (ndr > 0)
|
|
{
|
|
int errs = atransusg.DeleteSelected("[FROMNUMBER] = \'"+ApProcNum.Replace("'","''")+"\'");
|
|
if (errs>0)
|
|
{
|
|
MessageBox.Show("Error resolving transition records");
|
|
return;
|
|
}
|
|
atransusg.Pack();
|
|
}
|
|
|
|
// if there was a change in procedure number, then update the transitions-to in
|
|
// the approved version.
|
|
if (ApProcNum!=_Prcnum)
|
|
{
|
|
adset.Clear();
|
|
adset = atransusg.GetSortedByToTrans("[TONUMBER] = \'"+ApProcNum.Replace("'","''")+"\'");
|
|
ndr = adset.Tables[0].Rows.Count;
|
|
foreach (DataRow dr in adset.Tables[0].Rows) dr["TONUMBER"]=_Prcnum;
|
|
if (ndr>0) atransusg.DB_Data = adset.Tables[0].DataSet;
|
|
}
|
|
adset.Clear();
|
|
adset=null;
|
|
}
|
|
|
|
// now update the approved transitions from data based on data in the working
|
|
// draft.
|
|
vdb_TransUsage transusg = new vdb_TransUsage(ps._curDirectory+"\\"+ps.Location+"\\tran.dbf");
|
|
DataSet wdset = transusg.GetSortedByFromTrans("[FROMNUMBER] = \'"+_Prcnum.Replace("'","''")+"\'");
|
|
if (wdset.Tables[0].Rows.Count>0)
|
|
{
|
|
int errs = transusg.InsertInto(ps._curDirectory+"\\"+ps.Location+"\\"+appath,"[FROMNUMBER] = \'"+_Prcnum.Replace("'","''")+"\'");
|
|
if (errs>0)
|
|
{
|
|
MessageBox.Show("Error resolving transition records");
|
|
return;
|
|
}
|
|
|
|
// Now update the working draft 'OLDTO' field to contain the current
|
|
// working draft 'TONUMBER'+'TOSEQUENCE' fields.
|
|
StringBuilder qry = new StringBuilder();
|
|
qry.Append("UPDATE TRAN SET TRAN.OLDTO = [TONUMBER] & Space(20-Len([TONUMBER])) & [TOSEQUENCE] & Space(12-Len([TOSEQUENCE])) ");
|
|
qry.Append("WHERE (tran.FROMNUMBER=\'");
|
|
qry.Append(_Prcnum.Replace("'","''"));
|
|
qry.Append("\' AND tran.TOSEQUENCE IS NOT NULL)");
|
|
|
|
// This one handles the libdocs (their TOSEQUENCE is null).
|
|
bool success = transusg.UpdateUsing(qry.ToString());
|
|
if (!success) MessageBox.Show("Error When Updating Transition history");
|
|
qry.Length=0;
|
|
qry.Append("UPDATE TRAN SET TRAN.OLDTO = [TONUMBER] & Space(20-Len([TONUMBER])+12) ");
|
|
qry.Append("WHERE (tran.FROMNUMBER=\'");
|
|
qry.Append(_Prcnum.Replace("'","''"));
|
|
qry.Append("\' AND tran.TOSEQUENCE IS NULL)");
|
|
success = transusg.UpdateUsing(qry.ToString());
|
|
if (!success) MessageBox.Show("Error When Updating Transition history");
|
|
}
|
|
wdset.Dispose();
|
|
transusg=null;
|
|
atransusg=null;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
MessageBox.Show("Could not approve transition usages for " + _Prcnum + ", "+e.Message);
|
|
}
|
|
}
|
|
|
|
|
|
#if Upgrade2005_Print
|
|
#else
|
|
public override void AddToTree(TreeNode parentnd)
|
|
{
|
|
}
|
|
public override bool Expand(TreeNode parentnd)
|
|
{
|
|
return true;
|
|
}
|
|
#endif
|
|
public override bool mnuAllowUpdRO()
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (ps.isApproved||ps.IsEmpty||ps.isTempChange) return false;
|
|
return (amILockedByMe());
|
|
}
|
|
|
|
public override bool mnuAllowClean()
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (ps.isApproved||ps.IsEmpty) return false;
|
|
if (amILockedByMe()==false) return false;
|
|
if ((ps.accessFlags&Security.CLEAN)==Security.CLEAN) return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool mnuAllowDataCheck()
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (ps.isApproved||ps.IsEmpty) return false;
|
|
if (amILockedByMe()==false) return false;
|
|
if ((ps.accessFlags&Security.CLEAN)==Security.CLEAN) return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool mnuAllowChgDef()
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (ps.IsEmpty) return false;
|
|
return(amILockedByMe());
|
|
}
|
|
|
|
public override bool mnuAllowNew()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public override bool mnuAllowApprove()
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (amILockedByMe()==false) return false;
|
|
if ((ps.isApproved == false) && (ps.isTempChange==false)) return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool mnuAllowApproveSel()
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (ps.isApproved || ps.IsEmpty || ps.isTempChange) return false;
|
|
if (amILockedByMe()==false) return false;
|
|
if (ps.isSetApproved && ((ps.accessFlags&Security.APPROVESINGLE)==Security.APPROVESINGLE)) return true;
|
|
return false;
|
|
}
|
|
|
|
public override bool mnuAllowApproveAll()
|
|
{
|
|
bool allowit=false;
|
|
bool allowonlyonce=false;
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (ps.isApproved || ps.IsEmpty || ps.isTempChange) return false; // cannot approve an approved set
|
|
if (amILockedByMe()==false) return false;
|
|
if ((ps.accessFlags&Security.APPROVE)==Security.APPROVE) allowit = true;
|
|
// also check if there is a serial number option which allows only one
|
|
// approve-all, i.e. if an approved version exists, cannot approve all.
|
|
if (usrRunTime.SerialNumber.GetSNOption((uint)Utils.SerialNo.SN_Flags.SN_ONLYAPPROVEONCE_ON)>0)
|
|
allowonlyonce=true;
|
|
if (allowonlyonce && ps.isSetApproved) return false;
|
|
if (allowit) return true;
|
|
return false;
|
|
}
|
|
|
|
// the following method is used by various other methods to determine whether modifications
|
|
// can be made to the procedure.
|
|
private bool AllowMods()
|
|
{
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (ps.isApproved == true) return false;
|
|
if (amILockedByMe()==false) return false;
|
|
// Right now we are allowing the slave's procedure number and title be changed
|
|
// - but it will be wiped out when/if the master's set file changes.
|
|
// - If we want to NOT allow changes to the slave's procedure number and title
|
|
// then uncomment the following line. - jsj 04/08/05
|
|
// if (ps._ProcType == ProcTypeOptions.Slave) return false;
|
|
if ((ps.accessFlags&Security.ADDMODDEL)==Security.ADDMODDEL) return true;
|
|
return false;
|
|
}
|
|
public override bool mnuAllowDelete()
|
|
{
|
|
return AllowMods();
|
|
}
|
|
public override bool canEdit()
|
|
{
|
|
return AllowMods();
|
|
}
|
|
|
|
// determine whether drag/drop can occur.
|
|
public override bool canDoDragDrop()
|
|
{
|
|
// allow user to change order in approved set list
|
|
// return AllowMods();
|
|
VEO_DummySet ds = (VEO_DummySet) this.parentObj;
|
|
VEO_ProcSet ps = (VEO_ProcSet) ds.parentObj;
|
|
if (amILockedByMe()==false) return false;
|
|
if (ps._ProcType == ProcTypeOptions.Slave) return false;
|
|
if ((ps.accessFlags&Security.ADDMODDEL)==Security.ADDMODDEL) return true;
|
|
return false;
|
|
}
|
|
}
|
|
}
|