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):
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 get(self, request, *args, **kwargs):
export_id = kwargs.get("export_id")
export = ExportData.objects.filter(id=export_id, status=ExportData.COMPLETE,
provider_connection__provider__name=MONGO).first()
try:
if export:
file_path = os.path.join(export.file_path)
file_path_split = export.file_path.split("\\")
file_name = file_path_split[-1]
if os.path.exists(file_path):
with open(file_path, 'rb') as fh:
if export.file_type == ExportData.TXT:
response = HttpResponse(fh.read(), content_type='text/plain')
response['Content-Disposition'] = 'attachment; filename=%s' % file_name
return response
elif export.file_type == ExportData.EXCEL:
response = HttpResponse(
fh.read(),
content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
)
response['Content-Disposition'] = 'attachment; filename=%s' % file_name
return response
elif export.file_type == ExportData.PDF:
response = HttpResponse(fh.read(), content_type='application/pdf')
response['Content-Disposition'] = 'attachment; filename=%s' % file_name
return response
return responses.bad_request(data=None, message_code="CAN'T FIND FILE")
return responses.bad_request(data=None, message_code="EXPORT_ID_INVALID")
except Exception as ex:
print(ex)
return responses.bad_request(data=None, message_code="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):
table_name = kwargs.get('table', None)
connection_id = kwargs.get('pk', None)
page = request.GET.get('page', 1)
page_size = request.GET.get('page_size', 20)
column_sort = request.GET.get('column_sort', None)
sort = request.GET.get('sort', None)
try:
provider_connection = self.queryset.get(id=connection_id)
provider = provider_connection.provider
if provider:
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
try:
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=provider_connection)
documents, count = mongo_db_manager.get_all_documents(db=db, collection=table_name,
column_sort=column_sort,
sort=sort, page=page, page_size=page_size)
data = list(documents)
result = json.loads(dumps(data))
return responses.paging_data(data=result, total_count=count, method=constant.POST,
entity_name='db_provider_connection')
except Exception as err:
return responses.bad_request(data=str(err), message_code='BD_ERROR')
else:
# TODO: implement another phase
pass
else:
return responses.bad_request(data='Provider not found', message_code='PROVIDER_NOT_FOUND')
except DBProviderConnection.DoesNotExist as err:
return responses.not_found(data=None, message_code='PROVIDER_CONNECTION_NOT_FOUND', message_system=err)
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 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, **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 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, *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 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 get(self, request, *args, **kwargs):
pk = kwargs.get('pk', None)
page = request.GET.get('page', 1)
page_size = request.GET.get('page_size', 20)
try:
custom_column_fk = self.get_queryset().get(id=pk)
custom_column_filter = CustomColumnFKFilter.objects.filter(
custom_column_fk=custom_column_fk)
provider_connection = custom_column_fk.connection
provider = provider_connection.provider
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=provider_connection)
documents, count = mongo_db_manager.find_by_fk(
db,
custom_column_fk.table_name,
custom_column_filter,
page=page,
page_size=page_size)
data = list(documents)
result = json.loads(dumps(data))
return responses.paging_data(data=result,
total_count=count,
method=constant.POST,
entity_name='custom_column_fk')
else:
return responses.paging_data(data=None,
total_count=0,
method=constant.POST,
entity_name='custom_column_fk')
except Exception as err:
return responses.bad_request(
data=str(err), message_code='CUSTOM_COLUMN_FK_NOT_FOUND')
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 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 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 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):
table_name = kwargs.get('table_name', None)
list_filter = kwargs.get('list_filter', None)
list_column = kwargs.get('list_column', None)
connection_id = kwargs.get('connection', None)
try:
provider_connection = self.queryset.get(id=connection_id)
provider = provider_connection.provider
if provider:
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
try:
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=provider_connection)
# columns = mongo_db_manager.get_all_keys(db=db, collection=table_name)
# documents, count = mongo_db_manager.get_all_documents(db=db, collection=table_name,
# column_sort=None,
# sort=None, page=1, page_size=20)
documents = mongo_db_manager.export_db_by_column(db=db, table=table_name,
list_filter=list_filter,
list_column=list_column)
data = list(documents)
result = json.loads(dumps(data))
# final_data = []
# for d in result:
# i = []
# for k,v in d.items():
# i.append(v)
# final_data.append(i)
pdf = GeneratePdf(result, table_name, list_column)
response = pdf.generate_pdf(context={})
return response
except Exception as err:
return responses.bad_request(data=str(err), message_code='BD_ERROR')
else:
# TODO: implement another phase
pass
else:
return responses.bad_request(data='Provider not found', message_code='PROVIDER_NOT_FOUND')
except DBProviderConnection.DoesNotExist as err:
return responses.not_found(data=None, message_code='EXPORT_ERROR', message_system=err)
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
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 get(self, request, *args, **kwargs):
connection_id = kwargs.get('pk', None)
try:
if connection_id:
provider_connection = self.queryset.get(id=connection_id)
provider = provider_connection.provider
if provider:
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=provider_connection)
data = mongo_db_manager.get_all_collections(db=db, cache_db=cache_db)
return responses.ok(data=data, method=constant.POST, entity_name='db_provider_connection')
else:
# TODO: implement another phase
pass
else:
return responses.bad_request(data='Provider not found', message_code='PROVIDER_NOT_FOUND')
else:
return responses.bad_request(data=None, message_code='PROVIDER_CONNECTION_ID_EMPTY')
except Exception as err:
return responses.not_found(data=None, message_code='PROVIDER_CONNECTION_NOT_FOUND', message_system=err)
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 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')
def get(self, request, *args, **kwargs):
try:
user = request.user
connection_id = kwargs.get("connection")
table_name = kwargs.get("table_name")
list_filter = kwargs.get('list_filter', None)
list_column = kwargs.get('list_column', None)
provider_connection = self.queryset.get(id=connection_id)
provider = provider_connection.provider
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo_by_provider(provider_connection=provider_connection)
# c = db.__getattr__(table_name).find().limit(20)
documents = mongo_db_manager.export_db_by_column(db=db, table=table_name,
list_filter=list_filter,
list_column=list_column)
if documents.count() <= 1000:
result = json.loads(dumps(list(documents)))
headers = list(result[0].keys())
content = ''
for header in headers:
content += header
if headers.index(header) != len(headers) - 1:
content += ', '
else:
content += '\n'
for value in result:
for header in headers:
if header == "_id":
content += value.get(header).get('$oid')
else:
try:
content += value.get(header)
except:
content += ''
if headers.index(header) != len(headers) - 1:
content += ', '
else:
content += '\n'
today = datetime.now().strftime("%d%m%Y_%H%M%S")
filename = f"ExportData-{table_name}-{today}.txt"
response = HttpResponse(content, content_type='text/plain')
response['Content-Disposition'] = 'attachment; filename=%s' % filename
return response
else:
ExportData.objects.create(
provider_connection_id=provider_connection.id,
username=user.username,
table=table_name,
status=ExportData.INIT,
file_type=ExportData.EXCEL,
list_filter=list_filter,
list_column=list_column
)
return responses.ok(data="Waiting notify for export", method=constant.GET,
entity_name='export-data')
return responses.bad_request(data=None, message_code="SQL_PROVIDER_NOT_FOUND")
except Exception as err:
return responses.not_found(data=None, message_code='SQL_FUNCTION_NOT_FOUND', message_system=err)
def get(self, request, *args, **kwargs):
data = request.query_params
page = int(data.get("page", '1'))
page_size = int(data.get("page_size", '20'))
sharing_key_encode = kwargs.get("sharing_key")
try:
sharing_key_decode_utf8 = base64.b64decode(sharing_key_encode)
sharing_key_decode = sharing_key_decode_utf8.decode("utf-8")
sharing_key_array = sharing_key_decode.split(";")
if len(sharing_key_array) == 2:
connection_id = sharing_key_array[0]
table_name = sharing_key_array[1]
# Get data from connection and table name
provider_connection = self.queryset.get(id=connection_id)
provider = provider_connection.provider
if provider:
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
try:
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=provider_connection)
columns = mongo_db_manager.get_all_keys(
db=db, collection=table_name)
documents, count = mongo_db_manager.get_all_documents(
db=db,
collection=table_name,
column_sort=None,
sort=None,
page=page,
page_size=page_size)
data = list(documents)
result_document = json.loads(json_util.dumps(data))
result = {
'columns': columns,
'documents': result_document
}
return responses.paging_data(
data=result,
total_count=count,
method=constant.GET,
entity_name='sharing_files')
except Exception as err:
return responses.bad_request(
data=err, message_code='BD_ERROR')
else:
# TODO: implement another phase
return responses.ok(data=None,
method=constant.GET,
entity_name='sharing_files')
else:
return responses.bad_request(
data='Provider not found',
message_code='PROVIDER_NOT_FOUND')
else:
return responses.not_found(
data=None, message_code='SHARING_FILES_GET_DATA_NOT_FOUND')
except Exception as err:
return responses.not_found(
data=None,
message_code='SHARING_FILES_GET_DATA_NOT_FOUND',
message_system=err)
def post(self, request, **kwargs):
data = request.data
username = data.get('username')
channel = PUSH_NOTIFICATION
app = "WAB"
prev_reg_id = data.get('prev_reg_id')
reg_id = data.get('reg_id')
# validate channel requested
if not Channel.objects.filter(type=channel).exists():
return responses.bad_request(
data=None, message_code="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:
# not existed, create new user
user_notify = NotifyUser.objects.create(username=username)
if prev_reg_id and prev_reg_id != "":
subscribe = Subscribe.objects.filter(
user=user_notify,
app=app,
channel_id=channel.id,
contact__contains=[prev_reg_id]).first()
if not subscribe:
return responses.bad_request(
data=None, message_code="User subscription is invalid!")
if channel.type == PUSH_NOTIFICATION:
firebase_mgr = FirebaseManager()
firebase = firebase_mgr.get_by_channel(channel)
firebase.unsubscribe_topic(channel, [prev_reg_id])
subscribe.contact.remove(prev_reg_id)
subscribe.save()
# check subscription
if reg_id and reg_id != "":
subscribe = Subscribe.objects.filter(user=user_notify,
channel_id=channel.id,
app=app).first()
# Subscribe channel
if not subscribe:
subscribe = Subscribe.objects.create(user=user_notify,
active=True,
channel_id=channel.id,
app=app)
if channel.type == PUSH_NOTIFICATION:
firebase_mgr = FirebaseManager()
firebase = firebase_mgr.get_by_channel(channel)
subscribe.contact.append(reg_id)
is_valid, list_contact = firebase.validate_registration_id(
subscribe.contact)
if is_valid and reg_id in list_contact:
firebase.subscribe_topic(channel, [reg_id])
subscribe.contact = list_contact
subscribe.save()
else:
return responses.bad_request(
data=None, message_code="User token is invalid")
return responses.ok(data=None,
method=constant.POST,
entity_name='notify')
def put(self, request, *args, **kwargs):
custom_column_fk_id = kwargs.get('pk')
data = request.data
connection_id = data.get("connection_id")
name = data.get("name")
table_name = data.get("table_name")
custom_column_fk_filter_create_list = data.get(
"custom_column_fk_filter_create_list")
custom_column_fk_filter_update_list = data.get(
"custom_column_fk_filter_update_list")
custom_column_fk_filter_delete_list = data.get(
"custom_column_fk_filter_delete_list")
serializer_custom_column_fk = self.get_serializer(data=data)
if serializer_custom_column_fk.is_valid(raise_exception=True):
try:
# Update Custom_Column_FK
custom_column_fk = self.get_queryset().get(
id=custom_column_fk_id)
custom_column_fk.name = name
custom_column_fk.table_name = table_name
custom_column_fk.connection = DBProviderConnection.objects.get(
id=connection_id)
custom_column_fk.save()
serializer_custom_column_fk = self.get_serializer(
custom_column_fk)
# Delete custom_column_fk_filter_list
if custom_column_fk_filter_delete_list is not None:
CustomColumnFKFilter.objects.get(
id__in=custom_column_fk_filter_delete_list).delete()
# Update custom_column_fk_filter_list
if custom_column_fk_filter_update_list is not None:
for item in custom_column_fk_filter_update_list:
custom_column_fk_filter = CustomColumnFKFilter.objects.get(
id=item.get('id'))
custom_column_fk_filter.field_name = item.get(
'field_name')
custom_column_fk_filter.operator = item.get('operator')
custom_column_fk_filter.value = item.get('value')
custom_column_fk_filter.save()
# Create Custom_Column_Filter
if custom_column_fk_filter_create_list is not None:
for custom_column_filter in custom_column_fk_filter_create_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)
return responses.ok(data=serializer_custom_column_fk.data,
method=constant.PUT,
entity_name='custom_column_fk')
except Exception as err:
return responses.bad_request(
data=str(err),
message_code='UPDATE_CUSTOM_COLUMN_FK_HAS_ERROR')
else:
return responses.bad_request(
data=None, message_code='UPDATE_CUSTOM_COLUMN_FK_INVALID')
def get(self, request, *args, **kwargs):
table_name = kwargs.get('table', None)
connection_id = kwargs.get('pk', None)
try:
provider_connection = self.queryset.get(id=connection_id)
provider = provider_connection.provider
if provider:
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo_by_provider(
provider_connection=provider_connection)
documents, count = mongo_db_manager.get_all_documents(db=db, collection=table_name,
column_sort=None,
sort=None, page=1, page_size=20)
# TODO: PhuongTN -> get real column from database
columns = []
real_columns = mongo_db_manager.get_all_keys(db=db, collection=table_name)
# TODO: PhuongTN -> get custom column mapping
custom_columns = CustomColumnMapping.objects.filter(connection_id=connection_id,
table_name=table_name)
if custom_columns.exists():
if count == 0:
for cc in custom_columns:
obj = {
'id': cc.id,
'real_column': cc.real_column,
'custom_column_name': cc.custom_column_name,
'custom_column_id': cc.custom_column.id
}
columns.append(obj)
else:
custom_columns = custom_columns
for rc in real_columns:
is_append = False
for cc in custom_columns:
if rc == cc.real_column:
obj = {
'id': cc.id,
'real_column': cc.real_column,
'custom_column_name': cc.custom_column_name,
'custom_column_id': cc.custom_column.id
}
columns.append(obj)
is_append = True
break
if not is_append:
obj = {
'id': None,
'real_column': rc,
'custom_column_name': None,
'custom_column_id': None
}
columns.append(obj)
else:
for rc in real_columns:
obj = {
'id': None,
'real_column': rc,
'custom_column_name': None,
'custom_column_id': None
}
columns.append(obj)
return responses.ok(data=columns, method=constant.POST, entity_name='db_provider_connection')
else:
# TODO: implement another phase
pass
else:
return responses.bad_request(data='Provider not found', message_code='PROVIDER_NOT_FOUND')
except Exception as err:
return responses.not_found(data=None, message_code='PROVIDER_CONNECTION_NOT_FOUND', message_system=str(err))
def get(self, request, *args, **kwargs):
try:
user = request.user
connection_id = kwargs.get("connection")
table_name = kwargs.get("table_name")
list_filter = kwargs.get('list_filter', None)
list_column = kwargs.get('list_column', None)
provider_connection = self.queryset.get(id=connection_id)
provider = provider_connection.provider
if provider.name == MONGO:
mongo_db_manager = MongoDBManager()
db, cache_db = mongo_db_manager.connection_mongo_by_provider(provider_connection=provider_connection)
documents = mongo_db_manager.export_db_by_column(db=db, table=table_name,
list_filter=list_filter,
list_column=list_column)
if documents.count() <= 1000:
result = json.loads(dumps(list(documents)))
headers = list(result[0].keys())
output = io.BytesIO()
workbook = xlsxwriter.Workbook(output)
worksheet = workbook.add_worksheet()
cell_format_header = workbook.add_format()
cell_format_header.set_bold()
for index in range(len(headers)):
worksheet.write(0, index, headers[index], cell_format_header)
for row_num, columns in enumerate(result):
for index in range(len(headers)):
value = columns.get(headers[index]) if index != 0 else columns.get(headers[index]).get(
'$oid')
worksheet.write(row_num + 1, index, value)
workbook.close()
output.seek(0)
today = datetime.now().strftime("%d%m%Y_%H%M%S")
filename = f"ExportData-{table_name}-{today}.xlsx"
response = HttpResponse(
output,
content_type='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
)
response['Content-Disposition'] = 'attachment; filename=%s' % filename
return response
else:
ExportData.objects.create(
provider_connection_id=provider_connection.id,
username=user.username,
table=table_name,
status=ExportData.INIT,
file_type=ExportData.EXCEL,
list_filter=list_filter,
list_column=list_column
)
return responses.ok(data="Waiting notify for export", method=constant.GET,
entity_name='export-data')
return responses.bad_request(data=None, message_code="SQL_PROVIDER_NOT_FOUND")
except Exception as err:
return responses.not_found(data=None, message_code='SQL_FUNCTION_NOT_FOUND', message_system=err)
def put(self, request, *args, **kwargs):
sql_function_id = kwargs.get('pk')
data = request.data
name = data.get('name')
connection = data.get('connection')
sql_function_order_by_id = data.get('sql_function_order_by_id')
order_by_name = data.get('order_by_name')
sql_function_merges = data.get('sql_function_merges')
sql_function_condition_items_delete = data.get(
'sql_function_condition_items_delete')
sql_function_condition_items_update = data.get(
'sql_function_condition_items_update')
sql_function_condition_items_create = data.get(
'sql_function_condition_items_create')
serializer_sql_function = self.get_serializer(data=data)
if serializer_sql_function.is_valid(raise_exception=True):
try:
# Update SqlFunction
sql_function = self.get_queryset().get(id=sql_function_id)
sql_function.name = name
sql_function.connection = DBProviderConnection.objects.get(
id=connection)
sql_function.save()
serializer_sql_function = self.get_serializer(sql_function)
# Update SqlFunctionOrderBy
sql_function_order_by = SqlFunctionOrderBy.objects.get(
id=sql_function_order_by_id)
sql_function_order_by.order_by_name = order_by_name
sql_function_order_by.save()
# Update SqlFunctionMerge
if sql_function_merges is not None:
for item in sql_function_merges:
sql_function_merge = SqlFunctionMerge.objects.get(
id=item.get('id'))
sql_function_merge.table_name = item.get('table_name')
sql_function_merge.merge_type = item.get('merge_type')
sql_function_merge.column_name = item.get(
'column_name')
sql_function_merge.save()
# Delete SqlFunctionConditionItems
if sql_function_condition_items_delete is not None:
SqlFunctionConditionItems.objects.filter(
id__in=sql_function_condition_items_delete).delete()
# Update SqlFunctionConditionItems
if sql_function_condition_items_update is not None:
for item in sql_function_condition_items_update:
sql_function_condition_item = SqlFunctionConditionItems.objects.get(
id=item.get('id'))
sql_function_condition_item.table_name = item.get(
'table_name')
sql_function_condition_item.field_name = item.get(
'field_name')
sql_function_condition_item.value = item.get('value')
sql_function_condition_item.operator = item.get(
'operator')
sql_function_condition_item.relation = item.get(
'relation')
sql_function_condition_item.save()
# Create SqlFunctionConditionItems
if sql_function_condition_items_create is not None:
for item in sql_function_condition_items_create:
SqlFunctionConditionItems.objects.create(
table_name=item.get('table_name'),
field_name=item.get('field_name'),
sql_function=sql_function,
value=item.get('value'),
operator=item.get('operator'),
relation=item.get('relation'))
return responses.ok(data=serializer_sql_function.data,
method=constant.PUT,
entity_name='sql-function')
except Exception as err:
return responses.bad_request(
data=str(err),
message_code='UPDATE_SQL_FUNCTION_HAS_ERROR')
else:
return responses.bad_request(
data=None, message_code='UPDATE_SQL_FUNCTION_INVALID')
