Scratch
BOT Help Doc
Author:
Jeff Platt
Last
updated 11/15/2016
General Overview
Scratch
BOT enables JCapper users to import scratches and changes (in something
approaching real time) right from the internet. All you need is a live internet
connection and an understanding of the proper JCapper settings.
Scratch
BOT works by parsing web pages on the internet where scratches and changes info
is reported in a consistent and timely manner.
When
Scratch BOT finds new scratches and changes: Scratch BOT processes those
scratches and changes in a manner that JCapper can recognize and then notifies
you the user with a message box.
Scratch
BOT is a wonderful tool. But a word of warning is in order. Scratch BOT is only
as good as the info found on the web pages that it parses. If a horse is
scratched but not listed as a scratch on any of the web pages it parses, then
obviously Scratch BOT won’t be able to scratch the horse. If a race is taken
off the turf but the track for whatever reason doesn’t update the information
in the right way to Equibase, again, Scratch BOT
won’t be able to recognize the race as having been taken off the turf and won’t
be able to do its job correctly.
Based
on feedback, the overall user experience with Scratch BOT has been positive.
Most tracks do make every effort to get their web pages updated in real time.
Incorrect info posted on track web pages has actually become quite rare. But
mistakes by the tracks do happen occasionally.
Originally,
Scratch BOT was capable of parsing and processing Scratches and Races Off the Turf only.
Starting
with JCapper Build 198 ver 2.0 (and later) Scratch
BOT is now programmed to handle the following types of changes for HDW data
customers: Scratches, Races Off the Turf, Distance
Changes, Rider Changes, and Track Condition Changes.
For
those of you who are running older versions of JCapper – or those of you who
are using Brisnet data - Scratch BOT is programmed to
handle the following types of changes: Scratches, Races Off
the Turf, and Distance Changes.
Parsing the XML --
In
October, 2009 Equibase introduced a new system called
Scratches and Changes Today. The idea behind that system was to create a single
source on the web where players could go to get accurate scratches and changes
info constantly updated in something approximating real time. Very early on it
was decided that XML was the perfect delivery vehicle for getting scratches and
changes propagated out onto the web pages at Equibase.com as well as the web
pages of individual tracks and ADWs.
The Equibase XML Feed -
The
Equibase XML Feed is at the core of the Scratches and
Changes Today system. Scratches and changes from every North American track are
constantly updated to the XML feed throughout the day – often, within a minute
or two of when they are first announced by the track announcer over the public
address system.
It’s all in the timing
-
Before
moving on to the Scratch BOT tutorial I’d like to go over just a few of the
things you should be on the lookout for. Knowing ahead of time when scratches
and changes are updated on the web is crucial to you getting the most out of
Scratch Bot.
Here’s a
rundown of how and when scratches and changes are updated to the XML Feed:
Note: An
analysis of the previous system and where it was most frequently breaking down
clearly showed that in almost all cases, missing and/or incorrect scratches and
changes info was coming directly from the track employee level.
Relying on
the Equibase chart caller rather than track employees
to key in scratches and changes info was one of the keys to making the system
work as designed.
Understanding
how and when scratches and changes info becomes available in the XML is of
paramount importance when it comes to getting the most out of Scratch Bot.
Parsing the XML (How To)
Parsing the
XML is easy. Here are the steps:
After
the XML has been parsed, the user will be presented with various messages (for
scratches, races off the turf, distance changes, rider changes, and track
condition changes.)
After
clicking OK through the various messages, at this point (in about 99% of all
cases) complete current scratches and changes will have been imported into the
program.
To
see the effect of current scratches and changes on JCapper reports: X-out of
Scratch Bot, run a Calc Races, and launch the Report
Viewer.
Parsing
Rider Changes from the XML – HDW Info Model
Starting
with JCapper Build 198 ver 2.0 (and later) Scratch
BOT supports seamless parsing of rider changes from the XML for HDW data
customers.
Prerequisites List for seamless parsing of rider changes from the XML:
1. You must install a current version
Build 198 ver 2.0 (or later) c:\2004\JCapper.mdb
file.
2. You must be running JCapper Build Build 198 ver 2.0 (or later.)
3. The Data Vendor Setting
persisted on your User Sys Defs Screen must be: HDW.
4. You must have valid entries in the TrackAbbreviations table for those track codes where you
want Scratch BOT to be able to parse changes from the XML. (See the separate
section on the TrackAbbreviations table below.)
5. You must Populate
the CXNNames table in your current version Build 198 ver 2.0 (or later) c:\2004\JCapper.mdb file with rider
names.
6. The following settings must be
persisted in your Enhanced Settings Module as:
HDW
File Mgr Initial Data Folder: -1 Override DFM Checkbox.
CXN
Names Formatting: 0
Remove Punctuation Characters. (It cannot be 1 Punctuation Characters Left Intact.)
Scratch
BOT: 0 All
Scratches in the XML or 2 Block Vet Scratch Display on Reports. (It cannot be 1
Scratches For Loaded Card Files Only.)
Rider
Changes: -1 Rider
Changes ON.
7. One or more .JCP files for today’s
race date must be loaded into the program using the DFM Card Loader.
Note:
If you are running a third party Excel spreadsheet and you have loaded .JCP
files into that spreadsheet – in all likelihood Excel will place a lock or .ldb file on any .JCP files loaded into that spreadsheet.
Be
aware that Scratch BOT will not be able to write replacement rider names and
stats to .JCP files that have been locked by a third party Excel spreadsheet.
Your
best work-around would be to remove lock file(s) by closing down the
spreadsheet prior to running an XML parse routine. (And then relaunch the spreadsheet afterwards.)
When the
above prerequisites have been met: Scratch BOT seamlessly parses and processes
rider changes from the XML.
BASIC OPERATING INSTRUCTIONS for Parsing and Processing Rider
Changes from the XML:
1. Items 1-7 on the Prerequisites list
(above) must be met.
Before attempting to parse rider
changes from the XML:
Complete the Build 198 Install (install a current version c:\2004\JCapper.mdb
file as part of the build 198 install), make the required settings changes, and
populate the CXNNames table in your current version
c:\2004\JCapper.mdb file.
2. Launch Scratch BOT and click the XML
button to parse the xml.
3. Click OK through the various
messages (for scratches, races off the turf, distance changes, rider changes,
and track condition changes) as they are presented to you.
That’s It!
Populating the CXNNames
Table
There are
three ways to populate the CXNNames table with rider
names:
1. Follow the Install Instructions on
the JCapper Build 198 ver 2.0 web page
- and install the current version JCapper.mdb file comes with the download.
The
CXNNames table in that file comes pre-populated with
about 1300 .JCP file (HDW) compatible rider names – and gives you a great
starting point.
2. Use the Scratch BOT MENU to populate
the table.
3. Auto update of rider names during
.JCP File Build Routines.
BASIC OPERATING INSTRUCTIONS for
using the Scratch BOT MENU to populate the CXNNames
Table with HDW Rider Names:
1. Launch JCapper Scratch BOT, click
MENU, then select HDW Names - and select Populate CXNNames
Table with HDW StarterHistory Rider Names.
2. Click YES at the confirmation prompt
and use the dialog box that appears to select your SOURCE JCapper2.mdb file.
Required: The StarterHistory
table in the source JCapper2.mdb file you select in this step must contain HDW
rider names (not Brisnet.)
Required: The HDW rider names in the StarterHistory table of the JCapper2.mdb file you select in
this step MUST NOT contain punctuation characters.
Hint: The best way to get HDW rider
names without punctuation characters into a StarterHistory
table is to persist the CXN Names Formatting
setting in the Enhanced Settings Module as 0 Remove Punctuation Characters before (not after) you build .JCP
files. From there, the (punctuation free) names in your .JCP files are the
names written to your StarterHistory table when you
click the Build Database button.
Upon
clicking the OPEN button on the dialog box to finalize selection of your source
JCapper2.mdb file, the dialog box will close – and the interface will present you
with an input box that contains date text for a default start date:
3. Either accept
the default start date presented by the interface – or alternately - key your
own date text for the start date - and click OK to continue.
The
interface will apply the date text of your start date - and start the routine.
During the routine the interface will read rider names from the RIDER field in
the StarterHistory table of the source JCapper2.mdb
file selected in step 2 (above) and write each rider name to the Name1 field of
the CXNNames table in your c:\2004\JCapper.mdb file.
The NameType field for each record written during
this routine will be given a value of 1 to designate the entry as an HDW rider
name.
This
routine may take a few minutes to run. After the routine has run to completion
the interface will present you with a message telling you how many new rider
names were found in the source file StarterHistory
table and added to the CXNNames table in the
c:\2004\JCapper.mdb file.
That’s It!
Auto updating of rider names during .JCP File Build Routines
Starting
with Build 198 ver 2.0 (and later) when you run a
.JCP File Build Routine, the HDW File Mgr searches
the rider name for the current horse being processed against the list of rider
names recorded in the CXNNames table of the
c:\2004\JCapper.mdb file. If the rider name for the current horse doesn’t exist
in the CXNNames table: The interface adds it to the
table. If the rider name does exist in the table – nothing special happens –
and the interface simply processes the remaining data fields for the current
horse.
The above
routine is automatic – and requires no interaction from the user – provided
items 1-6 on the Prerequisites list (above) have been met.
Recommended Best Practice for populating the CXNNames table with rider names:
1. Start out by installing a current
version JCapper.mdb file as part of your JCapper Build 198 ver
2.0 (and later) Install. That gets you a CXNNames
table that has been prepopulated with about 1300 .JCP (HDW) compatible rider
names.
2. From there work through the
Prerequisites List (above.) Make the settings changes and double check them.
3. From there populate the CXNNames table with (any) additional names by running an
Update CXNNames Table with StarterHistory
Rider Names routine using the MENU in Scratch BOT.
Hint:
Use a start date that gets you a significant time period. A JCapper2.mdb file
with a StarterHistory table that contains one year of
back data is about right. Also, make sure the StarterHistory
table in the JCapper2.mdb file that you select contains rider names formatted
with punctuation characters stripped. (Double check them
first and rebuild .JCP files and database folders as needed.)
4. From there use Auto Updating of Rider
Names during .JCP File Build Routines. No interaction on the part of the user
(provided you are an HDW Data customer) is required. The CXNNames
table will be updated constantly with the names of new riders as they appear in
the Equibase data.
Clearing the CXNNames
Table
You may
clear the CXNNames Table at any time.
To clear
the CXNNames Table: Click MENU, select HDW Names –
and click Clear HDW Names (Rider, Trainer, etc.) from CXNNames
Table, and answer YES at the prompt.
Note: Do
not clear the table unless you have the ability to repopulate it. (A StarterHistory table with about 1 year of back data/HDW
rider names formatted with punctuation characters stripped out is about right.)
Processing of Rider Names Parsed
from the XML – How it works
When the Prerequisites
List (above) has been met and you click the XML button – Scratch BOT performs
the following steps:
1.
Identifies rider changes in the XML.
2. Parses
rider names from the XML, sends each name (as it exists in the xml) to a name
formatting function that makes its best attempt at morphing the xml name into
the same format as a .JCP data file name.
3. Takes
each reformatted xml name (from step 2 above) and runs it against the names in
the Name1 field of the CXNNames table looking for a
match.
4. If a
match is found between a reformatted xml name and a name in the Name1 field of
the CXNNames table the interface:
a. Writes
the unformatted xml name to the Name2 field of the CXNNames
table in the same row where the Name1 match was found.
b. Writes a
value of True to the Active field of the CXNNames
table in the same row where the Name1 match was found.
At this
point, the |Name1 / Name2 / Active| entry in the CXNNames
table is considered a 'Resolved Name'...
The general
rule is that the CXNNames table must contain a proper
entry (called a Resolved Name) before Scratch BOT can process a replacement
rider name parsed from the XML.
From this
point forward, whenever Scratch BOT parses a Name2 match from the XML the
interface will have the ability to recognize the xml name as a valid rider name
- and as a result can process the Rider Change in the following manner:
• Write the
New Rider Change to a new table (called the Changes table) in the
c:\2004\JCapper.mdb file.
• If the
rider change is for the same track code as that of a .JCP file that has been
loaded into the program for the same folder where you are running an XML parse
routine:
Scratch BOT
does the following:
a. Opens up
the .JCP file and inserts the new (resolved) rider name into the file for the
horse with the rider change.
b. Checks
the .JCP file to see if that same rider has another mount that day -- and if so
-- pulls all of the stats for that rider using the first other mount found -
and inserts them into the correct fields for the horse where the rider change
is taking place.
c. Saves
the modified .JCP file.
--At this
point:
Each .JCP
file that was loaded into the program when rider changes for that file were
parsed from the XML will contain not only each (resolved) replacement rider
name -- but the stats for the replacement rider provided he or she was named to
ride at least one other mount for the same race card.
Screenshot
that I ran for the SAR0826 card:
http://www.jcapper.com/messageboard/avatars/ScratchBOT-RiderChangesMsg.jpg
Note: I
purposely chose that card because I was working on getting Off-Turf races
written to the changes table and 08-26-2016 was the last date that Saratoga had
races come off the turf.
Note: The
screenshot only shows 1 .JCP file overwritten because the SAR0826.JCP file was
the only card file loaded into the program when I ran the XML parse routine.
Q. How did
I run an XML parse routine for a prior race date?
A. I've
been saving the XML files for each race date - and the new Scratch BOT has a
menu item that enables you to parse a previously saved XML file.
Parsing
Track Condition Changes from the XML
Starting
with JCapper Build 198 ver 2.0 (and later) Scratch
BOT supports seamless parsing of Track Condition changes from the XML for HDW
data customers.
The Prerequisites List for seamless parsing of Track Condition changes from the XML
is the almost identical to the Prerequisites List for Rider Changes (above.)
The key
difference is that parsing track condition changes from the XML does not
require a populated CXNNames table:
1. You must install a current version
Build 198 ver 2.0 (or later) c:\2004\JCapper.mdb
file.
2. You must be running JCapper Build Build 198 ver 2.0 (or later.)
3. The Data Vendor Setting
persisted on your User Sys Defs Screen must be: HDW.
4. You must have valid entries in the TrackAbbreviations table for those track codes where you
want Scratch BOT to be able to parse changes from the XML. (See the separate
section on the TrackAbbreviations table below.)
5. You must Populate the CXNNames table in
your current version Build 198 ver 2.0 (or later)
c:\2004\JCapper.mdb file with rider names.
6. The following settings must be
persisted in your Enhanced Settings Module as:
HDW
File Mgr Initial Data Folder: -1 Override DFM Checkbox.
CXN
Names Formating: 0 Remove Punctuation Characters. (It cannot be 1
Punctuation Characters Left Intact.)
Scratch
BOT: 0 All
Scratches in the XML or 2 Block Vet Scratch Display on Reports. (It cannot be 1
Scratches For Loaded Card Files Only.)
Rider
Changes: -1 Rider
Changes ON.
7. One or more .JCP files for today’s
race date must be loaded into the program using the DFM Card Loader.
When the
above prerequisites have been met: Scratch BOT seamlessly parses and processes
Track Condition changes from the XML.
BASIC OPERATING INSTRUCTIONS for Parsing and Processing Track Condtion Changes from the XML:
1. Items 1-4 and 6-7 on the
Prerequisites list (above) must be met.
2. Launch Scratch BOT and click the XML
button to parse the xml.
3. Click OK through the various
messages (for scratches, races off the turf, distance changes, rider changes,
and track condition changes) as they are presented to you.
That’s It!
(No further user action is required.)
Provided
all items on the Prerequisites List are met, as Track Condition Changes are
parsed from the XML, Scratch BOT automatically writes proper entries to the
RaceHeaders.txt file for the folder just parsed. The result is exactly the same
as bringing up race(s) in the Manual Changes Module, making change(s) to Track
Condition, and clicking the Save button.
Changes
Table Report
It was
necessary to add a new table called the Changes table to the
c:\2004\JCapper.mdb file in order to make rider changes possible.
There's a
rather cool side benefit that comes from that.
Suppose you
have 15+ tracks loaded on Folder 1 on a busy race day and you click the XML
button and run an XML parse routine for folder1.
In older
versions of JCapper you’d get a message box telling you that (something like)
178 scratches have been parsed from the XML.
Trouble is
- even though you remember that the last time you parsed the XML for folder1
there were 175 scratches - and you therefore know there are 3 NEW scratches...
You don't
have any idea WHERE - as in what track code and race number - those 3 new
scratches took place.
They could
be at some track you aren't playing. They could be for a race that goes to post
hours from now...
Or 1 of
them could be for a race that's going to post in a minute or two... a race you
might want to play - if you only KNEW ABOUT the new scratch!
The new
version of Scratch BOT in JCapper Build 198 enables you to generate an html
report showing detail for all records in the (new) changes table.
The (new)
report flags new changes that were picked up during the most recent XML parse
routine in red. The report is also sorted so that new changes picked up by the
most recent parse routine are displayed at the very top of the report - so you
can see them at a glance.
That way -
if a new change just happened for a race that's going to post in a minute or
two - you'll know about it.
And you'll
have a chance to run a single race Calc Races for
that race before the race goes off.
Whereas
in the past - you wouldn't have a chance to know about it at all.
Screenshot
that I ran for the SAR0826 card showing the top of the report:
http://www.jcapper.com/messageboard/avatars/ScratchBOT-TopOfChangesReport.jpg
Screenshot
that I ran for the SAR0826 card showing rider changes for SAR in the middle of
the report:
http://www.jcapper.com/messageboard/avatars/ScratchBOT-MidChangesReport.jpg
Note:
Again, I purposely chose that card because I was working on getting Off-Turf
races written to the changes table and 08-26-2016 was the last date that
Saratoga had races come off the turf.
Note: All
of the changes in the above screenshots are shown as new changes. That's to be
expected for the very first XML parse routine of the race day. After that, the
interface compares the timestamp for the current parse routine being run
against the value of the firstReported field in the
Changes table. This enables Scratch BOT to designate between NEW changes and
existing changes.
From there
- as you run several XML parse routines throughout the race day - only the NEW
changes from the most recent XML parse routine will display on the report in
red -- and the report will be sorted so that the NEW changes display at the top
of the report.
Link to a
sample Changes Table Report that I ran for 09-25-2016 at 11:17:55 am pacific
(about 15 minutes after the first XML parse of the day) showing new changes at
the very top of the report:
http://www.jcapper.com/messageboard/reports/ ChangesTableReport_09252016_1119am.html
BASIC OPERATING INSTRUCTIONS for running a Changes Table Report:
Click Menu,
then click Changes Table Report, and answer YES at the prompt. The interface
will generate the report, expand Scratch BOT by auto-clicking the + button, and
display the report in the right side viewing area.
-or
alternately:
After
Scratch BOT has been expanded, you will see a button labeled Changes Table
Report. Click the button and answer YES at the prompt. The interface will
generate the report, expand Scratch BOT by auto-clicking the + button, and
display the report in the right side viewing area.
You may
also view the report file in a web browser. The filename for the report is:
c:\JCapper\Exe\ ChangesTableReport.html.
Clearing the Changes Table
You may
clear the Changes Table at any time.
To clear
the Changes Table: Click MENU, click CLEAR CHANGES
from Changes Table, and answer YES at the prompt.
Also, the
Changes Table is cleared automatically at the start of each race day in the DFM
Card Loader when you click the Clear ALL – Folders 123 button to clear loaded
card files from the previous day.
Populating the Changes Table
The Changes
table auto populates each time you parse the XML - provided all items on the
Prerequisites List (above in the Rider Changes section) are met.
The Scratch BOT MENU
Newer
versions of Scratch BOT have a clickable Menu located in the upper left hand
area of the screen. In this section I’ll cover each of the Menu items briefly.
Screenshot
showing the Scratch BOT Menu after clicking MENU:
http://www.jcapper.com/messageboard/avatars/ScratchBOT_Menu.jpg
Parse XML File on
Local Machine Menu Item
This
menu item enables you to parse XML document files from previous race days
stored on your hard drive.
Each
time you click the XML button and parse the XML: Scratch BOT creates a copy of
the XML document file currently being parsed on your hard drive.
The
full path and filename for the current XML document file is:
c:\JCapper\Exe\ScratchesAndChanges.xml.
Each
time you parse the XML, the previous XML document file
is overwritten and replaced with the current XML document file.
However,
at the start of each new race day (or alternately late at night at the end of each
race day) if you make a habit out of navigating to your c:\JCapper\Exe folder
and renaming the ScratchesAndChanges.xml file from its default filename of
ScratchesAndChanges.xml to a user defined filename that contains the racedate (for example ScratchesAndChanges_09302016.xml) and
then copy the renamed file to a yearly folder that you’ve created for the
specific purpose of storing prior day XML scratches and changes files – after a
while you will have built up a library of prior day XML scratches and changes
files.
From
there, any time you decide to load prior day data files into the program with
the DFM Card Loader – you can then easily pick up prior day Scratches and
Changes. Simply use the Parse XML File on Local Machine Menu Item in Scratch
BOT to parse the correct prior day XML document file sitting on your hard
drive.
From
there – just run a Calc Races.
It’s
a great way to generate JCapper reports for prior race dates.
BASIC OPERATING
INSTRUCTIONS for
Parsing a Prior Day XML Scratches and Changes File:
1. You must have first saved (or at
least renamed) the desired prior day XML Scratches and Changes File as
described above.
2. Click MENU and then select Parse XML
File on Local Machine and answer YES at the prompt. This will toggle local XML
parsing ON. (You will see text displayed at the top of Scratch BOT indicating
that local XML parsing has been toggled on.)
Note:
To toggle local XML parsing OFF – simply click the menu item again and answer
NO at the prompt.
3. With local XML parsing toggled ON –
click the XML button. Instead of parsing the XML at the Equibase
site, Scratch BOT will open up a dialog box.
4. From here, use the dialog box to
navigate your hard drive and select a previously saved (prior day) XML
scratches and changes file.
Note:
Clicking Cancel at this point instead of selecting a previously saved (prior
day) XML scratches and changes file causes Scratch BOT to toggle local XML
parsing OFF and abandon the local parse routine.
5. After using the dialog box to select
a previously saved (prior day) XML scratches and changes file, click the OPEN
button on the dialog box.
6. Scratch BOT will parse scratches and
changes from the XML scratches and changes file selected in the previous step.
That’s
It!
Changes Table Report
Menu Item
Clicking
this menu item generates the Changes Table Report described (above) in the
Changes Table Report section.
Compact and Repair
JCapper.mdb File Menu Item
This
menu item opens up a dialog box that enables you to run a Compact and Repair
routine on a selected JCapper.mdb file.
Note:
It is generally a good idea to compact and repair the c:\2004\JCapper.mdb file
after adding or deleting a significant number of records from one of the tables
in the file. Populating the CXNNames table with more
than say 250 new rider names or clearing all rider names from the CXNNames table would both be examples that would call for a
compact and repair of the c:\2004\JCapper.mdb file.
Clear Changes from the
Changes Table Menu Item
This
menu item enables the user to manually clear the Changes table.
Clear Names (rider,
trainer, etc.) from CXNNames Table Menu Item
This
menu item enables the user to manually clear all names from the CXNNames table.
CXNNames
Table Interface Menu Item
This
menu item launches a datasheet style interface to the CXNNames
table.
As
of this writing I am considering whether or not to create a formal wizard style
interface for the CXNNames table that will appear in
a future JCapper program update. I included the datasheet style interface with the
initial release of JCapper Build 198 ver 2.0 in the
event that manual edit of a rider name in the CXNNames
table becomes necessary to create/achieve ‘Resolved Name’ status.
So
far (after a few weeks of beta testing) manual edit of rider names in the CXNNames table has not been necessary.
In
the event manual edit of a rider name in the CXNNames
table does become necessary to create/achieve ‘Resolved Name’ status: I will
post instructions on the JCapper Message Board.
Until
such time as that happens:
It might be a very good idea not to mess with the datasheet style interface to
the CXNNames table. I recommend that you not click
this menu item and that you not play around with the datasheet style interface
to the CXNNames table.
Why?
Because
- unless you know what you are doing - it can be easy to accidentally edit a
‘Resolved Name’ entry in the CXNNames table in such a
way that you ‘break’ ‘Resolved Name’ status for the single rider involved.
If
that happens the result will be that you end up preventing Scratch BOT from
processing rider changes for the individual rider involved.
So
stay out of the CXNNames Table Interface unless you
absolutely need to edit an entry and you know what you are doing.
Update CXNNames Table with StarterHistory
Rider Names Menu Item
This
menu item enables the user to populate the CXNNames
table in the c:\2004\JCapper.mdb file with rider names read from the StarterHistory table of a user selected SOURCE JCapper2.mdb
file.
Instructions for operating this menu
item appears
beneath the BASIC OPERATING INSTRUCTIONS for using the Scratch BOT MENU to
populate the CXNNames Table headline in the Parsing
Rider Changes from the XML section (above.)
Required
Settings for Scratch BOT Operation
This
section covers JCapper user settings that Scratch BOT relies on for its
operation.
The TrackAbbreviations
Table
Scratch Bot
uses data stored in the TrackAbbreviations Table of
the c:\2004\JCapper.mdb file when parsing the Equibase
XML Feed.
IMPORTANT: The purpose of TrackAbbreviations
table entries is to enable Scratch BOT to parse the Equibase
XML. The following three entries must be
present in the TrackAbbreviations Table for each
track you wish to have Scratch BOT process for you when you click the XML
button:
FileAbbrev
Field
Key the
first three characters of the data file name for the individual track into this
field.
ToteAbbrev
Field
Key the
first three characters of the data file name for the individual track into this
field.
Notes Field
Key the
full track name found in the track_name attribute as
listed in the XML itself into this field.
Hint: After
clicking the XML button, click the Plus “+” button to display the complete XML
in the Display Window. The XML itself is clickable. Clicking the minus sign “-“ or dash character to the left of each track node in the
XML will collapse the XML for that individual track. Clicking the “+” or plus
character to the left of a collapsed track node in the XML will expand the XML
for that individual track. Expanding the XML for each track will make nodes
containing track_name attribute tags visible. Use the
track name as listed in the track_name attribute tags
for each track.
Note:
Although there may be multiple track_name attribute
tags listed in the xml for each track, Scratch BOT requires a single entry for
each track (which includes data for each of the three fields listed above) in
order to be able to read and process changes from the XML for a given track.
Example:
Suppose for the sake of argument that you want to create a set of table entries
for
The Track Abbr
Table Button
The Track Abbr Table Button is located in the bottom left area of the
Scratch Bot screen. Clicking the Track Abbr Table
Button will launch the Track Abbreviations Data Entry Screen – enabling you to
make TrackAbbreviations Table entries so that you can
set up individual tracks in Scratch Bot.
Link to a
screenshot showing the proper entries for Delaware Park with the expanded XML
sitting in the background:
http://www.jcapper.com/messageboard/avatars/ScratchBOT_DEL.jpg
Bullet
points for the above linked to screenshot:
• Track
Code Field: DEL (Why? Because DEL matches the first 3 characters of the data file
name.)
• Tote Code
Field: DEL (Why? Because DEL matches the first 3 characters of the data file
name.)
• Notes
Field: DELAWARE PARK (Why? Because DELAWARE PARK matches the track_name attribute of the track node in the clickable
xml.)
Instructions for Using the original TrackAbbreviations Table Interface
Originally,
the Track Abbrev Table button launched a datasheet style interface (filename:
TrackAbbreviations.exe.) The instructions in this section are provided for
those of you who are running older versions of JCapper that were downloaded at
a time when this was the interface for maintaining entries in the TrackAbbreviations table.
The TrackAbbreviations Table Interface behaves in a way that is
very similar to a spreadsheet. Making entries is easy. Simply click inside of
the cell where you want to enter data and key in the data that you want to
enter. There is no Save button. To persist data sitting in a cell to the table,
simply navigate (with a mouse click or by hitting the tab key on your keyboard)
to a different cell. The data in the cell that you just navigated away from
will appear to “jump” slightly. As soon as you see the data “jump” it will have
been written to the table.
Adding a New Row
To add a
new row using the TrackAbbreviations Table Interface,
first launch the TrackAbbreviations Table Interface
by clicking the Track Abbrev Table button. Then scroll or tab all the way to
the bottom until the very bottom row in the interface becomes visible. Hint:
The very bottom row in the interface will be indicated by the presence of a
Star/Asterisk “*” character in the box located at the left hand edge of the
row. Click inside of a cell in the bottom row, key your data into that cell,
and navigate to the next cell with a mouse click or by using the tab key. When
data has been persisted in all three fields (TrackAbbrev,
ToteAbbrev, and Notes) your new entry will be
complete.
Deleting an Existing Row
To delete
an existing row using the TrackAbbreviations Table
Interface, first launch the TrackAbbreviations Table
Interface by clicking the Track Abbrev Table button. Scroll or tab vertically
through the table until the row you wish to delete becomes visible. Highlight
the row you wish to delete by single clicking the box at the left hand edge of
that row. Finally, with the row highlighted, tap the Delete key on your
keyboard once. The row will disappear – indicating that data for that row has
been deleted from the table.
A Word of Warning: When you delete a
row using this interface, you will not be presented with a warning/confirmation
message prior to deleting a highlighted row from the table. As soon as you tap
the Delete key, the interface will delete the highlighted row from the table.
Editing Data in an Existing Row
To edit
data in an existing row using the TrackAbbreviations
Table Interface, first launch the TrackAbbreviations
Table Interface by clicking the Track Abbrev Table button. Scroll or tab
vertically through the table until the row you wish to edit becomes visible.
Click
inside of a cell in the row you wish to edit, key your data into that cell, and
navigate to the next cell with a mouse click or by hitting the tab key. When
data has been persisted in all three fields (TrackAbbrev,
ToteAbbrev, and Notes) your edit will be complete.
Note: Alternately you can use a
third party database app such as Microsoft Access to open the c:\2004
JCapper.mdb file and edit data in the TrackAbbreviations
Table.
Exceptions – Handling the Ampersand
“&” Character:
For some
reason there are a handful of tracks that insist on making an ampersand “&”
character part of their own track name in the Equibase
XML. This is problematic because the ampersand character is part of the SQL
command set. Using the ampersand character as part of the track name has the ability
to wreak havoc with SQL expressions attempting to read such track names from
tables.
I have
created an internal work around to enable Scratch BOT to handle track such
track names. As of this writing there have been only two track names using the
ampersand character as part of the track name in the Equibase
XML: Charles Town and Mountaineer.
The valid
Notes field entry, despite what appears in the xml, for Charles Town is simply
“Charles Town” (without the quote characters.)
The valid
Notes field entry, despite what appears in the xml, for Mountaineer is simply
“Mountaineer” (without the quote characters.)
Note: Be
aware that tracks sometimes change their names. For that reason, track names as
listed in the track_name attribute in the xml are subject
to change. If and when a track changes its name in the xml, it is your job to
pull up the TrackAbbreviations Table Interface and
edit the Notes Field for that track.
Importing Default Settings (Master
Track List) Into the TrackAbbreviations Table
Default
settings (also known as the Master Track List) for the TrackAbbreviations
Table were compiled in late summer 2010 and are included in the TrackAbbreviations Table in the JCapper.mdb file placed on
the c:\JCapperBuild folder during a program install.
To import
the default settings from the c:\JCapperBuild\JCapper.mdb file into the active
c:\2004\JCapper.mdb file so that the Master Track List will become available to
Scratch Bot when parsing the XML:
Click the
Import Master Track List button located on the lower right hand area of the
Scratch BOT screen and answer Yes at the prompts.
Logic
within Scratch BOT will import the Master Track List (default entries for all
North American tracks) from the TrackAbbreviations
Table found in the c:\JCapperBuild\JCapper.mdb file into the same table in the
c:\2004\JCapper.mdb file. After the import routine is complete, you will find
that your previous TrackAbbreviations Table entries
will have been overwritten with new entries from the master track list.
The User System Definitions Screen –
Settings that impact Scratch BOT
The Data Vendor Checkbox
The Data
Vendor Setting on the User System Definitions Screen is one of the items on the
Prerequisites List for parsing Rider Changes from the XML.
As of this writing,
September 29, 2016, when The Data Vendor Setting on the User System Definitions
Screen is persisted as HDW - Provided all of the other items on the
Prerequisites List are met - Scratch BOT will parse (and process) rider changes
from the XML.
As of this
writing, September 29, 2016, when The Data Vendor Setting on the User System
Definitions Screen is persisted as Brisnet – It
doesn’t matter how many of the other items on the Prerequisites List are met -
Scratch BOT will NOT parse (and process) rider changes from the XML.
Note: This
will likely change in a future program update. But at this time – parsing and
processing rider changes from the XML in Scratch BOT requires that you be using
HDW data files.
The Enhanced Settings Module –
Settings that impact Scratch BOT
Scratch BOT Parse Type Setting
The Scratch
BOT setting in the Enhanced Settings Module is one of the items on the
Prerequisites List for parsing Rider Changes from the XML and gives you
explicit control over Scratch BOT behavior as relates to parsing changes from
the XML.
Below is a
description of the options for this setting.
Scratch
BOT Setting
Element
Type: Drop Down
Purpose:
Controls the type of parse routine used by Scratch BOT when the XML Button is
clicked.
Options:
Hint:
Use this setting if you want Scratch BOT to be able to parse and process rider
changes from the XML.
Hint:
Use this setting if you don’t want Scratch BOT to be able to parse and process
rider changes from the XML.
Hint:
Use this setting if you don’t use Vet Scratches in your handicapping, want the
ability to use them at some future point, don’t want to see them on your
reports today, AND want Scratch BOT to be able to parse and process rider
changes from the XML.
HDW File Mgr
Initial Data Folder Setting
Element
Type: Drop Down
Purpose:
This setting is one of the items on the Prerequisites List for parsing Rider
Changes from the XML and enables Scratch BOT to find, identify, and overwrite
.JCP files loaded into the program via the DFM Card Loader with replacement
rider names during XML parse routines.
This
setting also controls the initial data folder (upon startup) for the HDW File Mgr module.
Options:
Hint:
Use this setting if you want Scratch BOT to be able to parse and process rider
changes from the XML.
Also,
when this option is selected, the HDW File MGR “defaults” to the folder named
as DataFolder1 – and uses that folder upon startup – even if the boxes for
DataFolder2 or DataFolder3 are checked. This allows you to skip the step of
bringing up the DFM and re-checking DataFolder1 before downloading files from
the HDW site.
Hint:
Use this setting if you don’t want Scratch BOT to be able to parse and process
rider changes from the XML.
Also,
when this option is selected, the HDW File MGR “defaults” to the folder
persisted as checked – be it DataFolder1, DataFolder2, or DataFolder3.
Hint:
Use this setting if you really don’t mind bringing up the DFM and checking (or
rechecking) DataFolder1 each time you launch the HDW File Mgr
before downloading files from the HDW site.
CXN Names Formatting Setting
This
setting is one of the items on the Prerequisites List for parsing Rider Changes
from the XML. This setting controls how names for riders, trainer, and owners
are formatted during .JCP File Build Routines. This setting also controls how
names of horses are formatted for insertion into .JCP files.
Options:
Also,
when this option is selected, the HDW File MGR removes punctuation characters
from the names of riders, trainers, and owners during .JCP file build routines.
Also,
when this option is selected, the HDW File MGR removes apostrophe characters
from horsenames prior to insertion into .JCP files.
The
primary purpose for this option is to facilitate handling of names for riders,
trainers, owners, and horses in sql expressions.
Hint:
I strongly encourage you to use this option.
Also,
when this option is selected, the names for riders, trainers, owners, and
horses are inserted exactly as they exist in the Equibase
data (with all punctuation characters intact) upon delivery to HDW.
Hint:
Use this setting if you don’t want Scratch BOT to be able to parse and process
rider changes from the XML and/or if you have zero intention of ever operating
JCapper in SQL Mode.
The Rider Changes Setting
This setting
is one of the items on the Prerequisites List for parsing Rider Changes from
the XML. When all of the items on the Prerequisites List for parsing Rider
Changes from the XML are met: This setting acts as the ON/OFF switch for
parsing and processing Rider Changes from the XML.
Options:
The CXNNames
Table
Scratch Bot
uses data stored in the CXNNames Table of the
c:\2004\JCapper.mdb file when parsing rider changes from the XML. Having a
populated CXNNames table is one of the items on the
Prerequisites List for parsing and processing of rider changes. The general
rule is that the CXNNames table must contain a proper
entry (called a resolved name) before Scratch BOT can process a replacement
rider name parsed from the XML.
See the
section beneath the Parsing Rider Changes from the XML headline (above)
for instructions for populating the CXNNames table.
The Scratches.txt file
This is not
a setting per se but you need to know about this file. The Scratches.txt file
sits on your current Default Data Folder and contains all current scratches.
You can view this file in Notepad (or other text editor) by navigating to your
current Default Data Folder, finding the file, and opening it with a double
click. Keep in mind that opening this file using a third party app may place a
“lock” on this file. When the file is “locked” you will be unable to run a Calc Races routine. To clear an existing “lock” on this
file, simply close down whatever third party app you are using to view this
file.
The Clear Scratches Button
To Clear Scratches, simply click the Clear Scratches button and answer Yes at
the prompt. Doing this causes JCapper to overwrite the existing Scratches.txt
file with a fresh blank file.
Important Note: As a Best Practice,
I strongly recommended that you get in the habit of clearing out the previous
day's scratches (before getting scratches for each new race day) at the start
of each new race day. Why? Clearing Scratches prevents thousands of scratches
from accumulating in the Scratches.txt file. You can use any of the following
modules to clear scratches: Card Loader, File Downloader, Scratch Parser,
Manual Changes Module, or Scratch Bot.
Section
II – Parsing Live Tote and Individual Track Links
Note: Prior to October, 2009 parsing
Live Tote and Scratches Links for individual tracks was
the preferred way of operating Scratch Bot. This functionality remains as part of
Scratch BOT. Users still using it will find that occasionally use of this
functionality makes a good adjunct to parsing the XML. This is especially true
with gate scratches.
Parsing Live Tote Links
In my
opinion parsing the XML provides an overall superior user experience vs.
parsing the live tote links.
However, if
you so choose, you can still parse Live Tote links for individual tracks loaded
into JCapper (using the DFM Card Loader, the original Card Loader, or Screen
Two of the File Downloader) as a source for scratches and changes info.
Here are
the steps:
Note: Clicking a live tote link does
not clear existing scratches.
When and Why Live Tote Links are
sometimes more up to date than the XML:
The chart
caller can normally be expected to log into the Equibase
system and key in fresh scratches as soon as it is reasonable and prudent for
him to do so. However, in cases where the chart caller has already taken up a
position to start calling the race (one or more horses are already in the gate)
and a scratch occurs – in some racing jurisdictions (most notably
In such
cases you are better off parsing the Live Tote Link to pick up the scratch (or
using the Manual Changes Module) than you are parsing the XML.
Scratches and Entries
Note: If a
horse is scratched at the gate and that horse is part of an entry:
Note: In almost all cases, your best
means of picking up scratches when one part of an entry is scratched is to use
the Manual Changes Module.
Starting a New Session (and dealing with those annoying Session
Expired Messages)
Before
diving into instructions for starting a session, it might be a good idea to
first point out that starting a session is not required to parse the XML.
However,
starting a session and getting a session cookie placed on your local machine is
required prior to using Scratch BOT to parse the Live Tote Stream and Scratches
Links for individual tracks at Brisnet.com.
If you get
a “Session Expired” message when parsing a live tote link or an individual
track link, that means that you do not have a valid session cookie on your machine.
Your best course of action to get a session cookie placed on your machine would
be to log into Supertote and start a new Session.
Scratch Bot
contains an embedded Internet Explorer web browser. Each time you click on a
live tote link or a track scratches link, the Internet Explorer web browser
part of Scratch BOT visits web pages that present current live odds and
scratches information. This behavior is no different than if you had an open
instance of Internet Explorer running and used it manually to surf the same web
pages. One link click in Scratch BOT equals one link click in Internet
Explorer. Literally. When I first created Scratch BOT in early 2004, Bris didn’t care that apps like it might be browsing their
live web pages. Since that time they have changed their tune and have
implemented security measures designed to prevent unauthorized users from
browsing their live odds pages. Their security measures involve having the page
itself ask the user to log in using a valid username and password followed by having their server place a
session cookie onto the user’s local machine. Their web pages are
programmed to check for the presence of a session cookie. If one is found, the
user is allowed to browse the current web page. If a session cookie is not found,
of if it is found to have expired, the user is presented with a session expired
message. The easiest best way to get the Bris server
to place a session cookie placed on your local machine (which gives you
subsequent rights to browse their pages) is to have a Bris
account in good standing and log onto their site with your Brisnet
user-name and password. Session cookies have a shelf life of a few hours. So
after a few hours the cookie expires and you will have to log in all over
again. When you get a Session Expired message in Scratch BOT it just means that
there is no current session cookie present on your machine.
How
to start a new session and get a new session cookie:
1. Open a separate instance of Internet
Explorer (or use the built in browser found in Scratch Bot.)
2. Browse to the Bris
Site and visit their Supertote page.
3. Log into Supertote
using your Bris username and password. When you do
this the Bris page will put a new session cookie on
your machine.
4. Keep the current instance of
Internet Explorer open during live play and keep it pointed at the Bris Supertote page. That way you
will keep your session open.
So
long as you have a current session cookie on your machine Brisnet
will recognize you as authorized to browse live odds and scratches on their
site.
Note: If you do not have a current Brisnet account, consider contacting Brisnet.com and
signing up for an account there.
Note: Your Internet
Explorer security settings must be such that you allow Bris
to place the session cookie onto your machine upon login. Without a current
session cookie, Scratch BOT will not be able to browse web pages at the Brisnet site.
Parsing Scratches Links
Alternately,
you can also parse Scratches links for individual tracks loaded into JCapper
(using the Card Loader or Screen Two of the File Downloader) as a source for
scratches and changes info. Here are the steps:
Note: Clicking a scratches link does
not clear existing scratches.
The Tote Codes Table Mgr Button
Clicking
this button launches the Tote Codes Table Mgr screen.
The Tote
Codes Table Mgr screen allows you to create, edit,
and delete entries that enable Scratch BOT to parse Live Tote and Scratches
links.
The Tote
Codes Table Mgr screen also enables you to create,
edit, and delete entries that enable the JCapper WagerHistory
Module to import .csv files downloaded from the NHPlay
site.
Link to a
screenshot of the Tote Codes Table Mgr Screen showing
the proper entries for Delaware:
http://www.jcapper.com/messageboard/avatars/ToteCodesDEL.jpg
Bullet
point about the above screenshot:
• Track
Code Field: DEL (Why? Because DEL matches the first 3 characters of the data
file name.)
• Tote Code
Field: DEL (Why? Because DEL matches the first 3 characters of the data file
name.)
• Type
Field: 1 (Why? Because 1 matches the "type" attribute in the urls of the SuperTote site.)
• WinToteURL and ExaToteURL Fields:
After keying in Track Code, Tote Code, and Type Click the Assist Button to
auto-generate entries for WinToteURL and ExaToteURL. (Why? Because clicking the Assist button is
easier than keying the urls in manually.)
• NHPlayDescr Field: Delaware (Why? Because Delaware matches
the track name in .CSV WagerHistory files downloaded
from the NHPlay site.)
Scratch
BOT Video
In addition
to this help doc, a Scratch BOT video is available. To watch the video, visit
JCapper.com and click the link on the Nav Bar labeled
JCapper 101 Audio/Video. Then click
the Index item on the JCapper Podcasts page labeled Daily Reports. Then, look for and click Scratch Bot Video link to watch the video. If the server is too
slow when loading the video file, right click the link to the video and select
Save Target As. Save the .wmv file to your local
machine and watch it from there by double clicking the .wmv
file itself.
Note: What
you will pick up from watching the video that is (for some) difficult to pick
up from this Help Doc: The video shows me clicking and navigating inside of the
XML itself so that track names in the track_name
attribute of the xml become visible. If my description of how to do this within this Help Doc seems cloudy… Then watch the video!
Using Scratch BOT as a Web Browser -
the Plus “+” Button
Scratch Bot
contains an embedded Internet Explorer web browser. To have Scratch BOT display
web content currently being browsed, click the Plus “+” button. This will cause
Scratch Bot’s interface to expand. A viewing window will appear and web content
currently being browsed will display in that window. Clicking the Minus “-“ button causes the window to disappear and Scratch Bot’s
interface to return to its normal default state.
Note: In addition
to Scratch Bot, this same Plus “+” button, viewing window, and Minus “-“ button
interface can also be found in other JCapper modules such as the Live Play
Module and the File Download Tool found in JCapper’s
HDW File Manager.
Note: I
purposely did not include an address bar in Scratch Bot’s interface. I did this
for security reasons. Scratch Bot’s Plus “+” button, Viewing Window, and Minus
“-“ button interface was designed more along the lines of letting you see web
content the module is currently parsing than with the idea that you would want
to use Scratch BOT as a stand alone web browser. If
you are going to surf unknown pages across web, please use a web browser
intended for that purpose. When you browse web content using Scratch BOT you
are visiting known pages at known sites which minimizes (but does not
eliminate) your chances of picking up trojans,
viruses, or other pieces of malicious code.
Note: The
short list of sites that I am personally willing to use Scratch BOT as a stand alone app to surf would be: The Equibase
XML Feed, Brisnet SuperTote,
and the data download area at Handicappers Data Warehouse (HDW.) For example, I
am perfectly willing to use the Scratch BOT “+” button to navigate the Equibase XML or visit the Brisnet
site to start a new session so that I can get a Brisnet
session cookie placed on my local machine. I would not, however, want to use
Scratch BOT to browse other third party sites that I am unfamiliar with. I hope
that makes sense.
Troubleshooting
Note
about Clearing Scratches: If you ever notice that ALL
scratched horses still appear on your HTML Report, Text Report, or JCapper Past
Performances no matter how you picked the scratches up in the first place - the
FIRST thing you should try is Clearing Scratches. Follow that up with picking
up the scratches again followed by running a Calc
Races routine. In about 99.9 percent of all cases that will correct the
problem.
Note
about timing of WHEN scratches and changes data is made available:
Make sure to READ and UNDERSTAND the section above titled “It’s All in the Timing.” If you notice that Scratches and Changes
are being picked up from the XML for some tracks but not all –
The FIRST thing you should suspect is that scratches and changes for the
missing tracks are missing because the info has not yet been posted to the xml.
Your best course of action is to use Scratch BOT as a web browser and verify
this (visually) for yourself. Click the “+” Button and navigate through the
individual track nodes in the XML itself. Once you learn to do this, it will
become apparent at a glance whether or not individual tracks are either present
or are missing from the xml.
Note about changes of
track names in the XML: Please be aware that, for whatever
reason, individual tracks will sometimes request to have their track names
changed in the Equibase system. When that happens it is your job to change the track name in the Notes
Field of the TrackAbbreviations Table in order to
enable Scratch BOT to be able to process scratches and changes found in the XML
for that track. The first sign that a track name has changed in the xml will
likely be that you notice Scratch BOT is no longer processing changes for that
individual track.
If you notice that Scratches and
Changes are being picked up from the XML for some tracks but not all
– AND YOU HAVE VERIFIED THAT THE TRACKS IN QUESTION DO IN FACT HAVE CHANGES
LISTED IN THE XML (meaning you are certain the problem is not related to the
timing of when the changes are posted to the xml) - the FIRST thing you should
check is an exact match between the track_name
attribute in the XML vs. the track name persisted in the Notes Field of your TrackAbbreviations Table. In about 99.9 percent of all
cases that I have looked into, editing the Notes Field of the TrackAbbreviations Table to match the track_name
attribute of the XML will correct the problem.
Note about Cannot
Initialize Data Bindings Error Message: If you get this error
message when you click the Track Abbrev Table button, the FIRST thing you should
suspect is that the DLLs required to operate the Microsoft Data Grid Control
used by Scratch BOT (and other JCapper Modules) have not been (or are no
longer) properly registered. The solution to this problem is to use a program
called Regsvr32 to register the needed DLLs.
Here is a link to a JCapper Help Doc
illustrating the general procedure:
http://www.jcapper.com/regsvr32.html
Once you understand the general
procedure, this link will take you to a page where you can find information
about registering the specific DLLs used by the Microsoft Data Grid Control:
http://www.jcapper.com/TechServ_Bind.html