← Back to branch summary

~azzar1/unity/add-show-desktop-key

« back to all changes in this revision

Viewing changes to www/media/common/util.js

  • Committer: mattgiuca
  • Date: 2008-03-07 15:12:02 UTC
  • Revision ID: svn-v3-trunk0:2b9c9e99-6f39-0410-b283-7f802c844ae2:trunk:669
Timestamps are now stored within the program as Python "time" module's
    "struct_time" objects, rather than strings directly from the DB.
    They are parsed into struct_time objects when reading from the db.
    They are formatted into SQL Timestamp strings when writing to the db.
    This allows them to be manipulated and compared within the program.

common.db: _escape now accepts struct_time objects - it formats them into SQL
            time strings.
common.user: The User constructor now parses "acct_exp", "pass_exp" and
            "last_login" fields as timestamp strings, and stores them
            internally as struct_time.
tutorialservice: When recording a submission, the "date" field is now stored
            as a struct_time, not a formatted string.
login.py: When logging in, uncommented call to write last_login to the DB,
            passing the current local time. (This now works correctly).
            Note that this is done after retrieving the user details, so the
            value of last_login stored in the session is the _old_ last login,
            not the new one (this is intentional).

(With Tom Conway).

Show diffs side-by-side

added added

removed removed

Lines of Context:
www/media/common/util.js
278
278
            query_string += "&" + encodeURIComponent(arg_key) + "=" +
279
279
                encodeURIComponent(arg_val);
280
280
    }
281
 
    if (query_string == "")
282
 
        query_string = null;
283
 
    else
 
281
    if (query_string != "")
284
282
        /* Drop the first "&" */
285
283
        query_string = query_string.substr(1);
286
284
 
321
319
    else if (("args" in obj) && obj.args != null)
322
320
        query_string = make_query_string(obj.args);
323
321
 
324
 
    if (query_string != null)
 
322
    if (query_string != "" && query_string != null)
325
323
        url += "?" + query_string;
326
324
 
327
325
    return url;
343
341
    return path;
344
342
}
345
343
 
 
344
/** Writes a JSONable object to the cookie under a particular key
 
345
 * (JSON encoded and URL encoded).
 
346
 */
 
347
function write_cookie(key, value)
 
348
{
 
349
    var sendstr = encodeURIComponent(key) + "="
 
350
        + encodeURIComponent(JSON.stringify(value))
 
351
        + "; path=" + urlencode_path(root_dir);
 
352
    /* This actually just assigns to the key, not replacing the whole cookie
 
353
     * as it appears to. */
 
354
    document.cookie = sendstr;
 
355
}
 
356
/** Reads a cookie which has a JSONable object encoded as its value.
 
357
 * Returns the object, parsed from JSON.
 
358
 */
 
359
function read_cookie(key)
 
360
{
 
361
    var cookies = document.cookie.split(";");
 
362
    var checkstart = encodeURIComponent(key) + "=";
 
363
    var checklen = checkstart.length;
 
364
    for (var i=0; i<cookies.length; i++)
 
365
    {
 
366
        var cookie = cookies[i];
 
367
        while (cookie[0] == ' ')
 
368
            cookie = cookie.substr(1);
 
369
        if (cookie.substr(0, checklen) == checkstart)
 
370
        {
 
371
            var valstr = cookie.substr(checklen);
 
372
            valstr = decodeURIComponent(valstr);
 
373
            return JSON.parse(valstr);
 
374
        }
 
375
    }
 
376
}
 
377
 
346
378
/** Given an argument map, as output in the args parameter of the return of
347
379
 * parseurl, gets the first occurence of an argument in the URL string.
348
380
 * If the argument was not found, returns null.
521
553
    arr.splice(j, i-j);
522
554
}
523
555
 
524
 
/** Makes an XMLHttpRequest call to the server. Waits (synchronously) for a
525
 
 * response, and returns an XMLHttpRequest object containing the completed
526
 
 * response.
 
556
/** Shallow-clones an object */
 
