def rate(self, query_id, rating, *args, **kwargs):
        '''
            Rates the chat. Updates user score and statistics.
            
            @param query_id: needed to identify chat session 
            @param rate:  points given
        '''
        cs = ChatSession.select(ChatSession.c.query_id==query_id)[0];

        if not cs.user_id == identity.current.user.user_id:
            return dict()

        cs.rating = int(rating)
        cs.status = "RATED"
        
        session.save(cs);
        session.flush();

        expert=session.query(User).get_by(user_id=int(cs.expert_id))
        
        stats = expert.user_stats

        new_value=round(stats.average_rating*stats.no_of_ques_answered_rated)
        stats.no_of_ques_answered_rated+=1
        stats.average_rating=(new_value+float(rating))/stats.no_of_ques_answered_rated
        stats.score=round(stats.no_of_ques_answered_rated * stats.average_rating + stats.no_of_blog_ratings * stats.average_blog_rating)
        session.flush();

        return dict()

 def remove(self, **kw):
     item = ConfigItem.by_id(kw['id'])
     item.set(None, None, identity.current.user)
     session.add(item)
     session.flush()
     flash(_(u"%s cleared") % item.description)
     raise redirect(".")

    def test_abort_recipe_bubbles_status_to_job(self):
        xmljob = XmlJob(xmltramp.parse('''
            <job>
                <whiteboard>job </whiteboard>
                <recipeSet>
                    <recipe>
                        <distroRequires>
                            <distro_name op="=" value="BlueShoeLinux5-5" />
                        </distroRequires>
                        <hostRequires/>
                        <task name="/distribution/install" role="STANDALONE">
                            <params/>
                        </task>
                    </recipe>
                </recipeSet>
                <recipeSet>
                    <recipe>
                        <distroRequires>
                            <distro_name op="=" value="BlueShoeLinux5-5" />
                        </distroRequires>
                        <hostRequires/>
                        <task name="/distribution/install" role="STANDALONE">
                            <params/>
                        </task>
                    </recipe>
                </recipeSet>
            </job>
            '''))
        job = self.controller.process_xmljob(xmljob, self.user)
        session.flush()
        for recipeset in job.recipesets:
            for recipe in recipeset.recipes:
                recipe.process()
                recipe.queue()
                recipe.schedule()
                recipe.waiting()

        # Abort the first recipe.
        job.recipesets[0].recipes[0].abort()
        job.update_status()

        # Verify that it and its children are aborted.
        self.assertEquals(job.recipesets[0].recipes[0].status, TaskStatus.aborted)
        for task in job.recipesets[0].recipes[0].tasks:
            self.assertEquals(task.status, TaskStatus.aborted)

        # Verify that the second recipe and its children are still waiting.
        self.assertEquals(job.recipesets[1].recipes[0].status, TaskStatus.waiting)
        for task in job.recipesets[1].recipes[0].tasks:
            self.assertEquals(task.status, TaskStatus.waiting)

        # Verify that the job still shows waiting.
        self.assertEquals(job.status, TaskStatus.waiting)

        # Abort the second recipe now.
        job.recipesets[1].recipes[0].abort()
        job.update_status()

        # Verify that the whole job shows aborted now.
        self.assertEquals(job.status, TaskStatus.aborted)

    def test_group_removal_is_noticed(self):
        self.group.systems.append(self.system)
        session.flush()
        b = self.browser
        login(b)
        b.get(get_server_base() + 'groups/')
        b.find_element_by_xpath("//input[@name='group.text']").clear()
        b.find_element_by_xpath("//input[@name='group.text']").send_keys(self.group.group_name)
        b.find_element_by_id('Search').submit()
        delete_and_confirm(b, "//tr[td/a[normalize-space(text())='%s']]" % self.group.group_name,
            'Remove')
        should_have_deleted_msg = b.find_element_by_xpath('//body').text
        self.assert_('%s deleted' % self.group.display_name in should_have_deleted_msg)

        # Check it's recorded in System Activity
        b.get(get_server_base() + 'activity/system')
        b.find_element_by_link_text('Show Search Options').click()
        b.find_element_by_xpath("//select[@id='activitysearch_0_table']/option[@value='Action']").click()
        b.find_element_by_xpath("//select[@id='activitysearch_0_operation']/option[@value='is']").click()
        b.find_element_by_xpath("//input[@id='activitysearch_0_value']").send_keys('Removed')
        b.find_element_by_link_text('Add').click()

        b.find_element_by_xpath("//select[@id='activitysearch_1_table']/option[@value='Old Value']").click()
        b.find_element_by_xpath("//select[@id='activitysearch_1_operation']/option[@value='is']").click()
        b.find_element_by_xpath("//input[@id='activitysearch_1_value']").send_keys(self.group.display_name)
        b.find_element_by_id('searchform').submit()
        self.assert_(is_activity_row_present(b,via='WEBUI', action='Removed',
             old_value=self.group.display_name, new_value='',
             object_='System: %s' % self.system.fqdn))

