コード例 #1
0
ファイル: misc.py プロジェクト: umar93132/portal
def handle_if_company_tags(i, v, splits=False):
    from alchemist.models.user_company import BaseCompany
    from alchemist.models.base import DBSession

    obj = BaseCompany
    tags = []
    if splits == False:
        splits = [',']
    split = splits.pop()
    for tag in v.split(split):
        if not tag.strip():
            continue
        if splits:
            tags.extend(handle_if_company_tags(i, tag, splits))
            continue
        try:
            ftag = DBSession.query(obj).get(int(tag))
        except:
            ftag = DBSession.query(obj).filter(obj.name == tag.strip()).first()
            if not ftag:
                ftag = obj(name=tag.strip())
        if ftag:
            tags.append(ftag)
    v = tags
    return v
コード例 #2
0
ファイル: user.py プロジェクト: umar93132/portal
 def __setattr__(self, name, value):
     if name == 'user_id':
         if not self._user:
             self._user = DBSession.query(User).get(value)
         types = self._user.type.split(',')
         types.append(self.__tablename__)
         self._user.type = ','.join(set(types))
         return super(UserMixin, self).__setattr__(name, value)
     if 'tags' in name:
         name = 'tags'
     if hasattr(User, name):
         if not self._user and self.user_id:
             self._user = DBSession.query(User).get(self.user_id)
         if not self._user:
             _user = User()
             DBSession.add(_user)
             DBSession.flush()
             self.user_id = _user.id
         else:
             DBSession.add(self._user)
         try:
             return setattr(self._user, name, value)
         except DetachedInstanceError:
             DBSession.add(self._user)
             return setattr(self._user, name, value)
     else:
         return super(UserMixin, self).__setattr__(name, value)
コード例 #3
0
ファイル: misc.py プロジェクト: umar93132/portal
def handle_if_company(k, v, required=True, request=False):
    from alchemist.models.base import DBSession
    from alchemist.models.company import BaseCompany
    from alchemist.models.settings import Settings

    if k in ['company', 'company_id']:
        is_name = False
        try:
            company_id = int(v)
            company = DBSession.query(BaseCompany).get(company_id)
        except:
            v = v.replace(new_company_text, '')
            company = DBSession.query(BaseCompany).filter(BaseCompany.name == v).first()
            if not company:
                company = DBSession.query(BaseCompany).filter(BaseCompany.name.startswith(v.strip())).first()
            is_name = True
        assert not required or company, 'The company does not exist.'
        if not company and is_name:
            company = BaseCompany()
            company.name = v
            if request and request.referer and 'add/founder' in request.referer:
                company.is_alchemist = True
                company.alchemistclass = int(Settings.get('alchemistclass'))
                company.companytype = 'startup'
            DBSession.add(company)
            DBSession.flush()
        return company.id if k == 'company_id' else company
    return v
コード例 #4
0
ファイル: list.py プロジェクト: umar93132/portal
def get_records(request, type, max_records, action_verb='export'):
    ids, excl_ids = get_ids(request)
    sess_query = request.session.get('query')
    filters = {User: [User.id.in_(ids)] if ids else user_where_from_query({'query': sess_query}),
               BaseCompany: [BaseCompany.id.in_(ids)] if ids else where_from_query({'sessquery': sess_query})}
    filters = filters[type]
    if excl_ids:
        filters.append(type.id.notin_(excl_ids))
    if not request.user.is_admin:
        filters.append(type.activated == True)
    if type == User:
        filters.append(User.primary_type != None)
    elif type == BaseCompany and 'alchemist_startup' in request.referer:
        filters.append(BaseCompany.is_alchemist == True)
        filters.append(BaseCompany.companytype == 'startup')

    if not (ids or (request.session.get('select_all') and sess_query is not None)):
        request.session.flash('We didn\'t find anything to %s' % action_verb, 'error')
        return False
    if len(ids) > max_records:
        request.session.flash('You cannot %s more than %s %s' % (action_verb, max_records,
                                                                 {BaseCompany: 'companies', User: '******'}[type]),
                              'error')
        return False
    records = DBSession.query(type).outerjoin(User.company) if type == User else DBSession.query(type)
    records = records.filter(*filters).limit(max_records + 1).all()
    if len(records) > max_records:
        request.session.flash('You cannot %s more than %s %s' % (action_verb, max_records,
                                                                 {BaseCompany: 'companies', User: '******'}[type]),
                              'error')
        return False
    return records
コード例 #5
0
ファイル: misc.py プロジェクト: umar93132/portal
def handle_if_tags(i, v, splits=False, is_admin=False, otype='area_of_expertise'):
    from alchemist.models.tag import Tag
    from alchemist.models.base import DBSession

    obj = None
    if i == 'tags' or i.endswith('tags') or i == 'areas_of_interest':
        obj = Tag
    if obj:
        tags = []
        if splits == False:
            splits = [',']
        split = splits.pop()
        if v is not None:
            for tag in v.split(split):
                tag = tag.replace(new_tag_text, '')
                if not tag.strip():
                    continue
                if splits:
                    tags.extend(handle_if_tags(i, tag, splits=splits, is_admin=is_admin, otype=otype))
                    continue
                try:
                    ftag = DBSession.query(obj).get(int(tag))
                except:
                    ftag = DBSession.query(obj).filter(obj.text == tag.strip()).first()
                if not ftag and is_admin:
                    ftag = obj(text=tag.strip(), only_type=otype)
                if ftag:
                    tags.append(ftag)
        v = tags
    return v
コード例 #6
0
ファイル: questions.py プロジェクト: RaHus/portal
def list_answers(page, page_size, query, request):
    queryAll = DBSession.query(Questions).join(Answers).filter(Answers.user_id == request.user.id)
    user_filter = get_filters(request) if query is not None else []

    results = queryAll.filter(*user_filter). \
        limit(page_size).offset(page * page_size)
    total = DBSession.query(func.count(Questions.id)).join(Answers).filter(Answers.user_id == request.user.id).filter(
        *user_filter). \
        limit(page_size).offset(page * page_size).scalar()
    return results, total
コード例 #7
0
ファイル: user.py プロジェクト: RaHus/portal
 def company(self, value):
     if self.company and value and self.company.id == value.id:
         return
     if self.company:
         DBSession.query(UserXCompany).filter(UserXCompany.company == self.company,
                                              UserXCompany.user == self,
                                              UserXCompany.end_date == None). \
             update({'end_date': utcnow().datetime})
     DBSession.add(UserXCompany(company=value, user=self, start_date=utcnow().datetime,
                                relation=TypeOfRelation.employee))
コード例 #8
0
ファイル: questions.py プロジェクト: RaHus/portal
def list_questions(page, page_size, query, request):
    user_filter = get_filters(request) if query is not None else []
    if request.matchdict.get('type') == 'questions':
        user_filter.append(Questions.user_id == request.user.id)
    user_filter.append(and_(Questions.user_id != None))
    results = DBSession.query(Questions).filter(*user_filter).order_by(desc(Questions.created_at)). \
        limit(page_size).offset(page * page_size)
    total = DBSession.query(func.count(Questions.id)).filter(*user_filter). \
        limit(page_size).offset(page * page_size).scalar()

    return results, total
コード例 #9
0
ファイル: questions.py プロジェクト: RaHus/portal
def list_trackings(page, page_size, query, request):
    queryAll = DBSession.query(Questions).join(Trackers).filter(Trackers.tracker_id == request.user.id,
                                                                Trackers.is_bookmark == (
                                                                    request.matchdict.get('type') == 'bookmarked'))
    user_filter = get_filters(request) if query is not None else []

    results = queryAll.filter(*user_filter).order_by(desc(Questions.created_at)). \
        limit(page_size).offset(page * page_size)
    total = DBSession.query(func.count(Questions.id)).join(Trackers).filter(
        Trackers.tracker_id == request.user.id).filter(*user_filter). \
        limit(page_size).offset(page * page_size).scalar()
    return results, total
