IT Lesson

• Enriched wheat flour
• Liver
• Cabbage
• Spinach
• Navy beans

When it comes to writing UI applications in Apps Script, we get a lot of requests to support event callbacks that are handled in the user’s browser. For example, if your application has a form, you may want to disable a button after it is clicked the first time. Until now, the only way to do that would be by using an event handler on the server to disable that button. Using Client Handlers, your application can now respond to events in the browser without the need to perform a round trip to Google Apps Script servers.

By cutting out the round trip to the server, your app can respond instantly to user input. Imagine, for example, you want to provide your users with instant feedback within your app when a user types text where a number is expected. Ideally, you would want to warn users as they type the value, instead of waiting until the form is submitted. Having a server event handler for each keystroke is definitely overkill for such a simple and common task. Luckily, these use cases are now supported with Apps Script’s new Client Handlers and validators!

Let’s take a look at some code.

Client Handlers

A Client Handler allows you to react to any event in a browser without connecting to the server. What you can do in response to an event is limited to a set of predefined common actions, but you have a lot of flexibility in making your app more responsive.

You can use Client Handlers in any UiApp regardless of whether you are embedding in a Spreadsheet or a Sites Page or publishing as a service. This simple application enables the user to click a button to display the classic “Hello world” message:

function doGet() {
  var app = UiApp.createApplication();
  var button = app.createButton("Say Hello");
  
  // Create a label with the "Hello World!" text and hide it for now
  var label = app.createLabel("Hello World!").setVisible(false);
  
  // Create a new handler that does not require the server.
  // We give the handler two actions to perform on different targets.
  // The first action disables the widget that invokes the handler
  // and the second displays the label.
  var handler = app.createClientHandler()
    .forEventSource().setEnabled(false)
    .forTargets(label).setVisible(true);
  
  // Add our new handler to be invoked when the button is clicked
  button.addClickHandler(handler);
  
  app.add(button);
  app.add(label);
  return app;
}

The Client Handlers in the above example are set up in two steps:

1. Create a Client Handler just as we would create the server handlers you all know and love.
2. Define the target widget for this handler. The target widget is the widget on which the handler will take action. We set the handler’s target in one of two ways: (a) By using the forTargets method to define the target widget. (b) By using the forEventSource method which lets widget wire itself to the client handler.

In the above example, we set the handler’s target to be the event source, so that it will apply to the button that is clicked. Finally, we define the action that the handler should take, in this case disabling the button using setEnabled(false). Aside from setEnabled, you can also change styles using setStyleAttribute, change text using setText, and so on. One Client Handler can perform multiple actions — just chain them together - and you can even change the target so that some actions apply to one set of widgets and some actions to another set. In our example, along with disabling the button, we set the handler to display the label when it is invoked, using setVisible.

Validators

Another new addition to Apps Script is support for validators in handlers. Validators allow handlers to check simple and complex conditions before they are invoked. For example, the following application adds two numbers given by the user, while using validators to make sure the server is only called if both of the text boxes contain numbers.

function doGet() {
  var app = UiApp.createApplication();
  
  // Create input boxes and button
  var textBoxA = app.createTextBox().setId(textBoxA).setName(textBoxA);
  var textBoxB = app.createTextBox().setId(textBoxB).setName(textBoxB);
  var addButton = app.createButton("Add");

  // Create a handler to call the adding function
  // Two validations are added to this handler so that it will 
  // only invoke add if both textBoxA and textBoxB contain
  // numbers
  var handler = app.createServerClickHandler(add)
      .validateNumber(textBoxA)
      .validateNumber(textBoxB)
      .addCallbackElement(textBoxA)
      .addCallbackElement(textBoxB);
  
  addButton.addClickHandler(handler)
  
  app.add(textBoxA);
  app.add(textBoxB);
  app.add(addButton);
  return app;
}

function add(e) {
  var app = UiApp.getActiveApplication();
  var result = parseFloat(e.parameter.textBoxA) + parseFloat(e.parameter.textBoxB);
  var newResultLabel = app.createLabel("Result is: " + result);
  app.add(newResultLabel);
  return app;
}

There’s a variety of validators to choose from that perform different tasks. You can verify the input to be a number, an integer, or an e-mail address. You can check for a specific length, or for any numerical value in a defined range. You can also use general regular expressions. Lastly, each validator has its negation.

