Context Navigation

← Previous Revision
Latest Revision
Next Revision →
Normal
Revision Log

uPCE.pas@ 732

Last change on this file since 732 was 453, checked in by Kevin Toppenberg, 16 years ago
Initial upload of TMG-CPRS 1.0.26.69
File size: 119.4 KB

Rev	Line
[453]	1	//kt -- Modified with SourceScanner on 8/8/2007
	2	unit uPCE;
	3
	4	interface
	5
	6	uses Windows, SysUtils, Classes, ORFn, uConst, ORCtrls, ORClasses,UBAGlobals;
	7
	8	type
	9	TPCEProviderRec = record
	10	IEN: int64;
	11	Name: string;
	12	Primary: boolean;
	13	Delete: boolean;
	14	end;
	15
	16	TPCEProviderList = class(TORStringList)
	17	private
	18	FNoUpdate: boolean;
	19	FOnPrimaryChanged: TNotifyEvent;
	20	FPendingDefault: string;
	21	FPendingUser: string;
	22	FPCEProviderIEN: Int64;
	23	FPCEProviderName: string;
	24	function GetProviderData(Index: integer): TPCEProviderRec;
	25	procedure SetProviderData(Index: integer; const Value: TPCEProviderRec);
	26	function GetPrimaryIdx: integer;
	27	procedure SetPrimaryIdx(const Value: integer);
	28	procedure SetPrimary(index: integer; Primary: boolean);
	29	public
	30	function Add(const S: string): Integer; override;
	31	function AddProvider(AIEN, AName: string; APrimary: boolean): integer;
	32	procedure Assign(Source: TPersistent); override;
	33	function PCEProvider: Int64;
	34	function PCEProviderName: string;
	35	function IndexOfProvider(AIEN: string): integer;
	36	procedure Merge(AList: TPCEProviderList);
	37	procedure Clear; override;
	38	procedure Delete(Index: Integer); override;
	39	function PrimaryIEN: int64;
	40	function PrimaryName: string;
	41	function PendingIEN(ADefault: boolean): Int64;
	42	function PendingName(ADefault: boolean): string;
	43	property ProviderData[Index: integer]: TPCEProviderRec read GetProviderData
	44	write SetProviderData; default;
	45	property PrimaryIdx: integer read GetPrimaryIdx write SetPrimaryIdx;
	46	property OnPrimaryChanged: TNotifyEvent read FOnPrimaryChanged
	47	write FOnPrimaryChanged;
	48	end;
	49
	50	TPCEItem = class(TObject)
	51	{base class for PCE items}
	52	private
	53	FDelete: Boolean; //flag for deletion
	54	FSend: Boolean; //flag to send to broker
	55	FComment: String;
	56	protected
	57	procedure SetComment(const Value: String);
	58	public
	59	// Provider: Int64;
	60	Provider: Int64;
	61	Code: string;
	62	Category: string;
	63	Narrative: string;
	64	FGecRem: string;
	65	procedure Assign(Src: TPCEItem); virtual;
	66	procedure Clear; virtual;
	67	function DelimitedStr: string; virtual;
	68	function DelimitedStr2: string; virtual;
	69	function ItemStr: string; virtual;
	70	function Match(AnItem: TPCEItem): Boolean;
	71	// function MatchProvider(AnItem: TPCEItem):Boolean;
	72	function MatchProvider(AnItem: TPCEItem):Boolean;
	73	procedure SetFromString(const x: string); virtual;
	74	function HasCPTStr: string; virtual;
	75	property Comment: String read FComment write SetComment;
	76	property GecRem: string read FGecRem write FGecRem;
	77	end;
	78
	79	TPCEItemClass = class of TPCEItem;
	80
	81	TPCEProc = class(TPCEItem)
	82	{class for procedures}
	83	public
	84	FIsOldProcedure: boolean;
	85	Quantity: Integer;
	86	Modifiers: string; // Format Modifier1IEN;Modifier2IEN;Modifier3IEN; Trailing ; needed
	87	// Provider: Int64; {jm 9/8/99}
	88	Provider: Int64; {jm 9/8/99}
	89	procedure Assign(Src: TPCEItem); override;
	90	procedure Clear; override;
	91	function DelimitedStr: string; override;
	92	// function DelimitedStrC: string;
	93	// function Match(AnItem: TPCEProc): Boolean;
	94	function ModText: string;
	95	function ItemStr: string; override;
	96	procedure SetFromString(const x: string); override;
	97	procedure CopyProc(Dest: TPCEProc);
	98	function Empty: boolean;
	99	end;
	100
	101	TPCEDiag = class(TPCEItem)
	102	{class for diagnosis}
	103	public
	104	fProvider: Int64;
	105	Primary: Boolean;
	106	AddProb: Boolean;
	107	OldComment: string;
	108	SaveComment: boolean;
	109	procedure Assign(Src: TPCEItem); override;
	110	procedure Clear; override;
	111	function DelimitedStr: string; override;
	112	function DelimitedStr2: string; override;
	113	// function delimitedStrC: string;
	114	function ItemStr: string; override;
	115	procedure SetFromString(const x: string); override;
	116	procedure Send;
	117	end;
	118
	119	TPCEExams = class(TPCEItem)
	120	{class for Examinations}
	121	public
	122	// Provider: Int64;
	123	Results: String;
	124	procedure Assign(Src: TPCEItem); override;
	125	procedure Clear; override;
	126	function DelimitedStr: string; override;
	127	// function delimitedStrC: string;
	128	function ItemStr: string; override;
	129	procedure SetFromString(const x: string); override;
	130	function HasCPTStr: string; override;
	131	end;
	132
	133
	134	TPCEHealth = class(TPCEItem)
	135	{class for Health Factors}
	136	public
	137	// Provider: Int64; {jm 9/8/99}
	138	Level: string;
	139	procedure Assign(Src: TPCEItem); override;
	140	procedure Clear; override;
	141	function DelimitedStr: string; override;
	142	// function delimitedStrC: string;
	143	function ItemStr: string; override;
	144	procedure SetFromString(const x: string); override;
	145	function HasCPTStr: string; override;
	146	end;
	147
	148	TPCEImm = class(TPCEItem)
	149	{class for immunizations}
	150	public
	151	// Provider: Int64; {jm 9/8/99}
	152	Series: String;
	153	Reaction: String;
	154	Refused: Boolean; //not currently used
	155	Contraindicated: Boolean;
	156	procedure Assign(Src: TPCEItem); override;
	157	procedure Clear; override;
	158	function DelimitedStr: string; override;
	159	// function delimitedStrC: string;
	160	function ItemStr: string; override;
	161	procedure SetFromString(const x: string); override;
	162	function HasCPTStr: string; override;
	163	end;
	164
	165	TPCEPat = class(TPCEItem)
	166	{class for patient Education}
	167	public
	168	// Provider: Int64; {jm 9/8/99}
	169	Level: String;
	170	procedure Assign(Src: TPCEItem); override;
	171	procedure Clear; override;
	172	function DelimitedStr: string; override;
	173	// function delimitedStrC: string;
	174	function ItemStr: string; override;
	175	procedure SetFromString(const x: string); override;
	176	function HasCPTStr: string; override;
	177	end;
	178
	179	TPCESkin = class(TPCEItem)
	180	{class for skin tests}
	181	public
	182	// Provider: Int64; {jm 9/8/99}
	183	Results: String; //Do not confuse for reserved word "result"
	184	Reading: Integer;
	185	DTRead: TFMDateTime;
	186	DTGiven: TFMDateTime;
	187	procedure Assign(Src: TPCEItem); override;
	188	procedure Clear; override;
	189	function DelimitedStr: string; override;
	190	// function delimitedStrC: string;
	191	function ItemStr: string; override;
	192	procedure SetFromString(const x: string); override;
	193	function HasCPTStr: string; override;
	194	end;
	195
	196	// TPCEData = class;
	197
	198	tRequiredPCEDataType = (ndDiag, ndProc, ndSC); {jm 9/9/99}
	199	tRequiredPCEDataTypes = set of tRequiredPCEDataType;
	200
	201	//modified: 6/9/99
	202	//By: Robert Bott
	203	//Location: ISL
	204	//Purpose: Changed to allow capture of multiple providers.
	205	TPCEData = class
	206	{class for data to be passed to and from broker}
	207	private
	208	FUpdated: boolean;
	209	FEncDateTime: TFMDateTime; //encounter date & time
	210	FNoteDateTime: TFMDateTime; //Note date & time
	211	FEncLocation: Integer; //encounter location
	212	FEncSvcCat: Char; //
	213	FEncInpatient: Boolean; //Inpatient flag
	214	FEncUseCurr: Boolean; //
	215	FSCChanged: Boolean; //
	216	FSCRelated: Integer; //service con. related?
	217	FAORelated: Integer; //
	218	FIRRelated: Integer; //
	219	FECRelated: Integer; //
	220	FMSTRelated: Integer; //
	221	FHNCRelated: Integer; //
	222	FCVRelated: Integer; //
	223	FVisitType: TPCEProc; //
	224	FProviders: TPCEProviderList;
	225	FDiagnoses: TList; //pointer list for diagnosis
	226	FProcedures: TList; //pointer list for Procedures
	227	FImmunizations: TList; //pointer list for Immunizations
	228	FSkinTests: TList; //pointer list for skin tests
	229	FPatientEds: TList;
	230	FHealthFactors: TList;
	231	fExams: TList;
	232	FNoteTitle: Integer;
	233	FNoteIEN: Integer;
	234	FParent: string; // Parent Visit for secondary encounters
	235	FHistoricalLocation: string; // Institution IEN^Name (if IEN=0 Piece 4 = outside location)
	236	FStandAlone: boolean;
	237	FStandAloneLoaded: boolean;
	238
	239	function GetVisitString: string;
	240	function GetCPTRequired: Boolean;
	241	function getDocCount: Integer;
	242	function MatchItem(AList: TList; AnItem: TPCEItem): Integer;
	243	procedure MarkDeletions(PreList: TList; PostList: TStrings);
	244	procedure SetSCRelated(Value: Integer);
	245	procedure SetAORelated(Value: Integer);
	246	procedure SetIRRelated(Value: Integer);
	247	procedure SetECRelated(Value: Integer);
	248	procedure SetMSTRelated(Value: Integer);
	249	procedure SetHNCRelated(Value: Integer);
	250	procedure SetCVRelated(Value: Integer);
	251	procedure SetEncUseCurr(Value: Boolean);
	252	function GetHasData: Boolean;
	253	procedure GetHasCPTList(AList: TStrings);
	254	procedure CopyPCEItems(Src: TList; Dest: TObject; ItemClass: TPCEItemClass);
	255	public
	256	constructor Create;
	257	destructor Destroy; override;
	258	procedure Clear;
	259	procedure CopyPCEData(Dest: TPCEData);
	260	function Empty: boolean;
	261	procedure PCEForNote(NoteIEN: Integer; EditObj: TPCEData);(* overload;
	262	procedure PCEForNote(NoteIEN: Integer; EditObj: TPCEData; DCSummAdmitString: string); overload;*)
	263	procedure Save;
	264	procedure CopyDiagnoses(Dest: TStrings); // ICDcode^P\|S^Category^Narrative^P\|S Text
	265	procedure CopyProcedures(Dest: TStrings); // CPTcode^Qty^Category^Narrative^Qty Text
	266	procedure CopyImmunizations(Dest: TStrings); //
	267	procedure CopySkinTests(Dest: TStrings); //
	268	procedure CopyPatientEds(Dest: TStrings);
	269	procedure CopyHealthFactors(Dest: TStrings);
	270	procedure CopyExams(Dest: TStrings);
	271
	272	procedure SetDiagnoses(Src: TStrings; FromForm: boolean = TRUE); // ICDcode^P\|S^Category^Narrative^P\|S Text
	273	procedure SetExams(Src: TStrings; FromForm: boolean = TRUE);
	274	Procedure SetHealthFactors(Src: TStrings; FromForm: boolean = TRUE);
	275	procedure SetImmunizations(Src: TStrings; FromForm: boolean = TRUE); // IMMcode^
	276	Procedure SetPatientEds(Src: TStrings; FromForm: boolean = TRUE);
	277	procedure SetSkinTests(Src: TStrings; FromForm: boolean = TRUE); //
	278	procedure SetProcedures(Src: TStrings; FromForm: boolean = TRUE); // CPTcode^Qty^Category^Narrative^Qty Text
	279
	280	procedure SetVisitType(Value: TPCEProc); // CPTcode^1^Category^Narrative
	281	function StrDiagnoses: string; // Diagnoses: ...
	282	function StrImmunizations: string; // Immunizzations: ...
	283	function StrProcedures: string; // Procedures: ...
	284	function StrSkinTests: string;
	285	function StrPatientEds: string;
	286	function StrHealthFactors: string;
	287	function StrExams: string;
	288	function StrVisitType(const ASCRelated, AAORelated, AIRRelated, AECRelated,
	289	AMSTRelated, AHNCRelated, ACVRelated: Integer): string; overload;
	290	function StrVisitType: string; overload;
	291	function StandAlone: boolean;
	292	procedure AddStrData(List: TStrings);
	293	procedure AddVitalData(Data, List: TStrings);
	294
	295	function NeededPCEData: tRequiredPCEDataTypes;
	296	function OK2SignNote: boolean;
	297
	298	function PersonClassDate: TFMDateTime;
	299	function VisitDateTime: TFMDateTime;
	300	function IsSecondaryVisit: boolean;
	301	function NeedProviderInfo: boolean;
	302
	303	property HasData: Boolean read GetHasData;
	304	property CPTRequired: Boolean read GetCPTRequired;
	305	property Inpatient: Boolean read FEncInpatient;
	306	property UseEncounter: Boolean read FEncUseCurr write SetEncUseCurr;
	307	property SCRelated: Integer read FSCRelated write SetSCRelated;
	308	property AORelated: Integer read FAORelated write SetAORelated;
	309	property IRRelated: Integer read FIRRelated write SetIRRelated;
	310	property ECRelated: Integer read FECRelated write SetECRelated;
	311	property MSTRelated: Integer read FMSTRelated write SetMSTRelated;
	312	property HNCRelated: Integer read FHNCRelated write SetHNCRelated;
	313	property CVRelated: Integer read FCVRelated write SetCVRelated;
	314	property VisitType: TPCEProc read FVisitType write SetVisitType;
	315	property VisitString: string read GetVisitString;
	316	property VisitCategory:char read FEncSvcCat write FEncSvcCat;
	317	property DateTime: TFMDateTime read FEncDateTime write FEncDateTime;
	318	property NoteDateTime: TFMDateTime read FNoteDateTime write FNoteDateTime;
	319	property Location: Integer Read FencLocation;
	320	property NoteTitle: Integer read FNoteTitle write FNoteTitle;
	321	property NoteIEN: Integer read FNoteIEN write FNoteIEN;
	322	property DocCOunt: Integer read GetDocCount;
	323	property Providers: TPCEProviderList read FProviders;
	324	property Parent: string read FParent write FParent;
	325	property HistoricalLocation: string read FHistoricalLocation write FHistoricalLocation;
	326	property Updated: boolean read FUpdated write FUpdated;
	327	end;
	328
	329	type
	330	TPCEType = (ptEncounter, ptReminder, ptTemplate);
	331
	332	//kt const
	333	//kt PCETypeText: array[TPCEType] of string = ('encounter', 'reminder', 'template');
	334	function PCETypeText (index : TPCEType) : string; //kt 8/15/07
	335
	336	function InvalidPCEProviderTxt(AIEN: Int64; ADate: TFMDateTime): string;
	337	function MissingProviderInfo(PCEEdit: TPCEData; PCEType: TPCEType = ptEncounter): boolean;
	338	function IsOK2Sign(const PCEData: TPCEData; const IEN: integer) :boolean;
	339	function FutureEncounter(APCEData: TPCEData): boolean;
	340	function CanEditPCE(APCEData: TPCEData): boolean;
	341	procedure GetPCECodes(List: TStrings; CodeType: integer);
	342	procedure GetComboBoxMinMax(dest: TORComboBox; var Min, Max: integer);
	343	procedure PCELoadORCombo(dest: TORComboBox); overload;
	344	procedure PCELoadORCombo(dest: TORComboBox; var Min, Max: integer); overload;
	345	function GetPCEDisplayText(ID: string; Tag: integer): string;
	346	procedure SetDefaultProvider(ProviderList: TPCEProviderList; APCEData: TPCEData);
	347	function ValidateGAFDate(var GafDate: TFMDateTime): string;
	348	procedure GetVitalsFromDate(VitalStr: TStrings; PCEObj: TPCEData);
	349	procedure GetVitalsFromNote(VitalStr: TStrings; PCEObj: TPCEData; ANoteIEN: Int64);
	350
	351	type
	352	TPCEDataCat = (pdcVisit, pdcDiag, pdcProc, pdcImm, pdcSkin, pdcPED, pdcHF,
	353	pdcExam, pdcVital, pdcOrder, pdcMH, pdcMST, pdcHNC, pdcWHR, pdcWH);
	354
	355	function GetPCEDataText(Cat: TPCEDataCat; Code, Category, Narrative: string;
	356	PrimaryDiag: boolean = FALSE; Qty: integer = 0): string;
	357
	358	function PCEDataCatText (index: TPCEDataCat) : string; //kt 8/15/07 -- replace const with Fn
	359	(*const
	360	PCEDataCatText: array[TPCEDataCat] of string =
	361	{ dcVisit } ('',
	362	{ dcDiag } 'Diagnoses: ',
	363	{ dcProc } 'Procedures: ',
	364	{ dcImm } 'Immunizations: ',
	365	{ dcSkin } 'Skin Tests: ',
	366	{ dcPED } 'Patient Educations: ',
	367	{ dcHF } 'Health Factors: ',
	368	{ dcExam } 'Examinations: ',
	369	{ dcVital } '',
	370	{ dcOrder } 'Orders: ',
	371	{ dcMH } 'Mental Health: ',
	372	{ dcMST } 'MST History: ',
	373	{ dcHNC } 'Head and/or Neck Cancer: ',
	374	{ dcWHR } 'Women''s Health Procedure: ',
	375	{ dcWH } 'WH Notification: ');
	376	*)
	377
	378	const
	379	NoPCEValue = '@';
	380	TAB_STOP_CHARS = 7;
	381	(*TX_NO_VISIT = 'Insufficient Visit Information';
	382	TX_NEED_PROV1 = 'The provider responsible for this encounter must be entered before ';
	383	TX_NEED_PROV2 = ' information may be entered.';
	384	TX_NEED_PROV3 = 'you can sign the note.';
	385	TX_NO_PROV = 'Missing Provider';
	386	TX_BAD_PROV = 'Invalid Provider';
	387	TX_NOT_ACTIVE = ' does not have an active person class.';
	388	TX_NOT_PROV = ' is not a known Provider.';
	389	TX_MISSING = 'Required Information Missing';
	390	TX_REQ1 = 'The following required fields have not been entered:' + CRLF;
	391	TC_REQ = 'Required Fields';
	392	TX_ADDEND_AD = 'Cannot make an addendum to an addendum' + CRLF +
	393	'Please select the parent note or document, and try again.'; <-- original line. //kt 8/8/2007
	394	TX_ADDEND_MK = 'Unable to Make Addendum';
	395	TX_DEL_CNF = 'Confirm Deletion';
	396	TX_IN_AUTH = 'Insufficient Authorization';
	397	TX_NOPCE = '<No encounter information entered>';
	398	TX_NEED_T = 'Missing Encounter Information';
	399	TX_NEED1 = 'This note title is marked to prompt for the following missing' + CRLF +
	400	'encounter information:' + CRLF; <-- original line. //kt 8/8/2007
	401	TX_NEED_DIAG = ' A diagnosis.';
	402	TX_NEED_PROC = ' A visit type or procedure.';
	403	TX_NEED_SC = ' One or more service connected questions.';
	404	TX_NEED2 = 'Would you like to enter encounter information now?';
	405	TX_NEED3 = 'You must enter the encounter information before you can sign the note.';
	406	TX_NEEDABORT = 'Document not signed.';
	407	TX_COS_REQ = 'A cosigner is required for this document.';
	408	TX_COS_SELF = 'You cannot make yourself a cosigner.';
	409	TX_COS_AUTH = ' is not authorized to cosign this document.';
	410	TC_COS = 'Select Cosigner';
	411	*)
	412
	413	function TX_NO_VISIT : string; //kt 8-25-07 replace const with Fn.
	414	function TX_NEED_PROV1: string; //kt 8-25-07 replace const with Fn.
	415	function TX_NEED_PROV2: string; //kt 8-25-07 replace const with Fn.
	416	function TX_NEED_PROV3: string; //kt 8-25-07 replace const with Fn.
	417	function TX_NO_PROV : string; //kt 8-25-07 replace const with Fn.
	418	function TX_BAD_PROV : string; //kt 8-25-07 replace const with Fn.
	419	function TX_NOT_ACTIVE: string; //kt 8-25-07 replace const with Fn.
	420	function TX_NOT_PROV : string; //kt 8-25-07 replace const with Fn.
	421	function TX_MISSING : string; //kt 8-25-07 replace const with Fn.
	422	function TX_REQ1 : string; //kt 8-25-07 replace const with Fn.
	423	function TC_REQ : string; //kt 8-25-07 replace const with Fn.
	424	function TX_ADDEND_AD : string; //kt 8-25-07 replace const with Fn.
	425	function TX_ADDEND_MK : string; //kt 8-25-07 replace const with Fn.
	426	function TX_DEL_CNF : string; //kt 8-25-07 replace const with Fn.
	427	function TX_IN_AUTH : string; //kt 8-25-07 replace const with Fn.
	428	function TX_NOPCE : string; //kt 8-25-07 replace const with Fn.
	429	function TX_NEED_T : string; //kt 8-25-07 replace const with Fn.
	430	function TX_NEED1 : string; //kt 8-25-07 replace const with Fn.
	431	function TX_NEED_DIAG : string; //kt 8-25-07 replace const with Fn.
	432	function TX_NEED_PROC : string; //kt 8-25-07 replace const with Fn.
	433	function TX_NEED_SC : string; //kt 8-25-07 replace const with Fn.
	434	function TX_NEED2 : string; //kt 8-25-07 replace const with Fn.
	435	function TX_NEED3 : string; //kt 8-25-07 replace const with Fn.
	436	function TX_NEEDABORT : string; //kt 8-25-07 replace const with Fn.
	437	function TX_COS_REQ : string; //kt 8-25-07 replace const with Fn.
	438	function TX_COS_SELF : string; //kt 8-25-07 replace const with Fn.
	439	function TX_COS_AUTH : string; //kt 8-25-07 replace const with Fn.
	440	function TC_COS : string; //kt 8-25-07 replace const with Fn.
	441
	442	const
	443	TAG_IMMSERIES = 10;
	444	TAG_IMMREACTION= 20;
	445	TAG_SKRESULTS = 30;
	446	TAG_PEDLEVEL = 40;
	447	TAG_HFLEVEL = 50;
	448	TAG_XAMRESULTS = 60;
	449	TAG_HISTLOC = 70;
	450
	451	{ These piece numbers are used by both the PCE objects and reminders }
	452	pnumCode = 2;
	453	pnumPrvdrIEN = 2;
	454	pnumCategory = 3;
	455	pnumNarrative = 4;
	456	pnumExamResults = 5;
	457	pnumSkinResults = 5;
	458	pnumHFLevel = 5;
	459	pnumImmSeries = 5;
	460	pnumProcQty = 5;
	461	pnumPEDLevel = 5;
	462	pnumDiagPrimary = 5;
	463	pnumPrvdrName = 5;
	464	pnumProvider = 6;
	465	pnumPrvdrPrimary = 6;
	466	pnumSkinReading = 7;
	467	pnumImmReaction = 7;
	468	pnumDiagAdd2PL = 7;
	469	pnumSkinDTRead = 8;
	470	pnumImmContra = 8;
	471	pnumSkinDTGiven = 9;
	472	pnumImmRefused = 9;
	473	pnumCPTMods = 9;
	474	pnumComment = 10;
	475	pnumWHPapResult =11;
	476	pnumWHNotPurp =12;
	477
	478	USE_CURRENT_VISITSTR = -2;
	479
	480	implementation
	481
	482	uses uCore, rPCE, rCore, rTIU, fEncounterFrame, uVitals, fFrame,
	483	fPCEProvider, rVitals, uReminders
	484	,DKLang //kt
	485	;
	486
	487	const
	488	FN_NEW_PERSON = 200;
	489
	490	//kt PCETypeText: array[TPCEType] of string = ('encounter', 'reminder', 'template');
	491	function PCETypeText (index : TPCEType) : string; //kt 8/15/07
	492	begin
	493	Result := '';
	494	Case index of
	495	ptEncounter : Result := 'encounter';
	496	ptReminder : Result := 'reminder';
	497	ptTemplate : Result := 'template'
	498	end; {case}
	499	end;
	500
	501
	502	function PCEDataCatText (index : TPCEDataCat): string;
	503	begin
	504	Result := '';
	505	case index of
	506	pdcVisit : Result := '';
	507	pdcDiag : Result := DKLangConstW('uPCE_Diagnosesx');
	508	pdcProc : Result := DKLangConstW('uPCE_Proceduresx');
	509	pdcImm : Result := DKLangConstW('uPCE_Immunizationsx');
	510	pdcSkin : Result := DKLangConstW('uPCE_Skin_Testsx');
	511	pdcPED : Result := DKLangConstW('uPCE_Patient_Educationsx');
	512	pdcHF : Result := DKLangConstW('uPCE_Health_Factorsx');
	513	pdcExam : Result := DKLangConstW('uPCE_Examinationsx');
	514	pdcVital : Result := '';
	515	pdcOrder : Result := DKLangConstW('uPCE_Ordersx');
	516	pdcMH : Result := DKLangConstW('uPCE_Mental_Healthx');
	517	pdcMST : Result := DKLangConstW('uPCE_MST_Historyx');
	518	pdcHNC : Result := DKLangConstW('uPCE_Head_andxor_Neck_Cancerx');
	519	pdcWHR : Result := DKLangConstW('uPCE_Womenxxs_Health_Procedurex');
	520	pdcWH : Result := DKLangConstW('uPCE_WH_Notificationx');
	521	end; {case}
	522	end;
	523
	524	//kt 8-15-07 Begin mod. Converting constants into functions
	525	function TX_NO_VISIT: string; begin Result := DKLangConstW('uPCE_Insufficient_Visit_Information'); end; //kt added 8/8/2007
	526	function TX_NEED_PROV1: string; begin Result := DKLangConstW('uPCE_The_provider_responsible_for_this_encounter_must_be_entered_before'); end;
	527	function TX_NEED_PROV2: string; begin Result := DKLangConstW('uPCE_information_may_be_enteredx'); end;
	528	function TX_NEED_PROV3: string; begin Result := DKLangConstW('uPCE_you_can_sign_the_notex'); end;
	529	function TX_NO_PROV : string; begin Result := DKLangConstW('uPCE_Missing_Provider'); end;
	530	function TX_BAD_PROV : string; begin Result := DKLangConstW('uPCE_Invalid_Provider'); end;
	531	function TX_NOT_ACTIVE: string; begin Result := DKLangConstW('uPCE_does_not_have_an_active_person_classx'); end;
	532	function TX_NOT_PROV : string; begin Result := DKLangConstW('uPCE_is_not_a_known_Providerx'); end;
	533	function TX_MISSING : string; begin Result := DKLangConstW('uPCE_Required_Information_Missing'); end;
	534	function TX_REQ1 : string; begin Result := DKLangConstW('uPCE_The_following_required_fields_have_not_been_enteredx') + CRLF; end;
	535	function TC_REQ : string; begin Result := DKLangConstW('uPCE_Required_Fields'); end;
	536	function TX_ADDEND_AD : string;
	537	begin
	538	Result := DKLangConstW('uPCE_Cannot_make_an_addendum_to_an_addendum') + CRLF +
	539	DKLangConstW('uPCE_Please_select_the_parent_note_or_documentx_and_try_againx');
	540	end;
	541	function TX_ADDEND_MK : string; begin Result := DKLangConstW('uPCE_Unable_to_Make_Addendum'); end;
	542	function TX_DEL_CNF : string; begin Result := DKLangConstW('uPCE_Confirm_Deletion'); end;
	543	function TX_IN_AUTH : string; begin Result := DKLangConstW('uPCE_Insufficient_Authorization'); end;
	544	function TX_NOPCE : string; begin Result := DKLangConstW('uPCE_xNo_encounter_information_enteredx'); end;
	545	function TX_NEED_T : string; begin Result := DKLangConstW('uPCE_Missing_Encounter_Information'); end;
	546	function TX_NEED1 : string;
	547	begin
	548	Result := DKLangConstW('uPCE_This_note_title_is_marked_to_prompt_for_the_following_missing') + CRLF +
	549	DKLangConstW('uPCE_encounter_informationx') + CRLF;
	550	end;
	551	function TX_NEED_DIAG : string; begin Result := DKLangConstW('uPCE_A_diagnosisx'); end;
	552	function TX_NEED_PROC : string; begin Result := DKLangConstW('uPCE_A_visit_type_or_procedurex'); end;
	553	function TX_NEED_SC : string; begin Result := DKLangConstW('uPCE_One_or_more_service_connected_questionsx'); end;
	554	function TX_NEED2 : string; begin Result := DKLangConstW('uPCE_Would_you_like_to_enter_encounter_information_nowx'); end;
	555	function TX_NEED3 : string; begin Result := DKLangConstW('uPCE_You_must_enter_the_encounter_information_before_you_can_sign_the_notex'); end;
	556	function TX_NEEDABORT : string; begin Result := DKLangConstW('uPCE_Document_not_signedx'); end;
	557	function TX_COS_REQ : string; begin Result := DKLangConstW('uPCE_A_cosigner_is_required_for_this_documentx'); end;
	558	function TX_COS_SELF : string; begin Result := DKLangConstW('uPCE_You_cannot_make_yourself_a_cosignerx'); end;
	559	function TX_COS_AUTH : string; begin Result := DKLangConstW('uPCE_is_not_authorized_to_cosign_this_documentx'); end;
	560	function TC_COS : string; begin Result := DKLangConstW('uPCE_Select_Cosigner'); end;
	561
	562
	563	function InvalidPCEProviderTxt(AIEN: Int64; ADate: TFMDateTime): string;
	564	begin
	565	Result := '';
	566	if(not CheckActivePerson(IntToStr(AIEN), ADate)) then
	567	Result := TX_NOT_ACTIVE
	568	else
	569	if(not IsUserAProvider(AIEN, ADate)) then
	570	Result := TX_NOT_PROV;
	571	end;
	572
	573	function MissingProviderInfo(PCEEdit: TPCEData; PCEType: TPCEType = ptEncounter): boolean;
	574	begin
	575	if(PCEEdit.Empty and (PCEEdit.Location <> Encounter.Location) and (not Encounter.NeedVisit)) then
	576	PCEEdit.UseEncounter := TRUE;
	577	Result := NoPrimaryPCEProvider(PCEEdit.Providers, PCEEdit);
	578	if(Result) then
	579	//kt InfoBox(TX_NEED_PROV1 + PCETypeText[PCEType] + TX_NEED_PROV2, TX_NO_PROV, MB_OK or MB_ICONWARNING);
	580	InfoBox(TX_NEED_PROV1 + PCETypeText(PCEType) + TX_NEED_PROV2, TX_NO_PROV, MB_OK or MB_ICONWARNING);
	581	end;
	582
	583	var
	584	UNxtCommSeqNum: integer;
	585
	586	function IsOK2Sign(const PCEData: TPCEData; const IEN: integer) :boolean;
	587	var
	588	TmpPCEData: TPCEData;
	589
	590	begin
	591	if(assigned(PCEData)) then
	592	PCEData.FUpdated := FALSE;
	593	if(assigned(PCEData) and (PCEData.VisitString <> '') and
	594	(VisitStrForNote(IEN) = PCEData.VisitString)) then
	595	begin
	596	if(PCEData.FNoteIEN <= 0) then
	597	PCEData.FNoteIEN := IEN;
	598	Result := PCEData.OK2SignNote
	599	end
	600	else
	601	begin
	602	TmpPCEData := TPCEData.Create;
	603	try
	604	TmpPCEData.PCEForNote(IEN, nil);
	605	Result := TmpPCEData.OK2SignNote;
	606	finally
	607	TmpPCEData.Free;
	608	end;
	609	end;
	610	end;
	611
	612	function FutureEncounter(APCEData: TPCEData): boolean;
	613	begin
	614	Result := (Int(APCEData.FEncDateTime + 0.0000001) > Int(FMToday + 0.0000001));
	615	end;
	616
	617	function CanEditPCE(APCEData: TPCEData): boolean;
	618	begin
	619	if(GetAskPCE(APCEData.FEncLocation) = apDisable) then
	620	Result := FALSE
	621	else
	622	Result := (not FutureEncounter(APCEData));
	623	end;
	624
	625	procedure GetComboBoxMinMax(dest: TORComboBox; var Min, Max: integer);
	626	var
	627	DC: HDC;
	628	SaveFont: HFont;
	629	TextSize: TSize;
	630	TLen, i: integer;
	631	x: string;
	632
	633	begin
	634	Min := MaxInt;
	635	Max := 0;
	636	DC := GetDC(0);
	637	try
	638	SaveFont := SelectObject(DC, dest.Font.Handle);
	639	try
	640	for i := 0 to dest.Items.Count-1 do
	641	begin
	642	x := dest.DisplayText[i];
	643	GetTextExtentPoint32(DC, PChar(x), Length(x), TextSize);
	644	TLen := TextSize.cx;
	645	if(TLen > 0) and (Min > TLen) then
	646	Min := TLen;
	647	if(Max < TLen) then
	648	Max := TLen;
	649	end;
	650	finally
	651	SelectObject(DC, SaveFont);
	652	end;
	653	finally
	654	ReleaseDC(0, DC);
	655	end;
	656	if(Min > Max) then Min := Max;
	657
	658	inc(Min, ScrollBarWidth + 8);
	659	inc(Max, ScrollBarWidth + 8);
	660	end;
	661
	662	type
	663	TListMinMax = (mmMin, mmMax, mmFont);
	664
	665	var
	666	PCESetsOfCodes: TStringList = nil;
	667	HistLocations: TORStringList = nil;
	668	WHNotPurpose: TORStringList = nil;
	669	WHPapResult: TORStringList = nil;
	670	WHMammResult: TORStringList = nil;
	671	WHUltraResult: TORStringList = nil;
	672	const
	673	SetOfCodesHeader = '{^~Codes~^}';
	674	SOCHeaderLen = length(SetOfCodesHeader);
	675	ListMinMax: array[1..7, TListMinMax] of integer =
	676	((0,0,-1), // TAG_IMMSERIES
	677	(0,0,-1), // TAG_IMMREACTION
	678	(0,0,-1), // TAG_SKRESULTS
	679	(0,0,-1), // TAG_PEDLEVEL
	680	(0,0,-1), // TAG_HFLEVEL
	681	(0,0,-1), // TAG_XAMRESULTS
	682	(0,0,-1)); // TAG_HISTLOC
	683
	684	function CodeSetIndex(CodeType: integer): integer;
	685	var
	686	TempSL: TStringList;
	687	Hdr: string;
	688
	689	begin
	690	Hdr := SetOfCodesHeader + IntToStr(CodeType);
	691	Result := PCESetsOfCodes.IndexOf(Hdr);
	692	if(Result < 0) then
	693	begin
	694	TempSL := TStringList.Create;
	695	try
	696	case CodeType of
	697	TAG_IMMSERIES: LoadImmSeriesItems(TempSL);
	698	TAG_IMMREACTION: LoadImmReactionItems(TempSL);
	699	TAG_SKRESULTS: LoadSkResultsItems(TempSL);
	700	TAG_PEDLEVEL: LoadPEDLevelItems(TempSL);
	701	TAG_HFLEVEL: LoadHFLevelItems(TempSL);
	702	TAG_XAMRESULTS: LoadXAMResultsItems(TempSL);
	703	else
	704	KillObj(@TempSL);
	705	end;
	706	if(assigned(TempSL)) then
	707	begin
	708	Result := PCESetsOfCodes.Add(Hdr);
	709	PCESetsOfCodes.AddStrings(TempSL);
	710	end;
	711	finally
	712	KillObj(@TempSL);
	713	end;
	714	end;
	715	end;
	716
	717	procedure GetPCECodes(List: TStrings; CodeType: integer);
	718	var
	719	idx: integer;
	720
	721	begin
	722	if(CodeType = TAG_HISTLOC) then
	723	begin
	724	if(not assigned(HistLocations)) then
	725	begin
	726	HistLocations := TORStringList.Create;
	727	LoadHistLocations(HistLocations);
	728	HistLocations.SortByPiece(2);
	729	HistLocations.Insert(0,'0');
	730	end;
	731	List.AddStrings(HistLocations);
	732	end
	733	else
	734	begin
	735	if(not assigned(PCESetsOfCodes)) then
	736	PCESetsOfCodes := TStringList.Create;
	737	idx := CodeSetIndex(CodeType);
	738	if(idx >= 0) then
	739	begin
	740	inc(idx);
	741	while((idx < PCESetsOfCodes.Count) and
	742	(copy(PCESetsOfCodes[idx],1,SOCHeaderLen) <> SetOfCodesHeader)) do
	743	begin
	744	List.Add(PCESetsOfCodes[idx]);
	745	inc(idx);
	746	end;
	747	end;
	748	end;
	749	end;
	750
	751	function GetPCECodeString(CodeType: integer; ID: string): string;
	752	var
	753	idx: integer;
	754
	755	begin
	756	Result := '';
	757	if(CodeType <> TAG_HISTLOC) then
	758	begin
	759	if(not assigned(PCESetsOfCodes)) then
	760	PCESetsOfCodes := TStringList.Create;
	761	idx := CodeSetIndex(CodeType);
	762	if(idx >= 0) then
	763	begin
	764	inc(idx);
	765	while((idx < PCESetsOfCodes.Count) and
	766	(copy(PCESetsOfCodes[idx],1,SOCHeaderLen) <> SetOfCodesHeader)) do
	767	begin
	768	if(Piece(PCESetsOfCodes[idx], U, 1) = ID) then
	769	begin
	770	Result := Piece(PCESetsOfCodes[idx], U, 2);
	771	break;
	772	end;
	773	inc(idx);
	774	end;
	775	end;
	776	end;
	777	end;
	778
	779	procedure PCELoadORComboData(dest: TORComboBox; GetMinMax: boolean; var Min, Max: integer);
	780	var
	781	idx: integer;
	782
	783	begin
	784	if(dest.items.count < 1) then
	785	begin
	786	dest.Clear;
	787	GetPCECodes(dest.Items, dest.Tag);
	788	dest.itemindex := 0;
	789	if(GetMinMax) and (dest.Items.Count > 0) then
	790	begin
	791	idx := dest.Tag div 10;
	792	if(idx > 0) and (idx < 8) then
	793	begin
	794	if(ListMinMax[idx, mmFont] <> integer(dest.Font.Handle)) then
	795	begin
	796	GetComboBoxMinMax(dest, Min, Max);
	797	ListMinMax[idx, mmMin] := Min;
	798	ListMinMax[idx, mmMax] := Max;
	799	end
	800	else
	801	begin
	802	Min := ListMinMax[idx, mmMin];
	803	Max := ListMinMax[idx, mmMax];
	804	end;
	805	end;
	806	end;
	807	end;
	808	end;
	809
	810	procedure PCELoadORCombo(dest: TORComboBox);
	811	var
	812	tmp: integer;
	813
	814	begin
	815	PCELoadORComboData(dest, FALSE, tmp, tmp);
	816	end;
	817
	818	procedure PCELoadORCombo(dest: TORComboBox; var Min, Max: integer);
	819	begin
	820	PCELoadORComboData(dest, TRUE, Min, Max);
	821	end;
	822
	823	function GetPCEDisplayText(ID: string; Tag: integer): string;
	824	var
	825	Hdr: string;
	826	idx: integer;
	827	TempSL: TStringList;
	828
	829	begin
	830	Result := '';
	831	if(Tag = TAG_HISTLOC) then
	832	begin
	833	if(not assigned(HistLocations)) then
	834	begin
	835	HistLocations := TORStringList.Create;
	836	LoadHistLocations(HistLocations);
	837	HistLocations.SortByPiece(2);
	838	HistLocations.Insert(0,'0');
	839	end;
	840	idx := HistLocations.IndexOfPiece(ID);
	841	if(idx >= 0) then
	842	Result := Piece(HistLocations[idx], U, 2);
	843	end
	844	else
	845	begin
	846	if(not assigned(PCESetsOfCodes)) then
	847	PCESetsOfCodes := TStringList.Create;
	848	Hdr := SetOfCodesHeader + IntToStr(Tag);
	849	idx := PCESetsOfCodes.IndexOf(Hdr);
	850	if(idx < 0) then
	851	begin
	852	TempSL := TStringList.Create;
	853	try
	854	case Tag of
	855	TAG_IMMSERIES: LoadImmSeriesItems(TempSL);
	856	TAG_IMMREACTION: LoadImmReactionItems(TempSL);
	857	TAG_SKRESULTS: LoadSkResultsItems(TempSL);
	858	TAG_PEDLEVEL: LoadPEDLevelItems(TempSL);
	859	TAG_HFLEVEL: LoadHFLevelItems(TempSL);
	860	TAG_XAMRESULTS: LoadXAMResultsItems(TempSL);
	861	else
	862	KillObj(@TempSL);
	863	end;
	864	if(assigned(TempSL)) then
	865	begin
	866	idx := PCESetsOfCodes.Add(Hdr);
	867	PCESetsOfCodes.AddStrings(TempSL);
	868	end;
	869	finally
	870	KillObj(@TempSL);
	871	end;
	872	end;
	873	if(idx >= 0) then
	874	begin
	875	inc(idx);
	876	while((idx < PCESetsOfCodes.Count) and
	877	(copy(PCESetsOfCodes[idx],1,SOCHeaderLen) <> SetOfCodesHeader)) do
	878	begin
	879	if(Piece(PCESetsOfCodes[idx], U, 1) = ID) then
	880	begin
	881	Result := Piece(PCESetsOfCodes[idx], U, 2);
	882	break;
	883	end;
	884	inc(idx);
	885	end;
	886	end;
	887	end;
	888	end;
	889
	890	function GetPCEDataText(Cat: TPCEDataCat; Code, Category, Narrative: string;
	891	PrimaryDiag: boolean = FALSE; Qty: integer = 0): string;
	892	begin
	893	Result := '';
	894	case Cat of
	895	pdcVisit: if Code <> '' then Result := Category + ' ' + Narrative;
	896	pdcDiag: begin
	897	Result := Narrative;
	898	// if PrimaryDiag then Result := Result + ' (Primary)'; <-- original line. //kt 8/8/2007
	899	if PrimaryDiag then Result := Result + DKLangConstW('uPCE_xPrimaryx'); //kt added 8/8/2007
	900	end;
	901	pdcProc: begin
	902	Result := Narrative;
	903	// if Qty > 1 then Result := Result + ' (' + IntToStr(Qty) + ' times)'; <-- original line. //kt 8/8/2007
	904	if Qty > 1 then Result := Result + ' (' + IntToStr(Qty) + DKLangConstW('uPCE_timesx'); //kt added 8/8/2007
	905	end;
	906	else Result := Narrative;
	907	end;
	908	end;
	909
	910	procedure SetDefaultProvider(ProviderList: TPCEProviderList; APCEData: TPCEData);
	911	var
	912	SIEN, tmp: string;
	913	DefUser, AUser: Int64;
	914	UserName: string;
	915
	916	begin
	917	DefUser := Encounter.Provider;
	918	if(DefUser <> 0) and (InvalidPCEProviderTxt(DefUser, APCEData.PersonClassDate) <> '') then
	919	DefUser := 0;
	920	if(DefUser <> 0) then
	921	begin
	922	AUser := DefUser;
	923	UserName := Encounter.ProviderName;
	924	end
	925	else
	926	if(InvalidPCEProviderTxt(User.DUZ, APCEData.PersonClassDate) = '') then
	927	begin
	928	AUser := User.DUZ;
	929	UserName := User.Name;
	930	end
	931	else
	932	begin
	933	AUser := 0;
	934	UserName := '';
	935	end;
	936	if(AUser = 0) then
	937	ProviderList.FPendingUser := ''
	938	else
	939	ProviderList.FPendingUser := IntToStr(AUser) + U + UserName;
	940	ProviderList.FPendingDefault := '';
	941	tmp := DefaultProvider(APCEData.Location, DefUser, APCEData.PersonClassDate, APCEData.NoteIEN);
	942	SIEN := IntToStr(StrToIntDef(Piece(tmp,U,1),0));
	943	if(SIEN <> '0') then
	944	begin
	945	if(CheckActivePerson(SIEN, APCEData.PersonClassDate)) then
	946	begin
	947	if(piece(TIUSiteParams, U, 8) = '1') and // Check to see if DEFAULT PRIMARY PROVIDER is by Location
	948	(SIEN = IntToStr(User.DUZ)) then
	949	ProviderList.AddProvider(SIEN, Piece(tmp,U,2) ,TRUE)
	950	else
	951	ProviderList.FPendingDefault := tmp;
	952	end;
	953	end;
	954	end;
	955
	956	function ValidateGAFDate(var GafDate: TFMDateTime): string;
	957	var
	958	DateMsg: string;
	959	OKDate: TFMDateTime;
	960
	961	begin
	962	Result := '';
	963	if(Patient.DateDied > 0) and (FMToday > Patient.DateDied) then
	964	begin
	965	// DateMsg := 'Date of Death'; <-- original line. //kt 8/8/2007
	966	DateMsg := DKLangConstW('uPCE_Date_of_Death'); //kt added 8/8/2007
	967	OKDate := Patient.DateDied;
	968	end
	969	else
	970	begin
	971	// DateMsg := 'Today'; <-- original line. //kt 8/8/2007
	972	DateMsg := DKLangConstW('uPCE_Today'); //kt added 8/8/2007
	973	OKDate := FMToday;
	974	end;
	975	if(GafDate <= 0) then
	976	begin
	977	// Result := 'A date is required to enter a GAF score. Date Determined changed to ' + DateMsg + '.'; <-- original line. //kt 8/8/2007
	978	Result := DKLangConstW('uPCE_A_date_is_required_to_enter_a_GAF_scorex__Date_Determined_changed_to') + DateMsg + '.'; //kt added 8/8/2007
	979	GafDate := OKDate;
	980	end
	981	else
	982	if(Patient.DateDied > 0) and (GafDate > Patient.DateDied) then
	983	begin
	984	// Result := 'This patient died ' + FormatFMDateTime('mmm dd, yyyy hh:nn', Patient.DateDied) + <-- original line. //kt 8/8/2007
	985	Result := DKLangConstW('uPCE_This_patient_died')+' ' + FormatFMDateTime(DKLangConstW('uPCE_mmm_ddx_yyyy_hhxnn'), Patient.DateDied) + //kt added 8/8/2007
	986	// '. Date GAF determined can not ' + CRLF + <-- original line. //kt 8/8/2007
	987	DKLangConstW('uPCE_x__Date_GAF_determined_can_not') + CRLF + //kt added 8/8/2007
	988	// 'be later than the date of death, and has been changed to ' + DateMsg + '.'; <-- original line. //kt 8/8/2007
	989	DKLangConstW('uPCE_be_later_than_the_date_of_deathx_and_has_been_changed_to') + DateMsg + '.'; //kt added 8/8/2007
	990	GafDate := OKDate;
	991	end;
	992	end;
	993
	994	procedure GetVitalsFromDate(VitalStr: TStrings; PCEObj: TPCEData);
	995	var
	996	dte: TFMDateTime;
	997
	998	begin
	999	if(PCEObj.IsSecondaryVisit) then
	1000	dte := PCEObj.NoteDateTime
	1001	else
	1002	dte := PCEObj.DateTime;
	1003	GetVitalsFromEncDateTime(VitalStr, Patient.DFN, dte);
	1004	end;
	1005
	1006	procedure GetVitalsFromNote(VitalStr: TStrings; PCEObj: TPCEData; ANoteIEN: Int64);
	1007	begin
	1008	if(PCEObj.IsSecondaryVisit) then
	1009	GetVitalsFromEncDateTime(VitalStr, Patient.DFN, PCEObj.NoteDateTime)
	1010	else
	1011	GetVitalFromNoteIEN(VitalStr, Patient.DFN, ANoteIEN);
	1012	end;
	1013
	1014	{ TPCEItem methods ------------------------------------------------------------------------- }
	1015
	1016	//function TPCEItem.DelimitedStr2: string;
	1017	//added: 6/17/98
	1018	//By: Robert Bott
	1019	//Location: ISL
	1020	//Purpose: Return comment string to be passed in RPC call.
	1021	function TPCEItem.DelimitedStr2: string;
	1022	{created delimited string to pass to broker}
	1023	begin
	1024	If Comment = '' then
	1025	begin
	1026	result := 'COM' + U + IntToStr(UNxtCommSeqNum) + U + NoPCEValue;
	1027	end
	1028	else
	1029	begin
	1030	Result := 'COM' + U + IntToStr(UNxtCommSeqNum) + U + Comment;
	1031	end;
	1032
	1033	Inc(UNxtCommSeqNum); //set up for next comment
	1034	end;
	1035
	1036	procedure TPCEItem.Assign(Src: TPCEItem);
	1037	begin
	1038	FDelete := Src.FDelete;
	1039	FSend := Src.FSend;
	1040	Code := Src.Code;
	1041	Category := Src.Category;
	1042	Narrative := Src.Narrative;
	1043	Provider := Src.Provider;
	1044	Comment := Src.Comment;
	1045	end;
	1046
	1047	procedure TPCEItem.SetComment(const Value: String);
	1048	begin
	1049	FComment := Value;
	1050	while (length(FComment) > 0) and (FComment[1] = '?') do
	1051	delete(FComment,1,1);
	1052	end;
	1053
	1054
	1055	//procedure TPCEItem.Clear;
	1056	//modified: 6/17/98
	1057	//By: Robert Bott
	1058	//Location: ISL
	1059	//Purpose: Add Comments to PCE Items.
	1060	procedure TPCEItem.Clear;
	1061	{clear fields(properties) of class}
	1062	begin
	1063	FDelete := False;
	1064	FSend := False;
	1065	Code := '';
	1066	Category := '';
	1067	Narrative := '';
	1068	Provider := 0;
	1069	Comment := '';
	1070	end;
	1071
	1072	//function TPCEItem.DelimitedStr: string;
	1073	//modified: 6/17/98
	1074	//By: Robert Bott
	1075	//Location: ISL
	1076	//Purpose: Add Comments to PCE Items.
	1077	function TPCEItem.DelimitedStr: string;
	1078	{created delimited string to pass to broker}
	1079	var
	1080	DelFlag: Char;
	1081	begin
	1082	if FDelete then DelFlag := '-' else DelFlag := '+';
	1083	Result := DelFlag + U + Code + U + Category + U + Narrative;
	1084	end;
	1085
	1086	function TPCEItem.ItemStr: string;
	1087	{returns string to be assigned to Tlist in PCEData object}
	1088	begin
	1089	Result := Narrative;
	1090	end;
	1091
	1092	function TPCEItem.Match(AnItem: TPCEItem): Boolean;
	1093	{checks for match of Code, Category. and Item}
	1094	begin
	1095	Result := False;
	1096	if (Code = AnItem.Code) and (Category = AnItem.Category) and (Narrative = AnItem.Narrative)
	1097	then Result := True;
	1098	end;
	1099
	1100	function TPCEItem.HasCPTStr: string;
	1101	begin
	1102	Result := '';
	1103	end;
	1104
	1105	//procedure TPCEItem.SetFromString(const x: string);
	1106	//modified: 6/17/98
	1107	//By: Robert Bott
	1108	//Location: ISL
	1109	//Purpose: Add Comments to PCE Items.
	1110	procedure TPCEItem.SetFromString(const x: string);
	1111	{ sets fields to pieces passed from server: TYP ^ Code ^ Category ^ Narrative }
	1112	begin
	1113	Code := Piece(x, U, pnumCode);
	1114	Category := Piece(x, U, pnumCategory);
	1115	Narrative := Piece(x, U, pnumNarrative);
	1116	Provider := StrToInt64Def(Piece(x, U, pnumProvider), 0);
	1117	Comment := Piece(x, U, pnumComment);
	1118	end;
	1119
	1120
	1121	{ TPCEExams methods ------------------------------------------------------------------------- }
	1122
	1123	procedure TPCEExams.Assign(Src: TPCEItem);
	1124	begin
	1125	inherited Assign(Src);
	1126	Results := TPCEExams(Src).Results;
	1127	if Results = '' then Results := NoPCEValue;
	1128	end;
	1129
	1130	procedure TPCEExams.Clear;
	1131	{clear fields(properties) of class}
	1132	begin
	1133	inherited Clear;
	1134	// Provider := 0;
	1135	Results := NoPCEValue;
	1136	end;
	1137
	1138	//function TPCEExams.DelimitedStr: string;
	1139	//modified: 6/17/98
	1140	//By: Robert Bott
	1141	//Location: ISL
	1142	//Purpose: Add Comments to PCE Items.
	1143	function TPCEExams.DelimitedStr: string;
	1144	{created delimited string to pass to broker}
	1145	begin
	1146	Result := inherited DelimitedStr;
	1147	//Result := 'XAM' + Result + U + Results + U + IntToStr(Provider) +U + U + U +
	1148	Result := 'XAM' + Result + U + Results + U +U + U + U +
	1149	U + IntToStr(UNxtCommSeqNum);
	1150	end;
	1151
	1152	(*function TPCEExams.delimitedStrC: string;
	1153	begin
	1154	Result := inherited DelimitedStr;
	1155	Result := 'XAM' + Result + U + Results + U + IntToStr(Provider) +U + U + U +
	1156	U + comment;
	1157	end;
	1158	*)
	1159	function TPCEExams.HasCPTStr: string;
	1160	begin
	1161	Result := Code + ';AUTTEXAM(';
	1162	end;
	1163
	1164	function TPCEExams.ItemStr: string;
	1165	{returns string to be assigned to Tlist in PCEData object}
	1166	begin
	1167	if(Results <> NoPCEValue) then
	1168	Result := GetPCECodeString(TAG_XAMRESULTS, Results)
	1169	else
	1170	Result := '';
	1171	Result := Result + U + inherited ItemStr;
	1172	end;
	1173
	1174	procedure TPCEExams.SetFromString(const x: string);
	1175	{ sets fields to pieces passed from server: TYP ^ Code ^ Category ^ Narrative ^ Qty ^ Prov }
	1176	begin
	1177	inherited SetFromString(x);
	1178	// Provider := StrToInt64Def(Piece(x, U, pnumProvider), 0);
	1179	Results := Piece(x, U, pnumExamResults);
	1180	If results = '' then results := NoPCEValue;
	1181	end;
	1182
	1183
	1184	{ TPCESkin methods ------------------------------------------------------------------------- }
	1185
	1186	procedure TPCESkin.Assign(Src: TPCEItem);
	1187	var
	1188	SKSrc: TPCESkin;
	1189
	1190	begin
	1191	inherited Assign(Src);
	1192	SKSrc := TPCESkin(Src);
	1193	Results := SKSrc.Results;
	1194	Reading := SKSrc.Reading;
	1195	DTRead := SKSrc.DTRead;
	1196	DTGiven := SKSrc.DTGiven;
	1197	if Results = '' then Results := NoPCEValue;
	1198	end;
	1199
	1200	procedure TPCESkin.Clear;
	1201	{clear fields(properties) of class}
	1202	begin
	1203	inherited Clear;
	1204	// Provider := 0;
	1205	Results := NoPCEValue;
	1206	Reading := 0;
	1207	DTRead := 0.0; //What should dates be ititialized to?
	1208	DTGiven := 0.0;
	1209	end;
	1210
	1211	//function TPCESkin.DelimitedStr: string;
	1212	//modified: 6/17/98
	1213	//By: Robert Bott
	1214	//Location: ISL
	1215	//Purpose: Add Comments to PCE Items.
	1216	function TPCESkin.DelimitedStr: string;
	1217	{created delimited string to pass to broker}
	1218	begin
	1219	Result := inherited DelimitedStr;
	1220	//Result := 'SK' + Result + U + results + U + IntToStr(Provider) + U +
	1221	Result := 'SK' + Result + U + results + U + U +
	1222	IntToStr(Reading) + U + U + U + IntToStr(UNxtCommSeqNum);
	1223	//+ FloatToStr(DTRead) + U + FloatToStr(DTGiven);
	1224	end;
	1225
	1226	(*function TPCESkin.delimitedStrC: string;
	1227	begin
	1228	Result := inherited DelimitedStr;
	1229	Result := 'SK' + Result + U + results + U + IntToStr(Provider) + U +
	1230	IntToStr(Reading) + U + U + U + comment;
	1231	end;
	1232	*)
	1233	function TPCESkin.HasCPTStr: string;
	1234	begin
	1235	Result := Code + ';AUTTSK(';
	1236	end;
	1237
	1238	function TPCESkin.ItemStr: string;
	1239	{returns string to be assigned to Tlist in PCEData object}
	1240	begin
	1241	if(Results <> NoPCEValue) then
	1242	Result := GetPCECodeString(TAG_SKRESULTS, Results)
	1243	else
	1244	Result := '';
	1245	Result := Result + U;
	1246	if(Reading <> 0) then
	1247	Result := Result + IntToStr(Reading);
	1248	Result := Result + U + inherited ItemStr;
	1249	end;
	1250
	1251	procedure TPCESkin.SetFromString(const x: string);
	1252	{ sets fields to pieces passed from server: TYP ^ Code ^ Category ^ Narrative ^ Qty ^ Prov }
	1253	var
	1254	sRead, sDTRead, sDTGiven: String;
	1255	begin
	1256	inherited SetFromString(x);
	1257	// Provider := StrToInt64Def(Piece(x, U, pnumProvider), 0);
	1258	Results := Piece(x, U, pnumSkinResults);
	1259	sRead := Piece(x, U, pnumSkinReading);
	1260	sDTRead := Piece(x, U, pnumSkinDTRead);
	1261	sDtGiven := Piece(x, U, pnumSkinDTGiven);
	1262	If results = '' then results := NoPCEValue;
	1263
	1264	if sRead <> '' then
	1265	Reading := StrToInt(sRead);
	1266	if sDTRead <> '' then
	1267	DTRead := StrToFMDateTime(sDTRead);
	1268	if sDTGiven <> '' then
	1269	DTGiven := StrToFMDateTime(sDTGiven);
	1270
	1271	end;
	1272
	1273
	1274	{ TPCEHealth methods ------------------------------------------------------------------------- }
	1275
	1276	procedure TPCEHealth.Assign(Src: TPCEItem);
	1277	begin
	1278	inherited Assign(Src);
	1279	Level := TPCEHealth(Src).Level;
	1280	if Level = '' then Level := NoPCEValue;
	1281	end;
	1282
	1283	procedure TPCEHealth.Clear;
	1284	{clear fields(properties) of class}
	1285	begin
	1286	inherited Clear;
	1287	// Provider := 0;
	1288	Level := NoPCEValue;
	1289	end;
	1290
	1291	//function TPCEHealth.DelimitedStr: string;
	1292	//modified: 6/17/98
	1293	//By: Robert Bott
	1294	//Location: ISL
	1295	//Purpose: Add Comments to PCE Items.
	1296	function TPCEHealth.DelimitedStr: string;
	1297	{created delimited string to pass to broker}
	1298	begin
	1299	Result := inherited DelimitedStr;
	1300	// Result := 'HF' + Result + U + Level + U + IntToStr(Provider) + U + U + U +
	1301	Result := 'HF' + Result + U + Level + U + U + U + U +
	1302	U + IntToStr(UNxtCommSeqNum)+ U + GecRem;
	1303	end;
	1304
	1305	(*function TPCEHealth.delimitedStrC: string;
	1306	begin
	1307	Result := inherited DelimitedStr;
	1308	Result := 'HF' + Result + U + Level + U + IntToStr(Provider) + U + U + U +
	1309	U + comment;
	1310	end;
	1311	*)
	1312	function TPCEHealth.HasCPTStr: string;
	1313	begin
	1314	Result := Code + ';AUTTHF(';
	1315	end;
	1316
	1317	function TPCEHealth.ItemStr: string;
	1318	{returns string to be assigned to Tlist in PCEData object}
	1319	begin
	1320	if(Level <> NoPCEValue) then
	1321	Result := GetPCECodeString(TAG_HFLEVEL, Level)
	1322	else
	1323	Result := '';
	1324	Result := Result + U + inherited ItemStr;
	1325	end;
	1326
	1327	procedure TPCEHealth.SetFromString(const x: string);
	1328	{ sets fields to pieces passed from server: TYP ^ Code ^ Category ^ Narrative ^ Qty ^ Prov }
	1329	begin
	1330	inherited SetFromString(x);
	1331	// Provider := StrToInt64Def(Piece(x, U, pnumProvider), 0);
	1332	Level := Piece(x, U, pnumHFLevel);
	1333	if level = '' then level := NoPCEValue;
	1334	end;
	1335
	1336
	1337	{ TPCEImm methods ------------------------------------------------------------------------- }
	1338
	1339	procedure TPCEImm.Assign(Src: TPCEItem);
	1340	var
	1341	IMMSrc: TPCEImm;
	1342
	1343	begin
	1344	inherited Assign(Src);
	1345	IMMSrc := TPCEImm(Src);
	1346	Series := IMMSrc.Series;
	1347	Reaction := IMMSrc.Reaction;
	1348	Refused := IMMSrc.Refused;
	1349	Contraindicated := IMMSrc.Contraindicated;
	1350	if Series = '' then Series := NoPCEValue;
	1351	if Reaction ='' then Reaction := NoPCEValue;
	1352	end;
	1353
	1354	procedure TPCEImm.Clear;
	1355	{clear fields(properties) of class}
	1356	begin
	1357	inherited Clear;
	1358	// Provider := 0;
	1359	Series := NoPCEValue;
	1360	Reaction := NoPCEValue;
	1361	Refused := False; //not currently used
	1362	Contraindicated := false;
	1363	end;
	1364
	1365	//function TPCEImm.DelimitedStr: string;
	1366	//modified: 6/17/98
	1367	//By: Robert Bott
	1368	//Location: ISL
	1369	//Purpose: Add Comments to PCE Items.
	1370	function TPCEImm.DelimitedStr: string;
	1371	{created delimited string to pass to broker}
	1372	begin
	1373	Result := inherited DelimitedStr;
	1374	//Result := 'IMM' + Result + U + Series + U + IntToStr(Provider) + U + Reaction;
	1375	Result := 'IMM' + Result + U + Series + U + U + Reaction;
	1376	if Contraindicated then Result := Result + U + '1'
	1377	else Result := Result + U + '0';
	1378	Result := Result + U + U + IntToStr(UNxtCommSeqNum);
	1379	{the following two lines are not yet implemented in PCE side}
	1380	//if Refused then Result := Result + U + '1'
	1381	//else Result := Result + U + '0';
	1382	end;
	1383
	1384	(*function TPCEImm.delimitedStrC: string;
	1385	begin
	1386	Result := inherited DelimitedStr;
	1387	Result := 'IMM' + Result + U + Series + U + IntToStr(Provider) + U + Reaction;
	1388	if Contraindicated then Result := Result + U + '1'
	1389	else Result := Result + U + '0';
	1390	Result := Result + U + U + comment;
	1391	{the following two lines are not yet implemented in PCE side}
	1392	//if Refused then Result := Result + U + '1'
	1393	//else Result := Result + U + '0';
	1394	end;
	1395	*)
	1396	function TPCEImm.HasCPTStr: string;
	1397	begin
	1398	Result := Code + ';AUTTIMM(';
	1399	end;
	1400
	1401	function TPCEImm.ItemStr: string;
	1402	{returns string to be assigned to Tlist in PCEData object}
	1403	begin
	1404	if(Series <> NoPCEValue) then
	1405	Result := GetPCECodeString(TAG_IMMSERIES, Series)
	1406	else
	1407	Result := '';
	1408	Result := Result + U;
	1409	if(Reaction <> NoPCEValue) then
	1410	Result := Result + GetPCECodeString(TAG_IMMREACTION, Reaction);
	1411	Result := Result + U;
	1412	if(Contraindicated) then
	1413	Result := Result + 'X';
	1414	Result := Result + U + inherited ItemStr;
	1415	end;
	1416
	1417	procedure TPCEImm.SetFromString(const x: string);
	1418	{ sets fields to pieces passed from server: TYP ^ Code ^ Category ^ Narrative ^ Qty ^ Prov }
	1419	var
	1420	temp: String;
	1421	begin
	1422	inherited SetFromString(x);
	1423	// Provider := StrToInt64Def(Piece(x, U, pnumProvider), 0);
	1424	Series := Piece(x, U, pnumImmSeries);
	1425	Reaction := Piece(x, U, pnumImmReaction);
	1426	temp := Piece(x, U, pnumImmRefused);
	1427	if temp = '1' then refused := true else refused := false;
	1428	temp := Piece(x, U, pnumImmContra);
	1429	if temp = '1' then Contraindicated := true else Contraindicated := false;
	1430	if Series = '' then series := NoPCEValue;
	1431	if Reaction ='' then reaction := NoPCEValue;
	1432	end;
	1433
	1434
	1435
	1436	{ TPCEProc methods ------------------------------------------------------------------------- }
	1437
	1438	procedure TPCEProc.Assign(Src: TPCEItem);
	1439	begin
	1440	inherited Assign(Src);
	1441	Quantity := TPCEProc(Src).Quantity;
	1442	Modifiers := TPCEProc(Src).Modifiers;
	1443	Provider := TPCEProc(Src).Provider;
	1444	end;
	1445
	1446	procedure TPCEProc.Clear;
	1447	{clear fields(properties) of class}
	1448	begin
	1449	inherited Clear;
	1450	Quantity := 0;
	1451	Modifiers := '';
	1452	// Provider := 0;
	1453	Provider := 0;
	1454	end;
	1455
	1456	procedure TPCEProc.CopyProc(Dest: TPCEProc);
	1457	begin
	1458	Dest.FDelete := FDelete;
	1459	Dest.FSend := Fsend; //flag to send to broker
	1460	// Dest.Provider := Provider;
	1461	Dest.Provider := Provider;
	1462	Dest.Code := Code;
	1463	Dest.Category := Category;
	1464	Dest.Narrative := Narrative;
	1465	Dest.Comment := Comment;
	1466	Dest.Modifiers := Modifiers;
	1467	end;
	1468
	1469	//function TPCEProc.DelimitedStr: string;
	1470	//modified: 6/17/98
	1471	//By: Robert Bott
	1472	//Location: ISL
	1473	//Purpose: Add Comments to PCE Items.
	1474	function TPCEProc.DelimitedStr: string;
	1475	var
	1476	i, cnt: integer;
	1477	Mods, ModIEN, tmpProv: string;
	1478
	1479	{created delimited string to pass to broker}
	1480	begin
	1481	i := 1;
	1482	cnt := 0;
	1483	Mods := '';
	1484	repeat
	1485	ModIEN := piece(Modifiers, ';', i);
	1486	if(ModIEN <> '') then
	1487	begin
	1488	inc(cnt);
	1489	Mods := Mods + ';' + ModifierCode(ModIEN) + '/' + ModIEN;
	1490	inc(i);
	1491	end;
	1492	until (ModIEN = '');
	1493
	1494	Result := inherited DelimitedStr;
	1495	if Provider > 0 then tmpProv := IntToStr(Provider) else tmpProv := '';
	1496	Result := 'CPT' + Result + U + IntToStr(Quantity) + U + tmpProv
	1497	+ U + U + U + IntToStr(cnt) + Mods + U + IntToStr(UNxtCommSeqNum) + U;
	1498	if Length(Result) > 250 then SetPiece(Result, U, 4, '');
	1499	end;
	1500
	1501	(*function TPCEProc.delimitedStrC: string;
	1502	begin
	1503	Result := inherited DelimitedStr;
	1504	Result := 'CPT' + Result + U + IntToStr(Quantity) + U + IntToStr(Provider) +
	1505	U + U + U + U + comment;
	1506	end;
	1507	*)
	1508
	1509	function TPCEProc.Empty: boolean;
	1510	begin
	1511	Result := (Code = '') and (Category = '') and (Narrative = '') and
	1512	(Comment = '') and (Quantity = 0) and (Provider = 0) and (Modifiers = '');
	1513	end;
	1514
	1515	(*function TPCEProc.Match(AnItem: TPCEProc): Boolean; {NEW CODE - v20 testing only - RV}
	1516	begin
	1517	Result := inherited Match(AnItem) and (Modifiers = AnItem.Modifiers);
	1518	end;*)
	1519
	1520	function TPCEProc.ModText: string;
	1521	var
	1522	i: integer;
	1523	tmp: string;
	1524
	1525	begin
	1526	Result := '';
	1527	if(Modifiers <> '') then
	1528	begin
	1529	i := 1;
	1530	repeat
	1531	tmp := Piece(Modifiers,';',i);
	1532	if(tmp <> '') then
	1533	begin
	1534	tmp := ModifierName(tmp);
	1535	Result := Result + ' - ' + tmp;
	1536	end;
	1537	inc(i);
	1538	until (tmp = '');
	1539	end;
	1540	end;
	1541
	1542	function TPCEProc.ItemStr: string;
	1543	{returns string to be assigned to Tlist in PCEData object}
	1544	begin
	1545	if(Quantity > 1) then
	1546	// Result := IntToStr(Quantity) + ' times' <-- original line. //kt 8/8/2007
	1547	Result := IntToStr(Quantity) + DKLangConstW('uPCE_times') //kt added 8/8/2007
	1548	else
	1549	Result := '';
	1550	Result := Result + U + inherited ItemStr + ModText;
	1551	end;
	1552
	1553	procedure TPCEProc.SetFromString(const x: string);
	1554	var
	1555	i, cnt: integer;
	1556	Mods: string;
	1557	{ sets fields to pieces passed from server: TYP ^ Code ^ Category ^ Narrative ^ Qty ^ Prov }
	1558	begin
	1559	inherited SetFromString(x);
	1560	Quantity := StrToIntDef(Piece(x, U, pnumProcQty), 1);
	1561	// Provider := StrToInt64Def(Piece(x, U, pnumProvider), 0);
	1562	Provider := StrToInt64Def(Piece(x, U, pnumProvider), 0);
	1563	Modifiers := '';
	1564	Mods := Piece(x, U, pnumCPTMods);
	1565	cnt := StrToIntDef(Piece(Mods, ';', 1), 0);
	1566	if(cnt > 0) then
	1567	for i := 1 to cnt do
	1568	Modifiers := Modifiers + Piece(Piece(Mods, ';' , i+1), '/', 2) + ';';
	1569	end;
	1570
	1571
	1572	{ TPCEPat methods ------------------------------------------------------------------------- }
	1573
	1574	procedure TPCEPat.Assign(Src: TPCEItem);
	1575	begin
	1576	inherited Assign(Src);
	1577	Level := TPCEPat(Src).Level;
	1578	if Level = '' then Level := NoPCEValue;
	1579	end;
	1580
	1581	procedure TPCEPat.Clear;
	1582	{clear fields(properties) of class}
	1583	begin
	1584	inherited Clear;
	1585	// Provider := 0;
	1586	Level := NoPCEValue;
	1587	end;
	1588
	1589	//function TPCEPat.DelimitedStr: string;
	1590	//modified: 6/17/98
	1591	//By: Robert Bott
	1592	//Location: ISL
	1593	//Purpose: Add Comments to PCE Items.
	1594	function TPCEPat.DelimitedStr: string;
	1595	{created delimited string to pass to broker}
	1596	begin
	1597	Result := inherited DelimitedStr;
	1598	//Result := 'PED' + Result + U + Level + U + IntToStr(Provider) + U + U + U +
	1599	Result := 'PED' + Result + U + Level + U+ U + U + U +
	1600	U + IntToStr(UNxtCommSeqNum);
	1601	end;
	1602
	1603	(*function TPCEPat.delimitedStrC: string;
	1604	begin
	1605	Result := inherited DelimitedStr;
	1606	Result := 'PED' + Result + U + Level + U + IntToStr(Provider) + U + U + U +
	1607	U + comment;
	1608	end;
	1609	*)
	1610	function TPCEPat.HasCPTStr: string;
	1611	begin
	1612	Result := Code + ';AUTTEDT(';
	1613	end;
	1614
	1615	function TPCEPat.ItemStr: string;
	1616	{returns string to be assigned to Tlist in PCEData object}
	1617	begin
	1618	if(Level <> NoPCEValue) then
	1619	Result := GetPCECodeString(TAG_PEDLEVEL, Level)
	1620	else
	1621	Result := '';
	1622	Result := Result + U + inherited ItemStr;
	1623	end;
	1624
	1625	procedure TPCEPat.SetFromString(const x: string);
	1626	{ sets fields to pieces passed from server: TYP ^ Code ^ Category ^ Narrative ^ Qty ^ Prov }
	1627	begin
	1628	inherited SetFromString(x);
	1629	// Provider := StrToInt64Def(Piece(x, U, pnumProvider), 0);
	1630	Level := Piece(x, U, pnumPEDLevel);
	1631	if level = '' then level := NoPCEValue;
	1632	end;
	1633
	1634	{ TPCEDiag methods ------------------------------------------------------------------------- }
	1635
	1636	procedure TPCEDiag.Assign(Src: TPCEItem);
	1637	begin
	1638	inherited Assign(Src);
	1639	Primary := TPCEDiag(Src).Primary;
	1640	AddProb := TPCEDiag(Src).AddProb;
	1641	end;
	1642
	1643	//procedure TPCEDiag.Clear;
	1644	//modified: 6/17/98
	1645	//By: Robert Bott
	1646	//Location: ISL
	1647	//Purpose: Clear a diagnosis object.
	1648	procedure TPCEDiag.Clear;
	1649	{clear fields(properties) of class}
	1650	begin
	1651	inherited Clear;
	1652	Primary := False;
	1653	//Provider := 0;
	1654	AddProb := False;
	1655	end;
	1656
	1657	//function TPCEDiag.DelimitedStr: string;
	1658	//modified: 6/17/98
	1659	//By: Robert Bott
	1660	//Location: ISL
	1661	//Purpose: Create delimited string to pass to Broker.
	1662	function TPCEDiag.DelimitedStr: string;
	1663	{created delimited string to pass to broker}
	1664	var
	1665	ProviderStr: string; {jm 9/8/99}
	1666	begin
	1667	Result := inherited DelimitedStr;
	1668	if(AddProb) then
	1669	ProviderStr := IntToStr(fProvider)
	1670	else
	1671	ProviderStr := '';
	1672	Result := 'POV' + Result + U + BOOLCHAR[Primary] + U + ProviderStr + U +
	1673	BOOLCHAR[AddProb] + U + U + U;
	1674	if(SaveComment) then Result := Result + IntToStr(UNxtCommSeqNum);
	1675	if Length(Result) > 250 then SetPiece(Result, U, 4, '');
	1676	end;
	1677
	1678	function TPCEDiag.DelimitedStr2: string;
	1679	begin
	1680	If Comment = '' then
	1681	begin
	1682	SaveComment := (OldComment <> '') or (not AddProb);
	1683	if(SaveComment) then
	1684	result := 'COM' + U + IntToStr(UNxtCommSeqNum) + U + NoPCEValue
	1685	else
	1686	result := '';
	1687	end
	1688	else
	1689	begin
	1690	Result := 'COM' + U + IntToStr(UNxtCommSeqNum) + U + Comment;
	1691	SaveComment := TRUE;
	1692	end;
	1693	Inc(UNxtCommSeqNum);
	1694	end;
	1695
	1696	(*function TPCEDiag.DelimitedStrC: string;
	1697	{created delimited string for internal use - keep comment in same string.}
	1698	begin
	1699	Result := inherited DelimitedStr;
	1700	Result := 'POV' + Result + U + BOOLCHAR[Primary] + U + IntToStr(Provider)+
	1701	U + BOOLCHAR[AddProb] + U + U + U + comment;
	1702	end;
	1703	*)
	1704	function TPCEDiag.ItemStr: string;
	1705	{returns string to be assigned to Tlist in PCEData object}
	1706	begin
	1707	if Primary then
	1708	// Result := 'Primary' <-- original line. //kt 8/8/2007
	1709	Result := DKLangConstW('uPCE_Primary') //kt added 8/8/2007
	1710	else
	1711	// Result := 'Secondary'; <-- original line. //kt 8/8/2007
	1712	Result := DKLangConstW('uPCE_Secondary'); //kt added 8/8/2007
	1713	// This may change in the future if we add a check box to the grid
	1714	if(AddProb) then
	1715	// Result := 'Add' + U + Result <-- original line. //kt 8/8/2007
	1716	Result := DKLangConstW('uPCE_Add') + U + Result //kt added 8/8/2007
	1717	else
	1718	Result := U + Result;
	1719
	1720	Result := Result + U + inherited ItemStr;
	1721	end;
	1722
	1723	procedure TPCEDiag.Send;
	1724	//marks diagnosis to be sent;
	1725	begin
	1726	Fsend := True;
	1727	end;
	1728
	1729	//procedure TPCEDiag.SetFromString(const x: string);
	1730	//modified: 6/17/98
	1731	//By: Robert Bott
	1732	//Location: ISL
	1733	//Purpose: Sets fields to pieces passed from server.
	1734	procedure TPCEDiag.SetFromString(const x: string);
	1735	{ sets fields to pieces passed from server: TYP ^ Code ^ Category ^ Narrative ^ Primary ^ ^ ^ Comment }
	1736	begin
	1737	inherited SetFromString(x);
	1738	OldComment := Comment;
	1739	Primary := (Piece(x, U, pnumDiagPrimary) = '1');
	1740	//Provider := StrToInt64Def(Piece(x, U, pnumProvider),0);
	1741	AddProb := (Piece(x, U, pnumDiagAdd2PL) = '1');
	1742	end;
	1743
	1744	{ TPCEData methods ------------------------------------------------------------------------- }
	1745
	1746	constructor TPCEData.Create;
	1747	begin
	1748	FDiagnoses := TList.Create;
	1749	FProcedures := TList.Create;
	1750	FImmunizations := TList.Create;
	1751	FSkinTests := TList.Create;
	1752	FVisitType := TPCEProc.Create;
	1753	FPatientEds := TList.Create;
	1754	FHealthFactors := TList.Create;
	1755	fExams := TList.Create;
	1756	FProviders := TPCEProviderList.Create;
	1757	FSCRelated := SCC_NA;
	1758	FAORelated := SCC_NA;
	1759	FIRRelated := SCC_NA;
	1760	FECRelated := SCC_NA;
	1761	FMSTRelated := SCC_NA;
	1762	FHNCRelated := SCC_NA;
	1763	FCVRelated := SCC_NA;
	1764	FSCChanged := False;
	1765	end;
	1766
	1767	destructor TPCEData.Destroy;
	1768	var
	1769	i: Integer;
	1770	begin
	1771	with FDiagnoses do for i := 0 to Count - 1 do TPCEDiag(Items[i]).Free;
	1772	with FProcedures do for i := 0 to Count - 1 do TPCEProc(Items[i]).Free;
	1773	with FImmunizations do for i := 0 to Count - 1 do TPCEImm(Items[i]).Free;
	1774	with FSkinTests do for i := 0 to Count - 1 do TPCESkin(Items[i]).Free;
	1775	with FPatientEds do for i := 0 to Count - 1 do TPCEPat(Items[i]).Free;
	1776	with FHealthFactors do for i := 0 to Count - 1 do TPCEHealth(Items[i]).Free;
	1777	with FExams do for i := 0 to Count - 1 do TPCEExams(Items[i]).Free;
	1778	FVisitType.Free;
	1779	FDiagnoses.Free;
	1780	FProcedures.Free;
	1781	FImmunizations.Free;
	1782	FSkinTests.free;
	1783	FPatientEds.Free;
	1784	FHealthFactors.Free;
	1785	FExams.Free;
	1786	FProviders.Free;
	1787	inherited Destroy;
	1788	end;
	1789
	1790	procedure TPCEData.Clear;
	1791
	1792	procedure ClearList(AList: TList);
	1793	var
	1794	i: Integer;
	1795
	1796	begin
	1797	for i := 0 to AList.Count - 1 do
	1798	TObject(AList[i]).Free;
	1799	AList.Clear;
	1800	end;
	1801
	1802	begin
	1803	FEncDateTime := 0;
	1804	FNoteDateTime := 0;
	1805	FEncLocation := 0;
	1806	FEncSvcCat := 'A';
	1807	FEncInpatient := FALSE;
	1808	FEncUseCurr := FALSE;
	1809	FStandAlone := FALSE;
	1810	FStandAloneLoaded := FALSE;
	1811	FParent := '';
	1812	FHistoricalLocation := '';
	1813	FSCRelated := SCC_NA;
	1814	FAORelated := SCC_NA;
	1815	FIRRelated := SCC_NA;
	1816	FECRelated := SCC_NA;
	1817	FMSTRelated := SCC_NA;
	1818	FHNCRelated := SCC_NA;
	1819	FCVRelated := SCC_NA;
	1820
	1821	ClearList(FDiagnoses);
	1822	ClearList(FProcedures);
	1823	ClearList(FImmunizations);
	1824	ClearList(FSkinTests);
	1825	ClearList(FPatientEds);
	1826	ClearList(FHealthFactors);
	1827	ClearList(FExams);
	1828
	1829	FVisitType.Clear;
	1830	FProviders.Clear;
	1831	FSCChanged := False;
	1832	FNoteIEN := 0;
	1833	FNoteTitle := 0;
	1834	end;
	1835
	1836	procedure TPCEData.CopyDiagnoses(Dest: TStrings);
	1837	begin
	1838	CopyPCEItems(FDiagnoses, Dest, TPCEDiag);
	1839	end;
	1840
	1841	procedure TPCEData.CopyProcedures(Dest: TStrings);
	1842	begin
	1843	CopyPCEItems(FProcedures, Dest, TPCEProc);
	1844	end;
	1845
	1846	procedure TPCEData.CopyImmunizations(Dest: TStrings);
	1847	begin
	1848	CopyPCEItems(FImmunizations, Dest, TPCEImm);
	1849	end;
	1850
	1851	procedure TPCEData.CopySkinTests(Dest: TStrings);
	1852	begin
	1853	CopyPCEItems(FSkinTests, Dest, TPCESkin);
	1854	end;
	1855
	1856	procedure TPCEData.CopyPatientEds(Dest: TStrings);
	1857	begin
	1858	CopyPCEItems(FPatientEds, Dest, TPCEPat);
	1859	end;
	1860
	1861	procedure TPCEData.CopyHealthFactors(Dest: TStrings);
	1862	begin
	1863	CopyPCEItems(FHealthFactors, Dest, TPCEHealth);
	1864	end;
	1865
	1866	procedure TPCEData.CopyExams(Dest: TStrings);
	1867	begin
	1868	CopyPCEItems(FExams, Dest, TPCEExams);
	1869	end;
	1870
	1871	function TPCEData.GetVisitString: string;
	1872	begin
	1873	Result := IntToStr(FEncLocation) + ';' + FloatToStr(VisitDateTime) + ';' + FEncSvcCat;
	1874	end;
	1875
	1876	function TPCEData.GetCPTRequired: Boolean;
	1877	begin
	1878	Result := (([ndDiag, ndProc] * NeededPCEData) <> []);
	1879	end;
	1880
	1881	procedure TPCEData.PCEForNote(NoteIEN: Integer; EditObj: TPCEData);
	1882	(*const
	1883	NULL_STR = '';
	1884	begin
	1885	PCEForNote(NoteIEN, EditObj, NULL_STR);
	1886	end;
	1887
	1888	procedure TPCEData.PCEForNote(NoteIEN: Integer; EditObj: TPCEData; DCSummAdmitString: string);*)
	1889	var
	1890	i, j: Integer;
	1891	TmpCat, TmpVStr: string;
	1892	x: string;
	1893	DoCopy, IsVisit: Boolean;
	1894	PCEList, VisitTypeList: TStringList;
	1895	ADiagnosis: TPCEDiag;
	1896	AProcedure: TPCEProc;
	1897	AImmunization: TPCEImm;
	1898	ASkinTest: TPCESkin;
	1899	APatientEd: TPCEPat;
	1900	AHealthFactor: TPCEHealth;
	1901	AExam: TPCEExams;
	1902	FileVStr: string;
	1903	FileIEN: integer;
	1904	GetCat, DoRestore: boolean;
	1905	FRestDate: TFMDateTime;
	1906	// AProvider: TPCEProvider; {6/9/99}
	1907
	1908	function SCCValue(x: string): Integer;
	1909	begin
	1910	Result := SCC_NA;
	1911	if Piece(x, U, 3) = '1' then Result := SCC_YES;
	1912	if Piece(x, U, 3) = '0' then Result := SCC_NO;
	1913	end;
	1914
	1915	function AppendComment(x: string): String;
	1916	begin
	1917	//check for comment append string if a comment exists
	1918	If (((i+1) <= (PCEList.Count - 1)) and (Copy(PCEList[(i+1)], 1, 3) = 'COM')) then
	1919	begin
	1920	//remove last piece (comment sequence number) from x.
	1921	While x[length(x)] <> U do
	1922	x := Copy(X,0,(length(x)-1));
	1923	//add last piece of comment to x
	1924	x := X + Piece (PCEList[(i+1)],U,3);
	1925	end;
	1926	result := x;
	1927	end;
	1928
	1929	begin
	1930	(* if DCSummAdmitString <> '' then
	1931	TmpVStr := DCSummAdmitString
	1932	else*) if(NoteIEN < 1) then
	1933	TmpVStr := Encounter.VisitStr
	1934	else
	1935	begin
	1936	TmpVStr := VisitStrForNote(NoteIEN);
	1937	if(FEncSvcCat = #0) then
	1938	GetCat :=TRUE
	1939	else
	1940	if(GetVisitString = '0;0;A') then
	1941	begin
	1942	FEncLocation := StrToIntDef(Piece(TmpVStr, ';', 1), 0);
	1943	FEncDateTime := StrToFloatDef(Piece(TmpVStr, ';', 2),0);
	1944	GetCat :=TRUE
	1945	end
	1946	else
	1947	GetCat := FALSE;
	1948	if(GetCat) then
	1949	begin
	1950	TmpCat := Piece(TmpVStr, ';', 3);
	1951	if(TmpCat <> '') then
	1952	FEncSvcCat := TmpCat[1];
	1953	end;
	1954	end;
	1955
	1956	if(assigned(EditObj)) then
	1957	begin
	1958	if(copy(TmpVStr,1,2) <> '0;') and // has location
	1959	(pos(';0;',TmpVStr) = 0) and // has time
	1960	(EditObj.GetVisitString = TmpVStr) then
	1961	begin
	1962	if(FEncSvcCat = 'H') and (FEncInpatient) then
	1963	DoCopy := (FNoteDateTime = EditObj.FNoteDateTime)
	1964	else
	1965	DoCopy := TRUE;
	1966	if(DoCopy) then
	1967	begin
	1968	if(EditObj <> Self) then
	1969	begin
	1970	EditObj.CopyPCEData(Self);
	1971	FNoteTitle := 0;
	1972	FNoteIEN := 0;
	1973	end;
	1974	exit;
	1975	end;
	1976	end;
	1977	end;
	1978
	1979	TmpCat := Piece(TmpVStr, ';', 3);
	1980	if(TmpCat <> '') then
	1981	FEncSvcCat := TmpCat[1]
	1982	else
	1983	FEncSvcCat := #0;
	1984	FEncLocation := StrToIntDef(Piece(TmpVStr,';',1),0);
	1985	FEncDateTime := StrToFloatDef(Piece(TmpVStr, ';', 2),0);
	1986
	1987	if(IsSecondaryVisit and (FEncLocation > 0)) then
	1988	begin
	1989	FileIEN := USE_CURRENT_VISITSTR;
	1990	FileVStr := IntToStr(FEncLocation) + ';' + FloatToStr(FNoteDateTime) + ';' +
	1991	GetLocSecondaryVisitCode(FEncLocation);
	1992	DoRestore := TRUE;
	1993	FRestDate := FEncDateTime;
	1994	end
	1995	else
	1996	begin
	1997	DoRestore := FALSE;
	1998	FRestDate := 0;
	1999	FileIEN := NoteIEN;
	2000	(* if DCSummAdmitString <> '' then
	2001	FileVStr := DCSummAdmitString
	2002	else*) if(FileIEN < 0) then
	2003	FileVStr := Encounter.VisitStr
	2004	else
	2005	FileVStr := '';
	2006	end;
	2007
	2008	Clear;
	2009	PCEList := TStringList.Create;
	2010	VisitTypeList := TStringList.Create;
	2011	try
	2012	LoadPCEDataForNote(PCEList, FileIEN, FileVStr); // calls broker RPC to load data
	2013	FNoteIEN := NoteIEN;
	2014	for i := 0 to PCEList.Count - 1 do
	2015	begin
	2016	x := PCEList[i];
	2017	if Copy(x, 1, 4) = 'HDR^' then // HDR ^ Inpatient ^ ProcReq ^ VStr ^ Provider
	2018	{header information-------------------------------------------------------------}
	2019	begin
	2020	FEncInpatient := Piece(x, U, 2) = '1';
	2021	//FCPTRequired := Piece(x, U, 3) = '1';
	2022	//FNoteHasCPT := Piece(x, U, 6) = '1'; //4/21/99 error! PIECE 3 = cptRequired, not HasCPT!
	2023	FEncLocation := StrToIntDef(Piece(Piece(x, U, 4), ';', 1), 0);
	2024	if DoRestore then
	2025	begin
	2026	FEncSvcCat := 'H';
	2027	FEncDateTime := FRestDate;
	2028	FNoteDateTime := MakeFMDateTime(Piece(Piece(x, U, 4), ';', 2));
	2029	end
	2030	else
	2031	begin
	2032	FEncDateTime := MakeFMDateTime(Piece(Piece(x, U, 4), ';', 2));
	2033	FEncSvcCat := CharAt(Piece(Piece(x, U, 4), ';', 3), 1);
	2034	end;
	2035	//FEncProvider := StrToInt64Def(Piece(x, U, 5), 0);
	2036	ListVisitTypeByLoc(VisitTypeList, FEncLocation, FEncDateTime);
	2037	//set the values needed fot the RPCs
	2038	SetRPCEncLocation(FEncLocation);
	2039	// SetRPCEncDateTime(FEncDateTime);
	2040	end;
	2041	{visit information--------------------------------------------------------------}
	2042	if Copy(x, 1, 7) = 'VST^DT^' then
	2043	begin
	2044	if DoRestore then
	2045	begin
	2046	FEncDateTime := FRestDate;
	2047	FNoteDateTime := MakeFMDateTime(Piece(x, U, 3));
	2048	end
	2049	else
	2050	FEncDateTime := MakeFMDateTime(Piece(x, U, 3));
	2051	end;
	2052	if Copy(x, 1, 7) = 'VST^HL^' then FEncLocation := StrToIntDef(Piece(x, U, 3), 0);
	2053	if Copy(x, 1, 7) = 'VST^VC^' then
	2054	begin
	2055	if DoRestore then
	2056	FEncSvcCat := 'H'
	2057	else
	2058	FEncSvcCat := CharAt(x, 8);
	2059	end;
	2060	if Copy(x, 1, 7) = 'VST^PS^' then FEncInpatient := CharAt(x, 8) = '1';
	2061	{6/10/99}//if Copy(x, 1, 4) = 'PRV^' then FEncProvider := StrToInt64Def(Piece(x, U, 2), 0);
	2062	if Copy(x, 1, 7) = 'VST^SC^' then FSCRelated := SCCValue(x);
	2063	if Copy(x, 1, 7) = 'VST^AO^' then FAORelated := SCCValue(x);
	2064	if Copy(x, 1, 7) = 'VST^IR^' then FIRRelated := SCCValue(x);
	2065	if Copy(x, 1, 7) = 'VST^EC^' then FECRelated := SCCValue(x);
	2066	if Copy(x, 1, 8) = 'VST^MST^' then FMSTRelated := SCCValue(x);
	2067	// if HNCOK and (Copy(x, 1, 8) = 'VST^HNC^') then
	2068	if Copy(x, 1, 8) = 'VST^HNC^' then FHNCRelated := SCCValue(x);
	2069	if Copy(x, 1, 7) = 'VST^CV^' then FCVRelated := SCCValue(x);
	2070	if (Copy(x, 1, 3) = 'PRV') and (CharAt(x, 4) <> '-') then
	2071	{Providers---------------------------------------------------------------------}
	2072	begin
	2073	FProviders.Add(x);
	2074	end;
	2075
	2076	if (Copy(x, 1, 3) = 'POV') and (CharAt(x, 4) <> '-') then
	2077	{'POV'=Diagnosis--------------------------------------------------------------}
	2078	begin
	2079	//check for comment append string if a comment exists
	2080	x := AppendComment(x);
	2081	ADiagnosis := TPCEDiag.Create;
	2082	ADiagnosis.SetFromString(x);
	2083	FDiagnoses.Add(ADiagnosis);
	2084	end;
	2085	if (Copy(x, 1, 3) = 'CPT') and (CharAt(x, 4) <> '-') then
	2086	{CPT (procedure) information--------------------------------------------------}
	2087	begin
	2088	x := AppendComment(x);
	2089
	2090	IsVisit := False;
	2091	with VisitTypeList do for j := 0 to Count - 1 do
	2092	if Pieces(x, U, 2, 4) = Strings[j] then IsVisit := True;
	2093	if IsVisit and (FVisitType.Code = '') then FVisitType.SetFromString(x) else
	2094	begin
	2095	AProcedure := TPCEProc.Create;
	2096	AProcedure.SetFromString(x);
	2097	AProcedure.fIsOldProcedure := TRUE;
	2098	FProcedures.Add(AProcedure);
	2099	end; {if IsVisit}
	2100	end; {if Copy}
	2101	if (Copy(x, 1, 3) = 'IMM') and (CharAt(x, 4) <> '-') then
	2102	{Immunizations ---------------------------------------------------------------}
	2103	begin
	2104	x := AppendComment(x);
	2105	AImmunization := TPCEImm.Create;
	2106	AImmunization.SetFromString(x);
	2107	FImmunizations.Add(AImmunization);
	2108	end;
	2109	if (Copy(x, 1, 2) = 'SK') and (CharAt(x, 3) <> '-') then
	2110	{Skin Tests-------------------------------------------------------------------}
	2111	begin
	2112	x := AppendComment(x);
	2113	ASkinTest := TPCESkin.Create;
	2114	ASkinTest.SetFromString(x);
	2115	FSkinTests.Add(ASkinTest);
	2116	end;
	2117	if (Copy(x, 1, 3) = 'PED') and (CharAt(x, 3) <> '-') then
	2118	{Patient Educations------------------------------------------------------------}
	2119	begin
	2120	x := AppendComment(x);
	2121	APatientEd := TPCEpat.Create;
	2122	APatientEd.SetFromString(x);
	2123	FpatientEds.Add(APatientEd);
	2124	end;
	2125	if (Copy(x, 1, 2) = 'HF') and (CharAt(x, 3) <> '-') then
	2126	{Health Factors----------------------------------------------------------------}
	2127	begin
	2128	x := AppendComment(x);
	2129	AHealthFactor := TPCEHealth.Create;
	2130	AHealthFactor.SetFromString(x);
	2131	FHealthFactors.Add(AHealthFactor);
	2132	end;
	2133	if (Copy(x, 1, 3) = 'XAM') and (CharAt(x, 3) <> '-') then
	2134	{Exams ------------------------------------------------------------------------}
	2135	begin
	2136	x := AppendComment(x);
	2137	AExam := TPCEExams.Create;
	2138	AExam.SetFromString(x);
	2139	FExams.Add(AExam);
	2140	end;
	2141
	2142	end;
	2143	finally
	2144	PCEList.Free;
	2145	VisitTypeList.Free;
	2146	end;
	2147	end;
	2148
	2149	//procedure TPCEData.Save;
	2150	//modified: 6/17/98
	2151	//By: Robert Bott
	2152	//Location: ISL
	2153	//Purpose: Add Comments to PCE Items.
	2154	procedure TPCEData.Save;
	2155	{ pass the changes to the encounter to DATA2PCE,
	2156	Pieces: Subscript^Code^Qualifier^Category^Narrative^Delete }
	2157	var
	2158	i: Integer;
	2159	x, AVisitStr, EncName, Temp2: string;
	2160	PCEList: TStringList;
	2161	FileCat: char;
	2162	FileDate: TFMDateTime;
	2163	FileNoteIEN: integer;
	2164	dstring1,dstring2: pchar; //used to separate former DelimitedStr variable
	2165	// into two strings, the second being for the comment.
	2166
	2167	begin
	2168	PCEList := TStringList.Create;
	2169	UNxtCommSeqNum := 1;
	2170	try
	2171	with PCEList do
	2172	begin
	2173	if(IsSecondaryVisit) then
	2174	begin
	2175	FileCat := GetLocSecondaryVisitCode(FEncLocation);
	2176	FileDate := FNoteDateTime;
	2177	FileNoteIEN := NoteIEN;
	2178	if((NoteIEN > 0) and ((FParent = '') or (FParent = '0'))) then
	2179	FParent := GetVisitIEN(NoteIEN);
	2180	end
	2181	else
	2182	begin
	2183	FileCat := FEncSvcCat;
	2184	FileDate := FEncDateTime;
	2185	FileNoteIEN := 0;
	2186	end;
	2187	AVisitStr := IntToStr(FEncLocation) + ';' + FloatToStr(FileDate) + ';' + FileCat;
	2188	Add('HDR^' + BOOLCHAR[FEncInpatient] + U + U + AVisitStr);
	2189	// Add('HDR^' + BOOLCHAR[FEncInpatient] + U + BOOLCHAR[FNoteHasCPT] + U + AVisitStr);
	2190	// set up list that can be passed via broker to set up array for DATA2PCE
	2191	Add('VST^DT^' + FloatToStr(FileDate)); // Encounter Date/Time
	2192	Add('VST^PT^' + Patient.DFN); // Encounter Patient //DFN
	2193	if(FEncLocation > 0) then
	2194	Add('VST^HL^' + IntToStr(FEncLocation)); // Encounter Location
	2195	Add('VST^VC^' + FileCat); // Encounter Service Category
	2196	if(StrToIntDef(FParent,0) > 0) then
	2197	Add('VST^PR^' + FParent); // Parent for secondary visit
	2198	if(FileCat = 'E') and (FHistoricalLocation <> '') then
	2199	Add('VST^OL^' + FHistoricalLocation); // Outside Location
	2200
	2201	//Add('PRV^' + IntToStr(FEncProvider)); // Encounter Provider
	2202	//Add('PRV^' + IntToStr(UProvider.IEN)); // Encounter Provider
	2203	{with FProviders do for i := 0 to Count - 1 do with TPCEProvider(Items[i]) do
	2204	begin
	2205	PCEList.Add(DelimitedStr);
	2206	end;}
	2207	PCEList.AddStrings(FProviders);
	2208
	2209	if FSCChanged then
	2210	begin
	2211	if FSCRelated <> SCC_NA then Add('VST^SC^' + IntToStr(FSCRelated));
	2212	if FAORelated <> SCC_NA then Add('VST^AO^' + IntToStr(FAORelated));
	2213	if FIRRelated <> SCC_NA then Add('VST^IR^' + IntToStr(FIRRelated));
	2214	if FECRelated <> SCC_NA then Add('VST^EC^' + IntToStr(FECRelated));
	2215	if FMSTRelated <> SCC_NA then Add('VST^MST^' + IntToStr(FMSTRelated));
	2216	// if HNCOK and (FHNCRelated <> SCC_NA) then
	2217	if FHNCRelated <> SCC_NA then Add('VST^HNC^' + IntToStr(FHNCRelated));
	2218	if FCVRelated <> SCC_NA then Add('VST^CV^' + IntToStr(FCVRelated));
	2219	end;
	2220	with FDiagnoses do for i := 0 to Count - 1 do with TPCEDiag(Items[i]) do
	2221	if FSend then
	2222	begin
	2223	Temp2 := DelimitedStr2; // Call first to make sure SaveComment is set.
	2224	if(SaveComment) then
	2225	dec(UNxtCommSeqNum);
	2226	fProvider := FProviders.PCEProvider;
	2227	// Provides user with list of dx when signing orders - Billing Aware
	2228	PCEList.Add(DelimitedStr);
	2229	if(SaveComment) then
	2230	begin
	2231	inc(UNxtCommSeqNum);
	2232	if(Temp2 <> '') then
	2233	PCEList.Add(Temp2);
	2234	end;
	2235	end;
	2236	with FProcedures do for i := 0 to Count - 1 do with TPCEProc(Items[i]) do
	2237	if FSend then
	2238	begin
	2239	PCEList.Add(DelimitedStr);
	2240	PCEList.Add(DelimitedStr2);
	2241	end;
	2242	with FImmunizations do for i := 0 to Count - 1 do with TPCEImm(Items[i]) do
	2243	if FSend then
	2244	begin
	2245	PCEList.Add(DelimitedStr);
	2246	PCEList.Add(DelimitedStr2);
	2247	end;
	2248	with FSkinTests do for i := 0 to Count - 1 do with TPCESkin(Items[i]) do
	2249	if FSend then
	2250	begin
	2251	PCEList.Add(DelimitedStr);
	2252	PCEList.Add(DelimitedStr2);
	2253	end;
	2254	with FPatientEds do for i := 0 to Count - 1 do with TPCEPat(Items[i]) do
	2255	if FSend then
	2256	begin
	2257	PCEList.Add(DelimitedStr);
	2258	PCEList.Add(DelimitedStr2);
	2259	end;
	2260	with FHealthFactors do for i := 0 to Count - 1 do with TPCEHealth(Items[i]) do
	2261	if FSend then
	2262	begin
	2263	PCEList.Add(DelimitedStr);
	2264	PCEList.Add(DelimitedStr2);
	2265	end;
	2266	with FExams do for i := 0 to Count - 1 do with TPCEExams(Items[i]) do
	2267	if FSend then
	2268	begin
	2269	PCEList.Add(DelimitedStr);
	2270	PCEList.Add(DelimitedStr2);
	2271	end;
	2272
	2273	with FVisitType do
	2274	begin
	2275	if Code = '' then Fsend := false;
	2276	if FSend then
	2277	begin
	2278	PCEList.Add(DelimitedStr);
	2279	PCEList.Add(DelimitedStr2);
	2280	end;
	2281	end;
	2282	// call DATA2PCE (in background)
	2283	SavePCEData(PCEList, FileNoteIEN, FEncLocation);
	2284
	2285	// turn off 'Send' flags and remove items that were deleted
	2286	with FDiagnoses do for i := Count - 1 downto 0 do with TPCEDiag(Items[i]) do
	2287	begin
	2288	FSend := False;
	2289	if FDelete then
	2290	begin
	2291	TPCEDiag(Items[i]).Free;
	2292	Delete(i);
	2293	end;
	2294	end;
	2295	with FProcedures do for i := Count - 1 downto 0 do with TPCEProc(Items[i]) do
	2296	begin
	2297	FSend := False;
	2298	if FDelete then
	2299	begin
	2300	TPCEProc(Items[i]).Free;
	2301	Delete(i);
	2302	end;
	2303	end;
	2304	with FImmunizations do for i := Count - 1 downto 0 do with TPCEImm(Items[i]) do
	2305	begin
	2306	FSend := False;
	2307	if FDelete then
	2308	begin
	2309	TPCEImm(Items[i]).Free;
	2310	Delete(i);
	2311	end;
	2312	end;
	2313	with FSkinTests do for i := Count - 1 downto 0 do with TPCESkin(Items[i]) do
	2314	begin
	2315	FSend := False;
	2316	if FDelete then
	2317	begin
	2318	TPCESkin(Items[i]).Free;
	2319	Delete(i);
	2320	end;
	2321	end;
	2322	with FPatientEds do for i := Count - 1 downto 0 do with TPCEPat(Items[i]) do
	2323	begin
	2324	FSend := False;
	2325	if FDelete then
	2326	begin
	2327	TPCEPat(Items[i]).Free;
	2328	Delete(i);
	2329	end;
	2330	end;
	2331	with FHealthFactors do for i := Count - 1 downto 0 do with TPCEHealth(Items[i]) do
	2332	begin
	2333	FSend := False;
	2334	if FDelete then
	2335	begin
	2336	TPCEHealth(Items[i]).Free;
	2337	Delete(i);
	2338	end;
	2339	end;
	2340	with FExams do for i := Count - 1 downto 0 do with TPCEExams(Items[i]) do
	2341	begin
	2342	FSend := False;
	2343	if FDelete then
	2344	begin
	2345	TPCEExams(Items[i]).Free;
	2346	Delete(i);
	2347	end;
	2348	end;
	2349
	2350	for i := FProviders.Count - 1 downto 0 do
	2351	begin
	2352	if(FProviders.ProviderData[i].Delete) then
	2353	FProviders.Delete(i);
	2354	end;
	2355
	2356	if FVisitType.FDelete then FVisitType.Clear else FVisitType.FSend := False;
	2357	end; {with PCEList}
	2358	//if (FProcedures.Count > 0) or (FVisitType.Code <> '') then FCPTRequired := False;
	2359
	2360	// update the Changes object
	2361	EncName := FormatFMDateTime('mmm dd,yy hh:nn', FileDate);
	2362	x := StrVisitType;
	2363	if Length(x) > 0 then Changes.Add(CH_PCE, 'V' + AVisitStr, x, EncName, CH_SIGN_NA);
	2364	x := StrProcedures;
	2365	if Length(x) > 0 then Changes.Add(CH_PCE, 'P' + AVisitStr, x, EncName, CH_SIGN_NA);
	2366	x := StrDiagnoses;
	2367	if Length(x) > 0 then Changes.Add(CH_PCE, 'D' + AVisitStr, x, EncName, CH_SIGN_NA);
	2368	x := StrImmunizations;
	2369	if Length(x) > 0 then Changes.Add(CH_PCE, 'I' + AVisitStr, x, EncName, CH_SIGN_NA);
	2370	x := StrSkinTests;
	2371	if Length(x) > 0 then Changes.Add(CH_PCE, 'S' + AVisitStr, x, EncName, CH_SIGN_NA);
	2372	x := StrPatientEds;
	2373	if Length(x) > 0 then Changes.Add(CH_PCE, 'A' + AVisitStr, x, EncName, CH_SIGN_NA);
	2374	x := StrHealthFactors;
	2375	if Length(x) > 0 then Changes.Add(CH_PCE, 'H' + AVisitStr, x, EncName, CH_SIGN_NA);
	2376	x := StrExams;
	2377	if Length(x) > 0 then Changes.Add(CH_PCE, 'E' + AVisitStr, x, EncName, CH_SIGN_NA);
	2378
	2379
	2380	finally
	2381	PCEList.Free;
	2382	end;
	2383	end;
	2384
	2385	function TPCEData.MatchItem(AList: TList; AnItem: TPCEItem): Integer;
	2386	{ return index in AList of matching item }
	2387	var
	2388	i: Integer;
	2389	begin
	2390	Result := -1;
	2391	// with AList do for i := 0 to Count - 1 do with TPCEItem(Items[i]) do if Match(AnItem) and MatchProvider(AnItem)then
	2392	with AList do for i := 0 to Count - 1 do with TPCEItem(Items[i]) do if Match(AnItem) and MatchProvider(AnItem)then
	2393	// with AList do for i := 0 to Count - 1 do with TPCEItem(Items[i]) do if Match(AnItem) then
	2394	begin
	2395	Result := i;
	2396	break;
	2397	end;
	2398	end;
	2399
	2400	procedure TPCEData.MarkDeletions(PreList: TList; PostList: TStrings);
	2401	{mark items that need deleted}
	2402	var
	2403	i, j: Integer;
	2404	MatchFound: Boolean;
	2405	PreItem, PostItem: TPCEItem;
	2406	begin
	2407	with PreList do for i := 0 to Count - 1 do
	2408	begin
	2409	PreItem := TPCEItem(Items[i]);
	2410	MatchFound := False;
	2411	with PostList do for j := 0 to Count - 1 do
	2412	begin
	2413	PostItem := TPCEItem(Objects[j]);
	2414	// if (PreItem.Match(PostItem) and (PreItem.MatchProvider(PostItem))) then MatchFound := True;
	2415	if (PreItem.Match(PostItem) and (PreItem.MatchProvider(PostItem))) then MatchFound := True;
	2416	// if (PreItem.Match(PostItem)) then MatchFound := True;
	2417	end;
	2418	if not MatchFound then
	2419	begin
	2420	PreItem.FDelete := True;
	2421	PreItem.FSend := True;
	2422	end;
	2423	end;
	2424	end;
	2425
	2426	procedure TPCEData.SetDiagnoses(Src: TStrings; FromForm: boolean = TRUE);
	2427	{ load diagnoses for this encounter into TPCEDiag records, assumes all diagnoses for the
	2428	encounter will be listed in Src and marks those that are not in Src for deletion }
	2429	var
	2430	i, MatchIndex: Integer;
	2431	SrcDiagnosis, CurDiagnosis, PrimaryDiag: TPCEDiag;
	2432	begin
	2433	if FromForm then MarkDeletions(FDiagnoses, Src);
	2434	PrimaryDiag := nil;
	2435	for i := 0 to Src.Count - 1 do
	2436	begin
	2437	SrcDiagnosis := TPCEDiag(Src.Objects[i]);
	2438	MatchIndex := MatchItem(FDiagnoses, SrcDiagnosis);
	2439	if MatchIndex > -1 then //found in fdiagnoses
	2440	begin
	2441	CurDiagnosis := TPCEDiag(FDiagnoses.Items[MatchIndex]);
	2442	if ((SrcDiagnosis.Primary <> CurDiagnosis.Primary) or
	2443	(SrcDiagnosis.Comment <> CurDiagnosis.Comment) or
	2444	(SrcDiagnosis.AddProb <> CurDiagnosis.Addprob)) then
	2445	begin
	2446	CurDiagnosis.Primary := SrcDiagnosis.Primary;
	2447	CurDiagnosis.Comment := SrcDiagnosis.Comment;
	2448	CurDiagnosis.AddProb := SrcDiagnosis.AddProb;
	2449	CurDiagnosis.FSend := True;
	2450	end;
	2451	end else
	2452	begin
	2453	CurDiagnosis := TPCEDiag.Create;
	2454	CurDiagnosis.Assign(SrcDiagnosis);
	2455	CurDiagnosis.FSend := True;
	2456	FDiagnoses.Add(CurDiagnosis);
	2457	end; {if MatchIndex}
	2458	if(CurDiagnosis.Primary and (not assigned(PrimaryDiag))) then
	2459	PrimaryDiag := CurDiagnosis;
	2460	end; {for}
	2461	if(assigned(PrimaryDiag)) then
	2462	begin
	2463	for i := 0 to FDiagnoses.Count - 1 do
	2464	begin
	2465	CurDiagnosis := TPCEDiag(FDiagnoses[i]);
	2466	if(CurDiagnosis.Primary) and (CurDiagnosis <> PrimaryDiag) then
	2467	begin
	2468	CurDiagnosis.Primary := FALSE;
	2469	CurDiagnosis.FSend := True;
	2470	end;
	2471	end;
	2472	end;
	2473	end;
	2474
	2475	procedure TPCEData.SetProcedures(Src: TStrings; FromForm: boolean = TRUE);
	2476	{ load Procedures for this encounter into TPCEProc records, assumes all Procedures for the
	2477	encounter will be listed in Src and marks those that are not in Src for deletion }
	2478	var
	2479	i, MatchIndex: Integer;
	2480	SrcProcedure, CurProcedure, OldProcedure: TPCEProc;
	2481	begin
	2482	if FromForm then MarkDeletions(FProcedures, Src);
	2483	for i := 0 to Src.Count - 1 do
	2484	begin
	2485	SrcProcedure := TPCEProc(Src.Objects[i]);
	2486	MatchIndex := MatchItem(FProcedures, SrcProcedure);
	2487	if MatchIndex > -1 then
	2488	begin
	2489	CurProcedure := TPCEProc(FProcedures.Items[MatchIndex]);
	2490	(* if (SrcProcedure.Provider <> CurProcedure.Provider) then
	2491	begin
	2492	OldProcedure := TPCEProc.Create;
	2493	OldProcedure.Assign(CurProcedure);
	2494	OldProcedure.FDelete := TRUE;
	2495	OldProcedure.FSend := TRUE;
	2496	FProcedures.Add(OldProcedure);
	2497	end;*)
	2498	if (SrcProcedure.Quantity <> CurProcedure.Quantity) or
	2499	(SrcProcedure.Provider <> CurProcedure.Provider) or
	2500	(Curprocedure.Comment <> SrcProcedure.Comment) or
	2501	(Curprocedure.Modifiers <> SrcProcedure.Modifiers)then
	2502	begin
	2503	OldProcedure := TPCEProc.Create;
	2504	OldProcedure.Assign(CurProcedure);
	2505	OldProcedure.FDelete := TRUE;
	2506	OldProcedure.FSend := TRUE;
	2507	FProcedures.Add(OldProcedure);
	2508	CurProcedure.Quantity := SrcProcedure.Quantity;
	2509	CurProcedure.Provider := SrcProcedure.Provider;
	2510	CurProcedure.Comment := SrcProcedure.Comment;
	2511	CurProcedure.Modifiers := SrcProcedure.Modifiers;
	2512	CurProcedure.FSend := True;
	2513	end;
	2514	end else
	2515	begin
	2516	CurProcedure := TPCEProc.Create;
	2517	CurProcedure.Assign(SrcProcedure);
	2518	CurProcedure.FSend := True;
	2519	FProcedures.Add(CurProcedure);
	2520	end; {if MatchIndex}
	2521	end; {for}
	2522	end;
	2523
	2524
	2525
	2526	procedure TPCEData.SetImmunizations(Src: TStrings; FromForm: boolean = TRUE);
	2527	{ load Immunizations for this encounter into TPCEImm records, assumes all Immunizations for the
	2528	encounter will be listed in Src and marks those that are not in Src for deletion }
	2529	var
	2530	i, MatchIndex: Integer;
	2531	SrcImmunization, CurImmunization: TPCEImm;
	2532	begin
	2533	if FromForm then MarkDeletions(FImmunizations, Src);
	2534	for i := 0 to Src.Count - 1 do
	2535	begin
	2536	SrcImmunization := TPCEImm(Src.Objects[i]);
	2537	MatchIndex := MatchItem(FImmunizations, SrcImmunization);
	2538	if MatchIndex > -1 then
	2539	begin
	2540	CurImmunization := TPCEImm(FImmunizations.Items[MatchIndex]);
	2541
	2542	//set null strings to NoPCEValue
	2543	if SrcImmunization.Series = '' then SrcImmunization.Series := NoPCEValue;
	2544	if SrcImmunization.Reaction = '' then SrcImmunization.Reaction := NoPCEValue;
	2545	if CurImmunization.Series = '' then CurImmunization.Series := NoPCEValue;
	2546	if CurImmunization.Reaction = '' then CurImmunization.Reaction := NoPCEValue;
	2547
	2548	// if (SrcImmunization.Provider <> CurImmunization.Provider) or
	2549	if(SrcImmunization.Series <> CurImmunization.Series) or
	2550	(SrcImmunization.Reaction <> CurImmunization.Reaction) or
	2551	(SrcImmunization.Refused <> CurImmunization.Refused) or
	2552	(SrcImmunization.Contraindicated <> CurImmunization.Contraindicated) or
	2553	(CurImmunization.Comment <> SrcImmunization.Comment)then
	2554	begin
	2555	// CurImmunization.Provider := SrcImmunization.Provider;
	2556	CurImmunization.Series := SrcImmunization.Series;
	2557	CurImmunization.Reaction := SrcImmunization.Reaction;
	2558	CurImmunization.Refused := SrcImmunization.Refused;
	2559	CurImmunization.Contraindicated := SrcImmunization.Contraindicated;
	2560	CurImmunization.Comment := SrcImmunization.Comment;
	2561	CurImmunization.FSend := True;
	2562	end;
	2563	end else
	2564	begin
	2565	CurImmunization := TPCEImm.Create;
	2566	CurImmunization.Assign(SrcImmunization);
	2567	CurImmunization.FSend := True;
	2568	FImmunizations.Add(CurImmunization);
	2569	end; {if MatchIndex}
	2570	end; {for}
	2571	end;
	2572
	2573	procedure TPCEData.SetSkinTests(Src: TStrings; FromForm: boolean = TRUE);
	2574	{ load SkinTests for this encounter into TPCESkin records, assumes all SkinTests for the
	2575	encounter will be listed in Src and marks those that are not in Src for deletion }
	2576	var
	2577	i, MatchIndex: Integer;
	2578	SrcSkinTest, CurSkinTest: TPCESkin;
	2579	begin
	2580	if FromForm then MarkDeletions(FSKinTests, Src);
	2581	for i := 0 to Src.Count - 1 do
	2582	begin
	2583	SrcSkinTest := TPCESkin(Src.Objects[i]);
	2584	MatchIndex := MatchItem(FSKinTests, SrcSkinTest);
	2585	if MatchIndex > -1 then
	2586	begin
	2587	CurSkinTest := TPCESKin(FSkinTests.Items[MatchIndex]);
	2588	if CurSkinTest.Results = '' then CurSkinTest.Results := NoPCEValue;
	2589	if SrcSkinTest.Results = '' then SrcSkinTest.Results := NoPCEValue;
	2590	// if (SrcSkinTest.Provider <> CurSkinTest.Provider) or
	2591	if(SrcSkinTest.Results <> CurSkinTest.Results) or
	2592	(SrcSkinTest.Reading <> CurSkinTest.Reading) or
	2593	(CurSkinTest.Comment <> SrcSkinTest.Comment) then
	2594	begin
	2595	// CurSkinTest.Provider := SrcSkinTest.Provider;
	2596	CurSkinTest.Results := SrcSkinTest.Results;
	2597	CurSkinTest.Reading := SrcSkinTest.Reading;
	2598	CurSkinTest.Comment := SrcSkinTest.Comment;
	2599	CurSkinTest.FSend := True;
	2600	end;
	2601	end else
	2602	begin
	2603	CurSKinTest := TPCESkin.Create;
	2604	CurSkinTest.Assign(SrcSkinTest);
	2605	CurSkinTest.FSend := True;
	2606	FSkinTests.Add(CurSkinTest);
	2607	end; {if MatchIndex}
	2608	end; {for}
	2609	end;
	2610
	2611	procedure TPCEData.SetPatientEds(Src: TStrings; FromForm: boolean = TRUE);
	2612	var
	2613	i, MatchIndex: Integer;
	2614	SrcPatientEd, CurPatientEd: TPCEPat;
	2615	begin
	2616	if FromForm then MarkDeletions(FPatientEds, Src);
	2617	for i := 0 to Src.Count - 1 do
	2618	begin
	2619	SrcPatientEd := TPCEPat(Src.Objects[i]);
	2620	MatchIndex := MatchItem(FPatientEds, SrcPatientEd);
	2621	if MatchIndex > -1 then
	2622	begin
	2623	CurPatientEd := TPCEPat(FPatientEds.Items[MatchIndex]);
	2624
	2625	if CurPatientEd.level = '' then CurPatientEd.level := NoPCEValue;
	2626	if SrcPatientEd.level = '' then SrcPatientEd.level := NoPCEValue;
	2627	// if (SrcPatientEd.Provider <> CurPatientEd.Provider) or
	2628	if(SrcPatientEd.Level <> CurPatientEd.Level) or
	2629	(CurPatientEd.Comment <> SrcPatientEd.Comment) then
	2630	begin
	2631	// CurPatientEd.Provider := SrcPatientEd.Provider;
	2632	CurPatientEd.Level := SrcPatientEd.Level;
	2633	CurPatientEd.Comment := SrcPatientEd.Comment;
	2634	CurPatientEd.FSend := True;
	2635	end;
	2636	end else
	2637	begin
	2638	CurPatientEd := TPCEPat.Create;
	2639	CurPatientEd.Assign(SrcPatientEd);
	2640	CurPatientEd.FSend := True;
	2641	FPatientEds.Add(CurPatientEd);
	2642	end; {if MatchIndex}
	2643	end; {for}
	2644	end;
	2645
	2646
	2647	procedure TPCEData.SetHealthFactors(Src: TStrings; FromForm: boolean = TRUE);
	2648
	2649	var
	2650	i, MatchIndex: Integer;
	2651	SrcHealthFactor, CurHealthFactor: TPCEHealth;
	2652	begin
	2653	if FromForm then MarkDeletions(FHealthFactors, Src);
	2654	for i := 0 to Src.Count - 1 do
	2655	begin
	2656	SrcHealthFactor := TPCEHealth(Src.Objects[i]);
	2657	MatchIndex := MatchItem(FHealthFactors, SrcHealthFactor);
	2658	if MatchIndex > -1 then
	2659	begin
	2660	CurHealthFactor := TPCEHealth(FHealthFactors.Items[MatchIndex]);
	2661
	2662	if CurHealthFactor.level = '' then CurHealthFactor.level := NoPCEValue;
	2663	if SrcHealthFactor.level = '' then SrcHealthFactor.level := NoPCEValue;
	2664	// if (SrcHealthFactor.Provider <> CurHealthFactor.Provider) or
	2665	if(SrcHealthFactor.Level <> CurHealthFactor.Level) or
	2666	(CurHealthFactor.Comment <> SrcHealthFactor.Comment) then
	2667	begin
	2668	// CurHealthFactor.Provider := SrcHealthFactor.Provider;
	2669	CurHealthFactor.Level := SrcHealthFactor.Level;
	2670	CurHealthFactor.Comment := SrcHealthFactor.Comment;
	2671	CurHealthFactor.FSend := True;
	2672	end;
	2673	if(SrcHealthFactor.GecRem <> CurHealthFactor.GecRem) then
	2674	CurHealthFactor.GecRem := SrcHealthFactor.GecRem;
	2675	end else
	2676	begin
	2677	CurHealthFactor := TPCEHealth.Create;
	2678	CurHealthFactor.Assign(SrcHealthFactor);
	2679	CurHealthFactor.FSend := True;
	2680	CurHealthFactor.GecRem := SrcHealthFactor.GecRem;
	2681	FHealthFactors.Add(CurHealthFactor);
	2682	end; {if MatchIndex}
	2683	end; {for}
	2684	end;
	2685
	2686
	2687	procedure TPCEData.SetExams(Src: TStrings; FromForm: boolean = TRUE);
	2688
	2689	var
	2690	i, MatchIndex: Integer;
	2691	SrcExam, CurExam: TPCEExams;
	2692	begin
	2693	if FromForm then MarkDeletions(FExams, Src);
	2694	for i := 0 to Src.Count - 1 do
	2695	begin
	2696	SrcExam := TPCEExams(Src.Objects[i]);
	2697	MatchIndex := MatchItem(FExams, SrcExam);
	2698	if MatchIndex > -1 then
	2699	begin
	2700	CurExam := TPCEExams(FExams.Items[MatchIndex]);
	2701	if CurExam.Results = '' then CurExam.Results := NoPCEValue;
	2702	if SrcExam.Results = '' then SrcExam.Results := NoPCEValue;
	2703	// if (SrcExam.Provider <> CurExam.Provider) or
	2704	if(SrcExam.Results <> CurExam.Results) or
	2705	(CurExam.Comment <> SrcExam.Comment) then
	2706	begin
	2707	// CurExam.Provider := SrcExam.Provider;
	2708	CurExam.Results := SrcExam.Results;
	2709	CurExam.Comment := SrcExam.Comment;
	2710	CurExam.Fsend := True;
	2711	end;
	2712	end else
	2713	begin
	2714	CurExam := TPCEExams.Create;
	2715	CurExam.Assign(SrcExam);
	2716	CurExam.FSend := True;
	2717	FExams.Add(CurExam);
	2718	end; {if MatchIndex}
	2719	end; {for}
	2720	end;
	2721
	2722
	2723	procedure TPCEData.SetVisitType(Value: TPCEProc);
	2724	var
	2725	VisitDelete: TPCEProc;
	2726	begin
	2727	if (not FVisitType.Match(Value)) or
	2728	(FVisitType.Modifiers <> Value.Modifiers) then {causes CPT delete/re-add}
	2729	begin
	2730	if FVisitType.Code <> '' then // add old visit to procedures for deletion
	2731	begin
	2732	VisitDelete := TPCEProc.Create;
	2733	VisitDelete.Assign(FVisitType);
	2734	VisitDelete.FDelete := True;
	2735	VisitDelete.FSend := True;
	2736	FProcedures.Add(VisitDelete);
	2737	end;
	2738	FVisitType.Assign(Value);
	2739	FVisitType.Quantity := 1;
	2740	FVisitType.FSend := True;
	2741	end;
	2742	end;
	2743
	2744	procedure TPCEData.SetSCRelated(Value: Integer);
	2745	begin
	2746	if Value <> FSCRelated then
	2747	begin
	2748	FSCRelated := Value;
	2749	FSCChanged := True;
	2750	end;
	2751	end;
	2752
	2753	procedure TPCEData.SetAORelated(Value: Integer);
	2754	begin
	2755	if Value <> FAORelated then
	2756	begin
	2757	FAORelated := Value;
	2758	FSCChanged := True;
	2759	end;
	2760	end;
	2761
	2762	procedure TPCEData.SetIRRelated(Value: Integer);
	2763	begin
	2764	if Value <> FIRRelated then
	2765	begin
	2766	FIRRelated := Value;
	2767	FSCChanged := True;
	2768	end;
	2769	end;
	2770
	2771	procedure TPCEData.SetECRelated(Value: Integer);
	2772	begin
	2773	if Value <> FECRelated then
	2774	begin
	2775	FECRelated := Value;
	2776	FSCChanged := True;
	2777	end;
	2778	end;
	2779
	2780	procedure TPCEData.SetMSTRelated(Value: Integer);
	2781	begin
	2782	if Value <> FMSTRelated then
	2783	begin
	2784	FMSTRelated := Value;
	2785	FSCChanged := True;
	2786	end;
	2787	end;
	2788
	2789	procedure TPCEData.SetHNCRelated(Value: Integer);
	2790	begin
	2791	// if HNCOK and (Value <> FHNCRelated) then
	2792	if Value <> FHNCRelated then
	2793	begin
	2794	FHNCRelated := Value;
	2795	FSCChanged := True;
	2796	end;
	2797	end;
	2798
	2799	procedure TPCEData.SetCVRelated(Value: Integer);
	2800	begin
	2801	if (Value <> FCVRelated) then
	2802	begin
	2803	FCVRelated := Value;
	2804	FSCChanged := True;
	2805	end;
	2806	end;
	2807
	2808	procedure TPCEData.SetEncUseCurr(Value: Boolean);
	2809	begin
	2810	FEncUseCurr := Value;
	2811	if FEncUseCurr then
	2812	begin
	2813	FEncDateTime := Encounter.DateTime;
	2814	FEncLocation := Encounter.Location;
	2815	//need to add to full list of providers
	2816	FEncSvcCat := Encounter.VisitCategory;
	2817	FStandAlone := Encounter.StandAlone;
	2818	FStandAloneLoaded := TRUE;
	2819	//FCPTRequired := Encounter.StandAlone;
	2820	FEncInpatient := Encounter.Inpatient;
	2821	//if FEncInpatient then FCPTRequired := False;
	2822	//SetDefaultProvider(FProviders, FEncLocation, FNoteIEN, PersonClassDate);
	2823	end else
	2824	begin
	2825	FEncDateTime := 0;
	2826	FEncLocation := 0;
	2827	FStandAlone := FALSE;
	2828	FStandAloneLoaded := FALSE;
	2829	FProviders.PrimaryIdx := -1;
	2830	FEncSvcCat := 'A';
	2831	//FCPTRequired := False;
	2832	FEncInpatient := False;
	2833	end;
	2834	//
	2835	SetRPCEncLocation(FEncLocation);
	2836	// SetRPCEncDateTime(FEncDateTime);
	2837	end;
	2838
	2839	function TPCEData.StrDiagnoses: string;
	2840	{ returns the list of diagnoses for this encounter as a single comma delimited string }
	2841	var
	2842	i: Integer;
	2843	begin
	2844	Result := '';
	2845	with FDiagnoses do for i := 0 to Count - 1 do with TPCEDiag(Items[i]) do
	2846	if not FDelete then
	2847	Result := Result + GetPCEDataText(pdcDiag, Code, Category, Narrative, Primary) + ', ';
	2848	//kt if Length(Result) > 0 then Result := PCEDataCatText[pdcDiag] + Copy(Result, 1, Length(Result) - 2);
	2849	if Length(Result) > 0 then Result := PCEDataCatText(pdcDiag) + Copy(Result, 1, Length(Result) - 2);
	2850	end;
	2851
	2852	function TPCEData.StrProcedures: string;
	2853	{ returns the list of procedures for this encounter as a single comma delimited string }
	2854	var
	2855	i: Integer;
	2856	begin
	2857	Result := '';
	2858	with FProcedures do for i := 0 to Count - 1 do with TPCEProc(Items[i]) do
	2859	if not FDelete then
	2860	Result := Result + GetPCEDataText(pdcProc, Code, Category, Narrative, FALSE, Quantity) +
	2861	ModText + ', ';
	2862	//kt if Length(Result) > 0 then Result := PCEDataCatText[pdcProc] + Copy(Result, 1, Length(Result) - 2);
	2863	if Length(Result) > 0 then Result := PCEDataCatText(pdcProc) + Copy(Result, 1, Length(Result) - 2);
	2864	end;
	2865
	2866	function TPCEData.StrImmunizations: string;
	2867	{ returns the list of Immunizations for this encounter as a single comma delimited string }
	2868	var
	2869	i: Integer;
	2870	begin
	2871	Result := '';
	2872	with FImmunizations do for i := 0 to Count - 1 do with TPCEImm(Items[i]) do
	2873	if not FDelete then
	2874	Result := Result + GetPCEDataText(pdcImm, Code, Category, Narrative) + ', ';
	2875	//kt if Length(Result) > 0 then Result := PCEDataCatText[pdcImm] + Copy(Result, 1, Length(Result) - 2);
	2876	if Length(Result) > 0 then Result := PCEDataCatText(pdcImm) + Copy(Result, 1, Length(Result) - 2);
	2877	end;
	2878
	2879
	2880	function TPCEData.StrSkinTests: string;
	2881	{ returns the list of Immunizations for this encounter as a single comma delimited string }
	2882	var
	2883	i: Integer;
	2884	begin
	2885	Result := '';
	2886	with FSkinTests do for i := 0 to Count - 1 do with TPCESkin(Items[i]) do
	2887	if not FDelete then
	2888	Result := Result + GetPCEDataText(pdcSkin, Code, Category, Narrative) + ', ';
	2889	//kt if Length(Result) > 0 then Result := PCEDataCatText[pdcSkin] + Copy(Result, 1, Length(Result) - 2);
	2890	if Length(Result) > 0 then Result := PCEDataCatText(pdcSkin) + Copy(Result, 1, Length(Result) - 2);
	2891	end;
	2892
	2893	function TPCEData.StrPatientEds: string;
	2894	var
	2895	i: Integer;
	2896	begin
	2897	Result := '';
	2898	with FPatientEds do for i := 0 to Count - 1 do with TPCEPat(Items[i]) do
	2899	if not FDelete then
	2900	Result := Result + GetPCEDataText(pdcPED, Code, Category, Narrative) + ', ';
	2901	//kt if Length(Result) > 0 then Result := PCEDataCatText[pdcPED] + Copy(Result, 1, Length(Result) - 2);
	2902	if Length(Result) > 0 then Result := PCEDataCatText(pdcPED) + Copy(Result, 1, Length(Result) - 2);
	2903	end;
	2904
	2905	function TPCEData.StrHealthFactors: string;
	2906	var
	2907	i: Integer;
	2908	begin
	2909	Result := '';
	2910	with FHealthFactors do for i := 0 to Count - 1 do with TPCEHealth(Items[i]) do
	2911	if not FDelete then
	2912	Result := Result + GetPCEDataText(pdcHF, Code, Category, Narrative) + ', ';
	2913	//kt if Length(Result) > 0 then Result := PCEDataCatText[pdcHF] + Copy(Result, 1, Length(Result) - 2);
	2914	if Length(Result) > 0 then Result := PCEDataCatText(pdcHF) + Copy(Result, 1, Length(Result) - 2);
	2915	end;
	2916
	2917	function TPCEData.StrExams: string;
	2918	var
	2919	i: Integer;
	2920	begin
	2921	Result := '';
	2922	with FExams do for i := 0 to Count - 1 do with TPCEExams(Items[i]) do
	2923	if not FDelete then
	2924	Result := Result + GetPCEDataText(pdcExam, Code, Category, Narrative) + ', ';
	2925	//kt if Length(Result) > 0 then Result := PCEDataCatText[pdcExam] + Copy(Result, 1, Length(Result) - 2);
	2926	if Length(Result) > 0 then Result := PCEDataCatText(pdcExam) + Copy(Result, 1, Length(Result) - 2);
	2927	end;
	2928
	2929	function TPCEData.StrVisitType(const ASCRelated, AAORelated, AIRRelated,
	2930	AECRelated, AMSTRelated, AHNCRelated, ACVRelated: Integer): string;
	2931	{ returns as a string the type of encounter (according to CPT) & related contitions treated }
	2932
	2933	procedure AddTxt(txt: string);
	2934	begin
	2935	if(Result <> '') then
	2936	Result := Result + ',';
	2937	Result := Result + ' ' + txt;
	2938	end;
	2939
	2940	begin
	2941	Result := '';
	2942	//if ASCRelated = SCC_YES then AddTxt('Service Connected Condition'); <-- original line. //kt 8/8/2007
	2943	if ASCRelated = SCC_YES then AddTxt(DKLangConstW('uPCE_Service_Connected_Condition')); //kt added 8/8/2007
	2944	//if AAORelated = SCC_YES then AddTxt('Agent Orange Exposure'); <-- original line. //kt 8/8/2007
	2945	if AAORelated = SCC_YES then AddTxt(DKLangConstW('uPCE_Agent_Orange_Exposure')); //kt added 8/8/2007
	2946	//if AIRRelated = SCC_YES then AddTxt('Ionizing Radiation Exposure'); <-- original line. //kt 8/8/2007
	2947	if AIRRelated = SCC_YES then AddTxt(DKLangConstW('uPCE_Ionizing_Radiation_Exposure')); //kt added 8/8/2007
	2948	//if AECRelated = SCC_YES then AddTxt('Environmental Contaminants'); <-- original line. //kt 8/8/2007
	2949	if AECRelated = SCC_YES then AddTxt(DKLangConstW('uPCE_Environmental_Contaminants')); //kt added 8/8/2007
	2950	if AMSTRelated = SCC_YES then AddTxt('MST');//'Military Sexual Trauma';
	2951	// if HNCOK and (AHNCRelated = SCC_YES) then AddTxt('Head and/or Neck Cancer');
	2952	//if AHNCRelated = SCC_YES then AddTxt('Head and/or Neck Cancer'); <-- original line. //kt 8/8/2007
	2953	if AHNCRelated = SCC_YES then AddTxt(DKLangConstW('uPCE_Head_andxor_Neck_Cancer')); //kt added 8/8/2007
	2954	//if ACVRelated = SCC_YES then AddTxt('Combat Veteran Related'); <-- original line. //kt 8/8/2007
	2955	if ACVRelated = SCC_YES then AddTxt(DKLangConstW('uPCE_Combat_Veteran_Related')); //kt added 8/8/2007
	2956	//if Length(Result) > 0 then Result := ' related to: ' + Result; <-- original line. //kt 8/8/2007
	2957	if Length(Result) > 0 then Result := DKLangConstW('uPCE_related_tox') + Result; //kt added 8/8/2007
	2958	// Result := Trim(Result);
	2959	end;
	2960
	2961	function TPCEData.StrVisitType: string;
	2962	{ returns as a string the type of encounter (according to CPT) & related contitions treated }
	2963	begin
	2964	Result := '';
	2965	with FVisitType do
	2966	begin
	2967	Result := GetPCEDataText(pdcVisit, Code, Category, Narrative);
	2968	if Length(ModText) > 0 then Result := Result + ModText + ', ';
	2969	end;
	2970	Result := Trim(Result + StrVisitType(FSCRelated, FAORelated, FIRRelated,
	2971	FECRelated, FMSTRelated, FHNCRelated, FCVRelated));
	2972	end;
	2973
	2974	function TPCEData.StandAlone: boolean;
	2975	var
	2976	Sts: integer;
	2977
	2978	begin
	2979	if(not FStandAloneLoaded) and ((FNoteIEN > 0) or ((FEncLocation > 0) and (FEncDateTime > 0))) then
	2980	begin
	2981	Sts := HasVisit(FNoteIEN, FEncLocation, FEncDateTime);
	2982	FStandAlone := (Sts <> 1);
	2983	if(Sts >= 0) then
	2984	FStandAloneLoaded := TRUE;
	2985	end;
	2986	Result := FStandAlone;
	2987	end;
	2988
	2989	function TPCEData.getDocCount: Integer;
	2990	begin
	2991	rESULT := 1;
	2992	// result := DocCount(vISIT);
	2993	end;
	2994
	2995	{function TPCEItem.MatchProvider(AnItem: TPCEItem): Boolean;
	2996	begin
	2997	Result := False;
	2998	if (Provider = AnItem.Provider) then Result := True;
	2999	end;
	3000	}
	3001	function TPCEItem.MatchProvider(AnItem: TPCEItem): Boolean;
	3002	begin
	3003	Result := False;
	3004	if (Provider = AnItem.Provider) then Result := True;
	3005	end;
	3006
	3007	function TPCEData.GetHasData: Boolean;
	3008	begin
	3009	result := True;
	3010	if ((FDiagnoses.count = 0)
	3011	and (FProcedures.count = 0)
	3012	and (FImmunizations.count = 0)
	3013	and (FSkinTests.count = 0)
	3014	and (FPatientEds.count = 0)
	3015	and (FHealthFactors.count = 0)
	3016	and (fExams.count = 0) and
	3017	(FvisitType.Quantity = 0))then
	3018	result := False;
	3019	end;
	3020
	3021	procedure TPCEData.CopyPCEData(Dest: TPCEData);
	3022	begin
	3023	Dest.Clear;
	3024	Dest.FEncDateTime := FEncDateTime;
	3025	Dest.FNoteDateTime := FNoteDateTime;
	3026	Dest.FEncLocation := FEncLocation;
	3027	Dest.FEncSvcCat := FEncSvcCat;
	3028	Dest.FEncInpatient := FEncInpatient;
	3029	Dest.FStandAlone := FStandAlone;
	3030	Dest.FStandAloneLoaded := FStandAloneLoaded;
	3031	Dest.FEncUseCurr := FEncUseCurr;
	3032	Dest.FSCChanged := FSCChanged;
	3033	Dest.FSCRelated := FSCRelated;
	3034	Dest.FAORelated := FAORelated;
	3035	Dest.FIRRelated := FIRRelated;
	3036	Dest.FECRelated := FECRelated;
	3037	Dest.FMSTRelated := FMSTRelated;
	3038	Dest.FHNCRelated := FHNCRelated;
	3039	Dest.FCVRelated := FCVRelated;
	3040	FVisitType.CopyProc(Dest.VisitType);
	3041	Dest.FProviders.Assign(FProviders);
	3042
	3043	CopyPCEItems(FDiagnoses, Dest.FDiagnoses, TPCEDiag);
	3044	CopyPCEItems(FProcedures, Dest.FProcedures, TPCEProc);
	3045	CopyPCEItems(FImmunizations, Dest.FImmunizations, TPCEImm);
	3046	CopyPCEItems(FSkinTests, Dest.FSkinTests, TPCESkin);
	3047	CopyPCEItems(FPatientEds, Dest.FPatientEds, TPCEPat);
	3048	CopyPCEItems(FHealthFactors, Dest.FHealthFactors, TPCEHealth);
	3049	CopyPCEItems(FExams, Dest.FExams, TPCEExams);
	3050
	3051	Dest.FNoteTitle := FNoteTitle;
	3052	Dest.FNoteIEN := FNoteIEN;
	3053	Dest.FParent := FParent;
	3054	Dest.FHistoricalLocation := FHistoricalLocation;
	3055	end;
	3056
	3057	function TPCEData.NeededPCEData: tRequiredPCEDataTypes;
	3058	var
	3059	EC: TSCConditions;
	3060	NeedSC: boolean;
	3061	TmpLst: TStringList;
	3062
	3063	begin
	3064	Result := [];
	3065	if(not FutureEncounter(Self)) then
	3066	begin
	3067	// if(PromptForWorkload(FNoteIEN, FNoteTitle, FEncSvcCat, StandAlone) or CPTRequiredForNote(FNoteIEN)) then
	3068	if(PromptForWorkload(FNoteIEN, FNoteTitle, FEncSvcCat, StandAlone)) then
	3069	begin
	3070	if(fdiagnoses.count <= 0) then
	3071	Include(Result, ndDiag);
	3072	if((fprocedures.count <= 0) and (fVisitType.Code = '')) then
	3073	begin
	3074	TmpLst := TStringList.Create;
	3075	try
	3076	GetHasCPTList(TmpLst);
	3077	if(not DataHasCPTCodes(TmpLst)) then
	3078	Include(Result, ndProc);
	3079	finally
	3080	TmpLst.Free;
	3081	end;
	3082	end;
	3083	if(RequireExposures(FNoteIEN, FNoteTitle)) then
	3084	begin
	3085	NeedSC := FALSE;
	3086	EC := EligbleConditions;
	3087	if (EC.SCAllow and (SCRelated = SCC_NA)) then
	3088	NeedSC := TRUE
	3089	else if(SCRelated <> SCC_YES) then //if screlated = yes, the others are not asked.
	3090	begin
	3091	if(EC.AOAllow and (AORelated = SCC_NA)) then NeedSC := TRUE
	3092	else if(EC.IRAllow and (IRRelated = SCC_NA)) then NeedSC := TRUE
	3093	else if(EC.ECAllow and (ECRelated = SCC_NA)) then NeedSC := TRUE
	3094	end;
	3095	if(EC.MSTAllow and (MSTRelated = SCC_NA)) then NeedSC := TRUE;
	3096	// if HNCOK and (EC.HNCAllow and (HNCRelated = SCC_NA)) then NeedSC := TRUE;
	3097	if(EC.HNCAllow and (HNCRelated = SCC_NA)) then NeedSC := TRUE;
	3098	if(EC.CVAllow and (CVRelated = SCC_NA)) then NeedSC := TRUE;
	3099	if(NeedSC) then
	3100	Include(Result, ndSC);
	3101	end;
	3102	(* if(Result = []) and (FNoteIEN > 0) then // ** block removed in v19.1 {RV} **
	3103	ClearCPTRequired(FNoteIEN);*)
	3104	end;
	3105	end;
	3106	end;
	3107
	3108
	3109	function TPCEData.OK2SignNote: boolean;
	3110	var
	3111	Req: tRequiredPCEDataTypes;
	3112	msg: string;
	3113	Asked, DoAsk, Primary, Needed: boolean;
	3114	Outpatient, First, DoSave, NeedSave, Done: boolean;
	3115	Ans: integer;
	3116	Flags: word;
	3117	Ask: TAskPCE;
	3118
	3119	procedure Add(Typ: tRequiredPCEDataType; txt: string);
	3120	begin
	3121	if(Typ in Req) then
	3122	msg := msg + txt + CRLF;
	3123	end;
	3124
	3125	begin
	3126	if not CanEditPCE(Self) then
	3127	begin
	3128	Result := TRUE;
	3129	exit;
	3130	end;
	3131	if IsNonCountClinic(FEncLocation) then
	3132	begin
	3133	Result := TRUE;
	3134	exit;
	3135	end;
	3136	if IsCancelOrNoShow(NoteIEN) then
	3137	begin
	3138	Result := TRUE;
	3139	exit;
	3140	end;
	3141	Ask := GetAskPCE(FEncLocation);
	3142	if(Ask = apNever) or (Ask = apDisable) then
	3143	Result := TRUE
	3144	else
	3145	begin
	3146	DoSave := FALSE;
	3147	try
	3148	Asked := FALSE;
	3149	First := TRUE;
	3150	Outpatient := ((FEncSvcCat = 'A') or (FEncSvcCat = 'I') or (FEncSvcCat = 'T'));
	3151	repeat
	3152	Result := TRUE;
	3153	Done := TRUE;
	3154	Req := NeededPCEData;
	3155	Needed := (Req <> []);
	3156	if(First) then
	3157	begin
	3158	if Needed and (not Outpatient) then
	3159	OutPatient := TRUE;
	3160	if((Ask = apPrimaryAlways) or Needed or
	3161	((Ask = apPrimaryOutpatient) and Outpatient)) then
	3162	begin
	3163	if(Providers.PrimaryIdx < 0) then
	3164	begin
	3165	NoPrimaryPCEProvider(FProviders, Self);
	3166	if(not DoSave) then
	3167	DoSave := (Providers.PrimaryIdx >= 0);
	3168	if(DoSave and (FProviders.PendingIEN(FALSE) <> 0) and
	3169	(FProviders.IndexOfProvider(IntToStr(FProviders.PendingIEN(FALSE))) < 0)) then
	3170	FProviders.AddProvider(IntToStr(FProviders.PendingIEN(FALSE)), FProviders.PendingName(FALSE), FALSE);
	3171	end;
	3172	end;
	3173	First := FALSE;
	3174	end;
	3175	Primary := (Providers.PrimaryIEN = User.DUZ);
	3176	case Ask of
	3177	apPrimaryOutpatient: DoAsk := (Primary and Outpatient);
	3178	apPrimaryAlways: DoAsk := Primary;
	3179	apNeeded: DoAsk := Needed;
	3180	apOutpatient: DoAsk := Outpatient;
	3181	apAlways: DoAsk := TRUE;
	3182	else
	3183	{ apPrimaryNeeded } DoAsk := (Primary and Needed);
	3184	end;
	3185	if(DoAsk) then
	3186	begin
	3187	if(Asked and ((not Needed) or (not Primary))) then
	3188	exit;
	3189	if(Needed) then
	3190	begin
	3191	msg := TX_NEED1;
	3192	Add(ndDiag, TX_NEED_DIAG);
	3193	Add(ndProc, TX_NEED_PROC);
	3194	Add(ndSC, TX_NEED_SC);
	3195	if(Primary and ForcePCEEntry(FEncLocation)) then
	3196	begin
	3197	Flags := MB_OKCANCEL;
	3198	msg := msg + CRLF + TX_NEED3;
	3199	end
	3200	else
	3201	begin
	3202	if(Primary) then
	3203	Flags := MB_YESNOCANCEL
	3204	else
	3205	Flags := MB_YESNO;
	3206	msg := msg + CRLF + TX_NEED2;
	3207	end;
	3208	Flags := Flags + MB_ICONWARNING;
	3209	end
	3210	else
	3211	begin
	3212	Flags := MB_YESNO + MB_ICONQUESTION;
	3213	msg := TX_NEED2;
	3214	end;
	3215	Ans := InfoBox(msg, TX_NEED_T, Flags);
	3216	if(Ans = ID_CANCEL) then
	3217	begin
	3218	Result := FALSE;
	3219	InfoBox(TX_NEEDABORT, TX_NEED_T, MB_OK);
	3220	exit;
	3221	end;
	3222	Result := (Ans = ID_NO);
	3223	if(not Result) then
	3224	begin
	3225	if(not MissingProviderInfo(Self)) then
	3226	begin
	3227	NeedSave := UpdatePCE(Self, FALSE);
	3228	if(not DoSave) then
	3229	DoSave := NeedSave;
	3230	FUpdated := TRUE;
	3231	end;
	3232	Done := frmFrame.Closing;
	3233	Asked := TRUE;
	3234	end;
	3235	end;
	3236	until(Done);
	3237	finally
	3238	if(DoSave) then
	3239	Save;
	3240	end;
	3241	end;
	3242	end;
	3243
	3244	procedure TPCEData.AddStrData(List: TStrings);
	3245
	3246	procedure Add(Txt: string);
	3247	begin
	3248	if(length(Txt) > 0) then List.Add(Txt);
	3249	end;
	3250
	3251	begin
	3252	Add(StrVisitType);
	3253	Add(StrDiagnoses);
	3254	Add(StrProcedures);
	3255	Add(StrImmunizations);
	3256	Add(StrSkinTests);
	3257	Add(StrPatientEds);
	3258	Add(StrHealthFactors);
	3259	Add(StrExams);
	3260	end;
	3261
	3262	procedure TPCEData.AddVitalData(Data, List: TStrings);
	3263	var
	3264	i: integer;
	3265
	3266	begin
	3267	for i := 0 to Data.Count-1 do
	3268	List.Add(FormatVitalForNote(Data[i]));
	3269	end;
	3270
	3271	function TPCEData.PersonClassDate: TFMDateTime;
	3272	begin
	3273	if(FEncSvcCat = 'H') then
	3274	Result := FMToday
	3275	else
	3276	Result := FEncDateTime; //Encounter.DateTime;
	3277	end;
	3278
	3279	function TPCEData.VisitDateTime: TFMDateTime;
	3280	begin
	3281	if(IsSecondaryVisit) then
	3282	Result := FNoteDateTime
	3283	else
	3284	Result := FEncDateTime;
	3285	end;
	3286
	3287	function TPCEData.IsSecondaryVisit: boolean;
	3288	begin
	3289	Result := ((FEncSvcCat = 'H') and (FNoteDateTime > 0) and (FEncInpatient));
	3290	end;
	3291
	3292	function TPCEData.NeedProviderInfo: boolean;
	3293	var
	3294	i: integer;
	3295	TmpLst: TStringList;
	3296
	3297	begin
	3298	if(FProviders.PrimaryIdx < 0) then
	3299	begin
	3300	Result := AutoCheckout(FEncLocation);
	3301	if not Result then
	3302	begin
	3303	for i := 0 to FDiagnoses.Count - 1 do
	3304	begin
	3305	if not TPCEDiag(FDiagnoses[i]).FDelete then
	3306	begin
	3307	Result := TRUE;
	3308	break;
	3309	end;
	3310	end;
	3311	end;
	3312	if not Result then
	3313	begin
	3314	for i := 0 to FProcedures.Count - 1 do
	3315	begin
	3316	if not TPCEProc(FProcedures[i]).FDelete then
	3317	begin
	3318	Result := TRUE;
	3319	break;
	3320	end;
	3321	end;
	3322	end;
	3323	if not Result then
	3324	begin
	3325	for i := 0 to FProviders.Count - 1 do
	3326	begin
	3327	if not FProviders[i].Delete then
	3328	begin
	3329	Result := TRUE;
	3330	break;
	3331	end;
	3332	end;
	3333	end;
	3334	if not Result then
	3335	begin
	3336	TmpLst := TStringList.Create;
	3337	try
	3338	GetHasCPTList(TmpLst);
	3339	if(DataHasCPTCodes(TmpLst)) then
	3340	Result := TRUE;
	3341	finally
	3342	TmpLst.Free;
	3343	end;
	3344	end;
	3345	end
	3346	else
	3347	Result := FALSE;
	3348	end;
	3349
	3350	procedure TPCEData.GetHasCPTList(AList: TStrings);
	3351
	3352	procedure AddList(List: TList);
	3353	var
	3354	i: integer;
	3355	tmp: string;
	3356
	3357	begin
	3358	for i := 0 to List.Count-1 do
	3359	begin
	3360	tmp := TPCEItem(List[i]).HasCPTStr;
	3361	if(tmp <> '') then
	3362	AList.Add(tmp);
	3363	end;
	3364	end;
	3365
	3366	begin
	3367	AddList(FImmunizations);
	3368	AddList(FSkinTests);
	3369	AddList(FPatientEds);
	3370	AddList(FHealthFactors);
	3371	AddList(FExams);
	3372	end;
	3373
	3374	procedure TPCEData.CopyPCEItems(Src: TList; Dest: TObject; ItemClass: TPCEItemClass);
	3375	var
	3376	AItem: TPCEItem;
	3377	i: Integer;
	3378	IsStrings: boolean;
	3379
	3380	begin
	3381	if(Dest is TStrings) then
	3382	IsStrings := TRUE
	3383	else
	3384	if(Dest is TList) then
	3385	IsStrings := FALSE
	3386	else
	3387	exit;
	3388	for i := 0 to Src.Count - 1 do
	3389	begin
	3390	if(not TPCEItem(Src[i]).FDelete) then
	3391	begin
	3392	AItem := ItemClass.Create;
	3393	AItem.Assign(TPCEItem(Src[i]));
	3394	if(IsStrings) then
	3395	TStrings(Dest).AddObject(AItem.ItemStr, AItem)
	3396	else
	3397	TList(Dest).Add(AItem);
	3398	end;
	3399	end;
	3400	end;
	3401
	3402	function TPCEData.Empty: boolean;
	3403	begin
	3404	Result := (FProviders.Count = 0);
	3405	if(Result) then Result := (FSCRelated = SCC_NA);
	3406	if(Result) then Result := (FAORelated = SCC_NA);
	3407	if(Result) then Result := (FIRRelated = SCC_NA);
	3408	if(Result) then Result := (FECRelated = SCC_NA);
	3409	if(Result) then Result := (FMSTRelated = SCC_NA);
	3410	// if(Result) and HNCOK then Result := (FHNCRelated = SCC_NA);
	3411	if(Result) then Result := (FHNCRelated = SCC_NA);
	3412	if(Result) then Result := (FCVRelated = SCC_NA);
	3413	if(Result) then Result := (FDiagnoses.Count = 0);
	3414	if(Result) then Result := (FProcedures.Count = 0);
	3415	if(Result) then Result := (FImmunizations.Count = 0);
	3416	if(Result) then Result := (FSkinTests.Count = 0);
	3417	if(Result) then Result := (FPatientEds.Count = 0);
	3418	if(Result) then Result := (FHealthFactors.Count = 0);
	3419	if(Result) then Result := (fExams.Count = 0);
	3420	if(Result) then Result := (FVisitType.Empty);
	3421	end;
	3422
	3423	{ TPCEProviderList }
	3424
	3425	function TPCEProviderList.Add(const S: string): Integer;
	3426	var
	3427	SIEN: string;
	3428	LastPrimary: integer;
	3429
	3430	begin
	3431	SIEN := IntToStr(StrToInt64Def(Piece(S, U, pnumPrvdrIEN), 0));
	3432	if(SIEN = '0') then
	3433	Result := -1
	3434	else
	3435	begin
	3436	LastPrimary := PrimaryIdx;
	3437	Result := IndexOfProvider(SIEN);
	3438	if(Result < 0) then
	3439	Result := inherited Add(S)
	3440	else
	3441	Strings[Result] := S;
	3442	if(Piece(S, U, pnumPrvdrPrimary) = '1') then
	3443	begin
	3444	FNoUpdate := TRUE;
	3445	try
	3446	SetPrimaryIdx(Result);
	3447	finally
	3448	FNoUpdate := FALSE;
	3449	end;
	3450	if(assigned(FOnPrimaryChanged) and (LastPrimary <> PrimaryIdx)) then
	3451	FOnPrimaryChanged(Self);
	3452	end;
	3453	end;
	3454	end;
	3455
	3456	function TPCEProviderList.AddProvider(AIEN, AName: string; APrimary: boolean): integer;
	3457	var
	3458	tmp: string;
	3459
	3460	begin
	3461	tmp := 'PRV' + U + AIEN + U + U + U + AName + U;
	3462	if(APrimary) then tmp := tmp + '1';
	3463	Result := Add(tmp);
	3464	end;
	3465
	3466	procedure TPCEProviderList.Clear;
	3467	var
	3468	DoNotify: boolean;
	3469
	3470	begin
	3471	DoNotify := (assigned(FOnPrimaryChanged) and (GetPrimaryIdx >= 0));
	3472	FPendingDefault := '';
	3473	FPendingUser := '';
	3474	FPCEProviderIEN := 0;
	3475	FPCEProviderName := '';
	3476	inherited;
	3477	if(DoNotify) then
	3478	FOnPrimaryChanged(Self);
	3479	end;
	3480
	3481	procedure TPCEProviderList.Delete(Index: Integer);
	3482	var
	3483	DoNotify: boolean;
	3484
	3485	begin
	3486	DoNotify := (assigned(FOnPrimaryChanged) and (Piece(Strings[Index], U, pnumPrvdrPrimary) = '1'));
	3487	inherited Delete(Index);
	3488	if(DoNotify) then
	3489	FOnPrimaryChanged(Self);
	3490	end;
	3491
	3492	function TPCEProviderList.PCEProvider: Int64;
	3493
	3494	function Check(AIEN: Int64): Int64;
	3495	begin
	3496	if(AIEN = 0) or (IndexOfProvider(IntToStr(AIEN)) < 0) then
	3497	Result := 0
	3498	else
	3499	Result := AIEN;
	3500	end;
	3501
	3502	begin
	3503	Result := Check(Encounter.Provider);
	3504	if(Result = 0) then Result := Check(User.DUZ);
	3505	if(Result = 0) then Result := PrimaryIEN;
	3506	end;
	3507
	3508	function TPCEProviderList.PCEProviderName: string;
	3509	var
	3510	NewProv: Int64;
	3511
	3512	begin
	3513	NewProv := PCEProvider;
	3514	if(FPCEProviderIEN <> NewProv) then
	3515	begin
	3516	FPCEProviderIEN := NewProv;
	3517	FPCEProviderName := ExternalName(PCEProvider, FN_NEW_PERSON);
	3518	end;
	3519	Result := FPCEProviderName;
	3520	end;
	3521
	3522	function TPCEProviderList.GetPrimaryIdx: integer;
	3523	begin
	3524	Result := IndexOfPiece('1', U, pnumPrvdrPrimary);
	3525	end;
	3526
	3527	function TPCEProviderList.GetProviderData(Index: integer): TPCEProviderRec;
	3528	var
	3529	X: string;
	3530
	3531	begin
	3532	X := Strings[Index];
	3533	Result.IEN := StrToInt64Def(Piece(X, U, pnumPrvdrIEN), 0);
	3534	Result.Name := Piece(X, U, pnumPrvdrName);
	3535	Result.Primary := (Piece(X, U, pnumPrvdrPrimary) = '1');
	3536	Result.Delete := (Piece(X, U, 1) = 'PRV-');
	3537	end;
	3538
	3539	function TPCEProviderList.IndexOfProvider(AIEN: string): integer;
	3540	begin
	3541	Result := IndexOfPiece(AIEN, U, pnumPrvdrIEN);
	3542	end;
	3543
	3544	procedure TPCEProviderList.Merge(AList: TPCEProviderList);
	3545	var
	3546	i, idx: integer;
	3547	tmp: string;
	3548
	3549	begin
	3550	for i := 0 to Count-1 do
	3551	begin
	3552	tmp := Strings[i];
	3553	idx := AList.IndexOfProvider(Piece(tmp, U, pnumPrvdrIEN));
	3554	if(idx < 0) then
	3555	begin
	3556	SetPiece(tmp, U, 1, 'PRV-');
	3557	Strings[i] := tmp;
	3558	end;
	3559	end;
	3560	for i := 0 to AList.Count-1 do
	3561	Add(AList.Strings[i]); // Add already filters out duplicates
	3562	end;
	3563
	3564	function TPCEProviderList.PendingIEN(ADefault: boolean): Int64;
	3565	begin
	3566	if(ADefault) then
	3567	Result := StrToInt64Def(Piece(FPendingDefault, U, 1), 0)
	3568	else
	3569	Result := StrToInt64Def(Piece(FPendingUser, U, 1), 0);
	3570	end;
	3571
	3572	function TPCEProviderList.PendingName(ADefault: boolean): string;
	3573	begin
	3574	if(ADefault) then
	3575	Result := Piece(FPendingDefault, U, 2)
	3576	else
	3577	Result := Piece(FPendingUser, U, 2);
	3578	end;
	3579
	3580	function TPCEProviderList.PrimaryIEN: int64;
	3581	var
	3582	idx: integer;
	3583
	3584	begin
	3585	idx := GetPrimaryIdx;
	3586	if(idx < 0) then
	3587	Result := 0
	3588	else
	3589	Result := StrToInt64Def(Piece(Strings[idx], U, pnumPrvdrIEN), 0);
	3590	end;
	3591
	3592	function TPCEProviderList.PrimaryName: string;
	3593	var
	3594	idx: integer;
	3595
	3596	begin
	3597	idx := GetPrimaryIdx;
	3598	if(idx < 0) then
	3599	Result := ''
	3600	else
	3601	Result := Piece(Strings[idx], U, pnumPrvdrName);
	3602	end;
	3603
	3604	procedure TPCEProviderList.SetPrimary(index: integer; Primary: boolean);
	3605	var
	3606	tmp, x: string;
	3607
	3608	begin
	3609	tmp := Strings[index];
	3610	if(Primary) then
	3611	x := '1'
	3612	else
	3613	x := '';
	3614	SetPiece(tmp, U, pnumPrvdrPrimary, x);
	3615	Strings[Index] := tmp;
	3616	end;
	3617
	3618	procedure TPCEProviderList.SetPrimaryIdx(const Value: integer);
	3619	var
	3620	LastPrimary, idx: integer;
	3621	Found: boolean;
	3622
	3623	begin
	3624	LastPrimary := GetPrimaryIdx;
	3625	idx := -1;
	3626	Found := FALSE;
	3627	repeat
	3628	idx := IndexOfPiece('1', U, pnumPrvdrPrimary, idx);
	3629	if(idx >= 0) then
	3630	begin
	3631	if(idx = Value) then
	3632	Found := TRUE
	3633	else
	3634	SetPrimary(idx, FALSE);
	3635	end;
	3636	until(idx < 0);
	3637	if(not Found) and (Value >= 0) and (Value < Count) then
	3638	SetPrimary(Value, TRUE);
	3639	if((not FNoUpdate) and assigned(FOnPrimaryChanged) and (LastPrimary <> Value)) then
	3640	FOnPrimaryChanged(Self);
	3641	end;
	3642
	3643	procedure TPCEProviderList.SetProviderData(Index: integer;
	3644	const Value: TPCEProviderRec);
	3645	var
	3646	tmp, SIEN: string;
	3647
	3648	begin
	3649	if(Value.IEN = 0) or (index < 0) or (index >= Count) then exit;
	3650	SIEN := IntToStr(Value.IEN);
	3651	if(IndexOfPiece(SIEN, U, pnumPrvdrIEN) = index) then
	3652	begin
	3653	tmp := 'PRV';
	3654	if(Value.Delete) then tmp := tmp + '-';
	3655	tmp := tmp + U + SIEN + U + U + U + Value.Name + U;
	3656	Strings[index] := tmp;
	3657	if Value.Primary then
	3658	SetPrimaryIdx(Index);
	3659	end;
	3660	end;
	3661
	3662	procedure TPCEProviderList.Assign(Source: TPersistent);
	3663	var
	3664	Src: TPCEProviderList;
	3665
	3666	begin
	3667	inherited Assign(Source);
	3668	if(Source is TPCEProviderList) then
	3669	begin
	3670	Src := TPCEProviderList(Source);
	3671	Src.FOnPrimaryChanged := FOnPrimaryChanged;
	3672	Src.FPendingDefault := FPendingDefault;
	3673	Src.FPendingUser := FPendingUser;
	3674	Src.FPCEProviderIEN := FPCEProviderIEN;
	3675	Src.FPCEProviderName := FPCEProviderName;
	3676	end;
	3677	end;
	3678
	3679	initialization
	3680
	3681	finalization
	3682	KillObj(@PCESetsOfCodes);
	3683	KillObj(@HistLocations);
	3684
	3685	end.

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: cprs/branches/tmg-cprs/CPRS-Chart/Encounter/uPCE.pas@ 732

Download in other formats: