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)