def from_json( self, program_data ):
logh = self.__lgr.logger
try: self.title = program_data["title"]
except KeyError:
logh.exception( util.create_msg( "unable to find title for the program" ) )
return
try: self.author = program_data["author"]
except KeyError:
logh.exception( util.create_msg( "unable to find author of the program" ) )
return
try: self.url = program_data["url"]
except:
logh.warning( util.create_msg( "unable to find url for the program, default will be set" ) )
# TODO put in config
self.url = "www.radiocicletta.it"
try: self.theme = program_data["theme"]
except:
logh.warning( util.create_msg( "unable to find program theme, default will be set" ) )
# TODO put in config
self.theme = "ON AIR"
logh.log( util.create_msg( "All data successfully retrieved" ) )
def spam(self, spam_line = None, spam_url = None, day = None, hour = None, minute = None ):
if( spam_line == None ):
program_obj = self.get_on_air_program(day, hour, minute)
if not program_obj :
self.__logger_handler.logger.warning( util.create_msg("No on air program found") )
return None
spam_line = self.create_on_air_line(program_obj.author, program_obj.title, program_obj.theme)
self.__logger_handler.logger.debug( util.create_msg("Spam Line created correctly: " + spam_line) )
def get_on_air_program(self, day, hour, minute):
pal_reader = palim_reader.palim_reader(self.__palimpsest)
if pal_reader == None:
self.__logger_handler.logger.error( util.create_msg("Unable to get palimpsest reader") )
return
palim_obj = pal_reader.read(day, hour, minute)
if palim_obj == None:
self.__logger_handler.logger.warning( util.create_msg("Unable to read "+day+", "+hour+":"+minute+" on palimpsest") )
return
return palim_obj
def from_string( self, program_data_str ):
try:
program_data = json.loads(program_data_str)
except:
self.__lgr.logger.error( util.create_msg( "" ) )
return
self.from_json( program_data )
def spam_now( self, spam_line = None, spam_url = None ):
day = time.strftime("%a")
hour = time.strftime("%H")
minute = time.strftime("%M")
self.__logger_handler.logger.error( util.create_msg("try to spam "+day+" "+hour+":"+minute) )
self.spam( spam_line, spam_url, day, hour, minute )
def read_by_day( self, day_of_week ):
try:
palim_week = self.__pal_json["Palinsesto"]
except:
self.__lgr.logger.exception( util.create_msg( "Error in retrieving object from json" ) )
return None
try:
day_data = palim_week[day_of_week]
except KeyError:
pass
if day_data == None :
self.__lgr.logger.warning( util.create_msg( "Unable to retrieve data" + day_of_week ) )
return None
self.__lgr.logger.warning( util.create_msg( "data found " + str(day_data) ) )
return day_data
def to_string(self):
result = self.day + " - "
result += self.hour + ":"
result += self.minute + " "
result += self.title + " with "
result += self.author + ": "
result += self.theme + " on "
result += self.url
self.__lgr.logger.log( util.create_msg( "string created: " + result ) )
return result
def read( self, day_of_week, hour, minute ):
palim_hour = self.read_by_hour( day_of_week, hour )
if(palim_hour == None):
self.__lgr.logger.error( util.create_msg( "Error in loading day "+ day_of_week + " from json" ) )
return None
minute_data = None
try:
minute_data = palim_hour[minute]
except KeyError:
pass
if minute_data == None :
self.__lgr.logger.warning( util.create_msg("Program not found on " + str(day_of_week) + " at " + str(hour) + ":" + str(minute)) )
return
pal_obj = palimpsest_obj(day_of_week, hour, minute)
pal_obj.from_json(minute_data)
return pal_obj
def read_by_hour( self, day_of_week, hour ):
palim_day = self.read_by_day(day_of_week)
if(palim_day == None):
return None
hour_data = None
try:
hour_data = palim_day[hour]
except KeyError:
pass
if hour_data == None :
self.__lgr.logger.warning( util.create_msg( "Hour " + str(hour) + " not found on " + str(day_of_week) ) )
return
return hour_data
def __tweet( self, tweet, url = None ):
if not url : url = self._url
logh = self.__logger_handler.logger
tweet = self.__handle_tweet(tweet, url)
logh.debug( util.create_msg("tweet will be: " + tweet) )
conf_obj = util.conf_handler("../conf/twitter.conf")
consumer_key = conf_obj.get_conf_value("consumer_key" )
if ( consumer_key == None ):
logh.error( util.create_message("Unable to retrieve consumer_key") )
return None
consumer_secret = conf_obj.get_conf_value("consumer_secret" )
if ( consumer_secret == None ):
logh.error( util.create_message("Unable to retrieve consumer_secret") )
return None
access_token = conf_obj.get_conf_value("access_token" )
if ( access_token == None ):
logh.error( util.create_message("Unable to retrieve access_secret") )
return None
access_secret = conf_obj.get_conf_value("access_secret" )
if ( access_secret == None ):
logh.error( util.create_message("Unable to retrieve access_secret") )
return None
# Errors must be handled here and then
logh.debug( util.create_message("logging on twitter through OAuth") )
auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
auth.set_access_token(access_token, access_secret)
api = tweepy.API(auth)
logh.debug( util.create_message("twitting: " + tweet) )
# api.update_status(tweet)
return tweet
import time
import util
import logging
import spammer
log_handler = util.log_handler(debug_level=logging.DEBUG)
while True:
log_handler.logger.debug(util.create_msg("Time to log!"))
spam = spammer.spammer()
spam.spam_now()
time.sleep(60)
