def __delitem__(self, name):
name = unicode(name)
try:
principal = DBSession.query(self.factory).filter(self.factory.name == name).one()
DBSession.delete(principal)
except NoResultFound:
raise KeyError(name)
def edit_job(request, user, resume_id):
t = request.POST["experience"]
if resume_id != int(request.POST['resume_id']):
#TODO raise error
pass
if t == "new":
resume = DBSession.query(resources.Resume).filter_by(user=user, id=resume_id).first()
job_schema = JobSchema()
cstruct = job_schema.deserialize(request.POST)
job_obj = resources.Job()
cstruct2job(cstruct, job_obj)
resume.jobs.append(job_obj)
#flush to get the new id
DBSession.flush()
widget = JobsWidget(resume_id, resume.jobs)
json_string = json.dumps({'__result':0})
return Response(json_string+"$"+widget.render())
elif t == "modify":
job_schema = JobSchema()
cstruct = job_schema.deserialize(request.POST)
DBSession.query(resources.Job).filter_by(resume_id=resume_id, id=int(request.POST['id'])).\
update(cstruct, synchronize_session=False)
resume = DBSession.query(resources.Resume).filter_by(user=user, id=resume_id).first()
widget = JobsWidget(resume_id, resume.jobs)
json_string = json.dumps({'__result':0})
return Response(json_string+"$"+widget.render())
elif t == "delete":
job = DBSession.query(resources.Job).filter_by(resume_id=resume_id, id=int(request.POST['id'])).first()
oid = job.id
DBSession.delete(job)
return Response(json.dumps({'__result':0,'id':oid}))
return Response(json.dumps({'__result':1}))
def __delitem__(self, name: str) -> None:
name = name
try:
principal = self._principal_by_name(name)
DBSession.delete(principal)
except NoResultFound:
raise KeyError(name)
def __delitem__(self, name):
name = unicode(name)
try:
principal = self._principal_by_name(name)
DBSession.delete(principal)
except NoResultFound:
raise KeyError(name)
def __delitem__(self, name: str) -> None:
name = name
try:
principal = self._principal_by_name(name)
DBSession.delete(principal)
except NoResultFound:
raise KeyError(name)
def resume_view(context, request):
jquery.need()
user = get_user(request)
if not user:
raise UserNotFount()
if "add_resume" in request.POST:
title = request.POST['resume_title']
if title.strip() != '':
resume = resources.Resume(title=title, user=user)
#DBSession.add(resume)
#DBSession.flush()
#return HTTPFound(location='/resume_edit2/%d' % resume.id)
elif "operator" in request.POST:
ops = request.POST['operator']
print ops
if ops == 'del_resume':
id = request.POST['operator_id']
resume = DBSession.query(resources.Resume).get(id)
if resume and resume.user_id == user.id:
DBSession.delete(resume)
return wrap_user(request,{
'resumes':user.resumes,
'pcs':user.position_items,
})
def edit_education(request, user, resume_id):
t = request.POST["education"]
if resume_id != int(request.POST['resume_id']):
#TODO raise error
pass
if t == 'new':
resume = DBSession.query(resources.Resume).filter_by(user=user, id=resume_id).first()
edu_schema = Education()
cstruct = edu_schema.deserialize(request.POST)
edu_obj = resources.Education()
cstruct2edu(cstruct, edu_obj)
resume.educations.append(edu_obj)
#flush to get the new id
DBSession.flush()
widget = EducationsWidget(resume_id, resume.educations)
json_string = json.dumps({'__result':0})
return Response(json_string+"$"+widget.render())
elif t == 'modify':
edu_schema = Education()
cstruct = edu_schema.deserialize(request.POST)
DBSession.query(resources.Education).filter_by(resume_id=resume_id, id=int(request.POST['id'])).\
update(cstruct, synchronize_session=False)
resume = DBSession.query(resources.Resume).filter_by(user=user, id=resume_id).first()
widget = EducationsWidget(resume_id, resume.educations)
json_string = json.dumps({'__result':0})
return Response(json_string+"$"+widget.render())
elif t == 'delete':
edu = DBSession.query(resources.Education).filter_by(resume_id=resume_id, id=int(request.POST['id'])).first()
oid = edu.id
DBSession.delete(edu)
return Response(json.dumps({'__result':0,'id':oid}))
# raise error, not exists this operation
return Response(json.dumps({'__result':1}))
def edit_project(request, user, resume_id):
t = request.POST["project"]
if resume_id != int(request.POST['resume_id']):
return Response(json.dumps({'__result':1}))
#TODO use try/except
if t == "new":
resume = DBSession.query(resources.Resume).filter_by(user=user, id=resume_id).first()
obj = resources.ProjectInfo()
cstruct2project(request.POST, obj)
resume.projects.append(obj)
#flush to get the new id
DBSession.flush()
widget = ProjectWidget(resume_id, resume.projects)
json_string = json.dumps({'__result':0})
return Response(json_string+"$"+widget.render())
elif t == "modify":
cstruct = {}
cstruct2project(request.POST, cstruct)
DBSession.query(resources.ProjectInfo).filter_by(resume_id=resume_id, id=int(request.POST['id'])).\
update(cstruct, synchronize_session=False)
resume = DBSession.query(resources.Resume).filter_by(user=user, id=resume_id).first()
widget = ProjectWidget(resume_id, resume.projects)
json_string = json.dumps({'__result':0})
return Response(json_string+"$"+widget.render())
elif t == "delete":
project = DBSession.query(resources.ProjectInfo).filter_by(resume_id=resume_id, id=int(request.POST['id'])).first()
oid = project.id
DBSession.delete(project)
return Response(json.dumps({'__result':0,'id':oid}))
return Response(json.dumps({'__result':1}))
def __delitem__(self, name):
name = unicode(name)
try:
principal = self._principal_by_name(name)
DBSession.delete(principal)
except NoResultFound:
raise KeyError(name)
def __delitem__(self, name):
name = unicode(name)
try:
principal = DBSession.query(
self.factory).filter(self.factory.name == name).one()
DBSession.delete(principal)
except NoResultFound:
raise KeyError(name)
def admin_home_banners(context, request):
jquery.need()
user = get_user(request)
if not user:
return HTTPFound(location="/login?came_from=%s" % request.url)
if 'method' in request.POST:
# mt stands for meetup-type
try:
method = request.POST['method'] # del-banner
if method == 'del-banner':
mt_id = int(request.POST['banner-id'])
to_op_mt = DBSession.query(Banner).filter_by(id=mt_id).first()
banner_id = request.POST.get('banner-id', None)
if not banner_id :
return RetDict(errcode=RetDict.ERR_CODE_WRONG_PARAM)
try:
banner_id = int(banner_id)
except ValueError,e:
return RetDict(errcode=RetDict.ERR_CODE_WRONG_PARAM)
banner = DBSession.query(Banner).filter_by(id=banner_id).first()
if not banner:
return RetDict(errcode=RetDict.ERR_CODE_WRONG_PARAM)
DBSession.delete(banner)
msg = u"成功删除BANNER %d" % banner_id
request.session.flash(msg, 'success')
return RetDict(retval=msg)
except Exception,ex:
err_msg = "错误：%s" % ex
request.session.flash(err_msg, 'danger')
return RetDict(errmsg=err_msg)
def tnc_populate(db_session):
from transaction import commit
# remove content created by kotti default populator
from kotti import DBSession
from kotti.resources import get_root
DBSession.delete(get_root())
for populate in tnc_settings()['kotti.populators']:
populate()
commit()
def _populator():
from kotti import DBSession
from kotti.resources import Document
from kotti.populate import populate
populate()
for doc in DBSession.query(Document)[1:]:
DBSession.delete(doc)
transaction.commit()
def _populator():
from kotti import DBSession
from kotti.resources import Document
from kotti.populate import populate
populate()
for doc in DBSession.query(Document)[1:]:
DBSession.delete(doc)
transaction.commit()
def __delitem__(self, name):
log.debug( sys._getframe().f_code.co_name )
if self.behave_as_Principals:
del self.stub_factory[name]
else:
name = unicode(name)
log.debug(name)
account = DBSession.query(
self.factory).filter(self.factory.email == name).one()
DBSession.delete(account)
def test_sqlalchemy_events(self, db_session, events):
from kotti import events
from kotti import DBSession
from kotti.resources import get_root
from kotti.resources import Content
insert_events = []
def insert(event):
insert_events.append(event)
update_events = []
def update(event):
update_events.append(event)
delete_events = []
def delete(event):
delete_events.append(event)
after_delete_events = []
def after_delete(event):
after_delete_events.append(event)
def lengths():
return (len(insert_events), len(update_events),
len(delete_events), len(after_delete_events))
lis = events.objectevent_listeners
lis[(events.ObjectInsert, None)].append(insert)
lis[(events.ObjectUpdate, None)].append(update)
lis[(events.ObjectDelete, None)].append(delete)
lis[(events.ObjectAfterDelete, None)].append(after_delete)
root = get_root()
child = root[u'child'] = Content()
DBSession.flush()
assert lengths() == (1, 0, 0, 0)
assert insert_events[0].object == child
child.title = u"Bar"
DBSession.flush()
assert lengths() == (1, 1, 0, 0)
assert update_events[0].object == child
DBSession.delete(child)
DBSession.flush()
assert lengths() == (1, 1, 1, 1)
assert delete_events[0].object == child
assert after_delete_events[0].object == child
def admin_meetup_particinpate_view(context, request):
id = request.matchdict['id']
meetup = DBSession.query(Act).get(id)
if meetup is None:
return Response(u"不存在的活动")
if 'delete' in request.POST:
# 取消选中的人参加活动
todel = request.POST.getall('participate_check')
principals = get_principals()
for mid in todel:
# print 'mid:%s, len mid:%d'% ( mid, len(mid) )
to_cancel_user = principals.get(int(mid))
# if to_cancel_user in meetup.parts:
# meetup.parts.remove(to_cancel_user)
enrolled_user = DBSession.query(Participate).filter_by(user_id=int(mid), act_id=meetup.id).first()
if enrolled_user is not None :
# print meetup
DBSession.delete(enrolled_user)
request.session.flash(u"已取消选中人报名活动!" , 'success')
DBSession.flush()
elif 'approve_meetup_auth' in request.POST:
# 添加活动认识
toauth = request.POST.getall('participate_check')
for mid in toauth:
to_auth_user = DBSession.query(MbaUser).filter_by(id=mid).first()
print to_auth_user
if to_auth_user is not None:
to_auth_user.auth_meetup = True
request.session.flash(u"已成功给‘%s’添加活动认证" % to_auth_user.real_name , 'success')
DBSession.flush()
jquery.need()
return {'meetup': meetup}
def view_meetup_types(context, request):
jquery.need()
user = get_user(request)
if not user:
return HTTPFound(location="/login?came_from=%s" % request.url)
err_msg = u""
if 'method' in request.POST:
# mt stands for meetup-type
try:
method = request.POST['method'] # add-mt, del-mt, mdf-mt
if method == 'add-mt':
new_type_title = request.POST['mt-title']
DBSession.add( MeetupType(title=new_type_title))
request.session.flash((u"成功添加：'%s'" % new_type_title), 'success')
else:
mt_id = int(request.POST['mt-id'])
to_op_mt = DBSession.query(MeetupType).filter_by(id=mt_id).first()
mt_title = request.POST['mt-title']
if not to_op_mt:
raise Exception(u"错误的参数")
if method == 'del-mt':
DBSession.delete(to_op_mt)
request.session.flash(_(u"成功删除'%s'" % mt_title), 'success')
elif method == 'mdf-mt':
to_op_mt.title = mt_title
request.session.flash(_(u"修改成功!"), 'success')
else:
err_msg = u"错误的方法"
request.session.flash(_(u"错误的参数"))
except Exception,ex:
err_msg = "%s" % ex
request.session.flash(_(u"错误：'%s'" % err_msg), 'danger')
finally:
def test_sqlalchemy_events(self):
from kotti import events
from kotti import DBSession
from kotti.resources import get_root
from kotti.resources import Content
insert_events = []
def insert(event):
insert_events.append(event)
update_events = []
def update(event):
update_events.append(event)
delete_events = []
def delete(event):
delete_events.append(event)
lis = events.objectevent_listeners
lis[(events.ObjectInsert, None)].append(insert)
lis[(events.ObjectUpdate, None)].append(update)
lis[(events.ObjectDelete, None)].append(delete)
root = get_root()
child = root[u'child'] = Content()
DBSession.flush()
self.assertEqual(
(len(insert_events), len(update_events), len(delete_events)),
(1, 0, 0))
self.assertEqual(insert_events[0].object, child)
child.title = u"Bar"
DBSession.flush()
self.assertEqual(
(len(insert_events), len(update_events), len(delete_events)),
(1, 1, 0))
self.assertEqual(update_events[0].object, child)
DBSession.delete(child)
DBSession.flush()
self.assertEqual(
(len(insert_events), len(update_events), len(delete_events)),
(1, 1, 1))
self.assertEqual(delete_events[0].object, child)
def delete_result(self):
questions = self.context.children
if self.request.has_permission("delete", self.context):
username = self.request.params.get(
"username",
self.request.user.name if self.request.user else ""
)
else:
username = self.request.user.name if self.request.user else ""
user_survey = UserSurvey.query.filter(
UserSurvey.username == username,
UserSurvey.survey_id == self.context.id
).order_by(UserSurvey.date_completed.desc()).first()
DBSession.delete(user_survey)
return httpexc.HTTPFound(
location=self.context.path
)
def test_sqlalchemy_events(self):
from kotti import events
from kotti import DBSession
from kotti.resources import get_root
from kotti.resources import Content
insert_events = []
def insert(event):
insert_events.append(event)
update_events = []
def update(event):
update_events.append(event)
delete_events = []
def delete(event):
delete_events.append(event)
lis = events.objectevent_listeners
lis[(events.ObjectInsert, None)].append(insert)
lis[(events.ObjectUpdate, None)].append(update)
lis[(events.ObjectDelete, None)].append(delete)
root = get_root()
child = root[u'child'] = Content()
DBSession.flush()
self.assertEqual(
(len(insert_events), len(update_events), len(delete_events)),
(1, 0, 0))
self.assertEqual(insert_events[0].object, child)
child.title = u"Bar"
DBSession.flush()
self.assertEqual(
(len(insert_events), len(update_events), len(delete_events)),
(1, 1, 0))
self.assertEqual(update_events[0].object, child)
DBSession.delete(child)
DBSession.flush()
self.assertEqual(
(len(insert_events), len(update_events), len(delete_events)),
(1, 1, 1))
self.assertEqual(delete_events[0].object, child)
def i_authentications(request):
user = get_user(request)
if not user :
return HTTPFound('/login?came_from=%s' % request.url)
jquery.need()
# bootstrap.need()
if 'auth_type' in request.POST:
auth_type = request.POST.get('auth_type')
if auth_type == 'auth_expert':
user.auth_expert = user.AUTH_STATUS_REQ_FOR_AUTH
reason = request.POST.get("apply-reason","")
oldreason = DBSession.query(ExpertAuthReq).filter_by(user_id=user.id).all()
for r in oldreason:
DBSession.delete(r)
req = ExpertAuthReq(user_id=user.id, reason=reason)
DBSession.add(req)
elif auth_type == 'auth_info':
user.auth_info = user.AUTH_STATUS_REQ_FOR_AUTH
authentications = [
( 'auth_info', u'资料认证', u'管理员确认后即可获得该认证', user.auth_info ),
( 'auth_meetup', u'活动认证', u'成功参加一次志友汇活动即可获得该认证', user.auth_meetup ),
( 'auth_friend', u'校友认证', u'与10名校友成功交换名片即可获得该认证', user.auth_friend ),
( 'auth_honesty', u'诚信认证', u'资料认证、活动认证、校友认证任意两项或以上通过即可获得该认证', user.auth_honesty ),
( 'auth_expert', u'专家认证', u'管理员确认的专家可获得该认证', user.auth_expert )
]
return {'authentications': authentications}
def __delitem__(self, key):
node = self[unicode(key)]
self.children.remove(node)
DBSession.delete(node)
def __delitem__(self, key):
node = self[unicode(key)]
self.children.remove(node)
DBSession.delete(node)
def __delitem__(self, key: str) -> None:
node = self[key]
self.children.remove(node)
DBSession.delete(node)
def __delitem__(self, key: str) -> None:
node = self[key]
self.children.remove(node)
DBSession.delete(node)
def __delitem__(self, key):
"""See zope.app.interfaces.annotation.IAnnotations"""
if not key in self.obj._annotations:
raise KeyError(key)
anno = self.obj._annotations.pop(key)
DBSession.delete(anno)
