Callsheets are the absolute heart of the ServiceDesk system, and in particular of its Call Management system. These are the forms, arrayed four to a page, that constitute the primary screen in ServiceDesk. Each has facilities for recording all data that might possibly be relevant to incoming calls and service orders. Each has tools for managing those tasks as efficiently and easily as possible. And, besides their primary work of taking calls and forming the conduit for job-creation, Callsheets may also be used for inter-office communication, personal reminders, and so on. Think of them as little note pads (only in this case ones with great power), where you may instantly jot down anything that needs attention. And use them liberally, for there are an infinite number of Callsheets, all cheaper than paper.
Starting a new Callsheet is conceptually much the same as lifting one page from a note pad and starting on the next—except that, while with a note pad you might put unrelated notes on one page in order to conserve paper, in Callsheets there's no need. Start a new Callsheet as often as any new matter arises (such as a new incoming telephone call, for example).
To start using a new Callsheet, just move into the first one that's still unused (i.e., the first vacant one, which is always at the end of those already in-use). It's easy to move instantly to this position by pressing CtrlPgDn on your keyboard (this is the 'LastPage' command). Of course, if you're already on the Callsheet page that includes this first vacant form, you can also move to it simply by clicking on it with your mouse. Or, you might use any of several other methods that have been created for moving around within the set of in-use Callsheets.
Most simply and obviously, you can move from one page of four Callsheets to the next by pressing your keyboard's PgDn key (note that ServiceDesk will not permit you to move beyond a page that still has any unused Callsheets on it). Similarly, you can move back to a preceding page by pressing the PgUp key. And, as noted, to move from one Callsheet to another within a page, you can simply click with your mouse. This method, however, requires moving your hand from the keyboard, which is not always efficient, so naturally a better means is provided. To move to the next Callsheet following your present using the keyboard only, press Ctrl-Enter. To similarly move to the Callsheet preceding, press Ctrl-Backspace.
While these methods are adequate for just moving from one place to the next, they're not always fast. Suppose you've got many pages of in-use Callsheets; you need to move a distance across them, and you don't want to stop at every station along the way. You need some means of express navigation, in other words. ServiceDesk provides three kinds of tools here, and you've already been introduced to part of the first: the 'LastPage' command (which moves you instantly to the last page of in-use Callsheets), executed by pressing Ctrl-End. Its counterpart is the 'FirstPage' command, executed by pressing Ctrl-Home.
Less obvious are the 'FormActiveUp' and 'FormActiveDn' commands. Their purpose is to provide a rapid, search-type access to those Callsheets that are presently active to your own desk (meaning there are tasks you should currently be doing in their regard). There may be several intervening Callsheets that are either in hibernate mode or active to someone else's desk, and you don't want to spend time searching through those to find the tasks that await you. The solution is to press Alt-Backspace to find the next preceding form that's active to your desk, or Alt-Enter to find the next such succeeding Callsheet.
Finally, there is a 'Specified Target, Callsheet Search' feature, which allows you to search for the specific Callsheet that bears any text string you might want to find. There are two ways to execute this search, both of which use the Shift-F1 command. First, if you’re in a Callsheet that already contains the string of text that you’re interested in searching on, you can select that text, then press Shift-F1. The system will offer the selected text as your search target. You can hit Enter and proceed. If you’re not already in a Callsheet with text that you want to search on, hit Shift-F1 anyway, and the system will prompt for entry of your target text. In either case, ServiceDesk will search forward, looking for the first Callsheet that contains text (anywhere within it) that matches your search target. On finding match, it will display it for you. You can resume search (i.e., looking for other matches in earlier Callsheets) by hitting Shift-F1 again. Once it reaches the front of the file (i.e., first Callsheet, the system will rotate around and continue searching form the end, back to the point at which your search began.
On the right side of each Callsheet, you'll notice there are two sets of option buttons, one labeled 'ActiveDesk', the other 'Status'. These show which desk (i.e., which computer in your network) the Callsheet is presently assigned to, and whether the Callsheet's status is 'Current' (work needs done on it presently), 'Hibernate' (it's sleeping for a prescribed period), 'Delete' (this Callsheet is like a garbage piece of paper; you simply want to get rid of it), 'Job/Sale' (you've created a job/sale from this Callsheet), or 'Otherwise Done' (for some reason other than being used to create a ‘job/sale’, this Callsheet has similarly completed its purpose).
One detail you’ll notice is that the last three status categories (Delete', 'Job/Sale' and 'Otherwise Done') are framed somewhat separately within the list. The reason is simply to emphasize that it’s by being moved into one of these three categories that the Callsheet is considered “done” (and it’s only those that are in one of these categories that will be moved out of the current Callsheet workspace when, but not until, a CallsheetArchive routine is run). If the Callsheet remains in either ‘Current’ or ‘Hibernate’ status, by contrast, the supposition is that it’s not “done,” and it should (and will) not be moved out of the current Callsheet space, ever, so long as that remains the status.
Changing the selected option, when wanted, is done by left-clicking on the applicable button with your mouse, or by using the quick-key that is indicated for each of the possibilities. Indeed, you'll notice that the labels themselves indicate the key that, combined with Alt, will select them. Plus, you'll find that as you hold down your mouse button while clicking on any of these, their labels will change to indicate the full quick-key combination that could be used. Thus, if you wish to switch a Callsheet that is presently in any other Status back into 'Current' mode, press Alt-C. If you want to mark one for 'deLetion,' press Alt-L, or to mark one for 'othrws Done,' press Alt-D. The other two status modes, 'Hibernate' and 'Job/Sale' are similarly selected, but more events necessarily occur upon their selection than a mere change in the Callsheet's status, so these will be discussed separately.
In regard to changing a Callsheet's 'ActiveDesk' assignment, the quick-key is Alt-S (as in "Switch desks"), or again, you can always use your mouse. The situation in regard to the Callsheet's display of potential desks is a little complicated, since ServiceDesk must work in an environment involving anywhere from one to several stations, and there are positions available for only two different desk-assignment buttons on the Callsheet. Essentially, if there's only one station, the second button will not be displayed (because, obviously, there's only one possible desk assignment). If there are two stations, one button will be labeled for the first desk, and the second for its counterpart (with each displaying the actual StationName assigned to it). In this case, quite naturally, you're allowed to switch to either desk by simply clicking on its corresponding button, or you can toggle between the two with each press of Alt-S.
If there are three or more stations, it becomes more complicated, since there's not space on the Callsheet for an infinite number of buttons corresponding to every desk a larger user might include in their system. In this case, the first button is labeled 'My Own' (i.e., my own desk), while the second may be labeled either 'Another's' (if the Callsheet is assigned to your own desk) or with the particular name of the other desk to which it is assigned (assuming it is, in fact, assigned to someone else's desk). Now, if the Callsheet in question is assigned to your desk and you want to switch it, the task is initiated by selecting the 'Another's' option (either click on it or hit Alt-S). At this point, ServiceDesk will display a list showing each of the other desks to whom it might be transferred.
Make your selection, again using either cursor keys or mouse (in the case of only two other options, i.e., three stations total, a single stroke of the up or down cursor key is sufficient for selection); at this point, the Desk Assignment will instantly change to the station selected. Conversely, if the Callsheet is presently assigned to someone else's desk and you want to switch it back to yours, there's no need for the list. Just hit Alt-S or click on the 'My Own' option.
For most purposes, the Callsheet form in itself is quite complete. Right on its face, there are spaces for at least most the items of information that you’ll need to take from a customer during the course of a call. However, during the extended course of call-processing and order-taking, you will occasionally need to record additional items of information. This section concerns those needs.
First and most importantly, there is the Callsheet’s MoreInfo box. Access it by clicking on any Callsheet’s MoreInfo button, located in its lower-right corner (or press Alt-M on your keyboard).
As you’ll see upon loading it, the MoreInfo box contains two sections:
For example, suppose the Callsheet involves a simple message taken by the secretary indicating that so-and-so called to discuss a possible repair. You return the call, get an answering machine, and leave a message. You want to document having done so. Or, you’ve received a dispatch from an OEM or HomeWarranty client. All the order information goes into the Callsheet and the secretary calls the homeowner to schedule. She gets no answer, but wants document her effort. Or, a customer has called to complain about a technician’s performance. She’s going on and on describing details that you want to document. In any of these cases, the MoreNotes section is the ideal place to type-in the documenting info.
A suggestion here is to formulate a set of easy abbreviations that are understood by everyone in your office. You might use simple letters like "lmor", for example, to designate that you've ‘left a message on the recorder’, or "lmwc" for ‘left message with child’, or "na" for ‘no answer’, and so on. Thus, to document an attempt to connect with your customer, it becomes as simple as hitting Alt-M, then typing "lmor". Then simply hit Esc to exit from the form and save your entry.
You'll notice that a Callsheet's MoreInfo button is labeled "Empty" when the MoreInfo form contains no notes, and changes to "Yes" when notes have been added. Feel free to execute a Callsheet's MoreInfo button any time you wish to review or add more notes. You'll notice that, as a matter of course, ServiceDesk adds a new time and date stamp each time you enter the form—but don't worry, if you add no new notes after this inserted text (and do not edit existing notes), it will not be saved.
You’ll notice that the Callsheet contains spaces for four different telephone numbers. Typically, we expect that the first telephone number in each of the two sections (CustomerInfo and LocationInfo) will be used for home telephone number, and the second for a business number. At least, this is what we do by convention within our office (while, of course, you may do however you please). Anyway, even when following this convention there is occasionally need to append a tiny note to one or more of the telephone numbers. Even if, for example, we’re assuming that the right-hand number is for work, the question often remains whether (assuming it’s a “Mr. and Mrs. . . .” kind of customer) it’s the Mr.’s work that’s referenced, or the Mrs.’ (and it’s awkward, when calling the work number, if you don’t know which of the two to ask for). Also, there are times when you need to include an extension number. Other times you might want to indicate that it’s a cell number listed, and so on.
For any of these kinds of needs, there are spaces on the Callsheet, next to each telephone number box, where you can add up to four characters of text—associated with that telephone number. But “wait,” you say. You’ve looked, and can’t see any such spaces there. You are correct. The spaces are invisible. One of our objectives has been to keep the Callsheet looking relatively simple, even while adding enhanced capability from time to time. Thus, when we added these spaces we elected to not have them show. Nevertheless, they are there, and are completely usable. If you click on any such area with your mouse, the cursor will locate there and you can begin typing. Or, from within any of the standard telephone number boxes, you can hit Tab and the system will immediately move you into it’s adjoining Tel#Notation space.
A final method of dealing with supplemental information, in connection with a Callsheet, involves the UnitInfo system. This is a matter that’s primarily discussed elsewhere (see page 189), for its application is much broader than a mere connection with Callsheets. In a nutshell, however, it’s a system that allows you to create a specific record describing model number, serial number and similar kinds of information for a particular machine. This record may, in turn, be attached to either Callsheets, JobRecords or both. If, from a Callsheet, you have the need for such specific information in regard to a particular machine, this is another tool you should use.
There are a plethora of tools designed to help you fill-in a Callsheet with minimum effort, maximum ease and incredible speed. In other sections (by way of example), we’ll discuss how to insert a street name, grid reference, city name and zip code based on but a few keystrokes. We’ll discuss how to insert the full name,-address-and-telephone-number set based on info from an existing customer’s past job. And we’ll discuss how to insert the Item-Type and Item-Make from a little drop-down list. In this section (by way of contrast), we’ll discuss a selection of methods that are designed either to fill-in a Callsheet in its entirety, or at the least to insert a big block of previously prepared text. In fact, that last will be our first topic here.
If you’re like most servicers, you probably have a few clients for whom you do an extraordinary number of jobs. Perhaps you do work for home-warranty type or extended warranty companies, for example, or maybe it’s a major manufacturer for whom you do new warranty work. Maybe it’s a property management company that calls you, with some frequency, or any of several other possibilities.
Regardless of the particularities, in any situation such as this you’re essentially going to be billing a third-party for work done at some location. Each time you write an order for this kind of third-party work, you’ll want to put the paying-party’s name, address and telephone number set in the “Customer Info” section of a Callsheet (i.e., in its top name and address section). You’ll then want to put the homeowner (or tenant’s) info in its “Location Info” section (i.e., the bottom section as provided for name and address). Please notice, if this is a paying party you’re working for over and over again, it would be nice to be able to insert their full information set with minimal effort. That’s where Quick-Entry Templates come in.
To create Quick-Entry templates, use what’s called the QuickEntries form. It’s accessed by pressing Alt-Q from any Callsheet, or via selection from the main menu.
One important note in regard to formatting here. For any companies that use P.O. numbers as part of their service request (i.e., all home-warranty type companies), you should include space and labeling for that number as you setup the company's QuickEntry template. And, please note this setup must be in a particular location. Specifically, it must be in the top line of the form (i.e., the CustomerName line) toward the far right. The reason is because, during subsequent processing of the job, ServiceDesk will examine this particular line of text in search of a possible P.O.-type number. As the primary key of interpretation in this regard, it will look specifically for a pound sign (i.e., '#'). If it finds one, it will automatically interpret anything that follows as an actual P.O. (or equivalent purpose)-type Number.
Thus, if you’re setting up QuickEntry text for American Home Shield, as an example, you’d want to have their actual name on the left side of the form’s first line. Near the end of that same line, you’ll want to put a label for where the unique P.O. number will be typed after insertion of this text to a Callsheet. Basically, you’ll want to leave enough space after that pound sign for the particular quantity of characters the company uses in its P.O. numbers. In consequence, the first line of your AHS QuickEntry template (or that for any similar client) should look something like this:
AMERICAN HOME SHIELD I.D. #
You might notice that in this illustration we’ve used the text “I.D. #” (rather than “P.O. #”) to label the space we’re setting aside for the client’s job-identifying number. This is simply to illustrate that the particular terminology does not matter (and besides, this happens to be the terminology AHS has most recently adopted for their own use). It’s the pound sign—and its location as the last character before the blank area that’s left for the actual number—that’s critical. The rest is purely optional.
In addition to providing space and labeling for the client’s job-identifying number, you may also want to consider if the client requires you to include an indication of the homeowner’s contract number. If so, you’ll need to provide space and labeling for that as well. Basically, the same strategy is involved, except in this instance ServiceDesk will later look for such text in the LocationName line. In other words, whenever there is a need for ServiceDesk to pull and differentiate an indicated ContractNumber (as distinguished from other text), it will look (much as in the case of seeking a P.O.-type number) for a pound sign followed by some text. In this case it will simply be looking at a different line (the LocationName line), and interpreting text after a pound sign there as a ContractNumber. In consequence, your LocationName line of a client’s QuickEntry template might look something like this:
Note that again we’ve put in what is essentially our own labeling for a field and allowed space after for later insertion of a number. In this case, the left-hand portion of the line is left blank, for that’s where (after the QuickEntry text is inserted to a Callsheet) we’ll be typing in the homeowner’s name.
Of course, many clients do not require that servicers regurgitate a homeowner’s contract number, but do require collection of some deductible amount, which is a matter that for practical purposes is nice to have on each invoice. Thus, providing an indication (or space to insert) this information is another handy thing to place within a client’s QuickEntry template. As it happens, we’ve found that clients requiring contract numbers typically do not require deductibles, and vice versa. Therefore, we’ve found it handy to place a deductible reference in the same place instead of a contract number, if the template is for a client that requires the one but not the other. If this client’s deductible is always the same (or perhaps if it is even almost always the same), the reference can simply be placed there in its entirety, to be inserted to a Callsheet identically every time, as follows:
If the deductible varied from job to job, on the other hand, you might want to prepare the template with labeling text that would prompt your operator (and provide the appropriate space) to insert the deductible amount, while leaving the actual number area blank (such as in the following):
At any rate, you can see that in general the way you use the system is up to you. Just remember the one technical matter: that the system allows you to essentially create extra fields (in any Callsheet to which this text will later be inserted), one for a client’s job-identifying number, another for a contract number. This is done by using a pound sign (i.e., “#”) toward the right end of either the CustomerName or LocationName boxes. Whatever text is ultimately typed following such a pound sign in the CustomerName line (after the template-text is inserted to a Callsheet) will be interpreted by ServiceDesk as the client’s P.O. number. Whatever follows a pound sign in the LocationName line (again, after the template-text is inserted to a Callsheet) will be interpreted as a Contract Number.
For a full illustration of a completed QuickEntry template, please glance at the following:
The textual area here is filled in just as needed for insertion to our Callsheets when we’re creating a ticket for American Home Shield. We’ve allowed just the right amount of space for their 8-digit job I.D. #s (in the space that you’ll see at the end of the CustomerName line). Since they don’t require that we provide homeowners’ contract numbers, we’ve used the space where we might have setup for that to instead list the normal deductible amount. In addition, we’ve use a place where there was a little extra space (at the end of the CustomerCity line) to place in a little text reminding the technician of what our authorization limit is with this company. All of this provides a pretty perfect setup for what we want to have inserted to each Callsheet on which we write an order for this company. Of course, we’ve only discussed what’s placed in about the top three-fifths of this form (where you see boxes echoing equivalent spaces in a Callsheet). At a glance, you can see the form obviously has spaces to fill-in a lot more information. We’ll now turn to discussing those.
First of all, please notice the box in the center of the form, the little one with a lot of labeling around it (labeling which begins with the words “HighVolumeClient Abbreviation”). That labeling says enough, perhaps, to make any re-explanation here somewhat redundant, but even so, we probably should expand a bit. The box is for your insertion of what we call the "HVC Abbreviation." The purpose of this abbreviation is to provide a small handle by which any such frequent client can be known within ServiceDesk. It is useful in many contexts to have such a small handle, and useful as well for ServiceDesk to be able to distinguish this kind of a client (based solely on the on the fact that you’ve provided such an abbreviation) from others.
In the DispatchMap, for example, it makes sense to have a standard abbreviation for each of your very frequent customers, so that an American Home Shield job to the Smith residence, for example, can be rendered as "AHS-Smith," rather than as "Ameri-Smith". Similarly, it is better for completed sales to be rendered in such fashion. And it’s important for ServiceDesk to discriminate in contexts such as making a standard DunningList (where presumably you will not want to include this type of customer), or in compiling your CstmrDbaseIndex (where you don't need thousands of entries under the specific name of a single OEM, Home-Warranty, property-manager or similar type of client), or when it conducts it's automatic search to verify, when you're creating a job, that you've not inadvertently overlooked a pending Callsheet order (see page 73). Your own part in creating this distinction is simple. In regard to any customer you want ServiceDesk to recognize in this set-apart manner, simply include a two or three-character abbreviation as part of that client’s QuickEntry Template, in the space provided here. It’s that simple.
Immediately below the center area as provided for designating the client’s HVC abbreviation, you’ll see a couple of items that can be checked off or not. They’re pretty self-explanatory. Check as appropriate.
Moving on down in the form, you’ll see places for inserting information as applicable to a client for whom you do warranty service (such as your Servicer ID #, default labor amounts, and so on). These are used by ServiceDesk when later filling in a NARDA for you. Basically, when filling-in a NARDA ServiceDesk will look at the CustomerName as it exists in the underlying JobRecord, compare that text to that which exists in the equivalent field of each QuickEntry template, and when it finds a match figure to itself: “Aha, I can take the Servicer ID # from this Template (along with other appropriate items), and fill them items into appropriate places in the NARDA.”
Finally, there’s one more little box in this form we should explain. It’s in the bottom-right corner and is labeled “Type Designation (if applicable)”. The purpose here is connected to automated dispatch (whether via the emailed-dispatch-insertion system or when using the WebBasedDispatchEnabler in conjunction with ServiceBench). Basically, if an automated system needs to insert a service order from one of your highvolume clients to a Callsheet, it makes sense that it should first insert the particular QuickEntry Template that you’ve setup for that client. But how is the system to know which of the templates you’ve made is for, say, Whirlpool Warranty, and which is for Frigidaire Contract Service, and so on? The solution is in that little bottom-right box. That’s where you tell ServiceDesk, when you’ve made a template that is in fact for Whirlpool Warranty, that that’s the template it is. Then, when the WebBasedDispatchEnabler is doing inserting such a service request to a Callsheet, it knows that’s the template to insert first.
After you have completed and saved the template for any given client and exited the Edit form (click on its ‘Okay’ button), you should now see it as one of the items in the QuickEntries list. Notice that for the first 10 items in your list, there are single-digit numbers arrayed along the left side. This is to indicate that, in regard to these particular items in the list, there is a QuickKey method of insertion that does not depend on loading the QuickEntries form. Basically, from any Callsheet you can simply press the Alt button on your keyboard, combined with the number indicated for that entry. Thus, if American Home Shield template were the first in my company’s own QuickEntries list (in fact, it is), I could insert the AHS QuickEntry text from any Callsheet simply by pressing Alt-1 (or Alt-2 for the next template in the list, and so on).
Alternatively, if I can’t remember the particular number to use for a given client in conjunction with this Alt-N method, or if I’m wanting to insert for a client beyond the first ten (meaning they’re beyond the range for which the Alt-N method is available), I can simply bring up the QuickEntries form (press Alt-Q) and make my Page 62 selection from there (either double-click on the item, or select it then press the indicated ‘Insert Entry’ command button).
Naturally, any time you wish to change a client’s QuickEntry template, that easy to do also. It’s all selfexplanatory from the form.
One final tip: Immediately after you’ve inserted QuickEntry text into a Callsheet (i.e., you’re typing in an order as connected to a HighVolumeClient), you’ll find your cursor is left at the beginning of the CustomerName line. If it’s the type of order that requires a P.O. Number, hit the ‘End’ button on your keyboard. This will take your cursor to the space just after the pound sign, where in your template you’ve made space for that number. Thus, just after hitting that ‘End’ button you can begin typing the number. Similarly, if you’ve made space at the end of the LocationName line for a Contract number, you can tab down to that box and again hit the ‘End’ button to position your cursor in the proper place to begin typing that. Once it’s typed, hit the ‘Home’ button to more the cursor back to the front of the line, where you can begin typing the homeowner’s name (note that if you did this last in the reverse order, i.e., typing the name first, you’d upset the space as provided for the contract number).
While we don’t want to give the impression ServiceDesk is designed particularly for servicers who do work for American Home Shield, receive dispatches through ServiceBench, or otherwise process dispatches as received from large, institutional vendors (it’s not), it’s nevertheless true that a good many servicers do such work. To assist these, we’ve created some very specific systems.
In particular, we’ve created some extremely advanced systems as encompassed in our Web- and Email-BasedDispatchEnabler utilities (see page 103), but these are separate programs, optionally available for an added price. Prior to creating these, we’d already created somewhat less advanced, less fully automated systems that are fully integral to ServiceDesk itself. If you don’t want to purchase the more advanced utilities, you might still want to use these somewhat less advanced tools.
In regard specifically to processing dispatches as received via email from AHS or other companies, it may have occurred to you that, within each such email, you already possess—in electronic text format— virtually all the information that needs to go into a Callsheet. What a pity it would be to already have this information in such form, and yet nevertheless need to manually re-type it into appropriate spaces of a Callsheet. We’d not want you to be forced into this, and so created a system by which you can easily take that text, from an emailed dispatch, and instantly insert each element into appropriate boxes of a Callsheet.
The first step in using this system is to copy the applicable email text into your Windows clipboard. As explained elsewhere, the Windows clipboard is simply an unseen space that can temporarily hold any item of text, graphic, or whatever that you want to place into it. You can copy things into there, then ‘paste’ or ‘insert’ them back out into other locations. It’s very handy.
To copy an applicable email dispatch into the Windows clipboard, just go the applicable email and press Ctrl-A on your keyboard. This is the windows command to ‘select All’, and will cause the entire email contents to be highlighted. Now press Ctrl-C. This is the Windows ‘Copy’ command, and will copy the text that you just selected into the Windows clipboard.
Now that you’ve got the email dispatch text in your Windows clipboard, the next step is to go to a fresh Callsheet, and from there simply press Alt-I. This is the ServiceDesk command to ‘Insert email contents’ In result of the action, ServiceDesk will essentially read through the text that it finds in the Windows clipboard, looking for key words that tell it where to expect the particular text that should be inserted into various boxes of your Callsheet. Within an instant, it should find each such item of text, and insert them into appropriate boxes of the Callsheet for you.
Of course, since ServiceDesk doesn’t have true intelligence, there may be a few items of doctoring to do with the inserted text in your Callsheet. ServiceDesk doesn’t know how to distinguish a first from last name when there’s no comma, for example, so you may need to determine which of the names provided is a last name (AHS dispatches are typically in standard first-name(s)-then last format), and put that name at the front of the line with a comma following (again, use standard Windows cut and paste techniques to make this easier). And, you may need to backspace from the end of the address-line to bring up your ServiceDesk StreetList and do an insertion with grid reference, and so on (really, the needs should be obvious).
As mentioned, we now have a more advanced system that completely automates things (see page 103), but if you don’t want to get it, the above can be an excellent solution.
Much as there’s an older system designed to work with emailed dispatches, there’s also an older, totally-within-ServiceDesk system designed to work with dispatches as received through ServiceBench (for those particular servicers that do such work).
If you are such a servicer, you may know you can go to their website and download a file that contains your pending dispatch information. Obviously, you could read the information out of this file, and manually type each new job-item into a Callsheet, thus initiating each job as received. However, that would be a little work. Since the info is already in digital form, it makes much more sense to let ServiceDesk do the work.
For this purpose, all you must do from within ServiceDesk (after you’ve downloaded the dispatch file from ServiceBench) is, from within a Callsheet, press Cntrl-Shift/I on your keyboard. The system will then prompt you to identify the dispatch file in question, and once done will instantly pull each job-item from it, inserting all the relevant data into correct places of Callsheets (then, of course, it’s up to you to process further).
Again, we’ve now created separate utilities that completely automate these processes see page 103), but if you want to take advantage of just what’s available within ServiceDesk itself, the above should do nicely.
We’ve found that most service companies don’t, in fact, use a live answering service, but there are many advantages in doing so. Among these is the little known fact that you can arrange with such services to handle calls in a manner such that most callers will never realize they’re speaking with an answering service (assuming instead that they’re talking with office personnel). And, working in that fashion, you can in fact have an answering service take service orders for you, even scheduling the calls. In this manner, you can avoid losing many potential jobs—that would otherwise go to a competitor who gives the caller the satisfaction of speaking immediately with a human, and getting an actual appointment scheduled.
At any rate, if you use (or should decide to use) a live answering service, one of the associated tasks is getting your messages (including those regarding service orders taken) from them. ServiceDesk provides a means for this to all be done electronically, with each message/service order inserting itself for you into appropriate spaces on a Callsheet. It makes the process very convenient. The process of setting up for this is described in the Appendix, beginning at page 278.
As you begin typing in a street address (regardless of whether in the Customer- or Location-Info section of a Callsheet), ServiceDesk is watching. It’s waiting for you to finish typing the number portion of the address, and begin typing the street name (technically, it figures you’re on the street name when you’ve finished typing the first "word" of text, as in the "123-A" portion of "123-A WALNUT LN", add a space, then continue typing). As you do so, ServiceDesk watches with each keystroke to see if there are matching entries in your StreetList. As it finds any, it will immediately display them in a drop-down list. As the user, you should continue typing as many characters as are needed for the street name you are seeking to appear, then select that item for entry.
Actually, there are three ways of indicating your street selection, and you should use whichever is easiest. First, you may left-click with your mouse on the desired street. Second, you may use your keyboard cursor controls to move into the list and onto the desired street, then hit Enter for your selection. Finally, if you've typed enough characters to make the desired street come to the top in the list, simply hit Enter: ServiceDesk will assume you want the top item and insert it for you.
Aside from these alternatives for selecting a street, there are also options for specifying the type of insertion you prefer. Most obviously (and as the default method upon selection), ServiceDesk will insert simply the street name, its map grid reference, and the city name into appropriate spaces of your Callsheet. This format is obviously appropriate if it's simply a service location you're typing in, and you do not anticipate any subsequent need to mail a bill or other items.
Of course in many instances it will be a third-party payer's address that's being typed, in which case there's no need for a map grid reference, yet you do need full state and zip info for subsequently mailing of the bill. To designate this type of entry, use the right mouse button instead of the left when clicking to designate the street, or if using keyboard method make it a shift-Enter rather than Enter alone.
You might notice that, while your customized StreetList includes only abbreviations to each city, it will be the full name that ServiceDesk inserts for you. This conversion is based on a list of ‘CityNames and Abbreviations’ that we created specifically for your area. A copy of this list is provided in the Appendix (page 323). You may find it useful in deciphering the abbreviations.
In a perfect world, this would be all the discussion that’s needed regarding use of the StreetList. However, on occasion you’re likely to find that some things, at least, are imperfect. You may not find the street you are seeking, for example. Or you may find the city name that’s assigned is erroneous. To deal with such issues, and to understand in greater depth some of the underlying mechanics, please (as need arises) consult the technical discussion that begins in the Appendix on page 287.
When you have a caller on the phone and are scheduling an appointment, you'll want to know where they’re located, especially as compared to other jobs in your lineup. Just right-click on the address line. Your DispatchMap will immediately display and show the location, flagged in red. Hit Esc to return back to your Callsheet. (The same feature may be used from the JobsCurrent form, from whence you may be scheduling a return call after having ordered parts in.)
When you want to dial a number that is listed in any of a Callsheet's four TelephoneNumber boxes, just right-click on the number. You'll quickly see a form displaying the number, and should hear your modem go off-hook and sound the appropriate dialing tones. After your modem has dialed, go ahead and pickup your telephone's handset (or press your telephone's speaker button) on the appropriate telephone line. Now that your telephone is connected, press any key on your computer for ServiceDesk to hang-up, leaving you ready to conduct an unimpeded conversation.
This same feature may be used from the context of your DispatchMap (simply right-click on a job's list representation). Also, much as in a Callsheet, it may be used from any Archived Callsheet context, or from the JobsCurrent form. The DispatchMap application is particularly useful if you're attempting to locate a technician at some job site that's listed on his present schedule.
You may note that when this feature is used in conjunction with the CstmrDbase search (see page 209), you end up with a kind of built-in telephone directory. Suppose, for example, you did a job for an "Andrea Ward" at some time in the past, and you presently want to dial her. Just hit F12 to bring up your CstmrDbase search feature (see page 67), then type in "WARD, A . . .“ At this point, you'll see a list pop up showing all jobs performed for her. Click on the most recent, and note her telephone number(s) displayed in the appropriate locations on the JobsArchived form. Just right-click in the appropriate location and, almost instantly, you're connected—all with just a few keystrokes.
There's still another use of the AutoDialer which may seem kind of silly at first, but is potentially handy when you need it. Do you ever want to dial one of those alpha-stated numbers (like "1-800-1-CALL US")? It's quite annoying to search for each letter on your telephone's key pad. We personally got fed up with this annoyance, and so created a solution. If you left-click on the label section corresponding with either the Customer-Info or Location-Into section of any Callsheet, the auto-dialer will load with no number in it. At this point, you can simply type in the number wanted, but using letters if preferred. The AutoDialer will automatically translate letters into corresponding numbers, and dial for you. It's a tiny problem, but a convenience you might occasionally enjoy nonetheless.
ServiceDesk will look for your modem, by the way, at whatever CommPort is specified (by you) from the Settings form. On most installations, this will be CommPort 2.
One of your options in the 'local' portion of the Settings form is whether you want the AutoCstmrDbase-Search feature enabled or not. When this feature is on, ServiceDesk will conduct a search of the CstmrDbase Index, in each of eight different Callsheet fields, as you are typing-in characters. These are the Customer and Location Name fields, the Customer and Location Address fields, and the home and business Telephone fields in both Customer and Location sections. For obvious reasons, ServiceDesk will not begin the search until enough characters have been typed to make it meaningful.
When ServiceDesk finds a match or matches between your entered text and items in the CstmrDbase, it will expand the Callsheet and display a list referencing each match. This will go on as you continue typing-in your entry, and on any reasonably-powerful computer (300 megahertz or above) ServiceDesk can easily maintain your pace, instantly updating the list with each of your subsequent keystrokes.
The CstmrDbase is based, simply, on the entire history of all jobs written and managed through ServiceDesk. More specifically, it includes the already-indexed portions of the JobsCurrent file and all of the JobsArchived file. By using an index set that refers to both files, the system is able to conduct complete searches in the tiniest fraction of a second, even after accumulating a history consisting or many tens of thousands of jobs.
Since references in the list may refer to either current or past jobs, there is a distinction in the manner each item is displayed, to let you know which category of job it references. Basically, if items are from the JobsCurrent file, their list references will be shown with a row of four asterisks before and after the customer's address. If from the JobsArchived file, the references will not include such asterisks. Thus, you can distinguish in an instant between references to jobs still pending and those from the past.
If you see an item in the displayed list that you'd like to view more fully (the list itself includes only name, address segment, and telephone number), you may either left-click on it with your mouse, or press F1. At this point ServiceDesk will display a shortened version of the JobsArchived form, with the referenced item loaded into it (if you used F1, it shows the first item in the list). Thus you can instantly see all pertinent details regarding the selected job, regardless of whether it's current or one that was completed years ago. In many cases, you'll want to look at more such items as you talk with a customer on the line. It's easy. Once a single list item is referenced and displayed, use your cursor keys to move up or down in the list and display adjoining items. Thus you can view all the jobs in a particular customer's history, in seconds.
In many cases, rather than wanting to review past history, you'll be more interested in using that past name, address and telephone number simply to fill-in your present Callsheet, and without having to type or ask your old customer for such info again. In this case, you may either right-click on an item in the list, or again press F1 to move into the list, then cursor down to the item and press Enter. With either action, ServiceDesk will insert into your Callsheet the same full name, address and telephone number set that were used on the previous job. You may also simply press Enter after you've selected a job for display, and ServiceDesk will similarly insert its customer data-set into your Callsheet. Alternatively, if you wish only to enter the name and telephone numbers from the CstmrDbase item (i.e., you just need the name and telephone number to remind you to check on something then return the person's call, or something similar), you may modify any of the above actions by holding down the Shift key. This will cause an insertion with address and city omitted. Also, you can do an insertion of the previous info set in “Recall” format by doing Ctrl-Right/Click.
In any event, each of these insertion methods provide a virtually instant means by which you can use a former name, address and telephone set and get them instantly into a new Callsheet—with something so close to zero effort as is almost magical (to help you remember all the various commands available in a Callsheet, there’s an instantly accessible command summary; see page 76). Plus, you should be aware the system is doing even other things for you at such time, behind the scenes. For example, as you insert a customer’s info set, the system simultaneously checks in your Accounts Receivable file to see if any amounts are outstanding from the same customer. If so, it brings it to the operator’s attention, and offers to place a note on the invoice advising the technician to collect as he makes the visit.
While it does not require any appreciable time for ServiceDesk to conduct its search of the CstmrDbase, substantial resources are needed for your display system to expand and contract while accommodating a list that must appear or disappear in rapid response to your keystrokes (depending on whether matching entries are found with each new resulting strike). If your system is not particularly powerful and you type quickly, there may be enough delay to be annoying. If so, you may want go to the Settings form (use the 'File' section of the main menu or press Ctrl-F1) and disable the Auto-CstmrDbase-Search feature.
Whether your auto-CstmrDbsSearch feature is turned on or off, incidentally, you can still conduct the same searches, any time you want, and on the same fields. Simply press F1 while your cursor is located anywhere in such a field on a Callsheet. Indeed, within our office (even though we always have the autosearch feature on), we find this last trick eminently useful. The reason is because it may occur to you after the data has been typed in (and the then-displayed list is now gone) that you want to again conduct a search on one of the fields. You could at such point use the F12-based search feature (see following paragraph), but that would require re-typing some of the same target text that, in this instance, already exists in your Callsheet. Or you might backspace into some of that already-existing target on your Callsheet, and by such action reinvoke an auto-search (assuming such feature is turned on), but then you’d have to re-fix whatever editing you did. In fact, it’s far easier, whenever you already have suitable target text in any of a Callsheet’s search-able fields (and especially if your cursor is already in that same box), to just hit F1. That invokes the same search as though you were typing in the field, but without actually doing so.
All this discussion, incidentally, is directed toward using the CstmrDbase from within a Callsheet (since using Callsheets is the larger topic of this chapter). You should know, however, that if you are not otherwise typing a customer's info into a Callsheet (or don't already have it there), there's a much easier way to conduct a search than by this method. Simply press F12 to bring up the TechInterface form (as discussed more fully at page 209). From this context, it will automatically load itself in a format that's immediately ready to conduct a CstmrDbase search for you. Your task is simply to begin typing characters from the name, address or telephone number that would be found in the record you're looking for. Immediately, you'll see a list popping into view (similar to that which is produced from within a Callsheet) that shows all matches. When you see an entry you're interested in (again as if in a Callsheet), just click on it for full display (or again you may simply press F1 to move into the list, then use the cursor keys to move up and down within the records offered). Experienced users will typically find themselves using this feature many times each day
As you may have noticed, Callsheets not only store information, they also serve as a kind of "to do" note, like slips of paper you've placed on your desk to remind of particular things needing done (or like a faxed dispatch that sits on your desk reminding that a customer needs called for scheduling). As you may also have noticed, ServiceDesk helps you know when a Callsheet needs work done by following a simple convention. When work does need done, and needs done by you (i.e., the Callsheet's in 'Current' status and assigned to your desk), ServiceDesk keeps it illuminated at your desk. When work does not presently need done, on the other hand (i.e., the Callsheet's in any other mode), ServiceDesk keeps the Callsheet dim. Thus, when you create a job from a Callsheet (meaning its particular duty is done), or transfer responsibility on it to another desk, the Callsheet naturally goes dim, telling you at a glance that you presently have no work to do on it. It's much as if that piece of paper on your desk is taken away: you don't have to see it there anymore, nor feel nervous about whether there's any work for you to do in its connection.
This is great for those items that you can, in such manner, actually dispose of, but obviously, there are many items that you might have dealt with only in terms of immediate need, even while knowing the matter needs to be re-visited in an hour, a day, or whatever. Or maybe it's something you haven't taken care of at all, but it doesn't require tending to right away, and you intend to put it off as long as you gracefully can. In either case, you don't want an annoying piece of paper sitting on the desk bugging you during hours or days when you simply don't intend to address it. Nor do you want to lose track of the fact that, ultimately, you must.
The solution, when that piece of paper is a Callsheet, is to simply put it to sleep for whatever period of time you intend to ignore it. This is what we call Callsheet Hibernation, and essentially, it involves making a Callsheet go dim (so that you can in a sense sleep in its regard) for a specified period of time. To put any Callsheet to sleep, either click on its hibernate button or press Alt-H. This will bring up the Hibernate form, from which you can easily select the period of rest. Note that, as in most other forms which offer a single set of options, here you can either click on your selection with the mouse or move over it using your cursor keys, then press Enter for your selection. You can also specify a wake-up time that is not provided in the direct options, by simply typing it in.
You may notice that each of the sleep-period options have an accompanying "alarm period." This relates to still another feature that helps you know which Callsheets need attention, or, more specifically, which ones are past-due for attention. This feature is what we call the "Overdue Alarm." Basically, there's a built-in sentry in ServiceDesk that's continually monitoring all active Callsheets (i.e., ones in 'Current' status) to see that adequate attention is paid to them. If any go past some specified time without activity, ServiceDesk will begin beeping, and showing a notice in the title bar at top, to alert you to the neglect.
It is, essentially, this specified time period that's being described by the Hibernate form's indicated 'alarm periods.' Essentially, ServiceDesk will allow the 'alarm period' stated, after the sleep period ends and a Callsheet "wakes up," before sounding an alarm that the Callsheet is overdue for attention (assuming no attention has been paid to it during that period). Logically, there are longer alarm periods following longer sleep periods, and vice versa.
Of course, the alarm period that follows a Callsheet's awakening from hibernation is only one attribute of the Callsheet Sentry. For Callsheets in general (i.e., one's not subject to a specific post-awakening alarm period), the period is two hours. If, therefore, any Callsheet that's not in a specific post-awakening alarm period does not receive attention (i.e., work being done on it) over a space of two hours, ServiceDesk will begin sounding the alarm in its connection.
Of course, the beeping of an alarm can be annoying, and you may not have time immediately to satisfy its call. If this happens, you can silence the alarm by pressing Ctrl/Shift-LeftCursor (this combination is used because the keys are next to each other and are easy to press). Each press gives you one minute of silence. If you wish, you can hold the keys down and allow the Windows auto-repeat feature to run up several minutes of reprieve-time. By holding down for three or four seconds, you'll get an hour or more of silence (depending on the repeat rate you've set from Windows). Alternatively, if you do not like this alarm feature, you can turn it off entirely from within the Settings form.
Eventually, of course (and regardless), you should heed the alarm and do something to service your anxious Callsheets. ServiceDesk is easy in this regard. If you make any saved change in a Callsheet, ServiceDesk figures you must have done your duty for now, and lets the matter rest for another two hours. After that, if there have been no saved changes in the interim (and you didn't put the Callsheet to sleep for longer, or in any manner put it to final rest by creating a job from it, or something similar) it will inform you, by beeping again, to indicate that the item is again past due for attention.
It may be useful to know, at this point (and as explained in more detail later), that ServiceDesk saves your Callsheet edits, when there have been any, immediately upon any action that moves the control focus to another form. Thus, if you've just changed one or more characters in any of a Callsheet's text boxes, and you hit F5 to display the DispatchMap (or take an action to display any other form, even moving to another Callsheet), ServiceDesk will immediately save your Callsheet in the form it was left. ServiceDesk also does immediate saves when you change a Callsheet's status or desk assignment. Thus, it will immediately save if you transfer its assignment to another desk, or if you change its status from 'Current' to 'Otherwise Done,' or anything similar.
Regardless of how done, it follows that you can satisfy what might be called the Callsheet Sentry by invoking any Callsheet save. In fact, you can even cheat if wanted. Suppose, for example, that at the present moment you have some Callsheet that's beeping you. You don't want to give it any serious service, right now, and yet don't want to put it back to sleep either. Simply make it your active Callsheet, then hit Esc. This will invoke an immediate save, and ServiceDesk will be fooled (for another two hours, at least) into thinking you've paid it some attention.
There are two contexts in which you may be making appointments with your customers. First, is when you’re originally scheduling the job, generally at the same time your customer first places his or her order. Second, is any subsequent scheduling, such as if the first appointment was canceled and a new one is needed, for example, of if the technician found on the first visit that he needed to order a part, and therefore rescheduling was required after the part arrived, etc. It’s important to conceptually distinguish between these contexts, for just as the actual contexts are different, the mode of scheduling from within ServiceDesk also varies, depending on which context is involved.
Specifically, and for the first context, if you’re making a first-for-the-job appointment with your customer, it follows you’re probably still at the point where you’re typing job-initiating information into the Callsheet. Thus, there is as yet no JobRecord for the job. To this point, it’s represented only by the Callsheet upon which you are typing various kinds of information. Obviously, the first appointment is one such item, so naturally there’s a place in the Callsheet for you to enter a short notation describing it. Logically, it’s the box labeled ‘Date and Time’. Of course, the simple fact of entering an appointment within this box does not, in and of itself, create an entry into your ServiceDesk ScheduleList (this is a separate file where ServiceDesk keeps track of each appointment). For that to occur, you must create a job from the Callsheet (see next section). As part of the process when you do so, ServiceDesk will read the notation in the Callsheet’s ‘Date and Time’ box, and create a corresponding entry in the ScheduleList for you.
The second context (this one for making subsequent appointments) occurs downstream, as it were, perhaps some number of days after you’ve gone through the process just described in regard to creating the job and its initial appointment from a Callsheet. At subsequent points, obviously, the originating Callsheet has long since done its job, and so has been retired to the Callsheet Archive; thus, it is no longer a candidate tool for the process. Instead, at this point scheduling is done from the job’s JobRecord, using the JobsCurrent form (or, though it’s comparatively clumsy, you can do it by making entries directly from the ScheduleList form itself). Regardless, this chapter is about Callsheets, so at this point we’ll not further discuss how scheduling is done for appointments after the job’s been created (see discussion beginning at page 108 for such information).
Instead, at this point we’ll simply describe a few details regarding entry of an appointment notation in the ‘Date and Time’ box of your Callsheet.
The first thing you’ll notice, as you enter the ‘Date and Time’ box, is that a little calendar pops up above it (we call this the ‘DatePicker’). You can use either your cursor keys (then hit Enter) or click with your mouse to select the day of the appointment. Upon doing so, you’ll see that the system enters a notation in the ‘Date and Time’ box regarding the day in question, then immediately another box pops up, offering a selection of time-frames (or appointment windows) you may select from. Again, you may either click with your mouse or use the cursor keys and hit Enter to make your selection. Alternatively (especially if none of the offered timeframes fit your immediate need), you may simply type-in the time or time-frame for which you are scheduling the customer. Regardless, you’ll see the process is eminently easy.
Of course, there’s “easy” and “easier.” In most cases of scheduling, you will have used the Callsheet’s ItemLocate feature (see page 44) to view the job’s location from your DispatchMap. It’s likely while there, moreover (viewing various dynamics in your existing schedule) that you will have agreed with your customer on a suitable day and time for the appointment. Since that is the context where you’re deciding, why not indicate your intent then and there—and allow ServiceDesk to enter an appropriate notation in the Callsheet for you? In fact, this is almost too easy. When in the DispatchMap having arrived via an ItemLocate request, and when viewing the day for which you want to schedule the person, simply left-click on the item’s graphic reference, as flagged in red. In response, you’ll immediately see a combination entry/list box. You may either select a time-frame as offered in the list or type-in a different time or time-frame as wanted. The system will assume that the day displayed within the map is the day wanted, and create an appropriate notation in the Callsheet for you. Wala! That’s all there is to it.
Always bear in mind, however, that an appointment notation within the Callsheet is not the same as an entry in the ScheduleList. In and of itself, the former (a mere notation in the Callsheet) has no operative effect. It becomes operative only when you create a job from the Callsheet, at which point ServiceDesk copies that appointment notation (along with info referencing the job itself, which tech is assigned, and so on) into the ScheduleList for you. There, within the ScheduleList, an entry as thus created does have operative effect (meaning the job will be displayed in your DispatchMap, and so on).
In summary, please remember these points. For an appointment that’s made at the same time you’re creating a job from its initiating Callsheet, simply place an appropriate notation in the Callsheet’s ‘Date and Time’ box. You can place it there using helpful tools that are attached to the box itself (which will automatically appear at appropriate moments), or by signifying your appointment from the ItemLocate context in the DispatchMap, or even by typing manually. Regardless, when you then create a job from that Callsheet, an appropriate (and operative) appointment entry will be inserted to the ScheduleList for you.
The purpose of the Callsheets, primarily, is to take down information from incoming callers, document the process, serve as a work-space for follow-through, and so on. Of course, you'll hope that a significant percentage of your callers are placing orders for service. Or perhaps you have someone at your sales counter buying a part. In either case, the relevant information first enters ServiceDesk through a Callsheet. These are the portal, you might say, for initiating every job or counter sale.
So what distinguishes a mere Callsheet (say one on which you've only taken and returned someone's call) from one that's used for an actual job or sale creation?
The secret lies in what you do with the Callsheet. If you wish to use it (and the information you've already entered upon it) to create an actual job or immediate sale, your task is simply to click on the Callsheet's option button that, appropriately, is labeled 'Job/Sale'. Or you can press Alt-J.
In either case, you'll immediately be presented with ServiceDesk's Create Job/Sale form. Though small, this form offers several options, most of which are self-explanatory. Typically, you'll want to leave most everything in its default state, and simply hit Enter or click on the indicated ‘Okay’ button. Now, ServiceDesk will do several things, all in the blink of an eye. These tasks are:
Of course, there are several details you may wish to know about.
For example, as the Create Job/Sale form displays, you'll notice you're immediately placed into a box labeled 'Assigned Tech.' The reason for this box: if you know at the time who you want as the technician for the job (or simply have a pretty good idea), you might as well make the assignment presently (just enter his initials). While you can wait and make the assignment later from your DispatchMap, it's nice to have it done from the start (assignments can be re-juggled later, regardless). Also, you'll notice there are options, immediately to the right, marked 'Tentative' or 'Definite' (it defaults to the former) The purpose: if the job's a recall, special request from a customer, or for any other reason definitely needs to go to a particular tech, you can so specify here (you can click on the 'Definite' option with your mouse, but it's even faster, after entering the tech's initials, to press your keyboard's right cursor key then the down key, as this will highlight and select the 'Definite' option without any movement of your hands from the keyboard).
If you've enabled the option in ServiceDesk that allows you to separate your sales among various company divisions or departments (see page 172), you'll also notice there's a box in which you must select the category to which the job or sale will belong (absent enabling this option, you'll see no such box, and needn't worry about this subject). Just click on the appropriate department title, or tab over to the box and use cursor keys to highlight the appropriate department, then press Enter to select.
At the top of the Create Job/Sale form, you'll also notice a box with several options marked 'Action Type.’ Basically, the default option is to both print an invoice and create a job. However, you can instead specify that you want to create a job without also printing an invoice (handy if you're dispatching the job by telephone to a technician in the field, and he's going to hand-print one from his location, so no additional physical invoice needs printed from your office). Or, you can just print information from the Callsheet onto paper (creating kind of a pseudo invoice, sans genuine InvoiceNumber) without creating a job or sale at all. Finally, if a job/sale was already created from the Callsheet, yet its status somehow got changed to indicate otherwise, you can simply specify that you want its status changed back. Just click on whichever option you prefer (usually it should be the first, default option).
You'll also notice that the Create Job/Sale form specifies the InvoiceNumber ServiceDesk will assign to the job/sale in question. If you've not yet specified a beginning number from the Settings form, for this purpose, you'll be urged at this point to do so. ServiceDesk tracks each of the numbers used, and will assign the next number, in sequence, to each subsequent job/sale. It is possible, if you wish, to change the number assigned in any specific instance (this does not change the number ServiceDesk tracks as the next one properly assigned). However, there should seldom (if ever) be any such need. In general, we caution against changing the number proposed if in fact you’re creating a job, for serious difficulties can arise if out-ofsequence numbers are assigned to items entered in the JobsCurrent file. Similarly, you'll note ServiceDesk displays the CreationDate that will be printed to your invoice. You can also change this, should the odd need arise.
Bear in mind, in regard to InvoiceNumbers, ServiceDesk prints them to the invoice for you. Thus, there is no need to have them advance-stamped to the invoice by your printing company. This saves money, and avoids the necessity of having to verify, with each invoice printing event, that the invoice in your printer is stamped to the same number as ServiceDesk is prepared to print. In the future, please be sure to order your invoices with a blank space for the number, but no number actually stamped in.
You'll find, both as you move from a Callsheet to the Create Job/Sale form and as you execute the form's 'Okay' button, ServiceDesk checks several elements to make sure all is in proper order for creating a job (at least everything it's capable of checking, such as that an appointment is in proper format, for example). A particularly helpful check, done in the background so you're not even aware of it, is to make sure you are not printing a new job with the same P.O. Number (typically involving dispatches from a home-warranty type of client) as was already used on a previous order. If ServiceDesk finds you're re-using such a number, it will bring it to your attention and suggest you reconsider your course.
Another useful check is that ServiceDesk examines your still pending Callsheets to make sure you're not printing from a new one, when in fact you should be printing from an earlier one. Specifically, we've noted that occasionally there will be a home-warranty type of job, on which we already have a Callsheet in connection with which we've been trying to schedule the customer. Eventually, the customer calls back to schedule, but doesn't mention they're doing so under that pending home-warranty dispatch. Formerly, without realizing the connection, we'd sometimes write-up such a person on a new Callsheet, assuming they were a cash customer (while in fact there was still that earlier, home-warranty dispatch pending). This additional check, by ServiceDesk, now warns before such a mistake occurs.
In regard to actually printing your invoice, please bear in mind that nearly every servicer has his or her own, preferred invoice layout. In creating ServiceDesk, we’ve not wanted to make you, as the user, bend to any particular design in this regard. Thus, we’ve setup the system so that ServiceDesk will print job-initiating work-order/invoice information onto whatever format you specify. There are instructions in the Appendix that describe how to setup for your own particular layout (see page 269). Of course, you can simply continue in using the default format that’s provided for you (primarily we provide it just to give you an easy and quick start), but for most operations we don’t think it will be most ideal. The biggest reason is because that default format is designed to print both form image and job-text onto previously blank paper, and we think generally it’s much more efficient to use invoices where the form-image has already been printed-in for you by a local printing company.
In regard to the process of creating the job and printing its invoice, there’s one more matter to note. One of our clients wanted to equip their technicians with a supplementary document that would outline the history of past jobs at the same location. It seemed like a good idea, so we've provided a feature to make it convenient (the printed information will consist of the history of prior jobs, data that you'll accumulate in ServiceDesk regardless). We mention it here because, if this is something you want to do, it probably makes sense to print these histories at the same time you print each new, job-initiating invoice.
The recommended procedure for this purpose is as follows. After printing the invoice, press F12 (thus bringing up the TechInterface form in CstmrDbase search mode, see page 209), then type the first several characters of the address in question. If matches come up, you can click on one, view it, and view adjoining ones simply by using the up or down cursor keys. If there's history you deem significant enough to send with your technician, press 'P' or 'Alt-P' to print it. ServiceDesk will remind you to be sure you've shifted to plain (i.e., non-invoice) paper, and on your consent will print the history of each item thus requested.
A final matter concerns the ability to re-print an invoice after the job-creating process has already been run. Perhaps, for example, your printer jammed, or had the wrong kind of paper in it, or suffered some similar problem when the process was first run—so you didn't get a good paper invoice, but have in fact created the job (i.e., a unique InvoiceNumber was pulled and used, a JobRecord was created, etc.). Or, perhaps you dispatched a job to one tech, and he's got the physical invoice, yet calls in that he can't make it. Thus, you need a new copy to give to a different tech. Regardless, do not ever attempt print an existing job's invoice, once the job has been created, by running through the job-creating process again from its originating Callsheet. Instead, any new efforts to print the invoice should be made from its now existing record in the JobsCurrent form (press F7). There is a utility there provided for the purpose. Simply bring up the record wanted, then click on the command button labeled 'Print Copy' or press Alt-P. Ironically, the correct method is also the easy one.
Otherwise, if you do it the wrong way, you'll essentially be creating a new, duplicate of the original job (i.e., a new and different JobRecord, InvoiceNumber, etc.). We've found by experience that neophytes tend to make this mistake unless warned, so (you may find if you personally make such a mistake) ServiceDesk does it's best to steer the errant user away from such a course.
There are several tools to aid in the manipulation of text on a Callsheet . First, you can use any of the normal Windows editing tools, which are as follows:
Suppose, for example, you want to move a particular section of text from one place to another within your Callsheet (or even from one form to another). Just highlight the characters using your mouse, then press CtrlX, at which moment you'll see them disappear (don't worry, they're now in the Windows clipboard). Now, move your cursor to the place you want to insert and press Ctrl-V, at which point you'll see the characters pop into their new location. The other Windows tools work in a similar fashion, though each with a somewhat different result as described above.
Besides the basic Windows tools, ServiceDesk provides several of its own tricks, that are specifically tailored to your needs in a Callsheet. These are:
To illustrate some possible uses for these tools, suppose that a landlady is calling to order service at her rental. She's just given you an address which, as she gave it, you thought was for billing, so you dutifully typed it into the CustomerInfo section. Then, she continues, "and my billing address is . . ."—revealing you were mistaken about her earlier intent. Now you've got the location address already typed where the billing address needs to be, and in fact, she's presently dictating the latter to you. Where can you type it? No problem, just type the billing info into the vacant location space you're already in, and when done hit Alt-F, immediately reversing the two into their correct locations. Telephone FlipFlop can be used for an almost identical purpose (only in the context, obviously, of a home telephone versus business number).
As you’re reading this, we reckon you might be feeling that all these different commands are a lot to remember. Couldn’t we have designed it, instead, so there are obvious buttons right on the face of the form for each purpose—so you don’t have to remember? The answer is, there’s only so much you can present visually in a limited space, without crowding out other important stuff, and without making the whole thing appear too busy and complex. As in everything else in life, it’s best when there’s balance—in this case between what’s visual and mouse-click accessible versus increased utility via other actions that are just too many to be presentable in such fashion.
But there is a very handy aid. In other contexts, we’ll tell you about a very nice command summary, available on the MainMenu. This summarizes each of the various keyboard commands, in a very nicely organized hierarchy, making it easy for you to review while learning, or to consult simply to refresh your memory later on. Within this command summary, there’s a very detailed section that relates to Callsheet commands. If wanting to remind yourself of the command for some Callsheet function, you could click on Command Summary from the MainMenu, then choose Callsheet Controls, and you’d see this section. However, that’s a tiny bit of work.
Instead, if you simply right-click in any otherwise un-operative space of a Callsheet, the system will instantly present the appropriate section from the command summary for you. Think of the resulting show as your “cheat sheet.”
As you’ll see later, the same kind of thing is available from several other contexts.
In addition to these utilities, there are some helpful things to know about how ServiceDesk manages a few elements of housekeeping.
First, you’ll notice all the Callsheets, existing on your system at any particular time, are sequentially numbered. The purpose of this numbering is to provide you with sign posts, so to speak, so you can easily tell how many you have at a given time, and where you are within that set. It’s also so that when you want to draw a coworker’s attention to a particular Callsheet, you can easily reference it via that number (i.e., I might say to my secretary Brenda: “Mrs. Zelipsky on Callsheet 23 needs to be scheduled). The thing to remember is that this sequential numbering, of working-area Callsheets, is nothing more than that. The numbers are not, by any means, a permanent ID assignment for such Callsheets—as are, by contrast, the InvoiceNumbers that are assigned to actual jobs.
Second, when making changes in a Callsheet, it may sometimes be useful to know they are not continuously recorded (i.e., "saved") to your hard drive. However, 'saves' happen with some frequency, as specifically triggered by particular events, including: your own action in moving from an edited Callsheet (i.e., into another form, including any other Callsheet), your action in switching a Callsheet from one desk to another, changing its status, and so on. Of course the work is done in the background, and you needn't think about it. And please be assured these automatic 'saves' are frequent enough that, even if you had a system crash, you'd be unlikely to lose anything more than what you were typing in the preceding few seconds.
Moreover, even if you've done nothing inadvertent to trigger a Callsheet save (in terms of moving to another form, etc.), ServiceDesk automatically invokes an unseen, 30-second timer after any editing activity (i.e., typing in a Callsheet, deleting text, etc.). If the timer counts down to zero and there has not otherwise been a save, ServiceDesk invokes one on its own.
And further still, if wanted you can purposely invoke an immediate save, in any Callsheet that's had changes, simply by hitting Esc. As you do so, you'll notice that the normally teal-colored background (the area between the Callsheets) momentarily turns to a blue color. This is confirmation that your Callsheet is saving. As a matter of fact, this momentary change in color occurs during any Callsheet-save event, whether triggered by the manual Esc or automatically.
Something you'll quickly notice if running with multiple stations is that ServiceDesk is designed to allow the use of only one set of active Callsheets network-wide. In other words, the entire set of active, not-yetarchived Callsheets is the same for every station in the network, so from any desk the same Callsheet information is available and displayed. The difference between each desk is that if mine is the desk that a particular 'Current' status Callsheet happens to be assigned to, then it is on my desk alone that such a Callsheet will be illuminated, while on all others, it will remain dimmed (and those others will also be locked out from editing my Callsheet). Thus, while everyone has the same information, it's obvious to each which tasks they are immediately responsible for.
Since all stations constantly display the same set of Callsheets, you might wonder how is it when one station makes a change that others are updated (i.e., when one station edits an existing Callsheet, adds a new one, changes status, etc.). In particular, you might wonder what happens when two stations are both in the same first-vacant-Callsheet position, typing in their own separate info to create their own independent new Callsheets. In such a circumstance, both stations are essentially claiming the same position, on the same Callsheet page, for their own new Callsheets. How is this handled? Don't worry. ServiceDesk takes care of it, and does not require that you pay such matters any attention.
However, and even so, in the event you encounter situations like this, it may help if you understand a few quirks in operation, in terms of how ServiceDesk is juggling each user's demands. Basically, it follows these rules.
The result of the above protocols is that, from your perspective as user, there's virtually nothing to worry about. The only time anything seems even unusual, within ServiceDesk, is in the case described for situation 'c.' In this case, you may be merrily typing information into a new Callsheet when, suddenly, because another station has just saved their own new Callsheet in the same position, you find yourself being unwillingly transported to the next vacant spot. The event could seem disconcerting if you did not understand what was happening. However, with the explanation here provided, it should not cause alarm.
Occasionally, you may enter information into a Callsheet that you want to immediately display to other stations, even while you have no purpose for otherwise engaging in an action that would create a save. Again, the Callsheet-Esc method comes in handy. Just press that single key from your Callsheet, thereby inducing an immediate save, and thus causing instant updates to other computers.
Another matter of note concerns ServiceDesk's treatment of text in a Callsheet's two name fields (i.e., CustomerName and LocationName). The underlying reality here is that, as a user, you might be entering either a business or person's name—and the treatment in certain contexts needs to be different, depending on which is involved. If it's a person's name, for example, you'll want only the last name applied to shortreferences in the DispatchMap, to the "Dear So and So" in future billing reminders, and so on, while if it's a business name, the entire name will (in most cases at least) be used as a unit. Thus, ServiceDesk needs a means to distinguish between the two situations, and since it still lacks full human intelligence, you need to provide a little assistance. All you need to do is follow this convention: any time it's a person's name, use the format of LastName-comma-space-FirstName (e.g., “BOYLES, JOHN”). Finding the two words separated by a comma, ServiceDesk will figure it's dealing with a person's name, and will separate out the last name as that. In the absence of this format (i.e., no comma in the line), ServiceDesk figures it's dealing with a business name, and treats it accordingly (see note beginning at page 293).
As still another matter regarding your typing of info into Callsheets, you might note that ServiceDesk automatically engages the caps lock on your keyboard whenever you enter a Callsheet. The reason is because there is little point here in slowing down your typing by requiring the use of both upper and lower case. The expected convention, therefore, is that unless there's a specific reason to do otherwise, all your typing in a Callsheet will be in upper case. This simplifies the typing, and provides for a nice uniformity of output. You'll find the invoices look just fine in such format too.
Oh, and incidentally, in regard to the four telephone number fields that are provided in each Callsheet (two in the Customer-Info section and two in the Location-Info section): it’s our convention that home telephone number is placed in the left box and business telephone number in the right. You can certainly do otherwise (and attach appropriate notations to indicate pager numbers, etc.) but we find as a basic convention, this works well.
Like pages out of a note pad, individual Callsheets will eventually serve their purpose (actually, many will fulfill their purpose almost instantly, as you take the info for and schedule a service call, then immediately create a job from it). Naturally, you don't want your workspace cluttered with Callsheets that, if they were paper, you'd be ready to throw into the waste basket (or perhaps into a stack of completed call-records). So obviously, you need some means to readily cleanse your Callsheet workspace of all but items that will remind you of work that still needs done.
To accomplish this, you may either select the 'Archive Callsheets' option from the main menu or press Alt-A from the Callsheets themselves (as is, in fact, suggested by the menu option, in case you forget). The archiving process looks at each of the Callsheets in your current workspace. Any that are marked 'Job/Sale' or 'Otherwise Done' are moved into the CallsheetArchive, a separate file where they remain available for later search and review should the need arise (if you've ever had the need to go over old call-records, you can imagine how this might be useful). Those marked 'Delete,' obviously, are simply erased. All others remain in the current work area.
rrent work area. You can run this archive routine as often as you feel the need to clear your workspace—probably at least once a day, perhaps several times, depending on the volume of your incoming calls and personal preference. Some operators like to wait and see how many Callsheets have accumulated after a full day's work, then they archive. Others like to keep the workspace as uncluttered as possible, and so archive frequently throughout the day.
You might note, incidentally, that there are several other forms in ServiceDesk that occasionally require an archiving "flush" of non-current data from their active workspace; these are discussed in their own sections. You might also note there is an Auto-Archive feature that, if turned on, will automatically run archive routines on all of these, once each night.
If you ever want to view or conduct searches on (or just browse among) your Archived Callsheets, it's very easy. Just press Ctrl-F2 (or click on the corresponding MainMenu command button). This resource can be quite handy. You might want to lookup information on a Callsheet that was archived some time ago. Searches are easy. Just press 'S' or click on the indicated command button, then type your target (any leading portion is adequate), and hit Enter. To resume the same search after the first or any subsequent target is found, just hit 'S' and press Enter again (the target specified remains in memory). Press Esc to return to your current Callsheets.