def update(self, account_main_id, organisation: Organisation):
query = sql.SQL(""" UPDATE
organisation
SET
name = CASE WHEN {name_field}::varchar != '-1' THEN {name_field}::varchar WHEN {name_field}::varchar = '-1' THEN name END,
login = CASE WHEN {login_field}::varchar != '-1' THEN {login_field}::varchar WHEN {login_field}::varchar = '-1' THEN login END,
photo_link = CASE WHEN {photo_link_field}::varchar != '-1' THEN {photo_link_field}::varchar WHEN {photo_link_field}::varchar = '-1' THEN photo_link END,
description = CASE WHEN {description_field}::varchar != '-1' THEN {description_field}::varchar WHEN {description_field}::varchar = '-1' THEN description END,
edited_at = current_timestamp
WHERE
account_main_id = {account_main_id}
RETURNING id, edited_at;""").format(
name_field=sql.Identifier(organisation.name),
login_field=sql.Identifier(organisation.login),
photo_link_field=sql.Identifier(organisation.photo_link),
description_field=sql.Identifier(organisation.description),
account_main_id=sql.Identifier(organisation.account_main.id))
with self.pool.getconn() as conn:
with conn.cursor(cursor_factory=extras.RealDictCursor) as cur:
cur.execute(query)
row = cur.fetchone()
cur.close()
conn.commit()
self.pool.putconn(conn)
organisation.id = row['id']
organisation.edited_at = row['edited_at']
return organisation, None
def delete_teacher(auth_account_main_id: int, organisation_id: int):
teacher = Teacher(organisation=Organisation(id=organisation_id,
account_main=AccountMain(id=auth_account_main_id)))
teacher, err = TeacherService.delete_teacher(teacher)
if err:
return json.dumps(err)
return json.dumps(get_response_delete_teacher(teacher))
def _des_from_db_get_organisation(data):
return Organisation(
id=data['organisation_id'],
name=data['organisation_name'],
login=data['organisation_login'],
photo_link=data['organisation_photo_link'],
description=data['organisation_description'],
)
def delete_organisation(auth_account_main_id: int):
if request.method == 'POST':
organisations = Organisation(account_main=AccountMain(id=auth_account_main_id))
organisations, err = OrganisationService.delete_organisation(organisations)
if err:
return json.dumps(err)
return json.dumps(get_response_delete_organisation(organisations))
def _des_from_db_full_organisation(data):
return [
Organisation(id=data[i]['organisation_id'],
name=data[i]['organisation_name'],
login=data[i]['organisation_login'],
photo_link=data[i]['organisation_photo_link'],
description=data[i]['organisation_description'])
for i in range(len(data))
]
def _des_organisation_edit(organisation_dict):
return Organisation(name=organisation_dict.get('name')
if organisation_dict.get('name') else '-1',
login=organisation_dict.get('login')
if organisation_dict.get('login') else '-1',
photo_link=organisation_dict.get('photo_link')
if organisation_dict.get('photo_link') else '-1',
description=organisation_dict.get('description')
if organisation_dict.get('description') else '-1')
def _des_from_db_get_detail_event(event_dict) -> Events:
return Events(id=event_dict['events_id'],
type=event_dict['events_type'],
name=event_dict['events_name'],
date_event=event_dict['events_date_event'],
hours=event_dict['events_hours'],
skill=event_dict['events_skill'],
organisation=Organisation(
id=event_dict['events_organisation_id'], ))
def main_page(auth_account_main_id: int):
if request.method == 'GET':
organisation = Organisation(account_main=AccountMain(id=auth_account_main_id))
list_teacher_organisation, err = OrganisationService.get_all_by_account_id(organisation.account_main.id)
if err:
return json.dumps(err)
return json.dumps(get_response_detail_organisation(list_teacher_organisation))
def _des_from_db_full_events_by_org_id(list_events) -> List[Events]:
return [
Events(id=list_events[i]['events_id'],
type=list_events[i]['events_type'],
name=list_events[i]['events_name'],
date_event=list_events[i]['events_date_event'],
hours=list_events[i]['events_hours'],
skill=list_events[i]['events_skill'],
organisation=Organisation(
id=list_events[i]['events_organisation_id']))
for i in range(len(list_events))
]
def edit_teacher(auth_account_main_id: int, organisation_id: int):
errors = EditTeacherSchema().validate(dict(name=request.form['name'],
surname=request.form['surname'],
specialty=request.form['specialty']))
if errors:
return json.dumps(errors)
teacher = TeacherDeserializer.deserialize(request.form, DES_FOR_EDIT_TEACHER)
teacher.organisation = Organisation(id=organisation_id,
account_main=AccountMain(id=auth_account_main_id))
teacher, err = TeacherService.edit_teacher(teacher)
if err:
return json.dumps(err)
return json.dumps(get_response_edit_teacher(teacher))
def get_requests(auth_account_main_id: int, organisation_id: int):
if request.method == 'GET':
request_to_organisation = RequestToOrganisation(
events=Events(organisation=Organisation(
id=organisation_id,
account_main=AccountMain(id=auth_account_main_id)
))
)
list_request_to_organisation, err = RequestToOrganisationService.get_all_requests_by_org_id(request_to_organisation)
if err:
return json.dumps(err)
return json.dumps(get_response_with_get_all_requests(list_request_to_organisation))
def get_detail_request(auth_account_main_id: int, organisation_id: int, request_id: int):
if request.method == 'POST':
request_to_organisation = RequestToOrganisation(
id=request_id,
events=Events(organisation=Organisation(
id=organisation_id,
account_main=AccountMain(id=auth_account_main_id)
))
)
# TODO статус = тру, достаем id ребенка для events_child,
request_to_organisation, err = RequestToOrganisationService.accept_request(request_to_organisation)
if err:
return json.dumps(err)
return json.dumps(get_response_accept_request(request_to_organisation))
def add(self, organisation: Organisation):
sql = """ INSERT INTO organisation(account_main_id, name, login, photo_link, description) VALUES
(%s, %s, %s, %s, %s)
RETURNING id, created_at, edited_at;"""
with self.pool.getconn() as conn:
with conn.cursor(cursor_factory=extras.RealDictCursor) as cur:
try:
cur.execute(
sql, (organisation.account_main.id, organisation.name,
organisation.login, organisation.photo_link,
organisation.description))
row = cur.fetchone()
cur.close()
conn.commit()
except psycopg2.IntegrityError as err:
if err.pgcode == errorcodes.UNIQUE_VIOLATION:
return None, "Эта организация уже зарегистрирована"
else:
raise TypeError
self.pool.putconn(conn)
organisation.id = row['id']
organisation.created_at = row['created_at']
organisation.edited_at = row['edited_at']
return organisation, None
def remove(self, organisations: Organisation):
sql = """ DELETE FROM
organisation
WHERE
account_main_id = %s
RETURNING id;"""
with self.pool.getconn() as conn:
with conn.cursor(cursor_factory=extras.RealDictCursor) as cur:
cur.execute(sql, (organisations.account_main.id, ))
row = cur.fetchone()
cur.close()
conn.commit()
self.pool.putconn(conn)
organisations.id = row['id']
return organisations, None
def get_id_by_org_name(self, organisation_name: str):
sql = """ SELECT
id AS organisation_id
FROM
organisation
WHERE
organisation.name = %s"""
with self.pool.getconn() as conn:
with conn.cursor(cursor_factory=extras.RealDictCursor) as cur:
cur.execute(sql, (organisation_name, ))
row = cur.fetchone()
cur.close()
self.pool.putconn(conn)
if not row:
return None, "Такой компании не существует"
return Organisation(id=row['organisation_id']), None
def add_event(auth_account_main_id: int, organisation_id: int):
if request.method == 'POST':
errors = AddEventSchema().validate(dict(type=request.form['type'],
name=request.form['name'],
date_event=request.form['date_event'],
event_hours=request.form['hours'],
skill=request.form['skill']))
if errors:
return json.dumps(errors)
event: Events = EventDeserializer.deserialize(request.form, DES_FROM_ADD_EVENT)
event.organisation = Organisation(id=organisation_id,
account_main=AccountMain(id=auth_account_main_id))
event, err = EventsService.add_event(event)
if err:
return None, err
return json.dumps(get_response_add_event(event))
def wrapper(*args, auth_account_main_id: int, organisation_id: int,
**kwargs):
if not request.args.get('teacher'):
return json.dumps("Прикрепите учителя")
teacher = Teacher(
name=request.args.get('teacher').split(' ')[0],
surname=request.args.get('teacher').split(' ')[1],
organisation=Organisation(
id=organisation_id,
account_main=AccountMain(id=auth_account_main_id)))
teacher, err = TeacherService.get_by_organisation_id(teacher)
if err:
return json.dumps(err)
response = func(*args,
organisation_id=teacher.organisation.id,
teacher_id=teacher.id,
**kwargs)
return response
def get_by_id(self, account_main_id: int):
sql = """ SELECT
id AS organisation_id,
name AS organisation_name,
login AS organisation_login,
account_main_id AS account_main_id
FROM
organisation
WHERE
account_main_id = %s"""
with self.pool.getconn() as conn:
with conn.cursor(cursor_factory=extras.RealDictCursor) as cur:
cur.execute(sql, (account_main_id, ))
row = cur.fetchone()
cur.close()
self.pool.putconn(conn)
if not row:
return None, "Сначала зарегистрируйте себя как организацию"
organisation = Organisation(
id=row['organisation_id'],
name=row['organisation_name'],
login=row['organisation_login'],
account_main=AccountMain(id=row['account_main_id']))
return organisation, None
def _des_organisation_add(organisation_dict):
return Organisation(name=organisation_dict.get('name'),
login=organisation_dict.get('login'),
photo_link=organisation_dict.get('photo_link'),
description=organisation_dict.get('description'))
def _des_from_db_info_events(event_dict) -> Events:
return Events(
id=event_dict['events_id'],
name=event_dict['events_name'],
date_event=event_dict['events_date_event'],
organisation=Organisation(id=event_dict['events_organisation_id']))
def _des_from_db_detail_organisation(data):
return Organisation(id=data['organisation_id'],
created_at=data['organisation_created_at'],
name=data['organisation_name'],
photo_link=data['organisation_photo_link'],
description=data['organisation_description'])
