def __build_from_query__(self):
"""
Method for build from query
:return: from query
"""
return RFUtilsDb.build_from_query(db_engine_type=self.db_engine_type,
table_name=self._table_name)
def add(self, vo, params=None, rf_transaction=None, locale=None):
"""
Method for add in query
:param vo: to add
:param params:
:param rf_transaction:
:param locale:
:return: vo inserted
"""
# Audit create vo
if RFUtilsBuilt.has_attr(vo, "createdAt"):
RFUtilsBuilt.set_attr(vo, "createdAt", datetime.datetime.now())
# Audit update vo
if RFUtilsBuilt.has_attr(vo, "updatedAt"):
RFUtilsBuilt.set_attr(vo, "updatedAt", datetime.datetime.now())
dic_params_query = {}
query_builder_insert = RFUtilsDb.build_insert_query(
vo_instance=vo, dic_params_query=dic_params_query)
result = rf_transaction.execute_query(
query_builder_insert,
dic_params_query=dic_params_query,
insert=True)
# set latest pk inserted
if len(vo.__ar_pk_fields__) == 1:
RFUtilsBuilt.set_attr(vo, vo.__ar_pk_fields__[0], result)
return vo
def list(self,
ar_fields=None,
ar_filters=None,
ar_joins=None,
ar_orders=None,
ar_groups=None,
limit=None,
params=None,
rf_transaction=None,
locale=None):
"""
Method for list query
:param ar_fields:
:param ar_filters:
:param ar_joins:
:param ar_orders:
:param ar_groups:
:param limit:
:param params:
:param rf_transaction:
:param locale:
:return: list of query
"""
dic_params_query = {}
# Build select
query_builder_select = self.__build_select_query__(
ar_fields_query=self.__get_fields_query__(ar_fields,
rf_transaction),
ar_joins_query=ar_joins)
# Build from
query_builder_form = self.__build_from_query__()
# Build joins
query_builder_joins = self.__build_joins_query__(ar_joins)
# Build where
query_builder_where = self.__build_where_query__(
ar_filters_query=ar_filters, dic_params_query=dic_params_query)
# Build groupby
# TODO
# Build orderby
query_builder_order = self.__build_order_query__(ar_orders=ar_orders)
# Build limit
query_builder_limit = self.__build_limit_query__(
limit=limit, dic_params_query=dic_params_query)
query_builder = query_builder_select + query_builder_form + query_builder_joins + query_builder_where + \
query_builder_order + query_builder_limit
ar_data = rf_transaction.execute_list_query(
query_builder, dic_params_query=dic_params_query)
ar_response = RFUtilsDb.fetch_value_query(self.vo_class, ar_data)
return ar_response
def __build_order_query__(self, ar_orders=None):
"""
Method for build order query
:param ar_orders: orders for build
:return: order query
"""
return RFUtilsDb.build_order_query(ar_orders=ar_orders,
db_engine_type=self.db_engine_type)
def __build_limit_query__(self, limit=None, dic_params_query={}):
"""
Method for muild limit
:param limit: to build
:param dic_params_query: to set limit query
:return: build limit query
"""
return RFUtilsDb.build_limit(limit=limit,
dic_params_query=dic_params_query)
def __build_joins_query__(self, ar_joins_query):
"""
Method for build joins query
:param ar_joins_query: to build
:return: joins for query
"""
return RFUtilsDb.build_joins_query(db_engine_type=self.db_engine_type,
ar_joins_query=ar_joins_query,
vo_class_name=self._vo_class_name)
def __build_where_query__(self,
ar_filters_query=None,
dic_params_query={}):
"""
Mhetod for build where query
:param ar_filters_query: to apply
:param dic_params_query: for add to apply in engine database
:return: builder with query built with filters to apply
"""
return RFUtilsDb.build_where_query(ar_filters_query=ar_filters_query,
dic_params_query=dic_params_query,
db_engine_type=self.db_engine_type)
def __get_fields_query__(self, ar_fields, rf_transaction):
"""
Method for get fields to get in query
:param ar_fields: passed for list function
:param rf_transaction: to execute query
:return: ar fields to get in query
"""
return RFUtilsDb.get_fields_query(
ar_fields=ar_fields,
rf_transaction=rf_transaction,
db_engine_type=self.db_engine_type,
ar_default_fields_table=self._fields_table)
def __build_select_query__(self,
ar_fields_query=None,
ar_joins_query=None):
"""
Method for build select query
:param ar_fields_query: to get in query
:param ar_joins_query: joins for query. Is necessary if has join is fetch
:return: select query
"""
return RFUtilsDb.build_select_query(
ar_fields_query=ar_fields_query,
ar_joins_query=ar_joins_query,
db_engine_type=self.db_engine_type,
ar_default_fields_table=self._fields_table,
vo_class_name=self._vo_class_name)
def edit(self, vo, params=None, rf_transaction=None, locale=None):
"""
Method for edit vo
:param vo: to edit
:param params:
:param rf_transaction:
:param locale:
:return: vo edited
"""
# Audit update vo
if RFUtilsBuilt.has_attr(vo, "updatedAt"):
RFUtilsBuilt.set_attr(vo, "updatedAt", datetime.datetime.now())
dic_params_query = {}
query_builder_update = RFUtilsDb.build_update_query(
vo_instance=vo, dic_params_query=dic_params_query)
rf_transaction.execute_query(query_builder_update,
dic_params_query=dic_params_query)
return vo