Close previously opened command prompt/s, and open a Visual Studio 2008

Command Prompt (**IMPORTANT!!**). To do so, go to Start Menu, and then open

"Microsoft Visual C++ 2008 Express Edition" -> "Visual Studio Tools" ->

"Visual Studio 2008 Command Prompt"

.. note::

   64bit: For 64bit you need to modify the shortcut that is used to start the

   Visual Studio 2008 Command Prompt. Use right-mouse click to open properties.

Change commandline from::

%comspec% /k ""C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcvarsall.bat"" x86

to::

%comspec% /k ""C:\Program Files (x86)\Microsoft Visual Studio 9.0\VC\vcvarsall.bat"" amd64

In that CMD (loaded with VS2008 PATHs) type::

  cd C:\Kallithea\Env\Scripts (or similar)

  activate

The prompt will change into "(Env) C:\\Kallithea\\Env\\Scripts" or similar

(depending of your folder structure). Then type::

 pip install kallithea

(long step, please wait until fully complete)

Some warnings will appear, don't worry as they are normal.

Step8 - Configuring Kallithea

-----------------------------

steps taken from http://packages.python.org/Kallithea/setup.html

You have to use the same Visual Studio 2008 command prompt as Step7, so

if you closed it reopen it following the same commands (including the

"activate" one). When ready, just type::

  cd C:\Kallithea\Bin

  paster make-config Kallithea production.ini

port, mail settings, database, whatever). I recommend using NotePad++

(free) or similar text editor, as it handles well the EndOfLine

character differences between Unix and Windows

(http://notepad-plus-plus.org/)

For the sake of simplicity lets run it with the default settings. After

your edits (if any), in the previous Command Prompt, type::

 paster setup-db production.ini

(this time a NEW database will be installed, you must follow a different

step to later UPGRADE to a newer Kallithea version)

The script will ask you for confirmation about creating a NEW database,

answer yes (y)

The script will ask you for repository path, answer C:\\Kallithea\\Repos

(or similar)

The script will ask you for admin username and password, answer "admin"

+ "123456" (or whatever you want)

The script will ask you for admin mail, answer "admin@xxxx.com" (or

whatever you want)

If you make some mistake and the script does not end, don't worry, start

it again.

Step9 - Running Kallithea

-------------------------

In the previous command prompt, being in the C:\\Kallithea\\Bin folder,

just type::

 paster serve production.ini

Open yout web server, and go to http://127.0.0.1:5000

It works!! :-)

Remark:

If it does not work first time, just Ctrl-C the CMD process and start it

again. Don't forget the "http://" in Internet Explorer

What this Guide does not cover:

- Installing Celery

            h.flash(_("You can't edit this user"), category='warning')

            return redirect(url('users'))

        c.active = 'ips'

        c.user_ip_map = UserIpMap.query()\

            .filter(UserIpMap.user == c.user).all()

        c.inherit_default_ips = c.user.inherit_default_permissions

        c.default_user_ip_map = UserIpMap.query()\

            .filter(UserIpMap.user == User.get_default_user()).all()

        defaults = c.user.get_dict()

        return htmlfill.render(

            render('admin/users/user_edit.html'),

            defaults=defaults,

            encoding="UTF-8",

            force_defaults=False)

    def add_ip(self, id):

        """POST /user_ips:Add an existing item"""

        # url('user_ips', id=ID, method='put')

        ip = request.POST.get('new_ip')

        user_model = UserModel()

        try:

            user_model.add_extra_ip(id, ip)

            Session().commit()

            h.flash(_("Added ip %s to user whitelist") % ip, category='success')

        except formencode.Invalid, error:

            msg = error.error_dict['ip']

            h.flash(msg, category='error')

        except Exception:

            log.error(traceback.format_exc())

            h.flash(_('An error occurred during ip saving'),

                    category='error')

        if 'default_user' in request.POST:

            return redirect(url('admin_permissions_ips'))

        return redirect(url('edit_user_ips', id=id))

    def delete_ip(self, id):

        """DELETE /user_ips_delete/id: Delete an existing item"""

        # url('user_ips_delete', id=ID, method='delete')

        ip_id = request.POST.get('del_ip_id')

        user_model = UserModel()

        user_model.delete_extra_ip(id, ip_id)

        Session().commit()

        if 'default_user' in request.POST:

            return redirect(url('admin_permissions_ips'))

        return redirect(url('edit_user_ips', id=id))

class RecaptchaResponse(object):

    def __init__(self, is_valid, error_code=None):

        self.is_valid = is_valid

        self.error_code = error_code

    def __repr__(self):

        return '<RecaptchaResponse:%s>' % (self.is_valid)

