Intuit Partner Platform team blog

Flex 3 in Action: Ch. 23 Debugging, Functional and Unit Testing in Flex

Manning Publications has posted a free pdf of Chapter 23 from their book called "Flex 3 in Action". Chapter 23 includes Debugging, profiling, 3rd party tools, unit testing, and functional testing of Flex Applications.

Flex 3 in Action
Chapter 23
Manning Publishing
http://www.manning.com/ahmed/Flex3-sample-chapter-23.pdf

From the author's blog

Happy Coding,

Jarred

How to manage Relationships between tables in QuickBase for IPP?

How do we handle QuickBase relationships using the Intuit Partner Platform Flex SDK Plugin?

The QuickBase Missing Manual describes the mechanics for creating relationships between tables as well as common use-case relationships. For example, you can think of a one-to-many relation between projects and tasks where each task in the tasks table is linked to a specific project in the projects table. The projects table is referred to as the Master table and the tasks table as the Details table. QuickBase uses the master's key field or the record id# to relate the records between the master and details table.

Note that within QuickBase the only type of relationship you can directly define is 1:many though within your application you can implement a 1:1 relationship by having a back reference many:1 relationship from master to detail and implementing your business logic to enforce the 1:1 nature of the intended relationship. 

Why implement a relationship in the first place?  Quite simply, because once you have a relationship, QuickBase can do a lot of work for you:  fields from the master can be automatically reflected into the details rows (effectively an Inner Left Join for you SQL-nuts) so you don’t need to go look up the master record when you have a detail record in-hand and just need a couple of fields from the master record on a regular basis; and fields from the details table can be summarized in the master record using a variety of summary operators such as Average, Count, Maximum, etc.; they can even be summarized with the equivalent of a “where” clause to summarize only a subset of the details records (i.e. total task hours assigned to the current user).

How does this work with the IPP Flex SDK Plugin? Using DTOs and some of the APIs in the Kingussie framework we can simplify the task of adding records, maintaining relationships and refreshing summary fields.

I have a Developers table as the master table and a Ratings table as the details table. There can be many Ratings records for a single developer and the summary field which is the average rating in the Developers table keeps track of this.

The challenges are

How do we add a record to the ratings table and relate it to a developer record?

How do we refresh the summary field of the developer record in the view when a ratings record related to the developer is added? Normal refresh mechanisms such as those implemented by the QuickBaseDTOArrayCollection will not detect changes to the developer record if all that changed were details records summarized by the developer record, so our app needs to “know” that it has changed something that influences other records and force a refresh.

To add a Ratings record, we first relate it to the Developer record and add it.

                  rating.populateDTO();

                  // Relate the Ratings record to the Developers record

                  model.ratingsDTO.Relateddeveloper = Number(model.developersDTO.rid);
                  var addRatingEvent: QuickBaseEventStoreRecord = new
                       QuickBaseEventStoreRecord(model.RatingsDTO,
                       new KingussieEventCallBack(doRefreshRating));
           
                  addRatingEvent.dispatch();

Where rating is a simple IDNForm.

               <widgets:IDNForm id="rating" dto="{model.ratingsDTO}">
                   <widgets:IDNField fieldLabel="Enter Rating:" fieldName="Rating"/>     
               </widgets:IDNForm>

To refresh the view using the Kingussie event chaining, we define a method doRefreshRating which essentially refreshes the parent record and thereby updates the summary field.

           public function doRefreshRating(data:Object): void
           {
                  // refresh the parent record now
                  var refreshDeveloperEvent: QuickBaseEventRefreshRecord = new
                       QuickBaseEventRefreshRecord(model.developersDTO);
                  refreshDeveloperEvent.dispatch();

                 // refresh the ratings DTO
                  model.ratingsDTO = new Ratings_DTO();
           }

In conclusion, we looked at how to handle relationships between tables, what is a Master table and a Details table, how to link records between the tables and how to automatically refresh summary fields in the parent record.

How is the QuickBaseDTOArrayCollection different from an ArrayCollection?

Apart from the name, there are some important properties and methods that make it more useful in the context of writing your Flex code.

You can leverage the framework and use QuickBaseDTOArrayCollection to keep your data up to date and avoid having to do the low-level programming to acheive the same otherwise.

I'll try and explain this with some very simple code snippets.

The following is defined in the model.

         public var developersDTO: Developers_DTO = new Developers_DTO();
         public var developersList:  QuickBaseDTOArrayCollection ;

where the Developers_DTO is the Data Transfer Object for an individual record and it handles the marshalling and umarshalling of the fields of the record. It is automatically generated as part of the project when you use the "Generate data transfer objects" as part of the IPP plugin.

