def __init__(self):
AccountModel.sync()
self.__options: Dict[str, View] = {
'i': InsertAccountView(),
'l': ListAccountServicesView(),
'r': ListAccountsByServiceView()
}
def update_account(name):
account = Account(name).export(load_extras=False)
prepare_account(account)
# TODO Parse coordinates
# parse_location(account)
AccountModel.objects(name=name).update(**account, upsert=True)
def on_delete(self, req, resp):
"""
DEVELOPMENT ONLY!
Delete the account, and all the files belong to this account
"""
logging.debug('in account delete')
resp_dict = {}
try:
username = req.get_header('username') or ''
password = req.get_header('password') or ''
# email = req.get_header('email') or 'email'
# params = req.get_param_as_list()
# logging.debug('params:%s'%params)
logging.debug('username:%s, password:%s' %
(username, password))
except:
raise falcon.HTTPBadRequest('bad req',
'when read from req, please check if the req is correct.')
try:
# user = AccountModel.get(AccountModel.username==username,
# AccountModel.password==password)
user = AccountModel.auth(username, password)
logging.debug('delete after auth user')
conn = swiftclient.client.Connection(self.conf.auth_url,
user.keystone_tenant+':'+user.keystone_username,
user.password,
auth_version=self.conf.auth_version)
# for container in self.conf.services:
# conn.delete_container(username+'_'+container)
logging.debug('delete after con swift user')
keystonewrap.delete_user(user.keystone_tenant,
user.keystone_username,
user.keystone_password)
logging.debug('after delete keytone user')
q = AccountModel.delete().where(AccountModel.username==username,
AccountModel.password==password)
q.execute()
resp_dict['info'] = 'user:%s deleted successfully' % username
resp_dict['username'] = username
resp.status = falcon.HTTP_200
except:
logging.debug('in delete user Exception')
resp_dict['info'] = 'delete user:%s not successfully' % username
resp.status = falcon.HTTP_400
resp.body = json.dumps(resp_dict, encoding='utf-8',
sort_keys=True, indent=4)
def put(self, id):
self.abort_if_account_doesnt_exist(id)
account = AccountModel.fromData(db.get(id))
print(account.name)
parser = reqparse.RequestParser()
parser.add_argument('type', type=str)
parser.add_argument('number', type=str)
parser.add_argument('name', type=str)
parser.add_argument('first_name', type=str)
parser.add_argument('address', type=str)
parser.add_argument('birthdate', type=str)
args = parser.parse_args()
if 'type' in args and args['type'] != None:
account.type = args['type']
if 'number' in args and args['number'] != None:
account.number = args['number']
if 'name' in args and args['name'] != None:
account.name = args['name']
if 'first_name' in args and args['first_name'] != None:
account.first_name = args['first_name']
if 'address' in args and args['address'] != None:
account.address = args['address']
location = geolocator.geocode(args['address'])
if location != None:
account.latitude = location.latitude
account.longitude = location.longitude
else:
account.latitude = None;
account.longitude = None;
if 'birthdate' in args and args['birthdate'] != None:
account.birthdate = args['birthdate']
db.put(id, account.type, account.number, account.name, account.first_name, account.address, account.birthdate,
account.latitude, account.longitude)
return account
def account(requestType):
"用户帐号模块"
g.message = request.args.get("error", "")
if requestType == "login":
#登录
if request.method == "GET":
g.title = u"登录"
g.login = True
return render_template("notes/account.html")
else:
username = request.form.get("username", None)
password = request.form.get("password", "")
password = hashlib.md5(password).hexdigest()
dbSession = sessionMaker()
query = dbSession.query(AccountModel)
obj = query.filter(AccountModel.username == username).first()
dbSession.close()
if obj == None:
#用户名不存在
return redirect(u"/notes/account/login?error=用户名不存在")
else:
if obj.password == password:
#登录成功
session['uid'] = obj.id
return redirect(url_for("notes.index"))
else:
#密码错误
return redirect(u"/notes/account/login?error=密码错误")
else:
if request.method == "GET":
g.login = False
g.title = u"注册"
return render_template("notes/account.html")
else:
username = request.form.get("username", None)
password = request.form.get("password", "")
password = hashlib.md5(password).hexdigest()
dbSession = sessionMaker()
dao = AccountModel(username, password)
dbSession.add(dao)
try:
dbSession.commit()
session['uid'] = dao.id
result = True
except:
dbSession.rollback()
result = False
dbSession.close()
if result:
return redirect(url_for("notes.index"))
else:
return redirect(u"/notes/account/register?error=用户名已经被注册")
def post(self):
parser = reqparse.RequestParser()
parser.add_argument('type', type=str, required=True, help='Account type cannot be blank!')
parser.add_argument('number', type=str, required=True, help='Account number cannot be blank!')
parser.add_argument('name', type=str, required=True, help='User Name cannot be blank!')
parser.add_argument('first_name', type=str, required=True, help='User Fist Name cannot be blank!')
parser.add_argument('address', type=str, required=True, help='User address cannot be blank!')
parser.add_argument('birthdate', type=str, required=True, help='User birthdate cannot be blank!')
args = parser.parse_args()
account = AccountModel(
account_type = args['type'],
account_number = args['number'],
name = args['name'],
first_name = args['first_name'],
address = args['address'],
birthdate = args['birthdate'],
)
account.id = db.get_max_id()+1
location = geolocator.geocode(account.address)
if location != None:
account.latitude = location.latitude
account.longitude = location.longitude
else:
account.latitude = None;
account.longitude = None;
db.post(account.type, account.number, account.name, account.first_name, account.address, account.birthdate,
account.latitude, account.longitude)
return account, status.HTTP_201_CREATED
def create_user(self, user: UserCreate) -> User:
"""
registering user
:param user: dataclass with data for auth user
:return: dataclass user
"""
old_user = (self.session.query(AccountModel).filter
(AccountModel.email == user.email).first())
if old_user is not None:
raise ThisEmailAlreadyUse()
password_hash = generate_password_hash(user.password)
new_user = AccountModel(email=user.email, password=password_hash,
first_name=user.first_name,
last_name=user.last_name)
self.session.add(new_user)
self.session.commit()
return self.get_user(new_user.as_dict().get('id'))
def save_account(account_name, access_token):
settings = company_settings.get_company_settings(account_name,
access_token)
AccountModel(id=account_name,
access_token=access_token,
company_name=settings.company_name,
currency=settings.currency,
logo_url=settings.logo_url,
address=settings.address,
phone=settings.phone).put()
products.sync_products_for_account(account_name, access_token)
def is_valid_token(token):
try:
decoded_value = jwt.decode(jwt=token, key=current_app.config['SECRET_KEY'], algorithms=['HS256'])
except jwt.exceptions.DecodeError:
return False
username = decoded_value.get('username')
password = decoded_value.get('password')
date_created = datetime.strptime(decoded_value.get('date_created'), datetime_format)
is_expired = datetime.now() - date_created > timedelta(days=10)
return AccountModel.is_valid_account(username=username, password=password) and not is_expired
def parse_location(account):
location = account['profile'].get('location')
if AccountModel.objects(
name=account['name'],
profile__location=location).first() or location is None:
# Nothing to update
return
geolocator = Nominatim(user_agent="dtrip")
location = geolocator.geocode(location)
print(location.latitude, location.longitude)
def __init__(self, config):
QObject.__init__(self)
self.account_model = AccountModel(self)
self.subscriptions = LockableDict()
self.panel_model = PanelModel(
self,
self.subscriptions,
)
self.thread = TwitterThread(self, self.subscriptions, config["limits"])
self.thread.newTweets.connect(self.newTweets.emit)
self.logger = Logger("twitter")
class Twitter(QObject):
newTweets = pyqtSignal(object, list)
newSubscription = pyqtSignal("QVariant")
accountCreated = pyqtSignal(QObject)
tweetRemoved = pyqtSignal("QVariant")
tweetChanged = pyqtSignal(bool, unicode, object)
newTweetsForModel = pyqtSignal(TweetModel, list, int)
requestSent = pyqtSignal("QVariant", "QVariant")
def __init__(self, config):
QObject.__init__(self)
self.account_model = AccountModel(self)
self.subscriptions = LockableDict()
self.panel_model = PanelModel(
self,
self.subscriptions,
)
self.thread = TwitterThread(self, self.subscriptions, config["limits"])
self.thread.newTweets.connect(self.newTweets.emit)
self.logger = Logger("twitter")
def locking(func):
@wraps(func)
def wrapper(self, *args, **kwds):
try:
func(self, *args, **kwds)
except Exception as error:
self.requestSent.emit(False, unicode(error))
else:
self.requestSent.emit(True, None)
return wrapper
def check_selected_accounts(self, accounts):
if not accounts:
raise NoAccountSelectedException(
"You have to select at least one account"
)
def on_account_connected(self, account):
self.panel_model.setScreenName(account.uuid, account.me.screen_name)
@pyqtSlot("QVariant")
def subscribe(self, request):
subscription = create_subscription(
request["type"],
request["account"],
request.get("args", "")
)
tweet_model = self.panel_model.addPanel(subscription)
self.tweetRemoved.connect(tweet_model.removeTweet)
self.tweetChanged.connect(tweet_model.replaceTweet)
self.thread.force_check.set()
@pyqtSlot("QVariant", "QVariant", "QVariant")
@async
@locking
def tweet(self, accounts, tweet, in_reply=None):
self.check_selected_accounts(accounts)
in_reply = in_reply if in_reply else None
for account in accounts:
safe_api_request(
lambda api=account.api: api.update_status(tweet, in_reply)
)
@pyqtSlot("QVariant", "QVariant")
@async
@locking
def retweet(self, accounts, tweet_id):
self.check_selected_accounts(accounts)
for account in accounts:
# warum die beiden so unterschiedlich?
status = safe_api_request(
lambda api=account.api: api.retweet(tweet_id),
)
old_status = safe_api_request(
lambda: account.api.get_status(tweet_id)
)
status.retweeted = True
status.created_at = old_status.created_at
if hasattr(old_status, "retweeted_status"):
# RTed a retweet
status.other_retweet = old_status
self.tweetChanged.emit(False, tweet_id, status)
@pyqtSlot("QVariant", "QVariant")
@async
@locking
def undo_retweet(self, accounts, tweet_id):
self.check_selected_accounts(accounts)
for account in accounts:
status = safe_api_request(
lambda: account.api.destroy_status(tweet_id)
)
self.tweetChanged.emit(True, tweet_id, status.retweeted_status)
@pyqtSlot("QVariant", "QVariant")
@async
@locking
def favorite(self, accounts, tweet_id):
self.check_selected_accounts(accounts)
for account in accounts:
self.logger.debug("api.create_favorite({0})", tweet_id)
status = safe_api_request(
lambda api=account.api: api.create_favorite(tweet_id),
)
status.favorited = True
self.tweetChanged.emit(False, tweet_id, status)
@pyqtSlot("QVariant", "QVariant")
@async
@locking
def undo_favorite(self, accounts, tweet_id):
self.check_selected_accounts(accounts)
for account in accounts:
self.logger.debug("api.destroy_favorite({0})", tweet_id)
status = safe_api_request(
lambda: account.api.destroy_favorite(tweet_id)
)
status.favorited = False
self.tweetChanged.emit(True, tweet_id, status)
# Remove tweet from Favorites-Panels
for subscription, model in self.panel_model.panels:
print repr(tweet_id), subscription.subscription_type, subscription.account, account
if subscription.subscription_type == "favorites" \
and subscription.account == account:
call_in_mainloop(model.removeTweet, tweet_id)
@pyqtSlot("QVariant", "QVariant", "QVariant")
@async
@locking
def send_direct_message(self, account, to_twitter_id, text):
safe_api_request(
lambda: account.api.send_direct_message(
user_id=to_twitter_id,
text=text
)
)
@pyqtSlot("QVariant")
@async
@locking
def destroy_tweet(self, tweet_id):
# FIXME
status = self.account_model.accounts[0].api.get_status(tweet_id)
author_id = status.author.id
for account in self.account_model.accounts:
if author_id == account.me.id:
account.api.destroy_status(tweet_id)
self.requestSent.emit(True, None)
self.tweetRemoved.emit(tweet_id)
break
else:
raise TweepError(
"This tweet doesn't belong to any of your accounts"
)
@pyqtSlot("QVariant", "QVariant")
@async
@locking
def destroy_direct_message(self, account, tweet_id):
safe_api_request(
lambda: account.api.destroy_direct_message(tweet_id)
)
self.tweetRemoved.emit(tweet_id)
@pyqtSlot(result=QObject)
def new_account(self):
account = Account()
account.setParent(self)
#account.ready.connect(partial(self.announce_account, account))
self.accountCreated.emit(account)
return account
def add_account(self, account):
self.account_model.addAccount(account)
account.connected.connect(self.on_account_connected)
def connect(self):
"""
Connects all account and starts the TwitterThread which fetches
new tweets
"""
for account in self.account_model.accounts:
account.connect()
self.thread.start()
@pyqtSlot("QVariant")
@async
@locking
def debug_tweet(self, tweet):
self.logger.debug("debug_tweet: {0}", tweet)
def delete_account(account_name):
account = AccountModel.get_by_id(account_name)
if account:
products.remove_for_account(account_name)
account.key.delete()
def get_access_token(account_name):
account = AccountModel.get_by_id(account_name)
if account:
return account.access_token
def render(self) -> None:
service = input('Qual o nome do serviço? ')
username = input('Qual o nome do usuário? ')
password = input('Qual a senha? ')
AccountModel(service, username, password).insert()
def on_get(self, req, resp):
"""
:returns: info of the user in the req.header
"""
logging.debug('in account get')
resp_dict = {}
try:
username = req.get_header('username') or ''
password = req.get_header('password') or ''
# email = req.get_header('email') or 'email'
# params = req.get_param_as_list()
# logging.debug('params:%s'%params)
logging.debug('username:%s, password:%s' %
(username, password))
except:
raise falcon.HTTPBadRequest('bad req',
'when read from req, please check if the req is correct.')
try:
logging.debug('in account model get')
# user = AccountModel.get(AccountModel.username==username,
# AccountModel.password==password)
user = AccountModel.auth(username, password)
resp_dict['info'] = 'successfully get user:%s' % username
resp_dict['username'] = user.username
resp_dict['email'] = user.email
resp_dict['account_level'] = user.account_level
resp_dict['join_date'] = user.join_date
resp_dict['keystone_info'] = user.keystone_info
resp_dict['disk_container'] = user.disk_container
resp_dict['auth'] = 1
# keystone_info = swiftwrap.createuser(new_user.keystone_tenant,
# new_user.keystone_username,
# new_user.keystone_password, new_user.account_level)
resp.status = falcon.HTTP_200
except UserNotExistException:
logging.debug('in UserNotExistException')
resp_dict['info'] = 'user:%s does not exist' % username
resp_dict['auth'] = 0
resp.status = falcon.HTTP_400
resp.body = json.dumps(resp_dict, encoding='utf-8')
except PasswordIncorrectException:
logging.debug('in PasswordIncorrectException')
resp_dict['info'] = 'user:%s password not correct' % username
resp_dict['auth'] = 0
resp.status = falcon.HTTP_400
resp.body = json.dumps(resp_dict, encoding='utf-8')
# except:
# # `username` is a unique column, so this username already exists,
# # making it safe to call .get().
# resp_dict['info'] = 'user:%s does not exist or password not right' % username
# logging.debug('user does not exist or password not right...')
# resp.status = falcon.HTTP_200
else:
resp.body = json.dumps(resp_dict, encoding='utf-8')
def on_put(self, req, resp):
"""
:param req.header.username: the username
:param req.header.password: password
:param req.header.email: email
:returns: a json contains info of the operation, if the register is
success or failed
"""
logging.debug('in account put')
resp_dict = {}
try:
username = req.get_header('username') or ''
password = req.get_header('password') or ''
email = req.get_header('email') or 'email'
# params = req.get_param_as_list()
# logging.debug('params:%s'%params)
logging.debug('username:%s, password:%s, email:%s' %
(username, password, email))
except:
raise falcon.HTTPBadRequest('bad req',
'when read from req, please check if the req is correct.')
try:
logging.debug('in account put create')
with database.atomic():
# AccountModel.create(username=username,
# password=password,
# email=email,
# join_date=str(datetime.datetime.now())+' GMT+8',
# account_level=0,
# swift_tenant='test',
# swift_username=username,
# swift_password=password)
new_user = AccountModel.create(username=username,
password=password,
email=email,
join_date=str(datetime.datetime.now())+' GMT+8',
account_level=0,
keystone_tenant=self.conf.account,
keystone_username=username,
keystone_password=password,
disk_container=username+'_'+self.conf.disk_container,
keystone_info='')
logging.debug('in account put create database.atomic')
# conn = swiftclient.client.Connection(self.conf.auth_url,
# self.conf.account_username,
# self.conf.password,
# auth_version=self.conf.auth_version or 1)
keystone_info = swiftwrap.create_user(new_user.keystone_tenant,
new_user.keystone_username,
new_user.keystone_password,
new_user.account_level)
logging.debug('keystone_info:%s' % keystone_info)
q = AccountModel.update(keystone_info=keystone_info).where(
AccountModel.username == username,
AccountModel.password == password)
q.execute()
resp_dict['info'] = 'successfully create user:%s' % username
resp_dict['username'] = username
resp.status = falcon.HTTP_201
except KeystoneUserCreateException:
logging.error('in restapi KeystoneUserCreateException!')
q = AccountModel.delete().where(AccountModel.username==username,
AccountModel.password==password)
q.execute()
resp_dict['info'] = 'create user failed, did not create user:%s' % username
resp.status = falcon.HTTP_500
resp.body = json.dumps(resp_dict, encoding='utf-8')
except peewee.IntegrityError:
logging.warning('in account put create except')
# `username` is a unique column, so this username already exists,
# making it safe to call .get().
old_user = AccountModel.get(AccountModel.username == username)
logging.warning('user exists...')
resp_dict['info'] = 'user exists, did not create user:%s' % username
resp.status = falcon.HTTP_409
try:
change_user = AccountModel.get(AccountModel.username==username,
AccountModel.password==password)
except:
logging.debug('change user data failed...')
except:
logging.error('restapi_keystone put account Exception!')
q = AccountModel.delete().where(AccountModel.username==username,
AccountModel.password==password)
q.execute()
resp_dict['info'] = 'create user failed, did not create user:%s' % username
resp.status = falcon.HTTP_400
resp.body = json.dumps(resp_dict, encoding='utf-8')
resp.body = json.dumps(resp_dict, encoding='utf-8')
def on_get(self, req, resp):
"""
:param req.header.username: the username, should be tenant:user when dev
:param req.header.password: password
:returns: a json contains all objects in disk container, and metameata
{"meta":{}, "objects":{"obj1": {}}}
"""
resp_dict = {}
try:
username = req.get_header('username')
password = req.get_header('password')
logging.debug('username:%s, password:%s' % (username, password))
except:
raise falcon.HTTPBadRequest('bad req',
'please check if the req is correct, put username and \
password in the headers.')
try:
logging.debug('self.conf.auth_url: %s, conf.auth_version: %s' % (
self.conf.auth_url, self.conf.auth_version))
user = AccountModel.auth(username, password)
resp_dict['info'] = 'successfully get user:%s' % username
resp_dict['username'] = user.username
resp_dict['email'] = user.email
resp_dict['account_level'] = user.account_level
resp_dict['join_date'] = user.join_date
resp_dict['keystone_info'] = user.keystone_info
logging.debug('before conn to swift, resp_dict:%s' % resp_dict)
conn = swiftclient.Connection(
self.conf.auth_url,
user.keystone_tenant+':'+user.keystone_username,
user.password,
auth_version=self.conf.auth_version)
meta, objects = conn.get_container(user.disk_container)
logging.debug('meta: %s, objects: %s' % (meta, objects))
resp_dict = {}
resp_dict['meta'] = meta
objs = {}
for obj in objects:
logging.debug('obj:%s' % obj.get('name'))
objs[obj.get('name')] = obj
resp_dict['objects'] = objs
logging.debug('resp_dict:%s' % resp_dict)
except UserNotExistException:
logging.debug('in UserNotExistException')
resp_dict['info'] = 'user:%s does not exist' % username
resp.status = falcon.HTTP_404
resp.body = json.dumps(resp_dict, encoding='utf-8')
except PasswordIncorrectException:
logging.debug('in PasswordIncorrectException')
resp_dict['info'] = 'user:%s password not correct' % username
resp.status = falcon.HTTP_401
resp.body = json.dumps(resp_dict, encoding='utf-8')
except:
description = ('Unknown error, username and passwd ok!')
raise falcon.HTTPServiceUnavailable(
'Service Error',
description,
30)
resp.status = falcon.HTTP_200
resp.body = json.dumps(resp_dict, encoding='utf-8',
sort_keys=True, indent=4)
def __call__(self, req, resp, path2file):
"""
:param req.header.username: the username, should be tenant:user when dev
:param req.header.password: password
:path2file the part in the request url /v1/disk/(?P<path2file>.+?), to
identify the resource to manipulate
:returns: a json contains correspond response info
GET: the temp_url of the file in a resp dict
PUT: the auth_token and storage_url in a resp dict for uploading file
DELETE: description of if the operation success or fail
"""
logging.debug('in sink req.method:%s path2file:%s' % (
req.method, path2file))
resp_dict = {}
try:
username = req.get_header('username') or 'un'
password = req.get_header('password') or 'pw'
req_dir = req.get_header('dir') or None
logging.debug('username:%s, password:%s' % (username, password))
except:
raise falcon.HTTPBadRequest('bad req',
'when read from req, please check if the req is correct.')
if req.method == 'GET':
try:
user = AccountModel.auth(username, password)
os_options = {'tenant_name':user.keystone_tenant}
storage_url, auth_token = swiftclient.client.get_auth(
self.conf.auth_url,
user.keystone_tenant+':'+user.keystone_username,
user.password,
os_options=os_options,
auth_version=self.conf.auth_version)
logging.debug('url:%s, toekn:%s' % (storage_url, auth_token))
# if path2file[-1] is '/':
if req_dir:
meta, objects = conn.get_container(user.disk_container,
delimiter='/',
prefix=req_dir)
logging.debug('meta: %s, objects: %s' % (meta, objects))
resp_dict['meta'] = meta
logging.debug('resp_dict:%s' % resp_dict)
objs = {}
for obj in objects:
logging.debug('obj:%s' % obj.get('name'))
objs[obj.get('name')] = obj
resp_dict['objects'] = objs
else:
temp_url = get_temp_url(storage_url, auth_token,
user.disk_container, path2file)
resp_dict = {}
# resp_dict['meta'] = meta
resp_dict['temp_url'] = temp_url
resp_dict['path2file'] = path2file
resp.status = falcon.HTTP_200
# logging.debug('resp_dict:%s' % resp_dict)
except UserNotExistException:
logging.debug('in UserNotExistException')
resp_dict['info'] = 'user:%s does not exist' % username
resp.status = falcon.HTTP_404
resp.body = json.dumps(resp_dict, encoding='utf-8')
except PasswordIncorrectException:
logging.debug('in PasswordIncorrectException')
resp_dict['info'] = 'user:%s password not correct' % username
resp.status = falcon.HTTP_401
resp.body = json.dumps(resp_dict, encoding='utf-8')
except:
description = ('Unknown error, username and passwd ok!')
raise falcon.HTTPServiceUnavailable(
'Service Error',
description,
30)
elif req.method == 'PUT':
try:
# if path2file:
logging.debug(' path2file:%s' % (path2file))
# logging.debug('env:%s , \nstream:%s, \ncontext:, \ninput:' % (
# req.env, req.stream.read()))
user = AccountModel.auth(username, password)
os_options = {'tenant_name':user.keystone_tenant}
storage_url, auth_token = swiftclient.client.get_auth(
self.conf.auth_url,
user.keystone_tenant+':'+user.keystone_username,
user.password,
os_options=os_options,
auth_version=self.conf.auth_version)
logging.debug('url:%s, toekn:%s, if dir:%s' %
(storage_url, auth_token, req_dir))
if req_dir:
# modify to create multiple dir when req_dir with multiple '/'
req_dir = req_dir.rstrip('/')
req_dir += '/'
content_type = 'application/directory'
obj = None
swiftclient.client.put_object(storage_url, auth_token,
user.disk_container, req_dir, obj,
content_type=content_type)
resp_dict['info'] = 'successfully create fold:%s' % req_dir
else:
logging.debug('in else')
logging.debug('url:%s, token:%s' % (storage_url, auth_token))
resp_dict['auth_token'] = auth_token
resp_dict['storage_url'] = storage_url + '/' + \
user.disk_container + '/' + path2file
resp.status = falcon.HTTP_201
logging.debug('resp_dict:%s' % resp_dict)
except:
raise falcon.HTTPBadRequest('bad req',
'username or password not correct!')
elif req.method == 'DELETE':
resp_dict = {}
try:
# if path2file:
logging.debug(' path2file:%s' % (path2file))
# logging.debug('env:%s , \nstream:%s, \ncontext:, \ninput:' % (
# req.env, req.stream.read()))
user = AccountModel.auth(username, password)
conn = swiftclient.client.Connection(self.conf.auth_url,
user.keystone_tenant+':'+user.keystone_username,
user.password,
auth_version=self.conf.auth_version)
meta, objects = conn.get_container(user.disk_container,
prefix=path2file)
logging.debug('meta: %s, \n objects: %s' % (meta, objects))
if objects:
for obj in objects:
conn.delete_object(user.disk_container, obj['name'])
resp_dict['description_'+obj['name']] = \
'{} have been deleted'.format(obj['name'])
else:
resp_dict['description'] = 'There is no file to be \
deleted'
resp.status = falcon.HTTP_204
logging.debug('resp_dict:%s' % resp_dict)
except:
raise falcon.HTTPBadRequest('bad req',
'username or password not correct!')
resp.body = json.dumps(resp_dict, encoding='utf-8',
sort_keys=True, indent=4)
def on_post(self, req, resp):
"""
:param req.header.username: the username, should be tenant:user when dev
:param req.header.password: password
:returns: a json contains the successfully changed files
"""
resp_dict = {}
try:
username = req.get_header('username') or 'un'
password = req.get_header('password') or 'pw'
logging.debug('in home post, username:%s, password:%s' % (username, password))
except:
raise falcon.HTTPBadRequest('bad req',
'when read from req, please check if the req is correct.')
try:
# logging.debug('env:%s , \nstream:%s, \ncontext:%s, \ninput:%s, \n\
# params: %s , ' % (
# req.env, req.stream.read(), req.context,
# req.env['wsgi.input'], req.params))
logging.debug('self.conf.auth_url: %s, conf.auth_version: %s' % (
self.conf.auth_url, self.conf.auth_version))
"""
TODO:
Add data_check here for robust
"""
update_list = ast.literal_eval(req.params.get('data'))
pretty_logging({'update_list':update_list})
update_list = update_list.get('disk')
move_list = []
copy_list = []
move_list = list_with_key(update_list, 'move')
copy_list = list_with_key(update_list, 'copy')
# if len(update_list) > 0:
# for pair in update_list:
# # pretty_logging(pair)
# pretty_logging(move_list, 'movelist')
# pretty_logging(copy_list, 'copylist')
# else:
# pretty_logging({}, 'no files in update_list!')
user = AccountModel.auth(username, password)
pretty_logging({'tenent:':user.keystone_tenant,
'username':user.username,
'disk_container':user.disk_container})
if len(move_list) > 0:
for pair in move_list:
# pretty_logging(pair)
pretty_logging(pair, 'movelist')
swiftwrap.move_object(user.keystone_tenant,
user.keystone_username,
user.password,
user.disk_container,
pair.get('from'),
pair.get('move'))
else:
pretty_logging({}, 'no files in update_list!')
if len(copy_list) > 0:
for pair in copy_list:
# pretty_logging(pair)
pretty_logging(pair, 'copylist')
swiftwrap.copy_object(user.keystone_tenant,
user.keystone_username,
user.password,
user.disk_container,
pair.get('from'),
pair.get('copy'))
else:
pretty_logging({}, 'no files in update_list!')
# user = AccountModel.get(AccountModel.username==username,
# AccountModel.password==password)
logging.debug('1st resp_dict:%s' % resp_dict)
resp_dict['info'] = 'successfully get user:%s' % username
resp_dict['username'] = user.username
resp_dict['email'] = user.email
resp_dict['account_level'] = user.account_level
resp_dict['join_date'] = user.join_date
resp_dict['keystone_info'] = user.keystone_info
logging.debug('2nd resp_dict:%s' % resp_dict)
except UserNotExistException:
logging.debug('in UserNotExistException')
resp_dict['info'] = 'user:%s does not exist' % username
resp.status = falcon.HTTP_404
resp.body = json.dumps(resp_dict, encoding='utf-8')
except PasswordIncorrectException:
logging.debug('in PasswordIncorrectException')
resp_dict['info'] = 'user:%s password not correct' % username
resp.status = falcon.HTTP_401
resp.body = json.dumps(resp_dict, encoding='utf-8')
except:
description = ('Unknown error, username and passwd ok!')
raise falcon.HTTPServiceUnavailable(
'Service Error',
description,
30)
resp.status = falcon.HTTP_201
resp.body = json.dumps(resp_dict, encoding='utf-8',
sort_keys=True, indent=4)
def render(self) -> None:
services = tuple(account.service for account in AccountModel.list_all())
print(services)
def render(self) -> None:
service = input('Qual o nome do serviço? ')
accounts = AccountModel.list_by_service(service)
print(tuple((a.username, a.password) for a in accounts))
