def post(self):
if not setup_occurred():
Status.load_defaults()
Image.load_defaults()
api.invalidate_cache()
finish_setup()
self.redirect("/admin")
def test_status_warning(self):
s = Status(name=u"Hey", slug=u"hey", description=u"runaway",
image=u"helloworld.png", severity=30)
s.put()
data = s.rest("/api")
self.assertEquals(data["level"], "WARNING")
def post(self, version):
if (self.valid_version(version)):
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
image = self.request.get('image', default_value=None)
level = self.request.get('level', default_value=None)
severity = Level.get_severity(level)
if name and description and severity and image:
slug = slugify.slugify(name)
status = Status.get_by_slug(slug)
# Update existing resource
if status:
status.description = description
status.severity = severity
status.image = image
status.name = name
status.put()
self.json(status.rest(self.base_url(version)))
# Create new service
else:
status = Status(name=name, slug=slug, description=description,
severity=severity, image=image)
status.put()
self.json(status.rest(self.base_url(version)))
else:
self.error(400, "Bad Data")
else:
self.error(404, "API Version %s not supported" % version)
def data(self):
services = []
default_status = Status.get_default()
lists = []
for list in self.lists:
l = List.get_by_slug(list)
if l is not None:
lists.append(l)
for service in Service.all().filter("list IN", lists).order("name").fetch(100):
event = service.current_event()
if event is not None:
status = event.status
else:
status = default_status
if len(self.statuses) and not status.slug in self.statuses:
continue
today = date.today() + timedelta(days=1)
current, = service.history(1, default_status, start=today)
has_issues = current["information"] and status.key() == default_status.key()
service_dict = {
"slug": service.slug,
"name": service.name,
"url": service.url(),
"status": status,
"has_issues": has_issues,
"history": service.history(5, default_status),
}
services.append(service_dict)
return {"days": get_past_days(5), "statuses": Status.all().fetch(100), "services": services}
def test_status_normal(self):
s = Status(name=u"Hey", slug=u"hey", description=u"runaway",
image=u"helloworld.png", severity=10)
s.put()
data = s.rest("/api")
self.assertEquals(data["level"], "NORMAL")
def data(self):
services = []
dstatus = Status.default()
for s in Service.all().order("name").fetch(100):
event = s.current_event()
if event is not None:
status = event.status
else:
status = dstatus
service = {
"slug": s.slug,
"name": s.name,
"url": s.url(),
"status": status,
"history": s.history(5, dstatus)
}
services.append(service)
return {
"days": get_past_days(5),
"statuses": Status.all().fetch(100),
"services": services,
}
def data(self):
services = []
default_status = Status.get_default()
query = Service.all().filter("list =", self.list).order("name")
for service in query.fetch(100):
event = service.current_event()
if event is not None:
status = event.status
else:
status = default_status
today = date.today() + timedelta(days=1)
current, = service.history(1, default_status, start=today)
has_issues = (current["information"] and
status.key() == default_status.key())
service_dict = {
"slug": service.slug,
"name": service.name,
"url": service.url(),
"status": status,
"has_issues": has_issues,
"history": service.history(5, default_status),
}
services.append(service_dict)
return {
"days": get_past_days(5),
"statuses": Status.all().fetch(100),
"services": services,
}
def index(request):
all_messages = Status.objects.all()
if request.method == "POST":
msg_id = request.POST.get("msg_id", None)
del_msg = request.POST.get("del_msg", None)
new_msg = request.POST.get("new_msg", None)
if (msg_id is not None) and (del_msg is not None):
try:
this_status = Status.objects.get(pk=msg_id)
this_status.delete()
success_msg = "Deleted message: {}".format(this_status.msg)
messages.add_message(request, messages.SUCCESS, success_msg)
except:
error_msg = "Something went wrong while deleting message {}".format(msg_id)
messages.add_message(request, messages.ERROR, error_msg)
if new_msg is not None:
try:
new_status = Status()
new_status.msg = new_msg
new_status.save()
success_msg = "Created new message: {}".format(new_msg)
messages.add_message(request, messages.SUCCESS, success_msg)
except:
error_msg = "Something went wrong while creating: {}".format(new_msg)
messages.add_message(request, messages.ERROR, error_msg)
all_msgs = Status.objects.all()
return render_to_response("status_board.html", {"all_msgs": all_msgs}, context_instance=RequestContext(request))
def get(self):
user = users.get_current_user()
total = TotalAmount.all().filter('user = '******'page', 1))
if page > 0:
offset = limit * (page - 1)
else:
self.redirect('/')
return
chart_labels, chart_values = mk_chart_data(total)
total_status = Status.all().filter('user = '******'user = '******'-updated_at').fetch(limit, offset)
if len(statuses):
self.render_response('index.html', {
'statuses': statuses,
'total_amount': total.amount,
'chart_labels': chart_labels,
'chart_values': chart_values,
'is_paginated': limit < total_status,
'has_previous': page > 1,
'has_next': (offset + limit) < total_status,
'previous_page': page - 1,
'next_page': page + 1,
})
else:
self.render_response('index.html', {
'statuses': [],
})
else:
self.render_response('index.html', {})
def test_relationship(self):
"""Test relationships between users, devices, and statuses"""
u = User('user1', 'user1_guid', 'Jon Doe', 'Jon', 'Doe', 'Department',
'*****@*****.**')
d = Device('device1', 'aa:bb:cc:dd:ee')
s = Status('status-provider', 'in', dt.now())
self.session.add(s)
self.session.add(u)
self.session.add(d)
d.user = u
s.user = u
self.session.commit()
pprint(u)
pprint(d)
pprint(s)
pprint(u.devices)
pprint(u.statuses)
assert d.user == u
assert d in u.devices
assert s.user == u
assert s in u.statuses
assert u.devices[0] == d
assert u.statuses[0] == s
def get_status(request=None):
status = Status.objects.all()
if status:
return status[0]
else:
status = Status(step=1, running_status='normal')
status.save()
return status
def status_add(request):
data = JSONParser().parse(request)
status_object=Status(content=data["content"],owner=request.user.profile)
status_object.save()
serializer=StatusSerializer(status_object)
if serializer:
return JSONResponse(serializer.data, status=201)
return JSONResponse(serializer.errors, status=400)
def home(request):
# form = StatusForm()
if request.method == "POST":
status = Status()
status.status_text = request.POST['status_text']
status.save()
print request
status = Status.objects.all()
return render(request, 'statusBox/home.html', {'status': status})
def test_history_no_errors_boundary(self):
down = Status.get_by_slug("down")
up = Status.get_by_slug("up")
now = datetime(2011, 4, 5)
event = Event(status=down, service=self.service, start=now, message="HEY")
event.put()
history = self.service.history(5, up, start=date(2011, 4, 5))
self.assertEquals(history[0]["information"], False)
def post(self, request, format=None): user_id = request.DATA['user_id'] date = request.DATA['date'] temp = request.DATA['temp'] user = User.objects.get(user_id=user_id) user_status = Status(temp = temp, date = date, user = user) user_status.save() return HttpResponse(content=user_status, status=status.HTTP_201_CREATED)
def test_history_current_status(self):
down = Status.get_by_slug("down")
up = Status.get_by_slug("up")
now = datetime(2011, 4, 4, 12, 51)
event = Event(status=down, service=self.service, start=now, message="HEY")
event.put()
history, = self.service.history(1, up, start=date(2011, 4, 5))
self.assertEquals(history["information"], True)
def post(self, request, *args, **kwargs):
s = Status()
s.owner = request.user.get_profile()
status = StatusForm(request.POST, instance=s)
status.save()
#relationship = StatusRelationship(user=request.user,
#status=status)
#relationship.save()
return redirect("/")
def test_status_create(self):
s = Status(co_num = 14456,
description = 'Sample Status',
role = 'Developer')
s.save()
t = Task(user = "******",
date = date.today(),
status = s,
total_minutes = 13)
t.save()
status = str(s)
task = str(t)
def test_existing_status(self):
"""Services should 400 without a name"""
status = Status(name="Foo", slug="foo", description="hello",
image="cross-circle")
status.put()
response = self.post("/admin/api/v1/statuses",
data={"description": "An example service API",
"name": "Foo",
"image": "cross-circle"})
self.assertEquals(response.status_code, 400)
self.assertEquals(response.headers["Content-Type"], "application/json")
def test_create_event(self):
s = Service(slug=u"hey", name=u"you", description=u"lol")
s.put()
stat = Status(name=u"you", slug=u"leave", description=u"why",
image=u"cry")
stat.put()
e = Event(status=stat, service=s, message=u"¨¥¨œ∑´æ")
e.put()
data = e.rest("/api")
def set_status(request=None, step=0, running_status=''):
status = Status.objects.all()
if status:
status = status[0]
if step:
status.step = step
if running_status:
status.running_status = running_status
status.save()
else:
status = Status(step=step, running_status=running_status)
status.save()
return HttpResponseRedirect('/')
def main():
# Check if defaults have been installed
installed_defaults = memcache.get("installed_defaults")
if installed_defaults is None:
installed_defaults = Setting.all().filter('name = ', 'installed_defaults').get()
if installed_defaults is None:
logging.info("Installing default statuses")
Status.install_defaults()
if not memcache.add("installed_defaults", True):
logging.error("Memcache set failed.")
application = webapp.WSGIApplication(ROUTES, debug=config.DEBUG)
wsgiref.handlers.CGIHandler().run(application)
def setUp(self):
s = Status(co_num = 14456,
description = 'Sample Status',
role = 'Developer')
s.save()
t = Task(user = "******",
date = date(2012, 3, 18),
status = s,
total_minutes = 90)
t.save()
t2 = Task(user = "******",
date = date(2012, 3, 19),
status = s,
total_minutes = 120)
t2.save()
def post(self, version, status_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
status = Status.get_by_slug(status_slug)
if not status:
self.error(404, "No status with the slug %s found" % status_slug)
return
name = self.request.get('name', default_value=None)
image_slug = self.request.get('image', default_value=None)
image = None
default = self.request.get('default', default_value=None)
description = self.request.get('description', default_value=None)
if image_slug is not None:
image = Image.get_by_slug(image_slug)
if image is None:
self.error(400, "An Image with the "
"slug %s doesn't exist" % image_slug)
return
status.image = image.path
if description is not None:
status.description = description
if default is not None and default in ["false", "true"]:
# Reset default status
if default == "true":
for stat in Status.all().filter("default", True):
stat.default = False
stat.put()
status.default = default == "true"
if name is not None:
status.name = name
if description or name or image or default:
status.put()
invalidate_cache()
self.json(status.rest(self.base_url(version)))
def test_update_default(self):
response = self.post("/admin/api/v1/statuses/foo",
data={"default": "true"})
self.assertEquals(response.status_code, 200)
status = Status.get(self.status.key())
self.assertTrue(status.default)
def post(self):
"""Notify subscribers that a service changed status."""
address = self.request.get('address')
service = Service.get(self.request.get('service'))
oldstatus = Status.get(self.request.get('oldstatus'))
number = self.request.get('number')
logging.info("Service: %s" % service)
logging.info("Service name: %s" % service.name)
msg = "%s changed state from %s to %s (%s)" % (
service.name, oldstatus.name,
service.current_event().status.name,
service.current_event().message)
user = Subscription.get_by_email(address)
if user.status == "available" or not number:
status_code = xmpp.send_message(address, msg)
chat_message_sent = (status_code == xmpp.NO_ERROR)
logging.info("Notified: %s\nmessage: %s code: %d" % (address, msg, status_code))
elif user.status == "unavailable" and number:
sms = smsgw(to = number, msg = msg)
sms.send()
logging.info("Offline SMS: %s\nmessage: %s" % (number, msg))
def serverisdown (service):
# Create a new event with the given status and given service
service = Service.get_by_slug(service)
status = Status.get_by_slug("down")
e = Event(service=service, status=status, message="The server could not be reached")
e.put()
def post(self, version, status_slug):
if (self.valid_version(version)):
status = Status.get_by_slug(status_slug)
if status:
name = self.request.get('name', default_value=None)
image = self.request.get('image', default_value=None)
description = self.request.get('description', default_value=None)
level = self.request.get('level', default_value=None)
severity = Level.get_severity(level)
if description:
status.description = description
if image:
status.image = image
if name:
status.name = name
if severity:
status.severity = severity
if description or name or image or severity:
status.put()
self.json(status.rest(self.base_url(version)))
else:
self.error(404, "Status %s not found" % status_slug)
else:
self.error(404, "API Version %s not supported" % version)
def update(self, somekey=""):
"""
statusから抜き出してついーと
"""
"""適当"""
stasu = Status.all().order("status_id").fetch(1)
self.post(status)
def test_update_image(self):
response = self.post("/admin/api/v1/statuses/foo",
data={"image": "cross-circle"})
self.assertEquals(response.status_code, 200)
status = Status.get(self.status.key())
self.assertEquals(status.image, "fugue/cross-circle.png")
def updateIssue():
print 'TEST: Inside update_issue route.'
error = None
output = []
status_code = 400
try:
if request.method == 'POST':
print 'TEST: Inside POST Block for update_issue.'
# Collect data from CMS in JSON
issue_id = request.json['issue_id']
issue_status = request.json['issue_status']
issue_assignedTo = request.json['issue_assignedTo']
issue_updateTime = request.json['issue_updateTime']
issue_updatedBy = request.json['issue_updatedBy']
# Check if Issue is already present in Status table
checkIssue = Status.query.filter_by(SIssue_id = issue_id).first()
# Update record in Status table if issue already present
if checkIssue:
checkIssue.Status = issue_status
checkIssue.Status_updateTime = issue_updateTime
checkIssue.Status_updatedby = issue_updatedBy
db.session.commit()
output.append(dict(Msg = 'Status for Issue-id ' + str(issue_id) + ' updated successfully.'))
status_code = 200
# Insert new record in Status table
else:
new_status_issue = Status(SIssue_id = issue_id, Status = issue_status, Status_updateTime = issue_updateTime, Status_updatedBy = issue_updatedBy)
db.session.add(new_status_issue)
db.session.commit()
fetchStatus = Status.query.filter_by(SIssue_id = issue_id).first()
updateIssue = Issues.query.filter_by(Issue_id = issue_id).first()
# Update status_id, issue_assignedTo in Issues table
updateIssue.Istatus_id = fetchStatus.Status_id
updateIssue.IassignedTo = issue_assignedTo
db.session.commit()
output.append(dict(Msg = 'Status for Issue-id ' + str(issue_id) + ' added successfully.'))
status_code = 200
except Exception as e:
print e
return jsonify({'result' : output, 'status_code' : status_code})
def run(self):
logging.info("Update each status")
# For each status
for status in Status.all().fetch(100):
# Set the status to default
status.default = False
# Update the status url
status.image = "icons/fugue/" + status.image + ".png"
# Save the status
status.put()
# Get the up status and make it default
default_status = Status.get_by_slug("up")
if default_status is None:
logging.error("Could not find the up status")
return
default_status.default = True
default_status.put()
logging.info("Set up status as the default")
def test_history_order_late_month(self):
start = date(2011, 4, 5)
up = Status.get_by_slug("up")
history = self.service.history(5, up, start=start)
history_days = [h["day"] for h in history]
expected = [
date(2011, 4, 4),
date(2011, 4, 3),
date(2011, 4, 2),
date(2011, 4, 1),
date(2011, 3, 31),
]
self.assertEquals(history_days, expected)
def status(update, context):
logger.info("Command /status received.")
last_status = Status.select().order_by(Status.date.desc()).first()
if last_status is None:
context.bot.send_message(
update.message.chat_id,
text=
"O LHC pode estar aberto \U0001F513 ou fechado \U0001F512. Eu não consegui descobrir.",
)
else:
status = "aberto \U0001F513" if last_status.is_open else "fechado \U0001F512"
msg = f"O LHC está {status} desde {last_status.last_change}."
context.bot.send_message(update.message.chat_id, text=msg)
def status_list_page(uid, page=1):
if page <= 0:
abort(404)
total_page = int(math.ceil(g.user['status'] * 1.0 / config.ITEMS_PER_PAGE))
status_list = list(Status.select().where(Status.uid == uid).order_by(
Status.t.desc()).paginate(page, config.ITEMS_PER_PAGE).dicts())
for status in status_list:
extra = entry_comments_api(entry_id=status['id'])
status.update(**extra)
return render_template("status_list.html",
page=page,
total_page=total_page,
status_list=status_list)
def put(self, id):
if id is None:
return jsonify({'message' : 'Invalid request'}), 400
new_status = Status.fromJson(request.get_json())
if new_status is None:
return jsonify({'message' : 'Status data missing or incomplete'}), 400
status = Status.query.filter_by(id=id).one_or_none()
if not status:
return jsonify({'message' : 'Status not found'}), 404
status.name = new_status.name
db.session.commit()
return jsonify({'message' : 'Status updated'}), 202
def test_history_order(self):
start = date(2011, 4, 13)
up = Status.get_by_slug("up")
history = self.service.history(5, up, start=start)
self.assertEquals(len(history), 5)
history_days = [h["day"] for h in history]
expected = [
date(2011, 4, 12),
date(2011, 4, 11),
date(2011, 4, 10),
date(2011, 4, 9),
date(2011, 4, 8),
]
self.assertEquals(history_days, expected)
def data(self):
lists = {}
default_status = Status.get_default()
for service in Service.all().order("list").fetch(100):
event = service.current_event()
if event is not None:
status = event.status
else:
status = default_status
if service.list and not lists.has_key(service.list.slug) or \
lists[service.list.slug]["status"].name < status.name:
lists[service.list.slug] = {"list": service.list, "status": status}
return { "lists": lists.items() }
def save_status(request):
id = request.POST['id']
report = Report.objects.get(id=id)
message = request.POST['message']
note = request.POST['note']
user = request.user
new_status = Status()
new_status.tech = user
new_status.report = report
new_status.message = message
new_status.note = note
new_status.save()
if message == 'p':
report.completed = True
report.save()
return HttpResponseRedirect('/reports/' + id)
def get(self, version):
logging.debug("StatusesListHandler#get")
if (self.valid_version(version)):
query = Status.all().order('severity')
if (query):
data = []
for s in query:
data.append(s.rest(self.base_url(version)))
self.json({"statuses": data})
else:
self.error(404, "No statuses")
else:
self.error(404, "API Version %s not supported" % version)
def parse_guild_info(group_id, text, timestamp):
guild = get_guild(group_id)
text = text.strip()
lines = text.splitlines()
if guild is None:
# first row: guild data
raw_guild_data = lines[0]
guild = parse_guild_meta(raw_guild_data)
# check it the group allowed to proceed
tag = get_stored_tag(group_id)
if tag:
if tag != guild.tag:
raise GuildExistError
else:
store_tag(group_id, guild.tag)
glory = 0
# level = 0
members = []
for line in lines[1:]:
if line.strip().startswith("�"):
_, glory = parse_guild_level(line.strip())
if line.strip().startswith("#"):
member = parse_guild_member(line.strip())
members.append(member)
timestamp_str = timestamp.isoformat()
status = Status(timestamp=timestamp,
timestamp_str=timestamp_str,
glory=glory,
members=members)
guild.latest_status = status
last_war_timestamp = get_last_war_timestamp()
if status.timestamp < last_war_timestamp:
guild.before_war_status = status
else:
if guild.after_war_status is None or status.timestamp < guild.after_war_status.timestamp:
guild.after_war_status = status
save_guild(group_id, guild)
def post(self, version):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
name = self.request.get('name', default_value=None)
description = self.request.get('description', default_value=None)
image_slug = self.request.get('image', default_value=None)
default = self.request.get('default', default_value="false")
if default not in ["true", "false"]:
self.error(400, "Default must be true or false")
return
if not name or not description or not image_slug:
self.error(400, "Bad Data")
return
slug = slugify.slugify(name)
status = Status.get_by_slug(slug)
image = Image.get_by_slug(image_slug)
if status is not None:
self.error(400, "A Status with the slug %s already exists" % slug)
return
if image is None:
msg = "An Image with the slug %s doesn't exist" % image_slug
self.error(400, msg)
return
# Reset default status
if default == "true":
for stat in Status.all().filter("default", True):
stat.default = False
stat.put()
default = default == "true"
status = Status(name=name,
slug=slug,
description=description,
image=image.path,
default=default)
status.put()
invalidate_cache()
self.response.set_status(201)
self.json(status.rest(self.base_url(version)))
def on_data(self, data):
"""Called when raw data is received from connection.
Override this method if you wish to manually handle
the stream data. Return False to stop stream and close connection.
"""
if 'in_reply_to_status_id' in data:
status = Status.parse(self.api, json.loads(data))
if self.on_status(status) is False:
return False
elif 'delete' in data:
delete = json.loads(data)['delete']['status']
if self.on_delete(delete['id'], delete['user_id']) is False:
return False
elif 'limit' in data:
if self.on_limit(json.loads(data)['limit']['track']) is False:
return False
def delete(self, version, status_slug):
if not self.valid_version(version):
self.error(404, "API Version %s not supported" % version)
return
status = Status.get_by_slug(status_slug)
if not status:
self.error(404, "Status %s not found" % status_slug)
return
# We may want to think more about this
events = Event.all().filter('status =', status).fetch(1000)
for event in events:
event.delete()
status.delete()
self.json(status.rest(self.base_url(version)))
def delete(self, version, status_slug):
logging.debug("StatusInstanceHandler#delete slug=%s" % status_slug)
if (self.valid_version(version)):
status = Status.get_by_slug(status_slug)
if status:
# We may want to think more about this
events = Event.all().filter('status =', status).fetch(1000)
for event in events:
event.delete()
status.delete()
self.json(status.rest(self.base_url(version)))
else:
self.error(404, "Status %s not found" % service_slug)
else:
self.error(404, "API Version %s not supported" % version)
def add(cls, jid, nick=None, show=None):
""" 添加一个成员
Arguments:
`jid` - 成员jid
`nick` - 昵称
`show` - stanze.show
"""
if cls.get_one(jid):
return
m = Member(jid, nick)
m.status = [Status(show, jid.resource)]
try:
session.add(m)
session.commit()
except:
session.rollback()
return m
def test_history_order_early_month(self):
start = date(2011, 4, 2)
up = Status.get_by_slug("up")
history = self.service.history(5, up, start=start)
history_days = [h["day"] for h in history]
expected = [
date(2011, 4, 1),
date(2011, 3, 31),
date(2011, 3, 30),
date(2011, 3, 29),
date(2011, 3, 28),
]
self.assertEquals(history_days, expected)
for h in history:
self.assertFalse(h["information"])
def handle_endtag(self, tag):
if tag == 'tr':
status_obj = Status(
self.status_situacao,
self._formatar_descricao(self.status_descricao),
self.status_local, self._formatar_datetime(self.status_data))
self.status_list.append(status_obj)
self.reset_attributes()
self.parsing_status = False
if tag == 'td' and self.parsing_data_local:
self.parsing_data_local = False
if tag == 'td' and self.parsing_situacao_descricao:
self.parsing_situacao_descricao = False
if tag == 'strong' and self.parsing_situacao:
self.parsing_situacao = False
def status_check(context):
logger.info("Checking status of LHC.")
last_status = Status.select().order_by(Status.date.desc()).first()
response = requests.get("https://lhc.net.br/spacenet.json")
spacenet = response.json()
state = spacenet.get("state", {})
is_open = state.get("open")
last_change_timestamp = state.get("lastchange")
last_change = datetime.fromtimestamp(last_change_timestamp)
current_status = Status(
is_open=is_open,
last_change=last_change,
date=datetime.now(),
)
status = "OPEN" if is_open else "CLOSED"
logger.info(f"LHC is {status} since {current_status.last_change}.")
status_changed = (last_status is None
or current_status.is_open != last_status.is_open)
if status_changed:
response = requests.get("https://lhc.net.br/spacenet.json?whois")
whois = response.json()
n_unknown_macs = whois.get("n_unknown_macs", 0)
current_status.n_unknown_macs = n_unknown_macs
if is_open:
who = whois.get("who", [])
current_status.who = ", ".join(who)
notify_msg = f"O LHC foi aberto \U0001F513 por {current_status.who} às {current_status.last_change}."
else:
notify_msg = (
f"O LHC está fechado \U0001F512 desde {current_status.last_change}."
)
logger.info(
f"LHC status changed. Sending notification to LHC channel.")
# context.bot.send_message(chat_id="@lhc_campinas", text=notify_msg)
current_status.save()
def save_not_here_reason(self, bot, update):
"""Save user state as 'not here' with given reason."""
chat = update.message.chat
user = User.objects(id=chat.id).first()
status = Status(state=NOT_HERE,
reason=update.message.text,
user_id=chat.id,
user_name=user.name)
Report.objects.add_status(date=datetime.now().date(), status=status)
reply_markup = ManuKeyboard(admin=user.is_admin,
manager=user.is_manager).markup
message = emojize('got it!! thanks :punch:', use_aliases=True)
update.message.reply_text(message)
update.message.reply_text(text=emojize(":thumbsup:", use_aliases=True),
reply_markup=reply_markup)
return STATES.END
def get(self, slug):
status = Status.get_by_slug(slug)
if not status:
self.not_found()
return
td = {
"statuses_selected": True,
"status": status,
"action": "edit",
"url": "/admin/api/v1/statuses/" + slug,
"description": status.description,
"name": status.name,
"image_url": status.image,
"images": Image.all().fetch(200),
"default": status.default,
}
td.update(site.default_template_data())
self.render(td, 'admin/status_edit.html')
def get(self):
services = Service.all().fetch(50)
statuses = Status.all().fetch(10)
now = datetime.datetime.now()
for loop_no, service in enumerate(services):
if service.serviceurl == None:
continue
query = Event.all().filter('service =', service).order("-start").fetch(1)
if len(query) > 0 and (now - query.pop().start < timedelta(minutes=service.freq)):
continue
res = None
for i in range(3):
try:
# TODO: move to using async, so we can handle lots of pings...
res = urlfetch.fetch(service.serviceurl)
break
except:
logging.error('fetch num %d failed', i)
sleep(1)
if not res:
event = Event(service = service, status = statuses[0], message = "Failed page load.")
event.put()
continue
if res.status_code == 200:
if service.pattern:
result = re.search(service.pattern, res.content)
if result:
event = Event(service = service, status = statuses[1], message = "Passed. Page loaded. Regex found.")
event.put()
else:
event = Event(service = service, status = statuses[0], message = "Failed regex.")
event.put()
else:
event = Event(service = service, status = statuses[1], message = "Passed. Page loaded.")
event.put()
else:
event = Event(service = service, status = statuses[0], message = "Failed page load.")
event.put()
def update_fetch_info(uid):
from models import database, FetchedUser, User, Status, Gossip, Album, Photo, Blog
with database:
user = User.get_or_none(User.uid == uid)
if not user:
raise KeyError("no such user")
fetched_info = model_to_dict(user)
fetched_info.update(
status=Status.select().where(Status.uid == uid).count(),
gossip=Gossip.select().where(Gossip.uid == uid).count(),
album=Album.select().where(Album.uid == uid).count(),
photo=Photo.select().where(Photo.uid == uid).count(),
blog=Blog.select().where(Blog.uid == uid).count(),
)
FetchedUser.insert(**fetched_info).on_conflict('replace').execute()
print('update fetched info {fetched_info}'.format(
fetched_info=fetched_info))
return True
def _get_encomenda_status(self, html):
parser = EncomendaParser(html)
data = parser.data[3:] # table header
parser.close()
if not data:
raise CorreiosException('Object not found')
intervals = [data.index(x) for x in data if Correios.RE_DATE.match(x)]
intervals.append(len(data))
status = []
for x in intervals:
try:
status.append(
Status(*data[x:intervals[intervals.index(x) + 1]]))
except IndexError:
break
if not status:
raise CorreiosException('Status not found')
return status
def get(self, service_slug, year=None, month=None, day=None):
service = Service.get_by_slug(service_slug)
if not service:
self.not_found()
return
try:
if day:
start_date = date(int(year), int(month), int(day))
end_date = start_date + timedelta(days=1)
elif month:
start_date = date(int(year), int(month), 1)
days = calendar.monthrange(start_date.year,
start_date.month)[1]
end_date = start_date + timedelta(days=days)
elif year:
start_date = date(int(year), 1, 1)
end_date = start_date + timedelta(days=365)
else:
start_date = None
end_date = None
except ValueError:
self.not_found(404)
return
events = service.events
if start_date and end_date:
events.filter('start >= ', start_date).filter('start <', end_date)
td = default_template_data()
td["statuses"] = Status.all().fetch(100)
td["service"] = service
td["events"] = events.order("-start").fetch(500)
self.render(td, 'service.html')
def cpanel_submit(request):
# The user adding the request
user = request.user
name = request.POST['name']
phone = request.POST['phone']
email = request.POST['email']
type = request.POST['device']
os = request.POST['os']
problem = request.POST['problem']
description = request.POST['description']
deviceObj = Device()
report = Report()
usersWithSameEmail = User.objects.filter(email=email)
reportUser = User()
userFound = False
for u in usersWithSameEmail:
# If user exists, don't create a new one
if u.email == email:
reportUser = u
userFound = True
if not userFound:
reportUser.email = email
reportUser.username = name
reportUser.password = '******'
reportUser.save()
# Get the devices the user has
usersDevices = Device.objects.filter(owner=reportUser)
deviceFound = False
for d in usersDevices:
# If the device exists recognize it, and use it
if d.os == os and d.type == type:
deviceObj = d
deviceFound = True
if not deviceFound:
# Generate device object
deviceObj.owner = reportUser
deviceObj.os = os
deviceObj.type = type
deviceObj.save()
# Generate Report
report.owner = reportUser
report.device = deviceObj
report.description = description
report.problem = problem
report.completed = False
report.save()
# Generate initial status
status = Status()
status.report = report
# Checked in message
status.message = 'c'
status.tech = user
status.save()
return cpanel(request, True)
from models import Car, Driver, Garage, Manufacturer, Status, Station
import datetime
test_manufacturer = Manufacturer()
test_driver = Driver()
test_car = Car()
test_garage = Garage()
test_status = Status()
test_station = Station()
test_manufacturer = {
'id': 1,
'name': "Nissan",
'start_date': datetime.date(year=1933, month=12, day=26)
}
test_driver = {
'id': 1,
'name': "Sanic",
'birthday': datetime.date(year=2010, month=3, day=31)
}
test_car = {
'id': 1,
'on': False,
'doors': 2,
'color': 'black',
'make': test_manufacturer,
'passengers': [test_driver]
}
class Patero(GObject.GObject):
__gsignals__ = {
'finished': (GObject.SIGNAL_RUN_FIRST, None, [GObject.TYPE_PYOBJECT]),
}
def __init__(self):
GObject.GObject.__init__(self)
queue = self.queue = JobCollection()
queue.fetch()
self.tasks = deque()
self.status = Status()
self.running = False
GLib.timeout_add(500, self.transcode)
GLib.timeout_add(500, self.send_status)
def send_status(self, status=None):
self.status.save({'_id': 1, 'running': True})
return True
def transcode(self):
if self.running:
return True
job = self.queue.findWhere({'stage': 'queued'})
if not job:
return True
job['stage'] = 'about-to-process'
job.save()
def progress_cb(task, progress):
job = task.job
##logging.debug('Progress: %s', progress)
job['progress'] = progress
job.save()
def start_cb(task, src, dst):
job = task.job
logging.debug('Start: %s', src)
job['stage'] = 'processing'
job['progress'] = 0
job.save()
def error_cb(task, msg):
job = task.job
# XXX: get rid of all files here?
logging.error('Error: %s', msg)
job['stage'] = 'processing-error'
if job['tasks']:
job['tasks'][-1]['status'] = 'failed'
job['tasks'][-1]['message'] = 'Error: ' + msg
job.save()
self.tasks.clear()
self.running = False
def status_cb(task, msg):
job = task.job
logging.debug('Stage: %s', msg)
if job['tasks']:
job['tasks'][-1]['status'] = 'done'
job['tasks'].append({
'name': msg,
'status': 'processing',
'message': ''
})
job.save()
def start(*args):
self.running = True
task = self.tasks.popleft()
job = task.job
if job['tasks']:
job['tasks'][-1]['status'] = 'done'
task.start()
def success_cb(task, dst):
job = task.job
if job['tasks']:
job['tasks'][-1]['status'] = 'done'
job.save()
if not self.tasks:
logging.debug('Ok: %s', dst)
job['stage'] = 'processing-done'
job['progress'] = 0
job.save()
self.emit('finished', job)
self.running = False
return
else:
start()
def add_task(task):
self.tasks.append(task)
task.connect('progress', progress_cb)
task.connect('success', success_cb)
task.connect('status', status_cb)
task.connect('start', start_cb)
task.connect('error', error_cb)
filename = job['filename']
src = os.path.join(common.workspace_dir, filename)
dst = os.path.splitext(filename)[0] + '.m4v'
dst = os.path.join(common.workspace_dir, dst)
def on_transcode_finish(task, src, dst):
task.job['output']['transcoded'] = os.path.join(
common.output_dir, os.path.basename(dst))
task.job['output']['stat'] = {}
# XXX: this may end up with a different inode number after moving to processed dir.
try:
task.job['output']['stat'] = stat_to_dict(os.stat(dst))
except OSError:
pass
task.job.save()
_type = getFileType(src)
if _type['type'] == 'video':
task = Transcode(job, src, dst)
task.connect('finished', on_transcode_finish)
add_task(task)
# yeah, looks weird but we want the md5 of the already transcoded file.
task = MD5(job, src=dst)
add_task(task)
# even worse but we want the filmstrip of the already transcoded file.
src = dst
task = Filmstrip(job, src)
add_task(task)
task = FFmpegInfo(job, src)
add_task(task)
task = Thumbnail(job, src)
add_task(task)
else:
task = MD5(job, src)
add_task(task)
task = Filmstrip(job, src)
add_task(task)
task = FFmpegInfo(job, src)
add_task(task)
task = Thumbnail(job, src)
add_task(task)
start()
return True
def queue_file(self, filepath, do_copy=True):
try:
stat = stat_to_dict(os.stat(filepath))
except OSError:
return
filename = os.path.basename(filepath)
_type = getFileType(filepath)
if not _type:
logging.debug('File not recognized: %s', filepath)
return
# not reimplementing as mongo is quite good at this.
if self.queue._col.find({
'input.stat.mtime': stat['mtime'],
'path': filepath
}).count():
return
job = Job({
'input': {
'stat': stat,
'path': filepath,
},
'output': {
'checksum': '',
'files': [],
'metadata': {
'type': _type['type'],
},
},
'filename': filename,
'stage': '',
'progress': '0',
'tasks': [], # list of: {name:'', status:'', message:''}
})
job.save()
if do_copy:
try:
copy_or_link(filepath,
os.path.join(common.workspace_dir, filename))
job['stage'] = 'queued'
os.unlink(filepath)
except:
e = sys.exc_info()[1]
job['stage'] = 'processing-error'
job['tasks'].append({
'name': 'Moving files',
'status': 'failed',
'message': 'Error: ' + unicode(e),
})
finally:
job.save()
else:
job['stage'] = 'queued'
job.save()
self.queue.add(job)
class StatusInstanceTest(StashboardTest):
def setUp(self):
super(StatusInstanceTest, self).setUp()
image = Image(icon_set="fugue", slug="cross-circle",
path="fugue/cross-circle.png")
image.put()
self.status = Status(name="Foo", slug="foo", description="bar",
image="cross-circle")
self.status.put()
def test_update_wrong_image(self):
response = self.post("/admin/api/v1/statuses/foo",
data={"image": "foobar"})
self.assertEquals(response.status_code, 400)
def test_update_default_false(self):
response = self.post("/admin/api/v1/statuses/foo",
data={"default": "false"})
self.assertEquals(response.status_code, 200)
status = Status.get(self.status.key())
self.assertFalse(status.default)
def test_update_default(self):
response = self.post("/admin/api/v1/statuses/foo",
data={"default": "true"})
self.assertEquals(response.status_code, 200)
status = Status.get(self.status.key())
self.assertTrue(status.default)
def test_update_image(self):
response = self.post("/admin/api/v1/statuses/foo",
data={"image": "cross-circle"})
self.assertEquals(response.status_code, 200)
status = Status.get(self.status.key())
self.assertEquals(status.image, "fugue/cross-circle.png")
def test_update_description(self):
response = self.post("/admin/api/v1/statuses/foo",
data={"description": "blah"})
self.assertEquals(response.status_code, 200)
self.assertEquals(response.headers["Content-Type"], "application/json")
status = Status.get(self.status.key())
self.assertEquals(status.description, "blah")
def test_update_name(self):
response = self.post("/admin/api/v1/statuses/foo",
data={"name": "Foobar"})
self.assertEquals(response.status_code, 200)
self.assertEquals(response.headers["Content-Type"], "application/json")
status = Status.get(self.status.key())
self.assertEquals(status.name, "Foobar")
def test_get_wrong_status(self):
response = self.get("/api/v1/statuses/bat")
self.assertEquals(response.status_code, 404)
self.assertEquals(response.headers["Content-Type"], "application/json")
def test_get_status(self):
response = self.get("/api/v1/statuses/foo")
self.assertEquals(response.status_code, 200)
self.assertEquals(response.headers["Content-Type"], "application/json")
def test_url_api_correct(self):
response = self.get("/admin/api/v1/statuses/foo")
data = json.loads(response.content)
self.assertEquals(data['url'], 'http://localhost:80/admin/api/v1/statuses/foo')
def test_url_admin_api_correct(self):
response = self.get("/api/v1/statuses/foo")
data = json.loads(response.content)
self.assertEquals(data['url'], 'http://localhost:80/api/v1/statuses/foo')
def test_delete_success(self):
response = self.delete("/admin/api/v1/statuses/foo")
self.assertEquals(response.status_code, 200)
self.assertEquals(response.headers["Content-Type"], "application/json")
data = json.loads(response.content)
self.assertEquals(data['url'], 'http://localhost:80/admin/api/v1/statuses/foo')
status = Status.get(self.status.key())
self.assertEquals(status, None)
def test_delete_no_slug(self):
response = self.delete("/admin/api/v1/statuses/bar")
self.assertEquals(response.status_code, 404)
self.assertEquals(response.headers["Content-Type"], "application/json")
def test_delete_wrong_version(self):
response = self.delete("/admin/api/hey/statuses/foo")
self.assertEquals(response.status_code, 404)
self.assertEquals(response.headers["Content-Type"], "application/json")
def test_post_no_slug(self):
response = self.post("/admin/api/v1/statuses/bar")
self.assertEquals(response.status_code, 404)
self.assertEquals(response.headers["Content-Type"], "application/json")
def test_post_wrong_version(self):
response = self.post("/admin/api/hey/statuses/foo")
self.assertEquals(response.status_code, 404)
self.assertEquals(response.headers["Content-Type"], "application/json")
def test_wrong_version(self):
response = self.get("/api/hey/statuses/foo")
self.assertEquals(response.status_code, 404)
self.assertEquals(response.headers["Content-Type"], "application/json")
def setUp(self):
self.priotity = Priority('quickly')
self.status = Status('in progress')
self.task = Tasks('calculation', '01.01.2020', '07.01.2020',
self.priotity, self.status)