I instantiate this list in the view in the initPanel() or as appropriate. This indicates what fields of the record you want to retrieve.

model.developersList = new QuickBaseDTOArrayCollection
                   (Developers_DTO, true, "",
                   "Name.Company.EmailContact...", // fields are dot-separated. Not all shown
                   "",
                   "");

You initialize the list, which essentially populates the list, something along the lines of below.

                   model.developersList.initData();

This populated list can then be used as a dataProvider in a DataGrid just like a regular ArrayCollection, through the magic of Flex databinding and the QuickBaseDTOArraycollection's own magic of updating itself when data on the server changes. So, whenever a record is added, updated or deleted by any user (not necessarily the current user) this is reflected in the view.

          <mx:DataGrid id="developersViewGrid" change="true" wordWrap="true" dataProvider="{model.developersList}"

You can also force the update when you know things have changed (i.e. because you stored a record in the current client) as below

          model.developersList.forceUpdate();

Most importantly, by using the QuickBaseDTOArrayCollection to keep your data up to date, your application is imposing the smallest possible burden on the server, in particular, if data isn't changing, you aren't touching the database, and therefore are reducing your usage charges.

It's certainly possible to duplicate the functionality of the QuickBaseDTOArrayCollection yourself using a standard ArrayCollection, but why do all that low-level programming yourself?  Focus on your business logic and let the framework take care of the wiring for you.

You can get more details in the Programmer's Guide.

Setting Up a Co-Development IPP Project in Flex Builder

Hello IPP developers, my name is Jarred Keneally and I am a developer support engineer for the Intuit Partner Platform. After receiving quite a few inquiries as to the best way to setup a co-development IPP project, I though I would blog about the way to do that.

You should know we are working on exciting new developer tools to manage your IPP Projects in release 1.4. Until that release arrives, here is what you can do in the meantime. Please keep in mind this process is only temporary.

These are the steps that are typical of a new IPP project in Flex Builder:

1. Someone creates a “build” account on workplace (hereafter referred to as “build engineer”)

2. Build engineer creates a database using the native workplace UI

3. Build engineer creates a new Flex project in Flex Builder

4. Build engineer converts said Flex application to an IPP Application by Adding the IPP framework to the new project

5. Build engineer configures the IPP Project using the wizard

a. Calls the Project 1.0

b. Creates and/or Assigns an AppToken

c. Points to, the dbid from Step #2 to create the Development Master (normally, they’ll always just use Find DBID here)

d. Saves the IPP Project

6. Build engineer runs the DTO generator.

7. Build engineer adds all of the files to CVS/P4, excepting binaries and the DevEnvironment.xml (shouldn’t be one at this point if my memory is correct)

8. Build engineer invites his team, DevA, DevB and DevC to be admins to the Development Master (same dbid as is found in the IPP Project editor wizard)

9. STOP: Combine all logins under Build Engineers Account: All workplace logins that want to deploy this app need to be added to the build engineers account. This process is only temporary.

a. Please submit a support incident with build engineers email and the emails of the other Workplace logins to be added to the account. Click Here to Submit an Incident

10. DevA, DevB, DevC check out source code from CVS/P4

11. DevA, DevB, DevC build code and deploy to their dev environments… This will create their development sandboxes.  It will also create the DevEnvironment.xml file

12. DevA, DevB, DevC make enhancements that they check back into CVS/P4, etc, but they never check in the DevEnvironment.xml file

13. When a Q/A build is desired (or any other deployment or publishing operation) then Build Engineer comes back into the picture

14. Build Engineer checks out all code and deploys to Q/A, Stage, or publish.

*When someone changes the schema, it will be the schema of the dev master. That person must regen the DTOs and check them in.  The other devs must then refresh their project with those new DTO files.  The Dev Instance DBs will get updated automatically.

**The schemaVersion is what triggers the whole thing.  Until there is a difference between the compiled version (SchemaVersion.as) and the sandbox’s schemaVersion dbVar, no schemaUpdate command will be executed.  This is exactly the desired behavior because a developer may be in the middle of a task and not want his sandbox to be updated.  So long as he doesn’t sync code his wishes will be law.

***In Dev the QAR is deployed to the sandbox and never to the master.  In the other environments the exact opposite is true—you deploy the QAR to the master and when running the application the executable is automagically pulled from the master.  It is this difference that allows multiple developers to have different code bases

****Technically any of the developers can deploy to Q/A (etc) but this is probably poor practice.  Future versions of the tools will have role assignments to enforce the concept of an “authorized” deployment manager.  Every developer, however, can deploy to his/her development sandbox as that is limited to their own development area.  If they want, they can also start over this away simply by deleting the DevEnvironment.xml file and doing a Synch operation, or by running the IPP Project wizard and re-cloning the Development Master.

