There is too much focus on passwords and not enough focus on the protection of assets and the mitigation of adverse impacts of breaches. There is also too much focus on the creation of “custom” “security” systems and not enough focus on identifying threats and the risks of their occurring. There is too much complaining about how “hard” it is to have good security and not enough appreciation about the adverse impact of having the wrong type of security.

As a result of all this, at the upcoming FileMaker Developer Conference in Phoenix I will be conducting a special session:

Assets, Vulnerabilities, Threats, and Risks:
What Type Security Is Right For You?
Tuesday, July 15th 2008
11:15 AM to 12:30 PM
Sonoran Ballroom H

This session will feature a discussion of how to determine the right type of security for your solution. It is based on a set of circumstances specific to your individual solution, but common to all FileMaker Pro solutions.

All assets are subject to threats that can exploit vulnerabilities that, in turn, can breach their Confidentiality, Integrity, and Availability. The level of adverse impact of such a breach varies situation by situation as do the risks of those threats’ occurring and the prevalence of threat agents that can trigger the exploits.

Security then must focus on closing vulnerabilities, on blocking threat agents, and on mitigating adverse impact of breaches. And a great many FileMaker Pro solutions take no cognizance whatsoever of this key requirement.

So, if you are at the Develop Conference, feel free to stop by to listen, to contribute, or to debate this very important subject.

—–
Steven H. Blackwell
Platinum Member, FileMaker Business Alliance
Partner Member, FileMaker Solutions Alliance (1997-2007)
FileMaker 9 Certified Developer
FileMaker 8 Certified Developer
FileMaker 7 Certified Developer
FileMaker Authorized Trainer

So here, at long last, is the solution:

mebeliLet (
[
NewSubSummary =( GetNthRecord ( MyTable::MyKeyField ; Get(RecordNumber)-1) <> MyTable::MyKeyField ); //Test if record is the start of a new subsummary. MyKeyField is the sort field for my subsummary part.

$on = $val; // $on will always be whatever $val was last
$val = If (NewSubSummary; If ( $val = 1;"" ; 1) ) // switch the value of val
];
$on // if $on=1, then apply the conditional format

)

[edit:] Or, in much simpler terms:

Let (
[
$b = If ($b ;"" ;1 )
];
$b
)

To me, the interesting thing here is the way that these variable expressions are handled by FileMaker. First of all, the conditional formatting seems to get evaluated, as one might expect, from top to bottom of the page, allowing you to use variables to keep track of formatting decisions that were made earlier on the page, or even on previous pages. It seems there should be some much cooler implications of this, like multiple title headers and pseudo-headers (don’t know what I mean by that? Neither do I…). The other interesting thing is that the variables here are local variables, but they’re kept active while the whole page is rendered by preview mode, which is what allows me to make reference to the last evaluation of $val and produce the alternating effect (yeah, I know I could just as easily use global variables, but it’s handy to know I don’t have to)

The reason that this gave me a checkerboard on the first try:

was because I had placed the formula on a repeating field, meaning that each conditional format formula was evaluated for each repetition, left-to-right. Once I placed the calc on a regular field, the checkerboard was gone and I had nice alternating rows.

————-

EDIT: This post got hosed somehow, and everything beyond the part where I refer to myself as an idiot was erased. I can’t remember what was idiotic about my original conditional formatting in this case (if I weren’t such an idiot, I’d probably remember). In any case, below is a reprise of the brain teaser:

———–

Each line in Edoshin’s crosstab technique is basically a repeating summary field based on a repeating summary calc. My goal was to get each one of these repeating fields to alternate its background fill. Using any kind of Mod-based calculation based on record number was going to fail, since these fields are on a subsummary, and there’s no way to predict how many records correspond to each subsummary part.

Taking a purely throw-rocks-at-it-until-it-stops-moving approach, I opened up the conditional formatting dialog on that repeating summary field, and hammered out a calculation. I was astounded, when I went back to preview mode, to see this:

My conditional formatting calc had inadvertently produced a checkerboard pattern. I realized, shortly thereafter, that by placing the same calc on a regular field, rather than a repeating field, I could get the alternating pattern as I desired:

