def send_process (self, sock_c: socket.socket, addr: str) -> None:
while True:
letter = input()
date = 'XXX'
unique_id = 'XXX'
user_name = 'SERVER'
title = 'XXX'
letter = letter
user_ip = 'XXX'
password = '******'
message = Message(
message_json=json.dumps({
'unique_id': unique_id,
'user_name': user_name,
'date': date,
'title': title,
'letter': letter,
'user_ip': user_ip,
'password': password
})
)
sock_c.send(message.to_json(is_have_secret=False).encode('utf-8'))
if letter == 'bye':
print(f'OK, bye {message.user_name}')
break
return
def align_right(msg: Message, time: int, pdf: FPDF):
"""
Writes the given text into the PDF file. Aligns text right. Handles Image
:param msg: The Message Object for sender and text
:param time: Time stamp
:param pdf: The open PDF file
:return: Nothing
"""
global old
text = "[{0}] {1}:".format(
str(datetime.fromtimestamp(int(str(time)[:10])))[:16], msg.get_name())
if old != text:
pdf.set_font(config.FONT, size=config.FONT_CHATTER)
pdf.multi_cell(200, config.FONT_CHATTER, txt=text, align='R')
old = text
pdf.set_font(config.FONT, size=config.FONT_SIZE)
if msg.is_img():
if 150 + pdf.get_y() > config.A4_HEIGHT:
pdf.add_page()
pdf.image(msg.get_msg(),
w=config.WIDTH,
h=config.HEIGHT,
x=config.A4_WIDTH - 100)
else:
pdf.multi_cell(200,
config.FONT_SIZE,
txt="{}".format(msg.get_msg()),
align='R')
def send_mails():
content = sys.stdin.read()
package_name = get_package_name()
if not package_name:
log.error('No package name suggested.')
exit(1)
(package,keyword) = get_keyword(package_name)
message_cl = Message(content, package, keyword)
message = message_cl.get_message()
tag = message_cl.get_tag()
message_cl.set_keyword(tag)
log.info('(Tag, Keyword): (%s %s)' %(tag, keyword))
subscribers = Subscribers.get_subscribers_email(package_name, tag)
# print package, keyword, message, tag, subscribers
send_mails_to_all(message_cl, list(subscribers))
def send_process(self) -> None:
while True:
letter = input()
date = 'XXX'
unique_id = 'XXX'
user_name = 'CLIENT'
title = 'XXX'
letter = letter
user_ip = socket.gethostbyname(self.host)
password = '******'
message = Message(message_json=json.dumps({
'unique_id': unique_id,
'user_name': user_name,
'date': date,
'title': title,
'letter': letter,
'user_ip': user_ip,
'password': password
}))
self.post(message)
if letter == 'bye':
print(f'OK, bye {user_name}')
break
return
def extract_json(content: list, chatters: dict):
history = list()
count = 0
for j in content:
chat = dict()
if "conversations" in j:
for c in j["conversations"]:
if "events" in c:
for e in c["events"]:
sender = e["sender_id"]["chat_id"]
timestamp = e["timestamp"]
if "chat_message" in e and "message_content" in e[
"chat_message"]:
msg = e["chat_message"]["message_content"]
if "segment" in msg:
for s in msg["segment"]:
if "text" in s:
timestamp = int(timestamp) + 1
chat.update({
timestamp:
Message(s["text"], sender, False,
chatters)
})
#if "attachment" in msg:
# for a in msg["attachment"]:
# timestamp = int(timestamp) + 1
# chat.update({timestamp: Message(a["embed_item"]["plus_photo"]["thumbnail"]
# ["image_url"], sender, True, chatters)})
print("Extracted {} messages".format(len(chat)))
count = count + len(chat)
history.append(chat)
print("Total of {} messages found!\n".format(count))
return history
def test_from_dict():
input_dict = dict(text='5: 3 1', channel='2', user='******')
message = Message.from_dict(input_dict=input_dict, token='5')
assert message.args == '1'
assert message.channel == '2'
assert message.command == '3'
assert message.user == '4'
def test_constructor():
message = Message(args='1', channel='2', command='3', user='******')
assert isinstance(message, Message)
assert message.args == '1'
assert message.channel == '2'
assert message.command == '3'
assert message.user == '4'
def get_message(self, url, **kwargs):
base_url = urlparse.urlsplit(url)
query_args = urlparse.parse_qs(base_url.query)
query_args.update(kwargs)
messages = []
message_type = 'info'
for arg_name, arg_value in query_args.iteritems():
if arg_name in ['message', 'msg', 'info']:
message_type = 'info'
elif arg_name in [
'error', 'err', 'error_message', 'error_msg', 'errormsg'
]:
message_type = 'info'
if arg_value:
messages.append(arg_value)
if messages:
message = '\n'.join(('<p>%s</p>' % msg for msg in messages))
else:
return None
if message:
return Message(message, message_type=message_type)
else:
return None
def from_tg_to_vk(vk_id, message: Message):
vk_bot.loop.run_until_complete(
vk_bot.write_msg(message=message, peer_id=vk_id))
chat_listeners = db_persistence.get_chat_listeners(vk_id)
message._tg_id = message.from_id
message._from_id = vk_id
if len(chat_listeners) > 0:
message.chat_title = vk_bot.loop.run_until_complete(
vk_bot.get_chat_title(peer_id=vk_id))
for chat_listener in chat_listeners:
chat_listener_id = int(chat_listener[0])
if db_persistence.is_exist(vk_id=chat_listener_id) \
and db_persistence.is_fully_registered(chat_listener_id):
tg_id = db_persistence.get_ids(vk_id=chat_listener_id)[0][2]
if tg_id != message.tg_id:
from_vk_to_tg(tg_id, message)
def recv_process(self, sock_c: socket.socket, addr: str) -> None:
while True:
message_json = sock_c.recv(BUFSIZE).decode('utf-8')
message = Message(message_json)
green_color = '\033[32m'
end_color = '\033[0m'
print(f'\n{green_color}{message.letter:>40}{end_color}')
return
def bulletin_board(self) -> None:
self.connect()
mode = input('mode >> ')
if mode == 'read':
log_list = self.read()
for message in log_list:
print('===============================')
print(f'ユーザー名: {message.user_name}')
print(f'ID: {message.unique_id}')
print(f'投稿時刻: {message.date}')
print('-------------------------------')
print(f'[{message.title}]')
print(message.letter, '\n')
return
if mode == 'post':
# 時刻のハッシュ値とランダム文字列を結合し、固有IDを生成
date = datetime.datetime.now().strftime('%Y/%m/%d_%H:%M:%S')
unique_id = sha256(date)[0:5] + '%x' % random.randrange(16**10)
user_name = input('ユーザー名 >> ')
title = input('タイトル >> ')
letter = input('本文 >> ')
user_ip = socket.gethostbyname(self.host)
password_plain = getpass.getpass('パスワード >> ')
password_secret = sha256(plain_text=password_plain)
password_secure = sha256_add(secret_text=password_secret,
addition=date)
message = Message(
message_json=json.dumps({
'unique_id': unique_id,
'user_name': user_name,
'date': date,
'title': title,
'letter': letter,
'user_ip': user_ip,
'password': password_secure
}))
self.post(message)
return
if mode == 'delete':
target_id = input('ID >> ')
password = hashlib.sha256(
input('パスワード >> ').encode('utf-8')).hexdigest()
self.delete(target_id=target_id, password=password)
return
def recv_process(self) -> None:
while True:
message_json = self.sock.recv(BUFSIZE).decode('utf-8')
message = Message(message_json)
if message.letter == 'bye':
print(f'OK, bye {message.user_name}')
break
green_color = '\033[32m'
end_color = '\033[0m'
print(f'\n{green_color}{message.letter:>40}{end_color}')
return
def chat_message(self):
chat_listeners = db_persistence.get_chat_listeners(self.peer_id)
if len(chat_listeners) > 0:
for chat_listener in chat_listeners:
chat_listener_id = int(chat_listener[0])
if chat_listener_id != self.from_id:
if db_persistence.is_exist(
vk_id=chat_listener_id
) and db_persistence.is_fully_registered(chat_listener_id):
tg_id = db_persistence.get_ids(
vk_id=chat_listener_id)[0][2]
self.event.client_info.update(
{'from_title': f'{self.from_user}'})
self.event.message.update(
{'chat_title': self.chat_title})
connector.from_vk_to_tg(tg_id,
Message.from_vk(self.event))
def read(self) -> List[Message]:
req = {'mode': 'read', 'json': ''}
self.sock.send(json.dumps(req).encode('utf-8'))
log_json = self.sock.recv(BUFSIZE).decode('utf-8')
log_list = json.loads(log_json)['log']
return [Message(json.dumps(l)) for l in log_list]
size = 1024
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
while True:
command = raw_input("Insert command: ")
if command == 'connect':
name = raw_input("Insert name: ")
print 'Connecting'
try:
s.connect((host, port))
handler = Handler(s, size)
playing = True
handler.start()
except socket.error as msg:
print 'Cannot connect'
s.send(json.dumps(Message(name).__dict__))
elif command == 'send':
data = raw_input("Insert data: ")
s.send(json.dumps(Message(data).__dict__))
elif command == 'recv':
response = s.recv(size)
print 'Response: \'' + response + '\''
elif command == 'leave':
playing = False
s.send(json.dumps(Message(command).__dict__))
break
else:
def post(self, message: Message) -> None:
req = {
'mode': 'post',
'json': message.to_json(is_have_secret=True).encode('utf-8')
}
self.sock.send(json.dumps(req).encode('utf-8'))
def test_repr():
message = Message(args='1', channel='2', command='3', user='******')
assert str(message) == 'Args: 1, Channel: 2, Command: 3, User: 4'
c = sort_dict(c)
count2 = 0
print("Writing PDF Number {}".format(count + 1))
print("-----------------------\n")
for key, val in c.items():
if old is not val.get_name():
old = val.get_name()
changes = changes + 1
if changes % 2 == 0:
align_left(val, key, pdf)
else:
align_right(val, key, pdf)
count2 = count2 + 1
print("Wrote {0}/{1} lines".format(count2, len(c)))
done = done + count2
pdf.output(path + "/output_{}.pdf".format(count))
count = count + 1
print("\n##########################################")
print("Wrote {0}/{1} PDF files \n{2}% Done\n".format(
count, len(content), (done / full * 100)))
return count
if __name__ == "__main__":
pdf = FPDF()
pdf.add_page()
title("Test", pdf)
align_left(Message("Links", "Dennis", False, dict()), 123456124, pdf)
align_right(Message("Rechts", "Dennis", False, dict()), 123456124, pdf)
pdf.output("../output/t.pdf")
def nex_handler(message, vk_peer_id):
user_name = db.get_username_from_tg(message.chat.id)
vk_msg = Message.from_tg(message, user_name)
connector.from_tg_to_vk(vk_peer_id, vk_msg)
db.insert_or_update_tg_state(message.chat.id, TgUserState.INITIAL)
def bulletin_board(self, sock_c: socket.socket, addr: str) -> None:
req_json = sock_c.recv(self.buf_size).decode('utf-8')
print(req_json, type(req_json))
req_dict = json.loads(req_json)
mode = req_dict['mode']
# メッセージ投稿
if mode == 'post':
post_json = req_dict['json']
message = Message(post_json)
with open('log/log.json', 'r') as f:
log_dict = json.load(f)
log_dict['log'].append(message.to_dict(is_have_secret=True))
with open('log/log.json', 'w') as f:
json.dump(log_dict, f, indent=4)
return
# ログ呼び出し
if mode == 'read':
with open('log/log.json', 'r') as f:
log_dict = json.load(f)
# クライアントに送るべきでないデータを除去
log_dict['log'] = [
Message(json.dumps(log)).to_dict(is_have_secret=False)
for log in log_dict['log']
]
print(log_dict)
sock_c.send(json.dumps(log_dict).encode('utf-8'))
return
if mode == 'delete':
post_dict = req_dict['json']
target_id, password = post_dict['target_id'], post_dict['password']
with open('log/log.json', 'r') as f:
log_dict = json.load(f)
log_dict['log'] = [
Message(json.dumps(log)).to_dict(is_have_secret=True)
for log in log_dict['log']
]
target_idx = [
i for i, message in enumerate(log_dict['log'])
if message['unique_id'] == target_id and message['password'] ==
sha256_add(password, message['date'])
]
print(log_dict)
log_dict['log'].pop(target_idx[0])
with open('log/log.json', 'w') as f:
json.dump(log_dict, f, indent=4)
return
sock_c.close()
def send(self, destination_socket, data, content_type):
"""
Sends a message to the socket.
"""
msg = Message(self.tcpsock.getsockname(), data, content_type)
destination_socket.sendall(self.encode(msg))
def post(self, message: Message) -> None:
self.sock.send(message.to_json(is_have_secret=True).encode('utf-8'))
