def update_user(self, id_user, name, surname, role, email, password,
is_admin):
user = User.query.get(id_user)
if user is None:
return None
else:
try:
if name is not None:
user.name = name
if surname is not None:
user.surname = surname
if role is not None:
user.role = role
if email is not None:
user.email = email
if password is not None:
user.password = password
if is_admin is not None:
user.is_admin = is_admin == 1
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def delete_contact(self, id_contact):
contact = Contact.query.get(id_contact)
if contact is None:
return None
else:
dB.delete(contact)
dB.commit()
return True
def add_offer_v2(self, title, content, descriptor, id_user):
offer = Offer(title, content, descriptor, id_user)
dB.add(offer)
try:
dB.commit()
return offer.id
except Exception as e:
dB.rollback()
return -1
def delete_team(self, id_prediction, id_field):
team = Team.query.filter_by(id_prediction=id_prediction,
id_field=id_field).first()
if team is None:
return False
else:
dB.delete(team)
dB.commit()
return True
def add_team(self, id_prediction, id_field, nb_members):
team = Team(id_prediction, id_field, nb_members)
dB.add(team)
try:
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def add_contact(self, name, surname, email, phone, role, id_field):
contact = Contact(name, surname, email, phone, role, id_field)
dB.add(contact)
try:
dB.commit()
return contact.serialize()
except Exception as e:
dB.rollback()
return None
def add_user(self, name, surname, role, email, password, is_admin):
user = User(name, surname, role, email, password, is_admin == 1)
dB.add(user)
try:
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def add_field(self, name, description, descriptor, website):
field = Field(name, description, descriptor, website)
dB.add(field)
try:
dB.commit()
return field.serialize()
except Exception as e:
dB.rollback()
return None
def add_field_v2(self, name, description, descriptor, website):
field = Field(name, description, descriptor, website)
dB.add(field)
try:
dB.commit()
return field.id
except Exception as e:
dB.rollback()
return -1
def add_prediction_v2(self, mark, inbase, id_offer):
date = datetime.datetime.now()
prediction = Prediction(mark, inbase == 1, date, id_offer)
dB.add(prediction)
try:
dB.commit()
return prediction.id
except Exception as e:
dB.rollback()
return -1
def add_contact_field(self, id_contact, id_field):
field = Field.query.get(id_field)
contact = Contact.query.get(id_contact)
if field is None or contact is None:
return False
else:
try:
field.contacts.append(contact)
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def delete_prediction(self, id_prediction):
prediction = Prediction.query.get(id_prediction)
if prediction is None:
return None
else:
try:
teams = prediction.teams
for t in teams:
self.delete_team(t.id)
dB.delete(prediction)
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def delete_offer(self, id_offer):
offer = Offer.query.get(id_offer)
if offer is None:
return None
else:
prediction = Prediction.query.filter_by(id_offer=id_offer).first()
if prediction is not None:
team = Team.query.filter_by(
id_prediction=prediction.id).first()
if team is not None:
dB.delete(team)
dB.delete(prediction)
dB.delete(offer)
dB.commit()
return True
def delete_field(self, id_field):
field = Field.query.get(id_field)
if field is None:
return None
else:
for contact in field.contacts:
self.delete_contact(contact.id)
for team in field.teams:
prediction = Prediction.query.get(team.id_prediction)
dB.delete(team)
if prediction is not None:
dB.delete(prediction)
dB.delete(field)
dB.commit()
return True
def delete_user(self, id_user):
user = User.query.get(id_user)
if user is None:
return None
else:
try:
for o in user.offers:
if o.prediction.inbase:
o.id_user = 1
else:
self.delete_offer(o.id)
dB.delete(user)
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def update_prediction(self, id_prediction, mark, inbase, id_offer):
prediction = Prediction.query.get(id_prediction)
if prediction is None:
return None
else:
try:
if mark is not None:
prediction.mark = mark
if inbase is not None:
prediction.inbase = inbase == 1
if id_offer is not None:
prediction.idOffer = id_offer
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def update_team(self, id_prediction, id_field, nb_members):
"change la formation associe a une prediction "
"on suppose qu'il y a une seule formation associe a une prediction dans un premier temps"
team = Team.query.filter_by(id_prediction=id_prediction).first()
if team is None:
return None
else:
try:
if id_field is not None:
team.id_field = id_field
if nb_members is not None:
team.nb_members = nb_members
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def update_prediction_by_id_offer(self, id_offer, id_field, in_base):
offer = Offer.query.get(id_offer)
if offer is None:
return None
else:
try:
prediction = offer.prediction
if id_field != None:
teams = prediction.teams
for team in teams:
team.id_field = id_field
if in_base != None:
prediction.inbase = (in_base == 1)
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def update_offer(self, id_offer, title, content, descriptor, id_user):
offer = Offer.query.get(id_offer)
if offer is None:
return None
else:
try:
if title is not None:
offer.title = title
if content is not None:
offer.content = content
if descriptor is not None:
offer.descriptor = descriptor
if id_user is not None:
offer.id_user = id_user
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def update_field(self, id_field, name, description, descriptor, website):
field = Field.query.get(id_field)
if field is None:
return None
else:
try:
if name is not None:
field.name = name
if description is not None:
field.description = description
if descriptor is not None:
field.descriptor = descriptor
if website is not None:
field.website = website
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def update_contact(self, id_contact, name, surname, email, phone, role,
id_field):
contact = Contact.query.get(id_contact)
if contact is None:
return None
else:
try:
if name is not None:
contact.name = name
if surname is not None:
contact.surname = surname
if email is not None:
contact.email = email
if phone is not None:
contact.phone = phone
if role is not None:
contact.role = role
if id_field is not None:
contact.id_field = id_field
dB.commit()
return True
except Exception as e:
dB.rollback()
return False
def delete_users(self):
users = User.query.all()
for user in users:
self.delete_user(user.id)
dB.commit()
