class ButtonPressByUser(tdb_cassandra.View):
_use_db = True
_connection_pool = 'main'
_compare_with = tdb_cassandra.DateType()
_extra_schema_creation_args = {
"key_validation_class": tdb_cassandra.ASCII_TYPE,
}
_write_consistency_level = tdb_cassandra.CL.ONE
_read_consistency_level = tdb_cassandra.CL.ONE
@classmethod
def _rowkey(cls, user):
return "%s.%s" % (g.live_config["thebutton_srid"], user._id36)
@classmethod
def pressed(cls, user, dt):
rowkey = cls._rowkey(user)
column = {dt: ''}
cls._cf.insert(rowkey, column,
write_consistency_level=cls._write_consistency_level)
@classmethod
def has_pressed(cls, user):
rowkey = cls._rowkey(user)
try:
cls._cf.get(rowkey, column_count=1,
read_consistency_level=cls._read_consistency_level)
except NotFoundException:
return False
else:
return True
class IPsByAccount(tdb_cassandra.View):
_use_db = True
_extra_schema_creation_args = {
"key_validation_class": ASCII_TYPE,
"default_validation_class": ASCII_TYPE,
}
_compare_with = tdb_cassandra.DateType()
_ttl = CF_TTL
@classmethod
def set(cls, account_id, ip, date=None):
if date is None:
date = datetime.datetime.now(g.tz)
cls._set_values(str(account_id), {date: ip})
@classmethod
def get(cls,
account_id,
column_start=None,
column_finish=None,
column_count=100,
column_reversed=True):
"""Get the last accessed times of an account by IP address.
Returns a list of dicts of the last accessed times of an account by
IP address, most recent first.
Example:
>>> IPsByAccount.get(52)
[
{datetime.datetime(2016, 1, 24, 6, 23, 0, 326000, tzinfo=<UTC>): '127.0.0.3'},
{datetime.datetime(2016, 1, 24, 6, 22, 58, 983000, tzinfo=<UTC>): '127.0.0.2'},
]
Pagination is done based on the date of the entry. For instance, to
continue getting results from the previous set:
>>> IPsByAccount.get(52, column_start=datetime.datetime(
2016, 1, 24, 6, 22, 58, 983000))
[
{datetime.datetime(2016, 1, 24, 6, 21, 50, 121000, tzinfo=<UTC>): '127.0.0.1'},
]
"""
column_start = column_start or ""
column_finish = column_finish or ""
results = []
query = tdb_cassandra.ColumnQuery(
cls, (str(account_id),),
column_start=column_start,
column_finish=column_finish,
column_count=column_count,
column_reversed=column_reversed)
for date_ip in query:
for dt, ip in date_ip.iteritems():
results.append({dt.replace(tzinfo=pytz.utc): ip})
return results
class AccountsByIP(tdb_cassandra.View):
_use_db = True
_extra_schema_creation_args = {
"key_validation_class": ASCII_TYPE,
"default_validation_class": ASCII_TYPE,
}
_compare_with = tdb_cassandra.DateType()
_ttl = CF_TTL
@classmethod
def set(cls, ip, account_id, date=None):
if date is None:
date = datetime.datetime.now(g.tz)
cls._set_values(ip, {date: str(account_id)})
@classmethod
def get(cls,
ip,
column_start=None,
column_finish=None,
column_count=100,
column_reversed=True):
"""Get the times an IP address has accessed various account IDs.
Returns a list of dicts of the times an IP address has accessed
various account IDs, most recent first:
Example:
>>> AccountsByIP.get('127.0.0.1')
[
{datetime.datetime(2016, 1, 22, 23, 28, 21, 286000, tzinfo=<UTC>): 52},
{datetime.datetime(2016, 1, 22, 23, 28, 24, 301000, tzinfo=<UTC>): 53},
]
Pagination is also supported. See the documentation for
``IPsByAccount.get``.
"""
column_start = column_start or ""
column_finish = column_finish or ""
results = []
query = tdb_cassandra.ColumnQuery(
cls, (ip,),
column_start=column_start,
column_finish=column_finish,
column_count=column_count,
column_reversed=column_reversed)
for date_account in query:
for dt, account in date_account.iteritems():
results.append({dt.replace(tzinfo=pytz.utc): int(account)})
return results
class PromotedLinkRoadblock(tdb_cassandra.View):
_use_db = True
_connection_pool = 'main'
_read_consistency_level = tdb_cassandra.CL.ONE
_write_consistency_level = tdb_cassandra.CL.QUORUM
_compare_with = CompositeType(
tdb_cassandra.DateType(),
tdb_cassandra.DateType(),
)
@classmethod
def _column(cls, start, end):
start, end = map(to_datetime, [start, end])
return {(start, end): ''}
@classmethod
def _dates_from_key(cls, key):
start, end = map(to_date, key)
return start, end
@classmethod
def add(cls, sr, start, end):
rowkey = sr._id36
column = cls._column(start, end)
now = datetime.now(g.tz).date()
ndays = (to_date(end) - now).days + 7
ttl = timedelta(days=ndays).total_seconds()
cls._set_values(rowkey, column, ttl=ttl)
@classmethod
def remove(cls, sr, start, end):
rowkey = sr._id36
column = cls._column(start, end)
cls._remove(rowkey, column)
@classmethod
def is_roadblocked(cls, sr, start, end):
rowkey = sr._id36
start, end = map(to_date, [start, end])
# retrieve columns for roadblocks starting before end
try:
columns = cls._cf.get(rowkey, column_finish=(to_datetime(end),),
column_count=tdb_cassandra.max_column_count)
except tdb_cassandra.NotFoundException:
return False
for key in columns.iterkeys():
rb_start, rb_end = cls._dates_from_key(key)
# check for overlap, end dates not inclusive
if (start < rb_end) and (rb_start < end):
return (rb_start, rb_end)
return False
@classmethod
def get_roadblocks(cls):
ret = []
q = cls._cf.get_range()
rows = list(q)
srs = Subreddit._byID36([id36 for id36, columns in rows], data=True)
for id36, columns in rows:
sr = srs[id36]
for key in columns.iterkeys():
start, end = cls._dates_from_key(key)
ret.append((sr.name, start, end))
return ret
