def _create_position(self, ptype):
whom = self.lastsender
try:
quantity = int(self.values[0])
symbol = self.values[1]
except:
self.chat("That's not right")
return
if quantity <= 0:
self.chat("Do you think this is a muthafuckin game?")
return
stock = Stock(symbol)
if not stock:
self.chat("Stock not found")
return
if stock.exchange.upper() not in VALID_EXCHANGES:
self.chat("Stock exchange %s DENIED!" % stock.exchange)
return
if stock.price < 0.01:
self.chat("No penny stocks")
return
drinker = Drinker.objects(name=whom).first()
if not drinker:
drinker = Drinker(name=whom)
cost = stock.price * quantity
if cost > drinker.cash:
self.chat("You is poor")
return
position = Position(symbol=stock.symbol,
price=stock.price,
quantity=quantity,
date=datetime.utcnow(),
type=ptype)
drinker.positions.append(position)
drinker.cash -= cost
drinker.save()
verb = 'bought' if ptype == 'long' else 'shorted'
self.chat("%s %s %d shares of %s (%s) at %s" %
(whom, verb, position.quantity, stock.company,
position.symbol, position.price))
def _create_position(self, ptype):
whom = self.lastsender
try:
quantity = int(self.values[0])
symbol = self.values[1]
except:
self.chat("That's not right")
return
if quantity <= 0:
self.chat("Do you think this is a muthafuckin game?")
return
stock = Stock(symbol)
if not stock:
self.chat("Stock not found")
return
if stock.exchange.upper() not in VALID_EXCHANGES:
self.chat("Stock exchange %s DENIED!" % stock.exchange)
return
if stock.price < 0.01:
self.chat("No penny stocks")
return
drinker = Drinker.objects(name=whom).first()
if not drinker:
drinker = Drinker(name=whom)
cost = stock.price * quantity
if cost > drinker.cash:
self.chat("You is poor")
return
position = Position(symbol=stock.symbol,
price=stock.price,
quantity=quantity,
date=datetime.utcnow(),
type=ptype)
drinker.positions.append(position)
drinker.cash -= cost
drinker.save()
verb = 'bought' if ptype == 'long' else 'shorted'
self.chat("%s %s %d shares of %s (%s) at %s" %
(whom, verb, position.quantity, stock.company,
position.symbol, position.price))
def workat(self):
if not self.values:
self.chat("If you're unemployed, that's cool, just don't abuse the bot")
return
name = self.lastsender
company = " ".join(self.values)
drinker = Drinker.objects(name=name)
if drinker:
drinker = drinker[0]
drinker.company = company
else:
drinker = Drinker(name=name, company=company)
drinker.save()
def awaiting(self):
if not self.values:
self.chat("Whatchu waitin fo?")
return
name = self.lastsender
awaits = " ".join(self.values)
drinker = Drinker.objects(name=name)
if drinker:
drinker = drinker[0]
drinker.awaiting = awaits
else:
drinker = Drinker(name=name, awaiting=awaiting)
drinker.save()
return "Antici..... pating."
def awaiting(self):
if not self.values:
self.chat("Whatchu waitin fo?")
return
name = self.lastsender
awaits = " ".join(self.values)
drinker = Drinker.objects(name=name)
if drinker:
drinker = drinker[0]
drinker.awaiting = awaits
else:
drinker = Drinker(name=name, awaiting=awaiting)
drinker.save()
return "Antici..... pating."
def workat(self):
if not self.values:
return 'If you\'re unemployed, that\'s cool, just don\'t abuse the bot'
user = Id(self.lastid)
if not user.is_authenticated:
return 'That\'s cool bro, but I don\'t know you!'
drinker = Drinker.objects(name=user.name)
if drinker:
drinker = drinker[0]
drinker.company = ' '.join(self.values)
else:
drinker = Drinker(name=user.name, company=' '.join(self.values))
drinker.save()
return 'I know where you work... watch your back.'
def salias(self):
whom = self.lastsender
name = self.values[0]
evil = ['salias', 'ralias', 'lalias', 'dalias']
definition = ' '.join(self.values[1:])
drinker = Drinker.objects(name=whom).first()
if not name:
self.chat("Nope.")
return
if any(sin in definition for sin in evil):
self.chat("You're trying to hurt me aren't you?")
return
if not drinker:
drinker = Drinker(name=whom)
new_alias = Alias(name=name, definition=definition)
drinker.aliases.append(new_alias)
drinker.save()
self.chat(name + " saved.")
def salias(self):
whom = self.lastsender
name = self.values[0]
evil = ['salias', 'ralias', 'lalias', 'dalias']
definition = ' '.join(self.values[1:])
drinker = Drinker.objects(name=whom).first()
if not name:
self.chat("Nope.")
return
if any(sin in definition for sin in evil):
self.chat("You're trying to hurt me aren't you?")
return
if not drinker:
drinker = Drinker(name=whom)
new_alias = Alias(name=name, definition=definition)
drinker.aliases.append(new_alias)
drinker.save()
self.chat(name + " saved.")
def reward(self):
if not self.values:
self.chat("Reward whom?")
return
kinder = self.values[0]
if kinder == self.ego.nick:
self.chat("Service is own reward for " + self.ego.nick)
return
drinker = Drinker.objects(name=kinder)
if drinker:
drinker = drinker[0]
rewards = drinker.rewards + 1
else:
drinker = Drinker(name=kinder)
rewards = 1
drinker.rewards = rewards
drinker.save()
self.chat("Good job, " + kinder + ". Here's your star: " + colorize(u'\u2605', "yellow"))
self._act(" pats " + kinder + "'s head.")
def reward(self):
if not self.values:
self.chat("Reward whom?")
return
kinder = self.values[0]
if kinder == self.ego.nick:
self.chat("Service is own reward for " + self.ego.nick)
return
drinker = Drinker.objects(name=kinder)
if drinker:
drinker = drinker[0]
rewards = drinker.rewards + 1
else:
drinker = Drinker(name=kinder)
rewards = 1
drinker.rewards = rewards
drinker.save()
self.chat("Good job, " + kinder + ". Here's your star: " + colorize(u'\u2605', "yellow"))
self._act(" pats " + kinder + "'s head.")
class Id(object):
nick = False
ident = False
host = False
is_authenticated = False
is_guest = False
is_owner = False
prop = False
def __init__(self, user):
try:
self.nick, data = user.split('!')
self.ident, self.host = data.split('@')
except Exception as e:
pprint(e)
return
settings = load_config('config/settings.yaml')
auth_data = load_config(settings.directory.authfile)
if self.nick in auth_data:
self.is_authenticated = True
if 'owner' in auth_data[self.nick] and auth_data[self.nick].owner:
self.is_owner = True
self.prop = Drinker.objects(name=self.nick).first()
if not self.prop:
self.prop = Drinker(name=self.nick)
'''
Dynamicaly retrieve data from the datastore connection that are linked to the current
authenticated user.
'''
def __getattr__(self, key):
if not self.is_authenticated or not self.prop:
return False
# This can eventually be removed; migrate the data as we go
self.migrate(key)
if key in self.prop.data:
return self.prop.data[key]
if key in self.prop:
return self.prop[key]
return False
'''
Update an attribute in the datastore when a linked variable is accessed
'''
def __setattr__(self, key, value):
if hasattr(self.__class__, key):
object.__setattr__(self, key, value)
return True
if not self.is_authenticated or not self.prop:
return False
# This can eventually be removed; migrate the data as we go
self.migrate(key)
tainted = False
if key in self.prop.data:
self.prop.data[key] = value
tainted = True
# Even with a migration lets save the changes to the original as well,
# no need for an additional check.
if key in self.prop:
self.prop[key] = value
tainted = True
if tainted:
try:
self.prop.save()
except:
return False
return True
'''
Migrate data to new data format as we go
'''
def migrate(self, key):
protected = [ 'name', 'password' ]
if key in protected:
# Protected variable that should not get migrated
return
if key in self.prop.data:
# Already migrated
return
if key in self.prop:
self.prop.data[key] = self.prop[key]
self.prop.save()
return
class Id(object):
nick = False
ident = False
host = False
ip = False
fullid = False
is_authenticated = False
is_recognized = False
is_owner = False
prop = False
def __init__(self, *arguments, **keywords):
if not len(arguments) and len(keywords):
# Prepend 'data__' to all keywords for appropriate searching in data dictfield
keywords = dict(
map(lambda (key, value): ('data__' + str(key), value),
keywords.items()))
# Search for a user with the data field
self.prop = Drinker.objects(**keywords).first()
if self.prop:
self.nick = self.prop.name
else:
user = arguments[0]
self.fullid = user
try:
self.nick, self.ident = user.split('!')
self.host = self.ident.split('@', 1)[1]
except:
self.nick = user
try:
self.ip = socket.gethostbyname_ex(self.host.strip())[2][0]
except:
pass
if not self.nick:
return
# ident not getting set for some reason?
self.is_recognized = True
self.prop = Drinker.objects(name=self.nick).first()
if not self.prop:
self.prop = Drinker(name=self.nick)
self.is_recognized = False
if self.ident in self.prop['idents']:
self.is_authenticated = True
secrets = load_config('config/secrets.yaml')
if self.nick == secrets.owner and self.is_authenticated:
self.is_owner = True
# Dynamicaly retrieve data from the datastore connection that are linked to the current
# authenticated user.
def __getitem__(self, key):
return self.__getattr__(key)
def __setitem__(self, key, value):
return self.__setattr__(key, value)
def __getattr__(self, key):
if not self.is_recognized or not self.prop:
return False
# This can eventually be removed; migrate the data as we go
# self.migrate(key)
if key in self.prop.data:
return self.prop.data[key]
if key in self.prop:
return self.prop[key]
return False
# Update an attribute in the datastore when a linked variable is accessed
def __setattr__(self, key, value):
if hasattr(self.__class__, key):
object.__setattr__(self, key, value)
return True
if not self.is_authenticated or not self.prop:
return False
# This can eventually be removed; migrate the data as we go
self.migrate(key)
self.prop.data[key] = value
# Even with a migration lets save the changes to the original as well,
# no need for an additional check.
if key in self.prop:
self.prop[key] = value
try:
self.prop.save()
except:
return False
return True
# Migrate data to new data format as we go
def migrate(self, key):
protected = ['name', 'password']
if key in protected: return
if key in self.prop.data: return
if key in self.prop:
self.prop.data[key] = self.prop[key]
self.prop.save()
return
# Set the users password
def setpassword(self, password, skip_auth_check=False):
if (not self.is_authenticated
or not self.prop) and not skip_auth_check:
return False
obj = hashlib.sha256(password)
self.prop['password'] = obj.hexdigest()
self.is_authenticated = True
self.prop.save()
# Identify a user by password, and add ident if successful
def identify(self, password):
obj = hashlib.sha256(password)
if obj.hexdigest() != self.prop['password']:
return "Hex check failed."
self.is_authenticated = True
self.prop.idents.append(self.ident)
self.prop.save()
return True
class Id(object):
nick = False
ident = False
host = False
ip = False
fullid = False
is_authenticated = False
is_recognized = False
is_owner = False
prop = False
def __init__(self, *arguments, **keywords):
if not len(arguments) and len(keywords):
# Prepend 'data__' to all keywords for appropriate searching in data dictfield
keywords = dict(map(lambda (key, value): ('data__' + str(key), value), keywords.items()))
# Search for a user with the data field
self.prop = Drinker.objects(**keywords).first()
if self.prop:
self.nick = self.prop.name
else:
user = arguments[0]
self.fullid = user
try:
self.nick, self.ident = user.split('!')
self.host = self.ident.split('@', 1)[1]
except:
self.nick = user
try:
self.ip = socket.gethostbyname_ex(self.host.strip())[2][0]
except:
pass
if not self.nick:
return
# ident not getting set for some reason?
self.is_recognized = True
self.prop = Drinker.objects(name=self.nick).first()
if not self.prop:
self.prop = Drinker(name=self.nick)
self.is_recognized = False
if self.ident in self.prop['idents']:
self.is_authenticated = True
secrets = load_config('config/secrets.yaml')
if self.nick == secrets.owner and self.is_authenticated:
self.is_owner = True
# Dynamicaly retrieve data from the datastore connection that are linked to the current
# authenticated user.
def __getitem__(self, key):
return self.__getattr__(key)
def __setitem__(self, key, value):
return self.__setattr__(key, value)
def __getattr__(self, key):
if not self.is_recognized or not self.prop:
return False
# This can eventually be removed; migrate the data as we go
# self.migrate(key)
if key in self.prop.data:
return self.prop.data[key]
if key in self.prop:
return self.prop[key]
return False
# Update an attribute in the datastore when a linked variable is accessed
def __setattr__(self, key, value):
if hasattr(self.__class__, key):
object.__setattr__(self, key, value)
return True
if not self.is_authenticated or not self.prop:
return False
# This can eventually be removed; migrate the data as we go
self.migrate(key)
self.prop.data[key] = value
# Even with a migration lets save the changes to the original as well,
# no need for an additional check.
if key in self.prop:
self.prop[key] = value
try:
self.prop.save()
except:
return False
return True
# Migrate data to new data format as we go
def migrate(self, key):
protected = ['name', 'password']
if key in protected: return
if key in self.prop.data: return
if key in self.prop:
self.prop.data[key] = self.prop[key]
self.prop.save()
return
# Set the users password
def setpassword(self, password, skip_auth_check=False):
if (not self.is_authenticated or not self.prop) and not skip_auth_check:
return False
obj = hashlib.sha256(password)
self.prop['password'] = obj.hexdigest()
self.is_authenticated = True
self.prop.save()
# Identify a user by password, and add ident if successful
def identify(self, password):
obj = hashlib.sha256(password)
if obj.hexdigest() != self.prop['password']:
return "Hex check failed."
self.is_authenticated = True
self.prop.idents.append(self.ident)
self.prop.save()
return True
class Id(object):
nick = False
ident = False
host = False
is_authenticated = False
is_guest = False
is_owner = False
prop = False
def __init__(self, user):
try:
self.nick, data = user.split('!')
self.ident, self.host = data.split('@')
except Exception as e:
pprint(e)
return
settings = load_config('config/settings.yaml')
auth_data = load_config(settings.directory.authfile)
if self.nick in auth_data:
self.is_authenticated = True
if 'owner' in auth_data[self.nick] and auth_data[self.nick].owner:
self.is_owner = True
self.prop = Drinker.objects(name=self.nick).first()
if not self.prop:
self.prop = Drinker(name=self.nick)
'''
Dynamicaly retrieve data from the datastore connection that are linked to the current
authenticated user.
'''
def __getattr__(self, key):
if not self.is_authenticated or not self.prop:
return False
# This can eventually be removed; migrate the data as we go
self.migrate(key)
if key in self.prop.data:
return self.prop.data[key]
if key in self.prop:
return self.prop[key]
return False
'''
Update an attribute in the datastore when a linked variable is accessed
'''
def __setattr__(self, key, value):
if hasattr(self.__class__, key):
object.__setattr__(self, key, value)
return True
if not self.is_authenticated or not self.prop:
return False
# This can eventually be removed; migrate the data as we go
self.migrate(key)
tainted = False
if key in self.prop.data:
self.prop.data[key] = value
tainted = True
# Even with a migration lets save the changes to the original as well,
# no need for an additional check.
if key in self.prop:
self.prop[key] = value
tainted = True
if tainted:
try:
self.prop.save()
except:
return False
return True
'''
Migrate data to new data format as we go
'''
def migrate(self, key):
protected = ['name', 'password']
if key in protected:
# Protected variable that should not get migrated
return
if key in self.prop.data:
# Already migrated
return
if key in self.prop:
self.prop.data[key] = self.prop[key]
self.prop.save()
return
