Merge lp:~graeme-acm/sahana-eden/RMS into lp:sahana-eden

[Graeme Foster]

Completed the basic code for the series analysis of two questions
Added basic excel generation for a set of questions

Tidied up the try excepts around the matplotlib import.

=== modified file 'controllers/survey.py'
--- controllers/survey.py	2011-09-23 08:45:47 +0000
+++ controllers/survey.py	2011-09-26 09:46:25 +0000
@@ -23,6 +23,9 @@
 except:
     from StringIO import StringIO
 
+import base64
+
+from gluon.contenttype import contenttype
 from s3survey import survey_question_type, \
                              survey_analysis_type
 
@@ -252,6 +255,56 @@
                                 rheader=response.s3.survey_series_rheader)
     return output
 
+def series_export():
+    prefix = "survey"
+    resourcename = "series"
+    tablename = "%s_%s" % (prefix, resourcename)
+    s3mgr.load(tablename)
+    crud_strings = response.s3.crud_strings[tablename]
+    
+    if len(request.args) == 1:
+        series_id = request.args[0]
+        questions = response.s3.survey_getAllQuestionsForSeries(series_id)
+        try:
+            import xlwt
+        except ImportError:
+            output = s3_rest_controller(prefix,
+                                    resourcename,
+                                    rheader=response.s3.survey_series_rheader)
+            return output
+        
+        COL_WIDTH_MULTIPLIER = 864
+        book = xlwt.Workbook(encoding="utf-8")
+        sheet1 = book.add_sheet(T("Assignment"))
+        output = StringIO()
+        row = 0
+        section = ""
+        styleHeader = xlwt.XFStyle()
+        styleHeader.font.bold = True
+        styleHeader.alignment.horz = styleHeader.alignment.HORZ_CENTER
+        for question in questions:
+            if question["section"] != section:
+                section = question["section"]
+                sheet1.write_merge(row, row, 0, 1, section, style=styleHeader)
+                row += 1
+            sheet1.write(row, 0, question["code"])
+            sheet1.write(row, 1, question["name"])
+            width=len(unicode(question["name"]))*COL_WIDTH_MULTIPLIER
+            sheet1.col(1).width = width
+            row += 1
+        book.save(output)
+        output.seek(0)
+        response.headers["Content-Type"] = contenttype(".xls")
+        seriesName = response.s3.survey_getSeriesFromID(series_id)
+        filename = "%s.xls" % seriesName
+        response.headers["Content-disposition"] = "attachment; filename=\"%s\"" % filename
+        return output.read()
+    else:
+        output = s3_rest_controller(prefix,
+                                    resourcename,
+                                    rheader=response.s3.survey_series_rheader)
+        return output
+    
 def series_summary():
     # Load Model
     if request.env.request_method == "POST":
@@ -292,6 +345,115 @@
     response.s3.actions = None
     return output
 
