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')