コード例 #10
0
ファイル: company.py プロジェクト: RaHus/portal
 def startup_wishcustomers(self, companies):
     cids = map(attrgetter('id'), self.startup_wishcustomers)
     cids_new = map(attrgetter('id'), companies)
     for company in self.startup_wishcustomers:
         if company.id not in cids_new:
             DBSession.query(CompanyXCompany).filter(CompanyXCompany.company == company,
                                                     CompanyXCompany.by_company == self,
                                                     CompanyXCompany.relation == TypeOfRelation.wishlistcustomer).delete()
     for company in companies:
         if company.id not in cids:
             self.related_companies.append(
                 CompanyXCompany(company=company, by_company=self, relation=TypeOfRelation.wishlistcustomer))
コード例 #11
0
ファイル: questions.py プロジェクト: RaHus/portal
def vote_to_answer(request):
    aid = request.POST.get('aid', -1)
    answer = DBSession.query(Answers).filter(Answers.id == aid).first()
    vote = DBSession.query(AnswerVotes).filter(AnswerVotes.answer_id == aid).filter(
        AnswerVotes.user_id == request.user.id).first()
    if vote is not None:
        DBSession.delete(vote)
    else:
        vote = AnswerVotes(answer=answer, user=request.user)
        DBSession.add(vote)
    vote_count = DBSession.query(func.count(AnswerVotes.id)).filter(AnswerVotes.answer_id == aid).scalar()
    return {'votes': vote_count}
コード例 #12
0
ファイル: company.py プロジェクト: umar93132/portal
def list_companies(self, page, page_size, query, request):
    filtr = [BaseCompany.name.ilike('%' + query + '%')]
    if not request.user or not request.user.is_admin:
        filtr.append(BaseCompany.activated == True)
    results = DBSession.query(BaseCompany.id, BaseCompany.name). \
        filter(*filtr).limit(page_size).offset(page * page_size).all()
    total = DBSession.query(func.count(BaseCompany.id)). \
        filter(*filtr).scalar()
    if self and page == total / page_size and len(query) > 2:
        nt = request.params.get('new_text')
        query = query.replace(nt or new_company_text, '')
        results.append((query, query + (nt or new_company_text)))
    return results, total
コード例 #13
0
ファイル: connect_me.py プロジェクト: RaHus/portal
def render(request):
    conn = None
    existing_connection = request.params.get('conn_id')
    if existing_connection:
        conn = DBSession.query(Connection).get(int(existing_connection))
    type = request.matchdict.get('type')
    if not type and conn and conn.user.primary_type:
        type = conn.user.primary_type
    if type == 'mentor' or type == 'faculty':
        by_user = conn.by_user if conn else request.user
        to = conn.user if conn else User.bid(request.matchdict.get('to_id'))
        if not existing_connection:
            conn_data = {'by_user_cust_name': by_user.nicename,
                         'by_user_cust_email': by_user.email,
                         'by_user_cust_linkedin': by_user.linkedin_profile,
                         'by_user_cust_co_name': by_user.company.name if by_user.company else '',
                         'by_user_cust_co_website': by_user.company.website if by_user.company else '',
                         'by_user_cust_co_desc': by_user.company.description if by_user.company else '',
                         'by_user_cust_co_teamdesc': by_user.company.startup_teamdescription if by_user.company else '',
                         'type': 'RM'
                         }
        else:
            conn_data = {}
        conn = create_or_update_conn(by_user.id, existing_connection, to.id, **conn_data)
        message = conn.message if conn and conn.message else ''
        deleteonclose = 'connect/list' not in request.referrer
        return render_to_response('mentoring/request_meeting_modal.jinja2',
                                  {'to': to,
                                   'from': by_user,
                                   'conn': conn,
                                   'deleteonclose': deleteonclose,
                                   'message': message}, request)
    elif type == 'company':
        if conn:
            company = conn.company
        else:
            company = DBSession.query(BaseCompany).get(request.matchdict.get('to_id'))
        main_poc = find_poc(company, request)
        return render_to_response('company/connect_company_modal.jinja2',
                                  {'to': company,
                                   'main_poc': main_poc[0],
                                   'conn': conn,
                                   'by_user': conn.by_user if conn else request.user,
                                   'message': conn.message if conn else ''}, request)
    else:
        return render_to_response('connect_me/connect_me_modal.jinja2',
                                  {'to': conn.user if conn else User.bid(request.matchdict.get('to_id')),
                                   'from': conn.by_user if conn else request.user,
                                   'conn': conn,
                                   'message': conn.message if conn else ''}, request)
