def add_person_to_group(cls, request): request_data = cls.parse_add_person_to_group(request) if request_data: try: check_person = People.objects.get( person_id=request_data.get(KEY_PERSON_ID), project_id=Project.objects.get( project_id=request_data.get(KEY_PROJECT_ID))) group_arr = request.data.get(KEY_GROUP_ARRAY) for group in group_arr: check_group = PeopleGroup.objects.get( people_group_code=group, project_id=Project.objects.get( project_id=request_data.get(KEY_PROJECT_ID))) check_person_xref = XrefPeopleGroup.objects.filter( person_id=check_person, people_group_id=check_group) if not check_person_xref: result = XrefPeopleGroup.objects.create( person_id=check_person, people_group_id=check_group, ) if not result: return Result.failed( message= 'Have some problem when add person to group!') else: return Result.failed( message='This person already in this group!') return Result.success(message='Add person to group success!') except (People.DoesNotExist, PeopleGroup.DoesNotExist): return Result.failed( message='Person id or group id not exist!') else: return Result.failed(message='Missing data in the request!')
def get_camera_group_data(cls, request): camera_group_id = request.GET['camera_group_id'] if camera_group_id: try: check_group = CameraGroup.objects.get( camera_group_id=camera_group_id, status=DEFAULT_STATUS_ACTIVE ) result = { KEY_CAMERA_GROUP_ID: check_group.camera_group_id, KEY_CAMERA_GROUP_NAME: check_group.camera_group_name, KEY_CAMERA_GROUP_COLOR: check_group.camera_group_color, } return Result.success( message='Get group success', data=result ) except CameraGroup.DoesNotExist: return Result.failed( message='Group doesnt exist!' ) else: return Result.failed( message='Missing data in the request!' )
def delete_camera_group(cls, request): try: camera_group_id = request.GET['camera_group_id'] delete_group = CameraGroup.objects.get(camera_group_id=camera_group_id) if delete_group: try: xref_camera_group = XrefCameraGroup.objects.select_related('camera_group_id') \ .filter(camera_group_id=camera_group_id) delete_group.status = DEFAULT_STATUS_DEACTIVE delete_group.save() xref_camera_group.delete() return Result.success( message='Delete group success!', ) except CameraGroup.DoesNotExist: return Result.failed( message='CameraGroup matching query does not exist' ) else: return Result.failed( message='Group doesnt exist' ) except CameraGroup.DoesNotExist: return Result.failed( message='CameraGroup matching query does not exist!' ) except Exception as exc: return Result.failed( message=f'Missing data from request: {exc}' )
def delete_camera(cls, request): result_delete_camera = cls.parse_delete_camera_data(request) if result_delete_camera: try: check_camera = Camera.objects.get( camera_id=result_delete_camera.get(KEY_CAMERA_ID), project_id=result_delete_camera.get(KEY_PROJECT_ID)) xref_people_group = XrefCameraGroup.objects.select_related('camera_id') \ .filter(camera_id=result_delete_camera[KEY_CAMERA_ID]) xref_people_group.delete() process_running = list(Process.objects.filter( camera_id=Camera.objects.get( camera_id=result_delete_camera.get(KEY_CAMERA_ID) ) ).values()) for process in process_running: process_cur = Process.objects.get( process_id=process['process_id'] ) process_cur.delete() check_camera.status = DEFAULT_STATUS_DEACTIVE check_camera.save() return Result.success( message='Success delete camera' ) except Camera.DoesNotExist: return Result.failed( message='There is no camera with this ID!' ) else: return Result.failed( message='Missing data in the request!' )
def choose_project(cls, request): user_information = jwt.decode( cls.parse_request_user_data(request).get('token'), SECRET_TOKEN_KEY) project_code = request.GET['project_code'] if project_code: result_choose_project = Project.objects.filter( project_code=project_code, status=DEFAULT_STATUS_ACTIVE, owner_user_id=user_information[KEY_USER_ID], ) if result_choose_project: chose_project = list(result_choose_project.values())[0] result = { KEY_PROJECT_ID: chose_project.get(KEY_PROJECT_ID), KEY_PROJECT_NAME: chose_project.get(KEY_PROJECT_NAME), KEY_PROJECT_CODE: chose_project.get(KEY_PROJECT_CODE), KEY_PROJECT_SECRET_KEY: chose_project.get(KEY_PROJECT_SECRET_KEY), } return Result.success(message='Choose project success!', data=result) else: return Result.failed(message='Project does not exist') else: return Result.failed(message='Failed to choose project!')
def check_all_url(cls, request): project_id = request.GET['project_id'] if project_id: try: all_camera = list(Camera.objects.filter( status=DEFAULT_STATUS_ACTIVE, project_id=Project.objects.get(project_id=project_id) ).values()) except Project.DoesNotExist: return Result.failed( message='Project doesnt exist!!' ) list_status = [] for camera in all_camera: item = { KEY_CAMERA_ID: camera.get(KEY_CAMERA_ID), 'status': cls.check_camera_available(camera.get('stream_url')) } list_status.append(item) print(list_status) return Result.success( message='Status of all cameras', data=list_status ) else: return Result.failed( message='Missing data from request!!' )
def set_avatar(cls, request): user_information = jwt.decode( cls.parse_request_user_data(request).get('token'), SECRET_TOKEN_KEY) user_id = user_information[KEY_USER_ID] avatar = request.FILES['avatar'] try: XrefAvatarUser.objects.get(user_id=User.objects.get( user_id=user_id)).delete() except XrefAvatarUser.DoesNotExist: return Result.failed(message='Some data error!') _, serve_urls, exc = StaticServing.save_res( [avatar], ['user_avatar', f'{user_id}']) if exc is not None: raise IOError(f'Save image file failed: {exc}') img_url = serve_urls[0] try: result_create_avatar = XrefAvatarUser.objects.create( user_id=User.objects.get(user_id=user_id), avatar_file=img_url, ) except Exception as exc: # log.error(f'Save person image to db failed: {exc}') return Result.failed( message=f'Save person image to db failed: {exc}') if not result_create_avatar: return Result.failed( message='Have some problem when add image data!') return Result.success(message='Success set avatar!')
def delete_person_from_group(cls, request): request_data = cls.parse_delete_person_from_group_data(request) if request_data: try: check_person = People.objects.get( person_id=request_data.get(KEY_PERSON_ID), project_id=Project.objects.get( project_id=request_data.get(KEY_PROJECT_ID))) check_group = PeopleGroup.objects.get( people_group_id=request_data.get(KEY_PEOPLE_GROUP_ID)) result = XrefPeopleGroup.objects.filter( person_id=check_person, people_group_id=check_group, ) if result: result.delete() return Result.success( message='Delete person from group success!') else: return Result.failed( message='Have some problem when delete person to group!' ) except (People.DoesNotExist, PeopleGroup.DoesNotExist, Project.DoesNotExist): return Result.failed( message='Person id or group id not exist!') else: return Result.failed(message='Missing data in the request!')
def create(cls, request): # Get user information user = cls.parse_create_user_data(request) if user: result_check_username = User.objects.filter( username=user[KEY_USER_NAME]).values() result_check_email = User.objects.filter( email=user[KEY_USER_EMAIL]).values() # Check username is existed if not result_check_username.exists(): # Check email is existed if not result_check_email.exists(): # Create new user result_create_user = User.objects.create( username=user[KEY_USER_NAME], email=user[KEY_USER_EMAIL], password=cls.generate_password( user[KEY_USER_PASSWORD]), full_name=user[KEY_USER_FIRSTNAME] + user[KEY_USER_LASTNAME], role=DEFAULT_ADMIN_ROLE) # Check create user if result_create_user: # Retrive user after create new_user_query_set = User.objects.filter( username=user[KEY_USER_NAME]).values() new_user = list(new_user_query_set)[0] # Create new token # Check update new token for user result = { KEY_USER_ID: new_user.get(KEY_USER_ID), } profile_user = Profile.objects.create( first_name=user[KEY_USER_FIRSTNAME], last_name=user[KEY_USER_LASTNAME], user_id=User.objects.get( user_id=new_user.get(KEY_USER_ID))) if not profile_user: return Result.failed( message='Fail to create profile!', ) return Result.success( message='New user registration success!', data=result) else: return Result.failed( message='There was an error in creating new user!') else: return Result.failed(message='Email exists', ) else: return Result.failed(message='Username exists!', ) else: return Result.failed( message='User information not contained in the request!')
def add_camera_group(cls, request): result_group_data = cls.parse_add_camera_group_data(request) if result_group_data: check_group_exist = CameraGroup.objects.filter( project_id=result_group_data[KEY_PROJECT_ID], camera_group_name=result_group_data[KEY_CAMERA_GROUP_NAME], status=DEFAULT_STATUS_ACTIVE, ) if not check_group_exist: check_color_exist = CameraGroup.objects.filter( camera_group_color=result_group_data[KEY_CAMERA_GROUP_COLOR], status=DEFAULT_STATUS_ACTIVE, ) if not check_color_exist: try: result_group = CameraGroup.objects.create( project_id=Project.objects.get(project_id=result_group_data[KEY_PROJECT_ID]), camera_group_name=result_group_data[KEY_CAMERA_GROUP_NAME], camera_group_color=result_group_data[KEY_CAMERA_GROUP_COLOR], status=DEFAULT_STATUS_ACTIVE, ) except Project.DoesNotExist: return Result.failed( message='Project doesnt exist' ) if result_group: new_group_id = CameraGroup.objects.get( camera_group_name=result_group_data[KEY_CAMERA_GROUP_NAME], status=DEFAULT_STATUS_ACTIVE ).camera_group_id new_group = CameraGroup.objects.filter( camera_group_id=new_group_id) new_group_data = list(new_group.values())[0] return Result.success( message='New camera group has been created', data=new_group_data ) else: return Result.failed( message='Have some problem when create new camera group' ) else: return Result.failed( message='This group color already existed in this project' ) else: return Result.failed( message='This group code already existed in this project' ) else: return Result.failed( message='Missing data in the request!' )
def add_camera(cls, request): result_camera = cls.parse_add_camera_data(request) if result_camera: check_camera = Camera.objects.filter( camera_name=result_camera[KEY_CAMERA_NAME], project_id=Project.objects.get( project_id=result_camera[KEY_PROJECT_ID]), ).values() if not check_camera: result_create_camera = Camera.objects.create( camera_name=result_camera[KEY_CAMERA_NAME], stream_url=result_camera[KEY_STREAM_URL], project_id=Project.objects.get(project_id=result_camera[KEY_PROJECT_ID]), status=DEFAULT_STATUS_ACTIVE, is_running=True, ) if result_create_camera: camera_just_created = list(Camera.objects.filter( camera_name=result_camera[KEY_CAMERA_NAME], status=DEFAULT_STATUS_ACTIVE, ).values())[0] group_array = request.data['group'] if len(group_array) != 0: for group in group_array: result_create_group_camera = XrefCameraGroup.objects.create( camera_id=Camera.objects.get( camera_id=camera_just_created.get(KEY_CAMERA_ID), status=DEFAULT_STATUS_ACTIVE, ), camera_group_id=CameraGroup.objects.get( camera_group_name=group, status=DEFAULT_STATUS_ACTIVE, ) ) if not result_create_group_camera: return Result.failed( message='Have some problem when create group!' ) return Result.success( message='Success add camera!' ) else: return Result.failed( message='Have some problem when add camera!' ) else: return Result.failed( message='Camera name already existed!' ) else: return Result.failed( message='Missing data in the request!' )
def create_project(cls, request): project = cls.parse_create_project_data(request) user_information = jwt.decode( cls.parse_request_user_data(request).get('token'), SECRET_TOKEN_KEY) if project[KEY_PROJECT_NAME] == '' or project[KEY_PROJECT_CODE] == '': return Result.failed( message='You need input project name and project code!') if project: result_check_project_code = Project.objects.filter( project_code=project[KEY_PROJECT_CODE], status=DEFAULT_STATUS_ACTIVE, owner_user_id=user_information[KEY_USER_ID], ).values() if not result_check_project_code.exists(): result_create_project = Project.objects.create( project_name=project[KEY_PROJECT_NAME], project_code=project[KEY_PROJECT_CODE], owner_user_id=user_information[KEY_USER_ID], status=DEFAULT_STATUS_ACTIVE) if result_create_project: try: result = Project.objects.get( project_code=project[KEY_PROJECT_CODE], status=DEFAULT_STATUS_ACTIVE) result.secret_key = cls.make_project_secret_key( result.project_id).upper() result.save() except Project.DoesNotExist: return Result.failed( message= 'There was an error in creating new project!') new_project_query_set = Project.objects.filter( project_code=project[KEY_PROJECT_CODE], status=DEFAULT_STATUS_ACTIVE).values() new_project = list(new_project_query_set)[0] result = { KEY_PROJECT_ID: new_project.get(KEY_PROJECT_ID), KEY_PROJECT_CODE: new_project.get(KEY_PROJECT_CODE), KEY_PROJECT_NAME: new_project.get(KEY_PROJECT_NAME), } return Result.success( message='Create new project success!', data=result) else: return Result.failed( message='There was an error in creating new project!') else: return Result.failed(message='Project code exists!', ) else: return Result.failed( message='Project data not contained in the request!')
def set_profile(cls, request): profile_data = cls.parse_set_profile_data(request) user_information = jwt.decode( cls.parse_request_user_data(request).get('token'), SECRET_TOKEN_KEY) user_id = user_information[KEY_USER_ID] if not profile_data: return Result.failed(message='Missing data in request!') profile = Profile.objects.get(user_id=User.objects.get( user_id=user_id)) profile.first_name = profile_data[KEY_USER_FIRSTNAME] profile.last_name = profile_data[KEY_USER_LASTNAME] profile.address = profile_data[KEY_PROFILE_ADDRESS] profile.company = profile_data[KEY_PROFILE_COMPANY] profile.save() try: avatar = request.FILES['avatar'] except Exception as exc: return Result.failed(message=f'Some data error!{exc}') print(request.FILES) if avatar: avatar_user = list( XrefAvatarUser.objects.filter(user_id=User.objects.get( user_id=user_id))) if avatar_user: try: XrefAvatarUser.objects.get(user_id=User.objects.get( user_id=user_id)).delete() except XrefAvatarUser.DoesNotExist: return Result.failed(message='Some data error!') _, serve_urls, exc = StaticServing.save_res( [avatar], ['user_avatar', f'{user_id}']) if exc is not None: raise IOError(f'Save image file failed: {exc}') img_url = serve_urls[0] try: result_create_avatar = XrefAvatarUser.objects.create( user_id=User.objects.get(user_id=user_id), avatar_file=img_url, ) except Exception as exc: # log.error(f'Save person image to db failed: {exc}') return Result.failed( message=f'Save person image to db failed: {exc}') if not result_create_avatar: return Result.failed( message='Have some problem when add image data!') return Result.success(message='Success change profile!')
def get_process(cls, request): process_id = request.GET['process_id'] if process_id: try: process = Process.objects.filter(process_id=process_id, ) except Process.DoesNotExist: return Result.failed(message='Process doesnt exist') get_process = list(process.values())[0] print(get_process.get('camera_id_id')) return Result.success(message="Get process successful", data=get_process) else: return Result.failed(message="Process id not exists", )
def delete_process(cls, request): process_id = request.GET['process_id'] if process_id: try: check_process = Process.objects.select_related('process_id') \ .filter(process_id=request.GET['process_id']) check_process.delete() return Result.success(message='Success delete process') except Camera.DoesNotExist: return Result.failed( message='There is no process with this ID!') else: return Result.failed(message='Missing data in the request!')
def get_avatar(cls, request): user_information = jwt.decode( cls.parse_request_user_data(request).get('token'), SECRET_TOKEN_KEY) if not user_information: return Result.failed(message='Missing data from request!') try: check_image = XrefAvatarUser.objects.get(user_id=User.objects.get( user_id=user_information[KEY_USER_ID])) link = check_image.avatar_file.split('/static') result = cls.image_as_base64(STATIC_DIR + link[1]) return Result.success(message='Get image of person success!', data=result) except (User.DoesNotExist, XrefAvatarUser.DoesNotExist): return Result.failed(message='User doesnt exist!')
def get_all_people_group(cls, request): project_id = request.GET['project_id'] if project_id: try: all_people_group = PeopleGroup.objects.filter( project_id=Project.objects.get(project_id=project_id), status=DEFAULT_STATUS_ACTIVE) except Project.DoesNotExist: return Result.failed(message='Project doesnt exist') list_all_people_group = list(all_people_group.values()) return Result.success(message='Get all group success', data=list_all_people_group) else: return Result.failed(message='Missing data in the request!')
def get_all_camera(cls, request): project_id = request.GET['project_id'] if project_id: try: all_camera = Camera.objects.filter( project_id=Project.objects.get(project_id=project_id), status=DEFAULT_STATUS_ACTIVE ) except Project.DoesNotExist: return Result.failed( message='Project doesnt exist' ) result = [] list_all_camera = list(all_camera.values()) for camera in list_all_camera: try: check_camera = Camera.objects.get( camera_id=camera.get('camera_id'), status=DEFAULT_STATUS_ACTIVE, ) group_list = [] xref_camera_group = list(XrefCameraGroup.objects.select_related('camera_id') .filter(camera_id=check_camera.camera_id).values()) for item in xref_camera_group: group_item = \ list(CameraGroup.objects.select_related('camera_group_id') .filter(camera_group_id=item.get('camera_group_id_id'), project_id=Project.objects.get(project_id=project_id)).values()) if len(group_item) > 0: group_list.append(group_item[0]) camera['group'] = group_list result.append(camera) except Camera.DoesNotExist: return Result.failed( message='Camera id not exist!' ) return Result.success( message='Get all camera success', data=result ) else: return Result.failed( message='Missing data in the request!' )
def livefe(request): try: return StreamingHttpResponse( gen(VideoCamera(request.GET['stream_url']), request), content_type='multipart/x-mixed-replace;boundary=frame') except: # This is bad! replace it with proper handling return Result.failed(message='Have some problems!')
def get_image_person(cls, request): request_data = cls.parse_get_image_person_data(request) if request_data: try: check_image = ResPeopleImage.objects.filter( person_id=People.objects.get( person_id=request_data[KEY_PERSON_ID])).values() result = [] for item in list(check_image): link = item.get('image_file').split('/static') result.append(cls.image_as_base64(STATIC_DIR + link[1])) return Result.success(message='Get image of person success!', data=result) except People.DoesNotExist: return Result.failed(message='Person doesnt exist!') else: return Result.failed(message='Missing data in the request!')
def get_people_group_data(cls, request): people_group_id = request.GET['people_group_id'] if people_group_id: try: check_group = PeopleGroup.objects.get( people_group_id=people_group_id) result = { KEY_PEOPLE_GROUP_ID: check_group.people_group_id, KEY_PEOPLE_GROUP_CODE: check_group.people_group_code, KEY_PEOPLE_GROUP_NAME: check_group.people_group_name, KEY_PEOPLE_GROUP_COLOR: check_group.people_group_color, } return Result.success(message='Get group success', data=result) except PeopleGroup.DoesNotExist: return Result.failed(message='Group doesnt exist!') else: return Result.failed(message='Missing data in the request!')
def add_camera_to_group(cls, request): request_data = cls.parse_add_camera_to_group(request) if request_data: try: check_camera = Camera.objects.get( camera_id=request_data.get(KEY_CAMERA_ID), project_id=Project.objects.get(project_id=request_data.get(KEY_PROJECT_ID)), status=DEFAULT_STATUS_ACTIVE ) group_arr = request.data.get(KEY_GROUP_ARRAY) for group in group_arr: check_group = CameraGroup.objects.get( camera_group_name=group, project_id=Project.objects.get(project_id=request_data.get(KEY_PROJECT_ID)), status=DEFAULT_STATUS_ACTIVE ) check_camera_xref = XrefCameraGroup.objects.filter( camera_id=check_camera, camera_group_id=check_group ) if not check_camera_xref: result = XrefCameraGroup.objects.create( camera_id=check_camera, camera_group_id=check_group, ) if not result: return Result.failed( message='Have some problem when add camera to group!' ) else: return Result.failed( message='This camera already in this group!' ) return Result.success( message='Add camera to group success!' ) except (Camera.DoesNotExist, CameraGroup.DoesNotExist): return Result.failed( message='Camera id or group id not exist!' ) else: return Result.failed( message='Missing data in the request!' )
def logout(cls, request): # Get user information user_information = jwt.decode( cls.parse_request_user_data(request).get('token'), SECRET_TOKEN_KEY) # Check user is existed if user_information: # Set user token is logout token_available = UserToken.objects.filter( user_id=user_information[KEY_USER_ID], token=cls.parse_request_user_data(request).get( 'token')).values().order_by('-created_at') if token_available.exists(): token_status_available = list( token_available)[0][KEY_TOKEN_STATUS] if token_status_available is DEFAULT_TOKEN_ACTIVE: # Set user token is logout result_logout = UserToken.objects.filter( user_id=user_information[KEY_USER_ID], token=cls.parse_request_user_data(request).get( 'token')).update(status=DEFAULT_TOKEN_DEACTIVE) if result_logout: return Result.success( message='Log out the user successfully!') else: return Result.failed( message= 'Can not sign out of account because your user credentials are not valid!' ) else: return Result.failed( message='Your account credentials expired!') else: return Result.failed( message='The token code you provided is not valid!') else: return Result.failed( message='User information not contained in the request!')
def update_camera_group(cls, request): result_group_data = cls.parse_update_camera_group_data(request) if result_group_data: camera_group_choose = CameraGroup.objects.filter( camera_group_id=result_group_data[KEY_CAMERA_GROUP_ID] ).values() if camera_group_choose: check_group_name = CameraGroup.objects.filter( ~Q(camera_group_id=result_group_data[KEY_CAMERA_GROUP_ID]), camera_group_name=result_group_data[KEY_CAMERA_GROUP_NAME], status=DEFAULT_STATUS_ACTIVE, ) check_group_color = CameraGroup.objects.filter( ~Q(camera_group_id=result_group_data[KEY_CAMERA_GROUP_ID]), camera_group_color=result_group_data[KEY_CAMERA_GROUP_COLOR], status=DEFAULT_STATUS_ACTIVE, ) if check_group_name: return Result.failed( message='This group name exists' ) elif check_group_color: return Result.failed( message='This group color exists' ) else: camera_group_choose.update(camera_group_name=result_group_data[KEY_CAMERA_GROUP_NAME], camera_group_color=result_group_data[KEY_CAMERA_GROUP_COLOR], updated_at=datetime.now()) return Result.success( message='Update group success!' ) else: return Result.failed( message='Group doesnt exist' ) else: return Result.failed( message='Missing data in the request!' )
def get_process_list(cls, request): project_id = request.GET['project_id'] if project_id: try: all_process = Process.objects.filter( project_id=Project.objects.get(project_id=project_id), ) except Project.DoesNotExist: return Result.failed(message='Project doesnt exist') result = [] list_all_process = list(all_process.values()) for process in list_all_process: # print(json.loads(json.dumps(process.get('process_config')))) process['process_config'] = eval(process['process_config']) print(process) result.append(process) return Result.success(message="Get all process successful", data=result) else: return Result.failed(message="Project id not exists", )
def stop_process(cls, request): process_id = request.GET['process_id'] if process_id: process_update = Process.objects.get(process_id=process_id, ) process_update.process_status = KEY_PROCESS_STOP process_update.save() result = list( Process.objects.filter(process_id=process_id, ).values())[0] return Result.success(message='Success stop process!', data=result) else: return Result.failed(message='Missing data in the request!')
def delete_person(cls, request): result_delete_person = cls.parse_delete_people_data(request) if result_delete_person: try: check_person = People.objects.get( person_id=result_delete_person.get(KEY_PERSON_ID), project_id=result_delete_person.get(KEY_PROJECT_ID)) xref_people_group = XrefPeopleGroup.objects.select_related('person_id') \ .filter(person_id=result_delete_person[KEY_PERSON_ID]) image_people = ResPeopleImage.objects.select_related('person_id') \ .filter(person_id=result_delete_person[KEY_PERSON_ID]) xref_people_group.delete() image_people.delete() check_person.status = 0 check_person.save() return Result.success(message='Success delete people') except People.DoesNotExist: return Result.failed( message='There is no person with this ID!') else: return Result.failed(message='Missing data in the request!')
def get_group_of_person(cls, request): person_code = request.GET['person_code'] if person_code: try: check_person = People.objects.get(person_id=person_code) group_list = [] xref_people_group = list( XrefPeopleGroup.objects.select_related('person_id').filter( person_id=check_person.person_id).values()) for item in xref_people_group: group_item = \ list(PeopleGroup.objects.select_related('people_group_id') .filter(people_group_id=item.get('people_group_id_id')).values())[0] group_list.append(group_item) return Result.success(message='Get group of person success!', data=group_list) except People.DoesNotExist: return Result.failed(message='Person id not exist!') else: return Result.failed(message='Missing data in the request!')
def update_people_group(cls, request): result_group_data = cls.parse_update_people_group_data(request) if result_group_data: people_group_choose = PeopleGroup.objects.filter( people_group_id=result_group_data[KEY_PEOPLE_GROUP_ID]) if people_group_choose: check_group_code = PeopleGroup.objects.filter( ~Q(people_group_id=result_group_data[KEY_PEOPLE_GROUP_ID]), people_group_code=result_group_data[KEY_PEOPLE_GROUP_CODE], status=DEFAULT_STATUS_ACTIVE) check_group_name = PeopleGroup.objects.filter( ~Q(people_group_id=result_group_data[KEY_PEOPLE_GROUP_ID]), people_group_name=result_group_data[KEY_PEOPLE_GROUP_NAME], status=DEFAULT_STATUS_ACTIVE) check_group_color = PeopleGroup.objects.filter( ~Q(people_group_id=result_group_data[KEY_PEOPLE_GROUP_ID]), people_group_color=result_group_data[ KEY_PEOPLE_GROUP_COLOR], status=DEFAULT_STATUS_ACTIVE, ) if check_group_code: return Result.failed(message='This group code exists') elif check_group_name: return Result.failed(message='This group name exists') elif check_group_color: return Result.failed(message='This group color exists') else: people_group_choose.update( people_group_name=result_group_data[ KEY_PEOPLE_GROUP_NAME], people_group_code=result_group_data[ KEY_PEOPLE_GROUP_CODE], people_group_color=result_group_data[ KEY_PEOPLE_GROUP_COLOR], updated_at=datetime.now()) return Result.success(message='Update group success!') else: return Result.failed(message='Group doesnt exist') else: return Result.failed(message='Missing data in the request!')
def create_process(cls, request): process = cls.parse_create_process(request) if process: result_check_processname = Process.objects.filter( process_name=process[KEY_PROCESS_NAME], project_id=Project.objects.get( project_id=process[KEY_PROJECT_ID])).values() if not result_check_processname.exists(): result_create_process = Process.objects.create( process_name=process[KEY_PROCESS_NAME], process_config=process[KEY_PROCESS_CONFIG], people_group_id=process[KEY_PROCESS_PEOPLE_GROUP_ID], camera_id=Camera.objects.get( camera_id=process[KEY_PROCESS_CAMERA_ID]), project_id=Project.objects.get( project_id=process[KEY_PROCESS_PROJECT_ID]), process_status=DEFAULT_PROCESS_CREATE) if result_create_process: get_process_id = list( Process.objects.filter( process_name=process[KEY_PROCESS_NAME], project_id=Project.objects.get( project_id=process[KEY_PROJECT_ID]), ).values())[0].get('process_id') tmp_process_token = cls.create_process_token( get_process_id, datetime.datetime.now()) result = Process.objects.get( process_name=process[KEY_PROCESS_NAME], project_id=Project.objects.get( project_id=process[KEY_PROJECT_ID]), ) result.process_token = tmp_process_token result.save() return Result.success(message="Success create process", ) else: return Result.failed(message='Can not create process', ) else: return Result.failed(message='Process name exits', ) else: return Result.failed(message='Data empty', )