def displayhtml(public_key, use_ssl=False, error=None):

    """Gets the HTML to display for reCAPTCHA

    public_key -- The public api key

    use_ssl -- Should the request be sent over ssl?

    error -- An error message to display (from RecaptchaResponse.error_code)"""

    error_param = ''

    if error:

        error_param = '&error=%s' % error

    if use_ssl:

        server = API_SSL_SERVER

    else:

        server = API_SERVER

    return """<script type="text/javascript" src="%(ApiServer)s/challenge?k=%(PublicKey)s%(ErrorParam)s"></script>

<noscript>

  <iframe src="%(ApiServer)s/noscript?k=%(PublicKey)s%(ErrorParam)s" height="300" width="500" frameborder="0"></iframe><br />

  <textarea name="recaptcha_challenge_field" rows="3" cols="40"></textarea>

  <input type='hidden' name='recaptcha_response_field' value='manual_challenge' />

</noscript>

""" % {

        'ApiServer': server,

        'PublicKey': public_key,

        'ErrorParam': error_param,

    }

def submit(recaptcha_challenge_field, recaptcha_response_field, private_key,

           remoteip):

    """

    Submits a reCAPTCHA request for verification. Returns RecaptchaResponse

    for the request

    recaptcha_challenge_field -- The value of recaptcha_challenge_field from the form

    recaptcha_response_field -- The value of recaptcha_response_field from the form

    private_key -- your reCAPTCHA private key

    """

    if not (recaptcha_response_field and recaptcha_challenge_field and

                len(recaptcha_response_field) and len(

            recaptcha_challenge_field)):

        return RecaptchaResponse(is_valid=False,

                                 error_code='incorrect-captcha-sol')

    def encode_if_necessary(s):

        if isinstance(s, unicode):

            return s.encode('utf-8')

        return s

    params = urllib.urlencode({

        'privatekey': encode_if_necessary(private_key),

        'remoteip': encode_if_necessary(remoteip),

        'challenge': encode_if_necessary(recaptcha_challenge_field),

        'response': encode_if_necessary(recaptcha_response_field),

    })

    request = urllib2.Request(

        url="http://%s/recaptcha/api/verify" % VERIFY_SERVER,

        data=params,

        headers={

            "Content-type": "application/x-www-form-urlencoded",

            "User-agent": "reCAPTCHA Python"

        }

    )

    httpresp = urllib2.urlopen(request)

    return_values = httpresp.read().splitlines()

    httpresp.close()

    return_code = return_values[0]

    if return_code == "true":

        return RecaptchaResponse(is_valid=True)

    else:

        return RecaptchaResponse(is_valid=False, error_code=return_values[1])

    if _group:

        _group = _group.rstrip('/')

    return _group

def get_user_group_slug(request):

    _group = request.environ['pylons.routes_dict'].get('id')

    _group = UserGroup.get(_group)

    if _group:

        return _group.users_group_name

    return None

def _extract_id_from_repo_name(repo_name):

    if repo_name.startswith('/'):

        repo_name = repo_name.lstrip('/')

    by_id_match = re.match(r'^_(\d{1,})', repo_name)

    if by_id_match:

        return by_id_match.groups()[0]

def get_repo_by_id(repo_name):

    """

    Extracts repo_name by id from special urls. Example url is _11/repo_name

    :param repo_name:

    :return: repo_name if matched else None

    """

    _repo_id = _extract_id_from_repo_name(repo_name)

    if _repo_id:

        from kallithea.model.db import Repository

        repo = Repository.get(_repo_id)

        if repo:

            # TODO: return repo instead of reponame? or would that be a layering violation?

            return repo.repo_name

    return None

def action_logger(user, action, repo, ipaddr='', sa=None, commit=False):

    """

    Action logger for various actions made by users

    :param user: user that made this action, can be a unique username string or

        object containing user_id attribute

    :param action: action to log, should be on of predefined unique actions for

        easy translations

    :param repo: string name of repository or object containing repo_id,

        that action was made on

    :param sa: optional sqlalchemy session

    """

    if not sa:

        sa = meta.Session()

    # if we don't get explicit IP address try to get one from registered user

    # in tmpl context var

    if not ipaddr:

        ipaddr = getattr(get_current_authuser(), 'ip_addr', '')

    if getattr(user, 'user_id', None):

        user_obj = User.get(user.user_id)

    elif isinstance(user, basestring):

        user_obj = User.get_by_username(user)

    else:

        raise Exception('You have to provide a user object or a username')

    if getattr(repo, 'repo_id', None):

        repo_obj = Repository.get(repo.repo_id)

        repo_name = repo_obj.repo_name

    elif isinstance(repo, basestring):

        repo_name = repo.lstrip('/')

        repo_obj = Repository.get_by_repo_name(repo_name)

    else:

        repo_obj = None

        repo_name = ''

    user_log = UserLog()

    user_log.user_id = user_obj.user_id

    user_log.username = user_obj.username

    user_log.action = safe_unicode(action)

    user_log.repository = repo_obj

    user_log.repository_name = repo_name

    user_log.action_date = datetime.datetime.now()

    user_log.user_ip = ipaddr

    sa.add(user_log)

    log.info('Logging action:%s on %s by user:%s ip:%s' %

             (action, safe_unicode(repo), user_obj, ipaddr))

    if commit:

        sa.commit()

