class Competition(BasicModel):
name = CharField()
short_name = CharField()
section_code = CharField()
section_name = CharField()
season_id = IntegerField()
api_id = IntegerField(unique=True)
created = DateTimeField(default=now())
updated = DateTimeField(default=now())
@property
def teams(self):
fixtures = self.fixtures.select(Fixture.home_team, Fixture.away_team)
fixtures = fixtures.distinct(Fixture.home_team).distinct(
Fixture.away_team).tuples()
team_ids = list(set(sum(fixtures, ())))
teams = Team.select().where(Team.id << team_ids)
return teams
@property
def fixtures(self):
return Fixture.select().where((Fixture.competition == self))
def listening_for(self, message):
if utils.is_delete_event(message):
return False
if not self.secret_word and utils.now() - self.gsw_ts > 120:
self.secret_word = self._get_secret_word()
_handle = False
text = message.get('text')
user = message.get('metadata', {}).get('source_user')
channel = message.get('metadata', {}).get('source_channel')
if (isinstance(text, str) and user and user not in self.pool_excludes
and channel):
_handle = any([
self._listening_for_moin(text, user),
self._listening_for_secret_word(text, user, channel)
])
if utils.now() > self.next_pool and not _handle:
self._reset(message)
return _handle
def _to_escrow(self, miner, amt, prop):
m_type = 'Secret Word' if prop == 'sw_mined' else 'Moin'
tx_msg = (f'{m_type} Mining for {miner}. '
f'Escrow group id: {self.pool_id}')
if self._pay('pool', 'escrow', amt, tx_msg):
self.db.escrow.upsert({
'escrow_group_id': self.pool_id,
'tx_timestamp': utils.now(),
'payer_id': 'pool',
'payee_id': miner,
'amount': amt,
'memo': tx_msg
})
def _update_pool(self):
_now = utils.now()
if self.next_pool <= _now:
self.next_pool = _now + (randint(4, 15) * 3600)
amt = randint(25, 75) * 10
pool_balance = self._get_balance('pool', True)
if self._update_balance('pool', pool_balance + amt):
if self._write_tx('None', 'pool', amt, 'daily pool deposit',
_now):
self.db.pool_history.upsert({
'fillup_ts': _now,
'next_fillup_ts': self.next_pool,
'amount': amt
})
self._set_secret_word()
def _get_time_to_next_fill_up(self):
out = []
_now = utils.now()
diff = self.next_pool - _now
if diff < 60:
return f'{diff} Seconds'
hours = diff // 3600
if hours:
out.append(f'{hours} Hours')
remain = diff % 3600
minutes = remain // 60
if minutes:
out.append(f'{minutes} Minutes')
return ', '.join(out)
def _set_secret_word(self):
pool_id = self.db.pool_history.query(limit=1,
sort='id,desc',
return_field_value='id')
pool_id = pool_id if pool_id else 1
record = self.db.secret_word.query(limit=1, _filter={'id': pool_id})
if record:
self.secret_word = record['secret_word']
else:
word, user = self._generate_secret_word()
self.db.secret_word.upsert({
'id': pool_id,
'ts': utils.now(),
'secret_word': word,
'source_user': user
})
self.secret_word = word
def listening_for(self, message):
if utils.is_delete_event(message):
return False
text = message.get('text') if message.get('text') else ''
if (utils.now() > getattr(self, 'next_pool', 0)
and 'moin' not in text.lower()):
self._update_pool()
_handle = False
if isinstance(text, str):
params = re.split(r'\s+', text.lower())
if (len(params) > 1 and params[0] in self.triggers
and params[1] == 'pool'):
_handle = True
return _handle
def _set_secret_word(self, skip_current=False):
record = self.db.secret_word.query(limit=1, sort='id, DESC')
if (
record
and record['completed'] is not True
and skip_current is False
):
self.secret_word = record['secret_word']
self.secret_ts = record['ts']
else:
LOGGER.info('Setting new secret word.')
word, user = self._generate_secret_word()
now = utils.now()
self.db.secret_word.upsert({
'ts': now,
'secret_word': word,
'source_user': user
})
self.secret_word = word
self.secret_ts = now
def live_fixtures(self):
fixtures = self.app.data.load_fixtures(current=True, today_only=True)
return fixtures and fixtures[0].date <= now()
def update_event(self, item, kwargs):
kwargs['updated'] = now()
query = Event.update(**kwargs).where(Event.fs_id == item.fs_id)
query.execute()
return item
def update_stream(self, item, kwargs):
kwargs['updated'] = now()
query = Stream.update(**kwargs).where(Stream.url == item.url)
query.execute()
return item
def update_channel(self, item, kwargs):
kwargs['updated'] = now()
query = Channel.update(**kwargs).where(Channel.name == item.name)
query.execute()
return item
def update_fixture(self, item, kwargs):
kwargs['updated'] = now()
query = Fixture.update(**kwargs).where(Fixture.api_id == item.api_id)
query.execute()
return item
def update_team(self, item, kwargs):
kwargs['updated'] = now()
query = Team.update(**kwargs).where(Team.api_id == item.api_id)
query.execute()
return item
def _get_secret_word(self):
word = self.db.secret_word.get(self.pool_id,
return_field_value='secret_word')
self.gsw_ts = utils.now()
return word
class Event(BasicModel):
fs_id = CharField(unique=True)
fixture = ForeignKeyField(Fixture, related_name='fixture')
stream = ForeignKeyField(Stream, related_name='stream')
created = DateTimeField(default=now())
updated = DateTimeField(default=now())
def _generate_secret_word(self, periods=None):
if not periods or periods < 1:
periods = 1
fillups = self.db.secret_word.query(limit=periods, sort='id,desc')
if periods == 1:
fillups = (fillups['ts'], utils.now())
else:
fillups = (fillups[periods - 1]['ts'], utils.now())
users = self.db.balance.query(
limit=10,
sort='balance,asc',
fields='user',
_filter={'user__op': {
'startswith': 'U', 'notin_': self.pool_excludes}}
)
users = utils.jsearch('[].user', users)
messages = []
for channel in self.secret_word_channels:
messages += utils.call_slack_api(
self.botThread.slack_client,
'conversations.history',
True,
'messages',
total_limit=10000,
limit=1000,
latest=fillups[1],
oldest=fillups[0],
channel=channel
)
user_search = ('[?contains([{}], user) '
'&& !contains(lower(text), `moin`) '
'&& !starts_with(text, `!ak`)]').format(
', '.join([f'`{u}`' for u in users])
)
messages = utils.jsearch(user_search, messages)
word_pool = {}
for message in messages:
user = message['user']
if user not in word_pool:
word_pool[user] = []
word_pool[user] += re.findall(r':[a-zA-Z0-9_-]+:', message['text'])
string = re.sub(
r'(:[a-zA-Z0-9_-]+:)|(<@U[A-Z0-9]+>)', '', message['text'])
string = re.sub(r'\S+\.\S+', '', string)
words = re.findall(r'\b\w+\b', string)
word_pool[user] += [
w.lower() for w in words
if len(w) > 3
and w.lower() not in self.common_words
]
users = [k for k in word_pool.keys() if word_pool[k]]
last_ten = self.db.secret_word.query(sort='id,desc', limit=10)
last_ten = utils.jsearch('[].secret_word', last_ten)
if len(users) > 2 or periods >= 10:
word = last_ten[0]
i = 0
while word in last_ten:
user = choice(users)
word = choice(word_pool[user])
i += 1
if i > 9 and periods < 10:
word, user = self._generate_secret_word(periods + 1)
if i > 19:
word = last_ten[0]
break
else:
word, user = self._generate_secret_word(periods + 1)
return word, user