def _create_request(self, recorder_type, client_request, **options): ''' Creates request data. @param str recorder_type: recorder type @param dict client_request: client request @param dict client_response: client response @param dict error: error @return: request data ''' request_header = \ DynamicObject(recorder_type=recorder_type, version=RequestRecordManager.CURRENT_REQUEST_HEADER_VERSION) data = \ DynamicObject(request_header=request_header) request = \ DynamicObject(request_id=client_request.id, transaction_id=client_request.transaction_id, user_name=client_request.user_name, client_ip=client_request.ip, service_id=client_request.command_key, receieve_date=client_request.recieve_date, request_date=client_request.request_date, trace_id=client_request.trace_id, data=data) return request
def login(login_request): """ Authenticates the given credentials and returns login information. @param instance login_request: Raw request recevied from client. @return: login data @rtype: instance """ converter = login_request.get_converter() if converter is not None: login_request = converter.to_internal(login_request.get_request_dict()) else: login_request = login_request.get_request_dict() try: # For calculating execution time. process_start_time = time.time() if login_request.get('options') is None: login_request['options'] = {} login_request['options']['client_ip'] = login_request['ip'] login_info = DynamicObject() login_info.ticket = authentication_services.login(login_request['user_name'], login_request['password'], **login_request['options']) login_info.data = {} login_info.login_date = datetime.datetime.now() # Note: This should be refactored later. (see comment on `login_event'). login_event(None, None, login_request['ip'], login_request['user_name'], login_request['password'], result=login_info, **login_request['options']) LOGGER.info('User[{user}@{ip}],Channel[{channel}],Ticket[{ticket}] logged in. Time: [{execution_time}]'.format(user=login_request['user_name'], ip=login_request['ip'], channel=login_request['options'].get('channel'), ticket=login_info['ticket'], execution_time=time.time() - process_start_time)) if converter is not None: login_info = converter.to_external(login_info) return login_info except Exception as error: LOGGER.error('User[{user}@{ip}],Channel[{channel}] Login failed: {error}'.format(user=login_request['user_name'], ip=login_request['ip'], channel=login_request['options'].get('channel'), error=str(error))) raise
def register(self, invoice_items): ''' Registers new invoice. :param invoice_items: :return: ''' if invoice_items is None or len(invoice_items) <= 0: raise InvoiceException('At least one item should be included.') current_user = get_current_user() store = get_current_transaction_store() invoice = InvoiceEntity() invoice.invoice_consumer_user_id = current_user.id invoice.invoice_date = datetime.datetime.now() invoice.invoice_status = InvoiceEntity.InvoiceStatusEnum.ORDERED invoice.invoice_id = unicode(unique_id_services.get_id('uuid')) store.add(invoice) counter = 1 result = DynamicObject(entity_to_dic(invoice)) result.invoice_items = [] for item in invoice_items: item_entity = InvoiceItemEntity() item_entity.invoice_id = invoice.invoice_id item_entity.item_color = unicode(item.get('color')) item_entity.item_size = unicode(item.get('size')) item_entity.item_brand = unicode(item.get('brand')) item_entity.item_id = unicode(unique_id_services.get_id('uuid')) item_entity.item_price = Decimal(str(item.get('price'))) item_entity.item_quantity = int(item.get('quantity')) item_entity.item_row = counter item_entity.item_product_id = unicode(item.get('product_id')) products_services.decrease_product_counter( item_entity.item_product_id) product = products_services.get(item_entity.item_product_id, fetch_details=False) if (product.product_whole_sale_type == ProductsEntity.ProductWholesaleTypeEnum.WHOLESALE and current_user.user_production_type != UserEntity.UserProductionTypeEnum.PRODUCER): raise InvoiceException( "User [{0} - {1}] is not producer one and can not register " "product [{2}] which is wholesale product type.".format( current_user.user_id, current_user.user_name, product.product_name)) counter += 1 store.add(item_entity) result.invoice_items.append( DynamicObject(entity_to_dic(item_entity))) return result
def __init__(self, request, result, call_context): DynamicObject.__init__(self) self.request_id = request.id self.transaction_id = request.transaction_id self.trace_id = request.trace_id self.result = result self.context = call_context self.request_date = request.request_date self.recieve_date = request.recieve_date self.send_date = datetime.datetime.now()
def get_info(self): ''' Returns information about active request processor. @return: DynamicObject ''' processor = self.get_processor() info = DynamicObject(mode=processor.get_name()) info.update(processor.get_params()) return info
def register(self, channel_id, certificate, **options): ''' Registers a new channel. @param channel_id: channel ID @param certificate: certificate content @param **options: description: channel description enabled: channel enable flag ''' message = 'Trying to register channel [{0}]' ChannelManager.LOGGER.debug(message.format(channel_id)) # Checking channel existence if self.is_registered(channel_id): message = _('Channel {0} is already registered.') raise ChannelManagerException(message.format(channel_id)) # Checking the previous channel with the same certificate registered_channel = \ self.try_get_by_certificate(certificate) if registered_channel is not None: message = _('Certificate is in use.') raise ChannelManagerException(message) # Deciding on important parameters options['description'] = options.get('description') options['enabled'] = options.get('enabled') if options['enabled'] is None: options['enabled'] = True options['certificate_required'] = options.get('certificate_required') if options['certificate_required'] is None: options['certificate_required'] = True # Setting allowed and denied commands options['allowed'] = options.get('allowed') options['denied'] = options.get('denied') # Creating channel information channel = DynamicObject(id=channel_id, certificate=certificate) channel.update(options) # Registering channel self._channels[channel_id] = channel message = 'Channel [{0}] successfully registered' ChannelManager.LOGGER.info(message.format(channel_id))
def bulk_execute(self, commands, **options): ''' Executes a command by given key. @param commands: command data list as dict<command_key, args, kwargs>: command_key: command key args: command arguments kwargs: command keyword arguments @param **options: @return: object ''' if len(commands) == 0: raise CommandManagerException('There is no command to execute.') results = [] for command_data in commands: command_key = command_data['command_key'] args = command_data.get('args', tuple()) if not isinstance(args, (tuple, list)): args = (args, ) kwargs = command_data.get('kwargs', dict()) result = self.execute(command_key, *args, **kwargs) results.append( DynamicObject(command_key=command_key, command_result=result)) return results
def select(self, fields, command_key, *args, **kwargs): ''' Executes a command and returns requested fields. @param fields: list of requested fields @param command_key: command key @param *args: @param **kwargs: @return: [DynamicObject<fields>] ''' result = self.execute(command_key, *args, **kwargs) results = result if not isinstance(result, list): results = [result] if fields is None or len(fields) == 0: return results selected_resultes = [] for obj in results: record = DynamicObject() for field in fields: record[field] = obj.get(field) selected_resultes.append(record) return selected_resultes
def get_users(self, **options): """ Returns users using given options. @return: [DynamicObject<user info...>] """ expressions = [] statuses = options.get('statuses') if statuses is not None and len(statuses) > 0: expressions.append(In(UserEntity.user_status, statuses)) types = options.get('types') if types is not None and len(types) > 0: expressions.append(In(UserEntity.user_type, types)) store = get_current_transaction_store() entities = store.find(UserEntity, And(*expressions)) results = [] for user in entities: if user.user_id not in ('admin', 'root', 'support'): results.append(DynamicObject(entity_to_dic(user))) return results
def execute(self, ip, ticket, user_name, command_key, *args, **kargs): ''' Executes the given command. @param ip: client ip @param ticket: user ticket @param user_name: user name @param command_key: command key @return: object @note: This method is existed for backward compability. `execute_ex' should be used instead. ''' request = self._client_request_class( DynamicObject(request_id=None, transaction_id=None, request_date=None, ip=ip, ticket=ticket, user_name=user_name, command_key=command_key, command_args=args, command_kwargs=kargs, timeout=None, context=None)) response = self._communicator.execute(self, request) return response['result']
def get_product_brands(self, product_id, **options): ''' Returns product brands. :param product_id: :return: ''' store = get_current_transaction_store() statement = \ Select(columns=[ProductsBrandsEntity.product_brand, ProductsBrandsEntity.product_brand_id], where=And(ProductsBrandsEntity.product_id == product_id), tables=[ProductsBrandsEntity]) results = [] for (product_brand, product_brand_id) in store.execute(statement): results.append( DynamicObject(product_brand=product_brand, product_brand_id=product_brand_id)) concat_results = options.get('concat_results') if concat_results is None: concat_results = False if concat_results: return ','.join([b.product_brand for b in results]) return results
def get_events(self): ''' Returns all registered events. ''' results = [] for event in self._events.values(): event_hanlders = event.get_handlers() handlers = [] for event_hanlder in event_hanlders: handlers.append( DynamicObject(name=event_hanlder.get_name(), enable=event_hanlder.is_enable())) results.append( DynamicObject(name=event.get_name(), enable=event.is_enable(), handlers=handlers)) return results
def get(self, product_history_id): """ Returns product history info. :param product_history_id: :return: """ entity = self._get(product_history_id) return DynamicObject(entity_to_dic(entity))
def _session_to_dynamic_object(self, session): ''' @param session: ''' return DynamicObject(id = session.get_id(), state = session.get_state(), creation_date = session.get_creation_date(), user_id = session.get_user_id(), client_ip = session.get_client_ip())
def _create_cache_(self, sock, ip, name, data): request = ('create', name, data) request = cPickle.dumps(request) sock.send(request) response = sock.recv(MAX_DATA_SIZE) port, auth_key = cPickle.loads(response) if port == 0: raise RemoteCacheProviderException( "Could'nt create cache[{name}]".format(name=name)) return DynamicObject(ip=ip, cache_port=port, auth_key=auth_key)
def create_user(self, id, password, fullname, **options): ''' Creates a new user. @param id: user ID @param password: password @param fullname: full name @param **options: ''' return DynamicObject(id = id, password = password, name = id, fullname = fullname)
def find(self, **options): """ Searches product histories. :param optiosn: :return: """ from_edit_date = options.get('from_edit_date') to_edit_date = options.get('to_edit_date') from_price = options.get('from_price') to_price = options.get('to_price') name = options.get('name') categories = options.get('categories') include_out_of_stock = options.get('include_out_of_stock') if include_out_of_stock is None: include_out_of_stock = False expressions = [] if not include_out_of_stock: expressions.append( ProductsHistoryEntity.product_history_status == ProductsHistoryEntity.ProductHistoryStatusEnum.IN_STOCK) if from_edit_date is not None: expressions.append(ProductsHistoryEntity.product_history_edit_date >= from_edit_date) if to_edit_date is not None: expressions.append( ProductsHistoryEntity.product_history_edit_date <= to_edit_date ) if from_price is not None: expressions.append( ProductsHistoryEntity.product_history_price >= from_price) if to_price is not None: expressions.append( ProductsHistoryEntity.product_history_price >= to_price) if name is not None and name.strip() != "": expressions.append( Like(ProductsHistoryEntity.product_history_name, "%{0}%".format(name))) if categories is not None and len(categories) > 0: expressions.append( In(ProductsHistoryEntity.product_history_category, categories)) store = get_current_transaction_store() entities = store.find( ProductsHistoryEntity, And(*expressions)).order_by( ProductsHistoryEntity.product_history_edit_date) results = [] for entity in entities: results.append(DynamicObject(entity_to_dic(entity))) return results
def get(self, invoice_id): ''' Returns invoice info. :param invoice_id: :return: ''' entity = self._get(invoice_id) invoice = DynamicObject(entity_to_dic(entity)) store = get_current_transaction_store() item_entities = \ store.find(InvoiceItemEntity, InvoiceItemEntity.invoice_id == invoice_id).order_by(InvoiceItemEntity.item_row) invoice.items = [] for item in item_entities: invoice.items.append(DynamicObject(entity_to_dic(item))) return invoice
def get_permission(self, id): ''' Returns specified permission information. @param id: ''' store = get_current_transaction_store() entity = store.get(PermissionEntity, unicode(id)) if entity is None: message = _('Permission [{permission_id}] not found.') raise PermissionNotFoundException(message.format(permission_id = id)) return DynamicObject(entity_to_dic(entity))
def get(self, purchase_id): ''' Returns Purchase info. :param Purchase_id: :return: ''' entity = self._get(purchase_id) purchase = DynamicObject(entity_to_dic(entity)) store = get_current_transaction_store() item_entities = \ store.find(PurchasesCommentEntity, PurchasesCommentEntity.purchase_id == purchase_id).order_by(PurchasesCommentEntity.purchase_comment_date) purchase.items = [] for item in item_entities: purchase.items.append(DynamicObject(entity_to_dic(item))) return purchase
def logout(self, ip, ticket, user_name): ''' Log outs the user. @param ip: client ip @param ticket: user ticket @param user_name: user name ''' logout_request = self._client_request_class( DynamicObject(ip=ip, ticket=ticket, user_name=user_name)) return self._communicator.logout(self, logout_request)
def get_default_settings(self, process_unit_name): ''' Returns default settings of given process unit. @param process_unit_name: process unit name @return: DynamicObject ''' # Getting process unit default parameters params = self.__get_process_unit_config__(process_unit_name) return DynamicObject(params)
def get_by_name(self, name, category, **options): """ Returns product info. :param category: :param name: :return: """ unique_name = generate_product_unique_name(name, category) store = get_current_transaction_store() entity = store.find( ProductsEntity, ProductsEntity.product_unique_name == unique_name).one() if entity is None: raise ProductsException("Product [{0}] not found".format(name)) product = DynamicObject(entity_to_dic(entity)) fetch_details = options.get('fetch_details') if fetch_details is None: fetch_details = True if fetch_details: store = get_current_transaction_store() product.colors = [] colors = store.find( ProductsColorsEntity, ProductsColorsEntity.product_id == product.product_id) product.colors.extend( [DynamicObject(entity_to_dic(e)) for e in colors]) product.sizes = [] sizes = store.find( ProductsSizesEntity, ProductsSizesEntity.product_id == product.product_id) product.sizes.extend( [DynamicObject(entity_to_dic(e)) for e in sizes]) product.brands = [] brands = store.find( ProductsBrandsEntity, ProductsBrandsEntity.product_id == product.product_id) product.brands.extend( [DynamicObject(entity_to_dic(e)) for e in brands]) return product
def ddict_to_dict(ddct): ''' Converts a DDictionary object to Python dictionary. @param ddct: DDictionary ''' if ddct is None: return None dct = DynamicObject() for k in ddct: v = ddct[k] dct[k] = dobject_to_object(v) return dct
def get_role(self, id): ''' Returns role information by given role ID. @param role_id: role ID ''' store = get_current_transaction_store() entity = store.get(RoleEntity, unicode(id)) if entity is None: message = _('Role [{role_id}] not found.') raise RoleNotFoundException(message.format(role_id = id)) return DynamicObject(entity_to_dic(entity))
def __get_process_unit_config__(self, name): ''' Returns process unit configuration from batch.config file. @param name: process unit name ''' # Getting batch configuration store config_store = config.get_app_config_store('batch') # Getting default parameters from configuration file. if config_store.has_section(name): return config_store.get_section_data(name) return DynamicObject(thread_count=1)
def login_ex(self, ip, user_name, password, **options): ''' Logins in application. @param ip: client IP address @param user_name: user name @param password: user password ''' login_request = self._client_request_class( DynamicObject(ip=ip, user_name=user_name, password=password, options=options)) return self._communicator.login(self, login_request)
def get_user(self, id): ''' Returns user information by specified name @param id: user name @return: user data as DynamicObject ''' store = get_current_transaction_store() entity = store.get(UserEntity, unicode(id)) if entity is None: message = 'User [{user_id}] not found.' raise UserNotFoundException(message.format(user_id = id)) return DynamicObject(entity_to_dic(entity))
def get_permission_roles(self, permission_id, **options): ''' Returns all roles which are including specified permission. @param permission_id: permission ID @return: [role as DynamicObject] ''' store = get_current_transaction_store() entities = store.find(RoleEntity, And(RoleEntity.id == Role2PermissionEntity.role_id, Role2PermissionEntity.permission_id == unicode(permission_id))) results = [] for entity in entities: results.append(DynamicObject(entity_to_dic(entity))) return results
def get_role_users(self, role_id, **options): ''' Returns all user which are assigned to specified role. @param role_id: role ID @return: [user as DynamicObject] ''' store = get_current_transaction_store() entities = store.find(UserEntity, And(UserEntity.id == User2RoleEntity.user_id, User2RoleEntity.role_id == unicode(role_id))) results = [] for entity in entities: results.append(DynamicObject(entity_to_dic(entity))) return results