def createReport(openbadgerDB, csolDB):
  cur = csolDB.cursor()

  queryString = ("SELECT "
                 "CASE "
                 "WHEN age < 13 THEN 'Under 13' "
                 "WHEN age BETWEEN 13 AND 17 THEN '13-17' "
                 "WHEN age BETWEEN 18 AND 24 THEN '18-24' "
		              "WHEN age > 24 THEN 'Over 24' "
                  "END AS age_range, "
                  "COUNT(*) AS count "
                  "FROM (SELECT TIMESTAMPDIFF(YEAR, birthday, CURDATE()) AS age FROM csol.Learners) AS derived "
                  "GROUP BY age_range "
                  "ORDER BY FIELD(age_range, 'Under 13', '13-17', '18-24', 'Over 24'); ")
                
  cur.execute(queryString)

  report = Report('Learners by Age', 2)
  
  for row in cur.fetchall():
    age = row[0]
    count = row[1]
    
    report.addRow([age, count])
  
  return report
  

def createReport(openbadgerDB, csolDB):
  cur = csolDB.cursor()

  queryString = ('SELECT '
                  'CASE '
                  '  WHEN gender = "male" THEN "Male" '
                  '  WHEN gender = "female" THEN "Female" '
                  '  ELSE "Not Specified" '
                  'END AS gender_readable, '
                  'COUNT(*) as count '
                  'FROM csol.Learners '
                  'GROUP BY gender '
                  'ORDER BY FIELD(gender_readable, "Female", "Male", "Not Specified");')
                
  cur.execute(queryString)

  report = Report('Learners by Gender', 2)
  
  for row in cur.fetchall():
    gender = row[0]
    count = row[1]

    if gender is None or gender == '':
      gender = 'Not Specified'

    report.addRow([gender.title(), count])

  return report

    def report(self, start, finish, report_type, report_format, locale=None):
        if start >= finish:
            raise errors.StartShouldBeEarlierFinish()

        if not Report.is_supported(report_type, report_format):
            raise errors.ReportFormatIsNotSupported()

        report_cache = ReportCache()
        report_task = ReportTask()
        report_id = ReportId(start, finish, report_type, report_format, locale)

        data = report_cache.get_report(report_id)

        if data:
            if report_format == "json":
                return {"status": "completed",
                        "report": json.loads(data.decode("utf-8"))}
            filename = Report.generate_file_name(report_type, start, finish, report_format)
            content_disposition = make_content_disposition(filename, bottle.request.environ.get('HTTP_USER_AGENT'))
            return bottle.HTTPResponse(body=data, content_type=Report.content_types[report_format],
                                       content_disposition=content_disposition)

        status = report_task.task_status(report_id)
        if not status:
            result = report_file_generate.delay(report_id)
            logbook.info("Created report_file task {} for {}", result.id, report_id)
            report_task.set(report_id, result.id)
            status = "started"
        return {"status": status}

def createReport(openbadgerDB, csolDB):
  badges = openbadgerDB.badges
  
  steamBadgeDocuments = openbadgerDB.badges.find( {'categoryAward' : { '$nin': ['', None] } }, fields=['_id']);
  steamBadges = []
  for document in steamBadgeDocuments:
    steamBadges.append(document['_id'])
  
  badgeinstances = openbadgerDB.badgeinstances

  pipeline = [{'$match' : {'badge' : { '$in' : steamBadges } } },
              {'$group' : {'_id' : '$user', 'count' : {'$sum' : 1}}},
              {'$group' : {'_id' : '$count', 'count' : {'$sum' : 1}}}]
              
  results = badgeinstances.aggregate(pipeline)['result']

  report = Report('Learners by STEAM Badges Earned', 2)
  
  countList = [0,0,0,0,0]
  
  for row in results:
    countList[row['_id']-1] = row['count']
  
  for i in range(len(countList)):
    report.addRow([i+1, countList[i]])

  return report

