示例#1
0
 def sites_ip(self, *kw):
     session['func'] = 'sites_ip'
     session['site'] = kw[0]
     session.save()
     site = DBSession.query(Domain).get(session['site'])
     c.reports = sites_userip_report_grid
     c.query_params = { 'Date' : session['date'],
                         'Site' : site.text }
     c.backlink = '/reports/sites/' + session['date']
     return dict(page = 'squid')
示例#2
0
文件: access.py 项目: diegows/xreport
    def update(mini_cls, access):
        proxy_status = access.proxy_status.text
        if proxy_status.startswith("UDP_") or proxy_status == "NONE":
            return
        if access.proxy_status.text == "TCP_DENIED":
            status = mini_cls.denied
        else:
            status = mini_cls.allowed

        mini = (
            DBSession.query(mini_cls)
            .join(Address)
            .join(Domain)
            .join(ProxyUser)
            .filter(
                and_(
                    Address.text == access.address.text,
                    Domain.text == access.domain.text,
                    ProxyUser.text == access.proxy_user.text,
                    mini_cls.date == access.date,
                    mini_cls.status == status,
                )
            )
            .all()
        )

        if len(mini) == 0:
            mini = mini_cls()
            mini.date = access.date
            mini.address = access.address
            mini.domain = access.domain
            mini.proxy_user = access.proxy_user
            mini.upload_bytes = int(access.request_size)
            mini.download_bytes = int(access.reply_size)
            mini.count = 1
            mini.status = status
            DBSession.add(mini)
        else:
            mini = mini[0]
            mini.upload_bytes += int(access.request_size)
            mini.download_bytes += int(access.reply_size)
            mini.count += 1
示例#3
0
文件: access.py 项目: diegows/xreport
    def get(cls, text):
        cls.check(text)

        if fk_cache.has_key(cls) and fk_cache[cls].has_key(text):
            return fk_cache[cls][text]

        query = DBSession.query(cls)
        query._autoflush = False
        data = query.filter(cls.text == text).all()
        if len(data) == 0:
            data = cls()
            data.text = text
            DBSession.add(data)
        elif len(data) == 1:
            data = data[0]
        else:
            # XXX: do this better
            raise Exception()

        if not fk_cache.has_key(cls):
            fk_cache[cls] = {}
        fk_cache[cls][text] = data
        return data
示例#4
0
    def fetch_sites_userip_report(self, page = 1, rp = 25,
                    sortname = 'download_bytes', sortorder = 'desc',
                    qtype = None, query = None):

        if session['func'] == 'sites_ip':
            userip = Address.text
        else:
            userip = ProxyUser.text

        clients = DBSession.query(userip,
                                func.sum(MiniAccess.count),
                                func.sum(MiniAccess.download_bytes),
                                func.sum(MiniAccess.upload_bytes))

        if session['func'] == 'sites_ip':
            clients = clients.join(MiniAccess.address)
            clients = clients.group_by(MiniAccess.address_id)
        else:
            clients = clients.join(MiniAccess.proxy_user)
            clients = clients.group_by(MiniAccess.proxy_user_id)

        clients = clients.join(MiniAccess.domain)
        date = datetime.strptime(session['date'], '%Y-%m-%d')
        date = date.date()
        clients = clients.filter(and_(MiniAccess.date == date, 
                                    MiniAccess.domain_id == session['site']))
        
        sort_fn = get_sortfn(sortorder)
        if sortname == 'requests':
            clients = clients.order_by(sort_fn('sum_1'))
        elif sortname == 'download_bytes':
            clients = clients.order_by(sort_fn('sum_2'))
        elif sortname == 'upload_bytes':
            clients = clients.order_by(sort_fn('sum_3'))

        total = clients.count()
        offset = (page - 1) * rp
        clients = clients.offset(offset).limit(rp)

        rows = []
        for data in clients:
            values = [ data[0], data[1],
                        mb(data[2]),
                        mb(data[3]) ]
            row = { 'id' : data[0],
                    'cell' : values }
            rows.append(row)

        return dict(page = page, total = total, rows = rows)
示例#5
0
 def setup(self):
     try:
         new_attrs = {}
         new_attrs.update(self.attrs)
         new_attrs.update(self.do_get_dependencies())
         self.obj = self.klass(**new_attrs)
         DBSession.add(self.obj)
         DBSession.flush()
         return self.obj
     except:
         DBSession.rollback()
         raise
示例#6
0
    def fetch_sites_report(self, page = 1, rp = 25,
                    sortname = 'download_bytes', sortorder = 'desc',
                    qtype = None, query = None):

        clients = DBSession.query(Domain.text,
                                func.count(MiniAccess.address_id.distinct()),
                                func.count(MiniAccess.proxy_user_id.distinct()),
                                func.sum(MiniAccess.count),
                                func.sum(MiniAccess.download_bytes),
                                func.sum(MiniAccess.upload_bytes),
                                Domain.id)
        clients = clients.join(MiniAccess)
        clients = clients.group_by(Domain.text)

        clients = clients.filter(MiniAccess.date == session['date'])
        
        sort_fn = get_sortfn(sortorder)
        if sortname == 'address':
            clients = clients.order_by(sort_fn('count_1'))
        elif sortname == 'proxy_user':
            clients = clients.order_by(sort_fn('count_2'))
        elif sortname == 'requests':
            clients = clients.order_by(sort_fn('sum_1'))
        elif sortname == 'download_bytes':
            clients = clients.order_by(sort_fn('sum_2'))
        elif sortname == 'upload_bytes':
            clients = clients.order_by(sort_fn('sum_3'))

        total = clients.count()
        offset = (page - 1) * rp
        clients = clients.offset(offset).limit(rp)

        rows = []
        for data in clients:
            clients = link("reports/sites_ip", data[6], data[1])
            users = link("reports/sites_users", data[6], int(data[2]) - 1)
            values = [ data[0], clients, users, data[3],
                        mb(data[4]),
                        mb(data[5]) ]
            row = { 'id' : data[0],
                    'cell' : values }
            rows.append(row)

        return dict(page = page, total = total, rows = rows)
