Merge lp:~stephenjohnson505/lava-dashboard/graphingenhancement into lp:lava-dashboard

[Stephen Johnson]

Added graphing functionality to the image-reports tab of the dashboard.
Graphs can be viewed based on pass/fail, or based on measurements over time. Measurements can be further changed to include a target value, a floor value, and a weight.
Furthermore, project goals can be added to an image-set, which give the table of dates, as well as a dashed target-line for the weighted graph.

An example can be seen:
https://docs.google.com/file/d/0B9bUqR8Lmid1TlctZzZ0M3V0OHc/edit?usp=sharing

[lp:~stephenjohnson505/lava-dashboard/graphingenhancement]

407. By Stephen Johnson on 2013-07-17

Added pretty colored graphs.

Unmerged revisions

407. By Stephen Johnson on 2013-07-17

Added pretty colored graphs.

406. By Stephen Johnson on 2013-05-28

Added migration file

405. By Stephen Johnson on 2013-05-28

Fixed row graph, ready for merge

404. By Stephen Johnson on 2013-05-24

Fixed single date bug

403. By Stephen Johnson on 2013-05-24

Fixed typo, added the right axislabels

402. By Stephen Johnson on 2013-05-24

added graphing

=== modified file 'dashboard_app/admin.py'
--- dashboard_app/admin.py	2013-04-01 08:50:05 +0000
+++ dashboard_app/admin.py	2013-07-17 17:43:24 +0000
@@ -40,6 +40,8 @@
     SoftwarePackage,
     SoftwareSource,
     Tag,
+    Goal,
+    GoalDate,
     Test,
     TestCase,
     TestResult,
@@ -154,6 +156,14 @@
     list_filter = ('test',)
 
 
+class GoalsAdmin(admin.ModelAdmin):
+    class GoalDates(admin.TabularInline):
+        model = GoalDate
+        extra = 0
+    list_display = ('name',)
+    inlines = [GoalDates]
+
+
 class TestAdmin(admin.ModelAdmin):
     pass
 
@@ -219,6 +229,7 @@
 admin.site.register(SoftwarePackage, SoftwarePackageAdmin)
 admin.site.register(SoftwareSource, SoftwareSourceAdmin)
 admin.site.register(Test, TestAdmin)
+admin.site.register(Goal, GoalsAdmin)
 admin.site.register(TestCase, TestCaseAdmin)
 admin.site.register(TestResult, TestResultAdmin)
 admin.site.register(TestRun, TestRunAdmin)