def main(argv=None):
    directory = ''
    if argv is None:
        argv = sys.argv
    try:
        try:
            opts, args = getopt.getopt(argv[1:], "hd:v", ["help", "directory="])
        except getopt.error, msg:
            raise Usage(msg)
        
        # option processing
        for option, value in opts:
            if option == "-v":
                verbose = True
            if option in ("-h", "--help"):
                raise Usage(help_message)
            if option in ("-d", "--directory"):
                directory = value
    
        from attusage import AttUsage
        from report import Report, Directory
        usage = AttUsage()
        for filename in args:   
            usage.process(filename)
        directory = Directory(directory)
        report = Report(usage, directory=directory)
        for line in report.text():
          print line

    def _attack(self, army, report):
        if report:
            rep = Report()
        else:
            rep = None

        selfiter = iter(self)
        armyiter = iter(army)

        ours = advance_iter(selfiter)
        theirs = advance_iter(armyiter)

        while ours is not None and theirs is not None:
            if report:
                rep.start_round(ours, theirs)

            left1, left2 = ours.fight_with(theirs)

            if report:
                rep.end_round(left1, left2)

            if left1 == 0:
                ours = advance_iter(selfiter)
            if left2 == 0:
                theirs = advance_iter(armyiter)

        return (self.get_real_len() > army.get_real_len(), rep)

def console_report():
    """Runs a report from the cli."""

    args = parser.parse_args()
    conf = config.load(args.config_file)
    logger.setLevel(LOG_LEVELS.get(args.log_level.lower(), 'info'))

    manager = ClientManager(**conf.get('auth_kwargs', {}))
    ceilometer = manager.get_ceilometer()

    if args.mtd:
        start, stop = utils.mtd_range()
    elif args.today:
        start, stop = utils.today_range()
    elif args.last_hour:
        start, stop = utils.last_hour_range()
    else:
        start, stop = utils.mtd_range()

    r = Report(
        ceilometer,
        args.definition_filename,
        args.csv_filename,
        start=start,
        stop=stop
    )
    r.run()

    def generate_disturbing(self):

        self.NIVEL_ATUAL_PERT = random.randint(simconfig.BASE_DISTURBING_LEVEL-simconfig.INTERVAL_DISTURBING_LEVEL, simconfig.BASE_DISTURBING_LEVEL+simconfig.INTERVAL_DISTURBING_LEVEL)
        intervaloProximaPerturbacao = random.randint(simconfig.BASE_DISTURBING_PERIOD - simconfig.INTERVAL_DISTURBING_PERIOD, simconfig.BASE_DISTURBING_PERIOD + simconfig.INTERVAL_DISTURBING_PERIOD)
        
        Report.add_disturbing(str(self.NIVEL_ATUAL_PERT), str(intervaloProximaPerturbacao), self.simpyEnvironment.now)
        
        return intervaloProximaPerturbacao

