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)