示例#7
0
    def fetch_users_report(self, page = 1, rp = 25,
                    sortname = 'download_bytes', sortorder = 'desc',
                    qtype = None, query = None):

        clients = DBSession.query(ProxyUser.text,
                                func.count(MiniAccess.domain_id.distinct()),
                                func.sum(MiniAccess.count),
                                func.sum(MiniAccess.download_bytes),
                                func.sum(MiniAccess.upload_bytes))
        clients = clients.join(MiniAccess)
        clients = clients.group_by(ProxyUser.text)

        clients = clients.filter(and_(MiniAccess.date == session['date'],
                                        ProxyUser.text != '-'))
        
        sort_fn = get_sortfn(sortorder)
        if sortname == 'sites':
            clients = clients.order_by(sort_fn('count_1'))
        elif sortname == 'requests':
            clients = clients.order_by(sort_fn('sum_1'))
        elif sortname == 'download_bytes':
            clients = clients.order_by(sort_fn('sum_2'))
        elif sortname == 'upload_bytes':
            clients = clients.order_by(sort_fn('sum_3'))

        total = clients.count()
        offset = (page - 1) * rp
        clients = clients.offset(offset).limit(rp)

        rows = []
        for data in clients:
            sites = link('reports/user_sites', data[0], data[1])
            values = [ data[0], sites, data[2],
                        mb(data[3]),
                        mb(data[4]) ]
            row = { 'id' : data[0],
                    'cell' : values }
            rows.append(row)

        return dict(page = page, total = total, rows = rows)
示例#8
0
 def test_query_obj(self):
     obj = DBSession.query(self.klass).one()
     for key, value in self.attrs.iteritems():
         assert_equals(getattr(obj, key), value)
示例#9
0
 def tearDown(self):
     DBSession.rollback()
示例#10
0
文件: auth.py 项目: diegows/xreport
 def by_user_name(cls, username):
     """Return the user object whose user name is ``username``."""
     return DBSession.query(cls).filter(cls.user_name==username).first()
示例#11
0
文件: auth.py 项目: diegows/xreport
 def by_email_address(cls, email):
     """Return the user object whose email address is ``email``."""
     return DBSession.query(cls).filter(cls.email_address==email).first()
示例#12
0
    def fetch_main_report(self, page = 1, rp = 25, sortname = 'date',
                    sortorder = 'desc', qtype = None, query = None):

        dash_id = DBSession.query(ProxyUser.id).filter(ProxyUser.text == "-")
        dash_id = dash_id.one()[0]

        count_ip = """count(distinct if(miniaccess.proxy_user_id = %d,
            miniaccess.address_id, 0))""" % (dash_id)

        count_user = """count(distinct if(miniaccess.proxy_user_id <> %d,
            miniaccess.proxy_user_id, 0))""" % (dash_id)

        if session['group_by'] == 'day':
            date_col = MiniAccess.date
        else:
            date_col = func.concat(func.min(MiniAccess.date), ' - ', 
                            func.max(MiniAccess.date))
                   
        #count the clients address only if the request is not authenticated
        #I use literal SQL because i don't find how to do this with ORM.
        main = DBSession.query(date_col,
                                count_ip,
                                count_user,
                                func.count(MiniAccess.domain_id.distinct()),
                                func.sum(MiniAccess.count),
                                func.sum(MiniAccess.download_bytes),
                                func.sum(MiniAccess.upload_bytes))
        main = main.group_by(MiniAccess.date)

        sort_fn = get_sortfn(sortorder)
        if sortname == 'date':
            main = main.order_by(sort_fn(MiniAccess.date))
        elif sortname == 'clients':
            main = main.order_by(sort_fn('2'))
        elif sortname == 'users':
            main = main.order_by(sort_fn('3'))
        elif sortname == 'sites':
            main = main.order_by(sort_fn('count_1'))
        elif sortname == 'requests':
            main = main.order_by(sort_fn('sum_1'))
        elif sortname == 'download_bytes':
            main = main.order_by(sort_fn('sum_2'))
        elif sortname == 'upload_bytes':
            main = main.order_by(sort_fn('sum_3'))

        total = main.count()
        offset = (page - 1) * rp
        main = main.offset(offset).limit(rp)

        rows = []
        print main
        for data in main:
            urldate = data[0]
            clients = link('reports/clients', urldate, data[1])
            # We don't count '-' user because it's used in unauth. msgs.
            users = link('reports/users', urldate, data[2])
            sites = link('reports/sites', urldate, data[3])
            values = [ data[0], clients, users, sites, data[4],
                        mb(data[5]),
                        mb(data[6]) ]
            row = { 'id' : data[0],
                    'cell' : values }
            rows.append(row)

        return dict(page = page, total = total, rows = rows)