async def get_info(msg):
link = str(msg.content).split(' ')[0]
p = Post(link.split('@')[1])
if check_age(p, 2, 48):
embed = discord.Embed(color=0xe3b13c)
embed.add_field(name="Title", value=str(p.title), inline=False)
embed.add_field(name="Author", value=str("@" + p.author), inline=True)
embed.add_field(name="Nominator",
value=str('<@' + msg.author.id + '>'),
inline=True)
embed.add_field(name="Age",
value=str(p.time_elapsed())[:-10] + " hours",
inline=False)
embed.add_field(name="Payout", value=str(p.reward), inline=True)
embed.add_field(name="Payout in USD",
value=await payout(p.reward, sbd_usd, ste_usd),
inline=True)
embed.set_footer(
text="Marshal - a Steem bot by Vctr#5566 (@jestemkioskiem)")
return embed
else:
age_error = await client.send_message(
msg.channel, 'Your post has to be between 2h and 48h old.')
await client.delete_message(msg)
await asyncio.sleep(6)
await client.delete_message(age_error)
def upvote(self, op):
try:
post = Post(op['memo'])
except ValueError:
logger.info('Invalid identifier: %s', op['memo'])
self.refund(op, message='invalid url')
return
try:
weight = self.upvote_weight
post.upvote(weight=weight, voter=self.watch_account)
except VotingInvalidOnArchivedPost as e:
logger.info('Archived post. Cannot upvote. %s', op['memo'])
self.refund(op,
message='Couldnt vote. Archived post. %s' % op['memo'])
return
except Exception as e:
if 'already voted' in e.args[0]:
self.refund(op, message='Already upvoted. %s' % op['memo'])
logger.info('Already voted: %s. Skipping.', op['memo'])
return
if 'Read timed' in e.args[0]:
logger.info('Node is not responding. Trying again to upvote.')
return self.upvote(op)
logger.info('Upvoted %s with weight: %s', op['memo'], weight)
def upvote(self, weight, identify):
post = Post(post=identify, steemd_instance=self.s)
voters_list = self.voters(identify)
voted = {}
for username in self.keys_username:
try:
post.vote(weight, username)
voted[username] = {
"status": True,
"weight": weight,
"not": "voted"
}
except:
if username in voters_list:
voted[username] = {
"status": False,
"weight": weight,
"not": "already voted"
}
else:
voted[username] = {
"status": False,
"weight": weight,
"not": "Unknown"
}
return voted
def GetStats(self):
start_time = time.time()
comment_string = ""
postdetails = self.url_var.split("/")
#postdetails = ['', '', 'ekklesiagora', 'on-poverty-gentrification-addiction-and-homelessness']
#authortemp = '@ekklesiagora'
print(postdetails)
temp_dict = {'author': postdetails[2], 'permlink': postdetails[3]}
getpost = Post(temp_dict, steem)
print(getpost.items())
totalvotes = len(getpost['active_votes'])
comment_string += "<h3> Hello @"+self.initiator+" | Here are the stats of the <a href='https://steemit.com"+self.url_var+"'> Main Post </a></h3>"
comment_string += "<h5> Total Votes: "+str(totalvotes)+"</h5>"
if totalvotes == 0:
pass
else:
if totalvotes == 1:
high_weight = self.Highest_Voting_Weight(getpost['active_votes'])
comment_string += "<h5> Highest Voting Weight: @"+str(high_weight)+"</h5>"
else:
high_weight = self.Highest_Voting_Weight(getpost['active_votes'])
comment_string += "<h5> Highest Voting Weight: @"+str(high_weight)+"</h5>"
low_weight = self.Lowest_Voting_Weight(getpost['active_votes'])
comment_string += "<h5> Lowest Voting Weight: @"+str(low_weight)+"</h5>"
comment_string += "<h5>Votes Details: </h5>"
post_creation_date = self.Get_Created_Date(getpost['created'])
print(comment_string)
author_adj = postdetails[2].replace("@","")
resteems = steem.get_reblogged_by(author_adj, postdetails[3])
print(len(resteems))
print("================================================================\n")
comments_detail = steem.get_content_replies(author_adj, postdetails[3])
print(len(comments_detail))
def designated_post_for_self_vote_report(self):
today = datetime.utcnow().date().strftime("%Y-%m-%d")
post_title = self.self_voter_report_options.get("title").format(
date=today)
permlink = "self-voter-list-%s" % today
try:
return Post(
"%s/%s" % (self.bot_account, permlink),
steemd_instance=self.steemd_instance,
)
except steembase.exceptions.PostDoesNotExist:
pass
try:
self.steemd_instance.commit.post(
post_title,
open(self.self_voter_report_options.get(
"post_template")).read(),
self.bot_account,
tags=self.self_voter_report_options.get("tags"),
permlink=permlink,
)
except Exception as e:
if 'You may only post once every 5 minutes' in e.args[0]:
logger.info("Sleeping for 300 seconds to create a new post.")
time.sleep(300)
return self.designated_post_for_self_vote_report
raise
return Post("%s/%s" % (self.bot_account, permlink),
steemd_instance=self.steemd_instance)
def content_save(self, request, *args, **kwargs): # for me
self.community = request.community_model
self.tag = self.ready_tags()
self.dor = self.durationofread(self.content + self.title)
self.permlink = slugify(self.title.lower())
self.definition = self.prepare_definition(self.content)
while True: # hem coogger'da hemde sistem'de olmaması gerek ki kayıt sırasında sorun çıkmasın.
try: # TODO: buralarda sorun var aynı adres steemit de yokken coogger'da vardı ve döngüden çıkamadı.
Content.objects.filter(
user=self.user, permlink=self.permlink)[0] # db de varsa
try:
Post(post=self.get_absolute_url()).url # sistem'de varsa
self.new_permlink(
) # change to self.permlink / link değişir
except:
pass
except:
try:
Post(post=self.get_absolute_url()).url # sistem'de varsa
self.new_permlink(
) # change to self.permlink / link değişir
except:
break
steem_save = self.steemconnect_post(self.permlink, "save")
if steem_save.status_code == 200:
super(Content, self).save(*args, **kwargs)
return steem_save
def get_post(self, post):
if not post.author or post.author != self.author:
return
kwargs = {'author': post.author, 'permlink': post.slug}
try:
blockchain_post = Post(post=kwargs, steemd_instance=self.steem)
except:
return
votes = blockchain_post.get(
'net_votes') # len(post.get('active_votes'))
post.votes = votes
# pending reward
reward_pending_amount = blockchain_post.get(
'total_pending_payout_value')
amount = reward_pending_amount.get('amount')
asset = reward_pending_amount.get('asset')
if amount > 0:
post.reward = amount
self.set_asset(post, asset)
# payouts reward
total_payout_value = blockchain_post.get('total_payout_value')
amount = total_payout_value.get('amount')
asset = total_payout_value.get('asset')
self.set_asset(post, asset)
if amount > 0:
post.reward = amount
post.complete = True
if not post.reward:
post.save()
return
if post.provider == 'golos':
# calc BTC
local_course = self.get_local_course()
if local_course:
base_course = local_course.get('base')
if base_course:
gbg_course = float(base_course.split(' ')[0])
gbg_golos = post.reward / gbg_course
api = Bittrex(settings.BITTREX_KEY,
settings.BITTREX_SECRET)
btc_cost = api.get_ticker('BTC-GOLOS').get('result').get(
'Ask')
post.btc = btc_cost * gbg_golos
# calc RUB reward
rub_course = Coinapult().get_current_price(currency='RUB')
post.rub = post.btc * float(rub_course)
else:
return # TODO set it for steem
post.save()
async def on_message(message):
msg = message
msgcon = msg.content
msgaut = '@' + msg.author.name
if bot_role not in [
y.name.lower() for y in message.author.roles] and \
message.channel.id in allowed_channels:
if message.content.startswith('https://steemit') or \
message.content.startswith('steemit'):
smsgcon = msgcon.split('@')[1]
tmsgcon = msgcon.split('/')[3]
sp = Post(smsgcon)
if sp.time_elapsed() > datetime.timedelta(hours=2) and \
sp.time_elapsed() < datetime.timedelta(hours=48):
tempmsg = await client.send_message(
message.channel,
'The post is ' + str(sp.time_elapsed())[:-7] +
' hours old and earned ' + str(sp.reward))
res = await client.wait_for_reaction(['☑'], message=msg)
if moderating_roles[0] in [
y.name.lower() for y in res.user.roles
] or moderating_roles[1] in [
y.name.lower() for y in res.user.roles
]:
await client.delete_message(msg)
await client.delete_message(tempmsg)
if tmsgcon in tag_list:
dest_channel = tag_list.index(tmsgcon)
else:
dest_channel = tag_list.len()
await client.send_message(
client.get_channel(channels_list[dest_channel]),
content=msgaut + ' sent: ' + msgcon)
else:
tempmsg = await client.send_message(
message.channel,
'Your post has to be between 2h and 48h old.')
await client.delete_message(msg)
elif message.content.startswith('!ping') and moderating_roles[0] in [
y.name.lower() for y in message.author.roles
] or moderating_roles[1] in [
y.name.lower() for y in message.author.roles
]:
await client.send_message(message.channel, ':ping_pong: Pong!')
elif bot_role not in [y.name.lower() for y in message.author.roles]:
await client.delete_message(msg)
await client.send_message(message.channel,
content=msgaut +
' Your link has to start with '
'"https://steemit" or "steemit"')
def get_video(self, name, path):
video_metadata = User.get_video_unauthorized(name, path)
self._cur_post = Post(
{
'author': video_metadata['author'],
'permlink': video_metadata['name'],
}, self._steem)
return self._cur_post
def test_getPost(self):
self.assertEqual(
Post("@xeroc/piston", steem_instance=steem).url,
"/piston/@xeroc/piston")
self.assertEqual(
Post({
"author": "@xeroc",
"permlink": "piston"
},
steem_instance=steem).url, "/piston/@xeroc/piston")
def upsert_comment(mongo, identifier):
""" Upsert root post or comment. """
with suppress(PostDoesNotExist):
p = Post(identifier)
update = {'$set': strip_dot_from_keys(p.export())}
if p.is_comment():
return mongo.Comments.update(
{'identifier': p.identifier},
update, upsert=True)
return mongo.Posts.update({'identifier': p.identifier}, update, upsert=True)
def handle_curation(self, op_type, op_value):
curators = [c["account"] for c in get_curators()]
# we're only interested in votes
if op_type != "vote":
return
# if the voter is not a trusted curator, skip it.
if op_value.get("voter") not in curators:
return
# check the post if we have already voted?
p = Post("%s/%s" % (op_value.get("author"), op_value.get("permlink")),
steemd_instance=self.s)
# we're only interested in main posts
if not p.is_main_post():
return
# the post is tagged with the tags we defined?
if len(set(self.expected_tags).intersection(p.get("tags"))) == 0:
return
# is the author in the blacklist?
if is_blacklisted(op_value.get("author")):
return
score = 0
already_voted = False
curators_on_the_post = []
for active_vote in p.get("active_votes", []):
if active_vote.get("voter") == self.bot_account:
already_voted = True
if active_vote.get("voter") in curators:
score += active_vote.get("percent")
curators_on_the_post.append({
"curator":
active_vote.get("voter"),
"weight":
active_vote.get("percent"),
})
# if we already voted on that, skip.
if already_voted:
return
# if the score is lower then the threshold, skip.
if score < int(get_option(THRESHOLD_OPTION_ID)["value"]):
return
bot_account = Account(self.bot_account, steemd_instance=self.s)
weight = bot_account.voting_power()
self.upvote(p, weight, self.bot_account)
self.post_to_webhooks(p, curators_on_the_post, score, weight)
def get_latest_flags(self):
flags = {}
total_amount = 0
account = Account(self.account_for_flag_report,
steemd_instance=self.steemd_instance)
for vote in account.history_reverse(filter_by="vote"):
if vote["weight"] > 0:
continue
if vote["voter"] != self.account_for_flag_report:
continue
ts = parse(vote["timestamp"])
if ts < (datetime.utcnow() - timedelta(days=1)):
break
try:
p = Post("%s/%s" % (vote["author"], vote["permlink"]),
steemd_instance=self.steemd_instance)
except steembase.exceptions.PostDoesNotExist:
logger.info("Couldnt load the post. %s" % vote["permlink"])
continue
if vote["author"] not in flags:
flags[vote.get("author")] = {
"posts": 0,
"comments": 0,
"total_removed": 0
}
if p.is_main_post():
flags[vote.get("author")].update(
{"posts": flags[vote.get("author")]["posts"] + 1})
else:
flags[vote.get("author")].update(
{"comments": flags[vote.get("author")]["comments"] + 1})
logger.info("Analyzing %s" % self.url(p))
for active_vote in p.get("active_votes"):
if float(active_vote.get("rshares")) > 0:
continue
if active_vote.get("voter") != self.account_for_flag_report:
continue
amount_removed = self.get_payout_from_rshares(
active_vote.get("rshares"))
total_amount += amount_removed
flags[vote.get("author")].update({
"total_removed":
flags[vote.get("author")]["total_removed"] +
amount_removed,
})
return flags, round(total_amount, 2)
async def get_info(msg):
link = str(msg.content).split(' ')[0]
p = Post(link.split('@')[1])
embed=discord.Embed(color=0xe3b13c)
embed.add_field(name="Title", value=str(p.title), inline=False)
embed.add_field(name="Author", value=str("@"+p.author), inline=True)
embed.add_field(name="Nominator", value=str('<@'+ msg.author.id +'>'), inline=True)
embed.add_field(name="Age", value=str(p.time_elapsed())[:-10] +" hours", inline=False)
embed.add_field(name="Payout", value=str(p.reward), inline=True)
embed.add_field(name="Payout in USD", value=await payout(p.reward,sbd_usd,ste_usd), inline=True)
return embed
def upsert_comment(mongo, identifier):
""" Upsert root post or comment. """
with suppress(PostDoesNotExist):
p = Post(identifier)
if p.is_comment():
return mongo.Comments.update({'identifier': p.identifier},
p.export(),
upsert=True)
return mongo.Posts.update({'identifier': p.identifier},
p.export(),
upsert=True)
def update_last_post(post_id):
global _last_post_id
global _last_post_created
identifier = construct_identifier(post_id['username'], post_id['permlink'])
if identifier is not _last_post_id:
steemd_instance = get_steem_conn()
steem_post = Post(identifier, steemd_instance=steemd_instance)
_last_post_id = identifier
_last_post_created = steem_post.get('created')
async def check_age(msg,low,high):
link = str(msg.content).split(' ')[0]
p = Post(link.split('@')[1])
if p.time_elapsed() > datetime.timedelta(hours=low) and p.time_elapsed() < datetime.timedelta(hours=high):
return True
else:
age_error = await client.send_message(msg.channel, 'Your post has to be between 2h and 48h old.')
await client.delete_message(msg)
await asyncio.sleep(6)
await client.delete_message(age_error)
return False
def pending_payout(username):
context = {}
for post in steem.get_blog(username, 500, 500):
post = Post(post["comment"])
if post.is_main_post() and post["author"] == username:
if "1970-01-01 00:00:00" == str(post["last_payout"]):
payout = Amount(post["pending_payout_value"]).amount
if payout == 0:
payout = (Amount(post["total_payout_value"]).amount +
Amount(post["curator_payout_value"]).amount)
context[post.title] = payout * 0.56 * 0.5
return context
def getUpvoteCandidate(account):
""" Gets link to comments author has not voted on but is within voting window
Args:
account: A Steem Account object.
Returns:
identifier of posts/comments within voting window not already voted on
"""
# Make sure we have the latest data
account.refresh()
epoch_last_vote = 0
# Get last 2000 votes from account
history = account.get_account_history(-1, 1000, filter_by='comment')
current_time = epochDiff()
oldest_id = []
print('got history, now filtering...')
for event in history:
try:
# Make sure we are the author
if (event['author'] == account.name):
# Not really needed due to filter
if (event['type'] == 'comment'):
# Double confirmation of comment
if event['permlink'].startswith("re-"):
epoch_last_vote = epochVote(event)
elapsed_time = current_time - epoch_last_vote
# Is post in within time limit
if elapsed_time < cutofftime:
# Get details of main post
identifier = "@" + event[
'parent_author'] + "/" + event[
'parent_permlink']
parent = Post(identifier, s)
while not parent.is_main_post():
identifier = "@" + parent[
'parent_author'] + "/" + parent[
'parent_permlink']
parent = Post(identifier, s)
# Make sure Original post is in desired tag
if targeted_tag in parent['tags']:
identifier = "@" + event[
'author'] + "/" + event['permlink']
# Store comment if it meets conditions
oldest_id.append(identifier)
else:
# Everything else will be older than cutoff
break
except Exception as e:
print('issue with history: ' + str(e))
# print(oldest_id)
print('completed history search')
return list(reversed(oldest_id))
class User:
def __init__(self, username, password, steem):
self._username = username
self._passwd = password
self._steem = steem
self._ipfsapi = get_ipfsapi()
self._cur_post = None
@staticmethod
def get_videos_list(query):
return get_chain_master().get_videos_list(query)
@staticmethod
def get_video_unauthorized(name, path):
video_metadata = get_chain_master().get_video_metadata(name)
multihash = video_metadata['multihash']
get_ipfsapi().get_video(multihash, path)
return video_metadata
def get_video(self, name, path):
video_metadata = User.get_video_unauthorized(name, path)
self._cur_post = Post(
{
'author': video_metadata['author'],
'permlink': video_metadata['name'],
}, self._steem)
return self._cur_post
def add_video(self, name, path, description=None, miniature_url=None):
description = description or 'No description'
miniature_url = miniature_url or self.get_miniature_url(path)
result = self._ipfsapi.add_video(path)
get_chain_master().add_video(name, self._username, description,
result['Hash'])
self._steem.commit.post(title=name,
body=description + '\n' + miniature_url,
author=self._username,
permlink=name,
default_parent_permlink='video')
def vote_video(self, type):
if not self._cur_post:
raise RuntimeError('There is no post to vote')
if type == VoteType.UP_VOTE:
return self._cur_post.upvote(self._username)
return self._cur_post.downvote(self._username)
def get_miniature_url(self, path):
return 'https://static.tumblr.com/5cc5658c2c9cd06cfc68747c9059bd6f/i9ytv5i/szXn6nvfq/tumblr_static_tumblr_static__640.jpg'
def upsert_post(mongo, post_identifier, steem=None):
with suppress(PostDoesNotExist):
p = Post(post_identifier, steem_instance=steem)
# scrape post and its replies
entry = {
**p.export(),
'replies': [],
# 'replies': [x.export() for x in _fetch_comments_flat(p)],
}
return mongo.Posts.update({'identifier': p.identifier},
entry,
upsert=True)
def steemi_vote_up_steempython(post_id):
identifier = construct_identifier(post_id['username'], post_id['permlink'])
steemd_instance = get_steem_conn()
steem_post = Post(identifier, steemd_instance=steemd_instance)
already_voted = False
for active_vote in steem_post.get("active_votes", []):
if active_vote.get("voter") == STEEM_BOT_ACCOUNT:
already_voted = True
break
if not already_voted:
steem_post.vote(100, STEEM_BOT_ACCOUNT)
def profile_as_json():
steemd_instance = get_steemd_instance()
if request.method == "GET":
links = request.args.get("links")
else:
links = request.form.get("links")
rewards = []
links = links.split(",")
for link in links:
try:
post = Post(link, steemd_instance=steemd_instance)
except PostDoesNotExist:
abort(404)
total, curation, author, beneficiaries, sbd_amount, sp_amount, \
usd_amount = calculate_rewards(steemd_instance, post)
rewards.append({
"link":
link,
"total":
total,
"curation":
curation,
"author":
author,
"beneficiaries":
beneficiaries,
"cashout_time":
post["cashout_time"],
"is_main_post":
post.is_main_post(),
"title":
post["title"],
"elapsed_seconds":
int(post.time_elapsed().total_seconds()),
"sbd_amount":
sbd_amount,
"sp_amount":
sp_amount,
"usd_amount":
usd_amount,
})
rewards = sorted(rewards, key=lambda k: k['elapsed_seconds'])
return jsonify({"rewards": rewards})
def upsert_comment_chain(mongo, identifier, recursive=False):
""" Upsert given comments and its parent(s).
Args:
mongo: mongodb instance
identifier: Post identifier
recursive: (Defaults to False). Recursively update all parent comments.
"""
with suppress(PostDoesNotExist):
p = Post(identifier)
upsert_comment(mongo, p.identifier)
if recursive and p.is_comment():
parent_identifier = '@%s/%s' % (p.parent_author, p.parent_permlink)
upsert_comment_chain(mongo, parent_identifier, recursive)
def test_post_refresh():
""" Post should load correctly if passed a dict or string identifier. """
p1 = Post('https://steemit.com/marketing/@steemitblog/'
'marketing-w-mitchell-a-steem-ecosystem')
p2 = Post({
'author': 'steemitblog',
'permlink': 'marketing-w-mitchell-a-steem-ecosystem'
})
# did post load?
assert 'json_metadata' in p1 and 'json_metadata' in p2
# are posts the same
assert p1.export() == p2.export()
def __next__(self):
while not self.history:
self.refresh()
while self.history:
# consume an item from history
next_item = first(self.history)
self.history = list(rest(self.history))
# stay in while loop until we find a post that exists
with suppress(PostDoesNotExist):
p = Post(next_item)
p.refresh()
return p
def handle_data(self, plain_post):
# Skip long comments
if len(plain_post.get('body', '')) > 1024:
return
# Skip comments with no signal
signal_found = self.check_signal(plain_post)
if not signal_found:
return
post = Post(plain_post)
# Skip comments of which depth is not 1
if post.get('depth', 0) != 1:
return
parent_post_id = '@%s/%s' % (post['parent_author'],
post['parent_permlink'])
try:
parent_post = Post(parent_post_id)
except:
self.log.error('Failed to get the parent post %s' % parent_post_id)
return
tags = parent_post.json_metadata.get('tags')
if tags == None:
self.log.error("No tag: " + parent_post)
return
if tags and self.config['main_tag'] in tags or \
any(x.startswith(self.config['tag_prefix']) for x in tags):
self.log.info('Found a matching comment: %s' %
plain_post.get('body'))
# Save signal
plain_post['bot_signal'] = signal_found
plain_post['parent_post_id'] = parent_post_id
# Select signal type
if plain_post['bot_signal'] in self.config['report_signals']:
plain_post['signal_type'] = 'spam'
elif plain_post['bot_signal'] in self.config['praise_signals']:
plain_post['signal_type'] = 'praise'
elif plain_post['bot_signal'] in self.config['promote_signals']:
plain_post['signal_type'] = 'promote'
elif plain_post['bot_signal'] in self.config['welcome_signals']:
plain_post['signal_type'] = 'welcome'
else:
plain_post['signal_type'] = 'unknown'
if not self.is_valid(plain_post):
self.log.info('Ignore not valid request')
return
# sink down
self.db.queue_push('post', plain_post)
async def get_info(msg):
link = str(msg.content).split(' ')[0]
p = Post(link.split('@')[1])
embed = discord.Embed(color=0xe3b13c)
embed.add_field(name="Title", value=str(p.title), inline=False)
embed.add_field(name="Author", value=str("@" + p.author), inline=True)
embed.add_field(name="Nominator",
value=str('<@' + msg.author.id + '>'),
inline=True)
embed.add_field(name="Age",
value=str(p.time_elapsed())[:-10] + " hours",
inline=False)
embed.set_footer(text="Onelovebot")
return embed
def curate(mysql_uri, vote_caster, posting_key, weight=+50,
self_vote=False, limit=20, apply_to_categories=None,
vote_delay=+30, nodes=None):
last_posts = get_last_approved_posts(limit)
s = Steem(keys=[posting_key], nodes=nodes)
for utopian_post in last_posts:
if utopian_post["author"] == vote_caster and not self_vote:
logger.info("Skipping %s. No self-vote.", post.identifier)
continue
post = Post(
"@%s/%s" % (utopian_post["author"], utopian_post["permlink"]))
elapsed_minutes = int(post.time_elapsed().seconds / 60)
if elapsed_minutes < vote_delay:
logger.info(
"Skipping %s. I will wait until %s minutes.",
post.identifier,
vote_delay - elapsed_minutes
)
continue
if already_voted(mysql_uri, post):
logger.info("Skipping %s. Already voted.", post.identifier)
continue
if apply_to_categories:
if utopian_post["json_metadata"]["type"] \
not in apply_to_categories:
logger.info(
"Skipping %s, This posts category: %s",
post.identifier,
utopian_post["json_metadata"]["type"]
)
continue
try:
s.commit.vote(post.identifier, weight, account=vote_caster)
add_log(mysql_uri, post)
logger.info(
"Casted vote on: %s with weight: %s", post.identifier, weight)
time.sleep(3)
except Exception as error:
if 'already voted' in error.args[0]:
add_log(mysql_uri, post)
logger.error(error)
continue
async def authorize_post(msg, user):
dest_channel = None
msg_tag = msg.content.split('/')[3]
p = Post(msg.content.split('@')[1])
for channel in channels:
if channel['name'] == msg_tag:
dest_channel = channel['id_verified']
break
if dest_channel == None:
dest_channel = channels[len(channels) -
1]['id_verified'] # others as default
embed = await get_info(msg)
if embed:
await client.send_message(client.get_channel(dest_channel),
content=msg.content) # send original message
await client.send_message(client.get_channel(dest_channel),
embed=embed) # send embed
await client.send_message(client.get_channel(dest_channel),
content="This post was accepted by <@" +
user.id + ">") # send comment
# delete old messages
for msg_id in react_dict[msg.id]:
msg = await client.get_message(msg.channel, msg_id)
await client.delete_message(msg)
if dest_channel:
response = await client.send_message(
msg.channel,
"Post was moved to channel <#" + dest_channel + ">")
await asyncio.sleep(6)
await client.delete_message(response)
async def sort_post(msg):
dest_channel = None
msg_tag = msg.content.split('/')[3]
p = Post(msg.content.split('@')[1])
for channel in channels:
if channel['name'] == msg_tag:
dest_channel = channel['id_community']
break
if dest_channel == None:
dest_channel = channels[len(channels) -
1]['id_community'] # others as default
embed = await get_info(msg)
if embed:
new_msg = await client.send_message(client.get_channel(dest_channel),
content=msg.content
) # send original message
embed_msg = await client.send_message(client.get_channel(dest_channel),
embed=embed) # send embed
comment_msg = await client.send_message(
client.get_channel(dest_channel),
content="This post was submitted in the server by <@" +
msg.author.id + ">") # send comment
react_dict[new_msg.id] = [new_msg.id, embed_msg.id,
comment_msg.id] # store new messages ids
await client.delete_message(msg) # delete old message
if dest_channel:
response = await client.send_message(
msg.channel,
"Post was moved to channel <#" + dest_channel + ">")
await asyncio.sleep(6)
await client.delete_message(response)