コード例 #14
0
ファイル: user.py プロジェクト: RaHus/portal
 def primary_type(self, val):
     current_prim = DBSession.query(RoleXUser).filter(RoleXUser.is_primary == True,
                                                      RoleXUser.user_id == self.id).first()
     if current_prim and current_prim.role.title != val:
         current_prim.is_primary = False
     existing_role = DBSession.query(RoleXUser).join(Role).filter(Role.title == val,
                                                                  RoleXUser.user_id == self.id).first()
     if existing_role:
         existing_role.is_primary = True
     else:
         role = DBSession.query(Role).filter(Role.title == val).first()
         if role:
             role_x_user = RoleXUser(role=role, user=self, is_primary=True)
             Session.object_session(self).add(role_x_user)
コード例 #15
0
ファイル: questions.py プロジェクト: RaHus/portal
def addto_track(request):
    qid = request.POST.get('qid', -1)
    question = DBSession.query(Questions).filter(Questions.id == qid).first()
    bookmark_ = (request.POST.get('type') == 'bookmark')
    existed = DBSession.query(Trackers).filter(Trackers.questions_id == qid).filter(
        Trackers.tracker_id == request.user.id,
        Trackers.is_bookmark == bookmark_).first()
    if existed:
        DBSession.delete(existed)
        return {'type': 'removed'}
    else:
        tracker = Trackers(tracker=request.user, question=question, is_bookmark=bookmark_)
        DBSession.add(tracker)
        return {'type': 'added'}
コード例 #16
0
ファイル: detail.py プロジェクト: umar93132/portal
def item_view(request):
    try:
        uid = int(request.matchdict.get('id', 0))
    except ValueError:
        uid = None
    if 'company' in request.path:
        if not uid and request.user:
            company = request.user.company
            return HTTPFound('/company/%s' % company.id)
        else:
            company = DBSession.query(BaseCompany).get(uid)
        # """ Used for the next, prev buttons on profiles - Portal v2 Adwairs time
        #     NB! Not used actually bring up with Zach to discuss and see if worth salvaging these functions"""
        # if first_or_last_in_session(request) != -1:
        #    update_session(request)
        return {'item': company,
                'is_my_comp': request.user and request.user.company_id and request.user.company_id == company.id}
    user = User.load_all_roles(uid)

    # if first_or_last_in_session(request) != -1:
    #     update_session(request)

    return {'item': user,
            'user_types': user_types,
            'is_my_comp': False}
コード例 #17
0
ファイル: selection.py プロジェクト: RaHus/portal
def get_records(request, max_records, action_verb='export'):
    ids, excl_ids = get_ids(request)
    sess_query = request.session.get('query')
    filters = [BaseCompany.id.in_(ids)] if ids else where_from_query({'sessquery': sess_query})
    if excl_ids:
        filters.append(BaseCompany.id.notin_(excl_ids))
    if not request.user.is_admin:
        filters.append(BaseCompany.activated == True)

    if 'alchemist_startup' in request.referer:
        filters.append(BaseCompany.is_alchemist == True)
        filters.append(BaseCompany.companytype == 'startup')
    elif 'companies' not in request.referer:
        company_typestr = get_company_typestr(urlparse(request.referer).path[1:])
        filters.append(BaseCompany.companytype == company_typestr)

    if not (ids or (request.session.get('select_all_comp') and sess_query is not None)):
        request.session.flash('We didn\'t find anything to %s' % action_verb, 'error')
        return False
    if len(ids) > max_records:
        request.session.flash('You cannot %s more than %s companies' % (action_verb, max_records), 'error')
        return False

    records = DBSession.query(BaseCompany).filter(*filters).limit(max_records + 1).all()
    if len(records) > max_records:
        request.session.flash('You cannot %s more than %s companies' % (action_verb, max_records), 'error')
        return False
    return records