def create_job_for_recipes(recipes, owner=None, whiteboard=None, cc=None,product=None,
        retention_tag=None, group=None, submitter=None, priority=None, **kwargs):
    if retention_tag is None:
        retention_tag = RetentionTag.by_tag(u'scratch') # Don't use default, unpredictable
    else:
        retention_tag = RetentionTag.by_tag(retention_tag)

    if owner is None:
        owner = create_user()
    if whiteboard is None:
        whiteboard = unique_name(u'job %s')
    job = Job(whiteboard=whiteboard, ttasks=sum(r.ttasks for r in recipes),
        owner=owner, retention_tag=retention_tag, group=group, product=product,
        submitter=submitter)
    if cc is not None:
        job.cc = cc
    if priority is None:
        priority = TaskPriority.default_priority()
    recipe_set = RecipeSet(ttasks=sum(r.ttasks for r in recipes),
            priority=priority)
    recipe_set.recipes.extend(recipes)
    job.recipesets.append(recipe_set)
    session.add(job)
    session.flush()
    log.debug('Created %s', job.t_id)
    return job

 def update_setting(self, *args, **kwargs):
     '''
         Updates user settings.
         
         @param **kwargs: contains information about anonymity, sending a queries by email and newsletter 
     '''
     
     user = User.get_by(User.c.user_id==identity.current.user.user_id)
     s = user.getSettings()
     
     if kwargs['anonymous'] == "true":
         s.anonymous = 1
         user.display_name = "anonymous";
     else:
         s.anonymous = 0
         user.display_name = user.user_name;
                 
     if kwargs['email'] == "true":
         s.email = 1
     else:
         s.email = 0
         
     if kwargs['newsletter'] == "true":
         s.newsletter = 1
     else:
         s.newsletter = 0
                               
     session.save(user);
     session.save(s);
     session.flush();
     return dict()

def _handle_historical(session, data,myth_uuid):
    showcount = 0
    rectime = 0
    db_age = 0
    reccount = 0
    try:
        myth_hist = data['features']['historical']
    except:
        myth_hist = {}

    #session.query(mythtvHistorical).filter_by(machine_id = machine_id).delete()
    session.query(mythtvHistorical).filter_by(myth_uuid = myth_uuid).delete()

    try:
        showcount = myth_hist['showcount']
    except:
        pass

    try:
        rectime = myth_hist['rectime']
    except:
        pass
    try:
        db_age = myth_hist['db_age']
    except:
        pass
    try:
        reccount = myth_hist['reccount']
    except:
        pass

    session.add(mythtvHistorical(myth_uuid,
                                 showcount,rectime,db_age,reccount)
                                 )
    session.flush()

    def deleteQuery(self, query_id, *args, **kwargs):
        '''
            Allows user to delete a query. Updates query logging.
            
            @param query_id: identifies the query
            @return: status of attempted  delete operation of the query
        '''
        
        query = session.query(Query).get_by(query_id=int(query_id))
        
        status = ""
        
        if not query:
            status = "Query not found"
        elif session.query(ChatSession).get_by(query_id=int(query_id)):
            status = "Chat already started"
        elif query.user_id != identity.current.user.user_id:
            status = "Permission denied"
        else:
            query.experts[:] = []
            query_log=QueryLog(
                query_id = int(query_id),
                user_id = query.user_id,
                user_name = session.query(User).get_by(user_id=query.user_id).user_name,
                created = datetime.now(),
                status = 'Deleted')

            session.save(query_log)
            session.flush()
            session.delete(query);
            session.flush();
            
        return dict(status=status)    

