def re_structure_habit_input(fields, operation= 'create'):
if fields.reminder_time != '':
fields['reminder_time']= datetime.datetime.strptime(fields.reminder_time, datetime_format('time'))
structured= {
'_id': get_sequence('habits'),
'name': fields['name'],
'description': fields['description'],
'created_at': '',
'type': fields['type'],
'day': fields['day'],
'goal': fields['goal'],
'goal_dates': {
'start': datetime.datetime.strptime(fields.goal_dates.start, datetime_format('date')),
'end': datetime.datetime.strptime(fields.goal_dates.end, datetime_format('date'))
},
'reminder_time': fields['reminder_time'],
'is_reminder': fields['is_reminder'],
'is_notified': False,
'label_color': fields['label_color']
}
if operation == 'create':
current_datetime= datetime.datetime.now()
current_date= current_datetime.strftime(datetime_format('date'))
current_time= current_datetime.strftime(datetime_format('time'))
structured['created_at']= datetime.datetime.strptime(f"{current_date} {current_time}", datetime_format('datetime'))
elif operation == 'update':
del structured['_id']
del structured['created_at']
return structured
def mutate(self, info, article_ids):
is_article_ids_exist = mongo.db.articles.find(
{'_id': {
'$all': article_ids
}})
if is_article_ids_exist is None:
return ArchiveArticle(
archived_articles=[],
response=ResponseMessage(
text='Artikel tidak ditemukan, artikel gagal tersimpan',
status=False))
articles = list(mongo.db.articles.find({'_id': {'$in': article_ids}}))
is_user_articles_exist = mongo.db.user_articles.find_one(
{'user_id': ObjectId(get_jwt_identity())})
if is_user_articles_exist is None:
create_user_articles = mongo.db.user_articles.insert_one({
'_id':
get_sequence('user_articles'),
'user_id':
ObjectId(get_jwt_identity()),
'archived_articles': []
})
if create_user_articles.inserted_id is None:
return ArchiveArticle(
archived_articles=[],
response=ResponseMessage(
text=
'Tidak dapat membuat user_articles baru, artikel gagal tersimpan',
status=False))
is_already_archived = mongo.db.user_articles.find_one({
'user_id':
ObjectId(get_jwt_identity()),
'archived_articles': {
'$in': article_ids
}
})
if is_already_archived:
return ArchiveArticle(archived_articles=[],
response=ResponseMessage(
text='Artikel ini sudah tersimpan',
status=False))
result = mongo.db.user_articles.update_one(
{'user_id': ObjectId(get_jwt_identity())},
{'$push': {
'archived_articles': {
'$each': article_ids
}
}})
if result.modified_count == 0:
return ArchiveArticle(
archived_articles=[],
response=ResponseMessage(
text='Terjadi kendala pada server, artikel gagal tersimpan',
status=False))
return ArchiveArticle(archived_articles=articles,
response=ResponseMessage(
text='Artikel tersimpan', status=True))
def mutate(self, info, fields, header_img_upload):
if validate_datetime(fields.posted_at, 'date') is False:
return CreateArticle(
updated_article=None,
response=ResponseMessage(
text='Format tanggal tidak valid, artikel gagal terbuat',
status=False))
is_article_title_exist = mongo.db.articles.find_one(
{'title': fields.title})
if is_article_title_exist:
return CreateArticle(
updated_article=None,
response=ResponseMessage(
text='Judul sudah terpakai, artikel gagal terbuat',
status=False))
fields = {
'_id':
get_sequence('articles'),
'title':
fields['title'],
'short_summary':
fields['short_summary'],
'author':
fields['author'],
'posted_at':
datetime.datetime.strptime(fields.posted_at,
datetime_format('date')),
'reviewed_by':
fields['reviewed_by'],
'header_img':
default_img,
'content':
fields['content'],
'url_name':
fields['title'].lower().replace(', ', ' ').replace(' ', '-'),
'url':
''
}
if header_img_upload.filename != 'default':
upload_result = cloudinary.uploader.upload(header_img_upload)
fields['header_img'] = upload_result['secure_url']
# file_name= formatted_file_name(header_img_upload.filename)
# header_img_upload.save(os.path.join(f"{upload_path}/images", file_name))
result = mongo.db.articles.insert_one(dict(fields))
if result.inserted_id is None:
return CreateArticle(
updated_article=None,
response=ResponseMessage(
text='Terjadi kesalahan pada server, artikel gagal terbuat',
status=False))
created_article = list(
mongo.db.articles.find({}).sort('_id', -1).limit(1))[0]
created_article['posted_at'] = created_article['posted_at'].date()
return CreateArticle(created_article=created_article,
response=ResponseMessage(
text='Berhasil menambahkan artikel baru',
status=True))
def mutate(self, info, fields):
is_user_activities_exist = mongo.db.user_activities.find_one(
{'user_id': ObjectId(get_jwt_identity())})
if is_user_activities_exist is None:
create_user_activities = mongo.db.user_activities.insert_one({
'_id':
get_sequence('user_activities'),
'user_id':
ObjectId(get_jwt_identity()),
'activity_categories': [{
'_id':
get_sequence_in_array('user_activities',
ObjectId(get_jwt_identity()),
'activity_categories'),
'category':
fields.category,
'activities': []
}]
})
if create_user_activities.inserted_id is None:
return CreateActivityCategory(
created_activity_category=None,
response=ResponseMessage(
text=
'Tidak dapat membuat user_activities baru, kategori aktivitas gagal ditambahkan',
status=False))
else:
activities = []
if 'activities' in fields and len(fields.activities) > 0:
is_activity_ids_exist = mongo.db.user_activities.find_one(
{'user_id': ObjectId(get_jwt_identity())}, {
'activity_categories': {
'$elemMatch': {
'category': None,
'activities._id': {
'$all': fields.activities
}
}
}
})
if 'activity_categories' not in is_activity_ids_exist:
return CreateActivityCategory(
created_activity_category=None,
response=ResponseMessage(
text=
'Id aktivitas tidak ditemukan, kategori aktivitas gagal ditambahkan',
status=False))
remove_activities_from_none_category = mongo.db.user_activities.update_one(
{
'user_id': ObjectId(get_jwt_identity()),
'activity_categories.category': None
}, {
'$pull': {
'activity_categories.$.activities': {
'_id': {
'$in': fields.activities
}
}
}
})
if remove_activities_from_none_category.modified_count == 0:
return CreateActivityCategory(
created_activity_category=None,
response=ResponseMessage(
text=
'Tidak dapat menghapus aktivitas dari kategori "None", kategori aktivitas gagal ditambahkan',
status=False))
activities = [
activity for activity in
is_activity_ids_exist['activity_categories'][0]
['activities'] if activity['_id'] in fields.activities
]
insert_on_user_activities = mongo.db.user_activities.update_one(
{'user_id': ObjectId(get_jwt_identity())}, {
'$push': {
'activity_categories': {
'_id':
get_sequence_in_array('user_activities',
ObjectId(get_jwt_identity()),
'activity_categories'),
'category':
fields.category,
'activities':
activities
}
}
})
if insert_on_user_activities.modified_count == 0:
return CreateActivityCategory(
created_activity_category=None,
response=ResponseMessage(
text=
'Tidak dapat menyimpan pada user_activities collection, kategori aktivitas gagal ditambahkan',
status=False))
created_activity_category = mongo.db.user_activities.aggregate([{
'$match': {
'user_id': ObjectId(get_jwt_identity())
}
}, {
'$addFields': {
'last_inserted': {
'$last': '$activity_categories'
}
}
}, {
'$project': {
'last_inserted': 1
}
}])
return CreateActivityCategory(
created_activity_category=list(
created_activity_category)[0]['last_inserted'],
response=ResponseMessage(
text='Berhasil menambahkan kategori aktivitas baru',
status=True))
def mutate(self, info, fields, activity_category_id):
is_user_activities_exist = mongo.db.user_activities.find_one(
{'user_id': ObjectId(get_jwt_identity())})
query_conditions = {
'query_filter': {
'user_id': ObjectId(get_jwt_identity())
},
'$elemMatch': {}
}
if is_user_activities_exist is None:
create_user_activities = mongo.db.user_activities.insert_one({
'_id':
get_sequence('user_activities'),
'user_id':
ObjectId(get_jwt_identity()),
'activity_categories': [{
'_id':
get_sequence_in_array('user_activities',
ObjectId(get_jwt_identity()),
'activity_categories'),
'category':
None,
'activities': [{
'_id':
get_sequence_in_array('user_activities',
ObjectId(get_jwt_identity()),
'activities'),
'name':
fields.name,
'icon':
fields.icon
}]
}]
})
if create_user_activities.inserted_id is None:
return CreateActivity(
created_activity=None,
response=ResponseMessage(
text=
'Tidak dapat membuat user_activities baru, aktivitas gagal ditambahkan',
status=False))
else:
if activity_category_id == 0:
is_none_category_exist = mongo.db.user_activities.find_one({
'user_id':
ObjectId(get_jwt_identity()),
'activity_categories.category':
None
})
if is_none_category_exist is None:
create_none_category = mongo.db.user_activities.update_one(
{'user_id': ObjectId(get_jwt_identity())}, {
'$push': {
'activity_categories': {
'_id':
get_sequence_in_array(
'user_activities',
ObjectId(get_jwt_identity()),
'activity_categories'),
'category':
None,
'activities': []
}
}
})
if create_none_category.modified_count == 0:
return CreateActivity(
created_activity=None,
response=ResponseMessage(
text=
'Tidak dapat membuat kategori "None", aktivitas gagal ditambahkan',
status=False))
query_conditions['query_filter'][
'activity_categories.category'] = None
query_conditions['$elemMatch'] = {'category': None}
else:
is_category_id_exist = mongo.db.user_activities.find_one(
{'user_id': ObjectId(get_jwt_identity())}, {
'activity_categories': {
'$elemMatch': {
'_id': activity_category_id
}
}
})
if 'activity_categories' not in is_category_id_exist:
return CreateActivity(
created_activity=None,
response=ResponseMessage(
text=
'Kategori aktivitas tidak ditemukan, aktivitas gagal ditambahkan',
status=False))
query_conditions['query_filter'][
'activity_categories._id'] = activity_category_id
query_conditions['$elemMatch'] = {'_id': activity_category_id}
insert_on_user_activities = mongo.db.user_activities.update_one(
query_conditions['query_filter'], {
'$push': {
'activity_categories.$.activities': {
'_id':
get_sequence_in_array('user_activities',
ObjectId(get_jwt_identity()),
'activities'),
'name':
fields.name,
'icon':
fields.icon
}
}
})
if insert_on_user_activities.modified_count == 0:
return CreateActivity(
created_activity=None,
response=ResponseMessage(
text=
'Tidak dapat menyimpan pada user_activities collection, aktivitas gagal ditambahkan',
status=False))
created_activity = mongo.db.user_activities.find_one(
{'user_id': ObjectId(get_jwt_identity())}, {
'activity_categories': {
'$elemMatch': query_conditions['$elemMatch']
}
})
return CreateActivity(
created_activity=created_activity['activity_categories'][0]
['activities'][-1],
response=ResponseMessage(
text='Berhasil menambahkan aktivitas baru', status=True))
def mutate(self, info, fields):
if validate_datetime(
f"{fields.created_at.date} {fields.created_at.time}") is False:
return CreateMood(
created_mood=None,
response=ResponseMessage(
text=
'Format tanggal dan waktu tidak sesuai, mood gagal ditambahkan',
status=False))
activities = []
if len(fields.activities) > 0:
is_activity_ids_exist = mongo.db.user_activities.find_one({
'user_id':
ObjectId(get_jwt_identity()),
'activity_categories.activities._id': {
'$all': fields.activities
}
})
if is_activity_ids_exist is None:
return CreateMood(
created_mood=None,
response=ResponseMessage(
text=
'Aktivitas tidak ditemukan, mood gagal ditambahkan',
status=False))
activities = get_activities_from_user(fields.activities,
ObjectId(get_jwt_identity()))
fields = {
'_id':
get_sequence('moods'),
'emoticon':
fields['emoticon'],
'created_at':
datetime.datetime.strptime(
f"{fields.created_at.date} {fields.created_at.time}",
'%Y-%m-%d %H:%M'),
'parameters':
fields['parameters'],
'activities':
activities,
'note':
fields['note']
}
result = mongo.db.moods.insert_one(dict(fields))
if result.inserted_id is None:
return CreateMood(
created_mood=None,
response=ResponseMessage(
text=
'Tidak dapat menyimpan pada moods collection, mood gagal ditambahkan',
status=False))
is_user_moods_exist = mongo.db.user_moods.find_one(
{'user_id': ObjectId(get_jwt_identity())})
if is_user_moods_exist is None:
create_user_moods = mongo.db.user_moods.insert_one({
'_id':
get_sequence('user_moods'),
'user_id':
ObjectId(get_jwt_identity()),
'moods': [result.inserted_id]
})
if create_user_moods.inserted_id is None:
return CreateMood(
created_mood=None,
response=ResponseMessage(
text=
'Tidak dapat membuat user_moods baru, mood gagal ditambahkan',
status=False))
else:
insert_on_user_moods = mongo.db.user_moods.update_one(
{'user_id': ObjectId(get_jwt_identity())},
{'$push': {
'moods': result.inserted_id
}})
if insert_on_user_moods.modified_count == 0:
return CreateMood(
created_mood=None,
response=ResponseMessage(
text=
'Tidak dapat menyimpan pada user_moods collection, mood gagal ditambahkan',
status=False))
created_mood = mongo.db.moods.find_one({'_id': result.inserted_id})
created_mood['created_at'] = {
'date': created_mood['created_at'].date(),
'time': str(created_mood['created_at'].time())[:-3]
}
return CreateMood(created_mood=created_mood,
response=ResponseMessage(
text='Berhasil menambahkan mood baru',
status=True))
def mutate(self, info, fields):
#start validation check
if validate_datetime(fields.goal_dates.start, 'date') is False:
return CreateHabit(
created_habit=None,
response=ResponseMessage(
text=
'Format tanggal dimulai tidak sesuai, habit gagal diperbarui',
status=False))
if validate_datetime(fields.goal_dates.end, 'date') is False:
return CreateHabit(
created_habit=None,
response=ResponseMessage(
text=
'Format tanggal selesai tidak sesuai, habit gagal diperbarui',
status=False))
if lesser_comparison_datetime(fields.goal_dates.start,
fields.goal_dates.end, 'date') is False:
return CreateHabit(
created_habit=None,
response=ResponseMessage(
text=
'Tanggal dimulai dan tanggal selesai tidak sesuai, habit gagal diperbarui',
status=False))
if fields.reminder_time != '' and validate_datetime(
fields.reminder_time, 'time') is False:
return CreateHabit(
created_habit=None,
response=ResponseMessage(
text=
'Format waktu pengingat tidak sesuai, habit gagal diperbarui',
status=False))
#end validation check
#start create habit and user habits
insert_on_habits = mongo.db.habits.insert_one(
dict(re_structure_habit_input(fields)))
if insert_on_habits.inserted_id is None:
return CreateHabit(
created_habit=None,
response=ResponseMessage(
text=
'Tidak dapat menyimpan pada habits collection, habit gagal ditambahkan',
status=False))
is_user_habits_exist = mongo.db.user_habits.find_one(
{'user_id': ObjectId(get_jwt_identity())})
#check if user habits exist or not
if is_user_habits_exist is None:
create_user_habits = mongo.db.user_habits.insert_one({
'_id':
get_sequence('user_habits'),
'user_id':
ObjectId(get_jwt_identity()),
'habits': [insert_on_habits.inserted_id]
})
if create_user_habits.inserted_id is None:
return CreateHabit(
created_habit=None,
response=ResponseMessage(
text=
'Tidak dapat membuat user_habits baru, habit gagal ditambahkan',
status=False))
else:
insert_on_user_habits = mongo.db.user_habits.update_one(
{'user_id': ObjectId(get_jwt_identity())},
{'$push': {
'habits': insert_on_habits.inserted_id
}})
if insert_on_user_habits.modified_count == 0:
return CreateHabit(
created_habit=None,
response=ResponseMessage(
text=
'Tidak dapat menyimpan pada user_habits collection, habit gagal ditambahkan',
status=False))
created_habit = mongo.db.habits.find_one(
{'_id': insert_on_habits.inserted_id})
#end create habit and user habits
#start create habit track
result = mongo.db.habit_tracks.insert_one({
'habit_id':
insert_on_habits.inserted_id,
'total_completed':
0,
'total_streaks':
0,
'streak_logs': [{
'start_date':
datetime.datetime.strptime(fields.goal_dates.start,
datetime_format('date')),
'end_date':
datetime.datetime.strptime(fields.goal_dates.end,
datetime_format('date')),
'current_goal':
0,
'target_goal':
created_habit['goal'],
'last_marked_at':
None,
'is_complete':
False,
'marked_at': []
}]
})
if result.inserted_id is None:
return CreateHabit(
created_habit=None,
response=ResponseMessage(
text=
'Tidak dapat membuat habit track baru, habit gagal ditambahkan',
status=False))
created_habit_track = mongo.db.habit_tracks.find_one(
{'habit_id': insert_on_habits.inserted_id})
#end create habit streak logs
return CreateHabit(
created_habit=re_structure_habit_output(created_habit,
created_habit_track),
response=ResponseMessage(text='Berhasil menambahkan habit baru',
status=True))