def register():
form = RegisterForm(request.form)
if form.validate_on_submit():
participant = models.Person(first_name=form.first_name.data,
last_name=form.last_name.data,
user_id=current_user.user_id)
db.session.add(participant)
db.session.flush()
food_choice = models.FoodChoice(person=participant.id,
vegetarian=form.vegetarian.data,
vegan=form.vegan.data,
kid_menu=form.kids_menu.data,
allergy=form.allergies.data)
print("register", participant.first_name, participant.last_name)
db.session.add(food_choice)
db.session.commit()
return str(participant)
return abort(400)
def get_user(self, login=""):
try:
user = Models.User.objects.get(username=login)
return Models.Person.objects.get(user=user)
except ObjectDoesNotExist:
return Models.Person()
def setUp(self):
self.success_test_params = [{
KEY_INPUT:
'Pranavi',
KEY_EXPECTED: [INITIAL_USERNAME, 'Pranavi'],
}, {
KEY_INPUT: 'Pranavi',
KEY_EXPECTED: "(duplicate error)",
}, {
KEY_INPUT:
'guest',
KEY_EXPECTED: [INITIAL_USERNAME, 'Pranavi', 'guest'],
}]
self.failure_test_params = [{
KEY_INPUT: 'Guest',
KEY_EXPECTED: ['Guest', INITIAL_USERNAME],
}, {
KEY_INPUT:
'Guest',
KEY_EXPECTED: [INITIAL_USERNAME, 'Guest', "(duplicate error)"],
}, {
KEY_INPUT:
'NewUser',
KEY_EXPECTED: [INITIAL_USERNAME, 'NewUser', 'Guest'],
}]
initial_person = models.Person(username=INITIAL_USERNAME, rank=100)
self.initial_db_mock = [initial_person]
def niccage():
"""Adds sample Nicolas Cage movies and subscribes admin."""
nc = models.Person(name='Nicolas Cage')
ba = models.Genre(genre_id=1337, genre='Bad action')
l1 = models.Listing(title='Oviedo: The City of Chickens',
description='One last job.',
release_date=datetime.utcnow() + timedelta(days=2),
writers=[nc],
directors=[nc],
actors=[nc],
genres=[ba],
subscribers=[models.User.query.get('admin')])
l2 = models.Listing(title='Biology: Chemistry in Disguise',
description='One last job.',
release_date=datetime.utcnow() + timedelta(days=4),
writers=[nc],
directors=[nc],
actors=[nc],
genres=[ba],
subscribers=[models.User.query.get('admin')])
db.session.add(l1)
db.session.add(l2)
db.session.commit()
return "done"
def update_referent(rntId=None):
if request.method == 'DELETE':
rnt = models.Referent.query.get(rntId)
ref = rnt.reference
rels_as_sbj = models.ReferentRelationship.query.filter_by(
subject_id=rnt.id).all()
rels_as_obj = models.ReferentRelationship.query.filter_by(
object_id=rnt.id).all()
for r in rels_as_sbj:
db.session.delete(r)
for r in rels_as_obj:
db.session.delete(r)
db.session.delete(rnt)
db.session.commit()
stamp_edit(current_user, ref)
return jsonify({'id': rntId})
data = request.get_json()
if request.method == 'POST':
prs = models.Person()
db.session.add(prs)
db.session.commit()
rnt = models.Referent(reference_id=data['record_id'])
rnt.person = prs
if request.method == 'PUT':
rnt = models.Referent.query.get(rntId)
primary_name = update_referent_name(data['name'])
rnt.names.append(primary_name)
rnt.primary_name = primary_name
if request.method == 'POST':
prs.first_name = primary_name.first
prs.last_name = primary_name.last
db.session.add(prs)
rnt.roles = [
get_or_create_referent_attribute(a, models.Role) for a in data['roles']
]
db.session.add(rnt)
db.session.commit()
stamp_edit(current_user, rnt.reference)
return jsonify({
'name_id': rnt.primary_name.id,
'first': rnt.primary_name.first,
'last': rnt.primary_name.last,
'id': rnt.id,
'roles': [role.id for role in rnt.roles]
})
def setUp(self):
# These need to be re-initialized separately for each test because
# SQLAlchemy is weird
self.test_people = [
models.Person(name='Will Cromar'),
models.Person(name='Alex Marrich'),
models.Person(name='Brenden Apswich')
]
self.test_listings = [
models.Listing(title='Biology: Chemistry in Disguise',
release_date=datetime.utcnow()),
models.Listing(title='Oviedo: The City of Chickens',
release_date=datetime.utcnow())
]
self.test_users = [
models.User(username='******', password='******'),
models.User(username='******', password='******')
]
self.db = db
self.app = app.test_client()
self.db.create_all()
def register():
if request.method == "POST":
username = request.form.get('username')
userid = uuid.uuid4()
user = models.Person(username=username, userid=str(userid))
db.session.add(user)
db.session.commit()
session['username'] = username
session['authd'] = True
return redirect('/posts')
else:
if 'authd' in session:
return redirect('/posts')
return render_template('register.html',
message=request.form.get("message"))
def add_person():
"""
Add a person.
Requires admin privileges.
:return: Edit person template with "Add" action.
"""
form = PersonForm()
if form.validate_on_submit():
person = models.Person()
form.populate_obj(person)
db.session.add(person)
db.session.commit()
flash(u'Data has been saved for Person {} {}'.format(form.first_name.data,
form.last_name.data))
return redirect(url_for('user_management'))
return render_template('edit_person.html', form=form, actionName="Add")
def posel(self):
try:
query = models.Person_old.query.filter(
models.Person_old.id == request.form['id'])
user = query.first()
if request.form.get('sel'):
db.session.add(
models.Person(user, room=request.form.get('sel')))
db.session.commit()
models.Room_free.query.filter_by(
room_id=request.form.get('sel')).first().places -= 1
db.session.commit()
db.session.delete(user)
db.session.commit()
flash('Выселено', '%s users were successfully approved.')
except Exception as ex:
if not self.handle_view_exception(ex):
raise
return redirect('/admin/person_old')
def add_acc():
add_person_form = AddRealPersonsForm()
persons = session.query(models.Person).filter_by(is_fake=False).all()
if add_person_form.validate_on_submit():
session.add(
models.Person(
name=add_person_form.name.data,
login=add_person_form.login.data,
password=add_person_form.password.data,
is_fake=False,
))
session.commit()
flash('New user have been saved.')
return redirect(url_for('add_acc'))
return render_template(
'add_acc.html',
title='Deserto 0.2.0',
add_person_form=add_person_form,
persons=persons,
)
def load():
from openpyxl import load_workbook
import os
from config import basedir
wb = load_workbook(os.path.join(basedir, '1.xlsx'))
ws = wb['БАЗА']
for row in range(1, ws.max_row + 1):
try:
hostel_id = models.Hostel.query.filter_by(
number=ws['G%s' % row].value).first().id
room = models.Room.query.filter_by(
hostel_id=hostel_id,
room_number=ws['H%s' % row].value).first().id
except:
hostel_id = None
print('ERROR', ws['A%s' % row].value)
room = None
m = models.Person(first_name=ws['A%s' % row].value,
last_name=ws['B%s' % row].value,
middle_name=ws['C%s' % row].value,
department=ws['D%s' % row].value,
group=ws['E%s' % row].value,
form_of_education=ws['F%s' % row].value,
hostel_id=hostel_id,
room_id=ws['H%s' % row].value,
birthday=ws['I%s' % row].value,
passport=ws['J%s' % row].value,
parents=ws['K%s' % row].value,
index=ws['L%s' % row].value,
region=ws['M%s' % row].value,
district=ws['N%s' % row].value,
settlement=ws['O%s' % row].value,
street=ws['P%s' % row].value,
phone_number_parent=ws['Q%s' % row].value,
phone_number=ws['R%s' % row].value,
note=ws['S%s' % row].value,
room=room)
db_session.add(m)
db_session.commit()
def setUp(self):
self.success_test_params = [
{
KEY_INPUT: 'naman',
KEY_EXPECTED: [INITIAL_USERNAME, 'naman'],
},
{
KEY_INPUT: 'jose',
KEY_EXPECTED: [INITIAL_USERNAME, 'naman', 'jose'],
},
{
KEY_INPUT: 'jhon',
KEY_EXPECTED: [INITIAL_USERNAME, 'naman', 'jose', 'jhon'],
},
{
KEY_INPUT: 'ta',
KEY_EXPECTED:
[INITIAL_USERNAME, 'naman', 'jose', 'jhon', 'ta'],
},
]
initial_person = models.Person(username=INITIAL_USERNAME, score=100)
self.initial_db_mock = [initial_person]
def parse_films():
engine = create_engine('sqlite:///:memory:', echo=True)
data = {}
for film in models.Film.query.filter_by(rating_kp=None).all(): #
while True:
try:
r = ProxyRequests(f'{URL}{film.links}')
except:
break
r.get()
r.encoding = 'utf-8'
text = r.request
soup = BeautifulSoup(text, 'html.parser')
genres = soup.find('span', {'itemprop': 'genre'})
if genres:
genres = genres.find_all('a')
countrys = soup.find_all(
'div', {'style': 'position: relative'})[1].find_all('a')
persons = soup.find_all('li', {'itemprop': 'actors'})
for director in soup.find_all('td', {'itemprop': 'director'}):
persons.append(director)
break
list_genres = []
for genre in genres:
if not models.Genre.query.filter_by(name=genre.text).first():
while True:
new_genre = models.Genre(name=genre.text)
db.session.add(new_genre)
try:
db.session.commit()
list_genres.append(new_genre)
break
except Exception:
db.session.rollback()
else:
list_genres.append(
models.Genre.query.filter_by(name=genre.text).first())
list_countrys = []
for country in countrys:
if not models.Country.query.filter_by(name=country.text).first():
while True:
new_country = models.Country(name=country.text)
db.session.add(new_country)
try:
db.session.commit()
list_countrys.append(new_country)
break
except Exception:
db.session.rollback()
else:
list_countrys.append(
models.Country.query.filter_by(name=country.text).first())
list_person = []
for person in persons:
if person.find('a').text.replace(' ', '') == '...':
break
person_link = person.find('a').get('href')
if not models.Person.query.filter_by(id_person_kp=int(
re.findall(r'\d{1,}', person_link)[0])).first():
while True:
# person_link = person.find('a').get('href')
if models.Person.query.filter_by(id_person_kp=int(
re.findall(r'\d{1,}', person_link)[0])).first():
break
id_person_kp = int(re.findall(r'\d{1,}', person_link)[0])
new_person = models.Person(name=person.text,
links=person_link,
id_person_kp=id_person_kp)
db.session.add(new_person)
try:
db.session.commit()
list_person.append(new_person)
break
except Exception:
db.session.rollback()
else:
if not models.Person.query.filter_by(id_person_kp=int(
re.findall(r'\d{1,}', person_link)
[0])).first() in list_person:
list_person.append(
models.Person.query.filter_by(id_person_kp=int(
re.findall(r'\d{1,}', person_link)[0])).first())
# if not film.description:
while True:
try:
film.name = soup.find('span', {
'class': 'moviename-title-wrapper'
}).text
film.name_original = film.name if not soup.find(
'span', {
'class': 'alternativeHeadline'
}).text else soup.find('span', {
'class': 'alternativeHeadline'
}).text
film.description = soup.find('div', {
'itemprop': 'description'
}).text.replace(chr(151), '-')
film.rating_kp = float(
soup.find('span', {
'class': 'rating_ball'
}).text)
film.rating_imdb = float(
re.findall(
r'[\d][^ ]+',
soup.find('div', {
'style':
'color:#999;font:100 11px tahoma, verdana'
}).text)[0])
film.date_released = int(
soup.find('div', {
'style': 'position: relative'
}).find('a').text)
try:
db.session.commit()
except Exception:
db.session.rollback()
continue
film.genre.clear()
film.country.clear()
film.person.clear()
while True:
for i in list_genres:
film.genre.append(i)
for i in list_countrys:
film.country.append(i)
for i in list_person:
film.person.append(i)
db.session.add(film)
try:
db.session.commit()
break
except Exception:
db.session.rollback()
break
except:
db.session.rollback()
