def class_(self, id_, ws=None):
'''
Retrieve the :py:class:`orm.KBClass` instance with the given
id from the knowledge base SQL DB.
:type id_: string
:param id_: KB class identifier
:type ws: :py:class:`orm.Workspace`
:param ws: KB workspace object used to filter classes (default: None)
:rtype: :py:class:`orm.KBClass`
:returns: a KB class
:raises: :py:exc:`errors.NotFound` if a class with the given
ID does not exist in the knowledge base (or in the
specified workspace, when provided)
'''
cls = self.orm.cache_get(id_, self.session)
if cls is not None:
if not self._check_class_ws_access(cls, ws):
raise kb_exc.NotFound('class.id == %s' % (id_, ))
return cls
query = self.session.query(
self.orm.KBClass).filter(self.orm.KBClass.id == id_)
if (ws is not None):
query = self._add_ws_filter(query, ws)
try:
return query.one()
except sa_exc.NoResultFound:
raise kb_exc.NotFound('class.id == %s' % (id_, ))
def allowed_period(self, event):
"""
Returns list of allowed periods for events.
:param str event: Type of event. Currently supported: auto_report
:return List periods: List of periods.
**Example**::
{
"periods": [
{'period_id': 'week', 'localized_name': {'ru': 'еженедельно', 'en': 'weekly'}},
{'period_id': 'month', 'localized_name': {'ru': 'ежемесячно', 'en': 'monthly'}},
{'period_id': 'quarter', 'localized_name': {'ru': 'ежеквартально', 'en': 'quarterly'}}
]
}
"""
event_config = conf.event.event.get(event)
if not event_config:
raise errors.NotFound()
periods = event_config["periods"]
def copy_except(d, exclude):
return {k: v for k, v in d.items() if k not in exclude}
return {
"periods": [{
"period_id":
period,
"localized_name":
copy_except(conf.event.period[period], "cron")
} for period in periods]
}
def traverseSkin(ctx, ob, ns, nm, qname, default=NOT_GIVEN):
skin = ctx.policy.getSkin(nm)
if skin is not None:
return ctx.clone(skin=skin, rootURL=ctx.rootURL+'/'+qname)
if default is NOT_GIVEN:
raise errors.NotFound(ctx, qname, ctx.current)
return default
def destroy(self, silent=False):
path = self.getMorsecodePath()
resp = self._send('DELETE', path)
if not silent:
if resp.status == 404:
raise errors.NotFound("Collection not found at %s" % path)
elif resp.status != 204:
raise errors.SharingError("%s (HTTP status %d)" %
(resp.message, resp.status),
details="Received [%s]" % resp.body)
def tasks(event, context):
"""
taskListに紐づくtask一覧の取得
"""
logger.info(event)
logger.info(context)
try:
logger.info(event)
if not event['pathParameters']:
raise errors.BadRequest('Bad request')
task_list_id = event['pathParameters']['id']
# taskListが存在するか
try:
task_list = TaskListModel.get(task_list_id)
except TaskListModel.DoesNotExist as e:
logger.exception(e)
raise errors.NotFound('The taskList does not exist')
# tasksの取得
try:
tasks = TaskModel.tasks_gsi_taskListId.query(
task_list_id,
TaskModel.deleteFlag == False
)
except QueryError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps(
{
'statusCode': 200,
'taskList': task_list_id,
'tasks': [dict(task) for task in tasks]
}
)
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
def traverseName(self,name,default=NOT_GIVEN):
ns, nm = parseName(name)
if ns:
handler = self.policy.ns_handler(ns,None)
if handler is None:
raise errors.NotFound(self,name,self.current)
return handler(self, self.current, ns, nm, name, default)
if name=='..':
return self.parentContext()
elif not name or name=='.':
return self
else:
return IWebTraversable(self.current).traverseTo(name,self,default)
def traverseAttr(ctx, ob, ns, name, qname, default=NOT_GIVEN):
perm = ctx.policy.permissionFor(ob,name)
if perm is not None:
# We have explicit permissions defined, so allow access after check
loc = getattr(ob, name, NOT_FOUND)
if loc is not NOT_FOUND:
ctx.requireAccess(qname, ob, name, perm)
return ctx.childContext(qname,loc)
if default is NOT_GIVEN:
raise errors.NotFound(ctx,qname,ob)
return default
def users(event, context):
"""
taskに所属するuser一覧を返す
"""
try:
logger.info(event)
if not event['pathParameters']:
raise errors.BadRequest('Bad request')
task_id = event['pathParameters']['id']
# taskの取得
try:
task = TaskModel.get(task_id)
except TaskModel.DoesNotExist:
raise errors.NotFound('The task does not exist')
if not task.userIds:
task.userIds = []
# usersの取得
try:
users = task.get_users()
except UserModel.DoesNotExist as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps(
{
'statusCode': 200,
'taskId': task_id,
'users': [dict(user) for user in users]
}
)
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
def object(self, id_, ws=None):
'''
Retrieve the Python object mapped to the KB object with the
given id.
:type id_: string
:param id_: the identifier of the required KB object
:type ws: :py:class:`orm.Workspace`
:param ws: KB workspace object used to filter KB objects according to
the visibility of their class (default: None)
:rtype: :py:class:`orm.KBObject`
:returns: a Python object (mapped to the KB session)
:raises: :py:exc:`errors.NotFound` if an object with the given
ID does not exist in the knowledge base (or in the
specified workspace, when provided)
'''
# Retrieve the class id of the required object (if any)...
try:
o = self.session.query(self.schema.object_t.c['class']).filter(
self.schema.object_t.c.id == id_).one()
except sa_exc.NoResultFound:
raise kb_exc.NotFound('object.id == %s' % (id_, ))
cls_id = o[0]
# ...and then retrieve and ORMap its class (after checking the cache)
try:
c = self.python_class(cls_id)
except kb_exc.NotFound:
raise kb_exc.NotFound('object.id == %s' % (id_, ))
# We can now retrieve the actual object
obj = self.session.query(
self.orm.KBObject).filter(self.orm.KBObject.id == id_).one()
return obj
def traverseItem(ctx, ob, ns, name, qname, default=NOT_GIVEN):
gi = getattr(ob,'__getitem__',None)
if gi is not None:
try:
loc = ob[name]
except (KeyError,IndexError,TypeError):
pass
else:
ctx.requireAccess(qname, loc)
return ctx.childContext(qname,loc)
if default is NOT_GIVEN:
raise errors.NotFound(ctx,qname,ob)
return default
def done_undone(event, context):
try:
logger.info(event)
if not event['pathParameters']:
raise errors.BadRequest('Bad request')
task_id = event['pathParameters']['id']
# done or undone で ture or false
if re.match('.*/done$', event['resource']):
flag = True
else:
flag = False
# taskを取得
try:
task = TaskModel.get(task_id)
except TaskModel.DoesNotExist:
raise errors.NotFound('The task does not exist')
# taskを更新
try:
task.status_update(flag)
except UpdateError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps({
'statusCode': 200,
'task': dict(task)
})
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
def getraw(cls, obj_or_id, nothrow=False, cachekey=None):
obj = obj_or_id
if not issubclass(obj.__class__, ModelBase):
if issubclass(obj_or_id.__class__, ndb.Key):
obj = cls.get_by_id(obj_or_id.id())
else:
obj = None
if cachekey is not None:
obj = memcache.get(cachekey)
if obj is None:
obj = cls.get_by_id(obj_or_id)
if obj is None:
if nothrow: return None
else:
raise errors.NotFound("Object not found for ID: " +
str(obj_or_id))
return obj
async def request(http, endpoint, obj=None):
'''Used to request to the Discord API'''
if http == 'POST':
resp = await SESSION.post(API_BASE + endpoint, json=obj, headers=HEADERS)
elif http == 'DELETE':
resp = await SESSION.delete(API_BASE + endpoint, json=obj, headers=HEADERS)
if resp.status == 204:
return
obj = await resp.json()
print(resp)
if 300 > resp.status >= 200:
return #ok
elif resp.status == 403:
raise errors.Forbidden(resp, obj)
elif resp.status == 404:
raise errors.NotFound(resp, obj)
elif resp.status == 429:
raise errors.RateLimit(resp, obj)
def delete(event, context):
"""
delteFlagをfalseに変更
"""
try:
logger.info(event)
if not event['pathParameters']:
raise errors.BadRequest('Bad request')
task_id = event['pathParameters']['id']
# taskの取得
try:
task = TaskModel.get(task_id)
except TaskModel.DoesNotExist:
raise errors.NotFound('The task does not exist')
# taskの削除
try:
task.logic_delete()
except UpdateError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps({'statusCode': 200})
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
def workspace(self, id_):
'''
Retrieve the Workspace object with the given id.
An exception will be raised if the given id doesn't refer to
any stored workspace.
:type id_: int
:param id_: the identifier of the required Workspace
:rtype: :py:class:`orm.Workspace`
:returns: a workspace object
:raises: :py:exc:`errors.NotFound` if a workspace with the
given ID does not exist in the knowledge base
'''
try:
return self.session.query(
self.orm.Workspace).filter(self.orm.Workspace.id == id_).one()
except sa_exc.NoResultFound:
raise kb_exc.NotFound('workspace.id == %d' % (id_, ))
def user(self, id_):
'''
Retrieve the user object with the given identifier.
:type id_: string
:param id_: the identifier of the required user
:rtype: :py:class:`orm.User`
:returns: the requested user object
:raises: :py:exc:`errors.NotFound` if a user with the given
ID does not exist in the knowledge base
'''
query = self.session.query(
self.orm.User).filter(self.orm.User.id == id_)
try:
user = query.one()
except sa_exc.NoResultFound:
raise kb_exc.NotFound('user.id == %s' % (id_, ))
return user
def traverseLocationId(ctx, ob, ns, name, qname, default=NOT_GIVEN):
key = LOCATION_ID(name)
orig_ctx = ctx
while ctx is not None:
cob = ctx.current
try:
gcd = cob._getConfigData
except AttributeError:
pass
else:
result = gcd(cob,key)
if result is not NOT_FOUND:
return result.traverse(ctx)
ctx = ctx.previous
if default is not NOT_GIVEN:
return default
raise errors.NotFound(orig_ctx,qname,ob)
def update(event, context):
"""
taskをupdate
nameおよびdescription
"""
try:
logger.info(event)
if not (event['body'] and event['pathParameters']):
raise errors.BadRequest('Bad request')
data = json.loads(event['body'])
# dataから不要なattributeを削除
data = {k: v for k, v in data.items() if k in ['name', 'description']}
if not data:
raise errors.BadRequest('Bad request')
task_id = event['pathParameters']['id']
# taskの取得
try:
task = TaskModel.get(task_id)
except TaskModel.DoesNotExist:
raise errors.NotFound('The task does not exist')
if 'name' in data:
task.name = data['name']
if 'description' in data:
task.description = data['description']
if not task.userIds:
task.userIds = []
try:
task.save()
except InvalidNameError as e:
logger.exception(e)
raise errors.BadRequest(str(e.with_traceback(sys.exc_info()[2])))
except InvalidDescriptionError as e:
logger.exception(e)
raise errors.BadRequest(str(e.with_traceback(sys.exc_info()[2])))
except PutError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps({
'statusCode': 200,
'task': dict(task)
})
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
def add_remove(event, context):
"""
userをtaskに追加
"""
try:
logger.info(event)
if not (event['pathParameters'] and event['body']):
raise errors.BadRequest('Bad request')
data = json.loads(event['body'])
# dataから不要なattributeを削除
data = { k: v for k, v in data.items() if k == 'userIds' }
if not data:
raise errors.BadRequest('Bad request')
else:
if type(data['userIds']) != list:
raise errors.BadRequest('"userIds" attribute must be array')
task_id = event['pathParameters']['id']
user_ids = data['userIds']
# taskの取得
try:
task = TaskModel.get(task_id)
except TaskModel.DoesNotExist:
raise errors.NotFound('The task does not exist')
# add or remove
if re.match('.*/add$', event['resource']):
flag = True
else:
flag = False
# taskのuserIdsを更新
try:
task.user_ids_update(user_ids, flag)
except InvalidUserError as e:
logger.exception(e)
raise errors.NotFound(str(e.with_traceback(sys.exc_info()[2])))
except UpdateError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
task = TaskModel.get(task_id)
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps(
{
'statusCode': 200,
'task': dict(task)
}
)
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
except Exception as e:
logger.exception(e)
return {
'statusCode': 500,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps(
{
'statusCode': 500,
'errorMessage': 'Internal server error'
}
)
}
def publish(self,
collection,
displayName=None,
activity=None,
filters=None,
overwrite=False,
options=None):
from ics import ICSSerializer
from translator import SharingTranslator
from eimml import EIMMLSerializer
rv = self.itsView
# Stamp the collection
if not pim.has_stamp(collection, SharedItem):
SharedItem(collection).add()
conduit = webdav_conduit.WebDAVRecordSetConduit(itsView=rv,
account=self)
# Interrogate the server associated with the account
location = self.getLocation()
if not location.endswith("/"):
location += "/"
handle = conduit._getServerHandle()
resource = handle.getResource(location)
logger.debug('Examining %s ...', location.encode('utf8', 'replace'))
exists = handle.blockUntil(resource.exists)
if not exists:
logger.debug("...doesn't exist")
raise errors.NotFound(
_(u"%(location)s does not exist.") % {'location': location})
isCalendar = handle.blockUntil(resource.isCalendar)
logger.debug('...Calendar? %s', isCalendar)
isCollection = handle.blockUntil(resource.isCollection)
logger.debug('...Collection? %s', isCollection)
response = handle.blockUntil(resource.options)
dav = response.headers.getHeader('DAV')
logger.debug('...DAV: %s', dav)
allowed = response.headers.getHeader('Allow')
logger.debug('...Allow: %s', allowed)
supportsTickets = handle.blockUntil(resource.supportsTickets)
logger.debug('...Tickets?: %s', supportsTickets)
conduit.delete(True) # Clean up the temporary conduit
# Prepare the share
share = None
try:
if isCalendar:
# We've been handed a calendar directly. Just publish directly
# into this calendar collection rather than making a new one.
# Create a CalDAV share with empty sharename, doing a GET and
# PUT
share = Share(itsView=rv, contents=collection)
conduit = caldav_conduit.CalDAVRecordSetConduit(
itsParent=share,
account=self,
shareName=u"",
translator=SharingTranslator,
serializer=ICSSerializer)
share.conduit = conduit
if filters:
conduit.filters = filters
share.displayName = displayName or collection.displayName
alias = 'main'
try:
SharedItem(collection).shares.append(share, alias)
except ValueError:
# There is already a 'main' share for this collection
SharedItem(collection).shares.append(share)
share.sync(activity=activity)
else:
# the collection should be published
# determine a share name
existing = utility.getExistingResources(self)
displayName = displayName or collection.displayName
shareName = displayName
alias = 'main'
# See if there are any non-ascii characters, if so, just use
# UUID
try:
shareName.encode('ascii')
pattern = re.compile('[^A-Za-z0-9]')
shareName = re.sub(pattern, "_", shareName)
except UnicodeEncodeError:
shareName = unicode(collection.itsUUID)
# Append .ics extension of publishing a monolithic .ics file
if options.get('ics', False):
shareName = shareName + ".ics"
shareName = self._uniqueName(shareName, existing)
if ('calendar-access' in dav or 'MKCALENDAR' in allowed):
# We're speaking to a CalDAV server
share = Share(itsView=rv, contents=collection)
conduit = caldav_conduit.CalDAVRecordSetConduit(
itsParent=share,
account=self,
shareName=shareName,
translator=SharingTranslator,
serializer=ICSSerializer)
share.conduit = conduit
if filters:
conduit.filters = filters
share.displayName = displayName or collection.displayName
try:
SharedItem(collection).shares.append(share, alias)
except ValueError:
# There is already a 'main' share for this collection
SharedItem(collection).shares.append(share)
if share.exists():
raise errors.SharingError(
_(u"Collection already exists on server."))
share.create()
# bug 8128, this setDisplayName shouldn't be required, but
# cosmo isn't accepting setting displayname in MKCALENDAR
share.conduit.setDisplayName(displayName)
share.put(activity=activity)
# tickets after putting
if supportsTickets:
share.conduit.createTickets()
elif dav is not None:
# We're speaking to a WebDAV server
# Use monolithic ics if options['ics'], else use EIMML
share = Share(itsView=rv, contents=collection)
if options.get('ics', False):
# ICS
conduit = webdav_conduit.WebDAVMonolithicRecordSetConduit(
itsParent=share,
shareName=shareName,
account=self,
translator=SharingTranslator,
serializer=ICSSerializer)
else:
conduit = webdav_conduit.WebDAVRecordSetConduit(
itsParent=share,
shareName=shareName,
account=self,
translator=SharingTranslator,
serializer=EIMMLSerializer)
share.conduit = conduit
if filters:
conduit.filters = filters
try:
SharedItem(collection).shares.append(share, alias)
except ValueError:
# There is already a 'main' share for this collection
SharedItem(collection).shares.append(share)
if share.exists():
raise errors.SharingError(
_(u"Collection already exists on server."))
share.create()
share.put(activity=activity)
if supportsTickets:
share.conduit.createTickets()
except (errors.SharingError, zanshin.error.Error,
M2Crypto.SSL.Checker.WrongHost, CertificateVerificationError,
twisted.internet.error.TimeoutError), e:
# Clean up share objects
try:
share.delete(True)
except:
pass # ignore stale shares
# Note: the following "raise e" line used to just read "raise".
# However, if the try block immediately preceeding this comment
# raises an exception, the "raise" following this comment was
# raising that *new* exception instead of the original exception
# that got us here, "e".
raise e
def create(event, context):
"""
taskを作成
name, descriptionは必須
userIdsは任意
"""
try:
logger.info(event)
if not (event['body']):
raise errors.BadRequest('Bad request')
body = json.loads(event['body'])
validate_attributes(body)
if not 'userIds' in body:
body['userIds'] = []
task = TaskModel(id=str(uuid.uuid1()),
name=body['name'],
description=body['description'],
taskListId=body['taskListId'],
userIds=body['userIds'])
# taskの保存
try:
task.save()
except InvalidNameError as e:
logger.exception(e)
raise errors.BadRequest(str(e.with_traceback(sys.exc_info()[2])))
except InvalidDescriptionError as e:
logger.exception(e)
raise errors.BadRequest(str(e.with_traceback(sys.exc_info()[2])))
except InvalidTaskListError as e:
logger.exception(e)
if str(e.with_traceback(
sys.exc_info()[2])) == 'The taskList does not exist':
raise errors.NotFound(str(e.with_traceback(sys.exc_info()[2])))
else:
raise errors.BadRequest(
str(e.with_traceback(sys.exc_info()[2])))
except InvalidUserError as e:
logger.exception(e)
if str(e.with_traceback(sys.exc_info()[2])
) == 'The userIds contains a invalid userId does not exist':
raise errors.NotFound(str(e.with_traceback(sys.exc_info()[2])))
else:
raise errors.BadRequest(
str(e.with_traceback(sys.exc_info()[2])))
except PutError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps({
'statusCode': 200,
'task': dict(task)
})
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
def tasks_taskLists(event, context):
"""
userが属するtasksおよびtaskListsを返す
"""
try:
logger.info(event)
if not event['pathParameters']:
raise errors.BadRequest('Bad request')
user_id = event['pathParameters']['id']
# userを取得
try:
user = UserModel.get(user_id)
except UserModel.DoesNotExist:
raise errors.NotFound('The user does not exist')
# userの参加するtasksを取得
try:
tasks = user.get_tasks()
except ScanError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
# taskListIdでグループ化
tasks_group = {}
for task in tasks:
if task.taskListId in tasks_group:
tasks_group[task.taskListId].append(task)
else:
tasks_group[task.taskListId] = [task]
# taskListsを取得
task_lists = []
for task_list_id in tasks_group.keys():
try:
task_list = TaskListModel.get(task_list_id)
except TaskListModel.DoesNotExist as e:
logger.exception(e)
continue
except GetError as e:
logger.exception(e)
task_lists.append(task_list)
# 結果の整形
task_lists = [dict(task_list) for task_list in task_lists]
for task_list in task_lists:
task_list['tasks'] = [dict(task) for task in tasks_group[task_list['id']]]
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps(
{
'statusCode': 200,
'userId': user_id,
'taskLists': task_lists
}
)
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
}
raise errors.NotAllowed(message)
if err.status == twisted.web.http.CONFLICT:
# this happens if you try to create a collection within a
# nonexistent collection
(host, port, sharePath, username, password, useSSL) = \
self._getSettings(withPassword=False)
message = _(
u"The directory '%(directoryName)s' could not be found on %(server)s.\nPlease verify the Path field in your %(accountType)s account."
) % {
'directoryName': sharePath,
'server': host,
'accountType': 'WebDAV'
}
raise errors.NotFound(message)
if err.status == twisted.web.http.FORBIDDEN:
# the server doesn't allow the creation of a collection here
message = _(
u"Server doesn't allow publishing collections to %(url)s."
) % {
'url': url
}
raise errors.IllegalOperation(message)
if err.status == twisted.web.http.PRECONDITION_FAILED:
message = _(
u"The contents of %(url)s were modified unexpectedly on the server while trying to publish."
) % {
'url': url
def traverseResource(ctx, ob, ns, nm, qname, default=NOT_GIVEN):
if qname==ctx.policy.resourcePrefix:
return ctx.childContext(qname, ctx.skin)
if default is NOT_GIVEN:
raise errors.NotFound(ctx, qname, ctx.current)
return default
def delete(event, context):
"""
tasklistのdeleteFlagをfalseに変更
また関連するtaskのdeleteFlagもfalseに変更
"""
try:
logger.info(event)
if not event['pathParameters']:
raise errors.BadRequest('Bad request')
task_list_id = event['pathParameters']['id']
# tasklistをget
try:
task_list = TaskListModel.get(task_list_id)
except TaskListModel.DoesNotExist as e:
logger.exception(e)
raise errors.NotFound('The taskList does not exist')
# tasklistを論理削除
try:
task_list.logic_delete()
except UpdateError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
# 関連するtasksを論理削除
try:
tasks = TaskModel.tasks_gsi_taskListId.query(
task_list_id, TaskModel.deleteFlag == False)
print(tasks)
except QueryError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
for task in tasks:
try:
task.logic_delete()
except UpdateError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps({'statusCode': 200})
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
def delete(event, context):
"""
userを削除
また参加しているtaskのuserIdsから自身を取り除く
"""
try:
logger.info(event)
if not event['pathParameters']:
raise errors.BadRequest('Bad request')
user_id = event['pathParameters']['id']
# user_idがauthorized_userのものか検証
if user_id != event['requestContext']['authorizer']['authorizedUserId']:
raise errors.ForbiddenError('Access denied')
# userの取得
try:
user = UserModel.get(user_id)
except UserModel.DoesNotExist:
raise errors.NotFound('The user does not exist')
# userが参加するtaskの取得
try:
tasks = user.get_tasks()
except ScanError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
# userが参加するtaskのuserIdsからuser_idを削除
for task in tasks:
try:
task.update([TaskModel.userIds.delete([user_id])])
except UpdateError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
# userを削除
try:
user.logic_delete()
except UpdateError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps({'statusCode': 200})
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
def traverseView(ctx, ob, ns, name, qname, default):
if default is NOT_GIVEN:
raise errors.NotFound(ctx,qname,ob)
return default
def update(event, context):
"""
userの更新
updateでの更新対象はemail, name, phoneNumberのみ
"""
try:
logger.info(event)
if not (event['body'] and event['pathParameters']):
raise errors.BadRequest('Bad request')
data = json.loads(event['body'])
# dataから不要なattributeを削除
data = {
k: v
for k, v in data.items() if k in ['name', 'email', 'phoneNumber']
}
if not data:
raise errors.BadRequest('Bad request')
user_id = event['pathParameters']['id']
# user_idがauthorized_userのものか検証
if user_id != event['requestContext']['authorizer']['authorizedUserId']:
raise errors.ForbiddenError('Access denied')
# userが存在するか
try:
user = UserModel.get(user_id)
except UserModel.DoesNotExist as e:
raise errors.NotFound('This user does not exist')
if 'name' in data:
user.name = data['name']
if 'email' in data:
user.email = data['email']
if 'phoneNumber' in data:
user.phoneNumber = data['phoneNumber']
# userの更新
try:
user.save()
except InvalidNameError as e:
logger.exception(e)
raise errors.BadRequest(str(e.with_traceback(sys.exc_info()[2])))
except InvalidPhoneNumberError as e:
logger.exception(e)
raise errors.BadRequest(str(e.with_traceback(sys.exc_info()[2])))
except InvalidEmailError as e:
logger.exception(e)
if str(e.with_traceback(
sys.exc_info()[2])) == 'This email has been registered':
raise errors.UnprocessableEntity(
str(e.with_traceback(sys.exc_info()[2])))
else:
raise errors.BadRequest(
str(e.with_traceback(sys.exc_info()[2])))
except PutError as e:
logger.exception(e)
raise errors.InternalError('Internal server error')
return {
'statusCode': 200,
'headers': {
'Access-Control-Allow-Origin': '*',
'Content-Type': 'application/json'
},
'body': json.dumps({
'statusCode': 200,
'user': dict(user)
})
}
except errors.BadRequest as e:
logger.exception(e)
return build_response(e, 400)
except errors.ForbiddenError as e:
logger.exception(e)
return build_response(e, 403)
except errors.NotFound as e:
logger.exception(e)
return build_response(e, 404)
except errors.UnprocessableEntity as e:
logger.exception(e)
return build_response(e, 409)
except errors.InternalError as e:
logger.exception(e)
return build_response(e, 500)
