@locked_task

def get_commits_stats(repo_name, ts_min_y, ts_max_y):

    from rhodecode.model.db import Statistics, Repository

    log = get_commits_stats.get_logger()

    #for js data compatibilty

    author_key_cleaner = lambda k: person(k).replace('"', "")

    commits_by_day_author_aggregate = {}

    commits_by_day_aggregate = {}

    repos_path = get_repos_path()

    p = os.path.join(repos_path, repo_name)

    repo = get_repo(p)

    skip_date_limit = True

    parse_limit = 250 #limit for single task changeset parsing optimal for

    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 not repo.revisions:

        return True

    if last_rev == repo.revisions[-1] and len(repo.revisions) > 1:

        #pass silently without any work if we're not on first revision or 

        #current state of parsing revision(from db marker) is the last revision

        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)

    log.debug('starting parsing %s', parse_limit)

    lmktime = mktime

    last_rev = last_rev + 1 if last_rev > 0 else last_rev

    for rev in repo.revisions[last_rev:last_rev + parse_limit]:

        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)

            else:

                if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                    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)

        else:

            if k >= ts_min_y and k <= ts_max_y or skip_date_limit:

                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

        else:

            commits_by_day_aggregate[k] = 1

    if not commits_by_day_author_aggregate:

        commits_by_day_author_aggregate[author_key_cleaner(repo.contact)] = {

            "label":author_key_cleaner(repo.contact),

            "data":[0, 1],

            "schema":["commits"],

        }

    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)

    log.debug('last revison %s', last_rev)

    leftovers = len(repo.revisions[last_rev:])

    log.debug('revisions to parse %s', leftovers)

    if last_rev == 0 or leftovers < parse_limit:

        stats.languages = json.dumps(__get_codes_stats(repo_name))

    stats.repository = dbrepo

    stats.stat_on_revision = last_cs.revision

    try:

        sa.add(stats)

        sa.commit()

    except:

        log.error(traceback.format_exc())

        sa.rollback()

        return False

    if len(repo.revisions) > 1:

        run_task(get_commits_stats, repo_name, ts_min_y, ts_max_y)

    return True

@task

def reset_user_password(user_email):

    log = reset_user_password.get_logger()

    from rhodecode.lib import auth

    from rhodecode.model.db import User

    try:

        try:

            sa = get_session()

            user = sa.query(User).filter(User.email == user_email).scalar()

            new_passwd = auth.PasswordGenerator().gen_password(8,

                             auth.PasswordGenerator.ALPHABETS_BIG_SMALL)

            if user:

                user.password = auth.get_crypt_password(new_passwd)

                sa.add(user)