def load_playgrounds(path='data/playgrounds.csv'):
"""
Load playground data from the CSV into sqlite.
NOTE: THIS HAS NOT BEEN TESTED IN A VERY LONG TIME.
"""
features = copytext.Copy(app_config.COPY_PATH)['feature_list']
with open(path) as f:
rows = CSVKitDictReader(f)
for row in rows:
if row['Duplicate'] == 'TRUE':
#print 'Skipping duplicate: %s' % row['NAME']
continue
playground = Playground.create(
nprid=row['NPRID'],
name=row['NAME'],
facility=row['FACILITY'],
facility_type=row['FACILITY_TYPE'],
address=row['ADDRESS'],
city=row['CITY'],
state=row['STATE'],
zip_code=row['ZIP'],
longitude=float(row['LONGITUDE']) if row['LONGITUDE'] else None,
latitude=float(row['LATITUDE']) if row['LATITUDE'] else None,
agency=row['Agency'],
agency_type=row['AgencyType'],
owner=row['OWNER'],
owner_type=row['OWNER_TYPE'],
remarks=row['REMARKS'],
public_remarks=row['PubRermarks'],
url=row['url'],
entry=row['Entry'],
source=row['Source']
)
for feature in features:
slug = feature['key']
if row[slug] == 'TRUE':
PlaygroundFeature.create(
slug=slug,
playground=playground
)
Revision.create(
timestamp=datetime.datetime.now(pytz.utc),
action='insert',
playground=playground,
log=json.dumps([]),
headers='',
cookies='',
revision_group=1
)
def update_artboard(request):
try:
defs_elms = []
project_name = request.session['project']
redirection = '/exegesis/artboards?project=' + project_name
artboard_uuid = request.POST.get('artboard-uuid')
ArtBoard.objects.filter(project__project__contains=project_name, uuid=artboard_uuid).update(latest=False,
last_updated=datetime.now())
old_art = ArtBoard.objects.get(project__project__contains=project_name, uuid=artboard_uuid)
revision = Revision(name=old_art.artboard, artboard=old_art)
revision.save()
images_path = os.path.join('parse_svg', 'templates', 'uploads')
if not os.path.exists(images_path):
os.makedirs(images_path)
for f in request.FILES.getlist('svgfile'):
filename = f.name
print 'filename: ', filename
img_data = f.read()
uuid_name = uuid.uuid4()
img_name = "%s.%s" % (uuid_name, 'svg')
image_path = 'uploads/' + img_name
url = image_path
with open(os.path.join(images_path, img_name), "wb") as image:
image.write(img_data)
tree = ET.parse(os.path.join(settings.BASE_DIR, 'parse_svg', 'templates') + '/' + url)
root = tree.getroot()
for child in root.iter():
if child.tag.split('}')[1] == 'defs':
for subchild in child.iter():
defs_elms.append(subchild)
for child in root.iter():
if child not in defs_elms:
attribute = child.attrib
if 'id' in child.attrib:
elem_id = check_for_id()
child.set('id', elem_id)
if child.tag.split('}')[1] == 'use' and 'id' not in attribute.keys() or child.tag.split('}')[
1] == 'text' and 'id' not in attribute.keys():
elem_id = check_for_id()
child.set('id', elem_id)
tree.write(os.path.join(settings.BASE_DIR, 'parse_svg', 'templates') + '/' + url)
Project.objects.filter(project=project_name, email=request.user.email).update(thumbnail=url)
project = Project.objects.get(project=project_name, email=request.user.email)
filename = filename.split('.')[0]
new_entry = ArtBoard(project=project, artboard=filename, location=url, uuid=uuid_name, latest=True,
created=datetime.now(), last_updated=datetime.now())
new_entry.save()
Project.objects.filter(project=project_name).update(last_updated=datetime.now())
return redirect(redirection)
except:
print sys.exc_info()
return render(request, 'wrong.html')
def load_playgrounds(path='data/playgrounds.csv'):
"""
Load playground data from the CSV into sqlite.
NOTE: THIS HAS NOT BEEN TESTED IN A VERY LONG TIME.
"""
features = copytext.Copy(app_config.COPY_PATH)['feature_list']
with open(path) as f:
rows = CSVKitDictReader(f)
for row in rows:
if row['Duplicate'] == 'TRUE':
#print 'Skipping duplicate: %s' % row['NAME']
continue
playground = Playground.create(
nprid=row['NPRID'],
name=row['NAME'],
facility=row['FACILITY'],
facility_type=row['FACILITY_TYPE'],
address=row['ADDRESS'],
city=row['CITY'],
state=row['STATE'],
zip_code=row['ZIP'],
longitude=float(row['LONGITUDE'])
if row['LONGITUDE'] else None,
latitude=float(row['LATITUDE']) if row['LATITUDE'] else None,
agency=row['Agency'],
agency_type=row['AgencyType'],
owner=row['OWNER'],
owner_type=row['OWNER_TYPE'],
remarks=row['REMARKS'],
public_remarks=row['PubRermarks'],
url=row['url'],
entry=row['Entry'],
source=row['Source'])
for feature in features:
slug = feature['key']
if row[slug] == 'TRUE':
PlaygroundFeature.create(slug=slug, playground=playground)
Revision.create(timestamp=datetime.datetime.now(pytz.utc),
action='insert',
playground=playground,
log=json.dumps([]),
headers='',
cookies='',
revision_group=1)
def view_edit(req, page_name):
page = _get_page(page_name)
if req.method == 'POST':
if page is None:
page = Page(name=page_name)
page.save()
rev = Revision(page=page, text=req.form.get('text'))
rev.save()
session.commit()
return redirect_to('show', page_name=page.name)
else:
if page is not None:
page_name = page.name
return render_response('edit.jinja', page=page, page_name=page_name)
def post(self):
# if not self.check_user():
# return
file_id = self.request.get("id")
file = self.get_file(file_id)
if file is None:
self.response.out.write(file_id + " not found")
return
if self.get_file_permission(file) < base.ACCESS_WRITE:
self.response.out.write("permission denied")
return
new_text = self.request.get('content')
self.log_info("new_text = " + new_text)
if self.has_text_changed(file, new_text):
revision = Revision()
revision.author = self.get_current_user()
revision.content = new_text
revision.file = file
revision.prev = file.head
revision.put()
file.head = revision
file.put()
def post(self, page_name):
page = Page.by_name(page_name)
if self.user:
body = self.request.get('content')
else: # if posted while not logged in.
self.write('ERROR: not logged in.')
self.abort()
if not page: # For creatubg a new page.
page = Page(title=page_name)
page.put()
revision = Revision(body=body, user=self.user, parent=page)
revision.put()
page.revision = revision
page.put()
self.redirect_to('WikiPage', page_name=page_name)
def post(self, page_name):
page = Page.by_name(page_name)
if self.user:
body = self.request.get('content')
else: # if posted while not logged in.
self.write('ERROR: not logged in.')
self.abort()
if not page: # For creatubg a new page.
page = Page(title=page_name)
page.put()
revision = Revision(body=body, user=self.user, parent=page)
revision.put()
page.revision = revision
page.put()
self.redirect_to('WikiPage', page_name=page_name)
def test_process_updates_simple(self):
utils.load_test_playgrounds()
updated_playgrounds, revision_group = data.process_changes('tests/data/test_updates_simple.json')
self.assertEqual(len(updated_playgrounds), 1)
playground = Playground.select().where(Playground.id == updated_playgrounds[0].id)[0]
self.assertEqual(playground.id, 1)
self.assertEqual(playground.name, 'NEW NAME')
revisions = Revision.select().where(Revision.revision_group == revision_group)
self.assertEqual(revisions.count(), 1)
revision = revisions[0]
self.assertEqual(revision.playground.id, playground.id)
log = revision.get_log()
self.assertEqual(len(log), 2)
self.assertEqual(log[0]['field'], 'name')
self.assertEqual(log[0]['from'], 'Strong Reach Playground')
self.assertEqual(log[0]['to'], 'NEW NAME')
self.assertEqual(log[1]['field'], 'smooth-surface-throughout')
self.assertEqual(log[1]['from'], 1)
self.assertEqual(log[1]['to'], 0)
headers = revision.get_headers()
self.assertEqual(headers['content_length'], '18')
self.assertEqual(headers['host'], 'localhost')
cookies = revision.get_cookies()
self.assertEqual(len(cookies), 0)
def test_process_inserts(self):
models.delete_tables()
models.create_tables()
new_playgrounds, revision_group = data.process_changes(
'tests/data/test_inserts.json')
self.assertEqual(len(new_playgrounds), 1)
playground = Playground.select().where(
Playground.id == new_playgrounds[0].id)[0]
self.assertEqual(playground.name, 'NEW NAME')
revisions = Revision.select().where(
Revision.revision_group == revision_group)
self.assertEqual(revisions.count(), 1)
revision = revisions[0]
self.assertEqual(revision.playground.id, playground.id)
log = revision.get_log()
self.assertEqual(len(log), 1)
self.assertEqual(log[0]['field'], 'name')
self.assertEqual(log[0]['from'], '')
self.assertEqual(log[0]['to'], 'NEW NAME')
headers = revision.get_headers()
self.assertEqual(headers['content_length'], '18')
self.assertEqual(headers['host'], 'localhost')
cookies = revision.get_cookies()
def get(self,rev_key):
rev = Revision.get(rev_key)
class_key = rev.lect_class
lect_class = LectClass.get(class_key)
qs = get_rev_set(rev)
q_count = len(qs)
#see if student had attempted test before
user = self.get_user()
student = user['user']
attempt = RevisionAttempt.gql('WHERE student=:1 AND revision=:2 ORDER BY created DESC',student,rev).fetch(1)
class_hidden1 = ""
class_hidden2=""
score = ""
started = ""
akey = ""
if len(attempt)>0:
class_hidden1 = "js-hidden"
score = attempt[0].score
started = attempt[0].created
akey = attempt[0].key()
else:
class_hidden2 = "js-hidden"
extra = {
'class_hidden1':class_hidden1,
'class_hidden2':class_hidden2,
'score':score,
'started':started,
'akey':akey
}
self.render("explore-revision.html",rev=rev,qs=qs,lect_class=lect_class,extra = extra,q_count=q_count)
def test_process_inserts(self):
models.delete_tables()
models.create_tables()
new_playgrounds, revision_group = data.process_changes('tests/data/test_inserts.json')
self.assertEqual(len(new_playgrounds), 1)
playground = Playground.select().where(Playground.id == new_playgrounds[0].id)[0]
self.assertEqual(playground.name, 'NEW NAME')
revisions = Revision.select().where(Revision.revision_group == revision_group)
self.assertEqual(revisions.count(), 1)
revision = revisions[0]
self.assertEqual(revision.playground.id, playground.id)
log = revision.get_log()
self.assertEqual(len(log), 1)
self.assertEqual(log[0]['field'], 'name')
self.assertEqual(log[0]['from'], '')
self.assertEqual(log[0]['to'], 'NEW NAME')
headers = revision.get_headers()
self.assertEqual(headers['content_length'], '18')
self.assertEqual(headers['host'], 'localhost')
cookies = revision.get_cookies()
def get(self):
if not self.check_user(False):
#self.logged_user_home()
self.redirect('/')
return
max_results = 10
tmp = self.request.get("max")
if len(tmp):
max_results = int(tmp)
query = File.gql("WHERE author = :1", self.get_current_user())
files = query.fetch(max_results)
if len(files) > 0:
head = files[0].head
else:
head = Revision()
user = users.User(base.SUGGESTIONS_USER)
query = File.gql("WHERE author = :1", user)
public_files = query.fetch(50)
files = files + public_files
template_values = {
'user': self.get_current_user(),
'files': files,
'head': head,
'login_url': users.create_login_url(self.request.uri)
}
path = self.get_template_path('files.html')
self.response.out.write(template.render(path, template_values))
def process_changes(path='changes-in-progress.json'):
"""
Iterate over changes-in-progress.json and process its contents.
"""
revision_group = time.mktime((datetime.datetime.now(pytz.utc)).timetuple())
with open(path) as f:
changes = json.load(f)
changed_playgrounds = []
ACTIONS = {
'update': process_update,
'insert': process_insert,
'delete-request': process_delete
}
for record in changes:
action = ACTIONS[record['action']]
playground, revisions = action(record)
changed_playgrounds.append(playground)
timestamp = datetime.datetime.fromtimestamp(record['timestamp']).replace(tzinfo=pytz.utc)
# Assign the request headers to a variable.
# Need to modify the headers to add the remote IP address which is
# on the request object but not in the headers area.
# Why? Because we don't want to add an additional field to the
# Revisions model because we don't have DB migrations.
headers = record['request']['headers']
headers['remote_ip_address'] = record['request'].get('ip_address', None)
Revision.create(
timestamp=timestamp,
action=record['action'],
playground=playground,
log=json.dumps(revisions),
headers=json.dumps(headers),
cookies=json.dumps(record['request']['cookies']),
revision_group=revision_group
)
# Ensure all changes have been written to disk
database.commit()
return (changed_playgrounds, revision_group)
def process_changes(path='changes-in-progress.json'):
"""
Iterate over changes-in-progress.json and process its contents.
"""
revision_group = time.mktime((datetime.datetime.now(pytz.utc)).timetuple())
with open(path) as f:
changes = json.load(f)
changed_playgrounds = []
ACTIONS = {
'update': process_update,
'insert': process_insert,
'delete-request': process_delete
}
for record in changes:
action = ACTIONS[record['action']]
playground, revisions = action(record)
changed_playgrounds.append(playground)
timestamp = datetime.datetime.fromtimestamp(
record['timestamp']).replace(tzinfo=pytz.utc)
# Assign the request headers to a variable.
# Need to modify the headers to add the remote IP address which is
# on the request object but not in the headers area.
# Why? Because we don't want to add an additional field to the
# Revisions model because we don't have DB migrations.
headers = record['request']['headers']
headers['remote_ip_address'] = record['request'].get(
'ip_address', None)
Revision.create(timestamp=timestamp,
action=record['action'],
playground=playground,
log=json.dumps(revisions),
headers=json.dumps(headers),
cookies=json.dumps(record['request']['cookies']),
revision_group=revision_group)
# Ensure all changes have been written to disk
database.commit()
return (changed_playgrounds, revision_group)
def get(self, page_name):
revisions = Revision.by_page_name(page_name)
if revisions:
revisions = revisions.order('-date')
self.render('history.jinja',
page_name=page_name,
revisions=revisions,
user=self.user)
def get_revision_by_id(self, id):
rev_key = db.Key(id)
query = Revision.gql("WHERE __key__ = :1", db.Key(id))
entities = query.fetch(1)
if len(entities) > 0:
rev = entities[0]
return rev
return None
def delete_revision(self, args, user):
messages = []
search = ''
if len(args) <= 1:
raise Exception(
'Revision delte syntax\n```css\n.d revision delete "NAME"```')
if len(args) > 1:
search = ' '.join(args[2:])
revision = Revision().find(search)
if not revision:
return [f'"{search}"" was not found. No changes made.']
else:
search = str(revision.name)
revision.archived = True
self.save(revision, user)
messages.append(f'***{search}*** removed')
return messages
def get_revision_by_id(self, id):
rev_key = db.Key(id)
query = Revision.gql("WHERE __key__ = :1", db.Key(id))
entities = query.fetch(1)
if len(entities) > 0:
rev = entities[0]
return rev
return None
def get_entry_template():
tmp = Entry()
tmp.revisions.append(Revision(content='', rows=0))
return render_template(
'entry.html',
#create a fake single entry so the template renders a single entry div
entries=[tmp],
standalone=True) #prevent jinja2 from rendering the parent template
def get(self, page_name):
revisions = Revision.by_page_name(page_name)
if revisions:
revisions = revisions.order('-date')
self.render('history.jinja',
page_name=page_name,
revisions=revisions,
user=self.user)
def edit(request, name):
"""Allows users to edit wiki pages."""
try:
page = Page.objects.get(name=name)
except Page.DoesNotExist:
page = None
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
if not page:
page = Page()
page.name = form.cleaned_data['name']
page.save()
revision = Revision()
revision.page = page
revision.content = form.cleaned_data['content']
if request.user.is_authenticated():
revision.editor = request.user
revision.save()
return HttpResponseRedirect(page.get_absolute_url())
else:
if page:
revision = page.get_latest_revision()
form = PageForm(initial={'name': page.name, 'content': revision.content})
else:
form = PageForm(initial={'name': name})
ctx = { 'form': form }
return render_to_response('wiki/edit.html', ctx, context_instance=RequestContext(request))
def post(self):
# if not self.check_user():
# return
file_id = self.request.get("id")
file = self.get_file( file_id )
if file is None:
self.response.out.write(file_id + " not found")
return
if self.get_file_permission(file) < base.ACCESS_WRITE:
self.response.out.write("permission denied")
return
new_text = self.request.get('content')
self.log_info("new_text = " + new_text)
if self.has_text_changed(file, new_text):
revision = Revision()
revision.author = self.get_current_user()
revision.content = new_text
revision.file = file
revision.prev = file.head
revision.put()
file.head = revision
file.put()
def getrevisionset(rev_key='',email=''):
#test revision
logging.info("Function getrev... called")
rev = Revision.get(rev_key)
if rev:
rev_set = get_rev_set_raw(rev)
logging.info(rev_set)
return rev_set
else:
return ["nothing"]
def save(name):
revision = Page.by_name(name)
text = request.form.get('text')
note = request.form.get('note')
if request.form.get('cancel') or \
revision and revision.text == text:
return web.redirect(web.url_for('show', name=name))
elif not text:
error = _('You cannot save empty revisions.')
else:
note = request.form.get('note', '')
page = revision.page if revision else Page(name=name)
revision = Revision(text=text, page=page, note=note)
revision.save()
db.commit()
return web.redirect(web.url_for('show', name=name))
def revert(name):
"""Revert an old revision."""
rev_id = request.args.get('rev')
try:
rev_id = int(rev_id)
except:
pass
old_revision = page = None
error = _('No such revision')
if request.method == 'POST' and request.form.get('cancel'):
return web.redirect(web.url_for('show', name=page_name))
if rev_id:
old_revision = Page.by_revision(rev_id)
if old_revision:
new_revision = Page.by_name(name)
if old_revision == new_revision:
error = _('You tried to revert the current active ' \
'revision.')
elif old_revision.text == new_revision.text:
error = _('There are no changes between the current ' \
'revision and the revision you want to ' \
'restore.')
else:
error = ''
page = old_revision.page
if request.method == 'POST':
note = request.form.get('note', '')
note = 'revert' + (note and ': ' + note or '')
revision = Revision(page=page, text=old_revision.text,
note=note)
revision.save()
db.commit()
return web.redirect(web.url_for('show', name=name))
return web.render_template('revert.html',
error=error,
old_revision=old_revision,
revision=page
)
def get_revisions(self, file):
try:
max_results = 10
tmp = self.request.get("max")
if len(tmp):
max_results = int(tmp)
query = Revision.gql("WHERE file = :1 ORDER BY date DESC", file)
#.filter('__key__ != :1', file.head.key())
return query.fetch(max_results)
except: #BadKeyError:
return None
def update_entry(entry_id=None):
'''Update an existing entry at /update/entry_id/ or make a new one at /update/.
Returns the entry_id of the new or updated entry.'''
entry = Entry()
if entry_id != None:
entry = Entry.objects(id=entry_id)[0]
revision = Revision(content=request.form['content'],
rows=request.form['rows'])
entry.add_revision(revision)
entry.save()
return str(entry.id)
def get(self, page_name):
page = Page.by_name(page_name)
revision = None
revision_id = self.request.get('v')
if revision_id: # if a specific revision is requested
revision = Revision.by_id(revision_id, page)
self.render('edit.jinja',
page_name=page_name,
revision=revision,
user=self.user,
page=page)
def get(self, page_name):
revisions = Revision.by_page_name(page_name)
if revisions:
revisions = revisions.order('-date')
revision_id = self.request.get('v')
revision = None
if revision_id:
revision = Revision.by_id(revision_id, page_name)
else:
revisions = Revision.by_page_name(page_name)
if revisions:
revision = revisions.order('-date').get()
if revision:
self.render('page.jinja', page_name=page_name,
revision=revision,
user=self.user,
revisions=revisions)
else:
self.redirect_to('_edit', page_name=page_name)
def get(self):
if self.check_user(False):
query = Revision.gql("WHERE author = :1 ORDER BY date DESC", self.get_current_user())
revs = query.fetch(1)
if len(revs) > 0:
file_id = revs[0].file.key()
else:
file_id = self.create_file("New File")
else:
file_id = self.get_public_file_id()
self.response.out.write(file_id)
def get(self, page_name):
revisions = Revision.by_page_name(page_name)
if revisions:
revisions = revisions.order('-date')
revision_id = self.request.get('v')
revision = None
if revision_id:
revision = Revision.by_id(revision_id, page_name)
else:
revisions = Revision.by_page_name(page_name)
if revisions:
revision = revisions.order('-date').get()
if revision:
self.render('page.jinja',
page_name=page_name,
revision=revision,
user=self.user,
revisions=revisions)
else:
self.redirect_to('_edit', page_name=page_name)
def get(self, page_name):
page = Page.by_name(page_name)
revision = None
revision_id = self.request.get('v')
if revision_id: # if a specific revision is requested
revision = Revision.by_id(revision_id, page)
self.render(
'edit.jinja',
page_name=page_name,
revision=revision,
user=self.user,
page=page)
def get(self):
if self.check_user(False):
query = Revision.gql("WHERE author = :1 ORDER BY date DESC",
self.get_current_user())
revs = query.fetch(1)
if len(revs) > 0:
file_id = revs[0].file.key()
else:
file_id = self.create_file("New File")
else:
file_id = self.get_public_file_id()
self.response.out.write(file_id)
def name(self, args):
"""Display and create a new Revision by name
Parameters
----------
args : list(str)
List of strings with subcommands
Returns
-------
list(str) - the response messages string array
"""
if not self.can_edit:
raise Exception('You do not have permission to add revision text')
messages = []
rev_name = ' '.join(args[1:])
if args[1] == 'rename':
if len(args) < 4:
raise Exception(
'syntax: ```css\n.d revision rename "ORIGINAL NAME" "NEW NAME"```'
)
rev_name_orig = ' '.join(args[2])
rev_name_new = ' '.join(args[3])
revision_new = Revision().find(rev_name_new)
if revision_new:
raise Exception(
f'Cannot rename to _{rev_name_new}_. Revision already exists'
)
else:
revision = Revision().find(rev_name_orig)
if not rev_name_orig:
raise Exception(
f'Cannot find original revision named _{rev_name_orig}_'
)
revision.name = rev_name_new
revision_svc.save(revision, self.user)
messages.append(revision.get_string(self.user))
else:
if len(args) < 4:
raise Exception(
'syntax: ```css\n.d revision name "NAME" "NUMBER" "TEXT"```'
)
rev_name = args[1]
rev_number = args[2]
rev_text = args[3]
params = {'name': rev_name, 'number': rev_number, 'text': rev_text}
revision = Revision().create_new(**params)
messages.append(revision.get_string(self.user))
return messages
def commitRevision():
# Get list all production in magazine, not SoldOut
# Get List from magazine
# All not SoldOut and FromMagazine OK
# other not OK
user_id = 1
id_shop = 4
bc_from_revision = [
7895, 7896, 7897, 7898, 7899, 7900, 7901, 7902, 7903, 7904, 7905, 7906,
7907, 7908, 7909, 7910, 7911, 7912, 7913, 7914, 7915, 7916, 7917, 7918,
7919, 7920, 7921, 7922, 7923, 7924, 7925, 7926, 7927, 7928, 7929, 7930,
7931, 7932, 7933, 7934, 7935, 8516, 8517, 8518, 8519, 8520, 8521, 8522,
8523, 8524, 8525, 8526, 8527, 8528, 8529, 8530, 8531, 8532, 8533, 8534,
8535, 8536, 8537, 8538, 8539, 8540, 8541, 8542, 8543, 8544, 8545, 8546,
8547, 8548, 8549, 8550, 8551, 8552, 8553, 8554, 8555, 8556, 8557
]
send_to_shops = SendToShop.objects.filter(Shop_id=Shop.objects.get(
id=id_shop))
productToShop = ProductToShop.objects.filter(
SendToShop_id__in=send_to_shops)
bar_codes = BarCode.objects.filter(ProductToShop_id__in=productToShop,
SoldOut=False)
revision = Revision(DateTime=datetime.datetime.now(),
User_id=User.objects.get(id=user_id))
revision.save()
for bar_code in bar_codes:
if bar_code.id in bc_from_revision:
revisionHasBarCode = RevisionHasBarCode(Revision_id=revision,
BarCode=bar_code,
OK=True)
else:
revisionHasBarCode = RevisionHasBarCode(Revision_id=revision,
BarCode=bar_code,
OK=False)
revisionHasBarCode.save()
def _list_revision_groups():
context = {}
context['revision_groups'] = Set([])
revisions = Revision.select()
for revision in revisions:
revision_date = datetime.datetime.fromtimestamp(revision.revision_group)
context['revision_groups'].add((revision_date, revision.revision_group))
context['revision_groups'] = sorted(context['revision_groups'], key=lambda g: g[0], reverse=True)
return render_template('_email_list.html', **context)
def menu(bot, update):
uid = update.effective_user.id
is_admin = uid in settings.ADMINS
buttons = _admin_buttons(send_botlist_button=is_admin,
logs_button=is_admin)
txt = "🛃 Administration menu. Current revision: {}".format(
Revision.get_instance().nr)
bot.formatter.send_message(uid,
txt,
reply_markup=ReplyKeyboardMarkup(
buttons, resize_keyboard=True))
return BotStates.ADMIN_MENU
def extract_results(self, query_resp):
ret = []
# redirect_list = query_resp.get('redirects', []) # TODO
# redirects = dict([(r['from'], r['to']) for r in redirect_list])
requested_title = self.input_param
is_parsed = self.kwargs.get("rvparse", False)
pages = query_resp.get("pages", {})
for page_id, pid_dict in pages.iteritems():
if int(page_id) < 0:
continue
rev_dict = dict(pid_dict)
rev_dict.update(pid_dict["revisions"][0])
revision = Revision.from_query(rev_dict, source=self.source, is_parsed=is_parsed)
revision.req_title = requested_title
ret.append(revision)
return ret
def _list_revision_groups():
context = {}
context['revision_groups'] = Set([])
revisions = Revision.select()
for revision in revisions:
revision_date = datetime.datetime.fromtimestamp(
revision.revision_group)
context['revision_groups'].add(
(revision_date, revision.revision_group))
context['revision_groups'] = sorted(context['revision_groups'],
key=lambda g: g[0],
reverse=True)
return render_template('_email_list.html', **context)
def _playground(playground_slug):
"""
Playground detail page.
"""
from flask import request
context = make_context()
context['playground'] = Playground.get(slug=playground_slug)
context['fields'] = context['playground'].update_form()
context['features'] = context['playground'].update_features_form()
context['revisions'] = Revision.select()\
.where(Revision.playground == context['playground'].id)\
.where((Revision.action == 'insert') | (Revision.action == 'update'))\
.order_by(Revision.timestamp.desc())
context['display_field_name'] = display_field_name
context['path'] = request.path
return render_template('playground.html', **context)
def _playground(playground_slug):
"""
Playground detail page.
"""
from flask import request
context = make_context()
context['playground'] = Playground.get(slug=playground_slug)
context['fields'] = context['playground'].update_form()
context['features'] = context['playground'].update_features_form()
context['revisions'] = Revision.select()\
.where(Revision.playground == context['playground'].id)\
.where((Revision.action == 'insert') | (Revision.action == 'update'))\
.order_by(Revision.timestamp.desc())
context['display_field_name'] = display_field_name
context['path'] = request.path
return render_template('playground.html', **context)
def extract_results(self, query_resp):
ret = []
#redirect_list = query_resp.get('redirects', []) # TODO
#redirects = dict([(r['from'], r['to']) for r in redirect_list])
requested_title = self.input_param
is_parsed = self.kwargs.get('rvparse', False)
pages = query_resp.get('pages', {})
for page_id, pid_dict in pages.iteritems():
if int(page_id) < 0:
continue
rev_dict = dict(pid_dict)
rev_dict.update(pid_dict['revisions'][0])
revision = Revision.from_query(rev_dict,
source=self.source,
is_parsed=is_parsed)
revision.req_title = requested_title
ret.append(revision)
return ret
def test_prepare_email(self):
utils.load_test_playgrounds()
playground = Playground.get(id=1)
log = '''[{
"field": "name",
"from": "%s",
"to": "Test Playground"
}]''' % playground.name
Revision(action='update',
timestamp=time.mktime(
datetime.datetime.now(pytz.utc).timetuple()),
playground=playground,
log=log,
headers='',
cookies='',
revision_group=1).save()
body = app._prepare_email(1)
self.assertTrue(body.find(playground.name) >= 0)
def test_process_updates_simple(self):
utils.load_test_playgrounds()
updated_playgrounds, revision_group = data.process_changes(
'tests/data/test_updates_simple.json')
self.assertEqual(len(updated_playgrounds), 1)
playground = Playground.select().where(
Playground.id == updated_playgrounds[0].id)[0]
self.assertEqual(playground.id, 1)
self.assertEqual(playground.name, 'NEW NAME')
revisions = Revision.select().where(
Revision.revision_group == revision_group)
self.assertEqual(revisions.count(), 1)
revision = revisions[0]
self.assertEqual(revision.playground.id, playground.id)
log = revision.get_log()
self.assertEqual(len(log), 2)
self.assertEqual(log[0]['field'], 'name')
self.assertEqual(log[0]['from'], 'Strong Reach Playground')
self.assertEqual(log[0]['to'], 'NEW NAME')
self.assertEqual(log[1]['field'], 'smooth-surface-throughout')
self.assertEqual(log[1]['from'], 1)
self.assertEqual(log[1]['to'], 0)
headers = revision.get_headers()
self.assertEqual(headers['content_length'], '18')
self.assertEqual(headers['host'], 'localhost')
cookies = revision.get_cookies()
self.assertEqual(len(cookies), 0)
def get(self):
revisions = Revision.all().order('-date')
self.render('recent.jinja', revisions=revisions)
def _prepare_email(revision_group):
revisions = Revision.select().where(
Revision.revision_group == int(revision_group))
context = {}
context['base_url'] = '%s/playground/' % app_config.S3_BASE_URL
context['total_revisions'] = revisions.count()
context['deletes'] = {}
context['deletes']['playgrounds'] = []
context['deletes']['total_revisions'] = 0
context['inserts'] = {}
context['inserts']['playgrounds'] = []
context['inserts']['total_revisions'] = 0
context['updates'] = {}
context['updates']['playgrounds'] = []
context['updates']['total_revisions'] = 0
inserts = revisions.where(Revision.action == 'insert')
if inserts.count() > 0:
context['inserts']['total_revisions'] = inserts.count()
for revision in inserts:
p = Playground.get(slug=revision.playground.slug)
playground_dict = p.__dict__['_data']
playground_dict['display_name'] = p.display_name
playground_dict['site_url'] = '%s/playground/%s.html' % (
app_config.S3_BASE_URL, revision.playground.slug)
playground_dict['revision_group'] = int(revision_group)
playground_dict['headers'] = revision.get_headers()
playground_dict['feature_count'] = int(p.feature_count)
nearby = p.nearby(3)
playground_dict['nearby'] = []
for n in nearby:
if n.distance < 0.5:
playground_dict['nearby'].append(n)
context['inserts']['playgrounds'].append(playground_dict)
context['inserts']['playgrounds'] = sorted(
context['inserts']['playgrounds'], key=lambda p: p['name'])
deletes = revisions.where(Revision.action == 'delete-request')
if deletes.count() > 0:
context['deletes']['total_revisions'] = deletes.count()
for revision in deletes:
p = Playground.get(slug=revision.playground.slug)
playground_dict = playground_dict = p.__dict__['_data']
playground_dict['display_name'] = p.display_name
playground_dict['site_url'] = '%s/playground/%s.html' % (
app_config.S3_BASE_URL, revision.playground.slug)
playground_dict['delete_url'] = '%s/delete-playground/%s/' % (
app_config.SERVER_BASE_URL, revision.playground.slug)
playground_dict['revision_group'] = int(revision_group)
for item in json.loads(revision.log):
if item.get('field', None) == "reason":
playground_dict['text'] = cgi.escape(item.get('to'))
playground_dict['headers'] = revision.get_headers()
context['deletes']['playgrounds'].append(playground_dict)
context['deletes']['playgrounds'] = sorted(
context['deletes']['playgrounds'], key=lambda p: p['name'])
updates = revisions.where(Revision.action == 'update')
if updates.count() > 0:
context['updates']['total_revisions'] = updates.count()
updated_playgrounds = Set([])
for revision in updates:
updated_playgrounds.add(revision.playground.slug)
for playground_slug in updated_playgrounds:
p = Playground.get(slug=playground_slug)
playground_dict = p.__dict__['_data']
playground_dict['display_name'] = p.display_name
playground_dict['site_url'] = '%s/playground/%s.html' % (
app_config.S3_BASE_URL, playground_slug)
playground_dict['revisions'] = []
for revision in updates:
if revision.playground.id == p.id:
revision_dict = {}
revision_dict['revision_group'] = revision_group
revision_dict['fields'] = revision.get_log()
revision_dict['headers'] = revision.get_headers()
playground_dict['revisions'].append(revision_dict)
context['updates']['playgrounds'].append(playground_dict)
context['updates']['playgrounds'] = sorted(
context['updates']['playgrounds'], key=lambda p: p['name'])
with open('templates/_email.html', 'rb') as read_template:
payload = Template(read_template.read())
return payload.render(**context)
def get_all_revs():
#top 50 revisions, to be fine-tuned according to users course, university, etc
#also gives some stats, etc e.g. 23 qs, 500 attempts,etc
revs = Revision.all().fetch(50)
return revs
def get_revisions(self, file):
query = Revision.gql("WHERE file = :1 ORDER BY date DESC", file)
#.filter('__key__ != :1', file.head.key())
return query.fetch(100)
def changes():
page = max(1, request.args.get('page', type=int))
query = Revision.all().order('-timestamp')
return web.render_template('changes.html',
pagination=Pagination(query, 20, page, 'changes'))
def _prepare_email(revision_group):
revisions = Revision.select().where(Revision.revision_group == int(revision_group))
context = {}
context['base_url'] = '%s/playground/' % app_config.S3_BASE_URL
context['total_revisions'] = revisions.count()
context['deletes'] = {}
context['deletes']['playgrounds'] = []
context['deletes']['total_revisions'] = 0
context['inserts'] = {}
context['inserts']['playgrounds'] = []
context['inserts']['total_revisions'] = 0
context['updates'] = {}
context['updates']['playgrounds'] = []
context['updates']['total_revisions'] = 0
inserts = revisions.where(Revision.action == 'insert')
if inserts.count() > 0:
context['inserts']['total_revisions'] = inserts.count()
for revision in inserts:
p = Playground.get(slug=revision.playground.slug)
playground_dict = p.__dict__['_data']
playground_dict['display_name'] = p.display_name
playground_dict['site_url'] = '%s/playground/%s.html' % (app_config.S3_BASE_URL, revision.playground.slug)
playground_dict['revision_group'] = int(revision_group)
playground_dict['headers'] = revision.get_headers()
playground_dict['feature_count'] = int(p.feature_count)
nearby = p.nearby(3)
playground_dict['nearby'] = []
for n in nearby:
if n.distance < 0.5:
playground_dict['nearby'].append(n)
context['inserts']['playgrounds'].append(playground_dict)
context['inserts']['playgrounds'] = sorted(context['inserts']['playgrounds'], key=lambda p: p['name'])
deletes = revisions.where(Revision.action == 'delete-request')
if deletes.count() > 0:
context['deletes']['total_revisions'] = deletes.count()
for revision in deletes:
p = Playground.get(slug=revision.playground.slug)
playground_dict = playground_dict = p.__dict__['_data']
playground_dict['display_name'] = p.display_name
playground_dict['site_url'] = '%s/playground/%s.html' % (app_config.S3_BASE_URL, revision.playground.slug)
playground_dict['delete_url'] = '%s/delete-playground/%s/' % (app_config.SERVER_BASE_URL, revision.playground.slug)
playground_dict['revision_group'] = int(revision_group)
for item in json.loads(revision.log):
if item.get('field', None) == "reason":
playground_dict['text'] = cgi.escape(item.get('to'))
playground_dict['headers'] = revision.get_headers()
context['deletes']['playgrounds'].append(playground_dict)
context['deletes']['playgrounds'] = sorted(context['deletes']['playgrounds'], key=lambda p: p['name'])
updates = revisions.where(Revision.action == 'update')
if updates.count() > 0:
context['updates']['total_revisions'] = updates.count()
updated_playgrounds = Set([])
for revision in updates:
updated_playgrounds.add(revision.playground.slug)
for playground_slug in updated_playgrounds:
p = Playground.get(slug=playground_slug)
playground_dict = p.__dict__['_data']
playground_dict['display_name'] = p.display_name
playground_dict['site_url'] = '%s/playground/%s.html' % (app_config.S3_BASE_URL, playground_slug)
playground_dict['revisions'] = []
for revision in updates:
if revision.playground.id == p.id:
revision_dict = {}
revision_dict['revision_group'] = revision_group
revision_dict['fields'] = revision.get_log()
revision_dict['headers'] = revision.get_headers()
playground_dict['revisions'].append(revision_dict)
context['updates']['playgrounds'].append(playground_dict)
context['updates']['playgrounds'] = sorted(context['updates']['playgrounds'], key=lambda p: p['name'])
with open('templates/_email.html', 'rb') as read_template:
payload = Template(read_template.read())
return payload.render(**context)
def svg_images(request):
defs_elms = []
arts = []
project_uuid = request.POST.get('project-uuid')
project = Project.objects.get(uuid=project_uuid, email=request.session['email'])
project_name = project.project
redirection = '/exegesis/projects'
artboards = ArtBoard.objects.filter(project__project__contains=project_name)
for artboard in artboards:
arts.append(artboard.artboard)
images_path = os.path.join('parse_svg', 'templates', 'uploads')
if not os.path.exists(images_path):
os.makedirs(images_path)
for f in request.FILES.getlist('svgfile'):
filename = f.name
print 'filename: ', filename
if filename.endswith('zip'):
archive = zipfile.ZipFile(f)
for file in archive.namelist():
print 'file: ', file
if file.endswith('svg'):
img_data = archive.read(file)
uuid_name = uuid.uuid4()
img_name = "%s.%s" % (uuid_name, 'svg')
image_path = 'uploads/' + img_name
url = image_path
with open(os.path.join(images_path, img_name), "wb") as image:
image.write(img_data)
if '/' in file:
file = file.split('/')[1]
tree = ET.parse(os.path.join(settings.BASE_DIR, 'parse_svg', 'templates') + '/' + url)
root = tree.getroot()
for child in root.iter():
if child.tag.split('}')[1] == 'defs':
for subchild in child.iter():
defs_elms.append(subchild)
for child in root.iter():
if child not in defs_elms:
attribute = child.attrib
if 'id' in attribute:
elem_id = check_for_id()
child.set('id', elem_id)
if child.tag.split('}')[1] == 'use' and 'id' not in attribute.keys() or \
child.tag.split('}')[1] == 'text' and 'id' not in attribute.keys():
elem_id = check_for_id()
child.set('id', elem_id)
tree.write(os.path.join(settings.BASE_DIR, 'parse_svg', 'templates') + '/' + url)
Project.objects.filter(project=project_name, email=request.user.email).update(thumbnail=url)
project = Project.objects.get(project=project_name, email=request.user.email)
file = file.split('.')[0]
if file in arts:
old_art = ArtBoard.objects.get(artboard=file, project__project__contains=project_name,
latest=True)
ArtBoard.objects.filter(artboard=file, project__project__contains=project_name).update(
latest=False, last_updated=datetime.now())
revision_entry = Revision(name=file, artboard=old_art)
revision_entry.save()
new_entry = ArtBoard(project=project, artboard=file, location=url, uuid=uuid_name, latest=True,
created=datetime.now(), last_updated=datetime.now())
new_entry.save()
Project.objects.filter(project=project_name).update(last_updated=datetime.now())
else:
img_data = f.read()
uuid_name = uuid.uuid4()
img_name = "%s.%s" % (uuid_name, 'svg')
image_path = 'uploads/' + img_name
url = image_path
with open(os.path.join(images_path, img_name), "wb") as image:
image.write(img_data)
tree = ET.parse(os.path.join(settings.BASE_DIR, 'parse_svg', 'templates') + '/' + url)
root = tree.getroot()
for child in root.iter():
if child.tag.split('}')[1] == 'defs':
for subchild in child.iter():
defs_elms.append(subchild)
for child in root.iter():
if child not in defs_elms:
attribute = child.attrib
if 'id' in child.attrib:
elem_id = check_for_id()
child.set('id', elem_id)
if child.tag.split('}')[1] == 'use' and 'id' not in attribute.keys() or child.tag.split('}')[
1] == 'text' and 'id' not in attribute.keys():
elem_id = check_for_id()
child.set('id', elem_id)
tree.write(os.path.join(settings.BASE_DIR, 'parse_svg', 'templates') + '/' + url)
Project.objects.filter(project=project_name, email=request.user.email).update(thumbnail=url)
project = Project.objects.get(project=project_name, email=request.user.email)
filename = filename.split('.')[0]
if filename in arts:
old_art = ArtBoard.objects.get(artboard=filename, project__project__contains=project_name, latest=True)
ArtBoard.objects.filter(artboard=filename, project__project__contains=project_name).update(latest=False,
last_updated=datetime.now())
revision_entry = Revision(name=filename, artboard=old_art)
revision_entry.save()
new_entry = ArtBoard(project=project, artboard=filename, location=url, uuid=uuid_name, latest=True,
created=datetime.now(), last_updated=datetime.now())
new_entry.save()
Project.objects.filter(project=project_name).update(last_updated=datetime.now())
return redirect(redirection)
def get_revisions(self, file):
query = Revision.gql("WHERE file = :1 ORDER BY date DESC", file)
#.filter('__key__ != :1', file.head.key())
return query.fetch(100)
def get(self):
revisions = Revision.all().order('-date')
self.render('recent.jinja', revisions=revisions)
def get_lect_revs(user):
revs = Revision.gql('WHERE user=:1',user).fetch(50)
return revs
