class SpeakerThread(threading.Thread): config = inject.attr(Config) def __init__(self, wordsQueue): super(SpeakerThread, self).__init__() self.wordsQueue = wordsQueue self._stop = threading.Event() def finish(self): print 'terminando thread' self._stop.set() def run(self): name = self.config.configs['espeak_name'] rate = int(self.config.configs['espeak_rate']) espeak.set_voice(name) espeak.set_parameter(espeak.Parameter.Rate, rate) while not self._stop.isSet(): try: phrase = self.wordsQueue.get(True, 0.05) espeak.synth(phrase.encode('utf8')) except Queue.Empty: continue
class IDHAndlers(HTTPMethodView): mongo = inject.attr(Mongo) async def get(self, request, doc_id): doc = await self.mongo.get_doc(doc_id=doc_id) if doc: return HTTPResponse(body=self.mongo.docs_to_json(doc), content_type="application/json") else: raise sanic.exceptions.NotFound( message='Cannot find document with' ' id:{0}'.format(doc_id)) async def post(self, request, doc_id): new_doc = request.json update_result = await self.mongo.insert_or_update(doc=new_doc, doc_id=doc_id) if update_result["result"] == "updated": return text('Successfully updated document with id:{0}'. format(update_result['updated_id'])) else: raise sanic.exceptions.ServerError( message='Failed to update document') async def delete(self, request, doc_id): delete_result = await self.mongo.delete_doc(doc_id=doc_id) if delete_result: return text(body='Successfully deleted document with id:{0}'.format(doc_id)) else: raise sanic.exceptions.NotFound(message='Cannot find document with' ' id:{0}'.format(doc_id))
class TestHostStompEngine(unittest.TestCase): engine = inject.attr('stompEngine') def setUp(self): self.stompProtocol = StompProtocolFactory().buildProtocol( ('127.0.0.1', 0)) self.fakeTransport = proto_helpers.StringTransport() def tearDown(self): self.fakeTransport.clear() def test_connection(self): self.stompProtocol.makeConnection(self.fakeTransport) #ignore the connection request sent. We aren't testing that here self.fakeTransport.clear() #pretend we've received successful ack of our connection request. #check that the host engine subscribes to the topics upon connection connectedMsg = """CONNECTED session:ID:snorky.local-49191-1185461799654-3:18""" self.stompProtocol.dataReceived(connectedMsg) msg1 = stomper.subscribe(destinations.CONN_DESTINATION) msg2 = stomper.subscribe(destinations.CMD_RES_DESTINATION) self.assertTrue(msg1 in self.fakeTransport.value()) self.assertTrue(msg2 in self.fakeTransport.value())
class TestUserEndpoint: repository = inject.attr(UserRepository) def setup(self): self.mongo_client.db.users.drop() def test_delete(self, client): """ Delete user """ user_id = uuid.uuid4() user = User(id=UserId(user_id), name=UserName(f"User")) self.repository.save(user) response = client.delete(f"/user/{user_id}") assert response.status_code == HTTPStatus.NO_CONTENT def test_post(self, client): """ Create a new video posting("/users") """ user_payload = { "id": str(uuid.uuid4()), "name": "Test user" } response = client.post("/users", json=user_payload) assert response.status_code == HTTPStatus.NO_CONTENT
class Connection: registry = inject.attr(Registry) def __init__(self): self.name = '{}.{}'.format(self.__class__.__module__, self.__class__.__name__) self.host = self.registry.get(self.name, 'host') self.database = self.registry.get(self.name, 'database') self.user = self.registry.get(self.name, 'user') self.password = self.registry.get(self.name, 'password') self.pool = psycopg2.pool.ThreadedConnectionPool( 10, 20, host=self.host, database=self.database, user=self.user, password=self.password, cursor_factory=DictCursor) def get(self): return self.pool.getconn() def put(self, conn): self.pool.putconn(conn)
class UserService: user_repository = inject.attr(UserRepository) def create_user(self): from flask import current_app user1 = self.user_repository.create(email=current_app.config['FLASKY_ADMIN'], username='******', password='******', confirmed=True) user2 = self.user_repository.create(email='*****@*****.**', username='******', password='******', confirmed=True) self.user_repository.add(user1) self.user_repository.add(user2) def generate_fake(self, count=100): import forgery_py for i in range(count): u = self.user_repository.create( email=forgery_py.internet.email_address(), username=forgery_py.internet.user_name(True), password=forgery_py.lorem_ipsum.word(), confirmed=True, name=forgery_py.name.full_name(), location=forgery_py.address.city(), about_me=forgery_py.lorem_ipsum.sentence(), member_since=forgery_py.date.date(True) ) self.user_repository.add(u) def add_self_follows(self): for user in self.user_repository.all(): if not user.is_following(user): user.follow(user) self.user_repository.add(user)
class Dispatcher: rec = inject.attr(records.UserRec) def dispatch(self, user_id): user: entities.User = self.rec.get(user_id) return getattr(Context, user.context, None)
class InviteMember(GenericAPIView): bh = inject.attr(BaseHandler) serializer_class = InviteMemberSerializer permission_classes = [IsAuthenticated, IsLeadTeam] def post(self, request, id): from django.db import transaction user_id = request.POST.get('user_id') id_team = request.data['team_id'] if id == id_team: user = User.objects.get(pk=user_id) team = Team.objects.get(pk=id_team) with transaction.atomic(): invite_member = UserTeam.objects.create( team=team, user=user, roll='MEMBER', status='PENDING', ) serializer = InviteMemberSerializer(team) context = {'message': 'Invite member successfull!'} return Response( context, status=status.HTTP_201_CREATED, ) else: context = {"message": "Forbiden"} return Response(context, status=status.HTTP_403_FORBIDDEN)
class ListUserInvite(GenericAPIView): bh = inject.attr(BaseHandler) serializer_class = InviteSerializer permission_classes = [IsAuthenticated, IsLeadTeam] def get(self, request, id): id_team = request.data['team_id'] if id == id_team: users_list = User.objects.filter( ~Q(userteam__team_id=id_team), is_superuser=False).order_by('date_joined') result_limit = request.GET.get('result_limit', RESULT_LIMIT) page = request.GET.get('page', PAGE_DEFAULT) paginator = Paginator(users_list, result_limit) try: users = paginator.page(page) except PageNotAnInteger: users = paginator.page(PAGE_DEFAULT) except EmptyPage: users = paginator.page(paginator.num_pages) serializer = InviteSerializer(users, many=True) content = { 'id_team': id_team, 'result_count': users_list.count(), 'page': int(page), 'next_page_flg': users.has_next(), 'result': serializer.data, } return Response(content) else: context = {"message": "Forbiden"} return Response(context, status=status.HTTP_403_FORBIDDEN)
class UserUseCase: repo: IUserRepo = inject.attr(IUserRepo) def create_user(self, name: Name) -> UserCreatedResult: user = User.create(name) self.repo.save_user(user) return UserCreatedResult( id=user.id.value, name=user.name ) def list_users(self, request: BulkRequest) -> UserListResult: return UserListResult(users=self.repo.list_users(request)) def change_name(self, user_id: UserID, new_name: Name) -> ChangeNameResult: user = self.repo.get_user(user_id) if not user: raise RuntimeError('User not found') old_name = user.name user.name = new_name if not self.repo.save_user(user): raise RuntimeError('Save user failed') return ChangeNameResult( new_name=new_name, old_name=old_name )
class InvitationUpdate(UpdateModelMixin, GenericAPIView): bh = inject.attr(BaseHandler) serializer_class = InvitationUpdateSerializer permission_classes = [ IsAuthenticated, IsNormalUser, ] lookup_field = 'pk' queryset = UserTeam.objects.all() def update(self, request, *args, **kwargs): instance = self.get_object() serializer = self.get_serializer(instance, data=kwargs, partial=True) response = self.bh.validate(serializer) if response is not None: return response serializer.save() context = {"message": "Update invitation successfully"} return Response( context, status=status.HTTP_200_OK, ) def patch(self, request, *args, **kwargs): kwargs['status'] = 'ACCEPTED' return self.update(request, *args, **kwargs) def delete(self, request, *args, **kwargs): kwargs['status'] = 'REJECTED' return self.update(request, *args, **kwargs)
class BookingCancel(UpdateModelMixin, GenericAPIView): bh = inject.attr(BaseHandler) serializer_class = BookingCancelSerializer permission_classes = [ IsAuthenticated, ] lookup_field = 'pk' queryset = StadiumRegister.objects.all() def update(self, request, *args, **kwargs): instance = self.get_object() serializer = self.get_serializer(instance, data=kwargs, partial=True) response = self.bh.validate(serializer) if response is not None: return response serializer.save() context = {"message": "Cancel this booking successfully"} return Response( context, status=status.HTTP_200_OK, ) def put(self, request, *args, **kwargs): kwargs['status'] = 'CANCEL' return self.update(request, *args, **kwargs)
class BlockInspector(object): rpc_client = inject.attr(ParityEthJsonRpc) current_block = 0 def __init__(self): self.current_block = self.rpc_client.eth_blockNumber() def get_prev_block(self) -> Transaction: return self.__get_another_block(-1) def __get_another_block(self, step: int): logger = logging.getLogger() # logger.error(e, exc_info=True, extra={"txid": transaction['hash']}) while True: print(self.current_block) block = self.rpc_client.eth_getBlockByNumber(self.current_block) if block is None: time.sleep(5) logger.info("Sleeping on ", extra={"number": self.current_block}) continue self.current_block = hex_to_dec(block['number']) + step logger.info("Fetched new block", extra={"number": self.current_block - 1}) return block def get_next_block(self) -> Transaction: return self.__get_another_block(1)
class TestUsersEndpoint: repository = inject.attr(UserRepository) def setup(self): self.mongo_client.db.users.drop() def test_get(self, client): """ return all the users getting("/users") """ for i in range(0, random.randint(1, 10)): user = User(id=UserId(uuid.uuid4()), name=UserName(f"User {i}")) self.repository.save(user) response = client.get("/users") assert response.status_code == HTTPStatus.OK assert response.headers['Content-Type'] == 'application/json' assert json.loads(response.data) == [UserEncoder.encode(u) for u in self.repository.all()] def test_post(self, client): """ Create a new video posting("/users") """ user_payload = { "id": str(uuid.uuid4()), "name": "Test user" } response = client.post("/users", json=user_payload) assert response.status_code == HTTPStatus.NO_CONTENT
class AccountLimitedRepository(BaseRepository): account = inject.attr(Account) def filter(self, *args, **kwargs): filter_kwargs = {'account': self.account} kwargs.update(filter_kwargs) return super(AccountLimitedRepository, self).filter(*args, **kwargs)
class TestCommandRegistry(unittest.TestCase): stompProtocol = inject.attr('stompProtocol') def setUp(self): self.cmdRegistry = Host.CommandRegistry() self.names = ("testVM1", "testVM2") self.ids = ("DE:AD:BE:EF:00:01", "DE:AD:BE:EF:00:02") self.descriptors = map(lambda i: EntityDescriptor(i), self.ids) for d in self.descriptors: self.cmdRegistry.vmRegistry.addVM(d) self.fakeTransport = proto_helpers.StringTransport() def tearDown(self): self.fakeTransport.clear() def test_processCmdResult(self): #depends on the implementation of VMWords self.cmdRegistry.sendCmdRequest(self.names[0], 'fooCmd') rxdFrame = stomper.unpack_frame(self.cmdRegistry.msgSender.data) cmdId = rxdFrame['headers']['cmd-id'] self.assertIn(cmdId, self.cmdRegistry._cmdReqsSent) reqSent = self.cmdRegistry._cmdReqsSent[cmdId] self.cmdRegistry.processCmdResult(rxdFrame) self.assertIn(cmdId, self._cmdReqsRcvd) self.assertEquals(reqSent, self._cmdReqsRcvd[cmdId]) self.assertEquals(reqSent, self._cmdReqsRetired[cmdId])
class SessionService: session = None session_factory = inject.attr(SessionFactory) def new_game(self, game_type): self.session = self.session_factory.create(game_type) return self.session.game.type def add_user(self, name): self.session.add_user(name) return name def add_users(self, names): self.session.add_users(names) return names def remove_user(self, name): self.session.remove_user(name) return name def remove_users(self, names): self.session.remove_users(names) return names def get_players(self): if self.session is None: raise SessionNotStartedException return self.session.get_players() def draw(self): return self.session.draw()
class SimpleEventsListComponent(BaseMainWindowSection): """Events list component""" name = 'Simple Events List' plugin_proxy: plugins.PluginProxy = inject.attr(plugins.PluginProxy) def __init__(self): super(SimpleEventsListComponent, self).__init__() self.setLayout(QtWidgets.QVBoxLayout()) self.list_widget = QtWidgets.QListWidget() self.list_widget.setMinimumSize(QtCore.QSize(0, 100)) self.list_widget.setMaximumSize(QtCore.QSize(16777215, 150)) self.list_widget.setFrameShape(QtWidgets.QFrame.StyledPanel) self.list_widget.setVerticalScrollBarPolicy( QtCore.Qt.ScrollBarAsNeeded) self.list_widget.setHorizontalScrollBarPolicy( QtCore.Qt.ScrollBarAlwaysOff) self.list_widget.setAutoScroll(False) self.list_widget.setEditTriggers( QtWidgets.QAbstractItemView.NoEditTriggers) self.list_widget.setProperty("showDropIndicator", False) self.list_widget.setDefaultDropAction(QtCore.Qt.IgnoreAction) self.list_widget.setSelectionMode( QtWidgets.QAbstractItemView.NoSelection) self.layout().addWidget(self.list_widget) def on_journal_event(self, event: journal.Event): """Add journal event name to list widget""" self.list_widget.insertItem(0, event.name) count = self.list_widget.count() if count > 10: diff = count - 10 for i in range(1, diff + 1): self.list_widget.takeItem(count - i)
class FindStudent: students = inject.attr(Students) events = inject.attr(Events) profiles = inject.attr(Profiles) config = inject.attr(Config) def handleAction(self, server, message): if (message['action'] != 'findStudent'): return False if 'student' not in message: response = { 'id': message['id'], 'error': 'no existe la info del estudiante' } server.sendMessage(response) return True if 'id' not in message['student']: response = { 'id': message['id'], 'error': 'no existe la info del estudiante' } server.sendMessage(response) return True """ chequeo que exista la sesion, etc """ sid = message['session'] self.profiles.checkAccess(sid, ['ADMIN', 'USER']) con = psycopg2.connect( host=self.config.configs['database_host'], dbname=self.config.configs['database_database'], user=self.config.configs['database_user'], password=self.config.configs['database_password']) try: st = message['student'] student = self.students.findStudent(con, st['id']) response = {'id': message['id'], 'student': student, 'ok': ''} server.sendMessage(response) return True finally: con.close()
class CreateStudent: students = inject.attr(Students) events = inject.attr(Events) profiles = inject.attr(Profiles) config = inject.attr(Config) def handleAction(self, server, message): if (message['action'] != 'createStudent'): return False if 'student' not in message: response = { 'id': message['id'], 'error': 'no existe la info del estudiante' } server.sendMessage(response) return True """ chequeo que exista la sesion, etc """ sid = message['session'] self.profiles.checkAccess(sid, ['ADMIN']) con = psycopg2.connect( host=self.config.configs['database_host'], dbname=self.config.configs['database_database'], user=self.config.configs['database_user'], password=self.config.configs['database_password']) try: student = message['student'] self.students.createStudent(con, student) con.commit() response = {'id': message['id'], 'ok': ''} server.sendMessage(response) event = {'type': 'UserUpdatedEvent', 'data': student['id']} self.events.broadcast(server, event) return True except psycopg2.DatabaseError as e: con.rollback() raise e finally: con.close()
class Handler(threading.Thread): alive = True router = inject.attr('Router') logger = inject.attr('Logger') def __init__(self, socket): super().__init__() self.transport = Transport(socket) self.client = self.__build_client(self.transport) threading.local().client = self.client def run(self): threading.Thread(name=self.name, target=self.__ping).start() while self.alive: try: packet = self.transport.recv_packet() if packet: self.router.route(self.client, packet) except SocketDisconnect: self.stop() except Exception: self.logger.exception("Exception!", exc_info=True) def stop(self): self.logger.debug("Stopping client thread..") self.alive = False threading.local().client = None try: self.transport.close() except OSError: pass def __build_client(self, transport): return Client(transport) def __ping(self): def ping(self): try: self.logger.debug("Ping client") ping = PingClient() ping.ServerTime = int(time.time()) self.transport.send_packet(ping) except SocketDisconnect: self.stop() util.periodically(lambda: ping(self), lambda: self.alive, int(os.getenv("CLIENT_CHECK_TIMEOUT", 5)))
class Transport: closed = False null_enumerator = b'\0' buffer = b'' chunk_size = 1024 logger = inject.attr('Logger') def __init__(self, socket): self.socket = socket self.logger.debug("Connected!") def send_packet(self, packet): any = Any() Any.Pack(any, packet) return self.__send(any.SerializeToString()) def recv_packet(self): if self.closed: raise SocketDisconnect() while not self.closed: try: if self.null_enumerator in self.buffer: packets = self.buffer.split(self.null_enumerator) self.buffer = self.null_enumerator.join(packets[1:]) packet = packets[0] self.logger.debug("Received packet: " + str(packet)) return self.__parse_packet(packet) else: recv = self.socket.recv(self.chunk_size) if recv == "": self.close() self.buffer += recv except: self.close() def __send(self, data): try: self.socket.sendall(data + self.null_enumerator) except: self.close() def __parse_packet(self, packet): any = Any() any.ParseFromString(packet) cl = util.import_procotol_class(any.type_url.split("/")[1]) unpacked_message = cl() any.Unpack(unpacked_message) return unpacked_message def close(self): if self.closed: return self.closed = True try: self.socket.shutdown(socket.SHUT_RDWR) self.socket.close() finally: self.logger.debug("Disconnected!") raise SocketDisconnect()
class StadiumHandler(GenericAPIView): bh = inject.attr(BaseHandler) serializer_class = ListStadiumSerializer def get(self, request, *args, **kwargs): serializer = self.get_serializer(data=request.query_params) response = self.bh.validate(serializer) if response is not None: return response request_data = { k: (lambda x: int(x))(v) for k, v in request.query_params.items() if v is not None and v != '' } timestamp_time_from = datetime.fromtimestamp(request_data['time_from']) time_from_dt = timestamp_time_from.strftime('%Y-%m-%d %H:%M:%S+00') timestamp_time_to = datetime.fromtimestamp(request_data['time_to']) time_to_dt = timestamp_time_to.strftime('%Y-%m-%d %H:%M:%S+00') stadium_registed_list = StadiumRegister.objects.filter( (Q(time_from__lt=time_from_dt) & Q(time_to__gt=time_from_dt) | Q(time_from__lt=time_to_dt) & Q(time_to__gt=time_to_dt)) & ~Q(status='Cancel')).values_list('stadium_id').all() stadium_available = Stadium.objects.exclude( id__in=stadium_registed_list).order_by('id') if ('min_price' in request_data) & ('max_price' in request_data): stadium_available = stadium_available.filter( price__range=(request_data['min_price'], request_data['max_price'])) response_stadium_list = [] for stadium_list in stadium_available: stadium = ListStadiumResponse( stadium_list.id, stadium_list.name, stadium_list.lat, stadium_list.lng, stadium_list.phone_number, stadium_list.email, stadium_list.price, stadium_list.bank_num, ) response_stadium_list.append(stadium) result_limit = request.GET.get('result_limit', RESULT_LIMIT_DEFAULT) page = request.GET.get('page', PAGE_DEFAULT) paginator = Paginator(stadium_available, result_limit) try: stadiums = paginator.page(page) except PageNotAnInteger: stadiums = paginator.page(PAGE_DEFAULT) except EmptyPage: stadiums = paginator.page(paginator.num_pages) serializer = StadiumSerializer(stadiums, many=True) response_data = { "result_count": stadium_available.count(), "page": int(page), "next_page_flg": stadiums.has_next(), "stadium": serializer.data, } return Response(response_data)
class PostService: user_repository = inject.attr(UserRepository) post_repository = inject.attr(PostRepository) def generate_fake(self, count=100): from random import randint import forgery_py user_count = len(self.user_repository.all()) for i in range(count): id = random.randint(0, user_count - 1) u = self.user_repository.get(id=id) p = self.post_repository.create( body=forgery_py.lorem_ipsum.sentences(randint(1, 3)), timestamp=forgery_py.date.date(True), author=u) self.post_repository.add(p)
class Transport: car_plates = inject.attr(CarPlates) auction_provider = inject.attr(AuctionUrlProviderBase) def find_vin_by_number(self): pass def get_auction_url_by_vin(self, vin): return self.auction_provider.get_auction_url(vin) def get_auction_url_by_number(self, number): pass def handle(self, bot, update): vin_or_number = update.message.text[7:] try: data = self.car_plates.get_data(vin_or_number) except NotValidNumberOrVin: with open("media/pulp_fiction.jpg", "rb") as fh: bot.send_photo(update.message.chat_id, fh, caption="Чекни вин или номер", reply_to_message_id=update.message.message_id) return except CarPlatesApiError: bot.send_message(update.message.chat_id, "Походу такой тачки нет", reply_to_message_id=update.message.message_id, parse_mode=telegram.ParseMode.MARKDOWN) return auction_url = "" if data.auction and data.vin: auction_url = self.get_auction_url_by_vin(data.vin) message = (f"{update.message.from_user.name}\n" f"Вот что найдено:\n" f"Гос. номер: {data.number}\n" f"VIN: {data.vin if data.vin else 'Не найден'}\n" f"Аукцион: {auction_url}") if data.vin is None: message = ( f"Поиск VIN'а по Гос номеру WIP.\n" f"Вин можно найти через @OpenDataUABot или на https://policy-web.mtsbu.ua" ) bot.send_message(update.message.chat_id, message, parse_mode=telegram.ParseMode.MARKDOWN)
class UserService: repo: IUserRepository = inject.attr(IUserRepository) def __init__(self, id: str): self._id = id def get_user(self) -> Optional[User]: return self.repo.find_by_id(self._id)
class User(object): cache = inject.attr(Cache) def __init__(self, name): self.name = name def greet(self): return '%s, %s' % (self.cache.load_greeting(), self.name)
class GetAssistanceStatus: profiles = inject.attr(Profiles) config = inject.attr(Config) assistance = inject.attr(Assistance) date = inject.attr(Date) def handleAction(self, server, message): if (message['action'] != 'getAssistanceStatus'): return False if ('request' not in message) or ('user_id' not in message['request']): response = { 'id': message['id'], 'error': 'Insuficientes parámetros' } server.sendMessage(response) return True sid = message['session'] self.profiles.checkAccess(sid, ['ADMIN-ASSISTANCE', 'USER-ASSISTANCE']) con = psycopg2.connect( host=self.config.configs['database_host'], dbname=self.config.configs['database_database'], user=self.config.configs['database_user'], password=self.config.configs['database_password']) try: userId = message['request']['user_id'] date = None if 'date' in message['request']: date = self.date.parse(message['request']['date']) status = self.assistance.getAssistanceStatus(con, userId, date) response = {'id': message['id'], 'ok': '', 'response': status} server.sendMessage(response) return True except psycopg2.DatabaseError as e: raise e finally: con.close()
class StreamsetsBalancer: pipeline_provider = inject.attr(IPipelineProvider) logger = inject.attr(ILogger) def __init__(self): self.streamsets_pipelines: Dict[ IStreamSets, List[IPipeline]] = get_streamsets_pipelines() def balance(self): while not self.is_balanced(): pipeline = self.streamsets_pipelines[most_loaded_streamsets( self.streamsets_pipelines)].pop() to_streamsets = least_loaded_streamsets(self.streamsets_pipelines) self._move(pipeline, to_streamsets) self.logger.info( f'Moved `{pipeline.get_id()}` to `{pipeline.get_streamsets().get_url()}`' ) def unload_streamsets(self, streamsets: IStreamSets): for pipeline in self.streamsets_pipelines.pop(streamsets): to_streamsets = least_loaded_streamsets(self.streamsets_pipelines) self._move(pipeline, to_streamsets) def _move(self, pipeline: IPipeline, to_streamsets: IStreamSets): self.logger.info( f'Moving `{pipeline.get_id()}` from `{pipeline.get_streamsets().get_url()}` to `{to_streamsets.get_url()}`' ) should_start = client.get_pipeline_status(pipeline) in [ IPipeline.STATUS_STARTING, IPipeline.STATUS_RUNNING ] client.delete(pipeline) pipeline.set_streamsets(to_streamsets) client.create(pipeline) self.pipeline_provider.save(pipeline) if should_start: client.start(pipeline) self.streamsets_pipelines[to_streamsets].append(pipeline) def is_balanced(self) -> bool: if len(self.streamsets_pipelines.keys()) < 2: return True # streamsets are balanced if the difference in num of their pipelines is 0 or 1 lengths = [ len(pipelines) for pipelines in self.streamsets_pipelines.values() ] return max(lengths) - min(lengths) < 2
class PersistLaboralInsertionCV: laboralInsertion = inject.attr(LaboralInsertion) events = inject.attr(Events) profiles = inject.attr(Profiles) config = inject.attr(Config) def handleAction(self, server, message): if (message['action'] != 'persistLaboralInsertionCV'): return False if 'laboralInsertion' not in message: response = {'id':message['id'], 'error':'no existe la info correspondiente a insercion laboral '} server.sendMessage(response) return True """ chequeo que exista la sesion, etc """ sid = message['session'] self.profiles.checkAccess(sid,['ADMIN','USER']) try: con = psycopg2.connect(host=self.config.configs['database_host'], dbname=self.config.configs['database_database'], user=self.config.configs['database_user'], password=self.config.configs['database_password']) laboralInsertion = message['laboralInsertion'] laboralInsertion["cv"] = base64.b64decode(laboralInsertion["cv"]) self.laboralInsertion.persistLaboralInsertionCV(con,laboralInsertion) con.commit() response = {'id':message['id'], 'ok':''} server.sendMessage(response) event = { 'type':'UserUpdatedEvent', 'data':laboralInsertion['id'] } self.events.broadcast(server,event) return True except Exception as e: con.rollback() logging.exception(e) raise e finally: con.close()
def __init__(self, config=None): logging.debug('instanciando') ApplicationSession.__init__(self, config) self.serverConfig = inject.instance(Config) self.date = inject.attr(Date) self.events = inject.attr(Events) self.mail = inject.attr(Mail) self.users = inject.attr(Users) self.offices = inject.attr(Offices) self.justifications = inject.attr(Justifications)