def console_report():
    """Runs a report from the cli."""
    args = report_parser.parse_args()
    conf = config.load(args.config_file)
    logger.setLevel(LOG_LEVELS.get(args.log_level.lower(), 'info'))

    manager = ClientManager(**conf.get('auth_kwargs', {}))
    ceilometer = manager.get_ceilometer()

    out = output.Stream() if args.use_stdout else None

    if args.mtd:
        start, stop = utils.mtd_range()
        out = out or output.Mtd(args.output_directory, start, stop)
    elif args.today:
        start, stop = utils.today_range()
        out = out or output.Daily(args.output_directory, start, stop)
    elif args.last_hour:
        start, stop = utils.last_hour_range()
        out = out or output.Hourly(args.output_directory, start, stop)

    # If stop is provided, check for start
    elif args.stop:
        if not args.start:
            raise Exception('Provide --start if also using --stop')
        start = args.start
        stop = args.stop
        out = out or output.Other(args.output_directory, start, stop)

    # If start is provided, check for stop. If stop not provided,
    # default to now
    elif args.start:
        start = args.start
        _, now = utils.mtd_range()
        stop = args.stop or now
        out = out or output.Other(args.output_directory, start, stop)

    # Default to month to date
    else:
        start, stop = utils.mtd_range()
        out = out or output.Mtd(args.output_directory, start, stop)
    try:
        p_start = time.time()
        r = Report(
            ceilometer,
            args.definition_filename,
            out,
            start=start,
            stop=stop,
            max_samples=args.max_samples
        )
        r.run()
        logger.debug("Finished in {} seconds".format(time.time() - p_start))
    finally:
        out.close()

    if args.show_tags:
        print tag.all()

	def stockreport(self):
		name=os.path.join(FILEPATH,'safety_shoes_stock_report.csv')
		temp_issue_worker_report=tkFileDialog.asksaveasfilename(defaultextension='.csv',filetypes=[('Excel Files','*.csv')],initialdir='C:\\',initialfile=name,title='Save')
		if os.path.exists(temp_issue_worker_report):
			os.remove(temp_issue_worker_report)
		x=Report('safety_shoes')
		x.stock_safetyshoes(temp_issue_worker_report)
		print "finished..."
		tkMessageBox.showinfo('Notice','The Report saved already!')

    def run(self):
        print "run()"
        dirname = path.dirname(path.abspath(__file__))
        
        if self.tipo == 'txt':
            relatorio = Report(dirname+'/'+self.name+'.txt')
        relatorio.addTitle("Porous Structure")

        img = Image.open(self.img_name)
        #img = img.convert('L')
        img = binarizeImage(img)

        result = analysis(img)
        img.save('%s_test.jpg'%self.img_name)
        t_analise = Table(name = "Analise de estruturas porosas")

        #titulo das colunas da tabela
        title = [
        "Cor do Poro","Area Poro","Comp. Max. Horiz.",
        "Comp. Max. Vert.","Comp. Max. Medio"
        ]

        for name in title:
            t_analise.addColumnName(name,[])

        for path_img in result[0]:
            t_analise.addColumnValue(title[0], path_img.color)
            t_analise.addColumnValue(title[1], path_img.area)
            t_analise.addColumnValue(title[2], path_img.comprimentoHorizontal())
            t_analise.addColumnValue(title[3], path_img.comprimentoVertical())
            t_analise.addColumnValue(title[4], path_img.comprimentoMedio())

        t_analise.legend = "obs.: comprimentos (px, um, mm)"

        #resultado do intercepto linerar
        inter = intercepto(img)

        #Tabela de intercepto linear
        t_inter = Table(name = "Intercepto Linear")

        t_inter.addColumnName("Poro Vertical", inter["porous_list_vertical"])
        t_inter.addColumnName("Solido Vertical",inter["solid_list_vertical"])
        t_inter.addColumnName("Poro Horizontal", inter["porous_list_horizontal"])
        t_inter.addColumnName("Solido Horizontal",inter["solid_list_horizontal"])

        table_continuo = Table(name = "Continuidade direcional")
        table_continuo.addColumnName("Vertical",inter["solid_list_vertical"])
        table_continuo.addColumnName("Horizontal",inter["solid_list_horizontal"])

        relatorio.addTable(t_analise)
        relatorio.addTable(t_inter)
        relatorio.addTable(table_continuo)

        report_output = relatorio.buildInColumns()
        report_output.close()
        print "fim report"

    def add_worksheet(self, resp_list, building):
        header = Header(self.city, self.street, building)
        data = []

        for resp in resp_list:
            for owner in resp.owner_objs:
                di = DataInstance(resp, owner)
                data.append(di)

        Report.add_worksheet(self, header, data, building)		