コード例 #18
0
ファイル: tests.py プロジェクト: umar93132/portal
    def test_3login_flow(self):
        ver_code_of_last_user, last_uid = DBSession.query(User.ver_code, User.id).all()[-1]
        self.assert_(ver_code_of_last_user, 'Wrong order of tests')
        req = DummyRequest(path='linkedin_confirm/%s' % ver_code_of_last_user,
                           matchdict={'code': ver_code_of_last_user}, user=self.founder)
        auth_uids = []
        confirm_acc.remember = lambda x, y: auth_uids.append(y)
        ret = confirm_acc.linkedin_confirm_view(req)
        self.assert_(last_uid in auth_uids, 'User should be logged in')
        self.assert_(isinstance(ret, HTTPFound), 'Should redirect to linkedin')

        # now test the linkedin return but mock out all the linkedin credential checks
        req2 = Mock()
        req2.params = {'code': 'test'}
        req2.authenticated_userid = last_uid
        login.get_oauth_flow_linkedin = Mock()
        login.requests = Mock()
        linkedin_user_resp = Mock()
        linkedin_email = '*****@*****.**'
        linkedin_user_resp.json = {'id': 'dummyLinkedinID', 'emailAddress': linkedin_email}
        login.requests.get = lambda *x, **k: linkedin_user_resp
        login.check_csrf_token = Mock()
        # end of mocks

        self.assert_(self.get_linkedin_email_db(last_uid) != linkedin_email, 'Linkedin email should not be set yet')
        ret = login.oauthcallback_view(req2)
        # oauth callback view calls complete_confirm_acc
        self.assert_(isinstance(ret, HTTPFound), 'Should redirect to profile')
        self.assert_(self.get_linkedin_email_db(last_uid) == linkedin_email,
                     'Linkedin email should be set by complete_confirm_acc')
コード例 #19
0
ファイル: selection.py プロジェクト: RaHus/portal
def get_records(request, max_records, action_verb='export'):
    ids, excl_ids = get_ids(request)
    sess_query = request.session.get('query_conn')
    filters = [User.id.in_(ids)] if ids else user_where_from_query({'query': sess_query})
    if excl_ids:
        filters.append(User.id.notin_(excl_ids))
    if not request.user.is_admin:
        filters.append(User.activated == True)
    type_from_mdict = urlparse(request.referer).path[1:]
    if type_from_mdict:
        user_type_str = get_user_typestr(type_from_mdict)
        if user_type_str:
            filters.append(User.roles.any(Role.title == user_type_str))

    if not (ids or (request.session.get('select_all_conn') and sess_query is not None)):
        request.session.flash('We didn\'t find anything to %s' % action_verb, 'error')
        return False
    if len(ids) > max_records:
        request.session.flash('You cannot %s more than %s contact' % (action_verb, max_records), 'error')
        return False

    records = DBSession.query(User).outerjoin(User.companies_rel).filter(*filters).limit(max_records + 1).all()
    if len(records) > max_records:
        request.session.flash('You cannot %s more than %s contacts' % (action_verb, max_records), 'error')
        return False
    return records
コード例 #20
0
ファイル: company.py プロジェクト: umar93132/portal
def edit_company_view(request):
    company_id = request.matchdict.get('company_id')
    if company_id == 'no_company':
        return {'msg': 'You don\'t have a company'}
    company = DBSession.query(BaseCompany).get(company_id)
    assert company, 'No company'
    userid = request.authenticated_userid
    user = User.bid(userid)
    assert user.has_rights(['staff', 'admin', 'founder']) or (
        user.primary_type == 'founder' and User.bid(userid).company_id == company_id), \
        'You don\'t have access to this company'

    if request.method != 'POST':
        return {'company': company}

    for i, v in request.POST.iteritems():
        if i == 'checkboxes':
            i = v
            v = True
        if hasattr(company, i):
            v = handle_if_tags(i, v)
            v = handle_file_save(request.authenticated_userid, v)
            setattr(company, i, v)
    request.session.flash('Company info updated')
    if request.referer and '/company/' in request.referer:
        return HTTPFound(request.referer)
    return {'company': company}
