def create_blog_api(): user = g.get('user', None) if user is None: return redirect(url_for('login')) else: if user.admin: name = request.form['name'].encode('utf8') summary = request.form['summary'].encode('utf8') content = request.form['content'].encode('utf8') user_id = request.form['user_id'].encode('utf8') user_name = request.form['user_name'].encode('utf8') user_image = request.form['user_image'].encode('utf8') sess = DBSession() blog = Blogs(user_id=user_id, user_name=user_name, user_image=user_image, name=name, summary=summary, content=content) sess.add(blog) sess.commit() sess.close() return 'ok' else: return redirect(url_for('login'))
def oauth2callback(request): log.info('oauth2callback called at %s', request.url) # Get the auth code from the GET params try: code = request.GET['code'] log.info('Successfully got auth code') except KeyError: log.error('Could not find auth code in GET params') return error_response(500, 'Sorry, but Google authorization failed.') # Exchange the auth code for a bearer/access token flow = OAuth2WebServerFlow(CLIENT_ID, CLIENT_SECRET, OAUTH_SCOPE, redirect_uri=request.route_url('oauth2callback')) credentials = flow.step2_exchange(code) try: access_token = credentials.access_token refresh_token = credentials.refresh_token token_expiry = credentials.token_expiry if access_token is None or refresh_token is None or token_expiry is None: raise ValueError except (AttributeError, ValueError): log.error('Could not get access token, refresh token, and/or token expiry from exchanged credentials') return error_response(500, 'Sorry, but Google authorization failed.') DBSession.add(GDriveAccount(access_token, refresh_token, token_expiry)) return Response('Successfully authorized with Google Drive!')
def post_entry(request): entry = m.Entry() entry.start_datetime = datetime.datetime.now() entry.updated_datetime = datetime.datetime.now() DBSession.add(entry) DBSession.flush() return entry.entry_id
def job_output(self): log = logging.getLogger(__name__) jobid = self._request.matchdict['jobid'] log.info('Request job output for id:{0}'.format(jobid)) ssh_holder = self._request.registry.settings['ssh_holder'] ssh_jobmanager = SSHBasedJobManager(ssh_holder) jobs = self._get_current_jobs(ssh_jobmanager, self._coltitles) joboutput = ssh_jobmanager.get_job_output(jobid) if 'error' in joboutput and joboutput['error'] is None: db_joboutput = JobOutput(id=jobid, output=jsonpickle.encode(joboutput)) DBSession.add(db_joboutput) DBSession.commit() if 'error' in joboutput and joboutput['error'] is not None: jobresult = joboutput['error'] else: jobresult = joboutput['content'] jobresult = ''.join(jobresult) if 'type' not in joboutput: joboutput['type'] = 'type field missing' return {'project': self._projectname, 'jobs': jobs, 'output': dict(jobid=jobid, output=jobresult, type=joboutput['type'])}
def filemonitoring(self): log = logging.getLogger(__name__) if self._request.params: # TODO: add this information to the file md5_enabled = True if 'withmd5' in self._request.params and self._request.params['withmd5'] == '0' else False all_files = self._request.params.getall('file') complete_file, filenames, folders = self._get_monitored_files(self._request.params['folder'] + '/') with transaction.manager: for f in all_files: if f in complete_file: log.debug('Skipping file {0}, because it is already monitored'.format(f)) continue (path, filename) = os.path.split(f) dbobj = MonitoredFile(path, filename, f) DBSession.add(dbobj) DBSession.commit() files_not_mentioned = [c for c in complete_file if c not in all_files] # TODO: decide on this log.info('TODO: Still have to decide whether files which are not selected should be deleted or not.' 'Affected files would be: {0}'.format(files_not_mentioned)) else: log.info('Got an empty request, going to redirect to start page') subreq = Request.blank('/') return self._request.invoke_subrequest(subreq) subreq = Request.blank(self._request.route_path('filebrowser'), POST=dict(folder=self._request.params['folder'], currentfolder=self._request.params['currentfolder'], pathdescription='abs')) return self._request.invoke_subrequest(subreq)
def on_set_base_info(cls, company_id, company_name=None, country=None, city=None, address=None, timezone=None, currency=None, note=None): """ 设置公司基础信息 """ session = DBSession() com = session.query(cls).filter(cls.company_id == company_id).first() if com: if company_name: com.company_name = company_name if country: com.country = country if city: com.city = city if address: com.address = address if timezone: com.timezone = timezone if currency: com.currency = currency if note: com.note = note try: session.add(com) session.commit() except Exception as why: session.rollback() message = "companies.on_set_base_info: {0}".format(why) logging.info(message) return -1 return 0
def _init(self, stmtrs): # BANKTRANLIST tranlist = stmtrs.find('BANKTRANLIST') if tranlist is not None: self.transactions = TransactionList(self.account, tranlist) DBSession.add_all(self.transactions) # LEDGERBAL - mandatory ledgerbal = stmtrs.find('LEDGERBAL') self.ledgerbal = ledgerbal.instantiate(acctfrom=self.account) DBSession.add(self.ledgerbal) # AVAILBAL availbal = stmtrs.find('AVAILBAL') if availbal is not None: self.availbal = availbal.instantiate(acctfrom=self.account) DBSession.add(self.availbal) ballist = stmtrs.find('BALLIST') if ballist: self.other_balances = [bal.instantiate() for bal in ballist] DBSession.add_all(self.other_balances) # Unsupported subaggregates for tag in ('MKTGINFO', ): child = stmtrs.find(tag) if child: stmtrs.remove
class LagouPipeline(object): def __init__(self): self.session = DBSession() self.pool = redis.Redis(host='raspberrypi', port=6379, db=2) def process_item(self, item, spider): if isinstance(item, LagouItem): if self.session.query(Jobs).filter( Jobs.positionId == item['positionId'], Jobs.companyId == item['companyId']).first(): pass else: obj = Jobs( companyId=item['companyId'], positionId=item['positionId'], jobNature=item['jobNature'], companyName=item['companyName'], financeStage=item['financeStage'], companyFullName=item['companyFullName'], companySize=item['companySize'], industryField=item['industryField'], positionName=item['positionName'], city=item['city'], createTime=item['createTime'], salary_low=item['salary_low'], salary_high=item['salary_high'], workYear=item['workYear'], education=item['education'], positionAdvantage=item['positionAdvantage'], district=item['district'], # uid=item['uid'], companyLabelList=item['companyLabelList'], ) self.session.add(obj) try: self.session.commit() except Exception, e: print e self.session.rollback() # self.session.close() elif isinstance(item, CompanyItem): # 公司信息存入mysql数据库 ''' obj=Company( companyId=item['companyId'], companyName=item['companyFullName'] ) self.session.add(obj) try: self.session.commit() except Exception, e: print e self.session.rollback() ''' # 公司的数据存入redis self.pool.set(item['companyId'], item['companyFullName'])
def getUser(request): username = request.headers["X-Webauth-User"] #now get the uuid uuid = "" print "UserName:"******"UUID:", uuid if uuid == "": user = DBSession.query(Owners).filter_by(username=username).all() else: user = DBSession.query(Owners).filter_by(uuid=uuid).all() if len(user) == 0: cur = Owners(username, uuid) DBSession.add(cur) DBSession.commit() user = DBSession.query(Owners).filter_by(username=username).all() print "Made" if len(user) == 1: print "Found" cur = user[0] # if user == "zemon1": # user = "******" return cur
def attach_pictures(request): menu_query = DBSession.query(Menu).filter(Menu.id==request.matchdict['menu_id']) images_id = menu_query.one().images_id images_id = images_id.split(' ') if images_id else [] if images_id: images = DBSession.query(Image).filter(Image.id.in_(images_id)).all() added_thumbs = [] if "data" in request.params: data = json.loads(request.params["data"]) for image_info in data: image, thumb = image_info if not image or not thumb: continue ext = os.path.splitext(image)[-1].lower() if ext in (".jpg", ".jpeg", ".png"): new_image = Image(image_url=image, thumb_url=thumb) added_thumbs.append(thumb) DBSession.add(new_image) DBSession.flush() DBSession.refresh(new_image) images_id.append(new_image.id) menu_query.update({ "images_id": ' '.join([str(i) for i in images_id]), }) return json.dumps(added_thumbs)
def upload(request): if request.content_length/1000000 > 20: return error_response(400, 'Sorry, but the file must be under 20MB.') # Create photo object in database photo = Photo(datetime.today(), request.POST['file'].filename, request.client_addr, request.content_type, request.content_length) DBSession.add(photo) DBSession.flush() # Save uploaded file input_file = request.POST['file'].file input_file.seek(0) if not os.path.exists('data'): os.makedirs('data') if not os.path.exists('data/uploads'): os.makedirs('data/uploads') upload_path = os.path.join('data', 'uploads', str(photo.id)) with open(upload_path, 'w') as f: shutil.copyfileobj(input_file, f) # Check the content type and rename as appropriate mime = magic.from_file(upload_path, mime=True) if mime not in ['image/jpeg', 'image/pjpeg', 'image/gif', 'image/png', 'image/tiff', 'image/x-tiff']: resp = Response('Sorry, but we can only accept jpg, gif, or png files.') resp.status_code = 400 resp.status_string = '400 Bad Request' return resp extension = {'image/jpeg': '.jpg', 'image/pjpeg': '.jpg', 'image/gif': '.gif', 'image/png': '.png', 'image/tiff': '.tiff', 'image/x-tiff': '.tiff'}[mime] os.rename(upload_path, upload_path + extension) photo.content_type = mime return Response('OK')
def postAdd(request): currentUser = int(authenticated_userid(request)) rankWeight = None #TODO pasteTitle = request.POST['paste_title'] topic_id = request.POST['topic'] newPost = Post(currentUser,rankWeight,topic_id,pasteTitle) DBSession.add(newPost) DBSession.flush() contentTitles = [] contentURLs = [] for key, value in request.POST.iteritems(): if key == "title" and value != "": contentTitles.append(value) elif key == "URL" and value != "": contentURLs.append(value) contents = [] for title,URL in zip(contentTitles,contentURLs): contentType = "LINK" # TODO newContent = Content(title,URL,contentType,newPost.id) DBSession.add(newContent) DBSession.flush() contents.append(row2dict(newContent)) post = {} post['post'] = row2dict(newPost) post['contents'] = contents return {'post' : post}
def sentiment_data(self, url, common_list): """ Does the sentiment analysis with wit.ai and saves the sentiment data into the database. """ query_str = urllib.parse.quote_plus(' '.join(common_list)[:280]) resp = yield self.fetch_url( 'https://api.wit.ai/message?v=20180703&q={}'.format(query_str), headers={ 'Authorization': 'Bearer {WIT_AUTH_KEY}'.format(WIT_AUTH_KEY=WIT_AUTH_KEY) }) ents = json.loads(resp['body'])['entities'] sentiment = ents and ents.get('sentiment') if sentiment: sentiment = sentiment[0]['value'] s_obj = DBSession.query(UrlSentiment).filter( UrlSentiment.sentiment == sentiment) if s_obj.count() == 0: s_obj = UrlSentiment(url=url, sentiment=sentiment) DBSession.add(s_obj) DBSession.commit() raise gen.Return(s_obj) raise gen.Return(False)
def instantiate(self, **extra_attrs): """ Create an instance of a SQLAlchemy model class corresponding to my OFX tag, with attributes given by my contained OFX elements. If an instance that matches the given primary key signature has already been given, return that instead of creating a new one. """ self.extra_attributes = extra_attrs # SECID needs to instantiate as SECINFO if self.tag == 'SECID': SubClass = models.SECINFO else: SubClass = getattr(models, self.tag) self._preflatten() self.attributes = self._flatten() self._postflatten() self.attributes.update(self.extra_attributes) self.extra_attributes = {} try: fingerprint = SubClass._fingerprint(**self.attributes) instance = DBSession.query(SubClass).filter_by(**fingerprint).one() except NoResultFound: instance = SubClass(**self.attributes) DBSession.add(instance) return instance
def write_jobs_to_database(jobs): """ Writes the retrieved jobs to the database :param jobs: list of all jobs :return: """ log = logging.getLogger(__name__) with transaction.manager: for (classname, classmembers) in jobs.items(): if len(classmembers) == 0: continue for element in classmembers: if 'error' in element: continue if 'JobID' not in element: log.debug('Row didn''t match specified criteria {0}'.format(element)) continue if not re.search('[0-9]*', element['JobID']): log.debug('Row didn''t match specified criteria {0}'.format(element)) continue dbrow = DBSession.query(Job).filter(Job.id == element['JobID']).all() json_str = jsonpickle.encode(element) if len(dbrow) == 0: j = Job(element['JobID'], json_str) DBSession.add(j) elif len(dbrow) == 1: dbrow[0].jobinfo = json_str else: log.error('More than one entry for jobid: {0}'.format(json_str)) DBSession.commit()
def __init__(self, stmtrs): """ Initialize with *STMTRS Element """ self.currency = stmtrs.find('CURDEF').text acctfrom = stmtrs.find(self._acctTag) self.account = acctfrom.instantiate() DBSession.add(self.account) self._init(stmtrs)
def make_admin(config_path): from intranet3.models import User user_login = sys.argv[-1] if len(sys.argv) < 4: print u"Provide user login" return session = DBSession() user = session.query(User).filter(User.email == user_login).first() if not user: print u"No such user: %s" % user_login return if 'admin' in user.groups: print u'Removing %s from group admin' % user.name groups = list(user.groups) groups.remove('admin') user.groups = groups else: print u'Adding %s to group admin' % user.name groups = list(user.groups) groups.append('admin') user.groups = groups session.add(user) transaction.commit()
def make_admin(config_path): from intranet3.models import User user_login = sys.argv[-1] if len(sys.argv) < 4: print u"Provide user login" return session = DBSession() user = session.query(User).filter(User.email==user_login).first() if not user: print u"No such user: %s" % user_login return if 'admin' in user.groups: print u'Removing %s from group admin' % user.name groups = list(user.groups) groups.remove('admin') user.groups = groups else: print u'Adding %s to group admin' % user.name groups = list(user.groups) groups.append('admin') user.groups = groups session.add(user) transaction.commit()
def eventAdd(request): eventName = request.POST['name'] eventType = request.POST['type'] eventDescription = request.POST['description'] image = request.POST.getall('file') for i in image: imageId = uuid.uuid1() imageUrl = str(imageId) open('/home/mohit/intern/hallwala/HallWala/hallwala/images/%d.jpg' % (imageId), 'wb').write(i.file.read()) for infile in glob.glob("/home/mohit/intern/hallwala/HallWala/hallwala/images/*.jpg"): im = Image.open(infile) # don't save if thumbnail already exists if infile[0:2] != "T_": # convert to thumbnail image im.thumbnail((128, 128), Image.ANTIALIAS) # prefix thumbnail file with T_ im.save("T_" + infile, "JPEG") newEvent = Event(eventName,eventType,eventDescription) DBSession.add(newEvent) DBSession.flush() event = newEvent.getJSON() return {'event' : event}
def crawl_plat_overview(first_letter): # url = "https://www.wdzj.com/dangan/pjs/" url = "https://www.wdzj.com/dangan/{first_letter}/".format( first_letter=first_letter ) print("crawl plat {}".format(first_letter)) response = requests.get(url, headers=HEADERS) if response.status_code != 200: print('crawl failed: code: {}, url: {}'.format(response.status_code, url)) return # raise CrawlFailed('crawl failed!') encode_response(response) html = etree.HTML(response.text) try: plat_name = html.xpath("//div[@class='title']/h1|h2")[0].text print("plat name: {}".format(plat_name)) # 注册资金(实缴资金) 银行存管 投标保障 # box = html.xpath("//div[@class='zzfwbox'] | //div[@class='bgbox-bt zzfwbox']") try: zczj = html.xpath("//div[@class='zzfwbox']/dl[1]/dd[1]//div[@class='r']")[0].text.strip().split() except IndexError: zczj = html.xpath("// div[ @class ='bgbox-bt zzfwbox'] // dl[1] / dd[1] // div[@ class ='r']")[0].text.strip().split() # // div[ @class ='bgbox-bt zzfwbox'] // dl[1] / dd[1] // div[@ class ='r'] if len(zczj) == 2: zczj_value, sjzj = zczj sjzj_value = sjzj.strip('()').split(':')[1] else: zczj_value = zczj sjzj_value = '-' try: yhcg_value = html.xpath("//div[@class='zzfwbox']/dl[1]/dd[2]//div[@class='r']")[0].text.strip() except IndexError: yhcg_value = html.xpath("//div[ @class ='bgbox-bt zzfwbox']//dl[1]/dd[2]//div[@class='r']")[0].text.strip() try: tbbz_value = html.xpath("//div[@class='zzfwbox']/dl[2]/dd[3]//div[@class='r']")[0].text.strip() except IndexError: tbbz_value = html.xpath("//div[ @class ='bgbox-bt zzfwbox']//dl[2]/dd[3]//div[@class='r']")[0].text.strip() plat_overview = dict( plat_name=plat_name, zhucezijin=zczj_value, shijiaozijin=sjzj_value, yinhangcunguan=yhcg_value, toubiaobaozhang=tbbz_value ) except AttributeError as ex: print('crawl failed: ex: {}, url: {}'.format(str(ex), url)) raise except IndexError as ex: print('crawl failed: ex: {}, url: {}'.format(str(ex), url)) raise new_plat_overview = PlatOverview(**plat_overview) session = DBSession() session.add(new_plat_overview) session.commit() session.close()
def save_data(self, data): session = DBSession() temp = data.copy() temp['timestamp'] = time() new_record = Data(**temp) session.add(new_record) session.commit() session.close()
def entity_type_put(request): dbsession = DBSession() entity_type = EntityType() entity_type.name = clean_matchdict_value(request, 'entity_type') entity_type.timestamp = get_timestamp() dbsession.add(entity_type) transaction.commit() return {'status': 'success'}
def signup(request): form = Form(request, schema=SignupSchema()) if form.validate(): user = form.bind(User()) DBSession.add(user) request.session.flash(u'Now you can sign in', 'success') return HTTPFound(location=request.route_url('signin')) return _response_dict(request, renderer=FormRenderer(form))
def group(request): dbsession = DBSession() name = clean_matchdict_value(request, 'group') group = Group() group.name = name group.timestamp = get_timestamp() dbsession.add(group) transaction.commit() return {'status': 'success'}
def create_translation(client_id, contents=list(), gist_type='Service'): gist = TranslationGist(client_id=client_id, type=gist_type) DBSession.add(gist) DBSession.flush() for content in contents: atom = TranslationAtom(client_id=client_id, content=content[0], locale_id=content[1], parent=gist) DBSession.add(atom) DBSession.flush() return gist
def create_pad(request): form = Form(request, schema=PadSchema()) if form.validate(): pad = form.bind(Pad()) pad.user = get_current_user(request) DBSession.add(pad) request.session.flash(u'Pad is successfully created', 'success') return HTTPFound(location=request.route_url('notes')) return _response_dict(request, renderer=FormRenderer(form), pad=False)
def test_add_post(self): from models import Post with transaction.manager: post = Post("Hallo World!", "Hallo body World!") DBSession.add(post) post = Post.by_id(1) self.assertEqual(post.id, 1) self.assertEqual("Hallo World!", post.title) self.assertEqual("Hallo body World!", post.body)
def write_job_archive_config(configuration): """ Writes a new job archive configuration to the database :param configuration: :return: """ with transaction.manager: DBSession.add(ArchiveUserConfiguration(jsonpickle.encode(configuration))) DBSession.commit()
def setUp(self): self.config = testing.setUp() from sqlalchemy import create_engine engine = create_engine('sqlite://') from models import Base, MyModel DBSession.configure(bind=engine) Base.metadata.create_all(engine) with transaction.manager: model = MyModel(name='one', value=55) DBSession.add(model)
def add_money(player_in, amount): in_player = Player.query.filter(Player.id == int(player_in)).first() movement_in = Movement(player=in_player, amount=amount, move_type=Movement.TYPES['IN']) DBSession.add(movement_in) in_player.update_balance(operation_type=Movement.TYPES['IN'], amount=amount) DBSession.flush() DBSession.commit()
def subtract_money(player_out, amount): out_player = Player.query.filter(Player.id == int(player_out)).first() movement_out = Movement(player=out_player, amount=amount, move_type=Movement.TYPES['OUT']) DBSession.add(movement_out) out_player.update_balance(operation_type=Movement.TYPES['OUT'], amount=amount) DBSession.flush() DBSession.commit()
def action_put(request): dbsession = DBSession() action = Action() action.name = clean_matchdict_value(request, 'action') action.description = clean_param_value(request, 'description') action.points = clean_param_value(request, 'points') action.timestamp = get_timestamp() dbsession.add(action) transaction.commit() return {'status': 'success'}
def create_user(username, password): logging.debug("creating user %s" % (username)) if find_user(username): raise RuntimeError("User %s already exists" % (username)) hashed_password = hash_password(password) u = User(username=username, password=hashed_password) DBSession.add(u) DBSession.flush() DBSession.expunge(u) return u
def make_session(user, sessionid=None, expires_in=3600): if not sessionid: sessionid = str(uuid.uuid4()) DBSession.query(Session).filter(Session.sessionid == sessionid).delete() logging.debug("making session for %s with sessionid %s" % (user.username, sessionid)) s = Session(user_id=user.id, sessionid=sessionid, expires=datetime.datetime.now() + datetime.timedelta(0, expires_in)) DBSession.add(s) DBSession.flush() DBSession.expunge(s) return s
def add_players_command(num_of_players): '''num_of_players: Numero de jogadores''' for p in range(int(num_of_players)): player_name = 'Jogador {}'.format(p + 1) player = Player(player_name=player_name) DBSession.add(player) player = Player(player_name='Banqueiro', balance=float(1000000.00)) DBSession.add(player) DBSession.flush() DBSession.commit()
def post(self, catid): session = DBSession() args = parser.parse_args() if 'name' not in args.keys(): abort(400, message="`name` missing") if len(args['name']) == 0: abort(400, message="`name` empty") category = session.query(models.Category).filter_by(id=catid).first() item = models.Item(category=category, name=args['name']) session.add(item) session.commit()
def addToLog(log_user,log_type,log_message): mySession = DBSession() newLog = Activitylog(log_user,log_type,log_message) try: transaction.begin() mySession.add(newLog) #Add the new log to MySQL transaction.commit() mySession.close() except: transaction.abort() mySession.close()
def create_user(request): data = json.loads(request.body) new_user = User( uid=data['username'] ) new_user.created_at = datetime.now() if DBSession.query(User).filter(User.name == new_user.name).count() > 0: raise HTTPUnauthorized() DBSession.add(new_user) DBSession.commit() return {"success": True}
def add(request): form = ReusableForm() if request.method == 'POST': name = request.params['name'] lname = request.params['lname'] age = request.params['age'] address = request.params['address'] DBSession.add( User(First_Name=name, Last_Name=lname, Age=age, Address=address)) transaction.commit() users = DBSession.query(User).all() return dict(form=form, results=users)
def add_record(self): """Verifies post form and saves record to database.""" form_json = self.request.json with transaction.manager: record = Record.from_dict(form_json) DBSession.add(record) # refresh record before commit to send creted Record in response DBSession.flush() DBSession.refresh(record) response_json = record.to_json() transaction.commit() return Response(status=201, json=response_json)
def main(argv=sys.argv): if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) with transaction.manager: admin = Admin(name='admin', pw='admin') DBSession.add(admin)
def init_test_db(): """Create testing database.""" engine = create_engine("sqlite://") Base.metadata.create_all(engine) DBSession.configure(bind=engine) with transaction.manager: model = Record(timestamp=datetime.utcnow(), bp_upper=120, bp_lower=70, notes="") DBSession.add(model) # pylint: disable=E1101 return DBSession
def create_config(env): from intranet3.models import * import transaction config = ApplicationConfig( office_ip='', google_user_email='', google_user_password='', holidays_spreadsheet='', hours_employee_project='', ) DBSession.add(config) transaction.commit()
def main(argv=sys.argv): print 'called' if len(argv) != 2: usage(argv) config_uri = argv[1] setup_logging(config_uri) settings = get_appsettings(config_uri) engine = engine_from_config(settings, 'sqlalchemy.') DBSession.configure(bind=engine) Base.metadata.create_all(engine) with transaction.manager: model = Users(first_name='Julien', last_name='waddle') DBSession.add(model)
def add(cls, name, url): ret = True session = DBSession() record = Action(name, url) session.add(record) try: session.commit() session.close() logging.info('add action success<name=%s, url=%s>' % (name, url)) except IntegrityError as error: logging.error(str(error)) ret = False return ret
def on_remove_admin_user(cls, company_id): """ 删除公司管理员用户 """ session = DBSession() com = session.query(cls).filter(cls.company_id == company_id).first() if com: com.admin_user_id = None try: session.add(com) session.commit() except Exception as why: message = "companies.on_remove_admin_user: {0}".format(why) logging.info(message) return -1 return 0
def add_servers(self): data = self.request.json with transaction.manager: server = Server(**data) DBSession.add(server) DBSession.flush() qs = DBSession.query(Server) qs.session.refresh(server) return { 'uid': server.uid, 'address': server.address, 'port': server.port, 'useSSL': server.useSSL }
def emit(self, record): trace = None exc = record.__dict__['exc_info'] if exc: trace = traceback.format_exc() log = Log( logger=record.__dict__['name'], level=record.__dict__['levelname'], trace=trace, msg=record.__dict__['msg'],) #print(log.__dict__) DBSession.add(log) transaction.commit()
def create_note(request): user = get_current_user(request) form = Form( request, schema=NoteSchema(), state=State(user=user)) if form.validate(): note = form.bind(Note()) note.user = user DBSession.add(note) request.session.flash(u'Note is successfully created', 'success') return HTTPFound(location=request.route_url('notes')) return _response_dict( request, renderer=FormRenderer(form) )
def settings(request): user = get_current_user(request) form = Form( request, ChangePasswordSchema(), state=State(user=user) ) if form.validate(): user.password = form.data['password'] DBSession.add(user) request.session.flash(u'Password was successfully changed', 'success') return HTTPFound(location=request.route_url('settings')) return _response_dict( request, renderer=FormRenderer(form) )
def vote_article(self, artId): data = { "userId": self.userId, "accessToken": self.accessToken, "artId": artId } r = requests.post(VOTE_ARTICLE_API, data, verify=False) result = r.json() vote = VoteRecord(artId=artId, result=result['res'], message=result['resMsg']) session = DBSession() session.add(vote) session.commit() session.close()
def on_set_admin_user(cls, company_id, user_id): """ 设置公司管理用户 """ session = DBSession() com = session.query(cls).filter(cls.company_id == company_id).first() if com: com.admin_user_id = user_id try: session.add(com) session.commit() except Exception as why: session.rollback() message = "companies.on_set_admin_user: {0}".format(why) logging.info(message) return -1 return 0