def htmltopost(self, html, pagetime):
self.removecomments(html)
c = etree.tounicode(html, method='html', pretty_print=True)
postnumber = 0
postnumbernode = html.xpath(r"../../../tr[1]/td[2]/a[last()]")
if postnumbernode:
postnumber = int(etree.tounicode(postnumbernode[-1], method="text"))
postlinknode = postnumbernode[-1].attrib['href']
parsed = urlparse(postlinknode)
postid = int(parse_qs(parsed.query)['p'][0])
titlenode = html.xpath(r"../div[@class='smallfont']/strong")
title = etree.tounicode(titlenode[-1], method="text").strip()
posternode = html.xpath(r"../../td[1]/div/a[starts-with(@class,'bigusername')]")
poster = etree.tounicode(posternode[-1], method="text").strip()
timenode = html.xpath(r"../../../tr[1]/td[1]")
timestring = etree.tounicode(timenode[-1], method="text").strip()
ts = misc.parseitemtime(pagetime, timestring)
p = post.Post(content=c, postnumber=postnumber, title=title, postername=poster,
postid=postid, ts=ts)
print(postnumber, postid, poster, title)
return p
def delete_post(MED_PAG_ID):
v_post = post.Post()
if v_post.destroy(MED_PAG_ID):
flash("Registro fue eliminado correctamente")
else:
flash("Registro no puede ser eliminado")
return redirect(url_for('mantencion'))
def create_post():
v_post = post.Post()
if v_post.create(request.form['MED_PAG_NOMBRE']):
flash("Nuevo registro fue agregado correctamente")
else:
flash("Nuevo registro no pudo ser agregado correctamente")
return redirect(url_for('mantencion'))
def update(MED_PAG_ID):
v_post = post.Post()
if v_post.update(MED_PAG_ID, request.form['MED_PAG_NOMBRE']):
flash("Post was successfully updated.")
else:
flash("Post can't be updated.")
return redirect(url_for('mantencion'))
def createPostFromForm(form):
formText = form["text"]
duration = form["duration"]
public = form.get("public")
if (public != None):
public = 1
else:
public = 0
p = post.Post(formText, duration, public)
return p
def post(self):
subject, content = self.request.get('subject'), self.request.get(
'content')
args = {'subject': subject, 'content': content}
if subject and content:
# do the db magic here
p = post.Post(title=subject, content=content)
key = p.put()
self.redirect('/%d' % key.id())
else:
args['error'] = 'Both subject and content are required!'
self.render('newpost.html', **args)
def collect_posts(self, category):
if type(category) == type([]):
for x in category:
self.collect_posts(x)
return
post_files = self.get_files(os.path.join(dirs.src, category), 'md')
for f in post_files:
f = f.split('/', 1)[1] # remove dirs.src
p = post.Post(f, category, self)
self.posts.append(p)
def getPost(postId):
conn = sqlite3.connect(dbDir)
c = conn.cursor()
c.execute("select text, duration, time, public from posts where id=?",
(postId, ))
row = c.fetchone()
if (row != None):
p = post.Post(row[0], row[1], row[3], postId, row[2])
conn.close()
return p
else:
conn.close()
return None
def install(self, blog_data, user_data):
import user
import post
userClass = user.User(self.config)
postClass = post.Post(self.config)
self.response['error'] = None
try:
self.config['POSTS_COLLECTION'].ensure_index([('date', -1)])
self.config['POSTS_COLLECTION'].ensure_index([('tags', 1),
('date', -1)])
self.config['POSTS_COLLECTION'].ensure_index([('permalink', 1)])
self.config['POSTS_COLLECTION'].ensure_index([('query', 1),
('orderby', 1)])
self.config['USERS_COLLECTION'].ensure_index([('date', 1)])
post_data = {
'title': 'Hello World!',
'preview': '',
'body':
'Tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam',
'tags': [],
'author': user_data['_id'],
'pic_desc': '',
'picture': '',
'episode': ''
}
post = postClass.validate_post_data(post_data)
user_create = userClass.save_user(user_data)
post_create = postClass.create_new_post(post)
if blog_data['per_page'].isdigit():
blog_settings_error = None
self.collection.insert(blog_data)
else:
blog_settings_error = '"Per page" field need to be integer..'
if user_create['error'] or post_create[
'error'] or blog_settings_error:
self.response['error'] = []
self.response['error'].append(user_create['error'])
self.response['error'].append(post_create['error'])
self.response['error'].append(blog_settings_error)
self.config['POSTS_COLLECTION'].drop()
self.config['USERS_COLLECTION'].drop()
self.collection.drop()
except Exception, e:
self.print_debug_info(e, self.debug_mode)
self.response['error'] = 'Installation error..'
def get_posts(self):
"""
Get all posts on first page of tieba , and generate a post objects list
:return list of Post object:
"""
soup = self.get_content(self.tieba_base)
post_attr = self.__get_posts_url_postfix(soup)
url_list = [self.url_base + tag for tag in post_attr]
post_dict = self.__get_content_list(url_list)
post_list = [post.Post(url, soup) for url, soup in post_dict.items()]
return post_list
def post(self, id):
parser = reqparse.RequestParser()
# Token.
parser.add_argument("Authorization", location="headers")
params = parser.parse_args()
userobj = user.User(token=params["Authorization"])
postobj = post.Post(id, userobj)
try:
postobj.like()
except errors.BestagramException as e:
return e.get_response()
return {"success": True}, 200
def install(self, blog_data, user_data):
import user
import post
userClass = user.User(self.config)
postClass = post.Post(self.config)
self.response['error'] = None
try:
self.config['POSTS_COLLECTION'].ensure_index([('date', -1)])
self.config['POSTS_COLLECTION'].ensure_index([('tags', 1),
('date', -1)])
self.config['POSTS_COLLECTION'].ensure_index([('permalink', 1)])
self.config['POSTS_COLLECTION'].ensure_index([('query', 1),
('orderby', 1)])
self.config['USERS_COLLECTION'].ensure_index([('date', 1)])
post_data = {
'title': 'Blog For',
'preview':
'This is a pythonic Blog and meant for the python and data analytics update',
'body': 'So Guys please update your views',
'tags': [],
'author': user_data['_id']
}
post = postClass.validate_post_data(post_data)
user_create = userClass.save_user(user_data)
post_create = postClass.create_new_post(post)
if blog_data['per_page'].isdigit():
blog_settings_error = None
self.collection.insert(blog_data)
else:
blog_settings_error = '"Per page" field need to be integer..'
if user_create['error'] or post_create[
'error'] or blog_settings_error:
self.response['error'] = []
self.response['error'].append(user_create['error'])
self.response['error'].append(post_create['error'])
self.response['error'].append(blog_settings_error)
self.config['POSTS_COLLECTION'].drop()
self.config['USERS_COLLECTION'].drop()
self.collection.drop()
return self.response
except Exception, e:
self.print_debug_info(e, self.debug_mode)
self.response['error'] = 'Installation error..'
def home():
global post_list
blog_entries = requests.get(
url="https://api.npoint.io/5abcca6f4e39b4955965").json()
post_list = []
for entry in blog_entries:
title = entry["title"]
subtitle = entry["subtitle"]
body = entry["body"]
post_id = entry["id"]
new_post = post.Post(post_id=post_id,
post_body=body,
post_subtitle=subtitle,
post_title=title)
post_list.append(new_post)
return render_template("index.html", posts=post_list)
def on_create(self):
sub_shake = shake.Shake.get('id=%s and deleted=0', self.shake_id)
sub_user = user.User.get('id = %s and deleted=0', self.user_id)
shake_owner = user.User.get('id = %s and deleted=0', sub_shake.user_id)
shared_files = sub_shake.sharedfiles()
for sf in shared_files:
existing_post = post.Post.where(
'user_id = %s and sourcefile_id = %s', sub_user.id,
sf.source_id)
seen = 0
if existing_post:
seen = 1
new_post = post.Post(user_id=sub_user.id,
sharedfile_id=sf.id,
sourcefile_id=sf.source_id,
seen=seen,
shake_id=sub_shake.id)
new_post.save()
new_post.created_at = sf.created_at
new_post.save()
def parse(self):
response = self._get_response()
response.encoding = 'utf-8'
if not response.status_code / 100 == 2:
return []
doc = BeautifulSoup.BeautifulSoup(response.text)
urls = {}
posts = []
for e in doc.findAll('a'):
c = e.get('class')
href = e.get('href', None)
title = e.text.strip()
if not c:
continue
if not title:
continue
if not href:
continue
if not 'page_id' in href:
continue
if '(' == title[0]:
continue
urls[href] = True
for url in urls.keys():
p = post.Post(title=None, url=url, image=None)
posts.append(p)
return posts
import user
import post
import datetime
new_user1 = user.User("*****@*****.**", "jooe", "13123131",
"SW Engineer")
new_user2 = user.User("*****@*****.**", "essamico", "12313123131",
"Frontend Developer")
new_user3 = user.User("*****@*****.**", "youssiffio", "12313123131",
"Backend Developer")
post1 = post.Post("post 1", new_user1)
post2 = post.Post("post 2", new_user2)
post3 = post.Post("post 3", new_user3)
post1.display_post_info()
from flask import Flask, render_template
import post
app = Flask(__name__)
my_posts = post.Post()
@app.route('/')
def home():
return render_template("index.html", posts=my_posts.posts)
@app.route('/post/<int:post_id>')
def get_blog(post_id):
return render_template('post.html', posts=my_posts.posts, id=post_id)
if __name__ == "__main__":
app.run(debug=True)
if not settingsClass.is_installed():
return redirect(url_for('install'))
@app.errorhandler(404)
def page_not_found(error):
return render_template('404.html', meta_title='404'), 404
@app.template_filter('formatdate')
def format_datetime_filter(input_value, format_="%a, %d %b %Y"):
return input_value.strftime(format_)
settingsClass = settings.Settings(app.config)
postClass = post.Post(app.config)
userClass = user.User(app.config)
app.jinja_env.globals['url_for_other_page'] = url_for_other_page
app.jinja_env.globals['csrf_token'] = generate_csrf_token
app.jinja_env.globals['meta_description'] = app.config['BLOG_DESCRIPTION']
app.jinja_env.globals['recent_posts'] = postClass.get_posts(10, 0)['data']
app.jinja_env.globals['tags'] = postClass.get_tags()['data']
if not app.config['DEBUG']:
import logging
from logging import FileHandler
file_handler = FileHandler(app.config['LOG_FILE'])
file_handler.setLevel(logging.WARNING)
app.logger.addHandler(file_handler)
# -*- coding: utf-8 -*-
_author__ = 'HuCC'
import post
class User:
def __init__(self, username, password='******'):
self.id = 1
self.username = username
self.password = password
def update(self,password):
self.password=password
def do_post(self,p):
p.update(p.title,p.content)
p=post.Post('testtitle', 'testcontent', None, None)
u=User("test")
u.do_post(p)
def get_blog(blog_num):
post = p.Post(blog_id=blog_num)
return render_template("post.html", blog_post=post.post)
def mantencion_carrera():
v_posts = post.Post().allcarrera()
return render_template('mantencion_carrera.html', CARRERA=v_posts)
def create_post(self, title, content):
self.posts.append(post.Post(title, content))
# -*- coding: utf-8 -*-
import config
import post
import bugData
if __name__ == "__main__":
my_account = post.Post()
my_account.login(config.USERNAME, config.PASSWORD)
my_account.newthread(config.FID, config.TITLE, bugData.data)
# my_account.reply('10', u'发帖回复')
from flask import Flask, render_template
import requests
import post
app = Flask(__name__)
npoint = "https://api.npoint.io/5abcca6f4e39b4955965"
resp = requests.get(npoint)
posts = []
posts_data = resp.json()
for pt in posts_data:
post_obj = post.Post(pt)
posts.append(post_obj)
@app.route('/')
def home():
return render_template("index.html",posts=posts)
@app.route('/blog/<int:num>')
def get_blog(num):
post = [post for post in posts if post.id==num][0]
return render_template("post.html",post=post)
if __name__ == "__main__":
app.run(debug=True)
def get_post(self, post_no):
if post_no not in self.get_posts():
raise board.PostNotFound()
return post.Post(self.__translator, self.__posts[post_no])
def mantencion():
v_posts = post.Post().all()
return render_template('mantencion.html', MEDIO_PAGO=v_posts)
return (dB, ranges[rangeN], weights[weightN], speeds[speedN])
if __name__ == "__main__":
import logroll
import datetime
import time
import post
# connect to WS1381 over USB
dev = connect()
# set default modes: "A" weighting, "slow"
setMode(dev)
poster = post.Post()
log = logroll.LogRoll(logdir="logs")
while True:
now = datetime.datetime.now()
# roll over to a new log whenever the filename changes - in this case, every hour.
log.open_or_reopen(now.strftime('%Y-%m-%d.log'))
dB, range, weight, speed = readSPL(dev)
print("%.2f;%s;%s;%s" %
(dB, weight, speed, now.strftime('%Y-%m-%d;%H:%M:%S')),
file=log.fp)
print("%.2f;%s;%s;%s" %
(dB, weight, speed, now.strftime('%Y-%m-%d;%H:%M:%S')))
poster.post_request(dB, now.strftime('%Y-%m-%dT%H:%M:%SZ'), url,
def install(self, blog_data, user_data):
import user
import post
print("Installing")
userClass = user.User(self.config)
postClass = post.Post(self.config)
self.response['error'] = None
try:
self.config['POSTS_COLLECTION'].ensure_index([('date', -1)])
self.config['POSTS_COLLECTION'].ensure_index([('tags', 1),
('date', -1)])
self.config['POSTS_COLLECTION'].ensure_index([('permalink', 1)])
self.config['POSTS_COLLECTION'].ensure_index([('query', 1),
('orderby', 1)])
self.config['USERS_COLLECTION'].ensure_index([('date', 1)])
incident_description = """Lorem ipsum dolor sit amet, consectetur \
adipisicing elit, sed do eiusmod tempor incididunt ut labore et \
dolore magna aliqua. Ut enim ad minim veniam, quis nostrud \
exercitation ullamco laboris nisi ut aliquip ex ea commodo \
consequat. Duis aute irure dolor in reprehenderit in voluptate \
velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint \
occaecat cupidatat non proident, sunt in culpa qui officia \
deserunt mollit anim id est laborum."""
post_data = {
'incident_title': 'Hello World!',
'incident_description': incident_description,
'ttp_resources_infrastructure': 'Test Blockchain Platform',
'incident_categories': 'Smart Contract',
'ttp_description': 'Test vulnerability',
'ttp_exploits_targets': 'Test source of attack',
'incident_time_initial_compromise': '01/01/2018',
'incident_time_incident_reported': '01/01/2018',
'loss_crypto': '100 BTC',
'loss_usd': '100 USD',
'description_geographical': 'Singapore',
'references': 'https://localhost',
'advanced': None,
'author': user_data['_id']
}
post = postClass.validate_post_data(post_data)
user_create = userClass.save_user(user_data)
post_create = postClass.create_new_post(post)
if blog_data['per_page'].isdigit():
blog_settings_error = None
self.collection.insert(blog_data)
else:
blog_settings_error = '"Per page" field need to be integer..'
if user_create['error'] or post_create[
'error'] or blog_settings_error:
self.response['error'] = []
self.response['error'].append(user_create['error'])
self.response['error'].append(post_create['error'])
self.response['error'].append(blog_settings_error)
self.config['POSTS_COLLECTION'].drop()
self.config['USERS_COLLECTION'].drop()
self.collection.drop()
return self.response
except Exception as e:
self.print_debug_info(e, self.debug_mode)
self.response['error'] = 'Installation error..'
import mantencionmediopago # importa lo que hay dentro del archivo mantencionmediopago.py
import mantencionuniversidad # importa lo que hay dentro del archivo mantencionuniversidad.py
import mantenciontipousuario # importa lo que hay dentro del archivo mantenciontipousuario.py
import mantencionpermiso # importa lo que hay dentro del archivo mantencionpermiso.py
import masinfo
import registrousuario # importa lo que hay dentro del archivo registrousuario.py
import login # importa lo que hay dentro del archivo login.py
import mantencionalmuerzo # importa lo que hay dentro del archivo mantencionalmuerzo.py
import registrokiosco
import mostraralmuerzo
import mantencioncategoria
import comment
Post = post.Post()
app = Flask(__name__)#nuevo objeto
app.config['SECRET_KEY'] = '14e69cd065664ebcbb273a07c8105b2e338717fc4786de2479daa8b60d11e3ee9ebf16b80cd04a0ca746164fea8047be6cd76f19ede2ecb75e3ab290beacd472'
## PAGINA PRINCIPAL ##
@app.route('/')#wrap o un decorador
def index():
#if (request.cookies['capp_sesion_id']):
if "capp_sesion_id" in request.cookies:
logeado = True
else:
logeado = False
def new_post(self):
title = input('Enter post title: ')
content = input('Enter post content: ')
date = input('Enter data or leave blank (in format DDMMYYYY)')
post = post.Post(blog_id=self.blog_id, title=title, content=content, author=self.author, date=datetime.datetime.strptime(date, "%d%m%Y"))