def __init__(self, data = (), header_data = ()):
Message.__init__(self, data, header_data)
self.minimum_length = self.length(Message.format + self.format)
def revoke_invite(payload, user):
"""
Revokes an invite
args: payload, user
ret: response
"""
try:
invite = Invites.get(payload['invite'])[0]
except:
return Message(
Codes.NOT_FOUND,
{'message': 'There isn\'t any active invite with the given id.'})
group = Groups.get(invite[2])[0]
owner = group[2]
if user['id'] != owner:
return Message(Codes.FORBIDDEN, {
'message':
'You have to be a group\'s owner in order to modify it.'
})
Invites.revoke(invite[0])
return Message(Codes.SUCCESS,
{'message': 'You have successfully revoked the invite.'})
def setUp(self):
self._messages = [Message(1, 'CMD Test1', '@George'),
Message(2, 'CMD Test2 param1', '@George'),
Message(3, 'CMD Test1 param1', '@Ina')]
self._exp_cmds = [Test1(username = '******', data_source='memory'),
Test2('param1', username = '******', data_source='memory'),
Test1('param1', username = '******', data_source='memory')]
def invite(payload, user):
"""
Creates an invite
args: payload, user
ret: response
"""
try:
invited_user = Users.get_by_username(payload['username'])[0]
except:
return Message(
Codes.NOT_FOUND,
{'message': 'There isn\'t any user with the given username.'})
invited_users = [
invite[0] for invite in Invites.get_group_invites(payload['group'])
]
if invited_user[0] in invited_users:
return Message(
Codes.CONFLICT,
{'message': 'This user has already been invited to the group.'})
group_users = [user[0] for user in UsersGroups.get_users(payload['group'])]
if invited_user[0] in group_users:
return Message(Codes.CONFLICT,
{'message': 'This user is already in the group.'})
Invites.create(invited_user[0], payload['group'])
return Message(
Codes.SUCCESS,
{'message': 'The requested user has been invited successfully.'})
def reset(request,session_key):
error=""
msg=None
if session_key is None:
return HttpResponse(status=404)
au=get_object_or_404(OutAuthen,session_key=session_key)
user=get_object_or_404(User,id=au.user_id)
if request.method=='POST':
password=request.POST["password"]
password2=request.POST.get("password2")
msg=Message()
if password!="" :
if password!=password2:
error = u'两次输入的密码不一致'
elif len(password)<6:
error=u'密码长度不能小于6'
if error=="":
if password!="" :
user.set_password(password)
user.save()
msg.status="success"
msg.message=u'操作成功'
au.delete()
else:
msg.status="error"
msg.message=error
template=loader.get_template("accounts/reset.html")
context=RequestContext(request,{"msg":msg,"session_key":session_key})
return HttpResponse(template.render(context))
def update(request):
"""update profile"""
error=""
msg=None
if request.method=='POST':
username=request.POST["username"].strip()
password=request.POST["password"]
password2=request.POST.get("password2")
msg=Message()
if len(username)<4 or len(username)>16:
error=u'用户名必须在4至16个字符之间，请重新设置'
elif password!="" :
if password!=password2:
error = u'两次输入的密码不一致'
elif len(password)<6:
error=u'密码长度不能小于6'
elif len(User.objects.filter(username=username)) >0 :
error=u'该用户名已经存在，请重新输入'
if error=="":
user=request.user
if user.username!=username:
user.username=username
if password!="" :
user.set_password(password)
user.save()
msg.status="success"
msg.message=u'操作成功'
else:
msg.status="error"
msg.message=error
template=loader.get_template("accounts/settings.html")
context=RequestContext(request,{"msg":msg,"title":u'帐号设置',"div_id":"settings","class_settings":"current"})
return HttpResponse(template.render(context))
def create_group(payload, user):
"""
Creates a group
args: payload, user
ret: response
"""
try:
group_id = Groups.create(payload['name'], user['id'])
Directories.create('/', user['id'], group_id)
UsersGroups.insert(user['id'], group_id)
return Message(
Codes.SUCCESS, {
'message': 'A group has been created successfully.',
'group': {
'id': group_id,
'name': payload['name'],
'owner': {
'id': user['id'],
'username': user['username'],
'full_name': user['full_name']
}
}
})
except lite.IntegrityError:
return Message(Codes.BAD_REQUEST,
{'message': 'The requesting user has been deleted.'})
def test_ruler_sending_messages(self):
messages = [
Message(king_shan, "Air", "oaaawaala"),
Message(king_shan, "Land", "a1d22n333a4444p"),
Message(king_shan, "Ice", "zmzmzmzaztzozh")
]
for message in messages:
self.southeros.send_message(message)
assert self.southeros.get_ruler_problem_1() == king_shan
def validation_wrapper(payload, *args, **kwargs):
if is_payload_valid(payload, rules):
return func(payload, *args, **kwargs)
else:
return Message(
Codes.BAD_REQUEST,
{'message': 'The requests\'s payload is invalid.'})
def wrapper(payload, *args, **kwargs):
editors = Editors.get(payload['editor'])
if not editors:
return Message(Codes.NOT_FOUND, {'message': 'Editor not found.'})
return func(payload, *args, **kwargs)
def connected(self, protocol):
"""Handles connection."""
Service.connected(self, protocol)
self.protocol = protocol
self.send(Message(self.name, Message.TYPE_LOGIN))
return
def wrapper(payload, *args, **kwargs):
if not directory_exists(payload['directory']):
return Message(
Codes.NOT_FOUND,
{'message': 'A directory with this id was not found.'})
return func(payload, *args, **kwargs)
def delete_directory(payload, user):
"""
Deletes a directory
args: payload, user
ret: response
"""
directory_files = Files.get_directory_files(payload['directory'])
sub_directories = Directories.get_sub_directories(payload['directory'])
while sub_directories:
directory_files += Files.get_directory_files(sub_directories[0][0])
sub_directories += Directories.get_sub_directories(sub_directories[0][0])
sub_directories = sub_directories[1:]
for f in directory_files:
Files.delete(f[0])
Directories.delete(payload['directory'])
return Message(
Codes.SUCCESS,
{ 'message': 'The directory has been deleted successfully!' }
)
def update_user(token, full_name=None, password=None):
"""
Updates the current user
args: token, full_name, password
ret: response
"""
request = Message(Codes.UPDATE_USER, {'token': token})
if full_name:
request.payload['full_name'] = full_name
if password:
request.payload['password'] = password
return Connection().send_recieve(request)
def iteration(self):
"""
Does a connection iteration (checks for a user request and handles it)
args: self
ret: should_stop
"""
should_stop = self.stop.wait(EVENT_TIMEOUT)
if should_stop:
return True
try:
data = self.get_data()
if not data:
return True
message = Message.deserialize(data)
Logger.log_activity(message)
self.handle_message(message)
except socket.error:
pass
except:
self.send_bad_request()
return False
class TestWechatPush(unittest.TestCase):
user = User(userName='******',
password='******',
wechatId='MAIZHILING',
wechatName='dalaomai')
rule = Rule(
id=1,
webName="佛山市人民政府",
webUrl="http://www.foshan.gov.cn/zwgk/zwdt/jryw/",
ruleModel="regular",
rulePattern=
r'<li [\s\S]*?([0-9]{4}-[0-9]{2}-[0-9]{2})[\s\S]*?href="([\s\S]*?)"[\s\S]*?title="([\s\S]*?)" >',
titlePosition="2",
hrefPosition="1",
timePosition="0",
isEffect=1)
msg = Message("test", "http://www.foshan.gov.cn/zwgk/zwdt/jryw/",
"2019-1-8")
rule.addMessage(msg)
rule.addMessage(msg)
user.addRule(rule)
user.addRule(rule)
def testBaseMethod(self):
wechatPush = WechatPush()
self.assertEqual(wechatPush.getAccessToken(), 0)
text = wechatPush.structureMessageTextByMessage(self.msg)
self.assertEqual(wechatPush.sendMessages(self.user, text), 0)
self.assertEqual(wechatPush.push(), 0)
return
def wrapper(payload, user, *args, **kwargs):
if not is_in_directory_context(payload['directory'], user['id']):
return Message(
Codes.FORBIDDEN,
{'message': 'You are not in the directory\'s context.'})
return func(payload, user, *args, **kwargs)
def ping(payload):
"""
Returns an empty response to test connection
args: payload, user
ret: response
"""
return Message(Codes.SUCCESS, {})
def create_user(payload):
"""
Creates a user
args: payload, user
ret: response
"""
try:
user_id = Users.create(**payload)
Directories.create('/', user_id)
return Message(Codes.SUCCESS,
{'message': 'A user was created successfully!'})
except lite.IntegrityError:
return Message(
Codes.CONFLICT,
{'message': 'A user with this username already exists.'})
def send(self, messType, data):
try:
self.client.sendall(pickle.dumps(Message(messType, data)))
if messType == 'get':
return pickle.loads(self.client.recv(2048 * 4)).read()
# send a confirmation? is this all handled by sendall?
except socket.error as e:
print(e)
def wrapper(payload, user, *args, **kwargs):
if not is_file_owner(payload['file'], user['id']):
return Message(Codes.FORBIDDEN, {
'message':
'You have to be a file\'s owner in order to modify it.'
})
return func(payload, user, *args, **kwargs)
def pm_factory(PackageManager=Dnf, logger=Message()):
assert issubclass(PackageManager, PackageManagerAbstract), \
'PackageManager param must be subclass of PackageManagerAbstract'
pm_setup = Setup(logger=logger, system=PackageManager())
return pm_setup
def wrapper(payload, *args, **kwargs):
groups = Groups.get(payload['group'])
if not groups:
return Message(Codes.NOT_FOUND,
{'message': 'A group with this id was not found.'})
return func(payload, *args, **kwargs)
def get_user_data(token):
"""
Gets the current user's data
args: token
ret: response
"""
return Connection().send_recieve(
Message(Codes.GET_USER_DATA, {'token': token}))
def wrapper(payload, user, *args, **kwargs):
if not UsersGroups.is_in_group(user['id'], payload['group']):
return Message(
Codes.FORBIDDEN, {
'message':
'You have to be a group\'s user in order to get information about it.'
})
return func(payload, user, *args, **kwargs)
def wrapper(payload, user, *args, **kwargs):
if not is_directory_editor(payload['directory'], user['id']):
return Message(
Codes.FORBIDDEN, {
'message':
'You have to be a directory\'s editor in order to modify it.'
})
return func(payload, user, *args, **kwargs)
def log_in(payload):
"""
Logs a user in
args: payload, user
ret: response
"""
token = Users.log_in(**payload)
if token:
return Message(Codes.SUCCESS, {
'message': 'You have logged in successfully.',
'token': token
})
else:
return Message(
Codes.UNAUTHORIZED,
{'message': 'The credentials you have provided are invalid.'})
def kick_group_user(payload, user):
"""
Kicks a user
args: payload, user
ret: response
"""
if payload['user'] == user['id']:
return Message(Codes.BAD_REQUEST,
{'message': 'The owner of the group cannot be kicked.'})
if not UsersGroups.is_in_group(payload['user'], payload['group']):
return Message(Codes.NOT_FOUND,
{'message': 'This user is not a member of the group.'})
UsersGroups.delete(payload['user'], payload['group'])
return Message(Codes.SUCCESS, {'message': 'Kicked the user successfully.'})
async def auth(self, user, password):
s = time.time()
post_message = Message.spawn_post_msg(FC.AUTH, {
'user': user,
'password': password
})
post_message.add_flag(MsgFlag.NEED_ACK)
recv_message = await self.write(post_message)
return time.time() - s
def send_recieve(self, message):
"""
Sends a request and returns the response
args: self, message
ret: response
"""
self.socket.send(message.serialize())
return Message.deserialize(self.recieve_data())
def handle_get():
switch = {
'mapPath': self.room.mapPath,
'boats': [boat.get_attr() for boat in self.room.game.flotilla],
'buoys': [buoy.get_attr() for buoy in self.room.game.buoys],
'wind': self.room.game.wind
}
reply = Message('give', switch[mess.data])
self.send(reply)
def __getUnPushedMessagesSaveInRule(self, user, rule):
'''
'''
sql = "select title,href,time from UnPushed where ruleId = " + str(
rule.id) + " and userId=" + str(user.id)
results = self.__getFromDB(sql)
for result in results:
rule.addMessage(
Message(title=result[0], href=result[1], time=result[2]))
return 0
def __init__(self, data = (), header_data = ()):
Message.__init__(self, data, header_data)
self.minimum_length = self.length(Message.format + self.format)