コード例 #21
0
ファイル: user.py プロジェクト: RaHus/portal
 def get_connect_stats(self):
     conns = DBSession.query(Connection).filter(Connection.by_user_id == self.id,
                                                Connection.sent_at != None).order_by(Connection.sent_at).all()
     connected = len([1 for c in conns if c.accepted])
     sent = len(conns)
     meeting_reqs = [c for c in conns if c.type == 'RM' and not c.company_id]
     company_reqs = [c for c in conns if c.type == 'company' and not c.company_id]
     connect_me = [c for c in conns if c.type is None or c.type == 'CM']
     f_accept = lambda x: x.accepted
     tracked_questions = self.tracked_questions
     return {'sent': sent,
             'connected': connected,
             'ratio': float(connected) / max(sent, 1),
             'last': int(mktime(conns[0].sent_at.timetuple())) if conns else 0,
             'connect_me_accept': len(filter(f_accept, connect_me)),
             'connect_me_sent': len(connect_me),
             'connect_me_conv': float(len(filter(f_accept, connect_me))) / max(len(connect_me), 1),
             'request_meeting_accept': len(filter(f_accept, meeting_reqs)),
             'request_meeting_sent': len(meeting_reqs),
             'request_meeting_conv': float(len(filter(f_accept, meeting_reqs))) / max(len(meeting_reqs), 1),
             'company_accept': len(filter(f_accept, company_reqs)),
             'company_sent': len(company_reqs),
             'company_conv': float(len(filter(f_accept, company_reqs))) / max(len(company_reqs), 1),
             'questions_asked': len(self.questions_asked),
             'answers_submitted': len(self.question_answers),
             'questions_answered': len(set([qa.questions_id for qa in self.question_answers])),
             'question_bookmarks': len(filter(lambda x: x.is_bookmark, tracked_questions)),
             'question_alerts': len(filter(lambda x: not x.is_bookmark, tracked_questions)),
             'answer_upvotes': len(self.answer_upvotes)
             }
コード例 #22
0
ファイル: edit.py プロジェクト: umar93132/portal
def profile_view(request):
    auth_user = User.bid(request.authenticated_userid)
    userid = request.matchdict.get('user_id', auth_user.id) if auth_user.is_admin else auth_user.id
    current_type = request.matchdict.get('type', 'base')
    realtype = all_types[current_type]
    user = DBSession.query(realtype).get(userid)
    assert user, 'No user'
    if request.method == 'POST':
        post_data = request.POST
        password = post_data.get('password', '').strip()
        if password:
            assert password == post_data.get('password2', '').strip(), 'Passwords must match'
            assert hash_password(password) == user.password, 'The old password is incorrect'
        elif 'password' in post_data:
            del post_data['password']

        for k, v in post_data.iteritems():
            if hasattr(user, k) and k not in realtype.no_edit_fields:
                if v == 'on':
                    v = True
                v = {'true': True, 'false': False}.get(v, v)
                v = handle_if_company(k, v)
                v = handle_file_save(user.id, v)
                v = handle_if_tags(k, v)
                setattr(user, k, v)
        if 'profile' in request.referer or 'useredit' in request.referer:
            for i in realtype.boolean_fields:
                if i not in post_data.iterkeys():
                    setattr(user, i, False)
        request.session.flash('Saved')

    user_url = '/%s/%s' % (getattr(user, 'type', 'company').split(',')[-1], user.id)
    return HTTPFound(request.referer or user_url)
