CELERY_RESULT_SERIALIZER = 'json'

#Tasks will never be sent to the queue, but executed locally instead.

CELERY_ALWAYS_EAGER = False

#===============================================================================

# EMAIL SETTINGS

#===============================================================================

pylons_email_config = dict(config.items('DEFAULT'))

CELERY_SEND_TASK_ERROR_EMAILS = True

#List of (name, email_address) tuples for the admins that should receive error e-mails.

ADMINS = [('Administrator', pylons_email_config.get('email_to'))]

#The e-mail address this worker sends e-mails from. Default is "celery@localhost".

SERVER_EMAIL = pylons_email_config.get('error_email_from')

#The mail server to use. Default is "localhost".

MAIL_HOST = pylons_email_config.get('smtp_server')

#Username (if required) to log on to the mail server with.

MAIL_HOST_USER = pylons_email_config.get('smtp_username')

#Password (if required) to log on to the mail server with.

MAIL_HOST_PASSWORD = pylons_email_config.get('smtp_password')

MAIL_PORT = pylons_email_config.get('smtp_port')

#===============================================================================

# INSTRUCTIONS FOR RABBITMQ

#===============================================================================

# rabbitmqctl add_user rabbitmq qweqwe

# rabbitmqctl add_vhost rabbitmqhost

# rabbitmqctl set_permissions -p rabbitmqhost rabbitmq ".*" ".*" ".*"

from pylons_app.model.db import Statistics

from datetime import datetime, timedelta

from time import mktime

import calendar

        td = datetime.today() + timedelta(days=1) 

        y, m, d = td.year, td.month, td.day

        ts_min_y = mktime((y - 1, (td - timedelta(days=calendar.mdays[m])).month,

                            d, 0, 0, 0, 0, 0, 0,))

        ts_min_m = mktime((y, (td - timedelta(days=calendar.mdays[m])).month,

                            d, 0, 0, 0, 0, 0, 0,))

        ts_max_y = mktime((y, m, d, 0, 0, 0, 0, 0, 0,))

        run_task(get_commits_stats, c.repo_info.name, ts_min_y, ts_max_y)

        c.ts_min = ts_min_m

        c.ts_max = ts_max_y

        stats = self.sa.query(Statistics)\

            .filter(Statistics.repository == c.repo_info.dbrepo)\

            .scalar()

        if stats:

            c.commit_data = stats.commit_activity

            c.overview_data = stats.commit_activity_combined

        else:

            import json

            c.commit_data = json.dumps({})

            c.overview_data = json.dumps([[ts_min_y, 0], [ts_max_y, 0] ])

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    author_key_cleaner = lambda k: person(k).replace('"', "") #for js data compatibilty

    from pylons_app.model.db import Statistics, Repository

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    repo = MercurialRepository(repos_path + repo_name)

    skip_date_limit = True

    parse_limit = 500 #limit for single task changeset parsing

    last_rev = 0

    last_cs = None

    timegetter = itemgetter('time')

    sa = get_session()

    dbrepo = sa.query(Repository)\

        .filter(Repository.repo_name == repo_name).scalar()

    cur_stats = sa.query(Statistics)\

        .filter(Statistics.repository == dbrepo).scalar()

    if cur_stats:

        last_rev = cur_stats.stat_on_revision

    if last_rev == repo.revisions[-1]:

        #pass silently without any work

        return True

    if cur_stats:

        commits_by_day_aggregate = OrderedDict(

                                       json.loads(

                                        cur_stats.commit_activity_combined))

        commits_by_day_author_aggregate = json.loads(cur_stats.commit_activity)

    for cnt, rev in enumerate(repo.revisions[last_rev:]):

        last_cs = cs = repo.get_changeset(rev)

        if commits_by_day_author_aggregate.has_key(author_key_cleaner(cs.author)):

            try:

                l = [timegetter(x) for x in commits_by_day_author_aggregate\

                        [author_key_cleaner(cs.author)]['data']]

                time_pos = l.index(k)

            except ValueError:

                time_pos = False

            if time_pos >= 0 and time_pos is not False:

                datadict = commits_by_day_author_aggregate\

                    [author_key_cleaner(cs.author)]['data'][time_pos]

                datadict["commits"] += 1

                datadict["added"] += len(cs.added)

                datadict["changed"] += len(cs.changed)

                datadict["removed"] += len(cs.removed)

                #print datadict

                #print 'ELSE !!!!'

                    datadict = {"time":k,

                                "commits":1,

                                "added":len(cs.added),

                                "changed":len(cs.changed),

                                "removed":len(cs.removed),

                               }

                    commits_by_day_author_aggregate\

                        [author_key_cleaner(cs.author)]['data'].append(datadict)

            #print k, 'nokey ADDING'

                commits_by_day_author_aggregate[author_key_cleaner(cs.author)] = {

                                    "label":author_key_cleaner(cs.author),

                                    "data":[{"time":k,

                                             "commits":1,

                                             "added":len(cs.added),

                                             "changed":len(cs.changed),

                                             "removed":len(cs.removed),

                                             }],

                                    "schema":["commits"],

                                    }               

#        #gather all data by day

        if commits_by_day_aggregate.has_key(k):

            commits_by_day_aggregate[k] += 1

            commits_by_day_aggregate[k] = 1

        if cnt >= parse_limit:

            #don't fetch to much data since we can freeze application

            break

    for k, v in commits_by_day_aggregate.items():

    if not commits_by_day_author_aggregate:

        commits_by_day_author_aggregate[author_key_cleaner(repo.contact)] = {

    stats = cur_stats if cur_stats else Statistics()

    stats.commit_activity = json.dumps(commits_by_day_author_aggregate)

    stats.commit_activity_combined = json.dumps(overview_data)

    stats.repository = dbrepo

    stats.stat_on_revision = last_cs.revision

    stats.languages = json.dumps({'_TOTAL_':0, '':0})

    try:

        sa.add(stats)

        sa.commit()    

    except:

        log.error(traceback.format_exc())

        sa.rollback()

        return False

    return True

            if user:

                user.password = auth.get_crypt_password(new_passwd)

                sa.add(user)

                sa.commit()

                log.info('change password for %s', user_email)

class Statistics(Base):

    __tablename__ = 'statistics'

    __table_args__ = (UniqueConstraint('repository_id'), {'useexisting':True})

    stat_id = Column("stat_id", INTEGER(), nullable=False, unique=True, default=None, primary_key=True)

    repository_id = Column("repository_id", INTEGER(), ForeignKey(u'repositories.repo_id'), nullable=False, unique=True, default=None)

    stat_on_revision = Column("stat_on_revision", INTEGER(), nullable=False)

    commit_activity = Column("commit_activity", BLOB(), nullable=False)#JSON data

    commit_activity_combined = Column("commit_activity_combined", BLOB(), nullable=False)#JSON data

    languages = Column("languages", BLOB(), nullable=False)#JSON data

    repository = relation('Repository')

        <h5>${_('Commit activity by day / author')}</h5>