query = Department.get_query(info)
query = query.filter(DepartmentModel.id == self.departmentId)
title = kwargs.get('title', None)
if title:
query = query.filter(DepartmentModel.title == title)
return query.first()
class AzsConnection(relay.Connection):
class Meta:
node = Azs
SortEnumAzs = utils.sort_enum_for_model(
AzsModel,
'SortEnumAzs',
lambda c, d:
c.upper() + ('_ASC' if d else '_DESC')
)
class Kkt(SQLAlchemyObjectType):
class Meta:
model = KktModel
# interfaces = (relay.Node, )
class KktConnection(relay.Connection):
class Meta:
node = Kkt
class Meta:
node = Employee
class Role(SQLAlchemyObjectType):
class Meta:
model = RoleModel
interfaces = (relay.Node, )
class RoleConnection(relay.Connection):
class Meta:
node = Role
SortEnumEmployee = utils.sort_enum_for_model(EmployeeModel, 'SortEnumEmployee',
lambda c, d: c.upper() + ('_ASC' if d else '_DESC'))
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Allow only single column sorting
all_employees = SQLAlchemyConnectionField(
EmployeeConnection,
sort=graphene.Argument(
SortEnumEmployee,
default_value=utils.EnumValue('id_asc', EmployeeModel.id.asc())))
# Allows sorting over multiple columns, by default over the primary key
all_roles = SQLAlchemyConnectionField(RoleConnection)
# Disable sorting over this field
all_departments = SQLAlchemyConnectionField(DepartmentConnection, sort=None)
# pylint: disable=too-few-public-methods
from graphene import relay
from graphene_sqlalchemy import utils
from core.db.models.domain_card import DomainCard as DomainCardModel
from core.graphql.schemas import (
OptimizeResolveObjectType,
OptimizeResolveConnection,
)
class DomainCard(OptimizeResolveObjectType):
class Meta:
model = DomainCardModel
interfaces = (relay.Node,)
only_fields = ('display_title', 'display_text', 'display_image', 'display_order')
@staticmethod
def resolve_display_image(model, info):
value = model.display_image
return value.strip() if value else value
class DomainCardsConnection(OptimizeResolveConnection):
class Meta:
node = DomainCard
DomainCardSortEnum = utils.sort_enum_for_model(DomainCardModel)
def optimize_resolve_domain_card(query_parent_path):
query_child_path = '.'.join([query_parent_path, 'card'])
return OptimizeResolveTuple(
query_options=joinedload(query_child_path),
query_child_path=query_child_path,
child_node_class=DomainCard
)
class UserCardsConnection(OptimizeResolveConnection):
class Meta:
node = UserCard
UserCardSortEnum = utils.sort_enum_for_model(UserCardModel)
class UserCardInput(graphene.InputObjectType):
domain_card_id = graphene.ID(required=True)
preference = graphene.Field(CardPreference, required=True)
def save_user_cards(inp, user):
cards_inp = inp.get('user_cards')
if cards_inp is None:
return
card_inp_dict = {}
for card_inp in cards_inp:
domain_card_id = from_global_id_assert_type(card_inp.domain_card_id, 'DomainCard')
get_credit_card,
get_user,
get_or_create_user,
get_user_by_sub,
get_cognito_attr_dict,
populate_automatic_username,
)
from core.dbmethods.subscription import save_subscription
from core.order.actions.base import send_template_email
from core.order.order_manager import (
USER_UPCOMING_ORDER_STATES,
USER_PROPOSED_ORDER_STATES,
USER_ORDER_HISTORY_STATES,
)
UserSortEnum = utils.sort_enum_for_model(UserModel)
class CreditCard(graphene.ObjectType):
brand = graphene.String()
country = graphene.String()
exp_month = graphene.String()
exp_year = graphene.String()
last4 = graphene.String()
name = graphene.String()
def _can_return_sensitive_info(user, identity):
return user.cognito_sub == identity.id.subject or identity.can(admin_user_permission)
node = Persons
class Email(SQLAlchemyObjectType):
class Meta:
model = EmailModel
interfaces = (Node, )
class EmailsConnection(Connection):
class Meta:
node = Email
SortEnumPerson = utils.sort_enum_for_model(
PersonModel, 'SortEnumPerson', lambda c, d: c.upper() +
('_ASC' if d else '_DESC'))
class Query(ObjectType):
node = Node.Field()
all_persons = SQLAlchemyConnectionField(
PersonConnection,
sort=Argument(SortEnumPerson,
default_value=utils.EnumValue('id_asc',
PersonModel.id.asc())))
all_next_person = SQLAlchemyConnectionField(PersonsConnection, sort=None)
all_email = SQLAlchemyConnectionField(EmailsConnection)
class CreatePerson(Mutation):
node = User
class Role(SQLAlchemyObjectType):
class Meta:
model = RoleModel
interfaces = (relay.Node, )
class RoleConnection(relay.Connection):
class Meta:
node = Role
SortEnumUser = utils.sort_enum_for_model(
UserModel, 'SortEnumUser', lambda c, d: c.upper() + ('_ASC'
if d else '_DESC'))
class Query(graphene.ObjectType):
node = relay.Node.Field()
# Allow only single column sorting
all_users = SQLAlchemyConnectionField(
UserConnections,
sort=graphene.Argument(SortEnumUser,
default_value=utils.EnumValue(
'id_asc', UserModel.id.asc())))
# Allows sorting over multiple columns, by default over the primary key
all_roles = SQLAlchemyConnectionField(RoleConnection)
# Disable sorting over this field
all_blogs = SQLAlchemyConnectionField(BlogConnection, sort=None)