+def series_analysis():
+    # Load Model
+    prefix = "survey"
+    resourcename = "series"
+    tablename = "%s_%s" % (prefix, resourcename)
+    s3mgr.load(tablename)
+    crud_strings = response.s3.crud_strings[tablename]
+
+    def postp(r, output):
+        if r.interactive:
+            # Draw the chart
+            if "vars" in current.request and len(current.request.vars) > 0:
+                dummy, series_id = current.request.vars.viewing.split(".")
+            else:
+                series_id = r.id
+            numericQuestion = None
+            if "post_vars" in current.request and len(current.request.post_vars) > 0:
+                labelQuestion = None
+                if "labelQuestion" in current.request.post_vars:
+                    labelQuestion = current.request.post_vars.labelQuestion
+                numericQuestion = None
+                if "numericQuestion" in current.request.post_vars:
+                    numericQuestion = current.request.post_vars.numericQuestion
+                if (numericQuestion != None) and (labelQuestion != None):
+                    getAnswers = response.s3.survey_getAllAnswersForQuestionInSeries
+                    qstn = response.s3.survey_getQuestionFromCode(numericQuestion, series_id)
+                    qstn_id = qstn["qstn_id"]
+                    qstn_type = qstn["type"]
+                    answers = getAnswers(qstn_id, series_id)
+                    gqstn = response.s3.survey_getQuestionFromName(labelQuestion, series_id)
+                    gqstn_id = gqstn["qstn_id"] 
+                    ganswers = getAnswers(gqstn_id, series_id)
+                    analysisTool = survey_analysis_type[qstn_type](qstn_id, answers)
+                    grouped = analysisTool.groupData(ganswers)
+                    aggregate = "Sum"
+                    filtered = analysisTool.filter(aggregate, grouped)
+                    (label, data) = analysisTool.splitGroupedData(filtered)
+                    chart = Storage()
+                    chart["body"] = StringIO()
+                    chart["headers"] = Storage()
+                    chart["headers"]['Content-Type']="image/png"
+                    analysisTool.drawChart(chart, data, label)
+                    base64Img = base64.b64encode(chart.body.getvalue())
+                    image = IMG(_src="data:image/png;base64,%s" % base64Img)
+                    output["chart"] = image
+
+            # Build the form
+            if series_id == None:
+                return output
+            allQuestions = response.s3.survey_get_series_questions(series_id)
+            labelTypeList = ("String", "Option", "YesNo", "YesNoDontKnow")
+            labelQuestions = response.s3.survey_get_series_questions_of_type (allQuestions, labelTypeList)
+            lblQstns = []
+            for question in labelQuestions:
+                lblQstns.append(question["name"])
+            numericTypeList = ("Numeric")
+            numericQuestions = response.s3.survey_get_series_questions_of_type (allQuestions, numericTypeList)
+
+            form = FORM()
+            table = TABLE()
+
+            labelQstn = SELECT(lblQstns, _name="labelQuestion")
+            table.append(TR(TH(T("Label Question:")), _class="survey_question"))
+            table.append(labelQstn)
+
+            table.append(TR(TH(T("Numeric Question:")), _class="survey_question"))
+            for qstn in numericQuestions:
+                innerTable = TABLE()
+                tr = TR()
+                if numericQuestion != None and numericQuestion == qstn["code"]:
+                    tr.append(INPUT(_type='radio',
+                                    _name='numericQuestion',
+                                    _value=qstn["code"],
+                                    value=qstn["code"],
+                                   )
+                              )
+                else:
+                    tr.append(INPUT(_type='radio',
+                                    _name='numericQuestion',
+                                    _value=qstn["code"],
+                                   )
+                              )
+                tr.append(LABEL(qstn["name"]))
+                innerTable.append(tr)
+                table.append(innerTable)
+            form.append(table)
+
+            button = INPUT(_type="submit", _name="Chart", _value="Draw Chart")
+            form.append(button)
+
+            output["form"] = form
+            return output
+
+    # remove CRUD generated buttons in the tabs
+    s3mgr.configure(tablename,
+                    listadd=False,
+                    deletable=False,
+                   )
+
+    response.s3.postp = postp
+    output = s3_rest_controller(prefix,
+                                resourcename, 
+                                method = "create",
+                                rheader=response.s3.survey_series_rheader
+                               )
+    response.s3.has_required = False
+    response.view = "survey/series_analysis.html"
+    return output
+
 def completed_chart():
     """ RESTful CRUD controller """
     # Load Model

=== modified file 'models/survey.py'
--- models/survey.py	2011-09-23 07:33:12 +0000
+++ models/survey.py	2011-09-26 09:46:25 +0000
@@ -529,6 +529,70 @@
             questions = getAllQuestionsForSeries(series_id)
             return (questions, series_id)
 
+        def survey_getQuestionFromCode(code, series_id):
+            """
+                function to return the question for the given series 
+                with the code that matches the one passed in
+            """
+            sertable = db.survey_series
+            q_ltable = db.survey_question_list
+            qsntable = db.survey_question
+            query = db((sertable.id == series_id) & \
+                       (q_ltable.template_id == sertable.template_id) & \
+                       (q_ltable.question_id == qsntable.id) & \
+                       (qsntable.code == code)
+                      )
+            record = query.select(qsntable.id,
+                                  qsntable.code,
+                                  qsntable.name,
+                                  qsntable.type,
+                                  q_ltable.posn,
+                                  limitby=(0, 1)).first()
+            question = {}
+            question["qstn_id"] = record.survey_question.id
+            question["code"] = record.survey_question.code
+            question["name"] = record.survey_question.name
+            question["type"] = record.survey_question.type
+            question["posn"] = record.survey_question_list.posn
+            return question
+
+        def survey_getSeriesFromID(series_id):
+            """
+                function to return the series from a series id
+            """
+            sertable = db.survey_series
+            query = db((sertable.id == series_id))
+            record = query.select(sertable.name,
+                                  limitby=(0, 1)).first()
+            return record.name
+
+        def survey_getQuestionFromName(name, series_id):
+            """
+                function to return the question for the given series 
+                with the name that matches the one passed in
+            """
+            sertable = db.survey_series
+            q_ltable = db.survey_question_list
+            qsntable = db.survey_question
+            query = db((sertable.id == series_id) & \
+                       (q_ltable.template_id == sertable.template_id) & \
+                       (q_ltable.question_id == qsntable.id) & \
+                       (qsntable.name == name)
+                      )
+            record = query.select(qsntable.id,
+                                  qsntable.code,
+                                  qsntable.name,
+                                  qsntable.type,
+                                  q_ltable.posn,
+                                  limitby=(0, 1)).first()
+            question = {}
+            question["qstn_id"] = record.survey_question.id
+            question["code"] = record.survey_question.code
+            question["name"] = record.survey_question.name
+            question["type"] = record.survey_question.type
+            question["posn"] = record.survey_question_list.posn
+            return question
+
         def survey_save_answers_for_complete(complete_id, vars):
             # Get all the questions
             (questions, series_id) = getAllQuestionsForComplete(complete_id)
