forked from jmandel/testing-ghpages
/
index.html
480 lines (363 loc) · 25 KB
/
index.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>SMART Container Javascript Libraries</title>
<meta name="author" content="SMART Platforms">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<!-- Le HTML5 shim, for IE6-8 support of HTML elements -->
<!--[if lt IE 9]>
<script src="http://html5shim.googlecode.com/svn/trunk/html5.js"></script>
<![endif]-->
<link href="/assets/themes/twitter-2.0/css/pygments.css" rel="stylesheet">
<link href="/assets/themes/twitter-2.0/css/bootstrap.min.css" rel="stylesheet">
<link href="/assets/themes/twitter-2.0/css/bootstrap-responsive.min.css" rel="stylesheet">
<link href="/assets/themes/twitter-2.0/css/style.css" rel="stylesheet">
</head>
<body>
<div class="container">
<div class="content">
<section id="jekyll-page">
<div class="row">
<div class="span4">
<a href="/">
<img id='smart_top_logo' src="/images/smart.png"/>
</a>
<div id="left_nav">
<ul class="nav nav-list">
<li class="nav-header">Tutorials</li>
<li><a href="/howto/build_a_smart_app">Build a SMART App</a></li>
<li><a href="/howto/build_a_rest_app">Build a SMART REST App</a></li>
<li><a href="/howto/background_and_helper_apps">Background + Helper Apps</a></li>
<li><a href="/howto/build_smart_frame_ui_apps">Frame UI Apps</a></li>
<li><a href="/howto/got_statins">Got Statins? App</a></li>
<li><a href="/howto/rx_reminder">RxReminder App</a></li>
<li class="nav-header">Using SMART Data</li>
<li><a href="/howto/intro_to_rdf">Intro to RDF and SPARQL</a></li>
<li><a href="/howto/sparql_examples">SPARQL Examples for SMART</a></li>
<li><a href="/howto/intro_to_jsonld">Intro to the JSON-LD API</a></li>
<li><a href="/howto/deferred">$.Deferred for Parallel Queries</a></li>
<li><a href="/howto/smart_data">SMART Data: Best Practices</a></li>
<li class="nav-header">Reference</li>
<li><a href="/reference/data_model">Data Model</a></li>
<li><a href="/reference/rest_api">REST API</a></li>
<li><a href="/reference/filters">Query Filters</a></li>
<li><a href="/reference/app_manifest">App Manifest</a></li>
<li class="nav-header">Client Libraries</li>
<li><a href="/libraries/javascript">Javascript (SMART Connect)</a></li>
<li><a href="/libraries/python">Python</a></li>
<li><a href="/libraries/java">Java</a></li>
<li><a href="/libraries/dotnet">.NET</a></li>
<li><a href="/libraries/container_javascript">Container-side Javascript</a></li>
<li class="nav-header">SMART Update Guides</li>
<li><a href="/updates/smart_0.4/app">0.4 Apps</a></li>
<li><a href="/updates/smart_0.5/container">0.4 Containers</a></li>
<li><a href="/updates/smart_0.5/">0.5 Apps + Containers</a></li>
<li class="nav-header">Reference EMR Installation</li>
<li><a href="/install/linux">Ubuntu Linux</a></li>
<li><a href="/install/os_x">OS X</a></li>
<li class="nav-header">Presentations</li>
<li><a href="http://www.slideshare.net/jmandel/2010-0826smartarchitecture">Architecture (2010-08)</a></li>
<li><a href="http://www.slideshare.net/jmandel/2010-08-26-smart-governance">Governance (2010-08)</a></li>
<li><a href="http://media.smartplatforms.org/smart-screencast.mp4">Demo</a></li>
<li class="nav-header">Downloads</li>
<li><a href="/downloads/">Download Source + VM</a></li>
</ul>
</div>
</div>
<div class="span8" id="jekyll-page-content">
<div class="page-header">
<h1>SMART Container Javascript Libraries <small></small></h1>
</div>
<div id="toc"> </div>
<div class='simple_small_box'>Help us improve! You can correct errors or add to this page by clicking
<a class='githublink' href=''>here</a> to edit this page on Github.
</div>
<h2>What is smart-api-container.js?</h2>
<p><code>smart-api-container.js</code> enables a SMART container to talk with SMART apps,
establishing inter-frame messaging to pass data and notifications between
application and container.</p>
<div class='simple_box'>
N.B. <code>smart-api-container.js</code> is for SMART container developers, not SMART
app developers!
</div>
<p><code>smart-api-container.js</code> is used by SMART containers such as electronic medical
records platforms. It is a key component that helps turn ordinary EMRs into
SMART containers. If you're a SMART app developer, you don't need to worry about
the api-container, since it sits on the other side of the interface between your
SMART Connect app and the data it consumes.</p>
<h2>Using <code>smart-api-container.js</code></h2>
<p>There are two broad steps involved in turning your ordinary EMR into a SMART
container:</p>
<ol>
<li>Expose the SMART REST API on your server</li>
<li>Offer the SMART Connect API on your Web site</li>
</ol>
<p>This document focuses on #2.</p>
<h2>Including the Javascript Files</h2>
<p>SMART containers the provide SMART Connect API on their Web site by including
(or otherwise loading) three key javascript files: jQuery, jschannel, and
<code>smart-api-container</code>. The simplest way is to include the following script tags in
your HTML:</p>
<div class="highlight"><pre><code class="html"> <span class="nt"><script </span><span class="na">src=</span><span class="s">"http://ajax.googleapis.com/ajax/libs/jquery/1/jquery.min.js"</span><span class="nt">></script></span>
<span class="nt"><script </span><span class="na">src=</span><span class="s">"http://sandbox.smartplatforms.org/static/smart_common/resources/jschannel.js"</span><span class="nt">></script></span>
<span class="nt"><script </span><span class="na">src=</span><span class="s">"http://sandbox.smartplatforms.org/static/smart_common/resources/smart-api-container.js"</span><span class="nt">></script></span>
</code></pre>
</div>
<p>If your existing JavaScript codebase employs the '$' variable and you don't want
jQuery to clobber that namespace, you might also want to call:</p>
<div class="highlight"><pre><code class="html"> <span class="nt"><script </span><span class="na">type=</span><span class="s">"text/javascript"</span><span class="nt">></span><span class="nx">jQuery</span><span class="p">.</span><span class="nx">noConflict</span><span class="p">();</span><span class="nt"></script></span>
</code></pre>
</div>
<h2>Exposing the SMART Connect Interface</h2>
<h3>Instantiate a <code>SMART_CONNECT_HOST</code></h3>
<p><code>smart-api-container</code> attempts to handle the generic messaging and data routing
that SMART Connect apps require. To get things started, first instantiate a
<code>SMART_CONNECT_HOST</code> object. By convention, we'll call it <code>SMART_HOST</code></p>
<div class="highlight"><pre><code class="javascript"> <span class="kd">var</span> <span class="nx">SMART_HOST</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">SMART_CONNECT_HOST</span><span class="p">();</span>
</code></pre>
</div>
<h3>Override <code>SMART_HOST.get_credentials(app_instance, callback)</code></h3>
<p><code>get_credentials</code> is called automatically when a new app launches. Its job is to
provide the fledgling app with SMART REST tokens, formatted as an App Instances
Credential object (details below).</p>
<ul>
<li>Input: App Instance object with UUID, context (details below)</li>
<li>Callback with: App Instance Credentials object (details below)</li>
</ul>
<h3>Override <code>SMART_HOST.get_iframe(app_instance, callback)</code></h3>
<p><code>get_credentials</code> is called automatically when a new app launches -- right after
<code>get_credentials</code>. Its job is to provide the fledgling app with an empty <code><iframe></code>
DOM element in which to render.</p>
<ul>
<li>Input: App Instance object with UUID, context, credentials (details below)</li>
<li>Callback with: iframe DOM ojbect</li>
</ul>
<h3>Override <code>SMART_HOST.handle_api(app_instance, api_call, callback_success, callback_error)</code></h3>
<p><code>handle_api</code> is called whenever an already-running app needs to make a API call
with SMART CONNECT. Its job is to obtain the results of the specified API call
and return them back to the app.</p>
<ul>
<li>Inputs:
<ul>
<li>App Instance object with UUID, context, credentials (details below).</li>
<li>API Call object with method, func, params (details below)</li>
</ul></li>
<li>Callback on success with: <code>callback_success({'contentType': string, data: string})</code></li>
<li>Callback on error with: <code>callback_error(http_status, {'contentType': string, data: string})</code></li>
</ul>
<p>Note: your SMART Container may override additional functions if needed. Four
functions are provided as hooks for this purpose:</p>
<ul>
<li><code>SMART_HOST.on_app_launch_begin</code></li>
<li><code>SMART_HOST.on_app_launch_complete</code></li>
<li><code>SMART_HOST.on_app_launch_delegated_begin</code></li>
<li><code>SMART_HOST.on_app_launch_delegated_complete</code></li>
</ul>
<p>The framework calls these functions at the beginning and end of launch (and
delegated launch) operations.</p>
<h3>Launch an app</h3>
<p>Your Container should provide some way for a user to trigger the launch of an
app, for instance by clicking on the app's icon in a sidebar. When this occurs,
you'll need to notify the <code>SMART_CONNECT_HOST</code> that an app launch has been
requested. This will instigate the app launch process, beginning with the
creation of an <code>app_instance</code> with a unique ID. The <code>SMART_CONNECT_HOST</code> uses
<code>app_instance</code> objects to keep track of the currently-running apps.</p>
<p><code>SMART_HOST.launch_app(manifest, context, options)</code></p>
<ul>
<li>Inputs:
<ul>
<li>SMART Manifest JSON (see below)</li>
<li>App Instance Context object (see below)</li>
<li>JSON object the container may optionally attach to the new app instance </li>
</ul></li>
</ul>
<h3>Subscribe to App Notifications</h3>
<p>Apps that you've launch may send notifications and requests. For example, an app
that desires more screen real estate may sent a <code>request_fullscreen</code>
notification. To subscribe to a notification, call <code>SMART_HOST.on</code> as in the
example below:</p>
<div class="highlight"><pre><code class="javascript"> <span class="nx">SMART_HOST</span><span class="p">.</span><span class="nx">on</span><span class="p">(</span><span class="s2">"request_fullscreen"</span><span class="p">,</span> <span class="kd">function</span><span class="p">(</span><span class="nx">app_instance</span><span class="p">)</span> <span class="p">{</span>
<span class="nx">$</span><span class="p">(</span><span class="nx">app_instance</span><span class="p">.</span><span class="nx">iframe</span><span class="p">)</span>
<span class="p">.</span><span class="nx">css</span><span class="p">({</span>
<span class="nx">position</span><span class="o">:</span> <span class="s1">'fixed'</span><span class="p">,</span>
<span class="nx">width</span><span class="o">:</span> <span class="s1">'100%'</span><span class="p">,</span>
<span class="nx">height</span><span class="o">:</span> <span class="s1">'100%'</span><span class="p">,</span>
<span class="nx">left</span><span class="o">:</span><span class="mi">0</span><span class="p">,</span>
<span class="nx">top</span><span class="o">:</span><span class="mi">0</span>
<span class="p">});</span>
<span class="p">});</span>
</code></pre>
</div>
<h3>Send Notifications to an App</h3>
<p>When important events occur, you should notify any running apps.</p>
<ul>
<li><code>backgrounded</code> when an app instance is hidden from view</li>
<li><code>foregrounded</code> when an app instance is restored to view</li>
<li><code>destroyed</code> when an app instance is permanently closed</li>
</ul>
<p>For example, if you permit a user to hide an app, you should call:
<code>SMART_HOST.notify_app(app_instance, "backgrounded");</code></p>
<p>And if you restore it to view you should call:
`SMART_HOST.notify_app(app_instance, "foregrounded");</p>
<h3>Closing Apps when the Patient Record Context Changes</h3>
<p>The SMART Connect API works in a "one patient record at a time" paradigm: that
is, within a given browser window, there is one "current patient record" in
context, and all running apps share that context. When the patient record
context changes, the set of running apps is effectively cleared by calling:</p>
<p><code>SMART_HOST.record_context_changed();</code></p>
<p>This will close all currently-running apps -- so apps never have to deal with a
context change.</p>
<p>You may want your container to automatically launch new apps after the record
context changes. In this case, you can trigger the appropriate logic by
defining a <code>handle_context_changed</code> function:</p>
<div class="highlight"><pre><code class="javascript"> <span class="nx">SMART_HOST</span><span class="p">.</span><span class="nx">handle_context_changed</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(){</span>
<span class="c1">// your code here</span>
<span class="p">};</span>
</code></pre>
</div>
<h2>Understanding App Instance, Manifest, and API Call JavaScript Objects</h2>
<h3>App Instance Object</h3>
<p>The <code>SMART_CONNECT_HOST</code> interface uses plain-old JavaScript objects to represent
app instances as follows:</p>
<div class="highlight"><pre><code class="javascript"> <span class="p">{</span>
<span class="nx">uuid</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// unique ID for this instance of the app (new with each launch.)</span>
<span class="nx">manifest</span><span class="o">:</span> <span class="o"><</span><span class="nx">SMART</span> <span class="nx">App</span> <span class="nx">Manifest</span> <span class="nx">JSON</span> <span class="nx">structure</span><span class="o">></span><span class="p">,</span> <span class="c1">// includes app ID, URL, etc. (see below)</span>
<span class="nx">iframe</span><span class="o">:</span> <span class="o"><</span><span class="nx">iframe</span><span class="o">></span><span class="p">,</span> <span class="c1">// DOM iframe element in which the app instance should render.</span>
<span class="c1">// UI apps need user and patient context; Frame UI apps need user context.</span>
<span class="nx">context</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">user</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">id</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// User ID assigned by the SMART Container</span>
<span class="nx">full_name</span><span class="o">:</span> <span class="s2">"string"</span> <span class="c1">// Flattened string representation of the user's name</span>
<span class="p">},</span>
<span class="nx">record</span><span class="o">:</span> <span class="p">{</span>
<span class="nx">id</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// Patient Record ID assigned by the SMART Container</span>
<span class="nx">full_name</span><span class="o">:</span> <span class="s2">"string"</span> <span class="c1">// Flattened string representation of the patient's name</span>
<span class="p">}</span>
<span class="p">},</span>
<span class="nx">credentials</span><span class="o">:</span> <span class="o"><</span><span class="nx">SMART</span> <span class="nx">Credentials</span> <span class="nx">JSON</span> <span class="nx">structure</span><span class="o">></span> <span class="c1">// see below</span>
<span class="p">}</span>
</code></pre>
</div>
<h3>App Instance Credentials</h3>
<p>To support REST apps, your SMART Container should generate OAuth tokens each
time an app launches. The OAuth tokens are provided to the app as part of a
credentials JavaScript object, which is automatically incorporated into the
<code>app_instance</code> object. The credentials object includes:</p>
<div class="highlight"><pre><code class="javascript"> <span class="p">{</span>
<span class="nx">api_base</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// Base URL for the container's SMART API</span>
<span class="nx">rest_token</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// SMART REST Token bound to this user/patient/session</span>
<span class="nx">rest_secret</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// SMART REST Secret bound to this user/patient/session</span>
<span class="nx">oauth_header</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// OAuth header string embedding context & tokens (see below)</span>
<span class="p">}</span>
</code></pre>
</div>
<p>The <code>oauth_header</code> field is particularly important, since it's sent to the app
automatically, for a one-step way for the app to obtain access to the in-context
record. The <code>oauth_header</code> is a string representing a well-formed OAuth header,
which means that it must supply:</p>
<ul>
<li><code>oauth_nonce</code>: a one-time value that will not be sent again to this app</li>
<li><code>oauth_timestamp</code>: current UNIX epoch time</li>
<li><code>oauth_signature_method</code>: "HMAC-SHA1"</li>
<li><code>oauth_version</code>: "1.0"</li>
<li><code>oauth_consumer_key</code>: the consumer key that your SMART container has assigned to the app being launched</li>
<li><code>oauth_signature</code>: a computed signature for the HTTP GET of this app's index.html</li>
</ul>
<p>The following SMART-specific fields are also required, to provide the launching
app with necessary context:</p>
<ul>
<li><code>smart_app_id</code>: the ID of the app being launched (usually the same as the app's OAuth consumer key)</li>
<li><code>smart_record_id</code>: the ID of the patient record on which the app is being launched (should match context.record.id)</li>
<li><code>smart_user_id</code>: the ID of the user launching the app (should match context.user.id)</li>
<li><code>smart_container_api_base</code>: the base REST URL of the SMART container launching the app (no trailing slash)</li>
<li><code>smart_oauth_token</code>: an OAuth token that the app can use to sign requests for the current session</li>
<li><code>smart_oauth_token_secret</code>: an OAuth secret that the app can use to sign requests for the current session</li>
</ul>
<p>Here's an example of a fully-formed <code>oauth_header</code>s, with line breaks inserted for
clarity:</p>
<pre><code>'oauth_header' : 'OAuth realm="",
smart_record_id="1768562",
smart_app_id="problem-list%40apps.smartplatforms.org",
smart_user_id="joshmandel%40smart.org",
smart_oauth_token_secret="GHY2zhTL6oG1XLwvWHRB",
smart_oauth_token="Iet6gX4NMbPHjFYBhLkm",
smart_container_api_base="http%3A%2F%2Fsandbox-api.smartplatforms.org",
oauth_signature="QMVJcONlB/O53UUNTpkySuvT+Og%3D",
oauth_nonce="YiAs73cBx7QSO69bpLvh",
oauth_timestamp="1305921820",
oauth_signature_method="HMAC-SHA1",
oauth_version="1.0",
oauth_consumer_key="problem-list%40apps.smartplatforms.org"'
</code></pre>
<h3>API Call Object</h3>
<p>When an app makes an API Call, your handler function will be invoked with an
argument that looks like:</p>
<div class="highlight"><pre><code class="javascript"> <span class="p">{</span>
<span class="nx">type</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// HTTP method (e.g. "GET")</span>
<span class="nx">func</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// URL relative to container base (e.g. "/apps/manifests")</span>
<span class="nx">contentType</span><span class="o">:</span> <span class="s2">"string"</span><span class="p">,</span> <span class="c1">// sent to server (e.g. "application/x-www-form-urlencoded")</span>
<span class="nx">params</span><span class="o">:</span> <span class="o"><</span><span class="nx">object</span><span class="o">></span> <span class="c1">// JS Object containing key/value URL parameters</span>
<span class="p">}</span>
</code></pre>
</div>
<p>You can use this object to determine how to respond appropriately.</p>
<h3>SMART Manifest Object</h3>
<p>You'll provide the <code>SMART_CONNECT_HOST</code> with details about an app to launch by
passing a JavaScript manifest object that looks like the one below. For more
details, see App Manifest Documentation.</p>
<div class="highlight"><pre><code class="javascript"> <span class="p">{</span>
<span class="s2">"name"</span> <span class="o">:</span> <span class="s2">"Med List"</span><span class="p">,</span>
<span class="s2">"description"</span> <span class="o">:</span> <span class="s2">"Display medications in a table or timeline view"</span><span class="p">,</span>
<span class="s2">"author"</span> <span class="o">:</span> <span class="s2">"Josh Mandel, Children's Hospital Boston"</span><span class="p">,</span>
<span class="s2">"id"</span> <span class="o">:</span> <span class="s2">"med-list@apps.smartplatforms.org"</span><span class="p">,</span>
<span class="s2">"version"</span> <span class="o">:</span> <span class="s2">".1a"</span><span class="p">,</span>
<span class="s2">"mode"</span> <span class="o">:</span> <span class="s2">"ui"</span><span class="p">,</span>
<span class="s2">"scope"</span><span class="o">:</span> <span class="s2">"record"</span><span class="p">,</span>
<span class="s2">"icon"</span> <span class="o">:</span> <span class="s2">"http://app-server/framework/med_list/icon.png"</span><span class="p">,</span>
<span class="s2">"index"</span><span class="o">:</span> <span class="s2">"http://app-server/framework/med_list/index.html"</span>
<span class="p">}</span>
</code></pre>
</div>
<h2>A "working" example</h2>
<p>Here's a complete example of a SMART Container. This container implements only
one API call: (<code>GET medications</code>), and displays an alert if the contained app
attempts to call any other function.</p>
<p>You can view the example live at [1] -- and be sure to view the source code!</p>
<h2>Some manifests online</h2>
<p>If you're building a container, here are some manifests you can try loading to
get started, hosted in our sandbox</p>
<p><a href="http://sample-apps.smartplatforms.org/framework/got_statins/smart_manifest.json"><a href="http://sample-apps.smartplatforms.org/framework/got_statins/smart_manifest.json">http://sample-apps.smartplatforms.org/framework/got_statins/smart_manifest.json</a></a>
<br>
<a href="http://sample-apps.smartplatforms.org/framework/cardio_risk_viz/smart_manifest.json"><a href="http://sample-apps.smartplatforms.org/framework/cardio_risk_viz/smart_manifest.json">http://sample-apps.smartplatforms.org/framework/cardio_risk_viz/smart_manifest.json</a></a>
<br>
<a href="http://sample-apps.smartplatforms.org/framework/med_list/smart_manifest.json"><a href="http://sample-apps.smartplatforms.org/framework/med_list/smart_manifest.json">http://sample-apps.smartplatforms.org/framework/med_list/smart_manifest.json</a></a>
<br>
<a href="http://sample-apps.smartplatforms.org/framework/problem_list/smart_manifest.json"><a href="http://sample-apps.smartplatforms.org/framework/problem_list/smart_manifest.json">http://sample-apps.smartplatforms.org/framework/problem_list/smart_manifest.json</a></a></p>
</div>
</div>
</section>
</div>
<footer>
<div>
<a href='http://smartplatforms.org'>SMART Platforms</a> © 2012
</div>
</footer>
</div>
<script src="//ajax.googleapis.com/ajax/libs/jquery/1.7.1/jquery.min.js"></script>
<script>window.jQuery || document.write('<script src="/assets/themes/twitter-2.0/js/jquery.min.js"><\/script>')</script>
<script src="/assets/themes/twitter-2.0/js/bootstrap_aks.js"></script>
<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-33617191-1']);
_gaq.push(['_trackPageview']);
(function() {
var ga = document.createElement('script'); ga.type = 'text/javascript'; ga.async = true;
ga.src = ('https:' == document.location.protocol ? 'https://ssl' : 'http://www') + '.google-analytics.com/ga.js';
var s = document.getElementsByTagName('script')[0]; s.parentNode.insertBefore(ga, s);
})();
</script>
<script src="/assets/app.js?v=0.1"></script>
<script>Toc.init($("#jekyll-page-content"), $("#toc"));</script>
</body>
</html>