def add_ssh_public_key(username):
    """
    Adds a new SSH public key for the given user account.

    Accepts mimetype:`text/plain` request bodies containing the SSH public key 
    in the conventional OpenSSH format: <keytype> <key> <ident>.

    :param username: The user's username.
    """
    user = _get_user(username)
    if not user.can_edit(identity.current.user):
        raise Forbidden403('Cannot edit user %s' % user)
    if request.mimetype != 'text/plain':
        raise UnsupportedMediaType415('Request content type must be text/plain')
    with convert_internal_errors():
        keytext = request.data.strip()
        if '\n' in keytext:
            raise ValueError('SSH public keys may not contain newlines')
        elements = keytext.split(None, 2)
        if len(elements) != 3:
            raise ValueError('Invalid SSH public key')
        key = SSHPubKey(*elements)
        user.sshpubkeys.append(key)
        session.flush() # to populate id
    return jsonify(key.__json__())

    def rate_object(self, **kwargs):
        #log.info('args = %s' % str(args))
        #log.info('kwargs = %s' % str(kwargs))
        id = kwargs.get("ratingID")
        rating = kwargs.get("value")
        print "ID: %s" % id
        print "RATING: %s" % rating
        if id.startswith("Host"):
            sep = id.find("@")
            if sep == -1:
                host_id = id[4:]
                host = session.query(Host).filter_by(uuid=host_id).one()
                host.rating = int(rating)
                session.flush()
                return dict()

            host_id = id[4:sep]
            id = id[sep+1:]
            if id.startswith("Device"):
                device_id = int(id[6:])
                host = session.query(Host).filter_by(uuid=host_id).one()
                for device in host.devices:
                    if device.device_id == device_id:
                        device.rating = int(rating)
                        session.flush([host, device])
                        return dict()
        return dict()

    def isOnline(self):
        '''
            @return: Boolean (true if user is online).
        '''
        user_stats = self.user_stats
        
        # reload if status is old
        if not user_stats.isOnlineLastUpdated or user_stats.isOnlineLastUpdated < datetime.now() - timedelta(seconds = constants.isOnlineExpire):
            t=[]
            visit=session.query(Visit).select(and_(VisitIdentity.c.visit_key == Visit.c.visit_key, self.user_id == VisitIdentity.c.user_id))
            isOnline = 0
            for v in visit:
                t.append(v.expiry)
            t.sort()
            t.reverse()
            if len(t) > 0 and datetime.now()<t[0]:
                isOnline = 1

            user_stats.isOnline = isOnline
            user_stats.isOnlineLastUpdated = datetime.now()
            
            session.save(user_stats)
            session.flush()
            
        return user_stats.isOnline == 1

 def add_json_plus_pub_uuid(self, uuid, pub_uuid, host, token, smolt_protocol):
     self._run_add_json_checks(uuid, host, token, smolt_protocol)
     res = self.handle_submission(uuid, pub_uuid, host)
     log_entry = BatchJob(host, uuid, added=True)
     session.add(log_entry)
     session.flush()
     return res