@@ -570,6 +634,24 @@
             questions = getAllQuestionsForSeries(series_id)
             return build_questions_form(questions, complete_id)
             
+        def survey_get_series_questions(series_id):
+            return getAllQuestionsForSeries(series_id)
+
+        def survey_get_series_questions_of_type(questionList, type):
+            if isinstance(type, (list, tuple)):
+                types = type
+            else:
+                types = (type)
+            questions = []
+            for question in questionList:
+                if question["type"] in types:
+                    questions.append(question)
+                if question["type"] == "Link":
+                    widgetObj = survey_question_type["Link"](question_id = question["qstn_id"])
+                    if widgetObj.getParentType() in types:
+                        questions.append(question)
+            return questions
+
         def survey_build_template_questions(template_id):
             # Get all the questions
             questions = getAllQuestionsForTemplate(template_id)
@@ -672,10 +754,12 @@
                                 (T("Completed Assessments"), "complete"),
                                 (T("Series Details"), "read"),
                                 (T("Series Summary"),"series_summary/"),
+                                (T("Series Analysis"),"series_analysis/"),
                                 ]
                     else:
                         tabs = [(T("Series Details"), "read"),
                                 (T("Series Summary"),"series_summary/"),
+                                (T("Series Analysis"),"series_analysis/"),
                                ]
                         
                     rheader_tabs = s3_rheader_tabs(r, tabs)
@@ -832,35 +916,29 @@
         def survey_serieslist_dataTable_post(r):
             s3_action_buttons(r)
             if auth.s3_has_permission("create", tablename):
-                response.s3.actions = [
-                                       dict(label=str(T("Open")),
-                                            _class="action-btn",
-                                            url=URL(c=module,
-                                                    f="newAssessment",
-                                                    vars={"viewing":"survey_series.[id]"})
-                                           ),
-                                       dict(label=str(T("Analysis")),
-                                            _class="action-btn",
-                                            url=URL(c=module,
-                                                    f="series_summary",
-                                                    args=["[id]"])
-                                           ),
-                                      ]
+                openFunction = "newAssessment"
             else:
-                response.s3.actions = [
-                                       dict(label=str(T("Open")),
-                                            _class="action-btn",
-                                            url=URL(c=module,
-                                                    f="series",
-                                                    vars={"viewing":"survey_series.[id]"})
-                                           ),
-                                       dict(label=str(T("Analysis")),
-                                            _class="action-btn",
-                                            url=URL(c=module,
-                                                    f="series_summary",
-                                                    vars={"viewing":"survey_series.[id]"})
-                                           ),
-                                      ]
+                openFunction = "series"
+            response.s3.actions = [
+                                   dict(label=str(T("Open")),
+                                        _class="action-btn",
+                                        url=URL(c=module,
+                                                f=openFunction,
+                                                vars={"viewing":"survey_series.[id]"})
+                                       ),
+                                   dict(label=str(T("Analysis")),
+                                        _class="action-btn",
+                                        url=URL(c=module,
+                                                f="series_summary",
+                                                args=["[id]"])
+                                       ),
+                                   dict(label=str(T("Excel")),
+                                        _class="action-btn",
+                                        url=URL(c=module,
+                                                f="series_export",
+                                                args=["[id]"])
+                                       ),
+                                  ]
 
         def survey_answerlist_dataTable_post(r):
             s3_action_buttons(r)
@@ -1167,8 +1245,14 @@
             survey_build_template_questions = survey_build_template_questions,
             survey_build_complete_questions = survey_build_complete_questions,
             survey_build_completed_list = survey_build_completed_list,
+            survey_getSeriesFromID = survey_getSeriesFromID,
             survey_save_answers_for_complete = survey_save_answers_for_complete,
             survey_getAllAnswersForQuestionInSeries = getAllAnswersForQuestionInSeries,
+            survey_get_series_questions = survey_get_series_questions,
+            survey_get_series_questions_of_type = survey_get_series_questions_of_type,
+            survey_getAllQuestionsForSeries = getAllQuestionsForSeries,
+            survey_getQuestionFromCode = survey_getQuestionFromCode,
+            survey_getQuestionFromName = survey_getQuestionFromName,
             )
 
         return return_dict

=== modified file 'modules/s3/s3survey.py'
--- modules/s3/s3survey.py	2011-09-24 08:31:16 +0000
+++ modules/s3/s3survey.py	2011-09-26 09:46:25 +0000
@@ -41,6 +41,9 @@
     _debug = lambda m: None
 
 try:
