def read(self, mac):
global result
result = {}
try:
if mac in globals.KEEPED_CONNECTION:
logging.debug('Already a connection for ' + mac + ' use it')
conn = globals.KEEPED_CONNECTION[mac]
else:
logging.debug('Creating a new connection for ' + mac)
conn = Connector(mac)
globals.KEEPED_CONNECTION[mac] = conn
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
notification = Notification(conn, Smartplug)
conn.writeCharacteristic('0x2b', '0f050400000005ffff')
notification.subscribe(2)
return
except Exception as e:
try:
conn.disconnect()
except Exception as e:
pass
logging.error(str(e))
return
def read(self, mac):
result = {}
try:
conn = Connector(mac)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
logging.debug('read batteryFirm')
batteryFirm = bytearray(conn.readCharacteristic('0x18'))
battery = batteryFirm[0]
firmware = "".join(map(chr, batteryFirm[2:]))
notification = Notification(conn, Mithermaff)
logging.debug('write 0x10 0100 to get sensor values')
conn.writeCharacteristic('0x10', '0100', response=True)
notification.subscribe(2)
result['battery'] = battery
result['firmware'] = firmware
result['id'] = mac
logging.debug(str(result))
return result
except Exception, e:
logging.error(str(e))
def get_notifications(self, old_stars, old_watchers, old_forks):
new_stars, new_watchers, new_forks = self.stars, self.watchers, self.forks
delta_stars = new_stars - old_stars
delta_watchers = new_watchers - old_watchers
delta_forks = new_forks - old_forks
notifications = []
if delta_stars != 0:
context = 'starr'
if delta_stars < 0:
context = 'un' + context # not a typo
notifications.append(Notification.generate_message('{} users'.format(delta_stars), context, self.name))
if delta_watchers != 0:
context = 'watch'
if delta_watchers < 0:
context = 'un' + context
notifications.append(Notification.generate_message('{} users'.format(delta_watchers), context, self.name))
if delta_forks != 0:
context = 'fork'
if delta_forks < 0:
context = 'un' + context
notifications.append(Notification.generate_message('{} users'.format(delta_watchers), context, self.name))
return notifications
def lambda_handler(event, context):
# This is the function that is called by Lambda (like a Main function)
# Fetch all records from the last week
dynamoService = database.DynamoService()
now = int(time.time())
oneWeekAgo = now - (7 * 24 * 60 * 60)
print("Getting items")
identifierList = dynamoService.getItemIdentifiersAfterTimestamp(oneWeekAgo)
# Get nutrition data on all food
nutritionService = NutritionService()
nutrition = nutritionService.getMockNutritionData()
print("Querying for nutrition")
for identifiers in identifierList:
n = nutritionService.getNutritionByIdentifiers(identifiers)
if n is not None:
nutrition.append(n)
# Generate HTML report
nutritionReport = NutrtritionReport()
url = nutritionReport.getHTML(nutrition)
# Send user notification
notificationService = Notification()
message = "Your weekly Nutrition Report is ready. Download here: " + str(
url)
notificationService.sendNotification(message)
return message
def start_video_stream(self, stream_source):
"""
Starts a video stream using a camera source
:param stream_source: Sets the stream source (camera source) of the stream.
stream_source = 0 stream using system webcam,
stream_source = 1, 2, 3 .. : stream using connected camera/camera's.
"""
vs = cv2.VideoCapture(stream_source)
time.sleep(2.0)
Interface.update_progress_bar(100)
Interface.update_info_text(
"Press 'q' to quit window | press 's' to send email of last detection"
)
while True:
frame_exist, frame = vs.read()
frame = imutils.resize(frame, width=400)
self.start_mask_detection(frame=frame)
key = cv2.waitKey(1) & 0xFF
if key == ord("q"):
Interface.canvas.create_image(
150, 150, image=VideoMaskDetection.offender_img)
Interface.update_progress_bar(0)
Interface.update_info_text("")
break
elif key == ord("s"):
Notification.notify()
vs.release()
cv2.destroyAllWindows()
def getStatus(self, mac):
logging.debug('STATUS BLPNR')
try:
conn = Connector(mac)
if not conn.isconnected:
conn.connect(type='random')
if not conn.isconnected:
return
conn.writeCharacteristic('0x000f', '2902')
conn.disconnect()
except Exception as e:
logging.error(str(e))
try:
conn = Connector(mac)
if not conn.isconnected:
conn.connect(type='random')
if not conn.isconnected:
return
logging.debug('READ notif BLPNR')
notification = Notification(conn, Blpnr)
#notification.subscribe(10,disconnect=True)
notification.subscribe()
conn.writeCharacteristic('0x0011', '0d00000d00')
except Exception as e:
logging.error(str(e))
def main(self):
sense = SenseEnvironment()
notify = Notification()
while True:
# to get all devices which are paired with raspberry pi.
p = sp.Popen(["bt-device", "--list"],
stdin=sp.PIPE,
stdout=sp.PIPE,
close_fds=True)
(stdout, stdin) = (p.stdout, p.stdin)
data = stdout.readlines()
# Get the mac address as a string
str_mac = str(data)
str_mac = str(re.findall("\((.*?)\)", str_mac))
str_mac = str_mac[2:len(str_mac) - 2]
# searching for surrounding Bluetooth devices
nearbyDevices = bluetooth.discover_devices()
for macAddress in nearbyDevices:
# checking if the mac address founded is matching the one already paired.
if macAddress == str_mac:
if self.isInOneHour(macAddress) is False:
temp = sense.senseTmp()
hum = sense.senseHum()
notify.send_notification_via_pushbullet(
"",
" The temperature is {} and the humidity is {}".
format(temp, hum))
self.db.insert(str_mac)
# 20 sec before next scanning
time.sleep(20)
class List2SystemTray(UserDict.DictMixin):
def __init__(self, icon, parent=None):
self.system_tray_icon = SystemTrayIcon(icon, parent)
self.system_tray_icon.show()
self.item_to_action_dict = {}
# self.msg("App started")
self.notification_window = None
def __setitem__(self, key, value):
action = self.system_tray_icon.menu.addAction(key)
action.triggered.connect(value)
self.item_to_action_dict[key] = value
def __delitem__(self, key):
action = self.system_tray_icon.menu.removeAction(key)
# action.triggered.connect(value)
action.triggerd.disconnect()
del self.item_to_action_dict[key]
def msg(self, msg):
# self.system_tray_icon.showMessage("Ufs system", msg, 20000)
try:
self.notification_window = Notification()
except:
import traceback
traceback.print_exc()
self.notification_window.noti(msg)
def run(self):
if not self.args.lightcommand:
self.parser.print_help(sys.stderr)
return
if self.args.lightcommand == 'inc':
self.logger.info('Increase brightness of %d%%' % self.args.value)
check_output(self.values['increase_cmd'] % (self.args.value),
shell=True)
elif self.args.lightcommand == 'dec':
self.logger.info('Decrease brightness of %d%%' % self.args.value)
check_output(self.values['decrease_cmd'] % (self.args.value),
shell=True)
else:
self.logger.info('Set brightness to %d%%' % self.args.value)
check_output(self.values['set_cmd'] % (self.args.value),
shell=True)
current_value = int(
float(check_output(self.values['get_cmd'], shell=True)))
if current_value < 50:
icon = self.values['icon-low']
elif current_value < 75:
icon = self.values['icon-medium']
elif current_value < 100:
icon = self.values['icon-high']
else:
icon = self.values['icon-full']
Notification.sendNotification("Brightness", icon, current_value)
def read(self, mac):
result = {}
#account verify : 0x29
#realtimedata : 0x30
#settings : 0x34
#settingsresult : 0x25
#historydata : 0x2c
#
#credentials : 0x21, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01, 0xb8, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00
#
#enablerealtime : 0x0B, 0x01, 0x00, 0x00, 0x00, 0x00
#
#units celcisu : 0x02, 0x00, 0x00, 0x00, 0x00, 0x00
# defini seuil : dans 0x34 ecrire 010X48f4YYYY avec x numero de sonde (commencant a 0) et y temperature x10 inverse
#
#0x31 0100 activer notif temp
#batterie 0x34 082400000000
try:
conn = Connector(mac)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
conn.writeCharacteristic('0x29',
'2107060504030201b8220000000000',
response=True)
notification = Notification(conn, Ibbq6)
conn.writeCharacteristic('0x26', '0100', response=True)
conn.writeCharacteristic('0x34', '082400000000', response=True)
notification.subscribe(10)
return result
except Exception as e:
logging.error(str(e))
return result
def _mail_log_action(self, subject, body):
ses_settings = self._config['ses_settings']
notif = Notification(aws_access_key=ses_settings['aws_access_key'],
aws_secret_key=ses_settings['aws_secret_key'],
region=ses_settings['region'])
html_body = format_html_mail_body(self.app, self.job, self._config)
log_path = self._get_log_path()
log = {
'original_log_path': log_path,
'filename': os.path.basename(log_path),
}
try:
for log_notif in self.app.get('log_notifications', []):
mail = log_notif.get('email')
if (mail and
(self.job['status'] in log_notif.get('job_states', [])
or ''.join(log_notif.get('job_states', [])) == '*')):
notif.send_mail(From=ses_settings.get(
'mail_from', MAIL_LOG_FROM_DEFAULT),
To=mail,
subject=subject,
body_text=body,
body_html=html_body,
attachments=[log],
sender_name='Cloud Deploy')
pass
except:
self._init_log_file()
logging.exception(
"An exception occurred when trying to send the Job mail notification."
)
traceback.print_exc()
self._close_log_file()
def action(self, message):
mac = message['device']['id']
handle = message['command']['handle']
value = message['command']['value']
conn = Connector(mac)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
try:
if 'key' in message['command']:
conn.writeCharacteristic('0x19',
message['command']['key'],
response=True)
if handle == '0x4e':
conn.writeCharacteristic(handle, value, response=True)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
conn.writeCharacteristic('0x51', '04')
notification = Notification(conn, Miband)
notification.subscribe(20)
conn.writeCharacteristic('0x4c', '0100', response=True)
else:
conn.writeCharacteristic(handle, value)
if value == '02':
time.sleep(10)
conn.disconnect()
except Exception as e:
logging.error(str(e))
conn.disconnect()
return
def read(self, mac):
result = {}
try:
conn = Connector(mac)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
if (mac in globals.KNOWN_DEVICES
and globals.KNOWN_DEVICES[mac]['model']
== 'xiaomiht/xiaomiht_cleargrass'):
Firm = bytearray(conn.readCharacteristic('0x2a'))
else:
Firm = bytearray(conn.readCharacteristic('0x24'))
batt = bytearray(conn.readCharacteristic('0x18'))
battery = batt[0]
result['battery'] = battery
firmware = "".join(map(chr, Firm))
result['firmware'] = firmware
notification = Notification(conn, XiaomiHT)
conn.writeCharacteristic('0x10', '0100', response=True)
notification.subscribe(2)
result['id'] = mac
logging.debug('XIAOMIHT------' + str(result))
return result
except Exception as e:
logging.error(str(e))
return result
def run(self):
for raw_notification in self._consumer:
partition = raw_notification[0]
offset = raw_notification[1].offset
message = raw_notification[1].message.value
notification_data = json.loads(message)
ntype = notification_data['type']
name = notification_data['name']
addr = notification_data['address']
period = notification_data['period']
notification = Notification(ntype, partition, offset, name, addr,
period,
notification_data['retry_count'],
notification_data['raw_alarm'])
if self._keep_sending(notification.alarm_id, notification.state):
wait_duration = period - (
time.time() - notification_data['notification_timestamp'])
if wait_duration > 0:
time.sleep(wait_duration)
notification.notification_timestamp = time.time()
self._notifier.send([notification])
self._producer.publish(self._topic_name,
[notification.to_json()])
self._consumer.commit()
def _post_order(self, res_json, value, amount, operator):
"""Post processing after getting order."""
head = HEAD_FORMAT.format(
datetime.utcnow().strftime(DATETIME_FORMAT),
self.config.platform, self.config.username,
value, amount, operator)
msg = res_json.get('errorMsg', res_json)
data = res_json.get('data', {})
if msg == 'OK':
print('{} 抢到 {} 单'.format(head, len(data)))
for order in data:
args = {
'platform': self.config.platform,
'username': self.config.username,
'mobile': order['rechargeAccount'],
'province': order['product']['province'],
'operator': OPERATORS[order['product']['operator']],
'value': order['product']['faceValue']
}
if self.config.auto_confirmation:
Timer(self.config.confirm_delay, self._confirm_order,
[order['id'], args]).start()
Notification.send_get_order(args)
else:
print('{} {}'.format(head, msg))
return len(data)
def available_networks_err(*values):
global networks
networks['time'] = int(time())
networks['acquire'] = False
notify = Notification()
notify.info('No Cellular Network found' % len(networks['gtklist']))
def msg(self, msg):
# self.system_tray_icon.showMessage("Ufs system", msg, 20000)
try:
self.notification_window = Notification()
except:
import traceback
traceback.print_exc()
self.notification_window.noti(msg)
def add_notification(self, notification_type, layout, time=None):
notification = Notification()
if notification_type == 'create':
notification.layout = layout
self.createNotification = notification
elif notification_type == 'update':
notification.set('time', time)
notification.layout = layout
self.updateNotification = notification
raise TypeError('Unknown notification type: %s', notification_type)
def create_report(report_duration, interval, image_path, log_path, percentage, threshold, person_detected, frame):
elapsed_time = time.time() - starting_time_system
notification = Notification()
if threshold < percentage:
if report_duration <= elapsed_time:
report_duration = elapsed_time + interval
notification.send_notification()
Report.save_crowd_image(image_path, frame)
Report.write_log(log_path, percentage, person_detected)
return report_duration
def __init__(self, setting_name):
setup_logger()
logging.info('Shit_Happened initializing...')
self.storage_name = None
self.notification = Notification()
self.change_checker = Change_checker()
self.profile_dict = dict()
self.site_dict = dict()
logging.info('Reading settings...')
self._read_setting(setting_name)
def _confirm_order(self, order_id, args):
"""Confirm order with some delay."""
data = {
'JSESSIONID': self.session_id,
'id': order_id,
'orderStatus': 1,
'submitRemark': None,
}
res = self.session.post(CONFIRM_URL, data=data)
args['msg'] = res.json()['errorMsg']
Notification.send_confirm_order(args)
def load_notifications(self):
notification_rows = self.database.get_notifications()
for notification_row in notification_rows:
notification_id = notification_row[0]
notification_content = notification_row[1]
date_issued = notification_row[2]
incident = self.get_incident(notification_row[3])
notification = Notification(incident, notification_content)
notification.id = notification_id
notification.date_issued = date_issued
self.notifications[notification.id] = notification
def notify_self(self):
from notification import Notification
from follower import Follower
follower = Follower.query.filter(
and_(Follower.Type == self.Type,
Follower.ParentID == self.ParentID,
Follower.UserID == self.UserID)).first()
if follower:
note = Notification(UserID=self.UserID,
Type="Comments",
ParentID=self.CommentID,
FollowerID=follower.FollowerID)
note.save()
def sendAction(self,conn,subhandle,data,sendNotif=True):
try:
packet = make_command_packet (self.session_key, conn.mac, self.mesh_id, subhandle, data)
globals.PENDING_ACTION = True
if sendNotif == True:
notification = Notification(conn, Awoxmesh, {'mac': conn.mac, 'session':self.session_key})
notification.subscribe(timer=NOTIF_TIMEOUT,disconnect=False)
logging.debug("Sending packet for "+ conn.mac + " : " + packet + " with session key : "+ "".join("%02x" % b for b in self.session_key))
return conn.writeCharacteristic(COMMAND_CHAR_UUID, packet)
except Exception,e:
logging.debug("Exception found while sending action")
logging.debug(str(e))
return False
def parse(self, data, mac, name, manuf):
result = {}
result['present'] = 1
try:
conn = Connector(mac)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
notification = Notification(conn, LogiSwitch)
notification.subscribe(2)
except Exception, e:
logging.error(str(e))
def main():
# Where is our base folder (the one containing the auto_form.py file)?
global base_dir
base_dir = os.path.normpath(os.path.dirname(os.path.realpath(sys.argv[0])))
# Parsing arguments
if len(sys.argv) > 2:
print "Too many arguments"
return
elif len(sys.argv) == 2:
if sys.argv[1] == "--setup-cron":
setup_cron()
return
elif sys.arg[1] != "--run":
print "invalid option: %s" % sys.argv[0]
return
# We are good to go!
entities = import_entities()
#entities = {"285000001": "Gobernacion"}
current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M")
if len(entities) == 0:
print "%s:: No entities found. Are you sure the file is there?" % current_time
elif len(entities) < 10:
print "%s:: Will run against those entities %s" % (current_time,entities)
else:
print "%s:: Will run against %d entities" % (current_time,len(entities))
total = 0;
report = Report(os.path.join(base_dir,REPORTS_FOLDER))
for entity_id, entity_name in entities.iteritems():
print "\n***** Entity %s (%s) *****" % (entity_name, entity_id)
new_processes = do_one(entity_id)
if len(new_processes) > 0:
report.append(entity_id, entity_name, new_processes)
total += len(new_processes)
# Notify the result
notif = None
if report.created:
text_body = "Hay %d nuevos contratos disponibles.\nAdjunto el reporte." % total
notif = Notification(text_body, report.file_path);
else:
notif = Notification("No hay nada nuevo hoy.", None);
notif.send()
# Display summary
print "\n"
print "#############################################################"
print "# Summary"
print "# We found %d new processes" % total
print "# Report avail. at %s" % report.file_path
print "#############################################################"
def add_new_reservation(self, hotel_name, customer_name, Cust_number,
from_date, to_date):
hotel_num = 0
if Reservations.reserve_room(self, hotel_name, customer_name):
for e in Hotel.hotels:
if e[1] == hotel_name:
hotel_num = e[0]
Customer.customers.append([customer_name, Cust_number])
cust_num = len(Customer.customers)
Reservations.reservations.append(
[hotel_num, cust_num, from_date, to_date])
Notification.send_text_message(
self, "Your reservation done , Thank you " + customer_name,
Cust_number)
print "Done !"
def parse(self,data,mac,name,manuf):
action={}
action['present'] = 1
if mac.upper() in globals.KNOWN_DEVICES and globals.KNOWN_DEVICES[mac.upper()]['emitterallowed'] == globals.daemonname and globals.KNOWN_DEVICES[mac.upper()]['islocked'] == 1:
conn = Connector(mac)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return action
conn.writeCharacteristic('0x36','0100')
notification = Notification(conn,Itag)
notification.subscribe()
globals.KEEPED_CONNECTION[mac.upper()]=conn
return action
def read(self, mac, connection=''):
if 'localname' in globals.KNOWN_DEVICES[mac.upper()]:
# Make it works directly with devices paired by remote control (for testing)
if globals.KNOWN_DEVICES[mac.upper()]['localname'].startswith(
"R-"):
self.mesh_name = globals.KNOWN_DEVICES[
mac.upper()]['localname']
self.mesh_password = P_DEFAULTPASSWORD
if mac in globals.KEEPED_CONNECTION:
logging.debug('Already a connection for ' + mac + ' use it')
conn = globals.KEEPED_CONNECTION[mac]
else:
logging.debug('Creating a new connection for ' + mac)
conn = Connector(mac)
globals.KEEPED_CONNECTION[mac] = conn
i = 1
authresult = False
while i <= 2:
i = i + 1
if not conn.isconnected:
try:
conn.connect(retry=1)
except:
pass
if conn.isconnected:
authresult = self.auth(conn)
if authresult:
break
else:
time.sleep(1)
if not authresult:
logging.debug(
'Ending action due to authentication error on device')
globals.PENDING_ACTION = False
return result
# send message
notification = Notification(conn, Awoxmesh, {
'mac': conn.mac,
'session': self.session_key
})
notification.subscribe(timer=NOTIF_TIMEOUT, disconnect=False)
conn.readCharacteristic(STATUS_CHAR_UUID)
return {}
class Traker:
def __init__(self, contract, p_target, limit, sender_pass):
self.logger = Logger()
self.notif = Notification(sender_pass)
self.contract = contract
self.p_target = p_target
self.limit = limit
self.scraper = Scraper(self.contract)
def track_prices(self):
Logger.log_target(self.limit, self.p_target)
while True:
try:
current_p = self.scraper.get_price()
Logger.log_price(current_p)
except Exception:
Logger.log_price("ERROR")
continue
mult_lim = 1 if self.limit.lower() == "superior" else -1
if self.p_target*mult_lim - current_p*mult_lim < 0:
Logger.log_notif_intent()
notif_txt = self.notif.send_notifications(current_p, self.p_target, round(current_p + 0.1 * mult_lim, 2), mult_lim == 1)
Logger.log_notif_txt(notif_txt)
self.p_target = round(current_p + 0.1*mult_lim, 2)
Logger.log_target(self.limit, self.p_target)
sleep(60*2)
def parsing_notification(file_content):
'''
Pre-process notifications.
:param file_content: file content
:returns: array of notification objects
:raise TypeError: unexpected data structure
:raise ValueError: invalid timestamp
'''
notifications = []
for line in file_content:
# Trim whitespace
line = line.strip()
# Seperate elements by spaces
elements = line.split(" ")
try:
# Store new notification object into array
notifications.append(Notification(*elements))
except TypeError:
print "Unexpected data structure: " + line
print "Exiting..."
sys.exit()
except ValueError:
print "Invalid timestamp: " + line
print "Exiting..."
sys.exit()
return notifications
def archifPullLastUpdates():
archifStr = requests.get("https://meddl.center/archif").content.decode("utf8")
soup = BeautifulSoup(archifStr, 'html.parser')
ul = soup.select_one('ul.archif')
notificationArray = []
counter = 0
for li in ul:
id = counter
epoch = datetime.now()
source = "meddl.center"
topic = li.findAll('a')[0].next
description = ""
if len(li.findAll('a')) > 0:
if len(li.findAll('a')[0].findAll('i')) > 0:
description = li.findAll('a')[0].findAll('i')[0].next
notificationArray.append(Notification(id, epoch, source, topic, description))
counter += 1
if counter > 29:
break
counter = 0
for notification in notificationArray:
tmpEpoch = notificationArray[29 - counter].epoch
notificationArray[29 - counter].epoch = notification.epoch
notification.epoch = tmpEpoch
counter += 1
if counter == 15:
break
return notificationArray
def create_notification(self, incident, content):
notification = Notification(incident, content)
self.database.insert_notification(notification)
self.notifications[notification.id] = notification
notification.date_issued = self.database.get_notification_date_issued(
notification)
followers = self.get_followers(incident)
for follower in followers:
user_notification = UserNotification(follower, notification, False)
self.database.insert_user_notification(user_notification)
self.database.commit()
return notification
def read(self, mac):
result = {}
try:
conn = Connector(mac)
conn.connect()
if not conn.isconnected:
conn.connect()
if not conn.isconnected:
return
batteryFirm = bytearray(conn.readCharacteristic('0x38'))
conn.writeCharacteristic('0x33', 'a01f', response=True)
battery = batteryFirm[0]
firmware = "".join(map(chr, batteryFirm[2:]))
notification = Notification(conn, Miflora)
conn.writeCharacteristic('0x36', '0100', response=True)
result['battery'] = battery
result['firmware'] = firmware
result['id'] = mac
received = bytearray(conn.readCharacteristic('0x35'))
temperature = float(received[1] * 256 + received[0]) / 10
if temperature > 3276.8:
temperature = 0 - (6553.6 - temperature)
sunlight = received[4] * 256 + received[3]
moisture = received[7]
fertility = received[9] * 256 + received[8]
result['sunlight'] = sunlight
result['moisture'] = moisture
result['fertility'] = fertility
result['temperature'] = temperature
result['source'] = globals.daemonname
logging.debug(str(result))
globals.JEEDOM_COM.add_changes('devices::' + conn.mac, result)
return result
except Exception, e:
logging.error(str(e))
def available_networks_set(*values):
global networks
global window
networks['gtklist'].clear()
gtk.gdk.threads_enter()
for network in range(0, len(values[1])):
networks['gtklist'].set(networks['gtklist'].append(), 0, str(network+1), 1, values[2][network], 2, str(int(values[1][network])), 3, values[3][network])
hildon.hildon_gtk_window_set_progress_indicator(window, 0)
gtk.gdk.threads_leave()
networks['acquire'] = False
networks['time'] = int(time())
notify = Notification()
notify.info('%d Cellular Network(s) found' % len(networks['gtklist']))
def run(self):
for raw_notification in self._consumer:
partition = raw_notification[0]
offset = raw_notification[1].offset
message = raw_notification[1].message.value
notification_data = json.loads(message)
ntype = notification_data['type']
name = notification_data['name']
addr = notification_data['address']
notification = Notification(ntype,
partition,
offset,
name,
addr,
notification_data['retry_count'],
notification_data['raw_alarm'])
wait_duration = self._retry_interval - (
time.time() - notification_data['notification_timestamp'])
if wait_duration > 0:
time.sleep(wait_duration)
sent, failed = self._notifier.send([notification])
if sent:
self._producer.publish(self._topics['notification_topic'], sent)
if failed:
notification.retry_count += 1
notification.notification_timestamp = time.time()
if notification.retry_count < self._retry_max:
log.error(u"retry failed for {} with name {} "
u"at {}. "
u"Saving for later retry.".format(ntype, name, addr))
self._producer.publish(self._topics['retry_topic'],
[notification.to_json()])
else:
log.error(u"retry failed for {} with name {} "
u"at {} after {} retries. "
u"Giving up on retry."
.format(ntype, name, addr, self._retry_max))
self._consumer.commit()
def load(self, date):
Wahl = self.accessor.clazz('wahl')
# check wheter there is an election for this date
if self.session.query(exists().where(Wahl.termin == date)).scalar():
Wahlkreis = self.accessor.clazz('wahlkreis')
Sprengel = self.accessor.clazz('sprengel')
Parteistimmen = self.accessor.clazz('parteistimmen')
Bezirk = self.accessor.clazz('bezirk')
"""
Index: Label
0: wahlkreis
1: bezirk
2: sprengel
3: berechtigte
4: abgegebene
5: ungueltige
6: partei
7: stimmanzahl
"""
# just define the query so one can check if it is correct
query = self.session.query(Wahlkreis.wknr.label('wahlkreis'),
Bezirk.bnr.label('bezirk'),
Sprengel.snr.label('sprengel'),
Sprengel.berechtigt.label('berechtigt'),
Sprengel.abgegeben.label('abgegebene'),
Sprengel.ungueltig.label('ungueltig'),
Parteistimmen.pbez.label('partei'),
Parteistimmen.stimmanzahl.label('stimmanzahl')). \
select_from(Wahlkreis). \
join(Bezirk, Bezirk.wknr == Wahlkreis.wknr). \
join(Sprengel, and_(Sprengel.bnr == Bezirk.bnr,
Sprengel.termin == date)). \
join(Parteistimmen, and_(Parteistimmen.termin == date,
Parteistimmen.bnr == Bezirk.bnr,
Parteistimmen.snr == Sprengel.snr))
# convert the data using the executed query
data, header = WahlAnalyseDataConvertAlgorithm.convert_raw(query.all())
return data, header
else:
Notification.make("Table Error", "No Data for this Date")
return [], []
def __init__(self, contract, p_target, limit, sender_pass):
self.logger = Logger()
self.notif = Notification(sender_pass)
self.contract = contract
self.p_target = p_target
self.limit = limit
self.scraper = Scraper(self.contract)
def push_notification():
""" Send a notification with the device name and status
"""
if request.method != "POST":
return MethodNotAllowed(valid_methods=["POST"])
data = json.loads(request.data)
device_name = data.get("device_name")
status = data.get("status")
if not device_name or not status:
return BadRequest(description="Parameters <device_name> and <status> are mandatory")
notification = Notification(API_KEY)
notification.send(registration_ids=registration_ids, data=data)
logging.info("Notification sent about {0} with status '{1}'".format(device_name, status))
return "200 OK"
def save(self, *args, **kwargs):
""" Due to cross import, can't directly import Utilisateur """
#
if self.send_to_all or self.send_to_inactive: # or self.send_to_active
authusers = User.objects.filter(is_superuser=False).only('email')
users = []
if self.send_to_inactive:
for u in authusers:
try:
if u.profile.get_picture_count() == 0:
users.append(u)
except ObjectDoesNotExist:
pass
else:
users = authusers
from notification import Notification
notif = Notification(debug=settings.IS_LOCAL)
notif.set_content(self.subject, self.content)
for u in users:
notif.push(u.email)
notif.send(debug=settings.IS_LOCAL)
super(MailingList, self).save(*args, **kwargs)
def testNewMessage(self):
new_message("app", "user1", "level","CriticalMessage")
notice = Notification.get_by(app="app")
self.assertEqual(notice.app, "app",
"Value retrieved should be the stored")
self.assertEqual(notice.user, "user1",
"Value retrieved should be the stored")
self.assertEqual(notice.level, "level",
"Value retrieved should be the stored")
self.assertEqual(notice.text, "CriticalMessage",
"Value retrieved should be the stored")
def update_notify(self):
show = self.config.getboolean(self.config.get_default_section(), "show_notify")
if (self.notify):
if (show):
del self.notify
self.notify = False
else:
self.notify.reopen()
else:
if (show):
self.notify = Notification(self.config, self.tray.get_geometry)
else:
self.notify = False
def run(self):
for raw_notification in self._consumer:
partition = raw_notification[0]
offset = raw_notification[1].offset
message = raw_notification[1].message.value
notification_data = json.loads(message)
ntype = notification_data['type']
name = notification_data['name']
addr = notification_data['address']
period = notification_data['period']
notification = Notification(ntype,
partition,
offset,
name,
addr,
period,
notification_data['retry_count'],
notification_data['raw_alarm'])
if self._keep_sending(notification.alarm_id, notification.state):
wait_duration = period - (
time.time() - notification_data['notification_timestamp'])
if wait_duration > 0:
time.sleep(wait_duration)
notification.notification_timestamp = time.time()
self._notifier.send([notification])
self._producer.publish(self._topic_name,
[notification.to_json()])
self._consumer.commit()
def get_notifications(self, old_count):
# changes in followers
# notification
new_count = self.followers
notifications = []
if old_count != new_count:
if self.username == USERNAME:
notification_url = URL + '/user/followers'
target = 'you'
else:
notification_url = URL + '/users/' + self.username + '/followers'
target = self.username
if new_count > old_count:
params = {'per_page': self.followers}
start_page = old_count // 100
end_page = new_count // 100
followers = []
with requests.Session() as s:
for i in range(start_page + 1, end_page + 2):
params['page'] = i
new_page = s.get(notification_url, headers=HEADERS,
params=params, auth=(USERNAME, PASSWORD)).json()
#print("Length of page {} : {}".format(i, len(new_page)))
followers += new_page
start_index = old_count % 100
context = "follow"
#print("Len of followers:" + str(len(followers)))
#print("Len of list:" + str(len(followers[start_index:])))
for user_blob in followers[start_index:]:
protagonist = user_blob['login']
notifications += [Notification.generate_message(protagonist, context, target)]
else:
message = '{} users unfollowed {}'.format(old_count - new_count, target)
notifications += [Notification(message)]
return notifications
def add(cls, media, user, text, acl, parent_id=None, to_user=None):
from notification import Notification
c = Comment(media=media, user=user, text=text)
c.mentions = [x[0] for x in re.findall(r"@\[(\d+):([a-zA-z\s]+)\]", text)]
if parent_id:
c.parent_comment = Comment.get_by_id(int(parent_id))
c.is_parent = False
elif PRIVATE_COMMENTS:
# ACL only needed on parent. Replies don't need ACLs.
c.acl = acl
c.put()
media.comment_count += 1
media.put()
for m in c.mentions:
if not to_user or (to_user and m != to_user.id):
mentioned_user = User.get_by_key_name(m)
if not mentioned_user or True:
# Send them notification on FB
fetch = urlfetch.fetch(url='https://graph.facebook.com/%s/notifications' % m,
payload='access_token=%s&template=%s&href=%s' %
(constants.facebook_app()['APP_ACCESS_TOKEN'],
'@[' + user.id + ']' + ' mentioned you in a comment on ' + media.name + '!',
media.get_path()),
method=urlfetch.POST)
else:
n = Notification.add(mentioned_user, constants.NotificationType.MENTION, c)
broadcast.broadcastNotification(n)
if c.is_parent:
from useractivity import UserActivity
broadcast.broadcastNewActivity(UserActivity.add_comment(c.user, c))
return c
def save(self, date, data):
if len(data) > 0:
Wahl = self.accessor.clazz('wahl')
Sprengel = self.accessor.clazz('sprengel')
Parteistimmen = self.accessor.clazz('parteistimmen')
# make sure there is only one election per day
wahl_at_date = self.session.query(Wahl).filter_by(termin=date).first()
if wahl_at_date:
self.session.delete(wahl_at_date)
# TODO d
self.session.commit()
# create the election with the given date
wahl = Wahl(termin=date, mandate=100)
self.session.add(wahl)
# all fields besides these are parties
"""
T = Hierarchietyp (1 = Wien-Gesamt, 2 = Wahlkreis, 3 = Bezirk, 4 = Sprengel)
WV = Wahlkreis Wien-Gesamt (09 bei Bundeswahl, 01 bei Regionalwahl)
WK = Wahlkreis
SPR = Sprengelnummer
WBER = Wahlberechtigte
ABG. = Abgegebene Stimmen
UNG. = Ungültige Stimmen
"""
reserved = ['SPR', 'BZ', 'WBER', 'ABG.', 'UNG.', 'T', 'WV', 'WK']
# save the party names to an extra list
parties = []
for key in data[0].keys():
if key not in reserved:
parties.append(key)
for row in data:
sprengel = Sprengel(
snr=int(row['SPR']),
bnr=int(row['BZ']),
termin=date,
berechtigt=int(row['WBER']),
abgegeben=int(row['ABG.']),
ungueltig=int(row['UNG.'])
)
self.session.add(sprengel)
for party in parties:
parteistimmen = Parteistimmen(
pbez=party,
snr=int(row['SPR']),
bnr=int(row['BZ']),
termin=date,
stimmanzahl=int(row[party])
)
self.session.add(parteistimmen)
try:
self.session.commit()
except Exception as e:
Notification.make("Database Error", "Could not commit: " + str(e))
else:
Notification.make("Table Error", "Empty Data List")
def postmessage(request):
""" Post a message as AJAX """
remote_addr = request.META.get('REMOTE_ADDR')
http_referer = request.META.get('HTTP_REFERER')
L.info("Post a message from {remote} for the page {referer}".format(remote=remote_addr, referer=http_referer))
if request.method == 'POST':
if CommentPref.objects.get_preferences().only_registred and not request.user.is_authenticated():
L.error('ucomment.views.postmessage: Try to post when not authenticated. ')
return HttpResponseBadRequest('')
parent = int(request.POST.get('parent'))
parent = Comment.objects.get(pk=parent) if parent != 0 else None
content = request.POST['content']
onwallurl = request.POST.get('onwallurl')
if content:
referer = request.POST.get('url')
if not referer:
referer = "/"
if not onwallurl and referer == '/' and onwallurl != '/':
referer = http_referer.replace('http://%s' % Site.objects.get_current().domain, '')
# comment = Comment.objects.create(
comment = Comment.objects.post_comment(
url=referer,
message=content,
raw_html=False,
user=request.user,
ip=remote_addr,
parent=parent
)
# Prepare JSON
data = {
'username': request.user.username,
'submission_date': convert_date(timezone.now()),
'knowuser': True,
'avatar': request.user.profile.avatar_or_default(),
'userid': request.user.id,
'commentcount': Comment.objects.filter(user=request.user, visible=True, moderate=False).only('id').count(),
'pigstiescount': Picture.objects.filter(user=request.user, trash=False).only('id').count(),
'content': comment.content,
'commentid': comment.id,
'user_authenticated': request.user.is_authenticated(),
'csrf_token': get_token(request),
}
if parent is not None:
data['parentid'] = parent.id
else:
data['parentid'] = comment.id
# Send a email to all users
if parent is not None:
comments = list(Comment.objects.filter((Q(parent=parent) & ~Q(user=request.user))).only('user__email'))
mails = {}
for comment in comments:
mails[comment.user.email] = ''
req = RequestContext(request, {
'username': request.user.username,
'message': comment.content,
'url': comment.url
})
if not settings.IS_LOCAL:
notif = Notification(settings.BANDCOCHON_CONFIG.EmailTemplates.user_comment)
for mail in mails.keys():
notif.push(mail, req)
notif.send()
# Send Json
return JsonResponse(data)
else:
L.error("ucomment.views.postmessage : Don't have a content message")
else:
L.error("ucomment.views.postmessage: Not a POST call :")
return HttpResponseBadRequest('')
def __init__(self, notificationType, player, cards):
""" Initialize the Notification with the cards, the player that caused it and the notification type """
self.cards = cards
Notification.__init__(self, notificationType, player)
class TrayApplication(ApplicationAbstract):
def __init__(self):
self.config = Config()
self.preferences = False
self.control = False
gettext.bindtextdomain(self.config.app_name, self.config.locale_dir)
gettext.textdomain(self.config.app_name)
import __builtin__
__builtin__._ = gettext.gettext
self.tray = TrayIcon(self.config)
self.control = TrayMixerWindow(self.config,
self.on_volume_changed,
self.on_mute_changed,
self.tray.get_geometry)
self.menu = TrayPopupMenu(self.config,
self.control.mixer.on_mute_button,
self.control.mixer.get_mute,
self.quit,
self.on_show_preferences,
self.tray
)
self.tray.connect("popup_menu", self.menu.on_popup_event)
self.tray.connect("button_press_event", self.on_tray_press_event)
self.tray.connect("scroll_event", self.on_window_scroll_event)
self.notify = False
self.update_notify()
self.update()
def update_notify(self):
show = self.config.getboolean(self.config.get_default_section(), "show_notify")
if (self.notify):
if (show):
del self.notify
self.notify = False
else:
self.notify.reopen()
else:
if (show):
self.notify = Notification(self.config, self.tray.get_geometry)
else:
self.notify = False
def update(self):
info = self.control.mixer.get_status_info()
self.tray.update(info)
if (self.notify):
self.notify.update(info)
def show(self):
log.Notice("update_show", 1)
if (self.notify):
self.notify.show()
def on_volume_changed(self, show):
self.update()
if (show):
self.show()
def on_mute_changed(self, show):
self.on_volume_changed(show)
def on_tray_press_event(self, widget, event, data=None):
if event.button == 1:
self.control.toggle()
elif event.button == 2:
toggle = self.config.get(self.config.get_default_section(), "toggle")
if (toggle == "mute"):
self.control.mixer.toggle_mute()
self.update()
elif (toggle == "mixer"):
self.menu.on_show_mixer()
def on_window_scroll_event(self, widget, event):
log.Notice("scroll event")
if event.direction == gtk.gdk.SCROLL_UP:
self.control.mixer.inc_volume()
elif event.direction == gtk.gdk.SCROLL_DOWN:
self.control.mixer.dec_volume()
def on_show_preferences(self, widget=None, data=None):
""" Show preferences window """
self.preferences = Preferences(self.config, self.on_preferences_close, self.on_preferences_update)
def on_preferences_update(self):
log.Notice("preferences update")
self.control.update()
self.update_notify()
self.update()
def on_preferences_close(self):
self.config.save()