def createReport(openbadgerDB, csolDB):
  cur = csolDB.cursor()
  
  report = Report('Other Data', 2)
  
  queryString = ("SELECT COUNT(*) FROM Learners")                
  cur.execute(queryString)
  learnerCount = cur.fetchone()[0]
  report.addRow(['Number of Learners', learnerCount])
  
  badgeInstanceCount = openbadgerDB.badgeinstances.count()
  report.addRow(['Number of Badges Awarded', badgeInstanceCount])
  
  steamBadgeDocuments = openbadgerDB.badges.find( {'categoryAward' : { '$nin': ['', None] } }, fields=['_id']);
  steamBadges = []
  for document in steamBadgeDocuments:
    steamBadges.append(document['_id'])
  steamBadgeInstances = openbadgerDB.badgeinstances.aggregate([{'$match' : {'badge' : { '$in' : steamBadges } } }] )
  steamBadgeInstanceCount = len(steamBadgeInstances['result'])
  report.addRow(['Number of STEAM Badges Awarded', steamBadgeInstanceCount])
  
  queryString = ("SELECT COUNT(*) FROM Playlists")
  cur.execute(queryString)
  wishlistCount = cur.fetchone()[0]
  report.addRow(['Number of Badges Wishlisted', wishlistCount])
 
  return report

	def saveReport(self):
	
		rep = Report('D:\\Projects\\CC v2\\', 'Application Report - '+str(time.strftime("%B %d, %Y"))+'.docx')
		rep.addList(self.good_list, "1 - Applications which went through successfully:")
		rep.addList(self.complex_list, "2 - Applications which did NOT go through, but were close:")
		rep.addList(self.bad_list, "3 - Applications which cannot be automated:")
		rep.saveReport()	

def createReport(openbadgerDB, csolDB):
  learnersByZip = helper_queries.getLearnersByProperty('zipCode')

  report = Report('Top Zip Codes with Learners', 2)
  
  sortedLearnersByZip = sorted(learnersByZip.iteritems(), key=operator.itemgetter(1), reverse=True)
  
  for zip, count in sortedLearnersByZip:
    report.addRow([zip.title().decode('latin-1'), count])
  
  return report

 def post(self):
     data_dict = request.get_json()
     report = Report(**data_dict)
     report.position = [float(s) for s in data_dict["position"]]
     report.save()
     url = url_for(".report_detail", id=str(report.id))
     response = {
         "report": report.as_dict(),
         "url": url
     }
     return JsonResponse(response, status=200)

def createReport(openbadgerDB, csolDB):
  activeLearnersBySchool = helper_queries.getLearnersByProperty('school', badgeThreshold=1)

  report = Report('Top Schools with Active Learners', 2)
  
  sortedActiveLearnersBySchool = sorted(activeLearnersBySchool.iteritems(), key=operator.itemgetter(1), reverse=True)
  
  for school, count in sortedActiveLearnersBySchool:
    report.addRow([school.title().decode('latin-1'), count])
  
  return report

    def calculate_job_cost(disturbind_level, region_size):
        job_cost = disturbind_level - region_size

        erlang_cost = random.gammavariate(simconfig.ERLANG_SHAPE, 1)
        job_cost += int(erlang_cost)

        if job_cost < 1:
            job_cost = 1
            
        Report.add_jobs_costs(job_cost, ControlFunctions.simpyEnvironment.now)
        return job_cost

def cmd_report(args, options):
    if len(args) != 1:
        logging.error('Missing bid')
        return 1
    if not options.output:
        logging.error('Missing --output option')
        return 1
    db = open_db(options)
    report = Report(db, options)
    report.buildReport(args[0])
    db.close()
    return 0

    def executarTrabalho(self):

        if self.simulationEnvironment.jobs > 0:
            self.simulationEnvironment.jobs -= 1
            self.jobsExecuted += 1
            Report.add_jobs_executed_on_nodes(self.identificador)

            return ControlFunctions.calculate_job_cost(self.simulationEnvironment.NIVEL_ATUAL_PERT, self.simulationEnvironment.region._region_size)
        else:
            self.simulationEnvironment.idleLoops += 1
            Report.add_idle_cycle()
            return 1