def get_filesystem_repos(path, recursive=False, skip_removed_repos=True):

    """

    def revoke_perm(self, user, perm):

        """

        Revoke users global permissions

        :param user:

        :param perm:

        """

        user = self._get_user(user)

        perm = self._get_perm(perm)

        UserToPerm.query().filter(

            UserToPerm.user == user,

            UserToPerm.permission == perm,

        ).delete()

    def add_extra_email(self, user, email):

        """

        Adds email address to UserEmailMap

        :param user:

        :param email:

        """

        from kallithea.model import forms

        form = forms.UserExtraEmailForm()()

        data = form.to_python(dict(email=email))

        user = self._get_user(user)

        obj = UserEmailMap()

        obj.user = user

        obj.email = data['email']

        self.sa.add(obj)

        return obj

    def delete_extra_email(self, user, email_id):

        """

        Removes email address from UserEmailMap

        :param user:

        :param email_id:

        """

        user = self._get_user(user)

        obj = UserEmailMap.query().get(email_id)

        if obj:

            self.sa.delete(obj)

    def add_extra_ip(self, user, ip):

        """

        :param user:

        :param ip:

        """

        from kallithea.model import forms

        form = forms.UserExtraIpForm()()

        data = form.to_python(dict(ip=ip))

        user = self._get_user(user)

        obj = UserIpMap()

        obj.user = user

        obj.ip_addr = data['ip']

        self.sa.add(obj)

        return obj

    def delete_extra_ip(self, user, ip_id):

        """

        :param user:

        :param ip_id:

        """

        user = self._get_user(user)

        obj = UserIpMap.query().get(ip_id)

        if obj:

            self.sa.delete(obj)

<div class="ips_wrap">

      <table class="noborder">

      %if c.user_ip_map:

        %for ip in c.user_ip_map:

          <tr>

              <td><div class="ip">${ip.ip_addr}</div></td>

              <td><div class="ip">${h.ip_range(ip.ip_addr)}</div></td>

              <td>

                ${h.form(url('edit_user_ips', id=c.user.user_id),method='delete')}

                    ${h.hidden('del_ip_id',ip.ip_id)}

                    ${h.hidden('default_user', 'True')}

                    <i class="icon-minus-circled" style="color:#FF4444"></i> ${h.submit('remove_',_('delete'),id="remove_ip_%s" % ip.ip_id,

                ${h.end_form()}

              </td>

          </tr>

        %endfor

       %else:

        <tr><td><div class="ip">${_('All IP addresses are allowed.')}</div></td></tr>

       %endif

      </table>

</div>

${h.form(url('edit_user_ips', id=c.user.user_id),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

             <div class="field">

                <div class="label">

                </div>

                <div class="input">

                    ${h.hidden('default_user', 'True')}

                    ${h.text('new_ip', class_='medium')}

                </div>

             </div>

            <div class="buttons">

              ${h.submit('save',_('Add'),class_="btn")}

              ${h.reset('reset',_('Reset'),class_="btn")}

            </div>

        </div>

    </div>

${h.end_form()}

<div class="ips_wrap">

  <table class="noborder">

    %if c.default_user_ip_map and c.inherit_default_ips:

        %for ip in c.default_user_ip_map:

          <tr>

            <td><div class="ip">${ip.ip_addr}</div></td>

            <td><div class="ip">${h.ip_range(ip.ip_addr)}</div></td>

            <td>${h.literal(_('Inherited from %s') % h.link_to('*default*',h.url('admin_permissions_ips')))}</td>

          </tr>

        %endfor

    %endif

    %if c.user_ip_map:

        %for ip in c.user_ip_map:

          <tr>

            <td><div class="ip">${ip.ip_addr}</div></td>

            <td><div class="ip">${h.ip_range(ip.ip_addr)}</div></td>

            <td>

                ${h.form(url('edit_user_ips', id=c.user.user_id),method='delete')}

                    ${h.hidden('del_ip_id',ip.ip_id)}

                    <i class="icon-minus-circled" style="color:#FF4444"></i>

                    ${h.submit('remove_',_('delete'),id="remove_ip_%s" % ip.ip_id,

                ${h.end_form()}

            </td>

          </tr>

        %endfor

    %endif

    %if not c.default_user_ip_map and not c.user_ip_map:

        <tr><td><div class="ip">${_('All IP addresses are allowed.')}</div></td></tr>

    %endif

  </table>

</div>

<div>

    ${h.form(url('edit_user_ips', id=c.user.user_id),method='put')}

    <div class="form">

        <!-- fields -->

        <div class="fields">

             <div class="field">

                <div class="label">

                </div>

                <div class="input">

                    ${h.text('new_ip', class_='medium')}

                </div>

             </div>

            <div class="buttons">

              ${h.submit('save',_('Add'),class_="btn")}

              ${h.reset('reset',_('Reset'),class_="btn")}

            </div>

        </div>

    </div>

    ${h.end_form()}

</div>