def reset_master_admin_password(cls, request):
secret_key = request.data.get(KEY_SECRET_RESTORE_MASTER_ADMIN_PASSWORD)
master_admin = User.objects.filter(
username=DEFAULT_MASTER_ADMIN_USER_NAME).values()
if secret_key == SECRET_RESET_MASTER_ADMIN_PASSWORD_KEY:
new_password = cls.generate_password(DEFAULT_MASTER_ADMIN_PASSWORD)
if master_admin:
restore_password = User.objects.filter(
username=DEFAULT_MASTER_ADMIN_USER_NAME).update(
password=new_password)
if restore_password:
return Result.success(
message=
'Reset password for super administrator success!',
data={
KEY_USER_NAME: DEFAULT_MASTER_ADMIN_USER_NAME,
KEY_USER_PASSWORD: DEFAULT_MASTER_ADMIN_PASSWORD
})
else:
return Result.success(
message='Reset password for super administrator failed!'
)
else:
create_master_admin = User.objects.create(
username=DEFAULT_MASTER_ADMIN_USER_NAME,
password=new_password,
full_name=DEFAULT_MASTER_ADMIN_FULL_NAME,
role=DEFAULT_ADMIN_ROLE,
status=DEFAULT_USER_STATUS)
if create_master_admin:
return Result.success(
message=
'Reset password for super administrator success!',
data={
KEY_USER_NAME: DEFAULT_MASTER_ADMIN_USER_NAME,
KEY_USER_PASSWORD: DEFAULT_MASTER_ADMIN_PASSWORD
})
else:
return Result.success(
message='Reset password for super administrator failed!'
)
else:
return Result.failed(
message='The security key to reset the account is incorrect!')
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 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 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 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 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 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 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 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 dango():
try:
data = fetch('SELECT * FROM 小团子酱杨雪')
logger.success('查询 "小团子酱 杨雪" 完成')
return Result.success(data)
except:
logger.success('查询 "小团子酱 杨雪" 失败')
return Result.error(400, '获取数据失败')
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(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 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 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 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 update_process(cls, request):
process = cls.parse_update_process(request)
if process:
Process.objects.filter(process_id=process[KEY_PROCESS_ID]).update(
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]))
return Result.success(message='Success edit process!')
else:
return Result.failed(message='Missing data in the request!')
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_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 check_camera(cls, request):
camera_id = request.GET['camera_id']
if camera_id:
camera_url = Camera.objects.get(camera_id=camera_id).stream_url
camera_status = cls.check_camera_available(camera_url)
return Result.success(
message='Status of all cameras',
data=camera_status
)
else:
return Result.failed(
message='Missing data from 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 change_password(cls, request):
old_password = request.data.get('old_password')
# old_password = cls.generate_password(request.data.get('old_password'))
new_password = cls.generate_password(request.data.get('new_password'))
user_information = jwt.decode(
cls.parse_request_user_data(request).get('token'),
SECRET_TOKEN_KEY)
# print(old_password)
cur_user = User.objects.get(user_id=user_information[KEY_USER_ID])
validated_user_password = cls.check_user_password(
old_password, cur_user.password)
if validated_user_password:
cur_user.password = new_password
cur_user.save()
return Result.success(message='Success change password!')
else:
return Result.failed(message='Old password doesnt match!')
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 turn_off_camera(cls, request):
camera_id = request.GET['camera_id']
process_running = list(Process.objects.filter(
camera_id=Camera.objects.get(camera_id=camera_id)
).values())
for process in process_running:
process_cur = Process.objects.get(
process_id=process['process_id']
)
process_cur.process_status = 3
process_cur.save()
camera_off = Camera.objects.get(camera_id=camera_id)
camera_off.is_running = False
camera_off.save()
return Result.success(
message='Turn off camera success!'
)
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 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!'
)
