def main(request):
previous = request.POST.get('paste', '')
if previous:
try:
import hashlib
id = hashlib.md5(previous).hexdigest()
except:
import md5
id = md5.new(previous).hexdigest()
try:
Paste.objects.get(url=id)
except:
p = Paste(content=previous, url=id)
p.save()
previous = 'http://%s/%s' % (request.get_host(), id)
t = loader.get_template('index.html')
c = Context({
'previous': previous
})
return http.HttpResponse(t.render(c))
def post(self):
self.response.headers['Content-Type'] = 'text/html'
content = self.request.POST.get('content', '')
lang = self.request.POST.get('type', 'None')
paste = Paste(content=content, type=lang)
paste.put()
self.redirect('/' + b64.num_encode(paste.key().id()))
def create_paste():
"""
Create a paste and associate with a generated key
that will be used to uniquely identify it.
"""
try:
data = request.get_json()
content = data.get("content", None)
if not content:
raise Exception
except Exception:
abort(400)
# check that key doesn't already exist in the db
key = get_random_url_suffix(4)
while True:
if Paste.query.get(key):
key = get_random_url_suffix(4)
continue
else:
break
try:
paste = Paste(key=key, content=content)
paste.insert()
except Exception:
db.session.rollback()
abort(500)
return jsonify({"success": True, "data": paste.format()})
def pate_create():
content = flask.request.form.get('content', None)
if not content:
flask.abort(400)
try:
timeout = int(flask.request.form.get('timeout', 60))
except (ValueError, TypeError):
return 'invalid "timeout" value', 400
if timeout < 1:
return 'timeout has to be greater than 0', 400
# convert to minutes
if timeout > 60 * 60 * 24 * 2:
return 'timeout has to be smaller than 2 days', 400
paste = Paste(content=content)
paste.save(timeout)
app.logger.info('page created by %s, size %s', flask.request.remote_addr,
len(paste.content))
# context negotiation does not work well here
user_agent = flask.request.headers.get('user-agent')
if user_agent and user_agent.startswith('curl'):
url = 'http://{}/{}\n'.format(flask.request.host, paste.key)
return flask.Response(url, content_type='text/plain; charset=utf-8')
return flask.redirect(flask.url_for('.paste_show', key=paste.key))
def new(request):
while True:
paste_hash = "".join([random.choice(string.digits+string.ascii_lowercase)
for i in range(6)])
try:
Paste.objects.get(paste_hash=paste_hash)
except Paste.DoesNotExist:
paste = Paste(create_time=timezone.now(),
modified_time=timezone.now(),
paste_hash=paste_hash)
paste.save()
return HttpResponseRedirect(reverse('paste:edit', args=(paste.paste_hash, )))
else:
pass
def download(site, links):
for link in links:
if not link in previous:
r = requests.get(site['raw'] % link, headers=config.header)
paste = Paste(_id=link,
content=r.text,
filetype=test_filetype(r.text),
site=site['archive'])
try:
paste.store(db)
print "Stored new object %s" % link
except couchdb.http.ResourceConflict as error:
print "Object %s allready stored: %s" % (link, error)
time.sleep(random.uniform(0.2, 2))
def create(request):
form = CreationForm(request.POST)
if not form.is_valid():
return render_to_response('pastebin/create.html', {
'url': reverse(create),
'form': form.as_ul(),
}, RequestContext(request))
paste = Paste(
content=form.cleaned_data['content'],
lang=form.cleaned_data['lang'],
)
paste.save()
return HttpResponseRedirect(reverse(view, args=[paste.key]))
def paste_delete(key):
try:
paste = Paste.find(key)
paste.delete()
except Paste.NotFound:
flask.abort(404)
return "Successfully deleted", 204
def get_paste(id: int) -> Paste:
try:
paste: Paste = Paste.get(Paste.id == id)
return paste
except Paste.DoesNotExist:
raise HTTPException(status_code=HTTP_404_NOT_FOUND,
detail="Paste not found.")
def recent_pastes(request):
def day(paste):
return datetime.date(year=paste.created_at.year, month=paste.created_at.month, day=paste.created_at.day)
# Order by descending creation date to avoid duplicate day results from
# groupby().
paste_qs = Paste.get_for_request(request).order_by("-created_at")
paste_dict = dict([(p.pk, p) for p in paste_qs])
file_qs = File.objects.filter(paste__in=paste_qs).select_related()
file_dict = dict([(f.pk, f) for f in file_qs])
paste_files = collections.defaultdict(list)
for pk, f in file_dict.iteritems():
paste_files[f.paste.pk].append(f)
recent_pastes = []
for date, paste_list in groupby(paste_qs, day):
# Sort the pastes again to avoid incorrect ordering within a day, this
# might be unnecessary if the user can't modify creation dates.
paste_list = sorted(paste_list, key=lambda p: p.created_at, reverse=True)
for paste in paste_list:
paste.file_list = paste_files[paste.pk]
recent_pastes.append((date, paste_list))
return {"recent_pastes": recent_pastes}
def index():
form = PasteForm()
if form.validate_on_submit():
source = form.source.data
highlighting = form.highlighting.data
resource = form.resource.data
is_resource = False
if resource:
source = resource
highlighting = 'text'
is_resource = True
paste = Paste(source, highlighting, form.expiration.data,
form.title.data, form.password.data, is_resource)
db.session.add(paste)
db.session.commit()
return redirect(url_for('view', slug=paste.slug))
else:
form.flash_errors()
return render_template('index.html',
form=form,
js={
'bucket_region':
app.config['BOTO3_REGION'],
'bucket_name':
app.config['AWS_S3_BUCKET'],
'identity_pool_id':
app.config['AWS_COGNITO_IDENTITY_POOL'],
})
def uploadFile():
f = request.files['file']
if allowed_file(f.filename):
foundPaste = Paste.query.filter_by(url=f.filename).first()
if foundPaste is not None:
return redirect('/error')
try:
now = datetime.datetime.now()
username = request.form['username']
print('username', username)
newPaste = Paste(url=f.filename,
date=now.strftime("%d-%m-%Y"),
language='none',
uploadType='file',
username=username)
db.session.add(newPaste)
db.session.commit()
except Exception as e:
print(e)
return redirect('/error')
filename = secure_filename(f.filename)
f.save(os.path.join(APP_ROOT + '/files/') + filename)
return redirect('/')
else:
return redirect('/error')
def new(request):
while True:
paste_hash = "".join([
random.choice(string.digits + string.ascii_lowercase)
for i in range(6)
])
try:
Paste.objects.get(paste_hash=paste_hash)
except Paste.DoesNotExist:
paste = Paste(create_time=timezone.now(),
modified_time=timezone.now(),
paste_hash=paste_hash)
paste.save()
return HttpResponseRedirect(
reverse('paste:edit', args=(paste.paste_hash, )))
else:
pass
def view_raw(slug):
paste = Paste.get_or_404(slug)
if paste.password and not paste.verify_password(request.form.get('p', '')):
abort(401)
if paste.is_resource:
return redirect(paste.generate_presigned_resource_url())
return Response(response=paste.source, status=200, mimetype='text/plain')
def create_paste(paste: PasteRequestModel) -> Paste:
if not paste.text:
raise HTTPException(status_code=HTTP_400_BAD_REQUEST,
detail="Bad request.")
if not paste.title:
paste.title = paste.text[:30]
paste_obj = Paste.create(title=paste.title,
text=paste.text,
signature=paste.signature)
return paste_obj
def post():
file = request.files['file']
key = Paste.generate_random_resource_key()
Paste.upload_file(key, file)
paste = Paste(
key,
'text',
request.form.get('expiration', 10080),
request.form.get('title', file.filename),
request.form.get('password'),
True,
)
db.session.add(paste)
db.session.commit()
return jsonify(code=200,
slug=paste.slug,
url=url_for('view', slug=paste.slug, _external=True))
def get(self, paste_id):
try:
aid = b64.num_decode(paste_id)
paste = Paste.get_by_id(aid)
content, lang = paste.content, paste.type
formatter = HtmlFormatter()
self.response.out.write(template.render("paste.html", {'css': formatter.get_style_defs('.highlight'),
'paste': highlight(content, get_lexer_by_name(lang), formatter)}))
except Exception:
self.response.set_status(404)
self.response.out.write(template.render("404.html", {}))
def show_paste(paste_id):
paste= Paste.query.get(paste_id)
if paste == None:
paste= Paste("")
nav = Paste.query.all()
username = request.cookies.get('username')
paste_form = PasteForm()
paste_form.populate(paste)
return render_template('paste.html', form= paste_form, nav= nav, username= username)
async def related(id: int) -> List[PasteResponseModel]:
paste = get_paste(id)
pastes: List[PasteResponseModel]
if paste.signature:
entries = Paste.select().where(Paste.signature == paste.signature,
Paste.id != paste.id).order_by(
Paste.created_at.desc()).dicts()
pastes = [PasteResponseModel(**paste) for paste in entries]
return pastes
return []
def create_paste(request):
error_msg = u"No data sent."
if request.method == "GET":
get = request.GET.copy()
if get.has_key('title') and get.has_key('text') and get.has_key('nickname') and get.has_key('exp_time'):
ttl = get['title']
txt = get['text']
usr = get['nickname']
try:
exp = datetime.strptime(get['exp_time'],'%d/%m/%Y %H:%M')
except:
msg = 2
if len(txt) > 100000: # utf-8 100kB
msg = 0
else:
p = Paste(randString(15),usr,ttl,txt,exp)
p.save()
msg = 1
return HttpResponse(msg)
else:
error_msg = u"Insufficient data"
return HttpResponseServerError(error_msg)
def view(slug):
paste = Paste.get_or_404(slug)
if paste.password:
return jsonify(code=401)
return jsonify(
code=200,
paste=dict(
title=paste.title,
source=paste.source,
view_count=paste.view_count,
created_at=int(paste.created_at.timestamp()),
expire_at=int(paste.expire_at.timestamp())
if paste.expire_at else None,
secret=paste.password is not None,
),
)
def index(request):
"""Displays form."""
data = {'menu': 'index', 'max_characters': settings.MAX_CHARACTERS}
if request.method == 'POST':
paste = Paste(slug=random_id(),
paste_ip=request.META['REMOTE_ADDR'],
paste_agent=request.META['HTTP_USER_AGENT'])
form = PasteForm(request.POST, instance=paste)
if not form.is_valid():
data['form'] = form
return render(request, 'paste/index.html', data)
form.save() # Some logic added to overrided method, see forms.py
return redirect(
reverse('paste',
kwargs={
'slug': paste.slug,
'renderer': settings.DEFAULT_RENDERER
}))
data['form'] = PasteForm()
return render(request, 'paste/index.html', data)
def get_info(html):
title, username, content, date, lables = '', '', '', '', []
title_wrapper = html.find('div', class_='pre-info')
if title_wrapper is not None:
title = title_wrapper.h4.text.strip()
username_time_wrapper = html.find('div', class_='pre-footer')
date_str = ''
if username_time_wrapper.a is not None:
username = username_time_wrapper.a.text
date_str = (str(username_time_wrapper.div.div.text).split()[4:-1])
else:
username = '******'
date_str = (str(username_time_wrapper.div.div.text).split()[4:-1])
if date_str != '':
date = " ".join(date_str).replace(",", "")
date = str(arrow.get(date, 'DD MMM YYYY HH:mm:ss').to('UTC'))
content_wrapper = username_time_wrapper = html.find('div', class_='text')
if content_wrapper is not None:
for li in content_wrapper.findAll('li'):
content += li.div.text.strip()
lables = analyze(content)
return Paste(username, title, content, date, lables)
def create_paste():
form= PasteForm(request.form)
if request.method == 'POST' :
paste= None
if form.id.data != None:
paste= Paste.query.get(form.id.data)
if paste != None:
paste.author= form.author.data
paste.content= form.content.data
paste.name= form.name.data
#remove modules
for module in paste.modules:
db.session.delete(module)
if paste == None:
paste= Paste(author= form.author.data, content= form.content.data, name= form.name.data)
db.session.add(paste)
db.session.commit()
for module in form.modules:
if module.expanded.data == 0:
#skip content of non-expanded modules
module.content.data= ""
m= Module(name= module.mod_name.data,
score= module.score.data,
content= module.content.data,
module_id= module.module_id.data,
paste_id= paste.id)
db.session.add(m)
db.session.commit()
return redirect(url_for('show_paste', paste_id=paste.id))
return "0"
def view(slug):
paste = Paste.get_or_404(slug)
password = None
if paste.password:
form = PasswordForm()
if form.validate_on_submit():
if not paste.verify_password(form.password.data):
flash('비밀번호가 일치하지 않습니다.', 'error')
return render_template('password.html', form=form)
password = form.password.data
else:
form.flash_errors()
return render_template('password.html', form=form)
viewed = session.setdefault('viewed', [])
if paste.slug not in viewed:
viewed.append(paste.slug)
session.permanent = True
session.modified = True
paste.view_count += 1
db.session.add(paste)
db.session.commit()
lexer = get_lexer_by_name(paste.lexer)
formatter = HtmlFormatter(
linenos=True,
linespans='line',
lineanchors='line',
anchorlinenos=True,
)
return render_template(
'view.html',
styles=formatter.get_style_defs(),
highlighted_source=highlight(paste.source, lexer, formatter),
lexer=lexer,
paste=paste,
password=password,
)
def geturl():
url = request.get_json().get('url')
language = request.get_json().get('language')
username = request.get_json().get('username')
foundPaste = Paste.query.filter_by(url=url).first()
if foundPaste is not None:
return jsonify({'success': False, 'status': 'URL already exists'})
file = open('files/' + url + '.txt', 'w')
file.write(request.get_json().get('pasteData'))
file.close()
try:
now = datetime.datetime.now()
newPaste = Paste(url=url,
date=now.strftime("%d-%m-%Y"),
language=language,
uploadType='code',
username=username)
db.session.add(newPaste)
db.session.commit()
return jsonify({'success': True})
except Exception as e:
print(e)
return jsonify({'success': False})
def paste_show(key):
try:
paste = Paste.find(key)
except Paste.NotFound:
flask.abort(404)
lexer_name = flask.request.args.get('lang', None)
if not lexer_name:
return flask.Response(paste.content,
content_type='text/plain; charset=utf-8')
try:
lexer = get_lexer_by_name(lexer_name, stripall=True)
except pygments.util.ClassNotFound:
return 'language "{}" not supported'.format(lexer_name), 400
with_lines = 'lineno' in flask.request.args
formatter = HtmlFormatter(linenos=with_lines, cssclass="source")
html = highlight(paste.content, lexer, formatter)
stylename = 'css/pygments/{}.css'.format(
flask.request.args.get('style', 'tango'))
return flask.render_template('source_code.html', html=html,
stylename=stylename)
def new_paste(request, id=None):
text_form = file_form = link_form = None
if id:
try:
paste = Paste.objects.get(pk=id)
except Paste.DoesNotExist:
return HttpResponseRedirect(url('pastes.new'))
parent = paste.parent or paste
else:
parent = paste = None
if request.method == 'POST':
paste_type = int(request.POST.get('type', 0))
if paste_type == PASTE_TYPE_TEXT:
text_form = PasteTextForm(request.POST, prefix="text")
text_form.is_active = True
form = text_form
elif paste_type == PASTE_TYPE_FILE:
file_form = PasteFileForm(request.POST, request.FILES, prefix="file")
file_form.is_active = True
form = file_form
elif paste_type == PASTE_TYPE_LINK:
link_form = PasteLinkForm(request.POST, prefix="link")
link_form.is_active = True
form = link_form
if form.is_valid():
key = form.cleaned_data['slug']
if not key:
length = 5
while 1:
key = Paste.generate_key(length)
try:
Paste.objects.get(pk=key)
except Paste.DoesNotExist:
break
length += 1
new_paste = Paste(
id=key,
parent=parent,
type=paste_type,
status=form.cleaned_data.get('public') and 1 or 0,
title=form.cleaned_data.get('title', None),
ip=request.META['REMOTE_ADDR'],
author=request.user.is_authenticated() and request.user or None,
group=request.group,
)
if form is text_form:
new_paste.text = text_form.cleaned_data['text']
if not text_form.cleaned_data['syntax']:
# Automatic detection
try:
lexer = lexers.guess_lexer(new_paste.text)
syntax = Syntax.objects.filter(lexer=lexer.__class__.__name__)[0:1].get()
except (Syntax.DoesNotExist, ClassNotFound), exc:
syntax = Syntax.objects.get(name="Plaintext")
new_paste.syntax = syntax
else:
new_paste.syntax = text_form.cleaned_data['syntax']
elif form is link_form:
new_paste.text = link_form.cleaned_data['text']
elif form is file_form:
content = form.cleaned_data['file'].read()
filename = form.cleaned_data['file'].name
if not new_paste.title:
new_paste.title = filename
if IMAGE_TYPES.search(filename):
new_paste.type = PASTE_TYPE_IMAGE
else:
syntax = None
if len(content) < 1024*25: # 10 kb
try:
lexer = lexers.guess_lexer_for_filename(filename, content)
syntax = Syntax.objects.filter(lexer=lexer.__class__.__name__)[0:1].get()
except (Syntax.DoesNotExist, ClassNotFound):
pass
if syntax:
new_paste.syntax = syntax
new_paste.type = PASTE_TYPE_TEXT
new_paste.text = content
new_paste.file.save(filename, form.cleaned_data['file'])
request.session.setdefault('pastes', []).append(str(new_paste.id))
request.session.save()
new_paste.save()
return HttpResponseRedirect(new_paste.get_absolute_url())
def generate_random_s3_key():
key = Paste.generate_random_resource_key()
return jsonify(key=key)
def main(request):
previous = request.POST.get("paste", "")
user_name = ""
user_name_post = request.POST.get("user_name", "")
if "user_name" in request.COOKIES:
user_name = sanitize_username(request.COOKIES["user_name"])
if user_name_post:
user_name = sanitize_username(user_name_post)
ucookie = False
if previous:
if not user_name:
try:
user_name = sanitize_username(request.META["HTTP_X_REAL_IP"])
except:
user_name = request.META["REMOTE_ADDR"]
else:
ucookie = user_name
title = to_ascii_lazy(request.POST.get("title", "untitled"))
tsms = long(time.time() * 1000)
hash_inputs = [previous.encode("utf-8"), user_name + "-" + str(tsms)]
try:
import hashlib
hasher = lambda hash_input: hashlib.md5(hash_input).hexdigest()
except:
import md5
hasher = lambda hash_input: md5.new(hash_input).hexdigest()
hash = "".join([hasher(hash_input) for hash_input in hash_inputs])
id = None
for idsize in range(1, len(hash) + 1):
useid = "p" + hash[0:idsize]
try:
Paste.objects.get(url=useid)
except:
id = useid
break
if id:
p = Paste(content=previous, url=id, user_name=user_name, title=title, tsms=tsms)
p.save()
host = sanitize_nasty(request.get_host())
if hasattr(settings, "SIMPYL_SEARCH_PATH_OK"):
if host.endswith("." + settings.SIMPYL_SEARCH_PATH_OK):
host = host[0 : -len(settings.SIMPYL_SEARCH_PATH_OK) - 1]
previous = "http://%s/%s" % (host, id)
if hasattr(settings, "SIMPYL_PASTEBIN_ZMQ_URL"):
import zmq
ztx = zmq.Context()
pub = ztx.socket(zmq.PUB)
pub.connect(settings.SIMPYL_PASTEBIN_ZMQ_URL)
zm_action = "action::paste '%s' by %s: %s" % (title, user_name, previous)
pub.send(zm_action)
cdict = {"title": titl, "title_low": titl.lower(), "previous": previous, "user_name": user_name}
resp = shared_rr("index.html", cdict)
if ucookie:
set_cookie(resp, "user_name", ucookie, days_expire=365)
return resp
def main(request):
previous = request.POST.get('paste', '')
user_name = ''
user_name_post = request.POST.get('user_name', '')
if 'user_name' in request.COOKIES :
user_name = sanitize_username(request.COOKIES['user_name'])
if user_name_post :
user_name = sanitize_username(user_name_post)
ucookie = False
if previous:
try:
import hashlib
hash = hashlib.md5(previous).hexdigest()
except:
import md5
hash = md5.new(previous).hexdigest()
id = None
for idsize in range(1, len(hash) + 1) :
useid = hash[0:idsize]
try :
Paste.objects.get(url=useid)
except :
id = useid
break
if id :
id = 'p' + id
p = Paste(content=previous, url=id)
p.save()
host = sanitize_nasty(request.get_host())
if hasattr(settings, 'SIMPYL_SEARCH_PATH_OK') :
if host.endswith('.' + settings.SIMPYL_SEARCH_PATH_OK) :
host = host[0:-len(settings.SIMPYL_SEARCH_PATH_OK)-1]
previous = 'http://%s/%s' % (host, id)
if hasattr(settings, 'SIMPYL_PASTEBIN_ZMQ_URL') :
import zmq
ztx = zmq.Context()
pub = ztx.socket(zmq.PUB)
pub.connect(settings.SIMPYL_PASTEBIN_ZMQ_URL)
if not user_name :
try :
user_name = sanitize_username(request.META['HTTP_X_REAL_IP'])
except :
user_name = request.META['REMOTE_ADDR']
else :
ucookie = user_name
pub.send("action::paste by %s: %s" % (user_name, previous))
t = loader.get_template('index.html')
cdict = {
'title': titl,
'title_low': titl.lower(),
'previous': previous,
'user_name': user_name
}
if hasattr(settings, 'SIMPYL_PASTEBIN_NOTELINE') :
cdict['noteline'] = settings.SIMPYL_PASTEBIN_NOTELINE
if hasattr(settings, 'GA_ID') :
cdict['GA_ID'] = settings.GA_ID
c = Context(cdict)
resp = http.HttpResponse(t.render(c))
if ucookie :
set_cookie(resp, 'user_name', ucookie, days_expire=365)
return resp
import os
import flask
from redis import Redis
import pygments
from pygments import highlight
from pygments.formatters import HtmlFormatter
from pygments.lexers import get_lexer_by_name
from models import Paste
app = flask.Flask(__name__)
app.debug = bool(os.getenv('DEBUG', False))
redis = Redis(db=int(os.getenv('REDIS_DATABSE', 3)))
Paste.set_connection(redis)
@app.route("/", methods=["GET"])
def paste_form():
return flask.render_template('create_form.html')
@app.route("/help", methods=["GET"])
def help():
return flask.render_template('help.html')
@app.route("/", methods=["POST"])
def pate_create():
content = flask.request.form.get('content', None)
