def decorated_function(view, request, *args, **kwargs):
cookie = request._request.COOKIES.get(COOKIE_NAME, '')
decrypted_cookie, user = check_cookie(cookie)
if user is None:
response = create_custom_response(
status.HTTP_401_UNAUTHORIZED,
{'reason': 'auth is required'}
)
if not request._request.COOKIES.get(TRKIR_UUID_NAME):
response.set_cookie(TRKIR_UUID_NAME, generate_salt())
return response
expires_date = get_cookie_expires_date_from_seconds(decrypted_cookie['expires'])
# TODO: Проверить токен google на expires и сделать refresh google токена,
# если истекает срок жизни (~ < 2 дней)
# TODO: Написать тесты на проверку даты
if expires_date < datetime.now():
response = create_custom_response(
status.HTTP_401_UNAUTHORIZED,
{'reason': 'cookie is expired'}
)
response.set_cookie(COOKIE_NAME, '', expires=0)
return response
params = {
'decrypted_cookie': decrypted_cookie,
'cookie': cookie,
'user_info': user,
}
return f(view, request, *args, **kwargs, user=params)
def change_mouse_status(self, request, user, pk=None): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
new_status = json.loads(request.body)['status']
model_object_dates = dict()
if ExperimentStatuses.validate_change_status(new_status):
if new_status == ExperimentStatuses.Start.value:
model_object_dates['date_start'] = timezone.now()
new_status = ExperimentStatuses.Continue.value
if new_status == ExperimentStatuses.Complete.value:
model_object_dates['date_end'] = timezone.now()
model_object = {
**model_object_dates,
'status': new_status,
}
Mice.objects.filter(user_id=user_id,
pk=pk).update(**model_object)
mouse_experiment_id = model_to_dict(
Mice.objects.get(id=pk))['experiment']
WatcherRequests.manage_experiment_watcher(
experiment_id=mouse_experiment_id,
status=ExperimentWatcherRequests.Update.value)
else:
return create_custom_response(status.HTTP_400_BAD_REQUEST,
{'reason': 'wrong status'})
return create_custom_response(status.HTTP_200_OK)
except Exception:
return create_custom_response(status.HTTP_400_BAD_REQUEST)
def get_mouse_average_healthy(self, request, user, pk=None): # pylint: disable=unused-argument
try:
average_frames_count = int(
request.GET.get(
'average_frames_count',
Defaults.AverageFramesCount.value,
))
try:
meta = AverageFeaturesMeta.objects.get(
average_frames_value=average_frames_count)
except Exception:
return create_custom_response(
status.HTTP_400_BAD_REQUEST,
{'reason': 'no features with this average value'})
average_healthy = {
'color': get_random_color(),
'data': list(
AverageHealthyMice.objects \
.filter(
mouse=pk,
meta=meta,
)
.order_by('date')
.values(*FEATURES_FIELDS)
)
}
return create_custom_response(status.HTTP_200_OK,
{'average_healthy': average_healthy})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def make_mouse_boxplot(self, request, user, pk=None): # pylint: disable=unused-argument
try:
try:
meta = AverageFeaturesMeta.objects.get(
average_frames_value=Defaults.AverageFramesCount.value)
except Exception:
return create_custom_response(
status.HTTP_400_BAD_REQUEST, {
'reason':
'no meta for average features (create average features first)'
})
features = models_to_list(
AveragedMiceFeatures.objects.filter(
mouse=pk,
meta=meta.id,
).order_by('date'))
# TODO: boxplots
boxplot = BoxPlot.create(features)
db_boxplot = [
MiceBoxPlot(**{
**boxplot[index],
'mouse_id': pk,
}) for index in range(len(boxplot))
]
MiceBoxPlot.objects.filter(mouse=pk).delete()
MiceBoxPlot.objects.bulk_create(db_boxplot)
return create_custom_response(status.HTTP_200_OK, )
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_mouse_normalized_features(self, request, user, pk=None): # pylint: disable=unused-argument
try:
normalization_method = request.GET.get(
'method',
Defaults.NormalizationMethod.value,
)
features_count = int(
request.GET.get(
'features_count',
Defaults.FeaturesCount.value,
))
features = {
'color': get_random_color(),
'data': list(
NormalizedMiceFeatures.objects \
.filter(
mouse=pk,
normalization_method=normalization_method,
)
.order_by('date')
.values(*FEATURES_FIELDS)
)[-features_count:]
}
return create_custom_response(status.HTTP_200_OK,
{'features': features})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def create_from_favorites(self, request, user): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
request_data = json.loads(request.body)
is_clear_favorites = request_data.get('clear_favorites', False)
if 'clear_favorites' in request_data.keys():
del request_data['clear_favorites']
project_data = {**request_data, 'user_id': user_id}
project = AnalysisProjects.objects.create(**project_data)
favorite_mice_ids = list(
FavoriteMice.objects.filter(user_id=user_id).values_list(
'mouse', flat=True))
mice = Mice.objects.filter(id__in=favorite_mice_ids)
mice = [
AnalysisMouseRelation(analysis_project=project, mouse=mouse)
for mouse in mice
]
AnalysisMouseRelation.objects.bulk_create(mice)
if is_clear_favorites:
FavoriteMice.objects.filter(user_id=user_id).delete()
return create_custom_response(status.HTTP_201_CREATED,
{'project': project.id})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def decorated_function(view, request, *args, **kwargs):
data = request.GET \
if request.method == 'GET' else \
json.loads(request.body)
for key in keys:
try:
is_key_exists = get(data, key.split('.'))
if is_key_exists is None:
return create_custom_response(
status.HTTP_400_BAD_REQUEST,
{
'error':
'{} {}'.format(BAD_KEYS_ERROR, ', '.join(keys))
},
)
except Exception:
return create_custom_response(
status.HTTP_400_BAD_REQUEST,
{
'error':
'{} {}'.format(BAD_KEYS_ERROR, ', '.join(keys))
},
)
return f(view, request, *args, **kwargs)
def get_statuses(self, request, user): # pylint: disable=unused-argument
try:
return create_custom_response(
status.HTTP_200_OK,
{'statuses': ExperimentStatuses.choices_to_json()})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def make_mouse_averaged_normalized_features(self, request, user, pk=None): # pylint: disable=unused-argument
try:
request_data = json.loads(request.body)
average_frames_count = int(
request_data.get(
'average_frames_count',
Defaults.AverageFramesCount.value,
))
normalization_method = request_data.get(
'method', Defaults.NormalizationMethod.value)
meta, _ = AverageFeaturesMeta.objects.get_or_create(
average_frames_value=average_frames_count)
# find latest date added before
try:
latest_added_date = AveragedNormalizedMiceFeatures.objects\
.filter(
mouse=pk,
normalization_method=normalization_method,
meta=meta.id,
)\
.latest(FeatureNames.Date.value).date
except Exception:
latest_added_date = datetime.min
averaged_features = models_to_list(
AveragedMiceFeatures.objects.filter(
mouse=pk,
meta=meta.id,
date__gt=latest_added_date,
).order_by('date'))
averaged_normalized_features = Preprocessing.normalize_features(
averaged_features, normalization_method)
db_averaged_normalized_features = [
AveragedNormalizedMiceFeatures(
**{
**averaged_normalized_features[features_index],
'mouse_id':
pk,
'normalization_method':
normalization_method,
'meta':
meta,
})
for features_index in range(len(averaged_normalized_features))
]
AveragedNormalizedMiceFeatures.objects.bulk_create(
db_averaged_normalized_features)
return create_custom_response(status.HTTP_200_OK, )
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_mouse_heatmap(self, request, user, pk=None): # pylint: disable=unused-argument
try:
heatmap = list(
MiceHeatMap.objects.filter(mouse=pk).values(*HEATMAP_FIELDS))
return create_custom_response(status.HTTP_200_OK,
{'heatmap': heatmap})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_mouse_boxplot(self, request, user, pk=None): # pylint: disable=unused-argument
try:
boxplot = list(
MiceBoxPlot.objects.filter(mouse=pk).values(*BOXPLOT_FIELDS))
return create_custom_response(status.HTTP_200_OK,
{'boxplot': boxplot})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def update_info(self, request, user, pk=None): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
update_fields = json.loads(request.body)
Mice.objects.filter(user_id=user_id, pk=pk).update(**update_fields)
return create_custom_response(status.HTTP_200_OK)
except Exception:
return create_custom_response(status.HTTP_400_BAD_REQUEST)
def list(self, request, user): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
cameras = list(Cameras.objects.filter(user_id=user_id))
return create_custom_response(status.HTTP_200_OK,
{'cameras': models_to_list(cameras)})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def retrieve(self, request, user, pk=None): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
camera = model_to_dict(Cameras.objects.get(user_id=user_id, id=pk))
return create_custom_response(status.HTTP_200_OK,
{'camera': camera})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def delete(self, request, user): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
mouse_ids = json.loads(request.body)['mouse_ids']
FavoriteMice.objects.filter(user_id=user_id, mouse_id__in=mouse_ids).delete()
return create_custom_response(status.HTTP_200_OK)
except Exception:
return create_custom_response(status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_mouse_time_warping(self, request, user, pk=None): # pylint: disable=unused-argument
try:
time_warping = list(
MiceTimeWarping.objects.filter(mouse=pk).values(
*TIME_WARPING_FIELDS))
return create_custom_response(status.HTTP_200_OK,
{'time_warping': time_warping})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def update(self, request, user, pk=None): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
update_fields = json.loads(request.body)
Cameras.objects.filter(user_id=user_id,
pk=pk).update(**update_fields)
return create_custom_response(status.HTTP_200_OK)
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_project_pca(self, request, user, pk=None): # pylint: disable=unused-argument
try:
is_days = True if request.GET['is_days'] else False
project_pca = list(
AnalysisPCA.objects.filter(
analysis_project=pk, is_days=is_days).values(*PCA_FIELDS))
return create_custom_response(status.HTTP_200_OK,
{'project_pca': project_pca})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def create(self, request, user): # pylint: disable=unused-argument
try:
request_data = json.loads(request.body)
camera_data = {**request_data, 'user_id': user['user_info']['id']}
camera = Cameras.objects.create(**camera_data)
return create_custom_response(status.HTTP_201_CREATED,
{'camera': camera.id})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def get_mouse_seasonal_decomposition(self, request, user, pk=None): # pylint: disable=unused-argument
try:
seasonal_decomposition = list(
MiceSeasonalDecomposition.objects.filter(mouse=pk).values(
*SEASONAL_DECOMPOSITION_FIELDS))
return create_custom_response(
status.HTTP_200_OK,
{'seasonal_decomposition': seasonal_decomposition})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def delete(self, request, user): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
request_data = json.loads(request.body)
camera_ids = request_data['camera_ids']
Cameras.objects.filter(user_id=user_id, id__in=camera_ids).delete()
return create_custom_response(status.HTTP_200_OK)
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def list(self, request, user): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
projects = list(AnalysisProjects.objects.filter(user_id=user_id))
projects = filter_experiments(projects,
request.GET.get('filters', {}))
return create_custom_response(status.HTTP_200_OK,
{'projects': projects})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def set_virus(self, request, user, pk=None): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
virus = json.loads(request.body)['virus']
Mice.objects.filter(user_id=user_id,
pk=pk).update(virus=virus,
date_virus=timezone.now())
return create_custom_response(status.HTTP_200_OK)
except Exception:
return create_custom_response(status.HTTP_400_BAD_REQUEST)
def logout(self, request, user): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
cookie = request._request.COOKIES.get(COOKIE_NAME, '')
response = create_custom_response(status.HTTP_200_OK)
response.set_cookie(COOKIE_NAME, '', expires=0)
Cookies.objects.filter(user_id=user_id, cookie=cookie).delete()
return response
except Exception:
return create_custom_response(status.HTTP_500_INTERNAL_SERVER_ERROR)
def make_mouse_normalized_average_healthy(self, request, user, pk=None): # pylint: disable=unused-argument
try:
request_data = json.loads(request.body)
average_frames_count = int(
request_data.get(
'average_frames_count',
Defaults.AverageFramesCount.value,
))
normalization_method = request_data.get(
'method', Defaults.NormalizationMethod.value)
meta, _ = AverageFeaturesMeta.objects.get_or_create(
average_frames_value=average_frames_count)
averaged_normalized_features = models_to_list(
AveragedNormalizedMiceFeatures.objects.filter(
mouse=pk,
meta=meta.id,
normalization_method=normalization_method,
).order_by('date'))
normalized_average_healthy = Preprocessing.create_average_healthy(
averaged_normalized_features, )
db_normalized_average_healthy = [
NormalizedAverageHealthyMice(
**{
**normalized_average_healthy[features_index],
'mouse_id': pk,
'normalization_method': normalization_method,
'meta': meta,
})
for features_index in range(len(normalized_average_healthy))
]
NormalizedAverageHealthyMice.objects\
.filter(
mouse=pk,
normalization_method=normalization_method,
meta=meta.id,
)\
.delete()
NormalizedAverageHealthyMice.objects.bulk_create(
db_normalized_average_healthy)
return create_custom_response(status.HTTP_200_OK, )
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def make_experiment_pca(self, request, user, pk=None): # pylint: disable=unused-argument
try:
try:
meta = AverageFeaturesMeta.objects.get(
average_frames_value=Defaults.AverageFramesCount.value)
except Exception:
return create_custom_response(
status.HTTP_400_BAD_REQUEST, {
'reason':
'no meta for average features (create average features first)'
})
is_days = json.loads(request.body)['is_days']
experiment_mice = Mice.objects \
.filter(experiment=pk). \
values_list('id', flat=True)
mice_features = {
mouse_id: models_to_list(
AveragedMiceFeatures.objects.filter(
mouse=mouse_id,
meta=meta.id,
).order_by('date'))
for mouse_id in experiment_mice
}
experiment_pca = PCA.create(mice_features, is_days=is_days)
ExperimentsPCA.objects.filter(
experiment=pk,
is_days=is_days,
).delete()
db_experiment_pca = [
ExperimentsPCA(
**{
**experiment_pca[index],
'experiment_id': pk,
'meta': meta,
'is_days': is_days,
}) for index in range(len(experiment_pca))
]
ExperimentsPCA.objects.bulk_create(db_experiment_pca)
return create_custom_response(status.HTTP_200_OK, )
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def retrieve(self, request, user, pk=None): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
project = model_to_dict(
AnalysisProjects.objects.get(user_id=user_id, id=pk))
project_mice = AnalysisMouseRelation.objects.filter(
analysis_project=pk)
project['mice'] = models_to_list(project_mice)
return create_custom_response(status.HTTP_200_OK,
{'project': project})
except Exception:
return create_custom_response(
status.HTTP_500_INTERNAL_SERVER_ERROR)
def list(self, request, user): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
favorite_mice_ids = FavoriteMice.objects\
.filter(user_id=user_id)\
.values_list('mouse', flat=True)
mice = models_to_list(Mice.objects.filter(id__in=favorite_mice_ids))
return create_custom_response(
status.HTTP_200_OK,
{'favorite': mice}
)
except Exception:
return create_custom_response(status.HTTP_500_INTERNAL_SERVER_ERROR)
def set_cookie(cookie, expires, data=None):
if data is None:
data = {}
response = create_custom_response(status.HTTP_200_OK, data)
response.set_cookie(COOKIE_NAME, cookie, expires=expires)
return response
def add_mice(self, request, user): # pylint: disable=unused-argument
try:
user_id = user['user_info']['id']
mouse_ids = json.loads(request.body)['mouse_ids']
favorite_mice = [
FavoriteMice(user_id=user_id, mouse_id=mouse_id)
for mouse_id in mouse_ids
]
FavoriteMice.objects.bulk_create(favorite_mice)
return create_custom_response(
status.HTTP_201_CREATED,
)
except Exception:
return create_custom_response(status.HTTP_500_INTERNAL_SERVER_ERROR)