557
function shallow_clone_object(obj)
 
558
{
 
559
    o = {};
 
560
    for (k in obj)
 
561
        o[k] = obj[k];
 
562
    return o;
 
563
}
 
564
 
 
565
/** Returns a new XMLHttpRequest object, in a somewhat browser-agnostic
 
566
 * fashion.
 
567
 */
 
568
function new_xmlhttprequest()
 
569
{
 
570
    try
 
571
    {
 
572
        /* Real Browsers */
 
573
        return new XMLHttpRequest();
 
574
    }
 
575
    catch (e)
 
576
    {
 
577
        /* Internet Explorer */
 
578
        try
 
579
        {
 
580
            return new ActiveXObject("Msxml2.XMLHTTP");
 
581
        }
 
582
        catch (e)
 
583
        {
 
584
            try
 
585
            {
 
586
                return new ActiveXObject("Microsoft.XMLHTTP");
 
587
            }
 
588
            catch (e)
 
589
            {
 
590
                throw("Your browser does not support AJAX. "
 
591
                    + "IVLE requires a modern browser.");
 
592
            }
 
593
        }
 
594
    }
 
595
}
 
596
 
 
597
/** Makes an asynchronous XMLHttpRequest call to the server.
 
598
 * Sends the XMLHttpRequest object containing the completed response to a
 
599
 * specified callback function.
527
600
 *
 
601
 * \param callback A callback function. Will be called when the response is
 
602
 *      complete. Passed 1 parameter, an XMLHttpRequest object containing the
 
603
 *      completed response.
528
604
 * \param app IVLE app to call (such as "fileservice").
529
605
 * \param path URL path to make the request to, within the application.
530
606
 * \param args Argument object, as described in parse_url and friends.
532
608
 * \param content_type String, optional. Only applies if method is "POST".
533
609
 *      May be "application/x-www-form-urlencoded" or "multipart/form-data".
534
610
 *      Defaults to "application/x-www-form-urlencoded".
535
 
 * \return An XMLHttpRequest object containing the completed response.
536
611
 */
537
 
function ajax_call(app, path, args, method, content_type)
 
612
function ajax_call(callback, app, path, args, method, content_type)
538
613
{
539
614
    if (content_type != "multipart/form-data")
540
615
        content_type = "application/x-www-form-urlencoded";
544
619
     * (This is not checked against anywhere else, it is solely defined and
545
620
     * used within this function) */
546
621
    var boundary = "48234n334nu7n4n2ynonjn234t683jyh80j";
547
 
    var xhr = new XMLHttpRequest();
 
622
    var xhr = new_xmlhttprequest();
 
623
    xhr.onreadystatechange = function()
 
624
        {
 
625
            if (xhr.readyState == 4)
 
626
            {
 
627
                callback(xhr);
 
628
            }
 
629
        }
548
630
    if (method == "GET")
549
631
    {
550
632
        /* GET sends the args in the URL */
551
633
        url = build_url({"path": path, "args": args});
552
 
        /* open's 3rd argument = false -> SYNCHRONOUS (wait for response)
553
 
         * (No need for a callback function) */
554
 
        xhr.open(method, url, false);
 
634
        /* open's 3rd argument = true -> asynchronous */
 
635
        xhr.open(method, url, true);
555
636
        xhr.send(null);
556
637
    }
557
638
    else
558
639
    {
559
640
        /* POST sends the args in application/x-www-form-urlencoded */
560
641
        url = encodeURI(path);
561
 
        xhr.open(method, url, false);
 
642
        xhr.open(method, url, true);
562
643
        var message;
563
644
        if (content_type == "multipart/form-data")
564
645
        {
571
652
            xhr.setRequestHeader("Content-Type", content_type);
572
653
            message = make_query_string(args);
573
654
        }
 
655
        xhr.setRequestHeader("Content-Length", message.length);
574
656
        xhr.send(message);
575
657
    }
576
 
    return xhr;
577
658
}
578
659