Happy Coding

Jarred

Feedback on docs for IPP developers?

One of the areas I have been focusing on recently is the docs for IPP developers as I work on creating some simple sample applications.

A critical element of the documentation and learning material is the IPP programmer's guide. It provides a technical overview of building apps and is also a thorough reference for the APIs at the same time. For example, it talks about the established MVC design pattern and explains it with some animated flow. At a more detailed level it talks about QuickBaseDTOArrayCollection, how it enables refreshing database records in the view or the object instance automagically and so on. It also talks about the Kingussie framework which is based on Adobe's Cairngorm MVC-based framework although a comprehensive understanding of this is not necessary to get started.

The documentation is pretty rich and comprehensive. However, it might seem like the programmer's guide attempts to be a tutorial and a reference guide at the same time. There are some known issues that are being addressed (as I blog) as well.

At a time when Facebook is attempting to democratize its governing and opening it to users, it's appropriate to provide a Call For Action to the IPP developer community to get involved in improving the docs. Future versions of the documentation will make it much easier to submit and view comments "inline" but in the meantime, all feedback (good, bad or ugly) and ideas are always welcome.

Upcoming Intuit Partner Platform Webinars

Intuit Partner Platform Roadmap Update

During the Beta of Intuit Partner Platform (IPP), the IPP team received a tremendous amount of high quality feedback about what you’d like available as part of the platform. We want to share with you the plans we have for the Intuit Partner Platform – this is your chance to review those plans, give us feedback and ask questions directly to the IPP product development team.

Register for the Intuit Partner Platform Roadmap Update webinar today!
(You must be part of the Intuit Developer Network to attend these webinars.)

Intuit Partner Platform v1.2 Updates

Stay informed of the changes that have been made to the Intuit Partner Platform with this webinar that will address schema change capabilities, setting up and managing beta programs, new reporting capabilities and items fixed in v1.2.

Register now:
Wed, Feb 11, 2009 1:00 PM - 2:00 PM PST

Intuit Partner Platform Overview and Q&A

Learn about how you can build your SaaS business on the Intuit Partner Platform where you can build & sell engaging and powerful Rich Internet Applications (RIAs) without the hassle of building your own server, database, and billing infrastructure. We’ll also have a Q&A session where you have the opportunity to have your questions answered directly by the team.

Topics covered include
· The business opportunity
· Technical summary
· Fee and pricing
· Billing
· Support
· Technical resources for developers

Register now:
Thu, Feb 12, 2009 10:00 AM - 11:00 AM PST
Wed, Mar 11, 2009 1:00 PM - 2:00 PM PDT
Wed, Apr 8, 2009 1:00 PM - 2:00 PM PDT

Intuit Partner Platform Architect's View + Technical Q/A

Understand the technology behind the Intuit Partner Platform, and how Intuit’s cloud platform, data and the Adobe Flex Framework and tools can be leveraged to create useful and practical applications for Small Businesses and deployed to the Intuit WorkPlace. Take a look under the hood at the various components and services that are available to the developer and understand the relationship between Intuit’s platform services, QuickBooks and QuickBase.

Register now:
Wed, Feb 18, 2009 11:00 AM - 12:00 PM PST
Wed, Mar 18, 2009 10:00 AM - 11:00 AM PDT
Wed, Apr 15, 2009 11:00 AM - 12:00 PM PDT

e-learning solution for the Intuit Partner Platform (IPP) – can you help?

We are in the early stages of developing a new e-learning solution for the Intuit Partner Platform (IPP), targeted at developers who want to learn how to build SaaS solutions for small to medium sized business and have those solutions sold on the Intuit Workplace.

Your input into this process will be vital in making sure we develop a great learning experience for IPP developers. If you'd like to help us out, please head over to the Intuit Partner Platform forum where we have posted a short questionnaire designed to help us understand your learning preferences, skills, and gaps in the current learning content we provide today.

We look forward to hearing from you!

Thanks,

Alex Barnett,

Group Manager, Developer Relations Intuit Partner Platform and IDN

Tour de Flex app includes Intuit Partner Platform code sample

Adobe's Tour de Flex is a desktop application (running on AIR) for exploring Flex capabilities and resources, including the core Flex components, Adobe AIR and data integration, as well as a variety of third-party components, effects, skins, and more.

The app includes over 200 runnable samples, each with source code, links to documentation, and includes Intuit Partner Platform code samples.

The code sample used is from the same sample app James Ward (Adobe Technical Evangelist for Flex) put together and blogged earlier in the week - thanks James!

(via Robert McDonald)