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