+    # NOTE matplotlib requires a directory to write temp files to.
+    #      If it is unable to create or write to this directory
+    #      then it will raise a RunTimeError.
     import matplotlib
     # need to set up the back end before importing pyplot
     try:
@@ -50,7 +53,7 @@
         matplotlib.use('Agg')
     import matplotlib.pyplot as plt
     from pylab import savefig
-except:
+except ImportError:
     print >> sys.stderr, "S3 Debug: S3Survey: matplotlib Library not installed"
 
 try:
@@ -68,10 +71,14 @@
         output = StringIO()
         output.write(msg)
         response.body = output
+        return
     # draw the histogram
     ax.hist(data, bins=bins, range=(min,max))
     # Set up the response headers and body
-    response.headers['Content-Type']="image/png"
+    try:
+        response.headers['Content-Type']="image/png"
+    except:
+        pass
     savefig(response.body)
 
 def survey_pie(response, data, label):
@@ -84,6 +91,7 @@
         output = StringIO()
         output.write(msg)
         response.body = output
+        return
     # draw a pie chart
     ax.pie(data, labels=label)
     # Set up the response headers and body
@@ -723,6 +731,10 @@
         except:
             return DIV("Link", _class="surveyLinkWidget")
 
+    def getParentType(self):
+        self._store_metadata()
+        return self.get("Type")
+
     def getParentQstnID(self):
         db = current.db
         parent = self.get("Parent")
@@ -819,7 +831,7 @@
         link = A(current.T("Chart"), _href=src, _target="blank",  _class="action-btn")
         return DIV(link, _class="surveyChart%sWidget" % self.type)
 
-    def drawChart(self, response):
+    def drawChart(self, response, data = None, label = None):
         msg = "Programming Error: No chart for %sWidget" % self.type
         output = StringIO()
         output.write(msg)
@@ -838,7 +850,35 @@
         for (key, value) in self.result:
             table.append(TR(TD(B(key)),TD(value)))
         return table
-            
+
+    def groupData(self, groupAnswer):
+        grouped = {}
+        answers = {}
+        for answer in self.answerList:
+            answers[answer["complete_id"]] = answer["value"]
+        for ganswer in groupAnswer:
+            gcode = ganswer["complete_id"]
+            greply = ganswer["value"]
+            if gcode in answers:
+                value = answers[gcode]
+            else:
+                continue
+            if greply in grouped:
+                grouped[greply].append(value)
+            else:
+                grouped[greply] = [value]
+        return grouped
+
+    def filter(self, filterType, groupedData):
+        return groupedData
+
+    def splitGroupedData(self, groupedData):
+        keys = []
+        values = []
+        for (key, value) in groupedData.items():
+            keys.append(key)
+            values.append(value)
+        return (keys, values)
 
 class S3StringAnalysis(S3AbstractAnalysis):
 
@@ -936,8 +976,23 @@
             return None
         return S3AbstractAnalysis.chartButton(self)
 
-    def drawChart(self, response):
-        survey_hist(response, self.valueList, 10, 0, self.max)
+    def drawChart(self, response, data = None, label = None):
+        if data == None:
+            survey_hist(response, self.valueList, 10, 0, self.max)
+        else:
+            survey_pie(response, data, label)
+
+    def filter(self, filterType, groupedData):
+        filteredData = {}
+        if filterType == "Sum":
+            sum = 0
+            for (key, valueList) in groupedData.items():
+                for value in valueList:
+                    sum += self.castRawAnswer(value)
+                filteredData[key] = sum
+            return filteredData
+        return groupedData
+
 
 class S3OptionAnalysis(S3AbstractAnalysis):
 
@@ -970,7 +1025,7 @@
             for (key, value) in self.list.items():
                 self.listp[key] = "%s%%" %((100 * value) / self.cnt)
 
-    def drawChart(self, response):
+    def drawChart(self, response, data = None, label = None):
         data = []
         label = []
         for (key, value) in self.list.items():
@@ -1149,3 +1204,9 @@
 
     def chartButton(self):
         return self.widget.chartButton()
+
+    def filter(self, filterType, groupedData):
+        return self.widget.filter(filterType, groupedData)
+
+    def drawChart(self, response, data = None, label = None):
+        return self.widget.drawChart(response, data, label)

=== added file 'views/survey/series_analysis.html'
--- views/survey/series_analysis.html	1970-01-01 00:00:00 +0000
+++ views/survey/series_analysis.html	2011-09-26 09:46:25 +0000
@@ -0,0 +1,10 @@
+{{extend "layout.html"}}
+{{try:}}
+  {{=chart}}
+{{except:}}
+{{pass}}
+{{try:}}
+  {{=sform}}
+{{except:}}
+{{pass}}
+{{include "_create.html"}}