class Query(ObjectType):
node = Node.Field()
survey = MongoengineConnectionField(Survey)
question = MongoengineConnectionField(Question)
answer = MongoengineConnectionField(Answer)
question_analyse_item = Field(QuestionAnalyseItem, oid=ID(required=True))
question_analyse_items = List(QuestionAnalyseItem)
def resolve_question_analyse_items(self, info):
tmp = []
for each in Sur.objects.all():
for item in Que.objects(survey_oid=str(each.oid)):
tmp.append(QuestionAnalyseItem(oid=str(item.oid)))
return tmp
def resolve_question_analyse_item(self, info, oid):
return QuestionAnalyseItem(oid=oid)
class Query(graphene.ObjectType):
node = Node.Field()
words = MongoengineConnectionField(Word)
def resolve_words(self, info, entry=None):
if entry:
return list(WordModel.objects.filter(entry=entry))
return list(WordModel.objects.all())
class Query(graphene.ObjectType):
node = Node.Field()
allStages = MongoengineConnectionField(Stage)
allUsers = MongoengineConnectionField(User)
allItems = MongoengineConnectionField(Item)
galleryImages = graphene.Field(
graphene.List(GalleryImage),
ownerID=graphene.ID(required=True),
password=graphene.String(required=True),
) # Get gallery images of an owner
def resolve_galleryImages(root, info, ownerID, password):
owner = models.User.objects(id=ownerID).first()
if owner is None or not bcrypt.checkpw(password.encode(),
owner.hashedPassword.encode()):
return None
return list(models.GalleryImage.objects(owner=owner))
class Query(graphene.ObjectType):
"""
GraphQL Query
"""
get_single_user = graphene.Field(User,
user_id=graphene.NonNull(graphene.String))
get_users = MongoengineConnectionField(User)
get_single_article = graphene.Field(Articles,
article_id=graphene.NonNull(
graphene.String))
get_articles = MongoengineConnectionField(Articles, tag=graphene.String())
def resolve_get_users(self, info, **kwargs):
"""
Get All users with pagination
"""
db_user = crud_users.get_all_user()
if db_user is None:
raise GraphQLError("No Users Found")
return db_user
def resolve_get_single_user(self, info, user_id):
"""
Get single user
"""
return crud_users.get_user_id(user_id=user_id)
def resolve_get_articles(self, info, **kwargs):
"""
Get All articles with pagination and filters
"""
db_article = crud_articles.get_all_articles(
tag=kwargs.get("tag"), article_title=kwargs.get("article_title"))
if db_article is None:
raise GraphQLError("No Users Found")
return db_article
def resolve_get_single_article(self, info, article_id):
"""
Get Article
"""
return crud_articles.get_article(article_id=article_id)
class Query(graphene.ObjectType):
### Fields
# 모드별 랭킹 목록
modes_edges = MongoengineConnectionField(RankModeType)
modes = graphene.List(RankModeType,
mode=graphene.String(default_value="4x4"))
# 전체 랭킹 목록
ranks_edges = MongoengineConnectionField(RankType)
ranks = graphene.List(RankType,
page=graphene.Int(default_value=1),
count_for_rows=graphene.Int(default_value=10),
order=graphene.List(graphene.String),
search=InputSearchRank())
# 특정 랭킹에 대한 정보
rank = graphene.Field(RankType, id=graphene.String(required=True))
### Resolvers
# 모드별 랭킹 목록
def resolve_modes(parent, info, mode, **input):
return RankModeModel.objects(mode=mode).all()
# 전체 랭킹 목록
def resolve_ranks(parent, info, page, count_for_rows, **kwargs):
order = kwargs.get("order") if "order" in kwargs else list()
search = kwargs.get("search") if "search" in kwargs else dict()
page = page if page > 0 else 1
count_for_rows = count_for_rows if count_for_rows > 0 else 10
skip = (page - 1) * count_for_rows
model = RankModel.objects(**search).order_by(
*order).skip(skip).limit(count_for_rows)
return model
# 특정 랭킹에 대한 정보
def resolve_rank(parent, info, id):
return RankModel.objects.get(id=id)
class Query(graphene.ObjectType):
node = Node.Field()
allAwss = MongoengineConnectionField(AWS)
allAzures = MongoengineConnectionField(Azure)
sortAWSByHost = MongoengineConnectionField(AWS)
sortAzureByHost = MongoengineConnectionField(Azure)
sortAWSByName = MongoengineConnectionField(AWS)
sortAzureByName = MongoengineConnectionField(Azure)
fetchAWSData = graphene.String()
fetchAzureData = graphene.String()
def resolve_sortAWSByHost(self, info, **args):
return AwsModel.objects().order_by("-isFavorite", "host")
def resolve_sortAzureByHost(self, info, **args):
return AzureModel.objects().order_by("-isFavorite", "host")
def resolve_sortAWSByName(self, info, **args):
return AwsModel.objects().order_by("-isFavorite", "name")
def resolve_sortAzureByName(self, info, **args):
return AzureModel.objects().order_by("-isFavorite", "name")
def resolve_fetchAWSData(self, info):
init_aws()
return "Success"
def resolve_fetchAzureData(self, info):
init_azure()
return "Success"
class Query(graphene.ObjectType):
users = MongoengineConnectionField(UserType)
groups = MongoengineConnectionField(GroupType)
artwork = MongoengineConnectionField(ArtworkType)
portfolios = MongoengineConnectionField(PortfolioType)
achievements = MongoengineConnectionField(AchievementType)
reports = MongoengineConnectionField(ReportType)
class ModeQuery(graphene.ObjectType):
class Meta:
abstract = True
### Fields
# 모드별 랭킹 목록
modes_edges = MongoengineConnectionField(RankModeType)
modes = graphene.List(RankModeType, mode=graphene.String())
### Resolvers
# 모드별 랭킹 목록
def resolve_modes(parent, info, **input):
return RankModeModel.objects(**input).all()
class Query(graphene.ObjectType):
node = Node.Field()
all_sentiment = MongoengineConnectionField(Sentiment)
sentiment = graphene.Field(Sentiment, term=graphene.String(required=True))
def resolve_sentiment(parent, info, term):
term = term.lower()
sentiment = get_recent_sentiment_in_db(term)
if sentiment is None: # No sentiment for this term found (or it was older than 15 minutes)
add_sentiment(term)
sentiment = get_recent_sentiment_in_db(term)
return sentiment
else:
return sentiment
class Query(graphene.ObjectType):
all_ranks = MongoengineConnectionField(RankType)
ranks = graphene.List(
RankType, **{
"mode": graphene.String(required=True),
"limit": graphene.Int(),
"skip": graphene.Int()
})
rank = graphene.Field(RankType, **{"id": graphene.String(required=True)})
def resolve_ranks(parent, info, mode, **kwargs):
return RankModel.objects(mode=mode).skip(kwargs.get("skip")).limit(
kwargs.get("limit"))
def resolve_rank(parent, info, id):
return RankModel.objects.get(id=id)
class Query(graphene.ObjectType):
node = Node.Field()
all_employees = MongoengineConnectionField(User)
all_roles = MongoengineConnectionField(Role)
role = graphene.Field(Role)
class Query(graphene.ObjectType):
node = Node.Field()
all_levels = MongoengineConnectionField(Level)
all_enemies = MongoengineConnectionField(Enemy)
all_powerups = MongoengineConnectionField(Powerup)
class Query(ObjectType):
node = Node.Field()
all_activities = MongoengineConnectionField(Activity)
all_agents = MongoengineConnectionField(Agent)
all_references = MongoengineConnectionField(Reference)
class Query(ObjectType):
node = Node.Field()
all_users = MongoengineConnectionField(UserSchema)
user = Field(UserSchema)
class Query(graphene.ObjectType):
node = Node.Field()
all_auditionee = MongoengineConnectionField(AuditioneeType)
auditionee = graphene.Field(AuditioneeType)
all_choreographer = MongoengineConnectionField(ChoreographerType)
choreographer = graphene.Field(ChoreographerType)
class Query(graphene.ObjectType):
node = Node.Field()
all_employess = MongoengineConnectionField(Employee)
all_role = MongoengineConnectionField(Role)
all_dashboard = MongoengineConnectionField(Franquicia)
role = graphene.Field(Role)
class Query(graphene.ObjectType):
node = Node.Field()
all_movies = MongoengineConnectionField(Tech)
class Query(graphene.ObjectType):
all_object_information = MongoengineConnectionField(ObjectInformation)
class Query(graphene.ObjectType):
node = Node.Field()
all_bots = MongoengineConnectionField(Bots)
all_rooms = MongoengineConnectionField(Rooms)
all_users = MongoengineConnectionField(Users)
class Query(graphene.ObjectType):
node = Node.Field()
news = MongoengineConnectionField(News)
weather = MongoengineConnectionField(Weather)
class Query(graphene.ObjectType):
node = Node.Field()
allTask = MongoengineConnectionField(Task)
class Query(graphene.ObjectType):
node = Node.Field()
all_cloud_accounts = MongoengineConnectionField(CloudAccountSchema)
all_cloud_providers = MongoengineConnectionField(CloudProviderSchema)
all_customers = MongoengineConnectionField(CustomerSchema)
class Query(graphene.ObjectType):
node = Node.Field()
all_cms_pages = MongoengineConnectionField(CMSPage)
cms_page = graphene.Field(CMSPage, page_type=graphene.String())
class Query(graphene.ObjectType):
node = Node.Field()
all_cards = MongoengineConnectionField(Card)
class Query(ObjectType):
# this defines a Field `hello` in our Schema with a single Argument `name`
people = MongoengineConnectionField(Person)
roles = MongoengineConnectionField(Role)
class Query(graphene.ObjectType):
node = Node.Field()
request = MongoengineConnectionField(Request)
response = MongoengineConnectionField(Response)
class Query(graphene.ObjectType):
node = Node.Field()
all_articles = MongoengineConnectionField(ArticleObject)
class Query(graphene.ObjectType):
node = Node.Field()
all_versions = MongoengineConnectionField(Version)
all_cars = MongoengineConnectionField(Car)
all_brands = MongoengineConnectionField(Brand)
class Query(graphene.ObjectType):
node = Node.Field()
piece = MongoengineConnectionField(PieceOfClothing)
class Query(graphene.ObjectType):
node = Node.Field()
all_projects = MongoengineConnectionField(Projects)
all_users = MongoengineConnectionField(Users)
