class Group(db.Model):
__tablename__ = 'groups'
def __init__(self, name, description, topic_area):
self.name, self.description, self.topic_area = name, description, topic_area
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
university_id = db.Column('university_id', db.Integer, db.ForeignKey('universities.id'), nullable=False)
name = db.Column('name', db.String(40), nullable=False, unique=True)
topic_area = db.Column('topic_area', db.String(20), nullable=False)
password_hash = db.Column('password', db.String(256), default=None)
description = db.Column('description', db.String(140))
# backref users
notes = db.relationship('Note', backref='group', lazy='dynamic')
fields = {
'with_members': {
'id': fields.Integer,
'name': fields.String,
'topic_area': fields.String,
'description': fields.String,
'protected': fields.Boolean(attribute=lambda x: False if not x.password_hash else True),
'members': fields.Nested(user_model.User.fields['only_username'])
},
'basic': {
'id': fields.Integer,
'name': fields.String,
'topic_area': fields.String,
'description': fields.String,
'protected': fields.Boolean(attribute=lambda x: False if not x.password_hash else True)
},
'only_id_and_name': {
'topic_area': fields.String,
'id': fields.Integer,
'name': fields.String,
'protected': fields.Boolean(attribute=lambda x: False if not x.password_hash else True)
}
}
def hash_password(self, password):
self.password_hash = pwd_context.encrypt(password)
def verify_password(self, entered_password):
return pwd_context.verify(entered_password, self.password_hash)
def add_user(self, user):
self.members.append(user)
return self
def get(self, id, *args, **kwargs):
"""
@apiVersion 0.1.0
@api {get} /groups/{id}/ Get group at id.
@apiName GetGroupAtId
@apiGroup Groups
@apiUse TokenRequired
@apiUse BadRequest
@apiSuccess 200 message Success message for group creation.
@apiSuccessExample Success-Response:
HTTP/1.1 200 OK
{
'id': the groups id,
'name': the groups name,
'topic_area': the groups area of topic,
'description': the groups description,
'protected': true/false if the group is password protected,
'members': [{name: users who are members of the group}]
}
@apiUse NoSuchResourceError
"""
user_id = kwargs.get('user')['user_id']
user = user_model.User.query.get(user_id)
group = group_model.Group.query.get(id)
if user and group:
cpy = group_model.Group.fields['with_members'].copy()
cpy.update({
'im_a_member':
fields.Boolean(attribute=lambda x: True
if user in group.members else False)
})
return jsonify(marshal(group, cpy))
return response.simple_response('no such group or user', status=404)
class PutUserLockStatusResponse(object):
resource_fields = {
'status': fields.String(),
'providedPasswordDisabled': fields.Boolean()
}
required = ['status', 'providedPasswordDisabled']
code = 200
def get_field_type(attr_type):
if attr_type == int:
return fields.Integer()
elif attr_type == str:
return fields.String()
elif attr_type == bool:
return fields.Boolean()
elif attr_type == float:
return fields.Float()
def test_boolean():
values = [
(True, True),
(False, False),
({}, False),
("false", True), # These are different from php
("0", True), # Will this be a problem?
]
for value, expected in values:
yield check_field, expected, fields.Boolean(), value
class TopicModel(object):
"""
Swagger documentation object
"""
resource_fields = {
'name': fields.String(),
'topic': fields.String(),
'type': fields.String(),
'publishing': fields.Boolean()
}
required = ['']
def __init__(self):
self.parser = reqparse.RequestParser()
self.url_all_field = {
'id':fields.Integer(attribute='url.id'),
'group_name':fields.String(attribute='url.group_name', default=None),
'group_path':fields.String(attribute='url.group_path', default=None),
'path':fields.String(attribute='url.path'),
'short_path':fields.String(attribute='url.short_path'),
'custom':fields.Boolean(attribute='url.custom'),
'redirects':RedirectsField(attribute='redirects'),
'created_at':fields.String(attribute='url.created_time')
}
self.url_field = {
'id':fields.Integer(attribute='url.id'),
'group_name':fields.String(attribute='url.group_name', default=None),
'group_path':fields.String(attribute='url.group_path', default=None),
'path':fields.String(attribute='url.path'),
'short_path':fields.String(attribute='url.short_path'),
'custom':fields.Boolean(attribute='url.custom'),
'created_at':fields.String(attribute='url.created_time')
}
self.method_decorators = [authenticate]
class PostListFields:
'''
构造序列格式类，利用的是fields
从小到大构造，从内到外构造
'''
# 构造标签序列
taglist = {'id': fields.Integer(), 'title': fields.String()}
postlist = {
'title': fields.String(attribute='title'),
'text': fields.String(attribute='text') # 需要设置成过滤html模式
}
resource = {
'success': fields.Boolean(attribute='success'),
'postlist': fields.List(fields.Nested(postlist))
}
def __init__(self):
self.parser = reqparse.RequestParser()
self.parser.add_argument('offset',
type=int,
location='args',
required=False,
default=1)
self.parser.add_argument('limit',
type=int,
location='args',
required=False,
default=10)
self.parser.add_argument('classification_id',
location='args',
required=False,
type=int,
default=0)
self.parser.add_argument('name', type=str, location='json', default='')
self.parser.add_argument('artist',
type=str,
location='json',
default='')
self.parser.add_argument('is_hot', type=bool, location='json')
self.parser.add_argument('classification',
type=int,
location='json',
action='append')
classification_fields = {
'id': fields.Integer(attribute='id'),
'name': fields.String(attribute='name')
}
self.album_fields = {
'id': fields.Integer(attribute='id'),
'name': fields.String(attribute='name'),
'artist': fields.String(attribute='artist'),
'is_hot': fields.Boolean(attribute='is_hot'),
'classification':
fields.List(fields.Nested(classification_fields)),
}
self.resource_fields = {
'error_code': fields.Integer(attribute='error_code')
}
class Note(db.Model):
__tablename__ = 'notes'
def __init__(self, name, topic, content):
self.name, self.topic, self.content = name, topic, content
id = db.Column('id', db.Integer, primary_key=True, autoincrement=True)
user_id = db.Column('user_id',
db.Integer,
db.ForeignKey('users.id'),
nullable=False)
group_id = db.Column('group_id',
db.Integer,
db.ForeignKey('groups.id'),
nullable=False)
topic = db.Column('topic', db.String(20), nullable=False)
name = db.Column('name', db.String(20), nullable=False)
content = db.Column('content', db.String(4200))
image_path = db.Column('image_path', db.String(256))
# GROUP - public = db.Column('public')
# owner (user)
fields = {
'id':
fields.Integer,
'name':
fields.String,
'topic':
fields.String,
'creator':
fields.Nested(user_model.User.fields['only_username']),
'group':
fields.Nested(group_model.Group.fields['only_id_and_name']),
'content':
fields.String,
'has_image':
fields.Boolean(attribute=lambda n: True if n.image_path else False)
}
from flask_restful import fields
from application.outputs.booking import *
from application.outputs.maintenance import *
RoomOutput = {
'room_number': fields.String,
'building': fields.String,
'name': fields.String,
'is_available': fields.Boolean(default=True),
}
RoomDetailOutput = {
'room_number': fields.String,
'name': fields.String,
'building': fields.String,
'is_available': fields.Boolean(default=True),
'current_booking': fields.Nested(BookingOutput),
'modified_at': fields.DateTime(dt_format='iso8601'),
'booking_history': fields.List(fields.Nested(BookingOutput)),
'maintenance_history': fields.List(fields.Nested(MaintenanceOutput))
}
from flask_restful import fields
from src.system.utils.shell import States
restart_job_fields = {"timer": fields.Integer, "error": fields.String}
service_fields = {
'display_name': fields.String,
'service': fields.String,
'is_installed': fields.Boolean,
'state': fields.String(default=States.INACTIVE.value),
'status': fields.Boolean(default=False),
'date_since': fields.String,
'time_since': fields.String,
'is_enabled': fields.Boolean(default=False),
'restart_job': fields.Nested(restart_job_fields)
}
config_fields = {
'service': fields.String,
'delete': fields.Boolean,
'update': fields.Boolean,
'state': fields.String(default=States.INACTIVE.value)
}
config_delete_fields = {**config_fields, 'error': fields.String}
from flask_restful import Resource, reqparse, fields, marshal
from app.blueprints.supervisor.models.shared import db
from app.blueprints.supervisor.models.service import Service # , PublicService
from app.blueprints.kat.common.auth import auth
service_fields = {
"id": fields.String(),
"name": fields.String(),
"timestamp": fields.Integer(),
"mem": fields.Integer(),
"status": fields.Boolean(),
"pid": fields.Integer(),
"dir": fields.String(),
"exec": fields.String(),
"args": fields.String(),
"can_vote": fields.Boolean(),
"keep_alive": fields.Boolean(),
}
public_service_fields = {
"id": fields.String(),
"status": fields.Integer(),
"keep_alive": fields.Boolean(),
"can_vote": fields.Boolean()
}
class ServiceListResource(Resource):
decorators = [auth.login_required]
from flask import jsonify
from flask_restful import Resource, abort, fields, marshal_with, reqparse, marshal
from sqlalchemy.exc import IntegrityError
from library import db
from library.models.user import User
user_fields = {
'id': fields.Integer,
'first_name': fields.String,
'last_name': fields.String,
'email': fields.String,
'is_admin': fields.Boolean()
}
class UserApi(Resource):
def __init__(self):
self.reqparse = reqparse.RequestParser()
self.reqparse.add_argument('first_name',
type=str,
required=True,
location='json',
help='User first name is required')
self.reqparse.add_argument('last_name',
type=str,
required=True,
location='json',
help='User last name is required')
self.reqparse.add_argument('email',
type=str,
'userId': fields.Integer,
'userName': fields.String,
'realName': fields.String,
'globalLevel': fields.String,
'userLevel': fields.String
}
user_list_fields = {
'total':
fields.Integer(attribute=lambda pagination: pagination.total),
'currentPage':
fields.Integer(attribute=lambda pagination: pagination.page),
'pageSize':
fields.Integer(attribute=lambda pagination: pagination.per_page),
'hasNext':
fields.Boolean(attribute=lambda pagination: pagination.has_next),
'list':
fields.List(fields.Nested(user_item_fields),
attribute=lambda pagination: pagination.items)
}
class AdminUserResource(Resource):
# def __init__(self):
# self.parser = reqparse.RequestParser()
# self.parser.add_argument('userName', type=valid_user_name)
# self.parser.add_argument('passWord', type=valid_pass_word)
# self.parser.add_argument('realName', default=None)
# self.parser.add_argument('globalLevel', default=None)
# self.parser.add_argument('userLevel', default=None)
# super(UserResource, self).__init__()
# GNU Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
from flask_restful import Resource, fields, marshal
from ..db import db, User, Collection, UserCollection
from .utils import unauthorized_error, bad_request_error
from .login import with_user
collection_fields = {
"id": fields.Integer(attribute="collection.id"),
"name": fields.String(attribute="collection.name"),
"label": fields.String(attribute="collection.label"),
"is_admin": fields.Boolean(attribute="is_admin"),
}
class CollectionApi(Resource):
@with_user
def get(self, user, username, col_name=None):
if col_name is None:
user_collections = (db.session.query(UserCollection).join(
UserCollection.collection).join(Collection.owner).options(
db.contains_eager(UserCollection.collection), ).filter(
UserCollection.user_id == user.id).filter(
Collection.owner_id == User.id).filter(
User.username == username).order_by(
Collection.label).all())
# with this program; if not, write to the Free Software Foundation, Inc.,
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
from flask import url_for
from flask_restful import reqparse, fields
from xivo_confd.authentication.confd_auth import required_acl
from xivo_confd.helpers.restful import FieldList, Link, ListResource, ItemResource, \
Strict, DigitStr
from xivo_dao.alchemy.extension import Extension
fields = {
'id': fields.Integer,
'exten': fields.String,
'context': fields.String,
'commented': fields.Boolean(attribute='legacy_commented'),
'links': FieldList(Link('extensions'))
}
parser = reqparse.RequestParser()
parser.add_argument('exten', type=DigitStr(), store_missing=False)
parser.add_argument('context', type=Strict(unicode), store_missing=False)
parser.add_argument('commented',
type=Strict(bool),
store_missing=False,
dest='legacy_commented')
class ExtensionList(ListResource):
model = Extension
def isFollowerAttribute(user):
if fjwt.get_current_user():
return user.id in fjwt.get_current_user().followers
return False
short_profile = {
'avatar_id': fields.Integer,
'first_name': fields.String,
'last_name': fields.String,
}
user_fields_short = {
'id': fields.Integer,
'username': fields.String,
'is_admin': fields.Boolean,
'is_anonymous': fields.Boolean(attribute=lambda user: user.isAnonymous()),
'profile': MarshalFields(short_profile),
'isFriend': fields.Boolean(attribute=isFriendAttribute),
'isFollower': fields.Boolean(attribute=isFollowerAttribute),
}
user_fields = {
**user_fields_short,
'is_anonymous': fields.Boolean(attribute=lambda user: user.isAnonymous()),
'profile': MarshalFields({
**short_profile,
'description': fields.String,
'birthdate': DayDate,
'country': fields.String,
'gender': fields.String,
}),
file = snippet.files[0]
lines = file.text.split("\n")
file.text = "\n".join(lines[:10]) + "\n..." * (len(lines) > 10)
return file
file_fields = {
'filename': fields.String,
'text': fields.String,
'extension': fields.String
}
snippet_fields = {
"snippet_id": fields.String,
"title": fields.String,
"created_at": fields.DateTime,
"is_public": fields.Boolean,
"files": fields.List(fields.Nested(file_fields)),
"isFull": fields.Boolean(default=True)
}
snippet_list_fields = {
"snippet_id": fields.String,
"title": fields.String,
"created_at": fields.DateTime,
"is_public": fields.Boolean,
"file": fields.Nested(file_fields, attribute=format_file),
"statistic": Statistic(attribute="files"),
"isFull": fields.Boolean(default=False)
}
from flask_restful import fields
from sqlalchemy.ext.orderinglist import ordering_list
from resources.endereco import EnderecoModel, endereco_campos
from resources.natureza import NaturezaModel, natureza_campos
from sqlalchemy.sql import func
empresa_campos = {
'id': fields.Integer(attribute='id'),
'nome': fields.String(attribute='nome'),
'natureza': fields.Nested(natureza_campos),
'endereco': fields.Nested(endereco_campos),
'email': fields.String(attribute='email'),
'telefone': fields.String(attribute='telefone'),
'instagram': fields.String(attribute='instagram'),
'facebook': fields.String(attribute='facebook'),
'isDelivery': fields.Boolean(attribute='is_delivery'),
'isDeleted': fields.Boolean(attribute='is_deleted')
}
'''
Classe Empresa.
'''
class EmpresaModel(db.Model):
__tablename__ = 'tb_empresa'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255), nullable=False)
email = db.Column(db.String(255), nullable=False)
telefone = db.Column(db.String(13), nullable=False)
instagram = db.Column(db.String(255), nullable=True)
"""
Nest the transaction info
"""
sale_fields['transaction_info'] = {}
sale_fields['transaction_info']['Product'] = fields.String(attribute='product')
sale_fields['transaction_info']['Quantity'] = fields.Integer(
attribute='quantity')
sale_fields['transaction_info']['Date'] = fields.DateTime(attribute='date',
dt_format='rfc822')
sale_fields['transaction_info']['Description'] = fields.String(
attribute='description')
sale_fields['transaction_info']['Transaction_type'] = fields.String(
attribute='transaction_type')
sale_fields['transaction_info']['Complete'] = fields.Boolean(
attribute='complete')
admin_users = {
'manager': 'man',
}
users = {'manager': 'man', 'attendant': 'att'}
@admin_auth.get_password
def use_password(username):
if username in users:
return admin_users.get(username)
return None
from flask_restful import fields
from flask import make_response, jsonify, g, request
from flask_httpauth import HTTPTokenAuth
from tweetapi.database import User, LoginInfo
user_fields = {
'username': fields.String,
'user_id': fields.Integer,
'photo_url': fields.String
}
user_info_fields = {
'username': fields.String,
'user_id': fields.Integer,
'photo_url': fields.String,
'is_friend': fields.Boolean(default=False),
'is_fan': fields.Boolean(default=False),
'introduction': fields.String,
'region': fields.String,
'birth': fields.String,
'gender': fields.String
}
tweet_fields = {
'user': fields.Nested(user_fields),
# 'user_id': fields.Integer,
'time': fields.DateTime,
'description': fields.String,
'likes': fields.Integer,
'tweet_id': fields.Integer,
'image_url': fields.String
app = Blueprint('paper', __name__)
api = Api(app)
logger = logging.getLogger(__name__)
paper_fields = {
'id': fields.String,
'url': fields.String(attribute='local_pdf'),
'title': fields.String,
'authors': fields.Nested({'name': fields.String, 'id': fields.String}),
'time_published': fields.DateTime(attribute='publication_date', dt_format='rfc822'),
'abstract': fields.String,
'code': fields.Nested(paper_with_code_fields, attribute='paper_with_code', allow_null=True),
'groups': fields.List(fields.String(attribute='id'), attribute='groups'),
'is_editable': fields.Boolean(attribute='is_private', default=False),
'arxiv_id': fields.String(attribute='original_id', default=''),
}
class ItemState(Enum):
existing = 1
updated = 2
new = 3
def add_groups_to_paper(paper: Paper):
if get_jwt_identity():
user = get_user()
paper.groups = db.session.query(Collection.id).filter(Collection.users.any(
id=user.id), Collection.papers.any(id=paper.id)).all()
from flask_restful import Resource, fields, marshal_with, reqparse
from flask import request
from ..common.IMAPMailbox import makeNewIMAPconnection
from ..common.createFolder import createFolder
from ..common.deleteFolder import deleteFolder
from ..models.users import Users
from flask_jwt_extended import jwt_required, get_jwt_identity
from config import defaultFolders
resource_fields = {
'success': fields.Boolean(default=False),
'message': fields.String(default='Something goes wrong'),
}
class operateWithFolders(Resource):
@jwt_required
@marshal_with(resource_fields)
def post(self, folder):
userInfo = Users.query.filter_by(
userID=request.headers.get('ID')).first()
MAIL_USERNAME = userInfo.osUserName
MAIL_PASSWORD = userInfo.password
if request.headers.get('ID') == get_jwt_identity():
Mailbox = makeNewIMAPconnection()
Mailbox.login(MAIL_USERNAME, MAIL_PASSWORD)
#we encode it to utf7, couse imap badly operate with non-ascii characters
#folder = folder.encode('utf7')
status = createFolder(Mailbox, folder)
from flask import Blueprint, g
from flask_restful import Api, Resource, fields, marshal_with, request, marshal_with_field, abort, marshal
bp = Blueprint("users", __name__, url_prefix="/users")
api = Api(bp, prefix="/api/v1")
tg_fields = [
"id", "username", "first_name", "last_name", "is_bot", "language_code"
]
telegram_fields = {
"username": fields.String(),
"first_name": fields.String(),
"last_name": fields.String(),
"is_bot": fields.Boolean(default=False),
"language_code": fields.String(),
}
user_fields = {
"id": fields.Integer(),
"username": fields.String(),
"email": fields.String(),
"first_name": fields.String(),
"last_name": fields.String(),
"is_bot": fields.Boolean(default=False),
"language_code": fields.String(),
"password": fields.String(),
"group": fields.Integer(),
"access_token": fields.String(),
"refresh_token": fields.String(),
}
'username': fields.String(),
'password': fields.String(),
'is_verify': fields.Boolean,
}
cinema_field = {
'name': fields.String(),
'city': fields.String(),
'district': fields.String(),
'address': fields.String(),
'phone': fields.String(),
'score': fields.Integer,
'hallnum': fields.Integer(attribute='hall_num'),
'servicecharge': fields.Integer(attribute='service_charge'),
'astrict': fields.Integer,
'flag': fields.Integer,
'isdelete': fields.Boolean(attribute='is_delete'),
'cinemauserid': fields.Integer(attribute='cinema_user_id'),
}
class CinemaUserResource(Resource):
# 获取影院信息
@cinema_client_login_required
@permission_required(permission=CINEMA_CLIENT_PERMISSION)
def get(self):
cinema_user = g.user
cinema = CinemaModel.query.filter_by(cinema_user_id=cinema_user.id).all()
data = {
'status': current_app.config.get('HTTP_OK'),
from common.database import db
from flask_restful import fields
from sqlalchemy.ext.orderinglist import ordering_list
from sqlalchemy.sql import func
from models.empresa import EmpresaModel, empresa_campos
produto_campos = {
'id': fields.Integer(attribute='id'),
'nome': fields.String(attribute='nome'),
'descricao': fields.String(attribute='descricao'),
'preco': fields.String(attribute='preco'),
'isVisivel': fields.Boolean(attribute='is_visivel'),
'isDeleted': fields.Boolean(attribute='is_deleted'),
'empresa': fields.Nested(empresa_campos)
}
'''
Classe Produto.
'''
class ProdutoModel(db.Model):
__tablename__ = 'tb_produto'
id = db.Column(db.Integer, primary_key=True)
nome = db.Column(db.String(255))
descricao = db.Column(db.Text())
preco = db.Column(db.Float(precision='3,2'))
is_visivel = db.Column(db.Boolean, default=False)
is_deleted = db.Column(db.Boolean, default=False)
dt_insercao = db.Column(db.DateTime, default=func.current_timestamp())
fk_id_empresa = db.Column(db.Integer,
post_parse.add_argument("score", type=float, default=5.0, location='form')
post_parse.add_argument("is_anonymous", type=bool, default=0, location="form")
post_parse.add_argument("outbound_date", type=str, location="form")
user_fields = {
'user_name': fields.String, #"用户名",
'open_id': fields.String, #"微信openId",
'wx_nickname': fields.String, #"微信名",
'wx_img': fields.String, #"微信头像地址",
'user_password': fields.String, #"密码",
'user_gender': fields.String, #"性别",
'contact_email': fields.String, #"联系人E-mail",
'contact_name': fields.String, #"联系人姓名",
'contact_phone': fields.String, #"联系人电话",
'contact_id': fields.String, #"联系人的护照ID",
'is_superuser': fields.Boolean(default=False), #"是不是超级用户",
}
class SearchSchedulesApi(Resource):
decorators = [http_basic_auth]
def get(self):
"""
:return:
"""
tomorrow = datetime.today() + timedelta(days=1)
tomorrow_str = tomorrow.strftime("%Y-%m-%d")
departure = request.args.get("departure", "").strip() # 起始地点
**operation_fields
}
interface_template_fields = {
**interface_base_fields, 'parentDeviceName':
fields.String(attribute='parent_device.name'),
'parentEquipmentName':
fields.String(attribute='parent_equipment.name'),
'verifyUserName':
fields.String(attribute='verify_user.username')
}
cable_base_fields = {
**base_fields, 'signalType': fields.String(attribute='signal_type'),
'shieldType': fields.String(attribute='shield_type'),
'isCustom': fields.Boolean(attribute='is_custom'),
'parameterList': fields.String(attribute='parameter_list'),
**operation_fields
}
cable_template_fields = {
**cable_base_fields,
# 'startEquipmentName': fields.String(attribute='start_equipment.name'),
# 'endEquipmentName': fields.String(attribute='end_equipment.name'),
# 'startDeviceName': fields.String(attribute='start_device.name'),
# 'endDeviceName': fields.String(attribute='end_device.name'),
'startInterfaceName':
fields.String(attribute='start_interface.name'),
'endInterfaceName':
fields.String(attribute='end_interface.name'),
'verifyUserName':
'user': fields.String(attribute='user.username'),
'first_name': fields.String(attribute='user.first_name'),
'last_name': fields.String(attribute='user.last_name'),
'text': fields.String,
'createdAt': fields.DateTime(dt_format='rfc822', attribute='creation_date'),
}
comment_fields = {
'id': fields.String,
'text': fields.String(attribute='text'),
'highlighted_text': fields.String(attribute='highlighted_text'),
'position': fields.Raw,
'username': fields.String(attribute=lambda x: anonymize_user(x, 'username')),
'first_name': fields.String(attribute=lambda x: anonymize_user(x, 'first_name')),
'last_name': fields.String(attribute=lambda x: anonymize_user(x, 'last_name')),
'canEdit': fields.Boolean(attribute=lambda x: can_edit(x)),
'createdAt': fields.DateTime(dt_format='rfc822', attribute='creation_date'),
'replies': fields.List(fields.Nested(replies_fields)),
'visibility': visibility_fields,
'isGeneral': fields.Boolean(attribute='is_general'),
}
def visibilityObj(obj):
choices = ('public', 'private', 'anonymous', 'group')
vis_type = obj.get('type')
if vis_type not in choices:
raise ValueError('Visibility value is incorrect')
if vis_type == 'group' and not obj.get('id'):
raise ValueError('Group id is missing')
return obj