def system_command(fqdn):
    system = _get_system_by_FQDN(fqdn)
    if not system.lab_controller:
        raise BadRequest400('System is not attached to a lab controller')
    if not system.can_power(identity.current.user):
        raise Forbidden403('You do not have permission to control this system')
    # We accept JSON or form-encoded for convenience
    if request.json:
        if 'action' not in request.json:
            raise BadRequest400('Missing action key')
        action = request.json['action']
    elif request.form:
        if 'action' not in request.form:
            raise BadRequest400('Missing action parameter')
        action = request.form['action']
    else:
        raise UnsupportedMediaType415
    if action == 'reboot':
        raise BadRequest400('"reboot" is not a valid power command, '
                'send "off" followed by "on" instead')
    elif action in ['on', 'off', 'interrupt']:
        if not system.power:
            raise BadRequest400('System is not configured for power support')
        command = system.action_power(service=u'HTTP', action=action)
    elif action == 'clear_netboot':
        command = system.clear_netboot(service=u'HTTP')
    else:
        raise BadRequest400('Unknown action %r' % action)
    session.flush() # for created attribute
    return jsonify(command.__json__())

    def reject(self, person_name):
        """Reject a user's FPCA.

        This method will remove a user from the FPCA group and any other groups
        that they are in that require the FPCA.  It is used when a person has
        to fulfill some more legal requirements before having a valid FPCA.

        Arguments
        :person_name: Name of the person to reject.
        """
        show = {}
        show["show_postal_address"] = config.get("show_postal_address")
        exc = None
        user = People.by_username(turbogears.identity.current.user_name)
        if not is_admin(user):
            # Only admins can use this
            turbogears.flash(_("You are not allowed to reject FPCAs."))
            exc = "NotAuthorized"
        else:
            # Unapprove the cla and all dependent groups
            person = People.by_username(person_name)
            for role in person.roles:
                if self._cla_dependent(role.group):
                    role.role_status = "unapproved"
            try:
                session.flush()
            except DBAPIError, error:
                turbogears.flash(
                    _("Error removing cla and dependent groups" " for %(person)s\n Error was: %(error)s")
                    % {"person": person_name, "error": str(error)}
                )
                exc = "DBAPIError"

    def test_job_priority_changes(self):
        user1 = data_setup.create_user()
        user2 = data_setup.create_user()
        job1 = data_setup.create_job(owner=user1)
        job2 = data_setup.create_job(owner=user1)
        job3 = data_setup.create_job(owner=user2)
        job4 = data_setup.create_job(owner=user2)

        for j in [job1, job2, job3]:
            for rs in j.recipesets:
                activity = RecipeSetActivity(j.owner,
                                             'TEST',
                                             'Changed',
                                             'Priority',
                                             rs.priority.value,
                                             TaskPriority.high)
                activity.created = datetime.datetime(year=2012,
                                                     month=10,
                                                     day=10)
                rs.activity.append(activity)
        session.flush()

        rows = self.execute_reporting_query('job-priority-changes-by-user')
        all_rows = rows.fetchall()
        user1_rows = [row for row in all_rows if row.user_name == user1.user_name]
        user2_rows = [row for row in all_rows if row.user_name == user2.user_name]

        self.assertTrue(user1_rows[0].number_of_jobs_changed, 2)
        self.assertTrue(user2_rows[0].number_of_jobs_changed, 1)

 def save(self, **kw):
     try:
         RetentionTagUtility.save_tag(**kw)
         session.flush()
     except Exception, e:
         log.error('Error inserting tag: %s and default: %s' % (kw.get('tag'), kw.get('default_')))
         flash(_(u"Problem saving tag %s" % kw.get('tag')))

 def test_systems_by_cpu_type(self):
     vendor = u'AcmeCorp'
     common_cpu_family = 1
     common_cpu_stepping = 2
     rare_cpu_family = 3
     rare_cpu_stepping = 4
     for _ in range(2):
         data_setup.create_system().cpu = Cpu(vendor=vendor, model=1,
                 family=rare_cpu_family, stepping=rare_cpu_stepping)
     for _ in range(20):
         data_setup.create_system().cpu = Cpu(vendor=vendor, model=1,
                 family=common_cpu_family, stepping=common_cpu_stepping)
     data_setup.create_system(status=SystemStatus.removed).cpu = \
         Cpu(vendor=vendor)
     data_setup.create_system().cpu = None # un-inventoried
     session.flush()
     rows = list(self.execute_reporting_query('system-count-by-cpu'))
     # un-inventoried systems should show up at the top
     self.assertEquals(rows[0].cpu_vendor, None)
     self.assertEquals(rows[0].cpu_model, None)
     self.assertEquals(rows[0].cpu_family, None)
     self.assertEquals(rows[0].cpu_stepping, None)
     self.assert_(rows[0].system_count >= 1, rows[0])
     # check for fake CPUs created above
     vendor_rows = [row for row in rows if row.cpu_vendor == vendor]
     self.assertEquals(len(vendor_rows), 2, vendor_rows)
     self.assertEquals(vendor_rows[0].cpu_model, 1)
     self.assertEquals(vendor_rows[0].cpu_family, common_cpu_family)
     self.assertEquals(vendor_rows[0].cpu_stepping, common_cpu_stepping)
     self.assertEquals(vendor_rows[0].system_count, 20)
     self.assertEquals(vendor_rows[1].cpu_model, 1)
     self.assertEquals(vendor_rows[1].cpu_family, rare_cpu_family)
     self.assertEquals(vendor_rows[1].cpu_stepping, rare_cpu_stepping)
     self.assertEquals(vendor_rows[1].system_count, 2)

    def test_counts(self):
        lc = data_setup.create_labcontroller()
        manual_system = data_setup.create_system(lab_controller=lc)
        data_setup.create_manual_reservation(manual_system,
                start=datetime.datetime(2012, 1, 1, 0, 0, 0))
        recipe_system = data_setup.create_system(lab_controller=lc)
        data_setup.mark_recipe_running(
                data_setup.create_job().recipesets[0].recipes[0],
                system=recipe_system)
        idle_manual_system = data_setup.create_system(lab_controller=lc,
                status=SystemStatus.manual)
        idle_automated_system = data_setup.create_system(lab_controller=lc,
                status=SystemStatus.automated)
        idle_broken_system = data_setup.create_system(lab_controller=lc,
                status=SystemStatus.broken)
        idle_removed_system = data_setup.create_system(lab_controller=lc,
                status=SystemStatus.removed)
        session.flush()

        counts = system_utilisation_counts(System.query.filter(
                System.lab_controller == lc))
        self.assertEqual(counts['recipe'], 1)
        self.assertEqual(counts['manual'], 1)
        self.assertEqual(counts['idle_manual'], 1)
        self.assertEqual(counts['idle_automated'], 1)
        self.assertEqual(counts['idle_broken'], 1)
        self.assertEqual(counts['idle_removed'], 1)

    def promote_pending_user(self, pending_user):
        '''
            Promotes pending user to the official 'users'.

            @param pending_user: The pending user object
            @return: the new user object.
        '''
        
        # Let's try to do this programmatically.  The only thing you should have to modify
        # if you changed the schema fo RegistrationPendingUser is the 'excluded' list.  All 
        # columns not in this list will be mapped straight to a new user object.
        
        # This list contains the columns from RegistrationPendingUser that you DON'T want 
        # to migrate
        excluded = ['created', 'validation_key']
        columns = pending_user.c.keys()   # list of column names
        new_columns = dict()
        for c in columns:
            if c not in excluded:
                new_columns[c] = getattr(pending_user, c)
        UserClass = register_model.user_class_finder.user_class
        new_user = UserClass(**new_columns)
        if new_user:
            new_user.user_stats = UserStats()
        session.flush()
        return new_user

def _handle_pbp(session, data, machine_id):

    name = "unknown"
    profiles = ['unknown']

    try:
        myth_pb = data['features']['playbackprofile']
    except:
        myth_pb = {}

    try:
        name = myth_pb['name']
    except:
        pass


    try:
        profiles = myth_pb['profiles']
    except:
        pass

    #Remove old entry
    session.query(mythtvPbp).filter_by(machine_id = machine_id).delete()
    #Add new entry
    session.add(mythtvPbp(machine_id,name,profiles))
    session.flush()