Note that validators work with both client and server handlers.

Putting it all together

Of course, validators and Client Handlers work best together. For example, in our addition application above, the “Add” button should be disabled as long as the current input is not numeric. We would also like to let the user know why the button is disabled by displaying an error message. To do so, we combine the power of server handlers, Client Handlers, and validators in the following way:

function doGet() {
  var app = UiApp.createApplication();
  
  // Create input boxes and button.
  var textBoxA = app.createTextBox().setId(textBoxA).setName(textBoxA);
  var textBoxB = app.createTextBox().setId(textBoxB).setName(textBoxB);
  var addButton = app.createButton("Add").setEnabled(false);
  var label = app.createLabel("Please input two numbers");

  // Create a handler to call the adding function.
  // Two validations are added to this handler so that it will 
  // only invoke add if both textBoxA and textBoxB contain
  // numbers.
  var handler = app.createServerClickHandler(add)
      .validateNumber(textBoxA)
      .validateNumber(textBoxB)
      .addCallbackElement(textBoxA)
      .addCallbackElement(textBoxB);
  
  // Create handler to enable the button well all input is legal
  var onValidInput = app.createClientHandler()
      .validateNumber(textBoxA)
      .validateNumber(textBoxB)
      .forTargets(addButton).setEnabled(true)
      .forTargets(label).setVisible(false);
  
  // Create handler to mark invalid input in textBoxA and disable the button
  var onInvalidInput1 = app.createClientHandler()
      .validateNotNumber(textBoxA)
      .forTargets(addButton).setEnabled(false)
      .forTargets(textBoxA).setStyleAttribute("color", "red")
      .forTargets(label).setVisible(true);
  
  // Create handler to mark the input in textBoxA as valid
  var onValidInput1 = app.createClientHandler()
      .validateNumber(textBoxA)
      .forTargets(textBoxA).setStyleAttribute("color", "black");

  // Create handler to mark invalid input in textBoxB and disable the button
  var onInvalidInput2 = app.createClientHandler()
      .validateNotNumber(textBoxB)
      .forTargets(addButton).setEnabled(false)
      .forTargets(textBoxB).setStyleAttribute("color", "red")
      .forTargets(label).setVisible(true);

  // Create handler to mark the input in textBoxB as valid
  var onValidInput2 = app.createClientHandler()
      .validateNumber(textBoxB)
      .forTargets(textBoxB).setStyleAttribute("color", "black");

  // Add all the handlers to be called when the user types in the text boxes
  textBoxA.addKeyUpHandler(onInvalidInput1);
  textBoxB.addKeyUpHandler(onInvalidInput2);
  textBoxA.addKeyUpHandler(onValidInput1);
  textBoxB.addKeyUpHandler(onValidInput2);
  textBoxA.addKeyUpHandler(onValidInput);
  textBoxB.addKeyUpHandler(onValidInput);
  addButton.addClickHandler(handler);
  
  app.add(textBoxA);
  app.add(textBoxB);
  app.add(addButton);
  app.add(label);
  return app;
}

function add(e) {
  var app = UiApp.getActiveApplication();
  var result = parseFloat(e.parameter.textBoxA) + parseFloat(e.parameter.textBoxB);
  var newResultLabel = app.createLabel("Result is: " + result);
  app.add(newResultLabel);
  return app;
}

All of these features can be used to create more advanced and responsive applications. Client handlers can be used to change several attributes for widgets, and validators can help you check a variety of different conditions from well formed email addresses to general regular expressions.

If youd like to chat about these new features or have other questions about Google Apps Script, please join several members of the Apps Script team in the Google Apps Developer Office Hours on Google+ Hangouts tomorrow, Wednesday November 16th at 10am PST. You can also ask questions at any time in the Apps Script forum.

Omer Strulovich   profile Omer was an intern on the Google Docs team for the summer of 2011. He is now back to pursuing his master’s degree in the field of cryptography.

Here’s the scenario: you create a form, you have a script that triggers onFormSubmit and all is well... until it gets popular. Occasionally you start having interlacing modifications from separate invocations of your script to the spreadsheet. Clearly, this kind of interlacing is not what you intended for the script to do. Up until now, there was no good solution to this problem -- except to remain unpopular or just be lucky. Neither are great solutions.

