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 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 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