def post(self, request, **kwargs):
data = request.data
username = data.get('username')
channel = PUSH_NOTIFICATION
app = "WAB"
# validate channel requested
if not Channel.objects.filter(type=channel).exists():
return responses.bad_request(None, "Channel is not existed!")
else:
channel = Channel.objects.filter(type=channel).first()
user_notify = NotifyUser.objects.filter(username=username).first()
if user_notify is None:
user_notify = NotifyUser.objects.create(username=username)
# check subscription
if not Subscribe.objects.filter(
user=user_notify, channel_id=channel.id, app=app).exists():
return responses.ok(data={"is_subscribe": False},
method=constant.POST,
entity_name='notify')
subscription = Subscribe.objects.filter(user=user_notify,
channel_id=channel.id,
app=app).first()
serializer = SubscribeSerializer(subscription)
resp = serializer.data
resp["is_subscribe"] = True
return responses.ok(data=resp,
method=constant.POST,
entity_name='notify')
def post(self, request, *args, **kwargs):
data = request.data
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
try:
connection = DBProviderConnection.objects.get(
id=data.get('connection'))
provider = connection.provider
custom_column = CustomColumnType.objects.get(
id=data.get('custom_column'))
if provider.name == MONGO:
mongo_db = MongoDBManager()
db, cache_db = mongo_db.connection_mongo_by_provider(
provider_connection=connection)
# type in [str, int, float, datetime]
table = data.get('table_name')
column = data.get('real_column')
data_type = custom_column.slug
_ = mongo_db.update_convert_column_data_type(
db=db,
table=table,
column=column,
data_type=data_type,
provider_connection_id=connection.id)
return responses.ok(data=serializer.data,
method=constant.POST,
entity_name='custom_column_mapping')
else:
return responses.ok(data=None,
method=constant.POST,
entity_name='custom_column_mapping')
except Exception as err:
return responses.bad_request(data=str(err),
message_code='MAPPING_ERROR')
def put(self, request, *args, **kwargs):
data = request.data
custom_column_type_id = kwargs.get("custom_column_type_id")
name = data.get("name")
slug = data.get('slug')
custom_column_type_validator_delete_list = data.get(
"custom_column_type_validator_delete_list")
custom_column_type_validator_update_list = data.get(
"custom_column_type_validator_update_list")
custom_column_type_validator_create_list = data.get(
"custom_column_type_validator_create_list")
del data['custom_column_type_validator_delete_list']
del data['custom_column_type_validator_update_list']
del data['custom_column_type_validator_create_list']
# serializer = self.get_serializer(data=data)
# if serializer.is_valid(raise_exception=True):
try:
# Update Custom_Column_Config_Type
custom_column_type = CustomColumnType.objects.get(
id=custom_column_type_id)
custom_column_type.slug = slug
custom_column_type.name = name
custom_column_type.save()
# Delete List Custom_Column_Config_Type_Validator
if custom_column_type_validator_delete_list is not None:
CustomColumnTypeValidator.objects.filter(
id__in=custom_column_type_validator_delete_list).delete()
# Update List Custom_Column_Config_Type_Validator
if custom_column_type_validator_update_list is not None:
for updated_item in custom_column_type_validator_update_list:
updated_validator_id = updated_item.get("id")
updated_validator = CustomColumnTypeValidator.objects.get(
id=updated_validator_id)
custom_column_config_validation = CustomColumnConfigValidation.objects.get(
id=updated_item.get('custom_column_config_validation'))
updated_validator.custom_column_config_validation = custom_column_config_validation
updated_validator.operator = updated_item.get("operator")
updated_validator.value = updated_item.get("value")
updated_validator.save()
# Create List Custom_Column_Config_Type_Validator
if custom_column_type_validator_create_list is not None:
for validation_item in custom_column_type_validator_create_list:
CustomColumnTypeValidator.objects.create(
custom_column_type=custom_column_type,
custom_column_config_validation_id=validation_item.get(
'custom_column_config_validation'),
operator=validation_item.get('operator'),
value=validation_item.get("value"))
serializer_config_type = self.get_serializer(custom_column_type)
return responses.ok(data=serializer_config_type.data,
method=constant.POST,
entity_name='custom-column-type')
except Exception as err:
return responses.bad_request(
data=str(err),
message_code='UPDATE_CUSTOM_COLUMN_TYPE_HAS_ERROR')
def post(self, request, **kwargs):
data = request.data
notify_service = NotificationsService()
notify_service.process_push_broadcast_notification(data=data)
return responses.ok(data="Pushed broadcast notifications",
method="post",
entity_name="notifications")
def list(self, request, *args, **kwargs):
sql_function_id = kwargs.get('pk', None)
page = request.GET.get('page', 1)
page_size = request.GET.get('page_size', 20)
try:
mongo_db_manager = MongoDBManager()
sql_function = SqlFunction.objects.get(id=sql_function_id)
connection = sql_function.connection
if connection.provider.name == MONGO:
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=connection)
documents = mongo_db_manager.sql_function_exe(
sql_function=sql_function,
db=db,
page=page,
page_size=page_size)
data = list(documents)
first_record = data[0]
columns = first_record.keys()
result = json.loads(dumps(data))
final_data = {'columns': columns, 'collections': result}
return responses.paging_data(
data=final_data,
total_count=page_size,
method=constant.GET,
entity_name='db_provider_connection')
else:
return responses.ok(data=None,
method=constant.GET,
entity_name='sql_function')
except Exception as err:
return responses.bad_request(data=str(err),
message_code='SQL_ERROR')
def post(self, request, *args, **kwargs):
email = request.data.get('email', None)
if email:
user = User.objects.filter(email=email).first()
if user:
token = default_token_generator.make_token(user)
context = {
'username':
user.username,
'activate_url':
settings.WAB_API + 'accounts/reset-password/confirm/' +
token + '/'
}
KeyModel.objects.filter(user=user).delete()
KeyModel.objects.create(key=token, user=user)
html_message = get_template(
"account/wab/email_reset_password.html").render(context)
send_mail(settings.EMAIL_SUBJECT_PREFIX + ' Reset password',
None,
settings.DEFAULT_FROM_EMAIL, [email],
html_message=html_message)
return responses.ok(data='Reset success',
method=constant.POST,
entity_name='users')
else:
return responses.bad_request(data='User not found',
message_code='USER_NOT_FOUND')
else:
return responses.bad_request(data='Email invalid',
message_code='EMAIL_INVALID')
def post(self, request, *args, **kwargs):
data = request.data
custom_column_type_validator_list = data.get(
'custom_column_type_validator_list')
del data['custom_column_type_validator_list']
serializer = self.get_serializer(data=data)
if serializer.is_valid(raise_exception=True):
try:
# Create Custom Column Type
custom_column_type = serializer.save()
# Create Custom_Column_Config_Type
if custom_column_type_validator_list is not None:
for validation_item in custom_column_type_validator_list:
CustomColumnTypeValidator.objects.create(
custom_column_type=custom_column_type,
custom_column_config_validation_id=validation_item.
get('custom_column_config_validation'),
operator=validation_item.get('operator'),
value=validation_item.get("value"))
serializer_config_type = self.get_serializer(
custom_column_type)
return responses.ok(data=serializer_config_type.data,
method=constant.POST,
entity_name='custom-column-type')
except Exception as err:
return responses.bad_request(
data=str(err),
message_code='UPDATE_CUSTOM_COLUMN_TYPE_HAS_ERROR')
else:
return responses.bad_request(
data=None, message_code='UPDATE_CUSTOM_COLUMN_TYPE_INVALID')
def post(self, request, *args, **kwargs):
data = request.data
# data.update({'creator': request.user.id})
# data.update({'last_modified_by': request.user.id})
serializer = self.get_serializer(data=data)
if serializer.is_valid(raise_exception=True):
provider = self.queryset.filter(id=data.get('provider')).first()
if provider:
try:
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo(host=data.get('host'), port=data.get('port'),
username=data.get('username'),
password=data.get('password'),
database=data.get('database'),
ssl=data.get('ssl'), user_id=request.user.id)
collections = mongo_db_manager.get_all_collections(db=db, cache_db=cache_db)
# serializer.save()
return responses.ok(data=collections, method=constant.POST,
entity_name='db_provider_connection')
else:
# TODO: implement another phase
pass
except Exception as err:
return responses.bad_request(data=str(err), message_code='CONNECT_ERROR')
else:
return responses.bad_request(data='Provider not found', message_code='PROVIDER_NOT_FOUND')
else:
return Response(status=status.HTTP_503_SERVICE_UNAVAILABLE, data=None)
def get(self, request, *args, **kwargs):
provider_connection = self.queryset.get(id=1)
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=provider_connection)
result = mongo_db_manager.check_column_data_type(db, 'order_items', 'price')
return responses.ok(data=result, method=constant.GET, entity_name='db_provider_connection')
def put(self, request, *args, **kwargs):
"""
Update user profile
---
parameters:
- name: name
description: text
required: False
type: file
responseMessages:
- code: 200
message: Updated
"""
data = request.data
image = data.get('image')
url = upload_to_s3(folder='avatar',
file_name=image.name,
file=image,
user_id=request.user.id)
data.update({'avatar': url})
del data['image']
serializer = UserUpdateSerializer(data=data)
if serializer.is_valid(raise_exception=True):
user = request.user
user.name = data.get('name')
user.avatar = url
user.description = data.get('description', '')
user.save()
return responses.ok(data=serializer.data,
method=constant.PUT,
entity_name='user')
def get(self, request, *args, **kwargs):
list_regex_type = []
for x in RegexType:
list_regex_type.append({"code": x.value[0], "name": x.value[1]})
return responses.ok(data=list_regex_type,
method=constant.GET,
entity_name='list_regex_type')
def get(self, request, *args, **kwargs):
list_relation = []
for x in Relation:
list_relation.append({"code": x.value[0], "name": x.value[1]})
return responses.ok(data=list_relation,
method=constant.GET,
entity_name='list_relation')
def get(self, request, *args, **kwargs):
list_join = []
for x in MergeType:
list_join.append({"code": x.value[0], "name": x.value[1]})
return responses.ok(data=list_join,
method=constant.GET,
entity_name='list_join')
def post(self, request, **kwargs):
data = request.data
if data.get("username") is None:
return responses.bad_request(data=None,
message_code="USERNAME_INVALID")
notify_service = NotificationsService()
notify_service.process_push_single_notification(data=data)
return responses.ok(data="Pushed single notifications!",
method="post",
entity_name="notifications")
def create(self, request, *args, **kwargs):
data = request.data
data.update({'creator': request.user.id})
data.update({'last_modified_by': request.user.id})
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
return responses.ok(data=serializer.data,
method=constant.POST,
entity_name='custom_column_config_validation')
def create(self, request, *args, **kwargs):
data = request.data
data.update({'creator': request.user.id})
data.update({'last_modified_by': request.user.id})
serializer = self.get_serializer(data=data)
serializer.is_valid(raise_exception=True)
self.perform_create(serializer)
# headers = self.get_success_headers(serializer.data)
return responses.ok(data=serializer.data, method=constant.POST,
entity_name='db_provider_connection')
def get(self, request, *args, **kwargs):
try:
sql_function_id = kwargs.get("pk")
sql_function = SqlFunction.objects.get(id=sql_function_id)
serializer = self.serializer_class(sql_function)
return responses.ok(data=serializer.data,
method=constant.GET,
entity_name='sql-function')
except Exception as err:
return responses.bad_request(data=str(err),
message_code='SQL_FUNCTION_NOT_FOUND')
def get(self, request, *args, **kwargs):
list_operator_mongodb = []
for x in OperatorMongo:
list_operator_mongodb.append({
"code": x.value[0],
"name": x.value[1]
})
return responses.ok(data=list_operator_mongodb,
method=constant.GET,
entity_name='list-operator')
def get(self, request, *args, **kwargs):
try:
custom_column_fk_id = kwargs.get("pk")
custom_column_fk = self.get_queryset().get(id=custom_column_fk_id)
serializer = self.serializer_class(custom_column_fk)
return responses.ok(data=serializer.data,
method=constant.GET,
entity_name='custom-column-fk')
except Exception as err:
return responses.bad_request(
data=str(err), message_code='CUSTOM_COLUMN_FK_NOT_FOUND')
def update(self, request, *args, **kwargs):
pk = kwargs.get('pk', None)
try:
data = request.data
partial = kwargs.pop('partial', False)
instance = CustomColumnMapping.objects.get(id=pk)
serializer = self.serializer_class(instance,
data=data,
partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
connection = DBProviderConnection.objects.get(
id=data.get('connection'))
provider = connection.provider
custom_column = CustomColumnType.objects.get(
id=data.get('custom_column'))
if provider.name == MONGO:
mongo_db = MongoDBManager()
db, cache_db = mongo_db.connection_mongo_by_provider(
provider_connection=connection)
# type in [str, int, float, datetime]
table = data.get('table_name')
column = data.get('real_column')
data_type = custom_column.slug
_ = mongo_db.update_convert_column_data_type(
db=db,
table=table,
column=column,
data_type=data_type,
provider_connection_id=connection.id)
return responses.ok(data=serializer.data,
method=constant.PUT,
entity_name='custom_column_mapping')
else:
return responses.ok(data=None,
method=constant.PUT,
entity_name='custom_column_mapping')
except Exception as err:
responses.bad_request(
data=str(err), message_code='CUSTOM_COLUMN_MAPPING_NOT_FOUND')
def post(self, request, *args, **kwargs):
data = request.data
password1 = data.get('password1')
password2 = data.get('password2')
username = data.get('username')
email = data.get('email')
user = User.objects.filter(Q(username=username)
| Q(email=email)).first()
if user is None:
if password1 == password2:
# user_create = {
# 'username': username,
# 'email': email,
# 'password': make_password(password1)
# }
serializer = self.get_serializer(data=data)
if serializer.is_valid(raise_exception=True):
# user = serializer.save()
user = User.objects.create(
username=username,
email=email,
password=make_password(password1))
user.is_active = False
user.save()
current_site = get_current_site(self.request)
token = default_token_generator.make_token(user)
context = {
'username':
username,
'activate_url':
settings.WAB_API +
'oauth/registration/confirm-email/' + token + '/',
'fe_url':
settings.WAB_FE
}
KeyModel.objects.create(key=token, user=user)
html_message = get_template(
"account/wab/email_register.html").render(context)
send_mail(settings.EMAIL_SUBJECT_PREFIX +
' Please Confirm Your E-mail Address',
None,
settings.DEFAULT_FROM_EMAIL, [email],
html_message=html_message)
return responses.ok(data='Register success',
method=constant.POST,
entity_name='users')
else:
return responses.bad_request(data='Password does not match',
message_code='PASSWORD_NOT_SAME')
else:
return responses.bad_request(data='User is existed',
message_code='USER_EXISTED')
def post(self, request, *args, **kwargs):
data = request.data
name = data.get('name')
connection = data.get('connection')
order_by_name = data.get('order_by_name')
sql_function_merges = data.get('sql_function_merges')
sql_function_condition_items = data.get('sql_function_condition_items')
serializer_sql_function = self.get_serializer(data=data)
if serializer_sql_function.is_valid(raise_exception=True):
try:
# Create SqlFunction
sql_function = SqlFunction.objects.create(
name=name,
connection=DBProviderConnection.objects.get(id=connection))
serializer_sql_function = self.get_serializer(sql_function)
# Create SqlFunctionOrderBy
SqlFunctionOrderBy.objects.create(order_by_name=order_by_name,
sql_function=sql_function)
# Create SqlFunctionMerge
if sql_function_merges is not None:
for sql_function_merge in sql_function_merges:
SqlFunctionMerge.objects.create(
table_name=sql_function_merge.get('table_name'),
column_name=sql_function_merge.get('column_name'),
merge_type=sql_function_merge.get('merge_type'),
sql_function=sql_function)
# Create SqlFunctionConditionItems
if sql_function_condition_items is not None:
for sql_function_condition_item in sql_function_condition_items:
SqlFunctionConditionItems.objects.create(
table_name=sql_function_condition_item.get(
'table_name'),
field_name=sql_function_condition_item.get(
'field_name'),
sql_function=sql_function,
value=sql_function_condition_item.get('value'),
operator=sql_function_condition_item.get(
'operator'),
relation=sql_function_condition_item.get(
'relation'))
return responses.ok(data=serializer_sql_function.data,
method=constant.POST,
entity_name='sql-function')
except Exception as err:
return responses.bad_request(
data=str(err),
message_code='CREATE_SQL_FUNCTION_HAS_ERROR')
else:
return responses.bad_request(
data=None, message_code='CREATE_SQL_FUNCTION_INVALID')
def get(self, request, *args, **kwargs):
custom_column_type_id = kwargs.get("custom_column_type_id")
try:
custom_column_validators = CustomColumnTypeValidator.objects.filter(
custom_column_type__id=custom_column_type_id)
serializer = self.get_serializer(custom_column_validators,
many=True)
return responses.ok(data=serializer.data,
method=constant.GET,
entity_name='custom-column-validator')
except Exception as err:
return responses.not_found(
data=None,
message_system=err,
message_code='GET_CUSTOM_COLUMN_VALIDATOR_NOT_FOUND')
def get(self, request, *args, **kwargs):
connection_id = kwargs.get("connection_id")
table_name = kwargs.get("table_name")
try:
sharing_key_decode = connection_id + ";" + table_name
sharing_key_encode = base64.b64encode(
bytes(sharing_key_decode, "utf-8"))
return responses.ok(data=sharing_key_encode.decode('utf-8'),
method=constant.GET,
entity_name='sharing-files')
except Exception as err:
return responses.not_found(
data=None,
message_code='SHARING_FILES_CAN_NOT_CREATE_LINK',
message_system=err)
def post(self, request, *args, **kwargs):
data = request.data
connection_id = kwargs.get("connection_id")
list_field = data.get("list_field")
table_name = data.get("table_name")
connection = DBProviderConnection.objects.filter(
id=connection_id).first()
if connection is None:
return responses.bad_request(
data=None, message_code="PROVIDER_CONNECTION_NOT_FOUND")
if connection.provider.name == MONGO:
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=connection)
collections = mongo_db_manager.get_all_collections(
db=db, cache_db=cache_db)
column_mapping = CustomColumnMapping.objects.filter(
table_name=table_name, connection_id=connection.id).exists()
if column_mapping is False and table_name not in collections:
mongo_db_manager.create_new_collection(db, table_name)
else:
return responses.bad_request(
data=None, message_code="TABLE_NAME_IS_EXISTS")
for field in list_field:
try:
custom_column = CustomColumnType.objects.get(
id=field.get('custom_column'))
CustomColumnMapping.objects.create(
connection_id=connection.id,
table_name=table_name,
real_column=field.get("column_name"),
custom_column_name=field.get("column_name"),
custom_column_id=custom_column.id)
except Exception as ex:
print(ex)
continue
resp = CustomColumnMapping.objects.filter(connection_id=connection.id,
table_name=table_name)
serializer = self.get_serializer(resp, many=True)
return responses.ok(data=serializer.data,
method=constant.POST,
entity_name="custom_column_mapping")
def delete(self, request, *args, **kwargs):
custom_column_fk_id = kwargs.get('pk')
try:
custom_column_fk = self.get_queryset().get(id=custom_column_fk_id)
# Delete CustomColumnFKFilter
CustomColumnFKFilter.objects.filter(
custom_column_fk__id=custom_column_fk_id).delete()
# Delete SqlFunction
custom_column_fk.delete()
return responses.ok(data=None,
method=constant.DELETE,
entity_name='custom_column_fk')
except Exception as err:
return responses.bad_request(
data=str(err),
message_code='DELETE_CUSTOM_COLUMN_FK_HAS_ERROR')
def delete(self, request, *args, **kwargs):
sql_function_id = kwargs.get('pk')
try:
sql_function = self.get_queryset().get(id=sql_function_id)
# Delete SqlFunctionOrderBy
SqlFunctionOrderBy.objects.filter(
sql_function__id=sql_function_id).delete()
# Delete SqlFunctionMerge
SqlFunctionMerge.objects.filter(
sql_function__id=sql_function_id).delete()
SqlFunctionConditionItems.objects.filter(
sql_function_id=sql_function_id).delete()
# Delete SqlFunction
sql_function.delete()
return responses.ok(data=None,
method=constant.DELETE,
entity_name='sql-function')
except Exception as err:
return responses.bad_request(
data=str(err), message_code='DELETE_SQL_FUNCTION_HAS_ERROR')
def put(self, request, *args, **kwargs):
data = request.data
convert_field = data.get("convert_field")
data_type = data.get("data_type")
table = data.get("table")
provider_connection_id = data.get("provider_connection_id")
mongo_db = MongoDBManager()
provider_connection = DBProviderConnection.objects.filter(
id=provider_connection_id).first()
db, cache_db = mongo_db.connection_mongo_by_provider(
provider_connection=provider_connection)
# type in [str, int, float, datetime]
is_convert = mongo_db.update_convert_column_data_type(
db=db,
table=table,
column=convert_field,
data_type=data_type,
provider_connection_id=provider_connection_id)
return responses.ok(data={"is_convert": is_convert},
method="put",
entity_name="test")
def post(self, request, *args, **kwargs):
data = request.data
connection_id = data.get("connection_id")
name = data.get("name")
table_name = data.get("table_name")
custom_column_fk_filter_list = data.get("custom_column_fk_filter_list")
serializer_custom_column_fk = self.get_serializer(data=data)
if serializer_custom_column_fk.is_valid(raise_exception=True):
try:
# Create Custom_Column_FK
custom_column_fk = CustomColumnFK.objects.create(
name=name,
table_name=table_name,
connection=DBProviderConnection.objects.get(
id=connection_id),
creator=request.user,
last_modified_by=request.user)
# Create Custom_Column_Filter
if custom_column_fk_filter_list is not None:
for custom_column_filter in custom_column_fk_filter_list:
CustomColumnFKFilter.objects.create(
field_name=custom_column_filter.get('field_name'),
operator=custom_column_filter.get('operator'),
value=custom_column_filter.get('value'),
custom_column_fk=custom_column_fk)
serializer_custom_column_fk = self.get_serializer(
custom_column_fk)
return responses.ok(data=serializer_custom_column_fk.data,
method=constant.POST,
entity_name='custom-column-fk')
except Exception as err:
return responses.bad_request(
data=str(err),
message_code='CREATE_CUSTOM_COLUMN_FK_HAS_ERROR')
else:
return responses.bad_request(
data=None, message_code='UPDATE_CUSTOM_COLUMN_FK_INVALID')
def post(self, request, *args, **kwargs):
try:
sql_function_id = kwargs.get('sql_function_id')
table_name = kwargs.get('table_name')
sql_function = self.get_queryset().get(id=sql_function_id)
connection = sql_function.connection
provider = connection.provider
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=connection)
collection = mongo_db_manager.create_new_collection(
db=db, collection_name=table_name)
mongo_db_manager.create_table_with_sql_function(
db, collection, sql_function)
else:
return responses.ok(data=None,
method=constant.POST,
entity_name=sql_function)
except Exception as err:
return responses.bad_request(data=str(err),
message_code='SQL_FUNCTION_ERROR')