Now, my friend, you are in luck! We’ve just launched the LockService to deal with exactly this problem. The LockService allows you to have only one invocation of the script or portions thereof run at a time. Others that would’ve run at the same time can now be made to wait nicely in line for their turn. Just like the line at the checkout counter.

The LockService can provide two different kinds of locks-- one that locks for any invocation of your script, called a public lock, and another that locks only invocations by the same user on your script, called a private lock. If you’re not sure, using a public lock is the safest bet.

For example, in the scenario in the previous paragraph you would want something like this:

function onFormSubmit() {
  // we want a public lock, one that locks for all invocations
  var lock = LockService.getPublicLock();
  lock.waitLock(30000);  // wait 30 seconds before conceding defeat.
  // got the lock, you may now proceed
  ...whatever it used to do here....
  lock.releaseLock();
}

It’s best to release the lock at the end, but if you don’t, any locks you hold will be released at the end of script execution. How long should you wait? It depends on two things mainly: how long the thing you’re going to do while holding the lock takes, and how many concurrent executions you expect. Multiply those two and you’ll get your timeout. A number like 30 seconds should handle a good number of cases. Another way to pick the number is frankly to take an educated guess and if you guess too short, the script will occasionally fail.

If you want to avoid total failure if you can’t get the lock, you also have the option trying to get the lock and doing something else in the event of not being able to get it:

function someFunction() {
  var lock = LockService.getPublicLock();
  if (lock.tryLock(30000))  {
    // I got the lock!  Wo000t!!!11 Do whatever I was going to do!
  } else {
    // I couldn’t get the lock, now for plan B :(
    GmailApp.sendEmail(“admin@example.com”, “epic fail”,
        “lock acquisition fail!”);
  }
}

So now your scripts can be as popular as they can get with no worries about messing up shared resources due to concurrent edits! Check out the LockService documentation for more information.

Drew Csillag Drew is a Software Engineer and Manager at Google on the Google Apps Script project, based in New York. He previously worked on Billing at Google, and for the 13 years before, he has worked on everything from hardware up to GUI frontends and everything in between.

Directory API

Reports API

Google+ Domains API

Ajay Guwalani   Ajay Guwalani is Product Manager on Google Apps Admin APIs. His current focus is to build next generation admin APIs to make enterprise developers and admins happy.

Editor’s note: This is a guest post by Laura Bârlădeanu, lead programmer at MindMeister.
-- Steve Bazyl

MindMeister is a market innovator for providing collaborative online mind mapping solutions. Launched in May 2007, our site has since attracted hundreds of thousands of businesses, academic institutions and creative consumers who have mapped over 100 million ideas online. We were one of a few web applications invited to take part in the Google Drive launch earlier this year.

Requirements

The goal was to provide users with an intuitive integration between Google Drive and Mindmeister that would cover all the cases provided by the Google Drive guidelines at that time:

• Create mind maps directly from Google Drive
• Open mind map files from Google Drive using MindMeister
• Create a mind map file on Google Drive from MindMeister

Aside from these main integration points, we wanted to make use of the SDK and provide many useful Google Drive features, so we added a few more requirements to the list:

• Export all the user’s maps as a backup .zip file on Google Drive
• Import a file from Google Drive using the Google File Picker
• Attach a file from Google Drive directly to a node in a mind map
• Provide users the possibility to share mind maps with their Google contacts
• Provide users with an application setting that would allow them to sync all their mind maps with Google Drive
• Allow Google users opening the same file from Google Drive to collaborate in real time on the mind map directly in MindMeister
• Enable users to login with their Google account without providing any extra information

Authentication and authorization

Google Drive applications are required to use OAuth 2.0 as an authorization mechanism, and are recommended to use OpenID Connect for login. The authorization scope for Drive files is added by default for all registered drive apps. Additionally, the application can require extra scopes that would fit its needs. For our requirements, we needed the following scopes:

• https://www.googleapis.com/auth/drive.file (Drive)
• https://www.google.com/m8/feeds/ (Contacts)
• https://www.googleapis.com/auth/userinfo.profile (User information)
• https://www.googleapis.com/auth/userinfo.email (User email)

However, we didn’t want the user to turn away from our application by being asked for too many scopes straight from the beginning. Instead, we defined sets of actions that required a subset of these scopes:

