def click_btnaddguide(self): db.add( "guide", { 'id': self.guideid.text(), "label": self.guidelabel.text(), "description": self.guidedescription.toPlainText() })
def click_btnaddcommand(self): db.add( "commands", { 'id': self.commandid.text(), "label": self.commandlabel.text(), "description": self.commanddescription.toPlainText() })
def create(show_record: ShowRecord, current_user: str = Depends(get_current_user)): """ create a show record """ try: show = Show() show.artist = show_record.artist show.venue = show_record.venue show.city = show_record.city show.date = show_record.date show.festival = show_record.festival show.creator_id = current_user.id db.add(show) db.commit() except sqlalchemy.exc.IntegrityError: return { "code": "error", "message": "User already exists with that username or email" } except Exception as e: print(e) return {"code": "SUCCESS"}
def middleware(request): request.user = None if "u" in request.cookies: request.user = db.query(User).filter(User.token == request.cookies["u"]).first() if request.user: if datetime.now() > request.user.last_activity + config.user_inactivity_till_leave: request.user.last_visit = request.user.last_activity request.user.last_activity = datetime.now() db.flush() request.anonymous = None if request.remote_addr != "127.0.0.1": if request.user is None: if "a" in request.cookies: request.anonymous = db.query(Anonymous).filter(Anonymous.token == request.cookies["a"]).first() if request.anonymous is None: request.anonymous = Anonymous() request.anonymous.token = "".join(random.choice(string.letters + string.digits + string.punctuation) for i in xrange(32)) db.add(request.anonymous) db.flush() if request.remote_addr not in request.anonymous.ip_addresses: request.anonymous.ip_addresses = {a: True for a in request.anonymous.ip_addresses.keys()} request.anonymous.ip_addresses[request.remote_addr] = True db.flush() return request
def click_btnaddfigure(self): db.add( "figures", { 'id': self.figureid.text(), "name": self.figurename.text(), "imgpath": self.figureimgpath.text(), "description": self.figuredescription.toPlainText() })
def set(self, directory, key, value): kv = db.query(KV).filter_by(directory=directory, key=key).first() if kv is None: kv = KV() kv.directory = directory kv.key = key db.add(kv) kv.value = value db.flush()
def execute_admin_new(self, request, type): c = ContentItem() c.type = type c.type_key = str(int(time.time())) c.created_at = datetime.now() c.permissions = ContentItem.permissions_NOT_READY c.data = self.types[c.type]["type"].get_editor().new_db() db.add(c) db.flush() return redirect("/admin/content/edit/%d/" % c.id)
def get_assets(codes=["USD"]): """ Run periodically to get data """ for code in codes: producers = Asset(asset=code, bitshares_instance=btsconf.confs['bts']) for feed in producers.feeds: dbBTS = BTSAsset( code, datetime.now(), feed["producer"]["id"], float(repr(feed["settlement_price"]).split(" ")[0]), feed["maximum_short_squeeze_ratio"], feed["maintenance_collateral_ratio"], float(repr(feed["core_exchange_rate"]).split(" ")[0]), feed["date"]) db.add(dbBTS) db.commit()
def execute_admin_edit(self, request, id): c = db.query(ContentItem).get(id) if c is None: raise NotFound() editor = self.types[c.type]["type"].get_editor() if request.method == "POST": c.type_key = request.form["type_key"] c.started_at = dateutil.parser.parse(request.form["started_at"]) if request.form.get("started_at", "").strip() else None c.created_at = dateutil.parser.parse(request.form["created_at"]) c.permissions = ContentItem.permissions_PUBLIC if "public" in request.form else ContentItem.permissions_NOT_READY c.tags = [] for tag in request.form["tags"].split(","): tag = tag.strip() db_tag = db.query(Tag).filter(Tag.title == tag).first() if db_tag is None: db_tag = Tag() db_tag.url = tag.split(":", 2)[0] if ":" in tag else tag db_tag.title = tag.split(":", 2)[1] if ":" in tag else tag db.add(db_tag) db.flush() c.tags.append(db_tag) data = editor.form_to_db(request, c.data) c.data = None db.flush() c.data = data db.flush() cache.get_cache("content_item_%d" % c.id).remove_value(key="formatter_output") return redirect(request.path) else: form = editor.db_to_form(c.data) return self.render_to_response(request, [ "content/type/%s/edit.html" % (c.type,), "content/type/%s/edit.html" % (self._base_type(c.type),), ], **{ "breadcrumbs" : [u"Редактирование %s" % self.types[c.type]["type"].item_cases[1]], "form" : form, "content_item" : c, "tags" : u",".join([t.title for t in c.tags]), })
def execute_callback(self, request, **kwargs): result = self.services[kwargs["service"]].oauth_callback(request) if result: identity = db.query(Identity).filter(Identity.service == kwargs["service"], Identity.service_id == result[0]).first() if identity is None: identity = Identity() identity.service = kwargs["service"] identity.service_id = result[0] identity.service_data = result[1] db.add(identity) db.flush() else: identity.service_data = result[1] db.flush() if not identity.trusted and (identity.trust_last_checked is None or identity.trust_last_checked < datetime.now() - timedelta(minutes=10)): service = self.services[kwargs["service"]] identity.trusted = hasattr(service, "is_trusted") and service.is_trusted(identity.service_data) identity.trust_last_checked = datetime.now() db.flush() if identity.user is None: if request.user is None: identity.user = User() identity.user.default_identity_id = identity.id # identity.user.default_identity = identity causes CircularDependencyError identity.user.token = "".join(random.choice(string.letters + string.digits + string.punctuation) for i in xrange(32)) identity.user.url_token = "".join(random.choice(string.letters + string.digits + string.punctuation) for i in xrange(32)) identity.user.settings = {} db.add(identity.user) db.flush() else: identity.user = request.user db.flush() else: if request.user is not None and request.user is not identity.user: for other_identity in request.user.identities: other_identity.user = identity.user db.delete(request.user) db.flush() response = redirect(request.args.get("from", "/")) response.set_cookie("u", identity.user.token, expires=datetime.now() + timedelta(days=365)) return response else: raise Unauthorized()
def update(show_id, show_record: ShowRecord, current_user: str = Depends(get_current_user)): """ update a single show by id, must own the show to update it """ print(show_id) show = db.query(Show).filter(Show.id == show_id).one() show.artist = show_record.artist show.venue = show_record.venue show.city = show_record.city show.date = show_record.date show.festival = show_record.festival db.add(show) db.commit() return {"update": True}
async def finish(show_id, completed_files: CompletedFiles, current_user: User = Depends(get_current_user)): print(completed_files) for id in completed_files.ids: #update attachment record and set it to active attachment = db.query(Attachment).filter(Attachment.id == id).one() attachment.active = True db.add(attachment) # add relationship to show show_attachment = ShowAttachment() show_attachment.attachment_id = id show_attachment.show_id = show_id db.add(show_attachment) db.commit() return {}
async def sign(fileUpload: FileUpload, current_user: User = Depends(get_current_user)): # create attachment record with status incomplete # if upload success, callback from uppy try: attachment = Attachment() attachment.filename = fileUpload.filename attachment.creator_id = current_user.id db.add(attachment) db.commit() bucket_name = 'showlists' object_name = 'shows/{}'.format(attachment.id) response = s3_client.generate_presigned_post(bucket_name, object_name) except ClientError as e: print(e) return None # The response contains the presigned URL and required fields return response
async def register(user_registration: UserRegistration): """ register a new user """ try: user = User() user.username = user_registration.username user.email = user_registration.email user.hashed_password = get_password_hash(user_registration.password) db.add(user) db.commit() except sqlalchemy.exc.IntegrityError: return { "code": "error", "message": "User already exists with that username or email" } finally: db.rollback() # authenticate user and redirect to profile return {"code": "success", "message": "User registered successfully"}
id = str(item.id) item_ids.append(id) content_item = db.query(ContentItem).filter_by(type=type, type_key=id).first() if content_item is None: content_item = ContentItem() content_item.type = type content_item.type_key = id content_item.started_at = item.started_at content_item.created_at = item.created_at content_item.permissions = content_types[type].get("permissions", 0) content_item.data = item.data for kv_directory in item.kv: kv = item.kv[kv_directory] for k, v in kv() if callable(kv) else kv: if k not in kv_storage[kv_directory]: kv_storage[kv_directory][k] = v() if callable(v) else v db.add(content_item) db.flush() provider.on_item_inserted(content_item) db.flush() for content_item in db.query(ContentItem).filter(ContentItem.type == type, ContentItem.permissions != ContentItem.permissions_DELETED).order_by(ContentItem.created_at.desc())[:len(item_ids)]: if content_item.type_key not in item_ids and provider.is_not_actual_item(content_item): content_item.permissions = ContentItem.permissions_DELETED db.flush()
def process_request(self, request): for middleware in all_middleware: request = middleware(request) if (request.user is not None and request.user.permissions == 0 and request.user.trusted and any(request.environ["PATH_INFO"].startswith(p) for p in ("/blog/post/", "/gallery/view/", "/video/view/", "/chatlogs/view/", "/library/view/", "/shop/view/"))): return redirect(self._encrypt_url(request.user.url_token, request.environ["PATH_INFO"])) if request.environ["PATH_INFO"].startswith("/private/"): path_info = request.environ["PATH_INFO"] path_info = path_info[len("/private/"):] url = db.query(Url).filter(Url.encrypted_url == path_info).first() if request.user is not None and request.user.trusted: if url is not None and url.user != request.user: return redirect(self._encrypt_url(request.user.url_token, url.decrypted_url)) path_info_encrypted = path_info path_info = AES.new(request.user.url_token).decrypt(unhexlify(path_info)).rstrip("@") url = db.query(Url).filter(Url.encrypted_url == path_info_encrypted).first() if url is None: url = Url() url.encrypted_url = path_info_encrypted url.decrypted_url = path_info url.user = request.user db.add(url) else: if url is None: raise Forbidden() if not any(url.decrypted_url.startswith(p) for p in ("/blog/post/", "/gallery/view/", "/video/view/", "/chatlogs/view/", "/library/view/", "/shop/view/")): raise Forbidden() auv = db.query(AnonymousUrlView).filter(AnonymousUrlView.anonymous == request.anonymous, AnonymousUrlView.url == url).first() if auv is None: auv = AnonymousUrlView() auv.anonymous = request.anonymous auv.url = url db.add(auv) db.flush() path_info = url.decrypted_url request.environ["PATH_INFO"] = path_info request = Request(request.environ) local.request = request for middleware in all_middleware: request = middleware(request) else: if request.user is None or not request.user.trusted: if not (request.host.startswith("i.") or request.remote_addr == "127.0.0.1" or any(request.environ["PATH_INFO"].startswith(p) for p in ("/authorization/", "/content/post-comment/"))): raise Forbidden() endpoint, values = self.url_map.bind_to_environ(request.environ, server_name=urlparse(config.url).netloc.split(":")[0]).match() controller, controller_endpoint = endpoint.split("/", 1) controller = self.controllers[int(controller)] controller_method = "execute_{0}".format(controller_endpoint) response = getattr(controller, controller_method)(request, **values) if request.anonymous is not None: response.set_cookie("a", request.anonymous.token, expires=datetime.now() + timedelta(days=365)) if request.user is not None and request.user.permissions == 0: if isinstance(response.data, str): response.data = re.sub('(data-url|href)="(.+?)"', partial(self._hide_url_callback, request.user.url_token), response.data) if "Location" in response.headers: response.headers["Location"] = self._encrypt_url(request.user.url_token, response.headers["Location"]) if request.anonymous: if "Location" in response.headers: parts = self._encrypt_url_parts(response.headers["Location"]) if parts: url_prefix, url, anchor = parts url_view = db.query(AnonymousUrlView).\ join(Url).\ filter(AnonymousUrlView.anonymous == request.anonymous, Url.decrypted_url == url).\ first() if url_view: response.headers["Location"] = self._build_url(url_prefix, url_view.url.encrypted_url, anchor) return response
report += u"</ul>\n" if sys.argv[2] == "post": title = ucfirst(pytils.dt.ru_strftime(u"%B %Y", date=start)) now_playing = all_social_services["last.fm"].network.get_user(all_social_services["last.fm"].username).get_now_playing() if now_playing: music = u"%s – %s" % (now_playing.get_artist().get_name(), now_playing.get_title()) else: music = "" post = ContentItem() post.type = "blog_post" post.type_key = pytils.translit.slugify(title) post.created_at = datetime.now() post.permissions = ContentItem.permissions_PUBLIC post.data = { "title" : title, "title_html" : "", "music" : music, "text" : report, "ipaddress" : "127.0.0.1", "useragent" : "Monthly report generator", } db.add(post) db.flush() if sys.argv[2] == "print": print report