=== added file 'dashboard_app/migrations/0030_auto__add_goal__add_testresults.py'
--- dashboard_app/migrations/0030_auto__add_goal__add_testresults.py	1970-01-01 00:00:00 +0000
+++ dashboard_app/migrations/0030_auto__add_goal__add_testresults.py	2013-07-17 17:43:24 +0000
@@ -0,0 +1,344 @@
+# -*- coding: utf-8 -*-
+import datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding model 'GoalDate'
+        db.create_table('dashboard_app_goaldate', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('goal', self.gf('django.db.models.fields.related.ForeignKey')(to=orm['dashboard_app.Goal'])),
+            ('tag', self.gf('django.db.models.fields.CharField')(max_length=4)),
+            ('startdate', self.gf('django.db.models.fields.DateField')()),
+            ('enddate', self.gf('django.db.models.fields.DateField')()),
+            ('value', self.gf('django.db.models.fields.FloatField')(default=0, max_length=64)),
+        ))
+        db.send_create_signal('dashboard_app', ['GoalDate'])
+
+        # Adding model 'Goal'
+        db.create_table('dashboard_app_goal', (
+            ('id', self.gf('django.db.models.fields.AutoField')(primary_key=True)),
+            ('name', self.gf('django.db.models.fields.TextField')()),
+        ))
+        db.send_create_signal('dashboard_app', ['Goal'])
+
+        # Adding field 'ImageSet.relatedDates'
+        db.add_column('dashboard_app_imageset', 'relatedDates',
+                      self.gf('django.db.models.fields.related.ForeignKey')(to=orm['dashboard_app.Goal'], null=True, blank=True),
+                      keep_default=False)
+
+        # Adding field 'TestCase.target'
+        db.add_column('dashboard_app_testcase', 'target',
+                      self.gf('django.db.models.fields.FloatField')(default=0, max_length=64, null=True),
+                      keep_default=False)
+
+        # Adding field 'TestCase.floor'
+        db.add_column('dashboard_app_testcase', 'floor',
+                      self.gf('django.db.models.fields.FloatField')(default=0, max_length=64, null=True),
+                      keep_default=False)
+
+        # Adding field 'TestCase.weight'
+        db.add_column('dashboard_app_testcase', 'weight',
+                      self.gf('django.db.models.fields.FloatField')(default=1, max_length=64, null=True),
+                      keep_default=False)
+
+        # Adding field 'TestCase.goal'
+        db.add_column('dashboard_app_testcase', 'goal',
+                      self.gf('django.db.models.fields.FloatField')(default=0, max_length=64, null=True),
+                      keep_default=False)
+
+
+    def backwards(self, orm):
+        # Deleting model 'GoalDate'
+        db.delete_table('dashboard_app_goaldate')
+
+        # Deleting model 'Goal'
+        db.delete_table('dashboard_app_goal')
+
+        # Deleting field 'ImageSet.relatedDates'
+        db.delete_column('dashboard_app_imageset', 'relatedDates_id')
+
+        # Deleting field 'TestCase.target'
+        db.delete_column('dashboard_app_testcase', 'target')
+
+        # Deleting field 'TestCase.floor'
+        db.delete_column('dashboard_app_testcase', 'floor')
+
+        # Deleting field 'TestCase.weight'
+        db.delete_column('dashboard_app_testcase', 'weight')
+
+        # Deleting field 'TestCase.goal'
+        db.delete_column('dashboard_app_testcase', 'goal')
+
+
+    models = {
+        'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        'auth.permission': {
+            'Meta': {'ordering': "('content_type__app_label', 'content_type__model', 'codename')", 'unique_together': "(('content_type', 'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Group']", 'symmetrical': 'False', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        'dashboard_app.attachment': {
+            'Meta': {'object_name': 'Attachment'},
+            'content': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True'}),
+            'content_filename': ('django.db.models.fields.CharField', [], {'max_length': '256'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'mime_type': ('django.db.models.fields.CharField', [], {'max_length': '64'}),
+            'object_id': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'public_url': ('django.db.models.fields.URLField', [], {'max_length': '512', 'blank': 'True'})
+        },
+        'dashboard_app.bundle': {
+            'Meta': {'ordering': "['-uploaded_on']", 'object_name': 'Bundle'},
+            '_gz_content': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True', 'db_column': "'gz_content'"}),
+            '_raw_content': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True', 'db_column': "'content'"}),
+            'bundle_stream': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'bundles'", 'to': "orm['dashboard_app.BundleStream']"}),
+            'content_filename': ('django.db.models.fields.CharField', [], {'max_length': '256'}),
+            'content_sha1': ('django.db.models.fields.CharField', [], {'max_length': '40', 'unique': 'True', 'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_deserialized': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'uploaded_by': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'uploaded_bundles'", 'null': 'True', 'to': "orm['auth.User']"}),
+            'uploaded_on': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.utcnow'})
+        },
+        'dashboard_app.bundledeserializationerror': {
+            'Meta': {'object_name': 'BundleDeserializationError'},
+            'bundle': ('django.db.models.fields.related.OneToOneField', [], {'related_name': "'deserialization_error'", 'unique': 'True', 'primary_key': 'True', 'to': "orm['dashboard_app.Bundle']"}),
+            'error_message': ('django.db.models.fields.CharField', [], {'max_length': '1024'}),
+            'traceback': ('django.db.models.fields.TextField', [], {'max_length': '32768'})
+        },
+        'dashboard_app.bundlestream': {
+            'Meta': {'object_name': 'BundleStream'},
+            'group': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.Group']", 'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_anonymous': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_public': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'pathname': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '128'}),
+            'slug': ('django.db.models.fields.CharField', [], {'max_length': '64', 'blank': 'True'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']", 'null': 'True', 'blank': 'True'})
+        },
+        'dashboard_app.goal': {
+            'Meta': {'object_name': 'Goal'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.TextField', [], {})
+        },
+        'dashboard_app.goaldate': {
+            'Meta': {'object_name': 'GoalDate'},
+            'enddate': ('django.db.models.fields.DateField', [], {}),
+            'goal': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['dashboard_app.Goal']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'startdate': ('django.db.models.fields.DateField', [], {}),
+            'tag': ('django.db.models.fields.CharField', [], {'max_length': '4'}),
+            'value': ('django.db.models.fields.FloatField', [], {'default': '0', 'max_length': '64'})
+        },
+        'dashboard_app.hardwaredevice': {
+            'Meta': {'object_name': 'HardwareDevice'},
+            'description': ('django.db.models.fields.CharField', [], {'max_length': '256'}),
+            'device_type': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
+        'dashboard_app.image': {
+            'Meta': {'object_name': 'Image'},
+            'filter': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'+'", 'null': 'True', 'to': "orm['dashboard_app.TestRunFilter']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '1024'})
+        },
+        'dashboard_app.imageset': {
+            'Meta': {'object_name': 'ImageSet'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'images': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['dashboard_app.Image']", 'symmetrical': 'False'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '1024'}),
+            'relatedDates': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['dashboard_app.Goal']", 'null': 'True', 'blank': 'True'})
+        },
+        'dashboard_app.launchpadbug': {
+            'Meta': {'object_name': 'LaunchpadBug'},
+            'bug_id': ('django.db.models.fields.PositiveIntegerField', [], {'unique': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'test_runs': ('django.db.models.fields.related.ManyToManyField', [], {'related_name': "'launchpad_bugs'", 'symmetrical': 'False', 'to': "orm['dashboard_app.TestRun']"})
+        },
+        'dashboard_app.namedattribute': {
+            'Meta': {'unique_together': "(('object_id', 'name'),)", 'object_name': 'NamedAttribute'},
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['contenttypes.ContentType']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.TextField', [], {}),
+            'object_id': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'value': ('django.db.models.fields.TextField', [], {})
+        },
+        'dashboard_app.pmqabundlestream': {
+            'Meta': {'object_name': 'PMQABundleStream'},
+            'bundle_stream': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'+'", 'to': "orm['dashboard_app.BundleStream']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'})
+        },
+        'dashboard_app.softwarepackage': {
+            'Meta': {'unique_together': "(('name', 'version'),)", 'object_name': 'SoftwarePackage'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'version': ('django.db.models.fields.CharField', [], {'max_length': '128'})
+        },
+        'dashboard_app.softwarepackagescratch': {
+            'Meta': {'object_name': 'SoftwarePackageScratch'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'version': ('django.db.models.fields.CharField', [], {'max_length': '128'})
+        },
+        'dashboard_app.softwaresource': {
+            'Meta': {'object_name': 'SoftwareSource'},
+            'branch_revision': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'branch_url': ('django.db.models.fields.CharField', [], {'max_length': '256'}),
+            'branch_vcs': ('django.db.models.fields.CharField', [], {'max_length': '10'}),
+            'commit_timestamp': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'project_name': ('django.db.models.fields.CharField', [], {'max_length': '32'})
+        },
+        'dashboard_app.tag': {
+            'Meta': {'object_name': 'Tag'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.SlugField', [], {'unique': 'True', 'max_length': '256'})
+        },
+        'dashboard_app.test': {
+            'Meta': {'object_name': 'Test'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'blank': 'True'}),
+            'test_id': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '1024'})
+        },
+        'dashboard_app.testcase': {
+            'Meta': {'unique_together': "(('test', 'test_case_id'),)", 'object_name': 'TestCase'},
+            'floor': ('django.db.models.fields.FloatField', [], {'default': '0', 'max_length': '64', 'null': 'True'}),
+            'goal': ('django.db.models.fields.FloatField', [], {'default': '0', 'max_length': '64', 'null': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'target': ('django.db.models.fields.FloatField', [], {'default': '0', 'max_length': '64', 'null': 'True'}),
+            'test': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'test_cases'", 'to': "orm['dashboard_app.Test']"}),
+            'test_case_id': ('django.db.models.fields.TextField', [], {}),
+            'units': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'weight': ('django.db.models.fields.FloatField', [], {'default': '1', 'max_length': '64', 'null': 'True'})
+        },
+        'dashboard_app.testdefinition': {
+            'Meta': {'object_name': 'TestDefinition'},
+            'content': ('django.db.models.fields.files.FileField', [], {'max_length': '100', 'null': 'True', 'blank': 'True'}),
+            'description': ('django.db.models.fields.TextField', [], {}),
+            'environment': ('django.db.models.fields.CharField', [], {'max_length': '256'}),
+            'format': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'location': ('django.db.models.fields.CharField', [], {'default': "'LOCAL'", 'max_length': '64'}),
+            'mime_type': ('django.db.models.fields.CharField', [], {'default': "'text/plain'", 'max_length': '64'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '512'}),
+            'target_dev_types': ('django.db.models.fields.CharField', [], {'max_length': '512'}),
+            'target_os': ('django.db.models.fields.CharField', [], {'max_length': '512'}),
+            'url': ('django.db.models.fields.CharField', [], {'max_length': '1024'}),
+            'version': ('django.db.models.fields.CharField', [], {'max_length': '256'})
+        },
+        'dashboard_app.testresult': {
+            'Meta': {'ordering': "('_order',)", 'object_name': 'TestResult'},
+            '_order': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'filename': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'null': 'True', 'blank': 'True'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'lineno': ('django.db.models.fields.PositiveIntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'measurement': ('django.db.models.fields.DecimalField', [], {'null': 'True', 'max_digits': '20', 'decimal_places': '10', 'blank': 'True'}),
+            'message': ('django.db.models.fields.TextField', [], {'max_length': '1024', 'null': 'True', 'blank': 'True'}),
+            'microseconds': ('django.db.models.fields.BigIntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'relative_index': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'result': ('django.db.models.fields.PositiveSmallIntegerField', [], {}),
+            'test_case': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'test_results'", 'null': 'True', 'to': "orm['dashboard_app.TestCase']"}),
+            'test_run': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'test_results'", 'to': "orm['dashboard_app.TestRun']"}),
+            'timestamp': ('django.db.models.fields.DateTimeField', [], {'null': 'True', 'blank': 'True'})
+        },
+        'dashboard_app.testrun': {
+            'Meta': {'ordering': "['-import_assigned_date']", 'object_name': 'TestRun'},
+            'analyzer_assigned_date': ('django.db.models.fields.DateTimeField', [], {}),
+            'analyzer_assigned_uuid': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '36'}),
+            'bundle': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'test_runs'", 'to': "orm['dashboard_app.Bundle']"}),
+            'devices': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'test_runs'", 'blank': 'True', 'to': "orm['dashboard_app.HardwareDevice']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'import_assigned_date': ('django.db.models.fields.DateTimeField', [], {'auto_now_add': 'True', 'blank': 'True'}),
+            'microseconds': ('django.db.models.fields.BigIntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'packages': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'test_runs'", 'blank': 'True', 'to': "orm['dashboard_app.SoftwarePackage']"}),
+            'sources': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'test_runs'", 'blank': 'True', 'to': "orm['dashboard_app.SoftwareSource']"}),
+            'sw_image_desc': ('django.db.models.fields.CharField', [], {'max_length': '100', 'blank': 'True'}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "'test_runs'", 'blank': 'True', 'to': "orm['dashboard_app.Tag']"}),
+            'test': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'test_runs'", 'to': "orm['dashboard_app.Test']"}),
+            'time_check_performed': ('django.db.models.fields.BooleanField', [], {'default': 'False'})
+        },
+        'dashboard_app.testrundenormalization': {
+            'Meta': {'object_name': 'TestRunDenormalization'},
+            'count_fail': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'count_pass': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'count_skip': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'count_unknown': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'test_run': ('django.db.models.fields.related.OneToOneField', [], {'related_name': "'denormalization'", 'unique': 'True', 'primary_key': 'True', 'to': "orm['dashboard_app.TestRun']"})
+        },
+        'dashboard_app.testrunfilter': {
+            'Meta': {'unique_together': "(('owner', 'name'),)", 'object_name': 'TestRunFilter'},
+            'build_number_attribute': ('django.db.models.fields.CharField', [], {'max_length': '1024', 'null': 'True', 'blank': 'True'}),
+            'bundle_streams': ('django.db.models.fields.related.ManyToManyField', [], {'to': "orm['dashboard_app.BundleStream']", 'symmetrical': 'False'}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.SlugField', [], {'max_length': '1024'}),
+            'owner': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"}),
+            'public': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'uploaded_by': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'+'", 'null': 'True', 'to': "orm['auth.User']"})
+        },
+        'dashboard_app.testrunfilterattribute': {
+            'Meta': {'object_name': 'TestRunFilterAttribute'},
+            'filter': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'attributes'", 'to': "orm['dashboard_app.TestRunFilter']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '1024'}),
+            'value': ('django.db.models.fields.CharField', [], {'max_length': '1024'})
+        },
+        'dashboard_app.testrunfiltersubscription': {
+            'Meta': {'unique_together': "(('user', 'filter'),)", 'object_name': 'TestRunFilterSubscription'},
+            'filter': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['dashboard_app.TestRunFilter']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'level': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': "orm['auth.User']"})
+        },
+        'dashboard_app.testrunfiltertest': {
+            'Meta': {'object_name': 'TestRunFilterTest'},
+            'filter': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'tests'", 'to': "orm['dashboard_app.TestRunFilter']"}),
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'index': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'test': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'+'", 'to': "orm['dashboard_app.Test']"})
+        },
+        'dashboard_app.testrunfiltertestcase': {
+            'Meta': {'object_name': 'TestRunFilterTestCase'},
+            'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'index': ('django.db.models.fields.PositiveIntegerField', [], {}),
+            'test': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'cases'", 'to': "orm['dashboard_app.TestRunFilterTest']"}),
+            'test_case': ('django.db.models.fields.related.ForeignKey', [], {'related_name': "'+'", 'to': "orm['dashboard_app.TestCase']"})
+        }
+    }
+
+    complete_apps = ['dashboard_app']
\ No newline at end of file

=== modified file 'dashboard_app/models.py'
--- dashboard_app/models.py	2013-04-01 08:50:05 +0000
+++ dashboard_app/models.py	2013-07-17 17:43:24 +0000
@@ -659,6 +659,45 @@
             result=TestResult.RESULT_FAIL).count()
 
 
+class Goal(models.Model):
+    name = models.TextField(
+        verbose_name = _("Goal Name"),
+        help_text = (_("""The name for this series of goals""")))
+
+    def __unicode__(self):
+        return self.name
+
+    def return_dates(self):
+        goaldate = GoalDate.objects.all()
+        date = {}
+        for name in goaldate:
+            if (name.goal == self):
+                date[name] = {'startdate':name.startdate.isoformat(),'enddate':name.enddate.isoformat(), 'value':name.value}
+        return date
+
+
+class GoalDate(models.Model):
+    goal = models.ForeignKey(Goal)
+
+    tag = models.CharField(
+        max_length = 4,
+        help_text = (_("""1-4 character tag which distinguishes this goal on the graph""")))
+
+    startdate = models.DateField(
+        verbose_name= _("Start Date"))
+
+    enddate = models.DateField(
+        verbose_name= _("End Date"))
+
+    value = models.FloatField(
+        verbose_name= _("Value"),
+        default=0,
+        max_length = 64,
+        help_text = (_("""The goal % for this milestone.""")))
+
+    def __unicode__(self):
+        return self.tag
+
 class TestCase(models.Model):
     """
     Model for representing test cases.
@@ -687,6 +726,34 @@
                      + _help_max_length(100)),
         verbose_name = _("Units"))
 
+    target = models.FloatField(
+        default=0,
+        null = True,
+        max_length = 64,
+        help_text = (_("""The target value of the testcase, representing 100%.""")),
+        verbose_name= _("Target"))
+
+    floor = models.FloatField(
+        default=0,
+        max_length = 64,
+        null = True,
+        help_text = (_("""The lowest value of the testcase, representing 0%.""")),
+        verbose_name= _("Floor"))
+
+    weight = models.FloatField(
+        default=1,
+        null = True,
+        max_length = 64,
+        help_text = (_("""The weight of the testcase when graphed against others.""")),
+        verbose_name= _("Weight"))
+
+    goal = models.FloatField(
+        default=0,
+        null = True,
+        max_length = 64,
+        help_text = (_("""The goal % for a testcase.""")),
+        verbose_name= _("Goal"))
+
     class Meta:
         unique_together = (('test', 'test_case_id'))
 
@@ -1177,6 +1244,22 @@
     def test(self):
         return self.test_run.test
 
+    @property
+    def target(self):
+        return self.test_case.target
+
+    @property
+    def weight(self):
+        return self.test_case.weight
+
+    @property
+    def floor(self):
+        return self.test_case.floor
+
+    @property
+    def goal(self):
+        return self.test_case.goal
+
     # Core attributes
 
     result = models.PositiveSmallIntegerField(
@@ -1517,6 +1600,8 @@
 
     name = models.CharField(max_length=1024, unique=True)
 
+    relatedDates = models.ForeignKey(Goal, null=True, blank=True)
+
     images = models.ManyToManyField(Image)
 
     def __unicode__(self):
@@ -1715,6 +1800,33 @@
             "dashboard_app.views.filters.views.filter_detail",
             [self.owner.username, self.name])
 
+    def get_testruns_impl(self, user, bundle_streams, attributes):
+        accessible_bundle_streams = BundleStream.objects.accessible_by_principal(
+            user)
+        testruns = TestRun.objects.filter(
+            models.Q(bundle__bundle_stream__in=accessible_bundle_streams),
+            models.Q(bundle__bundle_stream__in=bundle_streams),
+            )
+
+        for (name, value) in attributes:
+            testruns = TestRun.objects.filter(
+                id__in=testruns.values_list('id'),
+                attributes__name=name, attributes__value=value)
+
+        # if the filter doesn't specify a test, we still only return one
+        # test run per bundle.  the display code knows to do different
+        # things in this case.
+        testruns = TestRun.objects.filter(
+            id__in=testruns.values_list('id'),
+            test=Test.objects.get(test_id='lava'))
+
+        return testruns
+
+    def get_test_runs(self, user):
+        return self.get_testruns_impl(
+            user,
+            self.bundle_streams.all(),
+            self.attributes.values_list('name', 'value'))
 
 class TestRunFilterSubscription(models.Model):
 

=== modified file 'dashboard_app/static/dashboard_app/js/jquery.flot.axislabels.js' (properties changed: -x to +x)
--- dashboard_app/static/dashboard_app/js/jquery.flot.axislabels.js	2011-05-05 01:22:07 +0000
+++ dashboard_app/static/dashboard_app/js/jquery.flot.axislabels.js	2013-07-17 17:43:24 +0000
@@ -1,87 +1,416 @@
 /*
-Flot plugin for labeling axis
-
-    (xy)axis: {
-        label: "label string",
-        labelPos: "high" or "low"
-    }
-
-This plugin allows you to label an axis without much fuss, by
-replacing one of the extreme ticks with the chosen label string. Set
-labelPos to "high" or "low" to replace respectively the maximum or the
-minimum value of the ticks. User set axis.tickFormatter are respected
-and multiple axes supported.
-
-Rui Pereira
-rui (dot) pereira (at) gmail (dot) com
+Axis Labels Plugin for flot.
+http://github.com/markrcote/flot-axislabels
+
+Original code is Copyright (c) 2010 Xuan Luo.
+Original code was released under the GPLv3 license by Xuan Luo, September 2010.
+Original code was rereleased under the MIT license by Xuan Luo, April 2012.
+
+Improvements by Mark Cote.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 */
 (function ($) {
-
-    function labelAxis(val, axis){
-        var ticks, opts = axis.options;
-
-        // generator
-        var tmpopts = axis.n == 1? opts: (typeof opts.alignedTo != 'undefined')? opts.alignedTo.options: null;
-        // first axis or some axis aligned wrt it
-        if (tmpopts && (tmpopts.autoscaleMargin == null ||
-                (tmpopts.labelPos == 'high' && tmpopts.max != null) ||
-                (tmpopts.labelPos == 'low' && tmpopts.min != null)))
-            // cut ticks not seen
-            ticks = $.grep(axis.tickGenerator(axis), function(v){
-                return (v > axis.min && v < axis.max);
-            });
-        // standard tick generator
-        else ticks = axis.tickGenerator(axis);
-
-        // formatter
-        if ((opts.labelPos == 'high' && val == ticks[ticks.length-1]) ||
-                (opts.labelPos == 'low' && val == ticks[0]))
-            return opts.label;
-        else {
-            // user set tickFormatter
-            if ($.isFunction(opts.userFormatter)){
-                var tmp = opts.userFormatter;
-                // avoid infinite loops
-                opts.userFormatter = null;
-                return tmp(val, axis);
+    var options = { };
+
+    function canvasSupported() {
+        return !!document.createElement('canvas').getContext;
+    }
+
+    function canvasTextSupported() {
+        if (!canvasSupported()) {
+            return false;
+        }
+        var dummy_canvas = document.createElement('canvas');
+        var context = dummy_canvas.getContext('2d');
+        return typeof context.fillText == 'function';
+    }
+
+    function css3TransitionSupported() {
+        var div = document.createElement('div');
+        return typeof div.style.MozTransition != 'undefined' // Gecko
+            || typeof div.style.OTransition != 'undefined' // Opera
+            || typeof div.style.webkitTransition != 'undefined' // WebKit
+            || typeof div.style.transition != 'undefined';
+    }
+
+
+    function AxisLabel(axisName, position, padding, plot, opts) {
+        this.axisName = axisName;
+        this.position = position;
+        this.padding = padding;
+        this.plot = plot;
+        this.opts = opts;
+        this.width = 0;
+        this.height = 0;
+    }
+
+
+    CanvasAxisLabel.prototype = new AxisLabel();
+    CanvasAxisLabel.prototype.constructor = CanvasAxisLabel;
+    function CanvasAxisLabel(axisName, position, padding, plot, opts) {
+        AxisLabel.prototype.constructor.call(this, axisName, position, padding,
+                                             plot, opts);
+    }
+
+    CanvasAxisLabel.prototype.calculateSize = function() {
+        if (!this.opts.axisLabelFontSizePixels)
+            this.opts.axisLabelFontSizePixels = 14;
+        if (!this.opts.axisLabelFontFamily)
+            this.opts.axisLabelFontFamily = 'sans-serif';
+
+        var textWidth = this.opts.axisLabelFontSizePixels + this.padding;
+        var textHeight = this.opts.axisLabelFontSizePixels + this.padding;
+        if (this.position == 'left' || this.position == 'right') {
+            this.width = this.opts.axisLabelFontSizePixels + this.padding;
+            this.height = 0;
+        } else {
+            this.width = 0;
+            this.height = this.opts.axisLabelFontSizePixels + this.padding;
+        }
+    };
+
+    CanvasAxisLabel.prototype.draw = function(box) {
+        var ctx = this.plot.getCanvas().getContext('2d');
+        ctx.save();
+        ctx.font = this.opts.axisLabelFontSizePixels + 'px ' +
+            this.opts.axisLabelFontFamily;
+        var width = ctx.measureText(this.opts.axisLabel).width;
+        var height = this.opts.axisLabelFontSizePixels;
+        var x, y, angle = 0;
+        if (this.position == 'top') {
+            x = box.left + box.width/2 - width/2;
+            y = box.top + height*0.72;
+        } else if (this.position == 'bottom') {
+            x = box.left + box.width/2 - width/2;
+            y = box.top + box.height - height*0.72;
+        } else if (this.position == 'left') {
+            x = box.left + height*0.72;
+            y = box.height/2 + box.top + width/2;
+            angle = -Math.PI/2;
+        } else if (this.position == 'right') {
+            x = box.left + box.width - height*0.72;
+            y = box.height/2 + box.top - width/2;
+            angle = Math.PI/2;
+        }
+        ctx.translate(x, y);
+        ctx.rotate(angle);
+        ctx.fillText(this.opts.axisLabel, 0, 0);
+        ctx.restore();
+    };
+
+
+    HtmlAxisLabel.prototype = new AxisLabel();
+    HtmlAxisLabel.prototype.constructor = HtmlAxisLabel;
+    function HtmlAxisLabel(axisName, position, padding, plot, opts) {
+        AxisLabel.prototype.constructor.call(this, axisName, position,
+                                             padding, plot, opts);
+    }
+
+    HtmlAxisLabel.prototype.calculateSize = function() {
+        var elem = $('<div class="axisLabels" style="position:absolute;">' +
+                     this.opts.axisLabel + '</div>');
+        this.plot.getPlaceholder().append(elem);
+        // store height and width of label itself, for use in draw()
+        this.labelWidth = elem.outerWidth(true);
+        this.labelHeight = elem.outerHeight(true);
+        elem.remove();
+
+        this.width = this.height = 0;
+        if (this.position == 'left' || this.position == 'right') {
+            this.width = this.labelWidth + this.padding;
+        } else {
+            this.height = this.labelHeight + this.padding;
+        }
+    };
+
+    HtmlAxisLabel.prototype.draw = function(box) {
+        this.plot.getPlaceholder().find('#' + this.axisName + 'Label').remove();
+        var elem = $('<div id="' + this.axisName +
+                     'Label" " class="axisLabels" style="position:absolute;">'
+                     + this.opts.axisLabel + '</div>');
+        this.plot.getPlaceholder().append(elem);
+        if (this.position == 'top') {
+            elem.css('left', box.left + box.width/2 - this.labelWidth/2 + 'px');
+            elem.css('top', box.top + 'px');
+        } else if (this.position == 'bottom') {
+            elem.css('left', box.left + box.width/2 - this.labelWidth/2 + 'px');
+            elem.css('top', box.top + box.height - this.labelHeight + 'px');
+        } else if (this.position == 'left') {
+            elem.css('top', box.top + box.height/2 - this.labelHeight/2 + 'px');
+            elem.css('left', box.left + 'px');
+        } else if (this.position == 'right') {
+            elem.css('top', box.top + box.height/2 - this.labelHeight/2 + 'px');
+            elem.css('left', box.left + box.width - this.labelWidth + 'px');
+        }
+    };
+
+
+    CssTransformAxisLabel.prototype = new HtmlAxisLabel();
+    CssTransformAxisLabel.prototype.constructor = CssTransformAxisLabel;
+    function CssTransformAxisLabel(axisName, position, padding, plot, opts) {
+        HtmlAxisLabel.prototype.constructor.call(this, axisName, position,
+                                                 padding, plot, opts);
+    }
+
+    CssTransformAxisLabel.prototype.calculateSize = function() {
+        HtmlAxisLabel.prototype.calculateSize.call(this);
+        this.width = this.height = 0;
+        if (this.position == 'left' || this.position == 'right') {
+            this.width = this.labelHeight + this.padding;
+        } else {
+            this.height = this.labelHeight + this.padding;
+        }
+    };
+
+    CssTransformAxisLabel.prototype.transforms = function(degrees, x, y) {
+        var stransforms = {
+            '-moz-transform': '',
+            '-webkit-transform': '',
+            '-o-transform': '',
+            '-ms-transform': ''
+        };
+        if (x != 0 || y != 0) {
+            var stdTranslate = ' translate(' + x + 'px, ' + y + 'px)';
+            stransforms['-moz-transform'] += stdTranslate;
+            stransforms['-webkit-transform'] += stdTranslate;
+            stransforms['-o-transform'] += stdTranslate;
+            stransforms['-ms-transform'] += stdTranslate;
+        }
+        if (degrees != 0) {
+            var rotation = degrees / 90;
+            var stdRotate = ' rotate(' + degrees + 'deg)';
+            stransforms['-moz-transform'] += stdRotate;
+            stransforms['-webkit-transform'] += stdRotate;
+            stransforms['-o-transform'] += stdRotate;
+            stransforms['-ms-transform'] += stdRotate;
+        }
+        var s = 'top: 0; left: 0; ';
+        for (var prop in stransforms) {
+            if (stransforms[prop]) {
+                s += prop + ':' + stransforms[prop] + ';';
+            }
+        }
+        s += ';';
+        return s;
+    };
+ 
+    CssTransformAxisLabel.prototype.calculateOffsets = function(box) {
+        var offsets = { x: 0, y: 0, degrees: 0 };
+        if (this.position == 'bottom') {
+            offsets.x = box.left + box.width/2 - this.labelWidth/2;
+            offsets.y = box.top + box.height - this.labelHeight;
+        } else if (this.position == 'top') {
+            offsets.x = box.left + box.width/2 - this.labelWidth/2;
+            offsets.y = box.top;
+        } else if (this.position == 'left') {
+            offsets.degrees = -90;
+            offsets.x = box.left - this.labelWidth/2 + this.labelHeight/2;
+            offsets.y = box.height/2 + box.top;
+        } else if (this.position == 'right') {
+            offsets.degrees = 90;
+            offsets.x = box.left + box.width - this.labelWidth/2
+                        - this.labelHeight/2;
+            offsets.y = box.height/2 + box.top;
+        }
+        return offsets;
+    };
+
+    CssTransformAxisLabel.prototype.draw = function(box) {
+        this.plot.getPlaceholder().find("." + this.axisName + "Label").remove();
+        var offsets = this.calculateOffsets(box);
+        var elem = $('<div class="axisLabels ' + this.axisName +
+                     'Label" style="position:absolute; ' +
+                     'color: ' + this.opts.color + '; ' +
+                     this.transforms(offsets.degrees, offsets.x, offsets.y) +
+                     '">' + this.opts.axisLabel + '</div>');
+        this.plot.getPlaceholder().append(elem);
+    };
+
+
+    IeTransformAxisLabel.prototype = new CssTransformAxisLabel();
+    IeTransformAxisLabel.prototype.constructor = IeTransformAxisLabel;
+    function IeTransformAxisLabel(axisName, position, padding, plot, opts) {
+        CssTransformAxisLabel.prototype.constructor.call(this, axisName,
+                                                         position, padding,
+                                                         plot, opts);
+        this.requiresResize = false;
+    }
+
+    IeTransformAxisLabel.prototype.transforms = function(degrees, x, y) {
+        // I didn't feel like learning the crazy Matrix stuff, so this uses
+        // a combination of the rotation transform and CSS positioning.
+        var s = '';
+        if (degrees != 0) {
+            var rotation = degrees/90;
+            while (rotation < 0) {
+                rotation += 4;
+            }
+            s += ' filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=' + rotation + '); ';
+            // see below
+            this.requiresResize = (this.position == 'right');
+        }
+        if (x != 0) {
+            s += 'left: ' + x + 'px; ';
+        }
+        if (y != 0) {
+            s += 'top: ' + y + 'px; ';
+        }
+        return s;
+    };
+
+    IeTransformAxisLabel.prototype.calculateOffsets = function(box) {
+        var offsets = CssTransformAxisLabel.prototype.calculateOffsets.call(
+                          this, box);
+        // adjust some values to take into account differences between
+        // CSS and IE rotations.
+        if (this.position == 'top') {
+            // FIXME: not sure why, but placing this exactly at the top causes
+            // the top axis label to flip to the bottom...
+            offsets.y = box.top + 1;
+        } else if (this.position == 'left') {
+            offsets.x = box.left;
+            offsets.y = box.height/2 + box.top - this.labelWidth/2;
+        } else if (this.position == 'right') {
+            offsets.x = box.left + box.width - this.labelHeight;
+            offsets.y = box.height/2 + box.top - this.labelWidth/2;
+        }
+        return offsets;
+    };
+
+    IeTransformAxisLabel.prototype.draw = function(box) {
+        CssTransformAxisLabel.prototype.draw.call(this, box);
+        if (this.requiresResize) {
+            var elem = this.plot.getPlaceholder().find("." + this.axisName + "Label");
+            // Since we used CSS positioning instead of transforms for
+            // translating the element, and since the positioning is done
+            // before any rotations, we have to reset the width and height
+            // in case the browser wrapped the text (specifically for the
+            // y2axis).
+            elem.css('width', this.labelWidth);
+            elem.css('height', this.labelHeight);
+        }
+    };
+
+
+    function init(plot) {
+        // This is kind of a hack. There are no hooks in Flot between
+        // the creation and measuring of the ticks (setTicks, measureTickLabels
+        // in setupGrid() ) and the drawing of the ticks and plot box
+        // (insertAxisLabels in setupGrid() ).
+        //
+        // Therefore, we use a trick where we run the draw routine twice:
+        // the first time to get the tick measurements, so that we can change
+        // them, and then have it draw it again.
+        var secondPass = false;
+
+        var axisLabels = {};
+        var axisOffsetCounts = { left: 0, right: 0, top: 0, bottom: 0 };
+
+        var defaultPadding = 2; // padding between axis and tick labels
+        plot.hooks.draw.push(function (plot, ctx) {
+            var hasAxisLabels = false;
+            if (!secondPass) {
+                // MEASURE AND SET OPTIONS
+                $.each(plot.getAxes(), function(axisName, axis) {
+                    var opts = axis.options // Flot 0.7
+                        || plot.getOptions()[axisName]; // Flot 0.6
+                    if (!opts || !opts.axisLabel || !axis.show)
+                        return;
+
+                    hasAxisLabels = true;
+                    var renderer = null;
+
+                    if (!opts.axisLabelUseHtml &&
+                        navigator.appName == 'Microsoft Internet Explorer') {
+                        var ua = navigator.userAgent;
+                        var re = new RegExp("MSIE ([0-9]{1,}[\.0-9]{0,})");
+                        if (re.exec(ua) != null) {
+                            rv = parseFloat(RegExp.$1);
+                        }
+                        if (rv >= 9 && !opts.axisLabelUseCanvas && !opts.axisLabelUseHtml) {
+                            renderer = CssTransformAxisLabel;
+                        } else if (!opts.axisLabelUseCanvas && !opts.axisLabelUseHtml) {
+                            renderer = IeTransformAxisLabel;
+                        } else if (opts.axisLabelUseCanvas) {
+                            renderer = CanvasAxisLabel;
+                        } else {
+                            renderer = HtmlAxisLabel;
+                        }
+                    } else {
+                        if (opts.axisLabelUseHtml || (!css3TransitionSupported() && !canvasTextSupported()) && !opts.axisLabelUseCanvas) {
+                            renderer = HtmlAxisLabel;
+                        } else if (opts.axisLabelUseCanvas || !css3TransitionSupported()) {
+                            renderer = CanvasAxisLabel;
+                        } else {
+                            renderer = CssTransformAxisLabel;
+                        }
+                    }
+
+                    var padding = opts.axisLabelPadding === undefined ?
+                                  defaultPadding : opts.axisLabelPadding;
+
+                    axisLabels[axisName] = new renderer(axisName,
+                                                        axis.position, padding,
+                                                        plot, opts);
+
+                    // flot interprets axis.labelHeight and .labelWidth as
+                    // the height and width of the tick labels. We increase
+                    // these values to make room for the axis label and
+                    // padding.
+
+                    axisLabels[axisName].calculateSize();
+
+                    // AxisLabel.height and .width are the size of the
+                    // axis label and padding.
+                    axis.labelHeight += axisLabels[axisName].height;
+                    axis.labelWidth += axisLabels[axisName].width;
+                    opts.labelHeight = axis.labelHeight;
+                    opts.labelWidth = axis.labelWidth;
+                });
+                // if there are axis labels re-draw with new label widths and heights
+                if (hasAxisLabels) {
+                    secondPass = true;
+                    plot.setupGrid();
+                    plot.draw();
+                }
             } else {
-                // scientific notation for small values
-                if ((axis.datamax != 0 && Math.abs(axis.datamax) < 1e-5) ||
-                        (axis.datamin != 0 && Math.abs(axis.datamin) < 1e-5))
-                    return val.toPrecision(2);
-                else return val.toFixed(axis.tickDecimals);
-            }
-        }
-    }
+                // DRAW
+                $.each(plot.getAxes(), function(axisName, axis) {
+                    var opts = axis.options // Flot 0.7
+                        || plot.getOptions()[axisName]; // Flot 0.6
+                    if (!opts || !opts.axisLabel || !axis.show)
+                        return;
 
-    function init(plot){
-        plot.hooks.processOptions.push(function(plot, options){
-            // separate X and Y
-            $.each({x: options.xaxes, y: options.yaxes}, function(direction, axes){
-                // get only axes with labels
-                $.each($.grep(axes, function(v){
-                    return (typeof v.label != 'undefined' && v.label);
-                }), function(i, axis){
-                    if ($.isFunction(axis.tickFormatter))
-                        axis.userFormatter = axis.tickFormatter;
-                    if (typeof axis.alignTicksWithAxis != 'undefined')
-                        $.each(plot.getAxes(), function(k,v){
-                            if (v.n == axis.alignTicksWithAxis && v.direction == direction)
-                                axis.alignedTo = v;
-                        });
-                    axis.tickFormatter = labelAxis;
+                    axisLabels[axisName].draw(axis.box);
                 });
-            });
+            }
         });
     }
 
-    var options = { xaxis: {label: null, labelPos: 'high'},
-                    yaxis: {label: null, labelPos: 'high'} };
 
     $.plot.plugins.push({
-                init: init,
-                options: options,
-                name: "axislabels",
-                version: "0.1"
-            });
+        init: init,
+        options: options,
+        name: 'axisLabels',
+        version: '2.0b0'
+    });
 })(jQuery);

=== added file 'dashboard_app/static/dashboard_app/js/jquery.flot.dashes.js'
--- dashboard_app/static/dashboard_app/js/jquery.flot.dashes.js	1970-01-01 00:00:00 +0000
+++ dashboard_app/static/dashboard_app/js/jquery.flot.dashes.js	2013-07-17 17:43:24 +0000
@@ -0,0 +1,231 @@
+/*
+ * jQuery.flot.dashes
+ * 
+ * options = {
+ *   series: {
+ *     dashes: {
+ *       
+ *       // show
+ *       // default: false
+ *       // Whether to show dashes for the series.
+ *       show: <boolean>,
+ *       
+ *       // lineWidth
+ *       // default: 2
+ *       // The width of the dashed line in pixels.
+ *       lineWidth: <number>,
+ *       
+ *       // dashLength
+ *       // default: 10
+ *       // Controls the length of the individual dashes and the amount of 
+ *       // space between them.
+ *       // If this is a number, the dashes and spaces will have that length.
+ *       // If this is an array, it is read as [ dashLength, spaceLength ]
+ *       dashLength: <number> or <array[2]>
+ *     }
+ *   }
+ * }
+ */
+(function($){
+  
+  function init(plot) {
+
+      plot.hooks.drawSeries.push(function(plot, ctx, series) {
+        
+        if (!series.dashes.show) {
+            return;
+        }
+          
+        var plotOffset = plot.getPlotOffset();
+        
+        function plotDashes(datapoints, xoffset, yoffset, axisx, axisy) {
+          
+          var points = datapoints.points,
+              ps = datapoints.pointsize,
+              prevx = null, 
+              prevy = null,
+              dashRemainder = 0, 
+              dashOn = true,
+              dashOnLength,
+              dashOffLength;
+          
+          if (series.dashes.dashLength[0]) {
+            dashOnLength = series.dashes.dashLength[0];
+            if (series.dashes.dashLength[1]) {
+              dashOffLength = series.dashes.dashLength[1];
+            } else {
+              dashOffLength = dashOnLength;
+            }
+          } else {
+            dashOffLength = dashOnLength = series.dashes.dashLength;
+          }
+          
+          ctx.beginPath();
+          
+          for (var i = ps; i < points.length; i += ps) {
+            
+            var x1 = points[i - ps], 
+                y1 = points[i - ps + 1],
+                x2 = points[i], 
+                y2 = points[i + 1];
+            
+            if (x1 == null || x2 == null) continue;
+
+            // clip with ymin
+            if (y1 <= y2 && y1 < axisy.min) {
+              if (y2 < axisy.min) continue;   // line segment is outside
+              // compute new intersection point
+              x1 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
+              y1 = axisy.min;
+            } else if (y2 <= y1 && y2 < axisy.min) {
+              if (y1 < axisy.min) continue;
+              x2 = (axisy.min - y1) / (y2 - y1) * (x2 - x1) + x1;
+              y2 = axisy.min;
+            }
+
+            // clip with ymax
+            if (y1 >= y2 && y1 > axisy.max) {
+              if (y2 > axisy.max) continue;
+              x1 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
+              y1 = axisy.max;
+            } else if (y2 >= y1 && y2 > axisy.max) {
+              if (y1 > axisy.max) continue;
+              x2 = (axisy.max - y1) / (y2 - y1) * (x2 - x1) + x1;
+              y2 = axisy.max;
+            }
+
+            // clip with xmin
+            if (x1 <= x2 && x1 < axisx.min) {
+              if (x2 < axisx.min) continue;
+              y1 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
+              x1 = axisx.min;
+            } else if (x2 <= x1 && x2 < axisx.min) {
+              if (x1 < axisx.min) continue;
+              y2 = (axisx.min - x1) / (x2 - x1) * (y2 - y1) + y1;
+              x2 = axisx.min;
+            }
+
+            // clip with xmax
+            if (x1 >= x2 && x1 > axisx.max) {
+              if (x2 > axisx.max) continue;
+              y1 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
+              x1 = axisx.max;
+            } else if (x2 >= x1 && x2 > axisx.max) {
+              if (x1 > axisx.max) continue;
+              y2 = (axisx.max - x1) / (x2 - x1) * (y2 - y1) + y1;
+              x2 = axisx.max;
+            }
+
+            if (x1 != prevx || y1 != prevy) {
+              ctx.moveTo(axisx.p2c(x1) + xoffset, axisy.p2c(y1) + yoffset);
+            }
+            
+            var ax1 = axisx.p2c(x1) + xoffset,
+                ay1 = axisy.p2c(y1) + yoffset,
+                ax2 = axisx.p2c(x2) + xoffset,
+                ay2 = axisy.p2c(y2) + yoffset,
+                dashOffset;
+            
+            function lineSegmentOffset(segmentLength) {
+              
+              var c = Math.sqrt(Math.pow(ax2 - ax1, 2) + Math.pow(ay2 - ay1, 2));
+              
+              if (c <= segmentLength) {
+                return {
+                  deltaX: ax2 - ax1,
+                  deltaY: ay2 - ay1,
+                  distance: c,
+                  remainder: segmentLength - c
+                }
+              } else {
+                var xsign = ax2 > ax1 ? 1 : -1,
+                    ysign = ay2 > ay1 ? 1 : -1;
+                return {
+                  deltaX: xsign * Math.sqrt(Math.pow(segmentLength, 2) / (1 + Math.pow((ay2 - ay1)/(ax2 - ax1), 2))),
+                  deltaY: ysign * Math.sqrt(Math.pow(segmentLength, 2) - Math.pow(segmentLength, 2) / (1 + Math.pow((ay2 - ay1)/(ax2 - ax1), 2))),
+                  distance: segmentLength,
+                  remainder: 0
+                };
+              }
+            }
+            //-end lineSegmentOffset
+            
+            do {
+              
+              dashOffset = lineSegmentOffset(
+                  dashRemainder > 0 ? dashRemainder : 
+                    dashOn ? dashOnLength : dashOffLength);
+              
+              if (dashOffset.deltaX != 0 || dashOffset.deltaY != 0) {
+                if (dashOn) {
+                  ctx.lineTo(ax1 + dashOffset.deltaX, ay1 + dashOffset.deltaY);
+                } else {
+                  ctx.moveTo(ax1 + dashOffset.deltaX, ay1 + dashOffset.deltaY);
+                }
+              }
+              
+              dashOn = !dashOn;
+              dashRemainder = dashOffset.remainder;
+              ax1 += dashOffset.deltaX;
+              ay1 += dashOffset.deltaY;
+              
+            } while (dashOffset.distance > 0);
+            
+            prevx = x2;
+            prevy = y2;
+          }
+          
+          ctx.stroke();
+        }
+        //-end plotDashes
+        
+        ctx.save();
+        ctx.translate(plotOffset.left, plotOffset.top);
+        ctx.lineJoin = 'round';
+        
+        var lw = series.dashes.lineWidth,
+            sw = series.shadowSize;
+        
+        // FIXME: consider another form of shadow when filling is turned on
+        if (lw > 0 && sw > 0) {
+          // draw shadow as a thick and thin line with transparency
+          ctx.lineWidth = sw;
+          ctx.strokeStyle = "rgba(0,0,0,0.1)";
+          // position shadow at angle from the mid of line
+          var angle = Math.PI/18;
+          plotDashes(series.datapoints, Math.sin(angle) * (lw/2 + sw/2), Math.cos(angle) * (lw/2 + sw/2), series.xaxis, series.yaxis);
+          ctx.lineWidth = sw/2;
+          plotDashes(series.datapoints, Math.sin(angle) * (lw/2 + sw/4), Math.cos(angle) * (lw/2 + sw/4), series.xaxis, series.yaxis);
+        }
+
+        ctx.lineWidth = lw;
+        ctx.strokeStyle = series.color;
+
+        if (lw > 0) {
+          plotDashes(series.datapoints, 0, 0, series.xaxis, series.yaxis);
+        }
+        
+        ctx.restore();
+        
+      });
+      //-end drawSeries hook
+      
+  }
+  //-end init
+
+  $.plot.plugins.push({
+    init: init,
+    options: {
+      series: {
+        dashes: {
+          show: false,
+          lineWidth: 2,
+          dashLength: 10
+        }
+      }
+    },
+    name: 'dashes',
+    version: '0.1b'
+  });
+
+})(jQuery)
\ No newline at end of file

=== added file 'dashboard_app/static/dashboard_app/js/jquery.flot.resize.js'
--- dashboard_app/static/dashboard_app/js/jquery.flot.resize.js	1970-01-01 00:00:00 +0000
+++ dashboard_app/static/dashboard_app/js/jquery.flot.resize.js	2013-07-17 17:43:24 +0000
@@ -0,0 +1,60 @@
+/*
+Flot plugin for automatically redrawing plots when the placeholder
+size changes, e.g. on window resizes.
+
+It works by listening for changes on the placeholder div (through the
+jQuery resize event plugin) - if the size changes, it will redraw the
+plot.
+
+There are no options. If you need to disable the plugin for some
+plots, you can just fix the size of their placeholders.
+*/
+
+
+/* Inline dependency: 
+ * jQuery resize event - v1.1 - 3/14/2010
+ * http://benalman.com/projects/jquery-resize-plugin/
+ * 
+ * Copyright (c) 2010 "Cowboy" Ben Alman
+ * Dual licensed under the MIT and GPL licenses.
+ * http://benalman.com/about/license/
+ */
+(function($,h,c){var a=$([]),e=$.resize=$.extend($.resize,{}),i,k="setTimeout",j="resize",d=j+"-special-event",b="delay",f="throttleWindow";e[b]=250;e[f]=true;$.event.special[j]={setup:function(){if(!e[f]&&this[k]){return false}var l=$(this);a=a.add(l);$.data(this,d,{w:l.width(),h:l.height()});if(a.length===1){g()}},teardown:function(){if(!e[f]&&this[k]){return false}var l=$(this);a=a.not(l);l.removeData(d);if(!a.length){clearTimeout(i)}},add:function(l){if(!e[f]&&this[k]){return false}var n;function m(s,o,p){var q=$(this),r=$.data(this,d);r.w=o!==c?o:q.width();r.h=p!==c?p:q.height();n.apply(this,arguments)}if($.isFunction(l)){n=l;return m}else{n=l.handler;l.handler=m}}};function g(){i=h[k](function(){a.each(function(){var n=$(this),m=n.width(),l=n.height(),o=$.data(this,d);if(m!==o.w||l!==o.h){n.trigger(j,[o.w=m,o.h=l])}});g()},e[b])}})(jQuery,this);
+
+
+(function ($) {
+    var options = { }; // no options
+
+    function init(plot) {
+        function onResize() {
+            var placeholder = plot.getPlaceholder();
+
+            // somebody might have hidden us and we can't plot
+            // when we don't have the dimensions
+            if (placeholder.width() == 0 || placeholder.height() == 0)
+                return;
+
+            plot.resize();
+            plot.setupGrid();
+            plot.draw();
+        }
+        
+        function bindEvents(plot, eventHolder) {
+            plot.getPlaceholder().resize(onResize);
+        }
+
+        function shutdown(plot, eventHolder) {
+            plot.getPlaceholder().unbind("resize", onResize);
+        }
+        
+        plot.hooks.bindEvents.push(bindEvents);
+        plot.hooks.shutdown.push(shutdown);
+    }
+    
+    $.plot.plugins.push({
+        init: init,
+        options: options,
+        name: 'resize',
+        version: '1.0'
+    });
+})(jQuery);

=== added file 'dashboard_app/static/dashboard_app/js/jquery.flot.threshold.js'
--- dashboard_app/static/dashboard_app/js/jquery.flot.threshold.js	1970-01-01 00:00:00 +0000
+++ dashboard_app/static/dashboard_app/js/jquery.flot.threshold.js	2013-07-17 17:43:24 +0000
@@ -0,0 +1,142 @@
+/* Flot plugin for thresholding data.
+
+Copyright (c) 2007-2013 IOLA and Ole Laursen.
+Licensed under the MIT license.
+
+The plugin supports these options:
+
+series: {
+threshold: {
+below: number
+color: colorspec
+}
+}
+
+It can also be applied to a single series, like this:
+
+$.plot( $("#placeholder"), [{
+data: [ ... ],
+threshold: { ... }
+}])
+
+An array can be passed for multiple thresholding, like this:
+
+threshold: [{
+below: number1
+color: color1
+},{
+below: number2
+color: color2
+}]
+
+These multiple threshold objects can be passed in any order since they are
+sorted by the processing function.
+
+The data points below "below" are drawn with the specified color. This makes
+it easy to mark points below 0, e.g. for budget data.
+
+Internally, the plugin works by splitting the data into two series, above and
+below the threshold. The extra series below the threshold will have its label
+cleared and the special "originSeries" attribute set to the original series.
+You may need to check for this in hover events.
+
+*/
+
+(function ($) {
+    var options = {
+        series: { threshold: null } // or { below: number, color: color spec}
+    };
+    
+    function init(plot) {
+        function thresholdData(plot, s, datapoints, below, color) {
+            var ps = datapoints.pointsize, i, x, y, p, prevp,
+                thresholded = $.extend({}, s); // note: shallow copy
+
+            thresholded.datapoints = { points: [], pointsize: ps, format: datapoints.format };
+            thresholded.label = null;
+            thresholded.color = color;
+            thresholded.threshold = null;
+            thresholded.originSeries = s;
+            thresholded.data = [];
+ 
+            var origpoints = datapoints.points,
+                addCrossingPoints = s.lines.show;
+
+            var threspoints = [];
+            var newpoints = [];
+            var m;
+
+            for (i = 0; i < origpoints.length; i += ps) {
+                x = origpoints[i];
+                y = origpoints[i + 1];
+
+                prevp = p;
+                if (y < below)
+                    p = threspoints;
+                else
+                    p = newpoints;
+
+                if (addCrossingPoints && prevp != p && x != null
+                    && i > 0 && origpoints[i - ps] != null) {
+                    var interx = x + (below - y) * (x - origpoints[i - ps]) / (y - origpoints[i - ps + 1]);
+                    prevp.push(interx);
+                    prevp.push(below);
+                    for (m = 2; m < ps; ++m)
+                        prevp.push(origpoints[i + m]);
+                    
+                    p.push(null); // start new segment
+                    p.push(null);
+                    for (m = 2; m < ps; ++m)
+                        p.push(origpoints[i + m]);
+                    p.push(interx);
+                    p.push(below);
+                    for (m = 2; m < ps; ++m)
+                        p.push(origpoints[i + m]);
+                }
+
+                p.push(x);
+                p.push(y);
+                for (m = 2; m < ps; ++m)
+                    p.push(origpoints[i + m]);
+            }
+
+            datapoints.points = newpoints;
+            thresholded.datapoints.points = threspoints;
+            
+            if (thresholded.datapoints.points.length > 0) {
+                var origIndex = $.inArray(s, plot.getData());
+                // Insert newly-generated series right after original one (to prevent it from becoming top-most)
+                plot.getData().splice(origIndex + 1, 0, thresholded);
+            }
+                
+            // FIXME: there are probably some edge cases left in bars
+        }
+        
+        function processThresholds(plot, s, datapoints) {
+            if (!s.threshold)
+                return;
+            
+            if (s.threshold instanceof Array) {
+                s.threshold.sort(function(a, b) {
+                    return a.below - b.below;
+                });
+                
+                $(s.threshold).each(function(i, th) {
+                    thresholdData(plot, s, datapoints, th.below, th.color);
+                });
+            }
+            else {
+                thresholdData(plot, s, datapoints, s.threshold.below, s.threshold.color);
+            }
+        }
+        
+        plot.hooks.processDatapoints.push(processThresholds);
+    }
+    
+    $.plot.plugins.push({
+        init: init,
+        options: options,
+        name: 'threshold',
+        version: '1.2'
+    });
+})(jQuery);

=== modified file 'dashboard_app/templates/dashboard_app/image-report.html'
--- dashboard_app/templates/dashboard_app/image-report.html	2013-07-01 15:49:15 +0000
+++ dashboard_app/templates/dashboard_app/image-report.html	2013-07-17 17:43:24 +0000
@@ -4,6 +4,7 @@
 {{ block.super }}
 <link rel="stylesheet" type="text/css" href="{{ STATIC_URL }}dashboard_app/css/image-report.css"/>
 <script type="text/javascript" src="{{ STATIC_URL }}dashboard_app/js/image-report.js"></script>
+<<<<<<< TREE
 <script src="{{ STATIC_URL }}dashboard_app/js/excanvas.min.js"></script>
 <script src="{{ STATIC_URL }}dashboard_app/js/jquery.flot.min.js"></script>
 <script src="{{ STATIC_URL }}dashboard_app/js/jquery.flot.dashes.min.js"></script>
@@ -15,10 +16,23 @@
   test_names = $.parseJSON($('<div/>').html("{{test_names}}").text());
   columns = $.parseJSON($('<div/>').html("{{columns}}").text());
 </script>
+=======
+<script type="text/javascript" src="{{ STATIC_URL }}lava-server/js/jquery.dataTables.min.js"></script>
+<script type="text/javascript" src="{{ STATIC_URL }}dashboard_app/js/jquery.flot.min.js"></script>
+<script type="text/javascript" src="{{ STATIC_URL }}dashboard_app/js/jquery.flot.stack.min.js"></script>
+<script type="text/javascript" src="{{ STATIC_URL }}dashboard_app/js/jquery.flot.resize.js"></script>
+<script type="text/javascript" src="{{ STATIC_URL }}dashboard_app/js/jquery.flot.dashes.js"></script>
+<script type="text/javascript" src="{{ STATIC_URL }}dashboard_app/js/jquery.flot.axislabels.js"></script>
+<script type="text/javascript" src="{{ STATIC_URL }}dashboard_app/js/jquery.flot.threshold.js"></script>
+<!-- cp jquery.flot.resize.js /var/www/lava-server/static/dashboard_app/js/ -->
+<!-- cp jquery.flot.dashes.js /var/www/lava-server/static/dashboard_app/js/ -->
+<!-- cp jquery.flot.axislabels.js /var/www/lava-server/static/dashboard_app/js/ -->
+>>>>>>> MERGE-SOURCE
 {% endblock %}
 
 {% block content %}
 <h1>Image Report: {{ image.name }}</h1>
+<<<<<<< TREE
 
 
 <div id="outer-container">
@@ -83,6 +97,1272 @@
 </div>
 
 
+=======
+<div style="display:inline-block;padding-left:20px;width:95%;">
+<div id="outer" style="width: 95%;">
+  <div id="inner" style="width: 75%; margin: 0 auto; ">
+    <input type="radio" name=typeselect id="passfailcheck" onclick="exposeList()" unchecked></input>Pass/Fail Graph
+    <input type="radio" name=typeselect id="kpicheck" onclick="exposeList()" checked></input>Measurement Graph
+    <div id="kpiinfo" style="display:inline">(
+      <input type="checkbox" id="weightedcheck" onclick="exposeList()"></input>Weighted
+      <div id="weightedinfo" style="display:none">
+        <input type="checkbox" id="weightedonly" onclick="draw()"></input>Only Goal
+      </div>
+)
+      <div style=float:right> <input type="checkbox" id="adjustedcheck" onclick="draw()"></input>Graph Adjusted Values</div>
+    </div>
+  </div>
+</div>
+
+<div id="error" style=color:#FF0000;>
+</div>
+<br>
+<div id="placeholder" style="width:90%;height:250px;float:left;">
+</div>
+<div id="legendtitle" style="width:9%;float:right;"><b>Legend</b></div>
+<div id="labeler" style="height:180px;width:9%;float:right;overflow:auto;border:1px solid gray;">
+</div>
+<div id="legendhelp" style="width:9%;float:right;border:1px solid gray;""><p style="font-size:11px">&nbsp;-Solid lines are values<br>&nbsp;-Dashed lines are goals</p>
+</div>
+<br>
+<select id="startDate" onchange="draw()" style="display:inline;width:15%">
+  <option>Start Date</option>
+</select>
+<select id="endDate" onchange="draw()" style="display:inline;width:15%">
+  <option>End Date</option>
+</select>
+<select id="startImage" onchange="draw()" style="display:none;width:15%">
+  <option>Start Image</option>
+</select>
+<select id="endImage" onchange="draw()" style="display:none;width:15%">
+  <option>End Image</option>
+</select>
+<br>
+<input type="checkbox" id="imagecheck" style="float:left" onclick="changeType()"></input>Graph by Image
+<br>
+<input type="checkbox" id="cbChoices" style="float:left;" onclick="exposeList()"></input>Choose Tests:
+<div id="goal_dates_label" style="float:right;width:15%"><div id="goal_dates_label" style="float:left"><b>Project Goals</b></div></div>
+<br>
+<div id="rows" style="height:120px;width:30%;overflow:auto;border:1px solid blue;display:none">
+</div>
+<div id="testcases" style="height:120px;width:30%;overflow:auto;border:1px solid blue;float:left;display:none">
+</div>
+<div id="goal_dates" style="height:160px;width:15%;overflow:auto;border:1px solid #ff4400;display:inline;float:right">
+</div>
+<div id="kpi" style="height:120px;width:20%;overflow:auto;border:1px solid green;display:none">
+  <b><label for="kpi" id="kpilabel" >KPI Data</label></b><br>
+  Target:&emsp;&nbsp;&emsp;&nbsp;<input type="text" id="kpitarget" style="width:50px" readonly></input>
+  <br>
+   Floor:&emsp;&emsp;&emsp;<input type="text" id="kpifloor" style="width:50px" readonly></input>
+  <br>
+  Weight:&emsp;&emsp;&nbsp;<input type="text" id="kpiweight" style="width:50px" readonly></input>
+  <br>
+  Goal(XX%)&emsp;<input type="text" id="kpigoal" style="width:50px" readonly></input>
+</div>
+<br>
+Link: <input id="permalink" type="text" style="width:75%"></input>
+<br>
+<input type="checkbox" id="cbHelp" style="float:left;" onclick="exposeHelp()"></input><b>Display Help</b><br>
+<div id="help" style="height:80px;width:80%;overflow:auto;border:1px solid black;display:none">
+  <b>Pass/Fail Graph:</b> Displays a Pass Fail graph for the current Image Report.<br>
+  <b>&emsp;Choose Tests:</b> If this box is unchecked, the graph displays a cumulative graph. Otherwise you can select individual tests to graph.<br>
+  <b>KPI Graph:</b> Displays a graph based on the measurements of the selected test cases. These are multiple ways to display the information.<br>&nbsp;&nbsp;<u>Note</u>: If no options are checked, displays the measurement values of the testcases over time.<br>
+  <b>&emsp;Weighted:</b> Displays a bar graph which aggregates the selected testcases into a percent. Calculated by averaging the adjusted value multiplied by the testcases weight.<br>
+  <b>&emsp;Only Goal:</b> Removes the individual test lines to display only the weighted bar graph.<br>
+  <b>&emsp;Graph Adjusted Values:</b> Displays the measurements as a percent, calculated using the range between the target and floor.<br>
+  <b>Graph By Image:</b> Allows you to graph using image names, instead of dates.<br>
+  <b>Link:</b> A URL link to this page with current settings.
+</div>
+<script type="text/javascript">
+
+if (document.URL.indexOf("?") != -1) {
+  var baseurl=document.URL.slice(0,document.URL.lastIndexOf("?"));
+  var url_options = document.URL.slice(document.URL.lastIndexOf("?")+1,document.URL.length+1);
+}
+else {
+  var baseurl = document.URL;
+  var url_options = '';
+}
+
+function zip() {
+    var args = [].slice.call(arguments);
+    var shortest = args.length==0 ? [] : args.reduce(function(a,b){
+        return a.length<b.length ? a : b
+    });
+
+    return shortest.map(function(_,i){
+        return args.map(function(array){return array[i]})
+    });
+};
+
+function trim (str) {
+    return str.replace(/^\s\s*/, '').replace(/\s\s*$/, '');
+}
+
+function unzip(a) {
+  var b = [];
+  var c = [];
+  for (var i=0;i<a.length;i++) {
+    b.push(a[i][0]);
+    c.push(a[i][1]);
+  }
+  return [b,c];
+};
+
+function doublesort(a, b, func) {
+  var c = zip(a,b);
+  c = c.sort(function(a,b) { if(a[0][2] > b[0][2]){return 1}else{return -1} } );
+  return unzip(c);
+}
+
+function pare(a, m) {
+  var b = new Array(m);
+  var n2 = a.length - 2;
+  var m2 = m - 2;
+  b[0] = a[0];
+  rem = Math.floor(n2/m2)
+  for (var i=0;i<(n2/rem)+1;i++) {
+    b[i]=a[i*rem];
+  }
+  b[b.length] = a[n2+1];
+  diff = b[1][0] - b[0][0];
+  for (var i=6;i<b.length;i++){
+    try {
+      if (b[i][0] - b[i-1][0] != diff) {
+        b.splice(i,1);
+        i--;
+      }
+    }
+    catch(err){
+      b.splice(i,1);
+      i--;
+    }
+  }
+  return b;
+}
+
+function rainbow(numOfSteps, step) {
+    var r, g, b;
+    var h = step / numOfSteps;
+    var i = ~~(h * 5);
+    var f = h * 8 - i;
+    var q = 1 - f;
+    switch(i % 6){
+        case 0: r = q, g = 0, b = 0; break;
+        case 1: r = 0, g = q, b = 0; break;
+        case 2: r = 0, g = q, b = 1; break;
+        case 3: r = 1, g = q, b = 0; break;
+        case 4: r = q, g = 1, b = 0; break;
+        case 5: r = 1, g = q, b = 0; break;
+    }
+    var c = "#" + ("00" + (~ ~(r * 255)).toString(16)).slice(-2) + ("00" + (~ ~(g * 255)).toString(16)).slice(-2) + ("00" + (~ ~(b * 255)).toString(16)).slice(-2);
+    return (c);
+}
+
+function contains(a, obj, gen) {
+  for (var i = 0; i < a.length; i++) {
+    if (gen) {
+}      if (a[i].toString().substr(0,a[i].toString().lastIndexOf(','))  === obj.toString()) {
+        return true;
+    }
+    else {
+      if (a[i].toString()  === obj.toString()) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
+function allimages(start, end) {
+  var images= [];
+  var counter=[]
+  {% for iimage in pfreport.images %}
+    images.push([{{forloop.counter0}},'{{iimage}}']);
+  {% endfor %}
+  tstart=start;
+  tend=end;
+  if (tstart == 0) {
+    tstart = 1;
+  }
+  if (tend == 0) {
+    tend = images.length;
+  }
+  if (tstart > tend) {
+    tend = images.length;
+    tstart = 1;
+    var div = document.getElementById("error");
+    div.textContent = "Invalid image Range: Start > End";
+  }
+  else {
+    var div = document.getElementById("error");
+    div.textContent = "";
+  }
+  images = images.slice(tstart-1,tend);
+  return [images,tstart-1,tend];
+};
+
+function alldates(start, end) {
+  var ddates = [];
+  var counter=[];
+  count = 0;
+  {% for ddate in pfreport.ddates %}
+    ddates.push([count,'{{ddate}}']);
+    count++;
+  {% endfor %}
+// This pushes the goalddates to the dates, worth it?
+/*
+  {% for tag, value in goaldates.items %}
+    ddates.push([count, '{{value.startdate}}'])
+    ddates.push([count, '{{value.enddate}}'])
+    count++
+  {% endfor %}
+*/
+  tstart=start;
+  tend=end;
+  if (tstart == 0) {
+    tstart = 1;
+  }
+  if (tend == 0) {
+    tend = ddates.length;
+  }
+  if (tstart > tend) {
+    tend = ddates.length;
+    tstart = 1;
+    var div = document.getElementById("error");
+    div.textContent = "Invalid date Range: Start > End";
+  }
+  else {
+    var div = document.getElementById("error");
+    div.textContent = "";
+  }
+  ddates = ddates.slice(tstart-1,tend);
+  return [ddates,tstart-1,tend];
+};
+
+function rownames() {
+  var rrow=[];
+  {% for row in test_run_names %}
+    rrow.push(['{{row}}']);
+  {% endfor %}
+  return rrow;
+};
+
+function casenames() {
+  var rrow=[];
+  {% for row, value in kpireport.items %}
+    rrow.push(['{{row}}', '{{value.units}}']);
+  {% endfor %}
+  return rrow;
+};
+
+function goalaxis(tstart, tend, datelocation) {
+  if (document.getElementById('imagecheck').checked == true) {
+    tstart = -1;
+    tend = -1;
+    for (var i=0; i<datelocation.length; i++){
+      if (datelocation[i].length > 0) {
+        if (tstart == -1) {
+          tstart = datelocation[i][1];
+        }
+        tend = datelocation[i][1];
+      }
+    }
+  }
+  var alldate = alldates(tstart, tend)[0];
+  var ret_array = [];
+  var goal_dates = [];
+  {% for tag, value in goaldates.items %}
+    goal_dates.push(['{{tag}}', '{{value.startdate}}', '{{value.enddate}}']);
+    ret_array.push(['{{tag}}',[], '{{value.value}}']);
+  {% endfor %}
+  ret = doublesort(goal_dates, ret_array, function(a,b) { return a[2] > b[2] } )
+  goal_dates = ret[0];
+  ret_array = ret[1];
+  for (var all=0;all<alldate.length;all++) {
+    for (var gl=0;gl<goal_dates.length;gl++) {
+      // if the date falls within the tag range...
+      // push the location and the tag
+      if (alldate[all][1] >= goal_dates[gl][1] && alldate[all][1] <= goal_dates[gl][2]) {
+        if (document.getElementById('imagecheck').checked == true) {
+          ret_array[gl][1].push([all, ret_array[gl][2]]);
+        }
+        else {
+          ret_array[gl][1].push([alldate[all][0], ret_array[gl][2]]);
+        }
+      }
+    }
+  }
+
+  // Make the dates overlap a little
+  var premx =-100;
+  var mxtag=1;
+  var around = false
+  for (var tag=0;tag<ret_array.length;tag++) {
+    var mn=9999999;
+    var mx =-100;
+    if (ret_array[tag][1].length > 0) {
+      for (var date=0;date<ret_array[tag][1].length;date++) {
+        if (ret_array[tag][1][date][0] < mn) {
+          mn =ret_array[tag][1][date][0];
+        }
+        if (ret_array[tag][1][date][0] > mx) {
+          mx =ret_array[tag][1][date][0];
+        }
+      }
+      if (mn != premx && around == true) {
+        ret_array[tag][1].push([mn-1, ret_array[tag][2]]);
+      }
+
+      premx = mx;
+      mxtag = tag;
+      around = true
+    }
+  }
+  ret_array[mxtag][1].push([premx+1, ret_array[mxtag][2]]);
+  return ret_array;
+}
+
+function allgraph(ddates) {
+  image = ddates[0];
+  images = [];
+  for (var i=0;i<image.length;i++){
+    images.push(image[i][1]);
+  }
+  tstart = ddates[1];
+  tend = ddates[2];
+  axis = [];
+  if (document.getElementById('imagecheck').checked == true) {
+    var treportpass = {{pfreport.dpass}};
+    var reportpass = [];
+    imagelist = {{pfreport.imagelist|safe}};
+    count = 0;
+    for (var i=0;i<treportpass.length;i++) {
+      if (contains(images, imagelist[i], false) && (imagelist[i] != '')) {
+        reportpass[count] = treportpass[i][1];
+        axis.push([count, imagelist[i]]);
+        count++;
+      }
+    }
+    var zipper = [];
+    for (var c=0; c<reportpass.length;c++) {
+      zipper.push(c);
+    }
+    reportpass = zip(zipper, reportpass);
+    var treportfail = {{pfreport.dfail}};
+    var reportfail = [];
+    count = 0;
+    for (var i=0;i<treportfail.length;i++) {
+      if (contains(images, imagelist[i], false) && (imagelist[i] != '')) {
+        reportfail[count] = treportfail[i][1];
+        count++;
+      }
+    }
+    reportfail = zip(zipper, reportfail);
+  }
+  else {
+    reportpass = {{pfreport.dpass}};
+    reportpass = reportpass.slice(tstart, tend);
+    reportfail = {{pfreport.dfail}};
+    reportfail = reportfail.slice(tstart, tend);
+    axis = ddates[0];
+  }
+  var reporttotalfails = 0;
+  for (var i=0; i < reportfail.length; i++) {
+    reporttotalfails = reporttotalfails + reportfail[i][1];
+  }
+  var reporttotalpasses = 0;
+  for (var i=0; i < reportpass.length; i++) {
+    reporttotalpasses = reporttotalpasses + reportpass[i][1];
+  }
+  total = reporttotalpasses+reporttotalfails;
+  var reportpercentpasses = parseInt((reporttotalpasses / total) *100);
+  var reportpercentfails = parseInt((reporttotalfails / total) *100);
+  var show = (reportfail.length == 1);
+  var ddata = [
+    {
+      'label': '<br><big><b>Fail: ' + reporttotalfails + '</b><br>' + reportpercentfails + '% failed.</big><br>',
+      'data': reportfail,
+      'color': '#FF0000',
+      'lines': { show: true },
+      'points': { show: show },
+    },
+    {
+      'label': '<br><big><b>Pass: ' + reporttotalpasses + '</b><br>' + reportpercentpasses + '% passed.</big><br>',
+      'data': reportpass,
+      'color': '#00FF00',
+      'lines': { show: true },
+      'points': { show: show },
+    },
+  ];
+  return [ddata, axis];
+};
+
+function adjustvalues(measures, i, target, flr, wgt) {
+  var rvrs = flr > target; // little numbers are better
+  var range = Math.abs(target-flr)
+  var measures_copy = []
+  for (var i=0;i<measures.length;i++)
+    measures_copy[i] = measures[i];
+  for (var j=0;j<measures.length;j++) {
+    if (measures[j] == null) {
+      measures_copy[j]=null;
+    }
+    else if (rvrs == true && measures[j] > flr) {
+      measures_copy[j] = 0;
+    }
+    else if (rvrs == true && measures[j] < target) {
+      measures_copy[j] = 100;
+    }
+    else if (rvrs == false && measures[j] > target) {
+      measures_copy[j] = 100;
+    }
+    else if (rvrs == false && measures[j] < flr) {
+      measures_copy[j] = 0;
+    }
+    else {
+      adjustednumber = Math.abs(measures[j]-flr);
+      measures_copy[j]=Math.ceil((adjustednumber/range)*100);
+    }
+  }
+  return measures_copy;
+}
+
+function averagevals(measures){
+  function average_val(arr, start, end, startval, endval) {
+    if ((start != end) && (start != end-1)) {
+      if (startval == null) {
+        for (var i=start+1; i < end; i++){
+          arr[i] = null;
+        }
+      }
+      else {
+        var points = end - start;
+        var range = endval - startval;
+        var change = range / points;
+        var count = 0;
+        for (var i=start+1; i < end; i++){
+          count++;
+          if (i == 0) {
+            arr[i] = parseFloat(startval)+change;
+          }
+          else {
+            arr[i] = parseFloat(arr[i-1])+change;
+          }
+        }
+      }
+    }
+    return arr;
+  };
+
+  var startval = 0; // value at start
+  var endval = 0; // value at end
+  var start = -1; // location
+  var end = -1; // location
+  for (var num = 0; num < measures.length; num++) {
+    if (measures[num] == -1) {
+      if (num == measures.length-1){
+        end = num+1;
+        startval = null;
+        measures = average_val(measures, start, end, startval, endval);
+      }
+    }
+    else { //value != -1
+      // first num you find, make all -1 before = val
+      if (startval == 0 && endval == 0) {
+          startval = null;
+      }
+      end = num;
+      endval = parseFloat(measures[num]);
+      measures = average_val(measures, start, end, startval, endval);
+      start = num;
+      startval = parseFloat(measures[num]);
+    }
+  }
+  return measures;
+}
+
+function kpigraph(pts, tests) {
+  var tstart = -1;
+  var tend = -1;
+  var ddata = [];
+  var weighteddata = [];
+  var sumweights = [];
+  var image = pts[0];
+  var images = [];
+  var label = [];
+  var dates = [];
+  for (var i=0;i<image.length;i++){
+    images.push(image[i][1]);
+  }
+  adjusted = document.getElementById("adjustedcheck").checked;
+  weighted = document.getElementById("weightedcheck").checked;
+  var i=-1;
+  var axis = [];
+  var needaxis = true;
+  var init = false;
+  {% for test,value in kpireport.items %}
+    i++;
+    var tgt;
+    var gl;
+    var wgt;
+    var flr;
+    if ('{{value.target}}'=='None') tgt = 0;
+    else tgt= {{value.target}};
+    if ('{{value.goal}}'=='None') gl = 0;
+    else gl= {{value.goal}};
+    if ('{{value.weight}}'=='None') wgt = 0;
+    else wgt= {{value.weight}};
+    if ('{{value.flr}}'=='None') flr = 0;
+    else flr= {{value.flr}};
+
+    glo_casedata[i][0] = tgt;
+    glo_casedata[i][1] = flr;
+    glo_casedata[i][2] = wgt;
+    glo_casedata[i][3] = gl;
+    var measures =[];
+    if (axis.length > 0) {
+      needaxis=false;
+    }
+    // its one of the selected test cases!
+    if (contains(tests,"{{test}}", true)) {
+      if (document.getElementById('imagecheck').checked == true) {
+        imagelist = {{pfreport.imagelist|safe}};
+        var tmeasures= new Array{{value.measurement|safe}};
+        count = 0;
+        for (var k=0;k<tmeasures.length;k++) {
+          if (contains(images, imagelist[k], false) && (imagelist[k] != '')) {
+            measures[count] = tmeasures[k];
+            if (needaxis == true) {
+              tstart = 0;
+              tend = count+1;
+              axis.push([count, imagelist[k]]);
+            }
+            count++;
+            dates.push([count, k]);
+          }
+          else {
+            dates.push([]);
+          }
+        }
+      }
+      else {
+      // Grab the measurements::Add the (0,#,1,#) with a zip
+        measures = new Array{{value.measurement|safe}};
+        for (var q=0;q<measures.length;q++){
+          dates.push(true);
+        }
+        axis = pts[0];
+        tstart = pts[1];
+        tend = pts[2];
+      }
+      measures = averagevals(measures);
+      if (weighteddata.length == 0) {
+        for (var k=0; k<measures.length;k++) {
+          weighteddata.push(0);
+          sumweights.push(0);
+        }
+      }
+      // If they want to % adjusted values
+      goalmeasures = adjustvalues(measures, i, tgt, flr, wgt);
+      if (adjusted == true) {
+        measures = adjustvalues(measures, i, tgt, flr, wgt);
+      }
+      for (var k=0; k<measures.length;k++) {
+        if (wgt != 0) {
+          if (goalmeasures[k] == null) {
+            // ignore it, don't update sumweights
+          }
+          else {
+            weighteddata[k] += goalmeasures[k]*wgt;
+            sumweights[k] += wgt;
+          }
+        }
+      }
+      //Lets save the data to graph the weighted graph
+
+      var zipper = [];
+      for (var c=0; c<measures.length;c++) {
+        zipper.push(c);
+      }
+      measures = zip(zipper, measures);
+      measures = measures.slice(tstart, tend);
+      goalmeasures = zip(zipper, goalmeasures);
+      goalmeasures = goalmeasures.slice(tstart, tend);
+      var color = rainbow(5, i);
+      len = 0
+      for (var m=0;m<measures.length;m++){
+        if (measures[m][1] != null) {
+          len++;
+        }
+      }
+      var show = (len <= 1);
+      ddata.push(
+          {
+          'label': "{{test}}",
+          'data': measures,
+          'color': color,
+          'lines': { show: true },
+          'points': { show: show },
+          }
+      );
+      label.push(false);
+      //  Add the dashed goal line
+      if (adjusted == true && weighted == false) {
+        var kpitarget = [];
+        var count = -1;
+        for (var j=measures[0][0];j<=measures[measures.length-1][0];j++) {
+          count++;
+          if (gl != 0) {
+            if (measures[count][1] == null) {
+              kpitarget.push([j, null]);
+            }
+            else {
+              kpitarget.push([j, gl]);
+            }
+          }
+        }
+
+        ddata.push(
+        {
+        'data': kpitarget,
+        'color': color,
+        'dashes': {show: true, },
+        'opacity': .9,
+        'points': {show: false },
+        }
+        );
+        label.push(false);
+      }
+    }
+  {% endfor %}
+
+  //check if they want the single weighted graph
+  if (weighted == true) {
+    if (document.getElementById('weightedonly').checked == true) {
+      ddata = [];
+      label = [];
+    }
+    for (var wt = 0; wt < weighteddata.length; wt++) {
+      weighteddata[wt]= ((weighteddata[wt]/100)/sumweights[wt])*100;
+    }
+    if (weighteddata.length > 0 && '{{goalname}}' != 'None') {
+      goaltarget = goalaxis(tstart, tend, dates);
+      for (var gl=0;gl<goaltarget.length;gl++) {
+        if (goaltarget[gl][1].length > 0) {
+          currentdates = goaltarget[gl][1]
+          ret = unzip(goaltarget[gl][1]);
+          ret[0] = ret[0].sort(function(a,b){ if(a > b){return 1}else{return -1} } );
+          goaltarget[gl][1] = zip(ret[0], ret[1]);
+          ddata.push({
+            'label': goaltarget[gl][0],
+            'data': goaltarget[gl][1],
+            //CAN YOU MAKE THIS OPACQUE?
+            'color': "#000000",
+            'dashes': {show: true, lineWidth: 2.5, dashLength: 5},
+            'points': {show: false },
+            'yaxis': 2,
+          });
+          label.push(true);
+          targetvalue = parseInt(currentdates[0][1])
+          mn = 9999
+          mx = -1
+          for (var val = 0; val<currentdates.length;val++) {
+            if (currentdates[val][0] < mn) mn = currentdates[val][0]
+            if (currentdates[val][0] > mx) mx = currentdates[val][0]
+          }
+          var goalvalues = weighteddata.slice(mn, mx)
+          var zipper = [];
+          for (var c=mn; c<mx;c++) {
+            zipper.push(c);
+          }
+          goalvalues = zip(zipper, goalvalues);
+          ddata.push(
+              {
+              'data': goalvalues,
+              'color': "#555555",
+              'bars': { show: true, barWidth: 0.8, align: "center", fillColor: { colors: [ { opacity: 0.5 }, { opacity: 0.2 } ] }},
+              'points': { show: false },
+              'yaxis': 2,
+              'threshold': [{below: targetvalue-5, color:'#990000'},{below: 101, color:'#009900'}, {below:targetvalue, color:'#999900'}],
+              }
+          );
+        }
+      }
+    }
+    else { // NO DATES GIVEN, JUST MAKE IT BLACK
+      var zipper = [];
+      for (var c=0; c<weighteddata.length;c++) {
+        zipper.push(c);
+      }
+      weighteddata = zip(zipper, weighteddata);
+      weighteddata = weighteddata.slice(tstart, tend);
+      ddata.push(
+          {
+          'data': weighteddata,
+          'color': "#555555",
+          'bars': { show: true, barWidth: 0.8, align: "center", fillColor: { colors: [ { opacity: 0.4 }, { opacity: 0.1 } ] }},
+          'points': { show: false },
+          'yaxis': 2,
+          }
+      );
+      label.push(false);
+    }
+  }
+  return [ddata,axis,label];
+};
+
+function rowgraph(ddates, selectedrows){
+  var dates = ddates[0];
+  images = [];
+  for (var i=0;i<dates.length;i++){
+    images.push(dates[i][1]);
+  }
+  var tstart = ddates[1];
+  var tend = ddates[2];
+  //Slice dictionary as needed..?
+  var ddata = [];
+  var axis = [];
+  var needaxis = true;
+  totalrows = rownames().length;
+  var selectnames = [];
+  for (var i=0; i<selectedrows.length;i++) {
+    selectnames.push(selectedrows[i][0]);
+  }
+  var m=-1;
+  var n=-1;
+  {% for value, row in rowreport.items %}
+    var passes =[];
+    var fails =[];
+    if (axis.length > 0) {
+      needaxis=false;
+    }
+    if (contains(selectnames, '{{value}}', true)) {
+      m++;
+      n++;
+    // graph this row
+      if (document.getElementById('imagecheck').checked == true) {
+        imagelist = {{pfreport.imagelist|safe}};
+
+        var tpasses=new Array({{row.pass}});
+        var tfails=new Array({{row.fail}});
+        tpasses = tpasses[0];
+        tfails = tfails[0];
+
+        count = 0;
+        for (var i=0;i<tpasses.length;i++) {
+          if (contains(images, imagelist[i], false) && (imagelist[i] != '')) {
+            passes[count] = tpasses[i][1];
+            if (needaxis == true) {
+              axis.push([count, imagelist[i]]);
+            }
+            count++;
+          }
+        }
+        var zipper = [];
+        for (var c=0; c<passes.length;c++) {
+          zipper.push(c);
+        }
+        passes = zip(zipper, passes);
+
+        count = 0;
+        for (var i=0;i<tfails.length;i++) {
+          if (contains(images, imagelist[i], false) && (imagelist[i] != '')) {
+            fails[count] = tfails[i][1];
+            count++;
+          }
+        }
+        fails = zip(zipper, fails);
+      }
+      else {
+        passes=new Array({{row.pass}});
+        fails=new Array({{row.fail}});
+        passes = passes[0];
+        fails = fails[0];
+        axis = ddates[0];
+        fails = fails.slice(tstart, tend);
+        passes = passes.slice(tstart, tend);
+      }
+      //ddata it up
+      var failcolor = '';
+      var passcolor = '';
+      m = n%8;
+      if (m<4){
+        failcolor = '#'+(15-m).toString(16)+(15-m).toString(16)
+                      +(m*4).toString(16)+(m*4).toString(16)
+                      +'00';
+        passcolor = '#00'
+                    +(15-m).toString(16)+(15-m).toString(16)
+                    +(m*4).toString(16)+(m*4).toString(16);
+      }
+      else {
+        m = n%4;
+        failcolor = '#'+(15-m).toString(16)+(15-m).toString(16)
+                    +'00'
+                    +(m*4).toString(16)+(m*4).toString(16);
+        passcolor = '#'+(m*4).toString(16)+(m*4).toString(16)
+                    +(15-m).toString(16)+(15-m).toString(16)
+                    +'00';
+      }
+      var show = (fails.length == 1);
+      ddata.push(
+          {
+          'label': '{{value}}'+' Fails',
+          'data': fails,
+          'color': failcolor,
+          'lines': { show: true },
+          'points': { show: show },
+          }
+      );
+      ddata.push(
+          {
+          'label': '{{value}}'+' Passes',
+          'data': passes,
+          'color': passcolor,
+          'lines': { show: true },
+          'points': { show: show },
+          }
+      );
+    }
+  {% endfor %}
+  return [ddata,axis];
+};
+
+function exposeList() {
+  var status = document.getElementById('cbChoices').checked;
+  var passstatus = document.getElementById('passfailcheck').checked;
+  if (passstatus == true) {
+    document.getElementById('testcases').style.display = 'none';
+    document.getElementById('kpi').style.display = 'none';
+    document.getElementById('cbChoices').style.display = "block";
+    document.getElementById('kpiinfo').style.display = "none";
+    if (status == true) {
+      document.getElementById('rows').style.display = "block";
+    }
+    else {
+      document.getElementById('rows').style.display = 'none';
+    }
+  }
+  else {
+    document.getElementById('rows').style.display = 'none';
+    document.getElementById('testcases').style.display = "block";
+    document.getElementById('cbChoices').style.display = "none";
+    document.getElementById('kpi').style.display = 'block';
+    document.getElementById('kpiinfo').style.display = "inline";
+    if (document.getElementById('weightedcheck').checked == true) {
+      document.getElementById('weightedinfo').style.display = 'inline';
+    }
+    else {
+      document.getElementById('weightedinfo').style.display = 'none';
+    }
+  }
+  draw();
+}
+
+function exposeHelp() {
+  var status = document.getElementById('cbHelp').checked;
+  if (status == true) {
+    document.getElementById('help').style.display = 'block';
+  }
+  else {
+    document.getElementById('help').style.display = 'none';
+  }
+}
+
+function changeType() {
+  var status = document.getElementById('imagecheck').checked;
+  if (status == true) {
+    document.getElementById('startDate').style.display = 'none';
+    document.getElementById('endDate').style.display = 'none';
+    document.getElementById('startImage').style.display = 'inline';
+    document.getElementById('endImage').style.display = 'inline';
+  }
+  else {
+    document.getElementById('startDate').style.display = 'inline';
+    document.getElementById('endDate').style.display = 'inline';
+    document.getElementById('startImage').style.display = 'none';
+    document.getElementById('endImage').style.display = 'none';
+  }
+  draw();
+}
+
+function loadtext() {
+  glo_selectedkpi=this.id.match(/\d+/);
+  document.getElementById('kpilabel').innerHTML = this.value;
+  document.getElementById('kpitarget').value = glo_casedata[glo_selectedkpi][0];
+  document.getElementById('kpifloor').value = glo_casedata[glo_selectedkpi][1];
+  document.getElementById('kpiweight').value = glo_casedata[glo_selectedkpi][2];
+  document.getElementById('kpigoal').value = glo_casedata[glo_selectedkpi][3];
+  draw();
+}
+
+function updateURL(casename, rowname) {
+  var url = baseurl;
+  url += '?sets={{setname}}&var=';
+  for (var i=0;i<=6;i++){
+    if ($("input").get(i).checked == true){
+      url += i+",";
+    }
+  }
+  url += '&kpis=';
+  for (var i=0; i < casename.length; i++) {
+    if (document.getElementById("case"+i) != null) {
+      if (document.getElementById("case"+i).checked == true) {
+        url += casename[i][0]+",";
+      }
+    }
+  }
+  url += '&rows=';
+  for (var i=0; i < rowname.length; i++) {
+    if (document.getElementById("row"+i) != null) {
+      if (document.getElementById("row"+i).checked == true) {
+          url += rowname[i][0]+",";
+      }
+    }
+  }
+  url += '&select=';
+  for (var i=0;i<=3;i++){
+    url += $("select").get(i).selectedIndex+","
+  }
+  $("#permalink")[0].value = url;
+
+}
+
+function draw() {
+  var ddata = [];
+  var val = [];
+  var labels = [];
+  if (document.getElementById('imagecheck').checked == true) {
+    var startd=document.getElementById("startImage");
+    var endd=document.getElementById("endImage");
+    var start = startd.options[startd.selectedIndex].index;
+    var end = endd.options[endd.selectedIndex].index;
+    var axis = allimages(start,end);
+  }
+  else {
+    var startd=document.getElementById("startDate");
+    var endd=document.getElementById("endDate");
+    var start = startd.options[startd.selectedIndex].index;
+    var end = endd.options[endd.selectedIndex].index;
+    var axis = alldates(start,end);
+  }
+  var rowstatus = document.getElementById('cbChoices').checked;
+  var passfailstatus = document.getElementById('passfailcheck').checked;
+  var selectedrows = [];
+  var kpi = false;
+  var casename = casenames();
+  var rowname = rownames();
+  if (passfailstatus == false) {
+    for (var i=0; i < casename.length; i++) {
+      if (document.getElementById("case"+i) != null) {
+        if (document.getElementById("case"+i).checked == true) {
+          selectedrows.push([casename[i][0], i]);
+        }
+      }
+    }
+    val = kpigraph(axis, selectedrows);
+    ddata = val[0];
+    axis = val[1];
+    labels = val[2];
+  }
+  else {
+    if (rowstatus == true) {
+      selectedrows = [];
+      for (var i=0; i < rowname.length; i++) {
+        if (document.getElementById("row"+i).checked == true) {
+          selectedrows.push([rowname[i], i]);
+        }
+      }
+      if (selectedrows.length != 0) {
+        val = rowgraph(axis, selectedrows);
+        ddata = val[0];
+        axis = val[1];
+      }
+      else {
+        val = allgraph(axis);
+        ddata = val[0];
+        axis = val[1];
+      }
+    }
+    else {
+      val = allgraph(axis);
+      ddata = val[0];
+      axis = val[1];
+    }
+  }
+  updateURL(casename,rowname);
+  // Make the dates not look terrible..
+  var goal = 10;
+  axispoints = axis;
+  if (axispoints.length > goal) {
+    axispoints = pare(axispoints, goal);
+  }
+
+  if (document.getElementById('adjustedcheck').checked == true && document.getElementById('kpicheck').checked == true) {
+    p = $.plot($("#placeholder"), ddata, {
+      xaxis: {
+        ticks: axispoints,
+      },
+      yaxis: {
+        min: 0,
+        max: 100,
+        autoscaleMargin: false,
+        axisLabel: 'Percent',
+      },
+      y2axis: {
+        min: 0,
+        max: 100,
+        autoscaleMargin: false,
+        axisLabel: 'Weighted Percent',
+      },
+     legend:{
+       container: $("#labeler")
+     },
+    });
+  }
+  else if (document.getElementById('kpicheck').checked == true){
+    p = $.plot($("#placeholder"), ddata, {
+      xaxis: {
+        ticks: axispoints,
+      },
+      yaxis: {
+        axisLabel: 'Units',
+      },
+      y2axis: {
+        min: 0,
+        max: 100,
+        autoscaleMargin: false,
+        axisLabel: 'Weighted Percent',
+      },
+      legend:{
+       container: $("#labeler")
+     },
+    });
+  }
+  else {
+    p = $.plot($("#placeholder"), ddata, {
+      xaxis: {
+        ticks: axispoints,
+      },
+      yaxis: {
+        axisLabel: 'Units',
+      },
+      y2axis: {
+        min: 0,
+        max: 100,
+        autoscaleMargin: false,
+        axisLabel: 'Weighted Percent',
+      },
+      legend:{
+        container: $("#labeler")
+     },
+    });
+  }
+  // Add the labels to the weighted graph
+  var count = -1;
+  if (p.getData().length > 0) {
+    $.each(p.getData(), function(i, row){
+      if (row.label) {
+        count++;
+        if (labels[count] == true) {
+          tlabel = row.label;
+          row.label = '';
+          if (row.data.length > 1) {
+            var o = p.pointOffset({x: row.data[0][0], y: row.data[0][1], yaxis: 2});
+            $('<div class="data-point-label">' +'<b><font size=3>'+ tlabel+ '</font></b>' + '</div>').css( {
+              position: 'absolute',
+              left: o.left + 2,
+              top: o.top - 23,
+              display: 'none',
+              escapeHTML: 'false',
+              border: '1.5px solid #aaaaaa',
+              background: '#aaccee',
+              opacity: '0.9',
+              }).appendTo(p.getPlaceholder()).fadeIn(0);
+          }
+        }
+      }
+    });
+    p.setupGrid();
+  }
+};
+
+var glo_selectedkpi = 0;
+var glo_casedata = [];
+
+$(window).resize(function() {
+  draw();
+});
+
+$(document).ready(function(){
+  var select = document.getElementById("startDate");
+  var select2 = document.getElementById("endDate");
+  var options = alldates(0,0)[0];
+//  url_options
+  for(var i = 0; i < options.length; i++) {
+    var opt = options[i][1];
+    var el = document.createElement("option");
+    var el2 = document.createElement("option");
+    el.textContent = opt;
+    el.value = opt;
+    el2.textContent = opt;
+    el2.value = opt;
+    select.appendChild(el);
+    select2.appendChild(el2);
+  }
+
+  select = document.getElementById("startImage");
+  select2 = document.getElementById("endImage");
+  options = allimages(0,0)[0];
+  for(var i = 0; i < options.length; i++) {
+    var opt = options[i][1];
+    var el = document.createElement("option");
+    var el2 = document.createElement("option");
+    el.textContent = opt;
+    el.value = opt;
+    el2.textContent = opt;
+    el2.value = opt;
+    select.appendChild(el);
+    select2.appendChild(el2);
+  }
+  select = document.getElementById("rows");
+  options = rownames();
+  rows=url_options.split("&rows=")[1];
+  if (rows != null) {
+    if (rows.indexOf("&") != -1) {rows=rows.substr(0,rows.indexOf("&")).split(",");}
+    else {rows = rows.split(",");}
+  }
+  else {
+    rows = [];
+  }
+  for (var r=0;r<rows.length;r++) {rows[r] = trim(rows[r]);}
+  for(var i = 0; i < options.length; i++) {
+    var opt = options[i];
+    var el = document.createElement("input");
+    el.type = "checkbox";
+    el.onclick=draw;
+    el.id = "row"+i;
+    el.name = "row"+i;
+    var label = document.createElement("label");
+    label.htmlFor = opt;
+    if (contains(rows, opt, false)) {el.checked = true;}
+    else {el.checked = false;}
+    label.appendChild(document.createTextNode(opt));
+    var br = document.createElement("br");
+    label.appendChild(br);
+    select.appendChild(el);
+    select.appendChild(label);
+  }
+
+  select = document.getElementById("testcases");
+  options = casenames();
+  rows=url_options.split("&kpis=")[1];
+  if (rows != null) {
+    if (rows.indexOf("&") != -1) {rows=rows.substr(0,rows.indexOf("&")).split(",");}
+    else {rows = rows.split(",");}
+  }
+  else {
+    rows = [];
+  }
+  for (var r=0;r<rows.length;r++) {rows[r] = trim(rows[r]);}
+  for(var i = 0; i < options.length; i++) {
+    glo_casedata.push([0, 0, 1, 100]);
+  }
+  for(var i = 0; i < options.length; i++) {
+    glo_selectedkpi=i;
+    var opt = options[i][0];
+    var units = options[i][1];
+    var el = document.createElement("input");
+    el.type = "checkbox";
+    el.onclick=loadtext;
+    el.id = "case"+i;
+    el.name = "case"+i;
+    el.value = opt
+    if (contains(rows, opt, false)) {el.checked = true;}
+    else {el.checked = false;}
+    var label = document.createElement("input");
+    label.type = "button";
+    label.value = opt;
+    label.id = "button"+i;
+    label.name = "button"+i;
+    label.onclick= loadtext;
+    var unit = document.createElement("input");
+    unit.type = "button";
+    unit.onclick = draw;
+    unit.value = units;
+    unit.id = "unit"+i;
+    label.name = "unit"+i;
+    var br = document.createElement("br");
+    select.appendChild(el);
+    select.appendChild(label);
+    select.appendChild(unit);
+    select.appendChild(br);
+    label.click();
+  }
+
+  rows=url_options.split("&var=")[1];
+  if (rows != null) {
+    if (rows.indexOf("&") != -1) {rows=rows.substr(0,rows.indexOf("&")).split(",");}
+    else {rows = rows.split(",");}
+  }
+  else {
+    rows = [1,2];
+  }
+  for (var i=0;i<rows.length;i++){
+    if (rows[i] != ''){
+      $("input").get(parseInt(rows[i])).checked = true
+    }
+  }
+
+  rows=url_options.split("&select=")[1];
+  var sdata = 0;
+  var simage = 0;
+  if (rows != null) {
+    if (rows.indexOf("&") != -1) {rows=rows.substr(0,rows.indexOf("&")).split(",");}
+    else {rows = rows.split(",");}
+  }
+  else {
+    if ($("select").get(0).length>7){ sdata = 7;}
+    else{ sdata=$("select").get(0).length-1;}
+    if ($("select").get(2).length>7){ simage = 7;}
+    else{ simage=$("select").get(2).length-1;}
+    rows = [$("select").get(0).length-sdata,$("select").get(1).length-1,$("select").get(2).length-simage,$("select").get(3).length-1];
+  }
+  for (var i=0;i<Math.min(rows.length, 4);i++){
+      $("select").get(i).selectedIndex = parseInt(rows[i]);
+  }
+  changeType();
+  exposeList();
+  goal_dates = [];
+  {% for tag, value in goaldates.items %}
+    goal_dates.push(['{{tag}}', '{{value.startdate}}', '{{value.enddate}}', '{{value.value}}']);
+  {% endfor %}
+  goal_dates = goal_dates.sort(function(a,b) { if(a[1] > b[1]){return 1}else{return -1} } );
+  goalElement = document.getElementById("goal_dates");
+  if (goal_dates.length > 0) {
+    goalElement.style.display = 'inline';
+    document.getElementById('goal_dates_label').style.display = 'inline';
+    inputString = '<table border="0"><tr><td><b>Tag&emsp;</b></td><td><b>Target Date&emsp;</b></td><td><b>Goal</b></td></tr>';
+    for (var tag=0;tag<goal_dates.length;tag++){
+      inputString += '<tr><td>'+goal_dates[tag][0]+'</td>';
+      inputString += '<td>'+goal_dates[tag][1]+'</td>';
+      inputString += '<td>'+goal_dates[tag][3]+'%</td></tr>';
+    }
+    inputString += '</table>';
+    goalElement.innerHTML = inputString;
+  }
+  else {
+    goalElement.style.display = 'none';
+    document.getElementById('goal_dates_label').style.display = 'none';
+  }
+  glo_selectedkpi=0;
+  draw();
+});
+
+</script>
+
+<h2>Detailed results:</h2>
+>>>>>>> MERGE-SOURCE
 <table id="outer-table">
   <tr>
     <td>

=== modified file 'dashboard_app/templates/dashboard_app/image-reports.html'
--- dashboard_app/templates/dashboard_app/image-reports.html	2012-07-18 05:20:11 +0000
+++ dashboard_app/templates/dashboard_app/image-reports.html	2013-07-17 17:43:24 +0000
@@ -9,10 +9,12 @@
   {% for image in imageset.images %}
   <li>
     {% if image.bundle_count %}
-    <a href="{{ image.link }}">{{ image.name }}</a>
-    ({{ image.bundle_count }} results)
+      <a href="{{ image.link }}">{{ image.imagename }}</a>
+      ({{ image.bundle_count }} results)
+      (<font color="Blue">{{image.grandtotal}} Totalcases;</font> <font color="green"> {{ image.passes }} Passes; </font><font color="red">{{image.fails}} Fails</font>)
     {% else %}
-    {{ image.name }} ({{ image.bundle_count }} results)
+      {{ imagename }} ({{ image.bundle_count }} results)
+      (<font color="Blue">{{image.grandtotal}} Totalcases;</font> <font color="green"> {{ image.passes }} Passes; </font><font color="red">{{image.fails}} Fails</font>)
     {% endif %}
   </li>
   {% endfor %}

=== modified file 'dashboard_app/views/images.py'
--- dashboard_app/views/images.py	2013-07-03 11:42:45 +0000
+++ dashboard_app/views/images.py	2013-07-17 17:43:24 +0000
@@ -16,11 +16,14 @@
 # You should have received a copy of the GNU Affero General Public License
 # along with Launch Control.  If not, see <http://www.gnu.org/licenses/>.
 
-
+import json
+import re
+from django.db import models
 from django.http import HttpResponseRedirect
 from django.shortcuts import get_object_or_404, render_to_response
 from django.template import RequestContext
 from django.views.decorators.http import require_POST
+from datetime import date
 
 from lava_server.bread_crumbs import (
     BreadCrumb,
@@ -29,32 +32,302 @@
 
 from dashboard_app.filters import evaluate_filter
 from dashboard_app.models import (
+    Bundle,
     LaunchpadBug,
     Image,
     ImageSet,
     TestRun,
 )
 from dashboard_app.views import index
+<<<<<<< TREE
 import json
+=======
+
+def pfdict_insert(dic, match, tag):
+    if tag not in dic:
+        dic[tag] = {'pass': 0, 'fail': 0, 'test_names': [], 'image': '', 'allpass':0, 'allfail':0}
+    dic[tag]['pass'] += match['count_pass']
+    dic[tag]['fail'] += match['count_fail']
+    dic[tag]['test_names']=match['test_names']
+    dic[tag]['allpass']=match['allpass']
+    dic[tag]['allfail']=match['allfail']
+    if (str(match['image']) != ''):
+      dic[tag]['image'] = match['image']
+    return dic
+
+def kpidict_insert(dic, aMatch, tag):
+    for match in aMatch:
+        testname = match
+        if testname not in dic:
+            dic[testname] = {'date': [],'measurement': [], 'units': '',
+                'target': '', 'floor': '', 'goal': '', 'weight': ''}
+        dic[testname]['date'].append(tag)
+        if (aMatch[match]['measurement']==None):
+            dic[testname]['measurement'].append(-1)
+        else:
+            dic[testname]['measurement'].append(str(aMatch[match]['measurement']))
+        if (dic[testname]['units'] == ''):
+            dic[testname]['units']=aMatch[match]['units']
+        dic[testname]['target']=aMatch[match]['target']
+        dic[testname]['floor']=aMatch[match]['floor']
+        dic[testname]['goal']=aMatch[match]['goal']
+        dic[testname]['weight']=aMatch[match]['weight']
+    return dic
+
+def rowdict_insert(dic, rowMatch, tag):
+    for match in rowMatch:
+        if tag not in dic:
+            dic[tag] = {}
+        if match not in dic[tag]:
+            dic[tag][match] = {'pass':0,'fail':0}
+    for testname in dic[tag]:
+        try:
+            dic[tag][testname]['pass'] = rowMatch[testname]['pass']
+        except KeyError:
+            dic[tag][testname]['pass'] = 0
+        try:
+            dic[tag][testname]['fail'] = rowMatch[testname]['fail']
+        except KeyError:
+            dic[tag][testname]['fail'] = 0
+    return dic
+
+
+def generate_dicts(allmatches, getcases):
+    # Lets only go through the database once..
+    kpidict = {}
+    detaildict = {}
+    rowdict = {}
+    dates = []
+    images = []
+    tagdic = {}
+    for matches in allmatches:
+        tag = ""
+        for match in matches.test_runs:
+            #Only keep latest test for same image
+            if (tag == ""):
+                tag = match.analyzer_assigned_date
+                tag = date(tag.year,tag.month,tag.day)
+            #tag = matches.tag
+            if tag not in dates:
+                dates.append(tag)
+            if tag not in tagdic:
+                tagdic[tag]=[]
+            tagdic[tag].append(match)
+    for tagname in tagdic:
+        aMatch = {'count_pass': 0,'count_fail': 0, 'test_names': [], 'image': '', 'allpass': 0, 'allfail': 0}
+        rowMatch = {}
+        for ddate in tagdic[tagname]:
+            aMatch['count_pass'] += ddate.denormalization.count_pass
+            aMatch['count_fail'] += ddate.denormalization.count_fail
+            aMatch['test_names'].append(ddate)
+            aMatch['image'] = ddate.sw_image_desc
+        aMatch['allpass'] = aMatch['count_pass']
+        aMatch['allfail'] = aMatch['count_fail']
+        aMatch['count_pass'] = float(aMatch['count_pass']) / float(len(tagdic[tagname]))
+        aMatch['count_fail'] = float(aMatch['count_fail']) / float(len(tagdic[tagname]))
+        detaildict = pfdict_insert(detaildict, aMatch, tagname)
+
+        if (match.sw_image_desc not in images) and not (match.sw_image_desc == ''):
+            images.append(match.sw_image_desc)
+        if (getcases == 1):
+            aMatch = {}
+            rowMatch = {}
+            for ddate in tagdic[tagname]:
+                if (ddate.test.test_id not in rowMatch):
+                    rowMatch[ddate.test.test_id] = {'pass':0,'fail':0,'count':0}
+                denorm = ddate.denormalization
+                rowMatch[ddate.test.test_id]['fail'] += denorm.count_fail
+                rowMatch[ddate.test.test_id]['pass'] += denorm.count_pass
+                if (denorm.count_fail == 0 and denorm.count_pass == 0):
+                    pass
+                else:
+                    rowMatch[ddate.test.test_id]['count'] += 1
+                testname = ddate.test # <-- TESTNAME
+                if (str(testname) != 'lava'):
+                    # Only take measuresments with a . in them, current lava implementation
+                    # measurements are stored as floats
+                    for test_case in ddate.test_results.filter(measurement__icontains='.'):
+                        test_case_name = test_case.test_case
+                        if (test_case.test_case not in aMatch):
+                            aMatch[test_case_name] = {'date': '','measurement': None, 'units': '','target': '',
+                                                      'floor': '', 'goal': '', 'weight': '', 'count': 0}
+                        if (aMatch[test_case_name]['measurement'] == None and test_case.measurement != None):
+                            aMatch[test_case_name]['measurement'] = 0
+                        if (test_case.measurement == None):
+                            test_case.measurement = 0
+                        if (aMatch[test_case_name] != None):
+                            aMatch[test_case_name]['measurement'] += test_case.measurement
+                            aMatch[test_case_name]['count'] += 1
+                        aMatch[test_case_name]['date'] = tagname
+                        aMatch[test_case_name]['units'] = test_case.units
+                        aMatch[test_case_name]['target']=test_case.target
+                        aMatch[test_case_name]['floor']=test_case.floor
+                        aMatch[test_case_name]['goal']=test_case.goal
+                        aMatch[test_case_name]['weight']=test_case.weight
+            for test in aMatch:
+                if (aMatch[test]['count'] == 0):
+                    aMatch[test]['measurement'] = 0
+                else:
+                    aMatch[test]['measurement'] = aMatch[test]['measurement'] / aMatch[test]['count']
+            kpidict = kpidict_insert(kpidict, aMatch, tagname)
+            for test in rowMatch:
+                if (rowMatch[test]['count'] == 0):
+                    rowMatch[test]['pass'] = 0
+                    rowMatch[test]['fail'] = 0
+                else:
+                    rowMatch[test]['pass'] = float(rowMatch[test]['pass']) / float(rowMatch[test]['count'])
+                    rowMatch[test]['fail'] = float(rowMatch[test]['fail']) / float(rowMatch[test]['count'])
+            rowdict = rowdict_insert(rowdict, rowMatch, tagname)
+    return kpidict, detaildict, rowdict, dates
+
+def report_for_kpigraph(counters, dates, images):
+    temp = counters.copy()
+    for key in counters:
+        found = 0;
+        for i in range(0, len(counters[key]['measurement'])):
+            if (counters[key]['measurement'][i] != -1):
+                found = 1
+                break
+        if (found == 0):
+            temp.pop(key)
+        else:
+            for curdate in dates:
+                if curdate not in temp[key]['date']:
+                    temp[key]['date'].append(curdate)
+                    temp[key]['measurement'].append(-1)
+    # So now we have a dictionary of the following format..
+    # caseid: {date:[] measurement:[], units:''}}
+
+    cases = []
+    dates = []
+    measures = []
+    returndict = {}
+    for key in temp:
+        returndict[key] = {'date': [],'measurement': [], 'units': '',
+            'target': '', 'flr': '', 'goal': '', 'weight': ''}
+        dates = temp[key]['date']
+        measures = temp[key]['measurement']
+        if (len(dates)>1):
+            dates, measures = zip(*sorted(zip(dates, measures)))
+        else:
+            measures = str(measures).replace('[','(').replace(']',')')
+            dates = str(dates).replace('[','(').replace(']',')')
+        returndict[key]['date'] = dates
+        returndict[key]['measurement'] = measures
+        returndict[key]['units'] = temp[key]['units']
+        returndict[key]['target'] = temp[key]['target']
+        returndict[key]['flr'] = temp[key]['floor']
+        returndict[key]['goal'] = temp[key]['goal']
+        returndict[key]['weight'] = temp[key]['weight']
+    return returndict
+
+def report_for_detailgraph(detaildict):
+    report = {'ddates': [], 'dfail': [], 'dpass': [], 'imagelist': [], 'totalfails': 0,
+        'totalpasses': 0, 'percentfails': 0, 'percentpasses': 0,
+        'grandtotal': 0, 'images': [], 'unfail': [], 'unpass': []}
+    taglist = []
+    sortable = 0
+    for tag in detaildict:
+        taglist.append(tag)
+    taglist = sorted(taglist)
+    count = 0
+    for tag in taglist:
+        fail_count = detaildict[tag]['fail']
+        pass_count = detaildict[tag]['pass']
+        image = detaildict[tag]['image']
+        if (image not in report['images']) and not (image == ''):
+            report['images'].append(image)
+        report['imagelist'].append(str(detaildict[tag]['image']))
+        report['ddates'].append(unicode(tag))
+        report['dfail'].append([count, fail_count])
+        report['dpass'].append([count, pass_count])
+        report['unfail'].append([count, detaildict[tag]['allfail']])
+        report['unpass'].append([count, detaildict[tag]['allpass']])
+        report['totalfails'] += detaildict[tag]['allfail']
+        report['totalpasses'] += detaildict[tag]['allpass']
+        report['grandtotal'] += detaildict[tag]['allfail']+detaildict[tag]['allpass']
+        count += 1
+    if report['grandtotal'] == 0:
+        report['percentfails'] = 0
+        report['percentpasses'] = 0
+    else:
+        report['percentfails'] = report['totalfails'] * 100 / report['grandtotal']
+        report['percentpasses'] = report['totalpasses'] * 100 / report['grandtotal']
+    report['dfail'] = json.dumps(report['dfail'])
+    report['dpass'] = json.dumps(report['dpass'])
+    return report
+
+def report_for_row(rowdict):
+    tags = {}
+    counters = {}
+    count = 0
+    sortedtests = []
+    sorteddates = []
+    lava = False
+    for dates in rowdict:
+        sorteddates.append(dates)
+        for rows in rowdict[dates]:
+            if rows not in sortedtests:
+                if rows!='lava':
+                    sortedtests.append(rows)
+                else:
+                    lava = True
+    sorteddates = sorted(sorteddates)
+    sortedtests = sorted(sortedtests)
+    if (lava):
+        sortedtests.insert(0, 'lava')
+    count = 0
+    for dates in sorteddates:
+        for testname in rowdict[dates]:
+            if (testname not in counters):
+                counters[testname] = {'pass':[],'fail':[]}
+            counters[testname]['pass'].append([count, rowdict[dates][testname]['pass']])
+            counters[testname]['fail'].append([count, rowdict[dates][testname]['fail']])
+        count += 1
+    return counters
+
+def generate_reports(allmatches, getcases):
+    kpidict, detaildict, rowdict, dates = generate_dicts(allmatches, getcases)
+    detailreport = report_for_detailgraph(detaildict)
+    rowreport = report_for_row(rowdict)
+    if (getcases == 1):
+        kpireport = report_for_kpigraph(kpidict, dates, detailreport['images'])
+    else:
+        kpireport = {}
+    return kpireport, detailreport, rowreport
+>>>>>>> MERGE-SOURCE
 
 @BreadCrumb("Image Reports", parent=index)
 def image_report_list(request):
+    kpireport = {}
+    pfreport = {}
+    testcases = []
     imagesets = ImageSet.objects.filter()
     imagesets_data = []
     for imageset in imagesets:
         images_data = []
+        bundle_ids = set()
+        count = 0
         for image in imageset.images.all():
             # Migration hack: Image.filter cannot be auto populated, so ignore
             # images that have not been migrated to filters for now.
             if image.filter:
                 filter_data = image.filter.as_data()
+                matches = evaluate_filter(request.user, filter_data, prefetch_related=['launchpad_bugs'])
+                kpireport, pfreport, rowreport = generate_reports(matches, 0)
+                filter_data = image.filter.as_data()
                 image_data = {
-                    'name': image.name,
-                    'bundle_count': evaluate_filter(request.user, filter_data).count(),
-                    'link': image.name,
+                    'name': image.name+"?"+"sets="+imageset.name,
+                    'imagename': image.name,
+                    'imageset': imageset.name,
+                    'bundle_count': matches.count(),
+                    'link': image.name+"?"+"sets="+imageset.name,
+                    'passes': pfreport['totalpasses'],
+                    'grandtotal': pfreport['grandtotal'],
+                    'fails': pfreport['grandtotal']-pfreport['totalpasses'],
                     }
                 images_data.append(image_data)
-        images_data.sort(key=lambda d:d['name'])
+        #Quick hack
         imageset_data = {
             'name': imageset.name,
             'images': images_data,
@@ -70,13 +343,36 @@
 
 @BreadCrumb("{name}", parent=image_report_list, needs=['name'])
 def image_report_detail(request, name):
-
+    setname = request.GET.get("sets", None)
+    currentset = None
+    if (setname != None):
+        imagesets = ImageSet.objects.filter()
+        for imageset in imagesets:
+            if (setname == imageset.name):
+                currentset = imageset
+                break
+    else:
+        goaldates = {}
+        currentset = None
+    if (currentset != None):
+        if (currentset.relatedDates != None):
+            goaldates = currentset.relatedDates.return_dates()
+            currentset = currentset.relatedDates.name
+        else:
+            goaldates = {}
+            currentset = None
+    else:
+        goaldates = {}
     image = Image.objects.get(name=name)
     filter_data = image.filter.as_data()
+<<<<<<< TREE
     matches = evaluate_filter(request.user, filter_data, prefetch_related=['launchpad_bugs', 'test_results'])[:50]
 
+=======
+    matches = evaluate_filter(request.user, filter_data, prefetch_related=['launchpad_bugs'])
+    kpireport, pfreport, rowreport = generate_reports(matches, 1)
+>>>>>>> MERGE-SOURCE
     build_number_to_cols = {}
-
     test_run_names = set()
 
     for match in matches:
@@ -86,7 +382,7 @@
             if denorm.count_fail == 0:
                 cls = 'present pass'
             else:
-                    cls = 'present fail'
+                cls = 'present fail'
             bug_ids = sorted([b.bug_id for b in test_run.launchpad_bugs.all()])
 
             measurements = [{'measurement': str(item.measurement)}
@@ -121,6 +417,7 @@
 
     table_data = {}
 
+    table_data_dict = {}
     for test_run_name in test_run_names:
         row_data = []
         for col in cols:
@@ -131,16 +428,34 @@
                     cls='missing',
                     )
             row_data.append(test_run_data)
+<<<<<<< TREE
         table_data[test_run_name] = row_data
+=======
+        table_data.append(row_data)
+        table_data_dict[test_run_name] = row_data
+
+    #Lets see what we can do with table_data_dict
+>>>>>>> MERGE-SOURCE
 
     return render_to_response(
         "dashboard_app/image-report.html", {
-            'bread_crumb_trail': BreadCrumbTrail.leading_to(
-                image_report_detail, name=image.name),
+            'bread_crumb_trail': BreadCrumbTrail.leading_to(image_report_detail, name=image.name),
             'image': image,
+<<<<<<< TREE
             'chart_data': json.dumps(table_data),
             'test_names': json.dumps(test_run_names),
             'columns': json.dumps(cols),
+=======
+            'cols': cols,
+            'table_data': table_data,
+            'test_run_names': test_run_names,
+            'pfreport': pfreport,
+            'rowreport': rowreport,
+            'kpireport': kpireport,
+            'goaldates': goaldates,
+            'goalname': currentset,
+            'setname': setname,
+>>>>>>> MERGE-SOURCE
         }, RequestContext(request))