from flask import abort from flask_restful import Resource, fields, marshal_with from api.models import Agrosemens class JsonItem(fields.Raw): def format(self, value): return value seed_fields = { 'variety' : fields.String(), 'category' : fields.String(), 'href' : fields.String(), 'taxon' : fields.String(), 'description' : JsonItem() } class SeedApi(Resource): @marshal_with(seed_fields) def get(self,page=1): seeds = Agrosemens.objects.paginate(page,page + 10).items if not seeds: abort(404) return seeds
from models.user import User from models.cable import Cable from models.device import Device from models.interface import Interface from models.equipment import Equipment from auth.permissions import admin_or_owner_required, admin_required from .forms.device import CreateOrUpdateForm, SearchForm from .helper.base_views import * from .helper.pagination import pagination_marshal_with, build_order_by from .helper.response_fields import device_base_fields, equipment_base_fields, device_template_fields bp = Blueprint('device', __name__, url_prefix='/appliance') device_list_fields = { **device_base_fields, 'parentEquipmentName': fields.String(attribute='parent_equipment.name'), } device_fields = { **device_base_fields, 'parentEquipment': fields.Nested(equipment_base_fields, attribute='parent_equipment'), } @bp.route('/device/<oid:oid>', methods=['GET']) @login_required @base_view(Device, device_fields) def get_device(): pass
# @author: Small_stars # @mailbox: [email protected] # @site: # @software: PyCharm # @file: views.py # @time: 2021/3/9 16:51 from flask_restful import Resource, fields, marshal from flask import request import json from .models import User from ..db import db from ..utils import authority, custom_status_code user_fields = { 'email': fields.String(), 'username': fields.String(attribute='username'), 'authority': fields.String(attribute='uauthority'), } user_items = { 'email': User.email, 'username': User.username, 'authority': User.uauthority, } # user class GetList(Resource): def get(self): data = User.query.filter(User.uauthority > authority['guest']).all()
def test_attribute(self): obj = {"bar": 3} field = fields.String(attribute="bar") self.assertEquals(field.output("foo", obj), "3")
#!/usr/bin/env python # encoding: utf-8 """ @author: zhanghe @software: PyCharm @file: enum_items.py @time: 2018-08-23 15:55 """ from __future__ import unicode_literals from flask_restful import fields fields_item_enum_items = { 'id': fields.Integer(attribute='ID'), 'id_enum': fields.Integer(attribute='idEnum'), 'code': fields.String(attribute='Code'), 'name': fields.String(attribute='Name'), 'is_deleted': fields.Boolean(attribute='IsDeleted'), } fields_item_enum_items_cn = { '主键': fields.Integer(attribute='ID'), '枚举id': fields.Integer(attribute='idEnum'), '编码': fields.String(attribute='Code'), '名称': fields.String(attribute='Name'), '删除': fields.Boolean(attribute='IsDeleted'), }
def test_string_no_value(self): field = fields.String() self.assertEquals(None, field.output("bar", Foo()))
def test_basic_dictionary(self): obj = {"foo": 3} field = fields.String() self.assertEquals(field.output("foo", obj), "3")
from flask_restful import fields song_fields = { 'id': fields.String(attribute='_id'), 'artist': fields.String, 'title': fields.String, 'difficulty': fields.Float, 'level': fields.Integer, 'released': fields.String, }
'slo_id': fields.String, 'slo_description': fields.String, 'performance_indicators': fields.List(fields.Nested(pi_data_fields)) } slo_data_extra_fields = { 'total_assessments': fields.Integer } class_data_fields = { 'crn': fields.String, 'course_number': fields.String, 'course_name': fields.String, 'course_type': fields.String, 'semester': fields.String, 'course_year': fields.String(attribute=lambda x: x['course_year'].year), # extract only the Year as a string 'total_students': fields.Integer, 'assigned_slos': fields.List(fields.Nested(slo_data_fields)), 'completion': fields.Boolean } # Input: List of AssessmentModel objects, SLO object # Output: List of PI data in the format specified by pi_data_fields def generateSummaryData(listOfAssessments, SLOModel): summaryData = [] #container relevant_assessments = [x for x in listOfAssessments if x.slo_id == SLOModel.slo_id] # Filters assessments to just be the ones for this specific SLO relevant_scores = [] #container that will hold all scores # For each relevant assessment, add it's scores to the relevant_scores container for a in relevant_assessments: relevant_scores = relevant_scores + a.scores
from models import db from flask_restful import fields, marshal user_fields = { 'email': fields.String, 'firstName': fields.String(attribute='first_name'), 'lastName': fields.String(attribute='last_name'), 'picture': fields.String(attribute='profile_picture_url'), 'token': fields.String(attribute='user_secret') } class User(db.Model): __tablename__ = 'users' email = db.Column(db.String, primary_key=True) google_id = db.Column(db.String) first_name = db.Column(db.String) last_name = db.Column(db.String) user_secret = db.Column(db.String) profile_picture_url = db.Column(db.String) contacts = db.relationship('UserContact') location_history = db.relationship('UserLocation', order_by='desc(UserLocation.time)') tracking_info = db.relationship('TrackingInfo', uselist=False) def __init__(self, gid, email, first, last, picture, secret): self.google_id = gid self.email = email self.first_name = first self.last_name = last self.profile_picture_url = picture
import os from datetime import datetime from logging import getLogger from time import sleep from flask import request from flask_restful import Resource, reqparse, fields, marshal_with, marshal from kafka.errors import NoBrokersAvailable from mongoengine import Q import dateutil.parser from database.data import Notification import json notification_fields = { 'id': fields.String(), 'user_id': fields.String(), 'timestamp': fields.DateTime(dt_format='iso8601'), 'creation_timestamp': fields.DateTime(dt_format='iso8601'), 'modified_timestamp': fields.DateTime(dt_format='iso8601'), 'type': fields.String(), 'data': fields.Raw(), 'is_active': fields.Boolean(), 'notes': fields.String() } parser = reqparse.RequestParser() parser.add_argument('id', type=str) parser.add_argument('user_id', type=str) parser.add_argument('timestamp', type=lambda x: dateutil.parser.parse(x)) parser.add_argument('creation_timestamp', type=lambda x: dateutil.parser.parse(x)) parser.add_argument('modified_timestamp',
#!/usr/bin/env python # encoding: utf-8 """ @author: zhanghe @software: PyCharm @file: sale_order.py @time: 2018-07-24 16:59 """ from __future__ import unicode_literals from flask_restful import fields fields_item_sale_order = { 'id': fields.Integer(attribute='ID'), 'code': fields.String(attribute='code'), 'customer_id': fields.Integer(attribute='idcustomer'), # 客户id 'settle_id': fields.Integer(attribute='idsettlecustomer'), # 结算客户id 'address': fields.String(attribute='address'), 'linkman': fields.String(attribute='linkMan'), 'amount': fields.Float(attribute='amount'), 'amount_tax': fields.Float(attribute='taxAmount'), 'contact_phone': fields.String(attribute='contactPhone'), 'delivery_mode': fields.Integer(attribute='deliveryMode'), 'receive_type': fields.Integer(attribute='reciveType'), 'maker_id': fields.Integer(attribute='makerid'), 'maker': fields.String(attribute='maker'), 'create_time': fields.DateTime(dt_format=b'iso8601', attribute='createdtime'), 'update_time': fields.DateTime(dt_format=b'iso8601', attribute='updated'), }
parse_base.add_argument('action', type=str, required=True, help='请确认请求参数') parse_base.add_argument('password', type=str, required=True, help='请输入密码') parse_register = parse_base.copy() parse_register.add_argument('phone', type=str, required=True, help='请输入手机号码') parse_register.add_argument('email', type=str, required=True, help='请输入邮箱') parse_login = parse_base.copy() parse_login.add_argument("email", type=str, required=True, help='请输入手机号码') parse_login.add_argument("phone", type=str, required=True, help='请输入手机号码') parse_login.add_argument("code", type=str, required=True, help='请输入验证码') boke_user_fields = { 'u_email': fields.String, 'u_phone': fields.String, 'password': fields.String(attribute="_password"), } single_boke_user_fields = { 'status': fields.Integer, 'msg': fields.String, 'data': fields.Nested(boke_user_fields) } class BokeUsersResource(Resource): def get(self): phone = request.args.get("phone") resp = send_verify_code(phone) result = resp.json()
from flask_restful import fields mac_fields = { 'mac_address': fields.String(), 'user': fields.String(attribute='user.name') } user_fields = { 'name': fields.String, 'mac_addresses': fields.List(fields.Nested(mac_fields)), } user_list_fields = { fields.List(fields.Nested(user_fields)), } logs_fields = { 'time': fields.String, 'mac_address': fields.String, 'user': fields.String, 'ip': fields.String, }
def test_string_with_lambda(self): field = fields.String(attribute=lambda x: x.hey) self.assertEquals("3", field.output("foo", Foo()))
from flask import request from flask_restful import fields, marshal_with from opencve.api.alerts import alert_fields from opencve.api.base import BaseResource from opencve.api.cves import cves_fields from opencve.api.fields import DatetimeField from opencve.controllers.alerts import AlertController from opencve.controllers.reports import ReportController from opencve.models.users import User report_list_fields = { "id": fields.String(attribute="public_link"), "created_at": DatetimeField(), "details": fields.Raw(attribute="details"), } report_fields = dict( report_list_fields, **{"alerts": fields.List(fields.Nested(alert_fields))} ) class ReportListResource(BaseResource): @marshal_with(report_list_fields) def get(self): user = User.query.filter_by( username=request.authorization.get("username") ).first() return ReportController.list_items({**request.args, "user_id": user.id})
def test_string(self): field = fields.String() self.assertEquals("3", field.output("hey", Foo()))
'ml_model_name': fields.String, 'condition_refcode': fields.String, 'condition_name': fields.String, 'name': fields.String, 'description': fields.String, 'creator': fields.Nested(user_fields), 'created_at': fields.DateTime, 'updated_at': fields.DateTime, 'feature_set_id': fields.Integer, 'environment': fields.Nested(environment_fields), 'feature_set': fields.Nested(feature_set_fields) } feature_fields = { 'resource': fields.String, 'key': fields.String(attribute='parameter_name'), 'value': fields.String, 'name': fields.String, 'resource_val_path': fields.String(attribute='output_value_path') } class MLModelListResource(Resource): def __init__(self): super(MLModelListResource, self).__init__() self.parser = reqparse.RequestParser() self.parser.add_argument('environment_id', type=int, required=True, help='No environment id provided', location='json') self.parser.add_argument('name', type=str, required=False, help='No model name provided', location='json') self.parser.add_argument('description', type=str, required=False, location='json') self.parser.add_argument('feature_set_id', type=int, required=False, location='json') self.parser.add_argument('condition_refcode', type=str, required=False, location='json')
def test_string_none(self): field = fields.String() self.assertEquals(None, field.output("empty", {'empty': None}))
from RestfulApp.ext import db from RestfulApp.models import Teacher req1 = RequestParser() # 创建RequestParser请求解析器对象 req1.add_argument("name", type=str, required=True, help="必须传递name参数,并且为字符串类型!") req1.add_argument("age", type=int, help="年龄必须是整数", dest="t_age") # 前端使用age传参,后端使用t_age接收参数 req1.add_argument("salary", type=float, required=True, help="必须传递salary参数,并且为小数!") # 老师实例化对象定制输出模板 teacher_instance = { "teacher_id": fields.Integer(attribute="id"), "teacher_name": fields.String(attribute="name"), "teacher_age": fields.Integer(attribute="age"), "teacher_salary": fields.Float(attribute="salary"), } teacher_output = { "code": fields.String, "msg": fields.String, "teacher": fields.Nested(teacher_instance, attribute="new_teacher") } class TeacherResource(Resource): @marshal_with(teacher_output) def post(self): print("111111111111111")
def test_no_attribute(self): obj = {"bar": 3} field = fields.String() self.assertEquals(field.output("foo", obj), None)
table_reader_fields = { 'reader': fields.Nested(user_fields, attribute='user'), 'read_count': fields.Integer } column_stat_fields = { 'stat_type': fields.String, 'stat_val': fields.String, # Optional 'start_epoch': fields.Integer, # Optional 'end_epoch': fields.Integer, # Optional } column_fields = { 'name': fields.String, 'description': fields.String, 'type': fields.String(attribute='col_type'), 'sort_order': fields.Integer, # Can be an empty list 'stats': fields.List(fields.Nested(column_stat_fields)) } watermark_fields = { 'watermark_type': fields.String, 'partition_key': fields.String, 'partition_value': fields.String, 'create_time': fields.String } tag_fields = {'tag_type': fields.String, 'tag_name': fields.String} table_writer_fields = {
import json from flask import jsonify, Blueprint, abort, g, make_response from flask_restful import Resource, Api, reqparse, inputs, fields, url_for, marshal, marshal_with import models from auth import auth review_fields = { 'id': fields.Integer, 'for_course': fields.String, 'rating': fields.Integer, 'comment': fields.String(default=''), 'created_at': fields.DateTime } def review_or_404(review_id): try: review = models.Review.get(models.Review.id == review_id) except models.Review.DoesNotExist: abort(404, message='Review {} does not exist'.format(review_id)) else: return review def add_course(review): review.for_course = url_for('resources.courses.course', id=review.course.id) return review
from flask_restful import Resource, request, fields, marshal from app.db import db, LectureModel from app.resource import message, admin_required lecture_field = { 'id': fields.Integer, 'titulo': fields.String, 'conteudo': fields.String, 'ministrante': fields.String(attribute=lambda obj: obj.speaker.nome) } remove_lecture_field = { 'id': fields.Integer, 'titulo': fields.String, 'conteudo': fields.String } load_title_field = { 'id': fields.Integer, 'titulo': fields.String, 'ministrante': fields.String(attribute=lambda obj: obj.speaker.nome) } class LectureAdminResource(Resource): @admin_required def get(self, lecture_id=None): loadtitle = int(request.args.get('loadtitle', 0)) if int(loadtitle) == 1: lectures = LectureModel.query.order_by(LectureModel.id).all() lectures = [marshal(l, load_title_field) for l in lectures] return {'values': lectures}, 200 if lecture_id:
from flask_restful import Resource, fields, marshal_with from wanghublog.controllers.flask_restful import fields as jf_fields from wanghublog.models import db, User, Post, Tag from wanghublog.controllers.flask_restful import parsers from flask import abort from datetime import datetime # String format output of tag nested_tag_fields = {'id': fields.String(), 'name': fields.String()} # String format output of post post_fields = { 'author': fields.String(attribute=str(lambda x: x.user.username)), 'title': fields.String(), 'text': jf_fields.HTMLField(), 'tags': fields.List(fields.Nested(nested_tag_fields)), 'publish_date': fields.DateTime(dt_format='iso8601') } class PostApi(Resource): """Restful API of posts resource.""" @marshal_with(post_fields) def get(self, post_id=None): """Can be execute when receive HTTP Method `GET`. Will be return the Dict object as post_fields. """ if post_id: post = Post.query.filter_by(id=post_id).first() if not post: abort(404)
MODEL = Messages ROUTE = "/messages" END_POINT = "messages" #NESTED SCHEMA FIELDS #OUTPUT SCHEMA output_fields = { 'id': fields.Integer, 'receiver_user_id': fields.Integer, 'is_read': fields.Boolean, 'name': fields.String(attribute=lambda x: x.user_data.name if x.user_data is not None else '') } #API METHODS FOR SINGLE ENTITY class MessagesResource(Resource): def __init__(self): self.route = ROUTE + '/<int:id>' self.end_point = END_POINT pass @marshal_with(output_fields) def get(self, id): entity = session.query(MODEL).filter(MODEL.id == id).first() if not entity: abort(404, message=ENTITY_NAME + " {} doesn't exist".format(id))
from ...models.tv import Channel from ._utils import marshal_nullable_with from ._utils import DateTimeWithUtc log = logging.getLogger(__name__) # output _channel_fields = { 'ID': fields.String, 'name': fields.String, 'name_short': fields.String, 'ip_string': fields.String, 'channel_status': fields.String(attribute='channel_status.status'), 'meta_teletext_page': fields.String, 'meta_country_code': fields.String, 'meta_language_code3': fields.String, 'meta_timezone': fields.String, 'meta_video_source': fields.String, } _channel_status_fields = { 'channel_ID': fields.String, 'status': fields.String, 'error': fields.String, 'ts': DateTimeWithUtc, }
def test_string_with_attribute(self): field = fields.String(attribute="hey") self.assertEquals("3", field.output("foo", Foo()))
class DepositionType(object): """Deposition type. A base class for the deposition types to ensure certain properties are defined on each type. A deposition type is just a BibWorkflow with a couple of extra methods. To customize rendering behavior of the workflow for a given deposition type you can override the render_error(), render_step() and render_completed() methods. """ workflow = [] """ Workflow definition """ name = "" """ Display name for this deposition type """ name_plural = "" """ Plural version of display name for this deposition type """ enabled = False """ Determines if type is enabled - TODO: REMOVE""" default = False """ Determines if type is the default - warnings are issed if conflicts exsists TODO: remove """ deletable = False """ Determine if a deposition is deletable after submission. """ editable = False """ Determine if a deposition is editable after submission. """ stopable = False """ Determine if a deposition workflow can be stopped (i.e. discard changes). """ group = None """ Name of group to include this type in. """ api = False """ Determines if API is enabled for this type (requires workflow to be compatible with the API). """ draft_definitions = {'_default': None} """ Dictionary of all drafts for this deposition type """ marshal_file_fields = dict( checksum=fields.String, filename=fields.String(attribute='name'), id=fields.String(attribute='uuid'), filesize=fields.String(attribute='size'), ) """ REST API structure of a file """ marshal_draft_fields = dict( metadata=fields.Raw(attribute='values'), completed=fields.Boolean, id=fields.String, ) """ REST API structure of a draft """ marshal_deposition_fields = dict( id=fields.Integer, title=fields.String, created=UTCISODateTime, modified=UTCISODateTime, owner=fields.Integer(attribute='user_id'), state=fields.String, submitted=fields.Boolean, files=fields.Nested(marshal_file_fields), drafts=fields.Nested(marshal_draft_fields, attribute='drafts_list'), ) """ REST API structure of a deposition """ @classmethod def default_draft_id(cls, deposition): """Default draft id.""" return '_default' @classmethod def render_error(cls, dummy_deposition): """ Render a page when deposition had an workflow error. Method can be overwritten by subclasses to provide custom user interface. """ flash('%(name)s deposition has returned error.' % {'name': cls.name}, 'error') return redirect(url_for('.index')) @classmethod def render_step(self, deposition): """ Render a page for a given deposition step. Method can be overwritten by subclasses to provide custom user interface. """ ctx = deposition.get_render_context() if ctx: return render_template(**ctx) else: return render_template('deposit/error.html', **dict( depostion=deposition, deposition_type=( None if deposition.type.is_default() else deposition.type.get_identifier() ), uuid=deposition.id, my_depositions=Deposition.get_depositions( current_user, type=deposition.type ), )) @classmethod def render_completed(cls, dummy_deposition): """Render page when deposition was successfully completed. (i.e workflow just finished successfully). Method can be overwritten by subclasses to provide custom user interface. """ flash('%(name)s was successfully finished.' % {'name': cls.name}, 'success') return redirect(url_for('.index')) @classmethod def render_final(cls, deposition): """Render page when deposition was *already* successfully completed. (i.e a finished workflow is being executed a second time). This allows you render e.g. a preview of the record. The distinction between render_completed and render_final is primarily useful for the REST API (see api_final and api_completed) Method can be overwritten by subclasses to provide custom user interface. """ return cls.render_completed(deposition) @classmethod def api_completed(cls, deposition): """Workflow just finished processing. Workflow just finished processing so return an 202 Accepted, since usually further background processing may happen. """ return deposition.marshal(), 202 @classmethod def api_final(cls, deposition): """Workflow already finished. And the user tries to re-execute the workflow, so send a 400 Bad Request back. """ return dict( message="Deposition workflow already completed", status=400, ), 400 @classmethod def api_step(cls, deposition): """Workflow was halted during processing. The workflow task that halted processing is expected to provide a response to send back to the client. The default response code is 500 Internal Server Error. A workflow task is expected to use Deposition.set_render_context() with a dictionary which is returned to the client. Set the key 'status', to change the status code, e.g.:: d.set_render_context(dict(status=400, message="Bad request")) If no response is provided by the workflow task, it is regarded as an internal server error. """ ctx = deposition.get_render_context() if ctx: return ctx.get('response', {}), ctx.get('status', 500) return cls.api_error(deposition) @classmethod def api_error(cls, deposition): """Api error.""" return dict(message='Internal Server Error', status=500), 500 @classmethod def api_action(cls, deposition, action_id): """Api action.""" if action_id == 'run': return deposition.run_workflow(headless=True) elif action_id == 'reinitialize': deposition.reinitialize_workflow() return deposition.run_workflow(headless=True) elif action_id == 'stop': deposition.stop_workflow() return deposition.run_workflow(headless=True) raise InvalidApiAction(action_id) @classmethod def api_metadata_schema(cls, draft_id): """Get the input validation schema for this draft_id. Allows you to override API defaults. """ from wtforms.fields.core import FieldList, FormField if draft_id in cls.draft_definitions: schema = dict() formclass = cls.draft_definitions[draft_id] for fname, fclass in formclass()._fields.items(): if isinstance(fclass, FieldList): schema[fname] = dict(type='list') elif isinstance(fclass, FormField): schema[fname] = dict(type='dict') else: schema[fname] = dict(type='any') return dict(type='dict', schema=schema) return None @classmethod def marshal_deposition(cls, obj): """Generate a JSON representation for REST API of a Deposition.""" return marshal(obj, cls.marshal_deposition_fields) @classmethod def marshal_draft(cls, obj): """Generate a JSON representation for REST API of a DepositionDraft.""" return marshal(obj, cls.marshal_draft_fields) @classmethod def marshal_file(cls, obj): """Generate a JSON representation for REST API of a DepositionFile.""" return marshal(obj, cls.marshal_file_fields) @classmethod def authorize(cls, deposition, action): """Authorize.""" if action == 'create': return True # Any authenticated user elif action == 'delete': if deposition.has_sip(): return deposition.type.deletable return True elif action == 'reinitialize': return deposition.type.editable elif action == 'stop': return deposition.type.stopable elif action in ['add_file', 'remove_file', 'sort_files']: # Don't allow to add/remove/sort files after first submission return not deposition.has_sip() elif action in ['add_draft', ]: # Allow adding drafts when inprogress (independent of SIP exists # or not). return deposition.state == 'inprogress' else: return not deposition.has_sip() @classmethod def authorize_draft(cls, deposition, draft, action): """Authorize draft.""" if action == 'update': # If deposition allows adding a draft, then allow editing the # draft. return cls.authorize(deposition, 'add_draft') return cls.authorize(deposition, 'add_draft') @classmethod def authorize_file(cls, deposition, deposition_file, action): """Authorize file.""" return cls.authorize(deposition, 'add_file') @classmethod def get_identifier(cls): """Get type identifier (identical to workflow name).""" return cls.__name__ @classmethod def is_enabled(cls): """Check if workflow is enabled.""" # Wrapping in a method to eventually allow enabling/disabling # via configuration. return cls.enabled @classmethod def is_default(cls): """Check if workflow is the default.""" # Wrapping in a method to eventually allow configuration # via configuration. return cls.default @classmethod def run_workflow(cls, deposition): """Run workflow for the given BibWorkflowObject. Usually not invoked directly, but instead indirectly through Deposition.run_workflow(). """ if deposition.workflow_object.workflow is None or ( deposition.workflow_object.version == ObjectVersion.INITIAL and deposition.workflow_object.workflow.status == WorkflowStatus.NEW): return deposition.workflow_object.start_workflow( workflow_name=cls.get_identifier(), id_user=deposition.workflow_object.id_user, module_name="webdeposit" ) else: return deposition.workflow_object.continue_workflow( start_point="restart_task", ) @classmethod def reinitialize_workflow(cls, deposition): """Reinitialize workflow.""" # Only reinitialize if really needed (i.e. you can only # reinitialize a fully completed workflow). wo = deposition.workflow_object if wo.version == ObjectVersion.COMPLETED and \ wo.workflow.status == WorkflowStatus.COMPLETED: wo.version = ObjectVersion.INITIAL wo.workflow.status = WorkflowStatus.NEW # Clear deposition drafts deposition.drafts = {} @classmethod def stop_workflow(cls, deposition): """Stop workflow.""" # Only stop workflow if really needed wo = deposition.workflow_object if wo.version != ObjectVersion.COMPLETED and \ wo.workflow.status != WorkflowStatus.COMPLETED: # Only workflows which has been fully completed once before # can be stopped if deposition.has_sip(): wo.version = ObjectVersion.COMPLETED wo.workflow.status = WorkflowStatus.COMPLETED # Clear all drafts deposition.drafts = {} # Set title - FIXME: find better way to set title sip = deposition.get_latest_sip(sealed=True) title = sip.metadata.get('title', 'Untitled') deposition.title = title @classmethod def all(cls): """Get a dictionary of deposition types.""" from .registry import deposit_types return deposit_types.mapping() @classmethod def get(cls, identifier): """Get.""" try: return cls.all()[identifier] except KeyError: raise InvalidDepositionType(identifier) @classmethod def keys(cls): """Get a list of deposition type names.""" return cls.all().keys() @classmethod def values(cls): """Get a list of deposition type names.""" return cls.all().values() @classmethod def get_default(cls): """Get a list of deposition type names.""" from .registry import deposit_default_type return deposit_default_type.get() def __unicode__(self): """Return a name for this class.""" return self.get_identifier() @classmethod def all_authorized(cls, user_info=None): """Get all authorized. Return a dict of deposit types that the current user is allowed to view. """ user_info = user_info or current_user all_types = cls.all() auth_types = user_info.get('precached_allowed_deposition_types', set()) return {key: all_types[key] for key in auth_types if key in all_types}
import json from flask import Flask, jsonify from flask_restful import reqparse, abort, Api, Resource, request, fields, marshal_with from ..service.action_entity import save_new_action_entity, get_all_action_entitys, get_a_action_entity, update_a_action_entity, delete_a_action_entity from .. import api action_entity_fields = { 'id': fields.Integer, 'type': fields.String(1024), 'category': fields.String(1024), 'name': fields.String(1024), 'description': fields.String, 'sn_name': fields.String(1024), 'sn_description': fields.String, 'tn_name': fields.String(1024), 'tn_description': fields.String, } action_entity_list_fields = { 'action_entitys': fields.List(fields.Nested(action_entity_fields)) } @api.resource('/action_entitys') class ActionEntityList(Resource): @marshal_with(action_entity_fields) def get(self): """List all registered action_entitys"""