• [‘drive’, ‘profile’, ‘email’] - any Google Drive action
• [‘profile’, ‘email’] - login with a Google account
• [‘contacts’, ‘profile’, ‘email’] - access the user’s Google contacts

Whenever the user wanted to execute an action that would require more scopes than they initially provided, we redirected them to a Google authorization dialog that requested the extra scope. Upon authorization, we stored the individual refresh tokens for each combination of scopes in a separate model (UserAppTokens).

Whenever the application needed the refresh token for a set of scopes (eg. for [‘profile’, ‘email’]) it would fetch the refresh token from the database which corresponded to a superset of the required scopes (eg. [‘drive’, ‘profile’, ‘email’] would fit for the required [‘profile’, ‘email’]). The access token would then be obtained from Google and stored in the session for future requests.

Challenges

The main challenge we encountered during design and implementation was dealing with the special cases of multiple users (Google users or internal users) editing on the same map which is a Google Drive file, as well as dealing with the special cases of the map being edited in multiple editors. We also had to find a solution for mapping the Google Drive user’s permissions (owner, reader, or writer) to the MindMeister’s existing permission mechanism.

The MindMeister application is registered for opening four types of files: our own .mind format, MindManager’s .mmap format, Freemind’s .mm format, as well as .xmind. However, since these formats are not 100% compatible with each other, there is always a chance of losing more advanced features when opening a file in a format other than .mind. We wanted to provide the user with the possibility to chose whether the opened file would be saved in its original format, thus risking some features loss, or saving the file in MindMeister format. This option should be per user, per file and with the possibility to be remembered for future files.

Solutions

After analyzing the requirements and the use cases, we designed the following architecture:

Out of sync maps and files

Using the revision fields in both Map and DriveData we always know if the map has been edited on MindMeister’s side without it being synced with the corresponding file on Google Drive. On the other hand, the token field from DriveData represents the file’s MD5 checksum at the moment of the last update and is supplied via the Google Drive SDK. So if the file is edited externally using another application than MindMeister, we have a mechanism in place for detecting this issue and presenting the user with a few courses of action.

Handling 3rd party formats

Upon opening a file that has a different format than .mind, the user is prompted with an option dialog where they can chose if they want the file to be saved back in the same format or in MindMeister’s own format. These options are then remembered in the current session and the per map settings are stored in the extension (the original format) and save_extension (the format to save back in) fields present in the DriveData model.

Handling user’s permissions

A map on MindMeister can always be shared with other MindMeister users and the collaborators can have reading or writing access to the map. However, only some of these users will have a corresponding Google account with access to the MindMeister Google Drive application and furthermore, only some of them will have access to the same file on Google Drive with writing permission. This is why it is important for us to know which users can write back to the file and the solution for these access levels was achieved with the help of the permission field in the DriveDataRight model.

Results

Now more than two weeks on from the Google Drive launch and we can confidently say that our integration was successful, with more than 14,000 new users using Google login and with over 7,000 users that have enabled the Google Drive integration. All in all, the Google Drive SDK was very easy to use and well documented. The developer support, especially, was always there to help and our contacts were open to our suggestions.

Laura Bârlădeanu Laura is the lead programmer at MindMeister, an online mind mapping tool built in HTML5 that features real-time collaboration.

GET http://www.google.com/calendar/feeds/example@google.com/private/full?fields=entry(title,gd:when)

<?xml version="1.0" encoding="UTF-8"?>
<feed xmlns="http://www.w3.org/2005/Atom" xmlns:gd="http://schemas.google.com/g/2005">
 <entry>
   <title type="text">Example meeting</title>
   <gd:when endTime="2010-03-25T09:00:00.000-07:00" startTime="2010-03-25T08:00:00.000-07:00">
     <gd:reminder method="alert" minutes="10"/>
     <gd:reminder method="sms" minutes="10"/>
   </gd:when>
 </entry>
 ... more entries ...
</feed>

PATCH http://www.google.com/calendar/feeds/default/private/full/eventID HTTP/1.1
Content-Type: application/xml
Host: www.google.com
GData-Version: 2
If-Match "FE8LQQJJeSp7IWA6WhVa"

