def _create_obj_from_cache(cls: Type[PKB], data: Any) -> Optional[PKB]:
if cls._valid_data(data):
obj = cls(**data)
make_transient_to_detached(obj)
obj = db.session.merge(obj, load=False)
return obj
return None
def fetch(self, path, params=None, **kw):
if not params:
params = list()
elif isinstance(params, dict):
params = list(params.items())
if self.account:
if self._should_refresh:
yield self._refresh_access()
if self.account.access_token:
params.append(
(self.OAUTH_TOKEN_PARAM, self.account.access_token))
provider = self.account.provider
else:
provider = Provider()
provider.id = self.PROVIDER_ID
make_transient_to_detached(provider)
provider = self.db.merge(provider, load=False)
params.append((self.OAUTH_CLIENT_KEY, provider.client_id))
url = '{}/{}'.format(self.API_BASE_URL, path.lstrip('/'))
uri = tornado.httputil.url_concat(url, params)
response = yield self.http_client.fetch(uri, **kw)
return response
def edit_req(id):
req = db_session.query(EnvironmentRequest).filter(
EnvironmentRequest.id == id).first()
if req:
form = EnvironmentRequestForm(formdata=request.form, obj=req)
if request.method == 'GET':
form.keep_data.data = req.keep_data
form.keep_ld.data = req.keep_ld
form.backup_db.data = req.backup_db
if request.method == 'POST' and form.validate():
_ = req.environment_id
_ = req.ods_id
_ = req.osb_id
_ = req.oss_id
_ = req.swp_number
db_session.expire(req, ['environment'])
db_session.expire(req, ['swp_number'])
db_session.expire(req, ['ods_integration'])
db_session.expire(req, ['osb_integration'])
db_session.expire(req, ['oss_integration'])
make_transient(req)
make_transient_to_detached(req)
inspect(req).committed_state.update(id=NEVER_SET)
inspect(req).committed_state.update(environment=NEVER_SET)
inspect(req).committed_state.update(swp_number=NEVER_SET)
inspect(req).committed_state.update(osb_integration=NEVER_SET)
inspect(req).committed_state.update(ods_integration=NEVER_SET)
inspect(req).committed_state.update(oss_integration=NEVER_SET)
req.environment = form.environment.data
req.requestedby = form.requestedby.data
req.swp_number = form.swp_number.data
req.zones = form.zones.data
req.version = str(form.swp_number.data).split()[0]
req.start_date = form.start_date.data
req.delivery_date = str(form.delivery_date.data)
req.backup_db = form.backup_db.data
req.keep_data = form.keep_data.data
req.keep_ld = form.keep_ld.data
req.osb_integration = form.osb_integration.data
req.ods_integration = form.ods_integration.data
req.oss_integration = form.oss_integration.data
req.source_uat_ref = str(form.source_uat_ref.data)
req.delivery_notification = form.delivery_notification.data
req.approval = False
current_session = db_session.object_session(req)
current_session.commit()
flash('Environment Request updated successfully!')
return redirect('/')
return render_template('edit_request.html', form=form)
else:
return 'Error loading #{id}'.format(id=id)
def _get_dummy_translation(self) -> 'Translation':
translation = getattr(self, '_dummy_translation', None)
if translation is None:
# Make a fake Translation object
translation = Translation(self.id, self.original_language, self.original_text)
make_transient_to_detached(translation)
setattr(self, '_dummy_translation', translation)
return translation
def test_secondary_as_join_complex_entity(self, registry):
"""integration test for #7868"""
Base = registry.generate_base()
class GrandParent(Base):
__tablename__ = "grandparent"
id = Column(Integer, primary_key=True)
grand_children = relationship("Child",
secondary="parent",
lazy="dynamic",
viewonly=True)
class Parent(Base):
__tablename__ = "parent"
id = Column(Integer, primary_key=True)
grand_parent_id = Column(Integer,
ForeignKey("grandparent.id"),
nullable=False)
class Child(Base):
__tablename__ = "child"
id = Column(Integer, primary_key=True)
type = Column(String)
parent_id = Column(Integer,
ForeignKey("parent.id"),
nullable=False)
__mapper_args__ = {
"polymorphic_on": type,
"polymorphic_identity": "unknown",
"with_polymorphic": "*",
}
class SubChild(Child):
__tablename__ = "subchild"
id = Column(Integer, ForeignKey("child.id"), primary_key=True)
__mapper_args__ = {
"polymorphic_identity": "sub",
}
gp = GrandParent(id=1)
make_transient_to_detached(gp)
sess = fixture_session()
sess.add(gp)
self.assert_compile(
gp.grand_children.filter_by(id=1),
"SELECT child.id AS child_id, child.type AS child_type, "
"child.parent_id AS child_parent_id, subchild.id AS subchild_id "
"FROM parent, child LEFT OUTER JOIN subchild "
"ON child.id = subchild.id "
"WHERE :param_1 = parent.grand_parent_id "
"AND parent.id = child.parent_id AND child.id = :id_1",
{"id_1": 1},
)
def save(self):
data = self.data
# remove the button
data.pop('submit', None)
forum = Forum(**data)
# flush SQLA info from created instance so that it can be merged
make_transient(forum)
make_transient_to_detached(forum)
return forum.save()
def save(self):
data = self.data
# remove the button
data.pop('submit', None)
forum = Forum(**data)
# flush SQLA info from created instance so that it can be merged
make_transient(forum)
make_transient_to_detached(forum)
return forum.save()
def save(self):
data = self.data
# delete submit and csrf_token from data
data.pop('submit', None)
data.pop('csrf_token', None)
forum = Forum(**data)
# flush SQLA info from created instance so that it can be merged
make_transient(forum)
make_transient_to_detached(forum)
return forum.save()
def save(self):
data = self.data
# delete submit and csrf_token from data
data.pop('submit', None)
data.pop('csrf_token', None)
forum = Forum(**data)
# flush SQLA info from created instance so that it can be merged
make_transient(forum)
make_transient_to_detached(forum)
return forum.save()
def load_user_from_request(request):
if 'user_id' not in session:
return None
if 'corporate_id' not in session:
u = User(id=int(session['user_id']))
make_transient_to_detached(u)
db.session.add(u)
return u
if 'corporate_as_user' in request.headers:
from models import Corporate
if Corporate.can_access_user(
session['corporate_id'],
request.headers.get('corporate_as_user')):
u = User(id=int(request.headers.get('corporate_as_user')))
make_transient_to_detached(u)
db.session.add(u)
return u
u = User(id=int(session['user_id']))
make_transient_to_detached(u)
db.session.add(u)
return u
