def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
r = inject.instance(Registry)
self.conn = Connection(r.getRegistry('dcsys'))
self.students = inject.instance(StudentDAO)
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
self.serverConfig = inject.instance(Config)
self.task = inject.instance(Task)
self.profiles = inject.instance(Profiles)
def __init__(self,config=None):
logging.debug('instanciando WampDigesto')
ApplicationSession.__init__(self, config)
self.digesto = inject.instance(Digesto)
self.serverConfig = inject.instance(Config)
self.profiles = inject.instance(Profiles)
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
self.serverConfig = inject.instance(Config)
self.overtime = inject.instance(Overtime)
self.date = inject.instance(Date)
self.profiles = inject.instance(Profiles)
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
reg = inject.instance(Registry)
self.conn = connection.Connection(reg.getRegistry('dcsys'))
self.loginModel = inject.instance(Login)
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
registry = inject.instance(Registry)
self.reg = registry.getRegistry('dcsys')
self.conn = Connection(self.reg)
self.loginModel = inject.instance(Login)
self.systemsModel = inject.instance(Systems)
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
r = inject.instance(Registry)
self.conn = Connection(r.getRegistry('dcsys'))
self.tutoriasModel = inject.instance(TutoriasModel)
self.login = inject.instance(Login)
def __init__(self,config=None):
logging.debug('instanciando WampDigesto')
ApplicationSession.__init__(self, config)
reg = inject.instance(Registry)
self.conn = connection.Connection(reg.getRegistry('dcsys2'))
self.sileg = inject.instance(SilegModel)
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
self.serverConfig = inject.instance(Config)
self.users = inject.instance(Users)
self.profiles = inject.instance(Profiles)
self.mails = inject.instance(Mail)
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
self.serverConfig = inject.instance(Config)
self.date = inject.instance(model.systems.assistance.date.Date)
self.profiles = inject.instance(Profiles)
self.justifications = inject.instance(Justifications)
def terminate():
"""This function terminates whole TwitterSentimentAnalysis package
It must be called after the end of usage of TwitterSentimentAnalysis package
It closes a connection to DB if core was initialized
"""
global __core_initialized
if __core_initialized:
inject.instance(pymongo.MongoClient).close()
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
reg = inject.instance(Registry)
self.conn = connection.Connection(reg.getRegistry('dcsys'))
self.login = inject.instance(Login)
self.date = inject.instance(model.assistance.date.Date)
self.justifications = inject.instance(Justifications)
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
reg = inject.instance(Registry)
self.conn = connection.Connection(reg.getRegistry('dcsys'))
self.laboralInsertion = inject.instance(LaboralInsertion)
self.utils = inject.instance(Utils)
self.users = inject.instance(UserDAO)
self.mails = inject.instance(MailDAO)
def setUp(self):
reg = inject.instance(Registry)
registrySection = reg.getRegistry('dcsys2')
self.connection = Connection(registrySection)
def __del__(self):
if inject and inject.is_configured():
cm = inject.instance(CONNECTION_MANAGER)
if self._valid:
cm.return_session_to_pool(self)
else:
cm.decrement_sessions_count()
def api(self):
if self._api is None:
try:
self._api = inject.instance('api')
except:
raise Exception('Brocade OS', 'Api handler is none or empty')
return self._api
def cli(self):
if self._cli is None:
try:
self._cli = inject.instance('cli_service')
except:
raise Exception('Brocade OS', 'Cli Service is none or empty')
return self._cli
def call(self, to=None, **kwargs):
try:
host = config.get_command_host(name=to)
except KeyError:
raise Exception('Host alias not found.')
settings = inject.instance('settings')
uuid_ = uuid.uuid1()
for line in self.command['commands']:
line = line.replace('{host}', host)
line = line.replace('{uuid}', uuid_)
print(color_text(line, color='white', bcolor='blue'))
params = line.split(' ')
args = arg_parser.parse_args(params)
args.argv0 = sys.argv[0]
client = ApiRpcClient(host='127.0.0.1', settings=settings)
if isinstance(args.func, str):
yield getattr(client, args.func)(**vars(args))
else:
yield args.func(**vars(args))
def logger(self):
if self._logger is None:
try:
self._logger = inject.instance('logger')
except:
raise Exception('BrocadeAutoload', 'Logger is none or empty')
return self._logger
def getReactor():
config = inject.instance(Config)
# log.startLogging(sys.stdout)
factory = BroadcastServerFactory()
factory.protocol = AssistanceWebsocketServer
reactor.listenTCP(8026, factory)
return reactor
def snmp(self):
if self._snmp is None:
try:
self._snmp = inject.instance('snmp_handler')
except:
raise Exception('BrocadeAutoload', 'Snmp handler is none or empty')
return self._snmp
def __init_provider(ssid):
db = inject.instance(SQLDb)
s_sql = 'select param, value from oauthdata'
c = db.cursor()
c.execute(s_sql)
params = {p: v for p, v in c.fetchall()}
return GSpreadSheet(ssid, params)
def __init__(self):
reg = inject.instance(Registry)
#parametros generales de zksoftware
registry = reg.getRegistry('zksoftware')
self.period = int(registry.get('period'))
host = registry.get('host')
port = int(registry.get('port'))
self.zk = ZkSoftware(host, port)
self.timezone = registry.get('timezone')
self.deviceId = registry.get('device_id')
# parametros que manejan cuando se borran los logs del reloj
self.hour_start_delete = registry.get('hour_start_delete')
self.minute_start_delete = registry.get('minute_start_delete')
self.hour_end_delete = registry.get('hour_end_delete')
self.minute_end_delete = registry.get('minute_end_delete')
# parametros de la conexion a la base
registry = reg.getRegistry('dcsys')
self.host = registry.get('host')
self.db = registry.get('database')
self.user = registry.get('user')
self.passw = registry.get('password')
def increase_visits_count(sid):
uow = inject.instance('UnitOfWorkManager')
with uow.start() as tx:
short_url = tx.short_urls.get(sid)
if short_url:
short_url.increase_visits()
tx.commit()
def api(self):
if self._api is None:
try:
self._api = inject.instance('api')
except:
raise Exception('EricssonConnectivityOperations', 'Failed to get api handler.')
return self._api
def logger(self):
if self._logger is None:
try:
self._logger = inject.instance('logger')
except:
raise Exception('EricssonConnectivityOperations', 'Failed to get logger.')
return self._logger
def cli(self):
if self._cli is None:
try:
self._cli = inject.instance('cli_service')
except:
raise Exception('EricssonConnectivityOperations', 'Failed to get cli_service.')
return self._cli
def given_a_short_url_already_stored(self):
self.url = "http://www.domain.com/big-article-name-with-params/?q=qwerty&t=10"
self.given_sid = "5Y14wQ"
configure_fake_injects()
self.handler = ShortUrlHandler(user)
uow = inject.instance('UnitOfWorkManager')
uow.sess.short_urls.add(ShortUrl(self.given_sid, "http://a_url.com/"))
def test_get_inventory(self):
#Arrange
# print(type(self.driver))
# handler = Mock()
handler = inject.instance('handler')
handler.discover_snmp = Mock()
logger = inject.instance('logger')
logger.info = Mock()
context = Mock(spec=AutoLoadCommandContext)
context.resource = Mock()
context.resource.name = Mock(return_value="resource name")
#Act
self.driver.get_inventory(context)
#Assert
self.assertTrue(handler.discover_snmp.called)
pass
def getPort():
config = inject.instance(Config)
log.startLogging(sys.stdout)
factory = BroadcastServerFactory()
factory.protocol = ActionsServerProtocol
port = reactor.listenTCP(int(config.configs['firmware_port']), factory=factory, interface=config.configs['firmware_ip'])
return (reactor,port,factory)
def event_listener(self, event):
config = inject.instance(
applauncher.kernel.Configuration).fcm_notification
self.notificator._FCM_API_KEY = config.api_key
import asyncio
from asyncio import coroutine
from autobahn.asyncio.wamp import ApplicationSession
from model.config import Config
''' configuro el injector y el logger '''
logging.getLogger().setLevel(logging.DEBUG)
def config_injector(binder):
binder.bind(Config, Config('server-config.cfg'))
inject.configure(config_injector)
config = inject.instance(Config)
sid = sys.argv[1]
userId = sys.argv[2]
class WampMain(ApplicationSession):
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
self.serverConfig = inject.instance(Config)
@coroutine
def onJoin(self, details):
logging.debug('ejecutando llamadas')
def __init__(self, config=None):
logging.debug('instanciando')
ApplicationSession.__init__(self, config)
self.serverConfig = inject.instance(Config)
def get_user(user_id):
db = inject.instance('DB')
user = db.users.get_user_by_id(user_id)
return jsonify(user)
def create_store():
db = inject.instance('DB')
db.users.get_user_by_id(request.json['manager_id'])
return jsonify({'store_id': db.stores.add_store(request.json)}), 201
def api(self):
if self._api:
api = self._api
else:
api = inject.instance(API)
return api
def cli(self):
if self._cli is None:
self._cli = inject.instance(CLI_SERVICE)
return self._cli
def session(self):
return inject.instance(SESSION)
def register_readmodel_updater():
eventbus = inject.instance(EventBus)
eventbus.register_listener(update_readmodel)
def update_store(store_id):
db = inject.instance('DB')
db.users.get_user_by_id(request.json['manager_id'])
db.stores.update_store_by_id(store_id, request.json)
return jsonify({'status': 'success'})
def get_store(store_id):
db = inject.instance('DB')
store = db.stores.get_store_by_id(store_id)
return jsonify(store)
def create_goods():
db = inject.instance('DB')
num_of_goods = db.goods.add_goods(request.json)
return jsonify({'Number of items created': num_of_goods}), 201
def get_goods():
db = inject.instance('DB')
return jsonify(db.goods.get_goods())
def delete(cls, object_name):
s3 = boto3.resource("s3")
config = inject.instance(Config)
bucket_name = config.get('s3_bucket', 'letsfuk')
obj = s3.Object(bucket_name, object_name)
obj.delete()
def get_update_user(user_id):
db = inject.instance('DB')
db.users.update_user_by_id(user_id, request.json)
return jsonify({'status': 'success'})
from expects import expect, equal, contain
import inject
import requests
from retrying import retry
from yatu import bootstrap, settings
from yatu.utils import make_uri
from .context_builders import make_short_it_request
bootstrap(settings)
shortifier = inject.instance('Shortifier')
uow = inject.instance('UnitOfWorkManager')
class When_a_short_url_is_requested:
def given_a_short_url_that_is_already_created(self):
self.url = "http://www.domain.com/big-article-name-with-params/?q=qwerty&t=10"
self.sid = shortifier(self.url)
self.short_url = make_uri(self.sid)
make_short_it_request({"url": self.url, "short_url": self.sid})
def because_we_request_for_the_short_url(self):
self.result = requests.get(self.short_url, allow_redirects=False)
def it_should_return_status_code_301(self):
expect(self.result.status_code).to(equal(301))
def it_should_redirect_to_the_original_url(self):
expect(self.result.headers.get('location')).to(equal(self.url))
def logger(self):
if self._logger:
logger = self._logger
else:
logger = inject.instance(LOGGER)
return logger
import logging
import inject
from flask import render_template, flash, redirect,request, Markup, url_for
from . import bp, config
from .forms import InputUsername, InputCode, InputCredentials
from login_html_hydra.models.ResetCredentialsModel import ResetCredentialsModel
from login_html_hydra.models.exceptions import IncorrectCodeException, InvalidCredentials, MailsNotFound, UserNotFound
resetCredentialsModel = inject.instance(ResetCredentialsModel)
"""
debug
"""
"""
@bp.route('/debug/<username>', methods=['GET'])
def debug(username):
ri = resetCredentialsModel.get_indexed_reset_info(username)
return render_template('debug.html', ri=ri, version=config.version)
"""
"""
paso 1 -- ingresa su usuario
"""
@bp.route('/username', methods=['GET'])
def input_username():
form = InputUsername()
def create_user():
db = inject.instance('DB')
user_id = db.users.add(request.json)
return jsonify({'user_id': user_id}), 201