<?xml version="1.0" encoding="UTF-8"?>
<entry>
 <title type="text">Example meeting update</title>
 <gd:when endTime="2010-03-27T10:00:00.000-07:00" startTime="2010-03-27T09:00:00.000-07:00">
   <gd:reminder method="alert" minutes="10"/>
   <gd:reminder method="sms" minutes="10"/>   
 </gd:when>
</entry>

1. To make an actual presentation (e.g. using PowerPoint for what it was meant to be used for)
2. To make printables for your classroom (e.g. the "teacher" way to use PowerPoint! lol!)

• Link to LearnOutLoud.com Free Stuff
• Reference - Learn Out Loud (Wynn Williamson)

WHAT?
LearnOutLoud.com is a one-stop destination for audio and video learning. Its collection allows you to browse over 15,000 educational audio books, MP3 downloads, podcasts, and videos.

JUICE?
As ZaidLearn is really about discovering, exploring, and reflecting free and/or open educational resources and tools, my interest on this site is only for the FREE STUFF. And LearnOutLoud.com has got some really juicy stuff not worth missing, including the:

• Free Directory - LearnOutLoud.com has scoured the Internet to bring you over 500 free audio and video titles (looking at the item numbers, it looks like it is more than 2000 items now, but I suppose that some of the items are in more than one category). Most audio titles can be downloaded in digital formats such as MP3 and most video titles are available to stream online.
• Authors - Complete resource to audio books from some of the greatest authors in self development, business, and more.
• Publishers - Comprehensive database of audio publishers including resources for language learning, rental services, and more.
• Articles - Dozens of free articles covering specific topics with audio & video suggestions to get you learning.
• Podcasts - It offers a number of its own educational podcasts.

In addition, you can enjoy their E-Magazine along with their Free Resource of the Day Email keep you updated on the world of audio & video learning.

Alright, that sounds cool, but what about the proof-of-juice? Here are a few individual podcasts that might get your learning mind ticking a bit:

• Malcolm X - Message To The Grass Roots
• Bill Gates - Software Breakthroughs
• A Conversation with G. Richard Wagoner, Chairman and CEO, General Motors
• The Search - John Battelle Speaks at Google NYC
• Barack Obama - "The Audacity of Hope"
• Thomas L. Friedman - The World is Flat
• A Conversation with Jack Welch
• Hedrick Smith - Is Wal-Mart Good for America?
• Martin Luther King, Jr. - I Have a Dream
• Mohandas Gandhi - A Spiritual Message to the World

I arrest my case :)

Link to site & full report (PDF, 27 pages, 695K)
"The online enrollment projections have been realized, and there is no evidence that enrollments have reached a plateau. Online enrollments continue to grow at rates faster than for the overall student body, and schools expect the rate of growth to further increase:

• Over 1.9 million students were studying online in the fall of 2003.
• Schools expect the number of online students to grow to over 2.6 million by the fall of 2004.
• Schools expect online enrollment growth to accelerate ? the expected average growth rate for online students for 2004 is 24.8%, up from 19.8% in 2003.

Are students as satisfied with online courses as they are with face-to-face instruction?

• 40.7% of schools offering online courses agree that students are at least as satisfied? with their online courses, 56.2% are neutral and only 3.1% disagree.
• Medium and large schools strongly agree (with less than 3% disagreeing).
• The smallest schools (under 1,500 enrollments) are the least positive, but even they have only 5.4% disagreeing compared to 32.9% agreeing.
• Doctoral/Research, Masters, and Associates schools are very positive, Specialized and Baccalaureate schools only slightly less so."

Read the summary (at least) or the full report . This report is excellent (27 pages), and gives us insight to the e-learning or online education state and progress in U.S. higher education.

• thinking less about delivering instruction and more about producing learning,
• reaching out to students through distance education technologies, and
• promoting a strong sense of community among learners.

Indeed, the concept of blended learning may be a synthesis of these areas as the learning environment becomes more learning-centered, with emphasis on active learning through collaboration and social construction of understanding. Such a concept is moving toward O?Banion?s (1997) vision of a learning college as a place where learning comes first and educational experiences are provided for learners anyway, anyplace, and anytime. Graham B. Spanier, president of The Pennsylvania State University, referred to this convergence of online and traditional instruction as the single-greatest unrecognized trend in higher education today (Young, 2002). "