コード例 #23
0
ファイル: settings.py プロジェクト: umar93132/portal
def settings_view(request):
    settings_all = dict(DBSession.query(Settings.key, Settings).all())

    if request.method == 'POST':
        for key, value in request.POST.iteritems():
            if 'drive_id' in key:
                settings_all[key[:-9]].drive_id = value
            elif key in settings_all:
                settings_all[key].value = value
        Settings.set_docs_vals(settings_all)
        Settings._cache = {}
        get_region('main').invalidate()

    settings = {}
    settings['urls'], settings['general'], settings['drive_ids'] = [{} for x in range(3)]
    for k, v in settings_all.iteritems():
        if 'http' in v.value:
            settings['urls'][k] = v.value
            if 'google' in v.value or v.drive_id:
                settings['drive_ids'][k] = v.drive_id or ''
        else:
            settings['general'][k] = v.value

    return {
        'settings_general': settings['general'],
        'settings_urls': settings['urls'],
        'settings_drive_ids': settings['drive_ids']
    }
コード例 #24
0
ファイル: answers.py プロジェクト: RaHus/portal
 def isvoted(self, uid):
     votes = DBSession.query(func.count(AnswerVotes.id)).filter(AnswerVotes.answer_id == self.id).filter(
         AnswerVotes.user_id == uid).scalar()
     if votes is None or votes == 0:
         return False
     else:
         return True
コード例 #25
0
ファイル: administration.py プロジェクト: RaHus/portal
def inactivate_profile(request):
    if 'company' in request.referrer:
        cid = int(request.matchdict.get('id', 0))
        company = DBSession.query(BaseCompany).filter(BaseCompany.id == cid).first()
        company.activated = False
        employees = company.employees
        for employee in employees:
            user = DBSession.query(User).filter(User._email == employee._email).first()
            user.activated = False
            employee.active = False
        return HTTPFound('/company/%s' % (cid))
    else:
        uid = int(request.matchdict.get('id', 0))
        user = User.bid(uid)
        user.activated = False
        return HTTPFound('/%s/%s' % (user.type.split(',')[-1], user.id))
コード例 #26
0
ファイル: confirm_acc.py プロジェクト: RaHus/portal
def linkedin_confirm_view(request):
    code = request.matchdict.get('code')
    user = DBSession.query(User).filter(User.ver_code == code).first()
    if not user:
        return HTTPFound('/logout?no_redirect=1')
    remember(request, user.id)
    flow = get_oauth_flow_linkedin(request)
    return HTTPFound(flow.step1_get_authorize_url())
コード例 #27
0
ファイル: unwanted.py プロジェクト: umar93132/portal
def unwanted_list(request):
    who = aliased(User, name="who")
    by = aliased(User, name="by")
    a = DBSession.query(UnWanted, who, by). \
        join(who, UnWanted.user).join(by, UnWanted.by_user). \
        all()
    a = obj_list_join(a, ['', 'user_', 'by_'])
    return {'unwanted': a}
コード例 #28
0
ファイル: emails.py プロジェクト: RaHus/portal
def get_users_with_filters(*filters):
    general_filters = [User.login_enabled == True,
                       User.roles_rel.any(
                           and_(RoleXUser.role_name == RolesTypes.founder, RoleXUser.is_primary == True))]
    notif_filters = filters[0]
    if len(filters) > 1:
        notif_filters = or_(*filters)
    return DBSession.query(User).filter(*(general_filters + [notif_filters])).all()
コード例 #29
0
ファイル: connect_me.py プロジェクト: RaHus/portal
def check_quota(user):
    count = DBSession.query(func.count(Connection.id)).filter(Connection.by_user == user,
                                                              Connection.sent_at != None,
                                                              or_(Connection.type == 'CM',
                                                                  Connection.type == None)).scalar()
    assert user.connect_me_quota >= count, \
        'Your connect me messages quota is full, use the help icon in bottom right corner or email [email protected]'
    return count
コード例 #30
0
ファイル: emails.py プロジェクト: RaHus/portal
def send_emails_immediate_answer(request, answer_id, attr_name, nice_type, type):
    users_wanting_immediate_emails = get_users_with_filters(
        getattr(User, attr_name) == NotificationChoice.immediate)
    answer = DBSession.query(Answers).get(answer_id)
    question = answer.question
    for user in users_wanting_immediate_emails:
        user.send_mail('exchange_immediate', request,
                       {'answer': answer, 'question': question, 'nice_type': nice_type, 'type': type})