The brain teaser challenge, before it got erased, was to figure out what sort of calculation could yield this effect on a subsummary part. The reward, if I recall correctly, was a signed copy of my memoir.

Step One

Step one, of course, is to read the original post. Familiarize yourself with the concepts. Is essence, we’re leveraging PHP to create a javascript page which displays the map in a FileMaker Web Viewer. In the original post, we used the Easy Google Map PHP class, and we’ll do the same here. You’ll also need a Google Maps API key if you wish to run this on your own server.

This example will be staged at http://etc.proofgroup.com/fmcollective/. The Easy Google Map PHP class will be hosted here http://etc.proofgroup.com/fmcollective/EasyGoogleMap.class.php. Neither of these links will prove very useful to you on their own, but they will be instrumental later when I build the actual application.

You will need a complementary PHP file to translate the FileMaker request (a GET request via HTTP) to the Easy Google Map class. This is where it gets just a little bit tricky. First off, how should we send multiple addresses via a GET HTTP request?

Perhaps something like this:

http://DOMAIN/MYPHPFILE.PHP?addr1=1st_Address&addr2=2nd_Address

But I can see all sorts of trouble with that, not the least of which is that it involves an ever-growing number of parameters (one for every address we want to map). It’s also not very PHP friendly. With some research and testing, I settled on using a PHP Array. PHP Arrays are very nice indeed. The only problem, how to create a PHP Array (a complex data structure) in FileMaker and then transmit it to the complementary PHP file? It turns out, PHP has a solution for that, too. It’s called a Serialized Array. According to the PHP manual, “This is useful for storing or passing PHP values around without losing their type and structure.” I like it!

Serialized arrays are strings which look something like this:

a:2:{i:0;s:3:"foo";i:1;s:3:"bar";}

That’s a 2-item array, the first item is “foo” (index 0) and the second item is “bar” (index 1).

Here’s my concept: serialize the data (manually or via custom function) in FileMaker, pass the string to the PHP, unserialize it there (turning it into a full-fledged array), and using the native PHP array to build the map data points via looping through the array items.

The Details

I mentioned a custom function above. I’ll need a custom function to translate a carriage-return separated list of data, such as this:

One
Two
Three

Into this:

a:3:{i:0;s:3:"One";i:1;s:3:"Two";i:2;s:5:"Three";}

I wrote a recursive custom function, called cfSerializeData, which is the following:

/*

By: Mike Lee
Date: 4 May 2007
Version: 1
Fxn Name: cfSerializeData
Parameter: ‘values’ – a carriage-return delimited list of values that you want to turn into a PHP serialized array of data
Description: This is a recursive function that takes a list of data in ‘Values’ and turns it into a serialized array for use
within PHP (see serialize() and unserialize() in the PHP documentation). This can be useful for passing lists of data to
a PHP function–either through HTTP calls or the PHP plugin.

Example Input: One¶Two¶Three
Example Result: a:3:{i:0;s:3:”One”;i:1;s:3:”Two”;i:2;s:5:”Three”;}

*/

Let(
[
//Set variables
$NumItems = Case( IsEmpty( $NumItems ) or $NumItems=”0″ ; ValueCount( Values ) ; $NumItems );
i = ValueCount( Values ) - 1;
lastItem = RightValues(values;1);
lastItem = Left(lastItem;Length(lastItem)-1);
remainder = LeftValues(values;ValueCount(values)-1);
headertxt = “a:” & $NumItems & “:{”;
footertxt = Case(i+1=$NumItems;”}”)
]
;

//If remainder is not empty recurse, else clear the variable and write the header txt
Case( not IsEmpty( remainder );cfSerializeData( remainder );Let( $NumItems = $null ; headertxt ))

&

//Actual serialized data
“i:” & i & “;s:” & Length(lastItem) & “:\”” & lastItem & “\”;” &

//Write footer txt (built-in conditional)
footertxt

)

You can then use that custom function, or, if you don’t have FileMaker Pro Advanced, some form of script, to turn a list of addresses into a serialized array of addresses suitable for PHP.

List of addresses:

1 Any Street, Anytown, Anystate, 12345
2 Any Street, Anytown, Anystate, 12345
3 Any Street, Anytown, Anystate, 12345
4 Any Street, Anytown, Anystate, 12345

Serialized array of addresses:

a:4:{i:0;s:38:"1 Any Street, Anytown, Anystate, 12345";i:1;s:38:"2 Any Street, Anytown, Anystate, 12345";i:2;s:38:"3 Any Street, Anytown, Anystate, 12345";i:3;s:38:"4 Any Street, Anytown, Anystate, 12345";}

The Complementary PHP file

All this talk about serialized arrays and custom functions and I almost forgot to say that you’ll also need a suitable, complementary PHP file to accept the request and turn it into the Google Maps request. This is the file I’ve written, hosted at http://etc.proofgroup.com/fmcollective/googlemaparray.php:

<?php

/* File Name: googlemaparray.php
File URI: http://etc.proofgroup.com/fmcollective/googlemap.php
Description: Google Map API wrapper script
Version: 1.1
Author: Mike Lee, The Proof Group LLC
Author URI: http://www.proofgroup.com
*
* Copyright (c) 2007-2008, The Proof Group LLC
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in any form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of The Proof Group LLC nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROOF GROUP LLC ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/

require 'EasyGoogleMap.class.php';

//Google Maps API Key
$googlemaps_api_key = "XXX-XXX-XXX-INSERT-YOUR-KEY-HERE";

//Get the ‘addr’ parameter from the GET request
$addrarray = $_GET[’addr’];
$addrarray = stripslashes($addrarray);

$addrarray = unserialize($addrarray);

$gm = & new EasyGoogleMap($googlemaps_api_key);

# Set address point(s)
foreach( $addrarray as $key => $value){
$gm->SetAddress($value);
}

# To Enable/Disable Map Type (Map/Satellite/Hybrid)
$gm->mMapType = TRUE;

# Set map size
$gm->SetMapWidth(’700′);
$gm->SetMapHeight(’500′);

# Set map zoom
$gm->SetMapZoom(8);

?>
<html>
<head>
<title>The Proof Group: Google Map Array API Example</title>
<?php echo $gm->GmapsKey(); ?>
</head>
<body>
<center>
<?php
echo $gm->MapHolder();
echo $gm->InitJs();
echo $gm->UnloadMap();
?>
<font face="arial, helvetica, verdana, sans-serif" size="-1">
Google Maps Array API Example hosted by <a href="http://www.proofgroup.com">The Proof Group</a>.<br>
See the original post on this topic at <a href="http://fmcollective.com/?p=88">The FileMaker Collective</a> for more information.<p>
</center>
</font>
<font face="arial, helvetica, verdana, sans-serif" size="-2">
Terms of Use: Thank you for using <a href="http://www.proofgroup.com">The Proof Group</a> Google Maps API. (1) You may not use this API for commercial purposes (2) Use of this API is limited to 100 requests per IP per day (3) You are subject to all terms and conditions of the Google Maps API Terms of Use, <a href="http://www.google.com/apis/maps/terms.html">
http://www.google.com/apis/maps/terms.html</a>.
</font>
</body>
</html>

The important part is the ‘foreach’, foreach( $addrarray as $key => $value) {$gm->SetAddress($value);}, which loops through the array and adds all the addresses as individual map points. This is really the only major difference betweent he single-point mapping PHP file and this one.

What of FileMaker

How does this work from within FileMaker? Essentially, using a list of addresses, you loop through the addresses and capture them to a carriage-return delimited list – the old SetField(LIST;LIST & myAddress & ¶) trick.

Once you’ve got the list, you’ll serialize it using the custom function – SetField(ARRAY;cfSerializeData(LIST)).

Then, it’s just a matter of calling the correct URL from within the Web Viewer:

http://etc.proofgroup.com/fmcollective/googlemaparray.php?addr=ARRAY

First, in FileMaker, you need a table of address data. Here I’m using some really awful, made-up addresses:

I’ve also created a Globals table, with the fields: ARRAY, LIST, and URL (all of which are text, globals).

In layout mode, add a Web Viewer (here, in an enlarged header part), point it to the Globals::URL field and name it ‘wv’ in the object information floating window:

Within FileMaker, I wrapped the entire thing into a Script called “Update Map With Found Set”, a screenshot of which follows:

For convenience, I also attached this script to a button on the layout to update the Web Viewer. Back in browse, get a found set (more about that later), and press the button:

For a found set of 25 records, the request URL will look something like this (pardon the mess):

http://etc.proofgroup.com/fmcollective/googlemaparray.php?addr=a:25:{i:0;s:35:”Main Street, Wallingford, CT, 06492″;i:1;s:34:”Main Street, New Canaan, CT, 08640″;i:2;s:34:”Main Street, Manchester, CT, 06042″;i:3;s:34:”Main Street, Ridgefield, CT, 06877″;i:4;s:33:”Main Street, Riverside, CT, 06878″;i:5;s:33:”Main Street, Greenwich, CT, 06830″;i:6;s:28:”Main Street, Lyme, CT, 06371″;i:7;s:31:”Main Street, Cos Cob, CT, 06807″;i:8;s:34:”Main Street, Stonington, CT, 06378″;i:9;s:31:”Main Street, Madison, CT, 06443″;i:10;s:35:”Main Street, New Britain, CT, 06053″;i:11;s:34:”Main Street, Farmington, CT, 06032″;i:12;s:30:”Main Street, Darien, CT, 06820″;i:13;s:35:”Main Street, Wallingford, CT, 06492″;i:14;s:32:”Main Street, Westport, CT, 06880″;i:15;s:31:”Main Street, Milford, CT, 06460″;i:16;s:32:”Main Street, Simsbury, CT, 06070″;i:17;s:32:”Main Street, Rowayton, CT, 06853″;i:18;s:29:”Main Street, Essex, CT, 06426″;i:19;s:32:”Main Street, Stamford, CT, 06902″;i:20;s:37:”Main Street, West Hartford, CT, 06110″;i:21;s:35:”Main Street, Wallingford, CT, 06492″;i:22;s:33:”Main Street, Greenwich, CT, 06830″;i:23;s:30:”Main Street, Orange, CT, 06477″;i:24;s:40:”Main Street, Vernon Rockville, CT, 06066″;}

What could go wrong?

There’s one problem with this technique. Here’s how to reproduce the issue. Show all records and update the map. With all 177 records showing, the Web Viewer map should fail and the following should be shown:

Request-URI Too Large

The requested URL’s length exceeds the capacity limit for this server

I’m no Apache expert, but I know this is based on some form of compile-time configuration and is specific to a GET request. Since the Web Viewer only allows me to use GET requests, we have this upper limit issue (somewhere around 100 records in this example). Alternatively, you can re-compile Apache, but I’ll let you figure that one out.

The solution, of course, is to use POST, but I’ll leave that as an exercise for the reader. Hint: you may have to do things completely differently and FM9 helps.

By the way, once you add “Labels” (one for each address, for example to show demographic info) and other display niceties (e.g. varying marker icons or colors) to your request URL, the maximum number of addresses you can map will plummet. When I’ve fleshed this out, the max easily drops to below 50 records.

Do have fun and let me know what you think in the comments.

You can download a zipped copy of the example file here.

To the left is an example of what I mean. This effect can’t be achieved with portals (as far as I know). In this example, the canonical approach would be to construct a layout based on the invoice line items. However, doing so would make it impossible for me to put in the text element down the right side, or to incorporate related data from multiple tables.

To solve the problem, I create repeating calc fields in the invoice table and define them to refer to specific related records, depending on the repetition. For example:
 

Now, although FM 9 didn’t fulfill my wish of making this technique obsolete, it did offer a fix for one of the shortcomings of the technique – alternate row shading. To achieve this, make sure one of your pseudoportal fields extends the width of the whole set (usually, I just use the first field). Set conditional formatting on it for the color you want using this formula:

http://www.petervinogradov.com/TechniqueFiles/PV_PseudoPortals.zip 

The file also includes some fun CFs and examples for automatically balancing multi-column pseudoportals.

The fuss over Andy’s conditional formatting tricks, for example, is certainly well-deserved (though let’s face it, we all would have worked that stuff out on our own, right? no?).  After playing with those for a bit, a post about Ray Cologon’s “Progress Bars” ( http://www.nightwing.com.au/FileMaker/demos.html ) caught my attention, and I ended up spending a good afternoon hacking that file apart.

What I particularly love about this solution is the idea of dumping a bunch of webviewer resources (pictures, etc.) into the user’s temp folder using the get (temporarypath) function. While I’ve certainly employed some variations on this – sneaking some garbage PDFs into a my docs folder or out to the desktop prior to e-mailing, etc – I’ve been overlooking the temp folder for years (mostly I guess because there’s never been a convenient get function for it before). Now with FM 9 data URLs finally working, the webviewer has (almost) completely arrived, and a convenient place to dump huge amounts of rubbish couldn’t be more timely. [edit - just read the "dispatches from DevCon" post. Evidently this demo was a big hit there, too]

Lately, I’ve been scrambling to finish a rewrite of a scheduling solution for a school that I work for. The requirements are simple – be able to define courses in any variety of blocks and times and dynamically generate graphical student schedules with seamless handling of overlaps and conflicts. Once upon a time, I tried to achieve this using microscopic portal rows and a schedule table with zillions of records and dozens of lead-like calculations. It worked, but it was only “dynamic” from a geologic perspective and it made white smoke pour out the back of my Dell.

With the web viewer, of course, that all changed – almost. I was able to throw out the schedule table and generate a whole mess of CSS Divs instead. The schedules were coming out slicker and faster than ever, but FM was still doing all the heavy lifting of stitching together adjacent course blocks, knocking out overlaps, and sizing text based on available block sizes. Spitting out a batch of schedules was no longer an overnight project, but it was still burdened with a sluggishness that gnawed at me in light of all the extra coding and testing it took to implement.

Over the course of this project, it did occur to me to try moving the heavy lifting over to the web browser, but I hesitated for a couple of reasons:

- I hadn’t written a word of Javascript in over 3 years
- generating HTML in an FM calc or CF is painful enough. Imagine having to debug a bunch of Javascript with escaped quotations everywhere.

Finally, though, it was Ray’s sample file that gave me the kick I needed. If I could simply pack my javascript into a container file, have that dumped into the user’s temp folder, and reference it in my HTML, life would be a lot simpler.

After two days of dusting off the cobwebs in my Javascript memory (nothing like a few years of FM calc habits to help THAT along…), I’ve finally got a rough library of functions that can connect and polish several dozen disjointed, poorly formatted div tags in a split-second. It beats the pants off the custom functions I had going in FM, and only rarely does it lock up my browser in an endless loop (okay, so there’s some debugging to do).

So, three cheers for sample files, particulary Ray’s 9 for 9 collection. Looking forward to 10 for 10 - unless of course FM comes out with something boneheaded, like  ”FM Creative Suite”, “FMX”, “FM smooth ultra king 100s”…

Yes, it isn’t exactly the feature I had in mind. I would have preferred to have full-blown access to all object properties and a way to program them using the calculation engine. But, Conditional Formatting gets me very close.

Here are a couple of basic highlighting patterns solved using CF.

1. Highlighting a Focused Field

There was quite a bit of buzz about Andy Lecates’ DevCon 2007 session where he showed off this active-field highlighting in his demo app. Andy noted that he was almost embarrassed to tell people that the formula behind this technique was literally a “1″. This puzzled me a bit so I decided to reproduce the technique. I have been told the credit for discovering this should properly be attributed to Chad Novotony of The Support Group. Kudos, Chad; it is really quite brilliant in its simplicity.

You can download the example file below and check out the conditional format properties of the fields shown.

The secret sauce behind this technique is to fill the fields with your highlight color of choice before you even open up the conditional formatting dialog box. I know this sounds completely backwards but the technique is based on the principle that a field object’s conditional formating expression isn’t evaluated when your cursor is sitting in it. So, when we enter the field, its CF stops working and the field defaults to its default fill color. So, the only thing left to do now is to make CF turn the fields white when I am not in it, which is to say, always make it white all the time. The formula for that? You guess it, “1″.

I know, I know…who would have thunk it? Kudos to Chad for this gem and to Andy Lecates for making it public.

2. Portal Row Highlighting

This next example is a bit more straightforward. We want to select a portal row and highlight it. Do accomplish this, you need two basic components, (i) an object to serve as the base CF highlight element, and ii) a script to trip the highlight. Here’s picture of the pieces before assembly…

The conditionally formatted object in this case is just a regular button set to turn blue if the value in a global variable, $$selected matches its row id. Next, make a script to set the $$selected global variable with the portal row’s record id. After that, bind that script to a “select” button inside the portal row and presto, portal row highlight without adding even one extra field!

Get the example file, conditional formatting example 1 to check this out yourself.

Cheers,

Ernest Koe
The Proof Group LLC

With the introduction of support for seamless connectivity to external SQL based data sources, the company demonstrates its continuing commitment to FileMaker Pro’s becoming an enterprise level player for businesses large and small. The ability to draw data from back-end “big iron” types systems such as Oracle and SQL Server 2005 and to utilize those data within the FileMaker Pro solution construct will open new markets for FileMaker products and for FileMaker developers.

While a considerable amount of attention and experimentation will center on this External SQL Source functionality, the new FileMaker Pro 9 and FileMaker Server 9 have some additional enhancements that are both compelling and useful:

•Scripts can now be organized into folders and subfolders, a major step forward in organization and management of even modestly complex solutions. Developers eagerly await the extension of this functionality to other objects such as tables, fields, layouts, and value lists.

•ScriptMaker now has non-modal windows, meaning that several scripts can be open for editing at the same time and that items can be copied from one to another without closing any windows. Additionally, developers can switch between ScriptMaker windows and layout windows.

•An enhanced script debugger permits running of scripts with subordinate level Accounts but then temporarily authenticating for high level privilege functions. As a result developers can see how the script behaves for different levels of privileges.

•Conditional formatting of layout objects, based either on hard-coded formulas or on dynamic calculation results will significantly enhance UI capabilities. For example, if an invoice is over 60 days old, its total can be made to turn to red automatically without need for scripting or other workarounds.

•In FileMaker Server 9 the venerable SAT Tool has been replaced on both Macintosh and Windows platforms with a new Uniform Admin Console. In an enhanced panel focused on connected users, the Account Name, Privilege Set name, and IP address of each connected user can be made to display.

•Since Custom Web Publishing is now part of the core FileMaker Server 9 product, its configuration is also managed through the Uniform Admin Console. The configuration options have been simplified and more tightly integrated into the core parts of the Console. For example, there is no longer the need to specify the User ID and Passcode or to have separate credentials for accessing the Web Publishing Engine’s management options.

•Finally, FileMaker, Inc. added several new functions to FileMaker Pro 9, my favorite of which is the Self function. As its name implies, it returns the content of the object in which a calculation is defined. This is useful for creating a single calculation formula that can be applied to many different objects. It provides a way for a calculation to reference an associated object without having explicitly to reference it.

Steven H. Blackwell

Google Mapping in FileMaker

I’m sure you’ve seen the Web Viewer maps in FileMaker. Sure, they’re serviceable, but you’ve got no control. And with Google recently adding “Search Results” and “My Maps” to the screen as well (a laudable feature, to be sure), the available real estate for the actual map shrunk by almost half. What can be done? I’ll show you how to roll you own mapping engine using PHP and the Google Map API.

Using the built-in tools

Simple Google maps can be produced in FileMaker using the Web Viewer object. I’m sure you’ve all seen this:

This is the Web Viewer Setup for that example:

What’s wrong here?

The problem with this, in my opinion, is that the Search Results and My Maps area of the map takes up almost half of the screen. Further, you’ve got limited to no control of how this looks. And, one click on a link and the user is off browsing the web—not exactly what you want them to be doing.

Using the API

I decided to turn to the Google Maps API to attempt to solve these issues. The first step here is to sign up for a Google Maps API Key for the site you’ll be hosting your maps from (the maps will still need a home).

So as not to re-invent the wheel, my first step was to search for a PHP wrapper for the Google Maps API that I could use as the basis for my mapping API. I found one that I came to like called the Easy Google Map class. This PHP class wraps all the JavaScript in PHP calls, so a PHP-buff like myself can easily use it. You’ll need to download the Easy Google Map class (”EasyGoogleMap.class.php”) and install it on a webserver that supports PHP (the same one for which you got the Google Maps API key).

In this example, we’ll be staging the work at http://etc.proofgroup.com/fmcollective/, so the class will be located at http://etc.proofgroup.com/fmcollective/EasyGoogleMap.class.php. You can load this URL now, if you’d like, but you won’t get anything because it’s a PHP class and doesn’t return anything on its own.

The next step, of course, is to write a complementary PHP file that will actually be the mapping API. My thought was to make this simple to call from FileMaker, with a URL formatted like the following:

http://DOMAIN/MYCOMPLIMENTARYPHPFILE.PHP?addr=The+Address+To+Map

To do this I’ll need a PHP file that can grab the ‘addr’ parameter and process it according to the needs of the Easy Google Mapping Class in order to produce a map.

Here’s what my file (which I have named ‘googlemap.php’) looks like:


<?php
/*
* File Name: googlemap.php
* File URI: http://etc.proofgroup.com/fmcollective/googlemap.php
* Description: Google Map API wrapper script
* Version: 1.0
* Author: Mike Lee, The Proof Group LLC
* Author URI: http://www.proofgroup.com
*
* Copyright (c) 2007, The Proof Group LLC
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in any form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of The Proof Group LLC nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE PROOF GROUP LLC ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
require 'EasyGoogleMap.class.php';
# Google Maps API Key
$googlemaps_api_key = "XXX-XXX-XXX-INSERT-YOUR-KEY-HERE";
# Get the 'addr' parameter from the GET request
$addr = $_GET['addr'];
$gm = & new EasyGoogleMap($googlemaps_api_key);
# Set address point(s)
$gm->SetAddress($addr);
$gm->SetInfoWindowText($addr);
$gm->SetSideClick($addr);
# To Enable/Disable Map Type (Map/Satellite/Hybrid)
$gm->mMapType = TRUE;
# Set map size
$gm->SetMapWidth('700');
$gm->SetMapHeight('600');
?>
<html>
<head>
<title>EasyGoogleMap</title>
<?php echo $gm->GmapsKey(); ?>
</head>
<body>
<center>
<?php
echo $gm->GetSideClick();
echo $gm->MapHolder();
echo $gm->InitJs();
echo $gm->UnloadMap();
?>
</center>
</body>
</html>


Copy that text and save it as ‘googlemap.php’ (you’ll want to insert your own API key where indicated). That file is now hosted here: http://etc.proofgroup.com/fmcollective/googlemap.php. You will want to put it in the same directory you put the EasyGoogleMap.class.php file.

A direct link to the file, which you can download, is here: Google Map PHP File. You will need to rename the file ‘googlemap.php’.

The fmcollective directory now looks like this:

.
|-- EasyGoogleMap.class.php
`-- googlemap.php


If you load the googlemap.php page right now, you’ll notice it’s blank, because you’ve not passed it any address to map (via the ‘addr’ parameter).

A fully working example URL is the following: http://etc.proofgroup.com/fmcollective/googlemap.php?addr=1600+Amphitheatre+Pkwy,+Mountain+View,+CA+94043.

Put the API into FileMaker’s Web Viewer

Now, let’s go back to the top and put this into FileMaker’s Web Viewer. Here’s a screenshot of what the finished product looks like:

The Web Viewer setup is for a ‘Custom Web Address’ set to the following:

"http://etc.proofgroup.com/fmcollective/googlemap.php?" & "addr=" & /*Address=*/ Contact Preferred Address::Street & ", " & /*City=*/ Contact Preferred Address::City & ", " & /*State=*/ Contact Preferred Address::StateProv & " " & /*Zip Code=*/ Contact Preferred Address::PostalCode

I hope you’ve enjoyed my first post and learned something useful. Comments are welcome.