class Teacher:
"""School teacher or employee
:var int ~.id: Teacher ID
:var str ~.first_name: Teacher first name
:var str ~.last_name: Teacher last name (surname)
:var str ~.short: Code (short name) of the teacher
:var int ~.login_id: Teacher account ID
"""
id = IntegerField(key="Id")
first_name = StringField(key="Imie")
last_name = StringField(key="Nazwisko")
short = StringField(key="Kod")
login_id = IntegerField(key="LoginId")
@property
def name(self):
"""Returns the teacher's full name as "Name Surname".
:rtype: str
"""
return "{} {}".format(self.first_name, self.last_name)
@property
def name_reversed(self):
return "{} {}".format(self.last_name, self.first_name)
class PresenceType(Serializable):
"""Presence type
:var int ~.id: attendance ID
:var str ~.name: attendance name
:var str ~.symbol: attendance symbol
:var int ~.category_id: attendance category ID
:var str ~.category_name: attendance category name
:var int ~.position: attendance position
:var bool ~.presence: presence on lesson
:var bool ~.absence: absence on lesson
:var bool ~.exemption: exemption from lesson
:var bool ~.late: is late for lesson
:var bool ~.justified: justified absence
:var bool ~.deleted: whether the entry is deleted
"""
id = IntegerField(key="Id")
name: str = StringField(key="Name")
symbol: str = StringField(key="Symbol")
category_id: int = IntegerField(key="CategoryId")
category_name: str = StringField(key="CategoryName")
position: int = IntegerField(key="Position")
presence: bool = BooleanField(key="Presence")
absence: bool = BooleanField(key="Absence")
exemption: bool = BooleanField(key="LegalAbsence")
late: bool = BooleanField(key="Late")
justified: bool = BooleanField(key="AbsenceJustified")
deleted: bool = BooleanField(key="Removed")
class School:
"""School
:var int ~.id: School ID
:var str ~.name: School full name
:var str ~.short: Short name of the school
:var str ~.symbol: School symbol
"""
id = IntegerField(key="IdJednostkaSprawozdawcza")
name = StringField(key="JednostkaSprawozdawczaNazwa")
short = StringField(key="JednostkaSprawozdawczaSkrot")
symbol = StringField(key="JednostkaSprawozdawczaSymbol")
@staticmethod
def only_keys(json):
return dict_only(
json,
{
"IdJednostkaSprawozdawcza",
"JednostkaSprawozdawczaNazwa",
"JednostkaSprawozdawczaSkrot",
"JednostkaSprawozdawczaSymbol",
},
)
class Addressbook(Serializable):
"""An address book.
:var str ~.id: recipient id
:var str ~.login_id: recipient login id
:var str ~.first_name: recipient's first name
:var str ~.last_name: recipient's last name
:var str ~.initials: recipient's initials
:var list[Role] ~.roles: recipient's role (eg. Teacher)
"""
id: str = StringField(key="Id")
login_id: int = IntegerField(key="LoginId")
first_name: str = StringField(key="Name")
last_name: str = StringField(key="Surname")
initials: str = StringField(key="Initials")
roles: List[Role] = SequenceField(Role, key="Roles", repr=True)
@classmethod
async def get(cls, api,
**kwargs) -> Union[AsyncIterator["Addressbook"], List[int]]:
"""
:rtype: Union[AsyncIterator[:class:`~vulcan.data.Addressbook`], List[int]]
"""
data = await api.helper.get_list(DATA_ADDRESSBOOK,
FilterType.BY_LOGIN_ID, **kwargs)
for addressbook in data:
yield Addressbook.load(addressbook)
class Lesson(Serializable):
"""A lesson.
:var int ~.id: lesson's ID
:var `~vulcan.hebe.model.DateTime` ~.date: lesson's date
:var `~vulcan.hebe.model.TimeSlot` ~.time: lesson's time
:var `~vulcan.hebe.data.LessonRoom` ~.room: classroom, in which is the lesson
:var `~vulcan.hebe.model.Teacher` ~.teacher: teacher of the lesson
:var `~vulcan.hebe.model.Teacher` ~.second_teacher: second teacher of the lesson
:var `~vulcan.hebe.model.Subject` ~.subject: subject on the lesson
:var str ~.event: an event happening during this lesson
:var str ~.changes: lesson changes
:var `~vulcan.hebe.model.TeamClass` ~.team_class: the class that has the lesson
:var str ~.pupil_alias: pupil alias
:var `~vulcan.hebe.model.TeamVirtual` ~.group: group, that has the lesson
:var bool ~.visible: lesson visibility (whether the timetable applies to the given student)
"""
id: int = IntegerField(key="Id", required=False)
date: DateTime = ChildField(DateTime, key="Date", required=False)
time: TimeSlot = ChildField(TimeSlot, key="TimeSlot", required=False)
room: LessonRoom = ChildField(LessonRoom, key="Room", required=False)
teacher: Teacher = ChildField(Teacher, key="TeacherPrimary", required=False)
second_teacher: Teacher = ChildField(
Teacher, key="TeacherSecondary", required=False
)
subject: Subject = ChildField(Subject, key="Subject", required=False)
event: str = StringField(key="Event", required=False)
changes: str = StringField(key="Change", required=False)
team_class: TeamClass = ChildField(TeamClass, key="Clazz", required=False)
pupil_alias: str = StringField(key="PupilAlias", required=False)
group: TeamVirtual = ChildField(TeamVirtual, key="Distribution", required=False)
visible = BooleanField(key="Visible", required=False)
@classmethod
async def get(
cls, api, last_sync, deleted, date_from, date_to, **kwargs
) -> Union[AsyncIterator["Lesson"], List[int]]:
"""
:rtype: Union[AsyncIterator[:class:`~vulcan.hebe.data.Lesson`], List[int]]
"""
if date_from == None:
date_from = datetime.date.today()
if date_to == None:
date_to = date_from
date_to = date_to + datetime.timedelta(
days=1
) # Vulcan requires the date_to to be one greater the date it is supposed to be
data = await api.helper.get_list(
DATA_TIMETABLE,
FilterType.BY_PUPIL,
deleted=deleted,
date_from=date_from,
date_to=date_to,
last_sync=last_sync,
**kwargs
)
for lesson in data:
yield Lesson.load(lesson)
class GradeColumn(Serializable):
"""A grade column. Represents a topic which a student
may get a grade from (e.g. a single exam, short test, homework).
:var int ~.id: grade column's ID
:var str ~.key: grade column's key (UUID)
:var int ~.period_id: ID of the period when the grade is given
:var str ~.name: grade column's name (description)
:var str ~.code: grade column's code (e.g. short name or abbreviation)
:var str ~.group: unknown, yet
:var int ~.number: unknown, yet
:var int ~.weight: weight of this column's grades
:var `~vulcan.hebe.model.Subject` ~.subject: the subject from which
grades in this column are given
:var `~vulcan.hebe.data.GradeCategory` ~.category: category (base type)
of grades in this column
:var `~vulcan.hebe.model.Period` ~.period: a resolved period of this grade
"""
id: int = IntegerField(key="Id")
key: str = StringField(key="Key")
period_id: int = IntegerField(key="PeriodId")
name: str = StringField(key="Name")
code: str = StringField(key="Code")
group: str = StringField(key="Group")
number: int = IntegerField(key="Number")
weight: float = FloatField(key="Weight")
subject: Subject = ChildField(Subject, key="Subject")
category: GradeCategory = ChildField(GradeCategory, key="Category")
period: Period = ChildField(Period, key="Period", required=False)
class Grade(Serializable):
"""A grade.
:var int ~.id: grade's ID
:var str ~.key: grade's key (UUID)
:var int ~.pupil_id: the related pupil's ID
:var str ~.content_raw: grade's content (with comment)
:var str ~.content: grade's content (without comment)
:var `~vulcan.model.DateTime` ~.date_created: grade's creation date
:var `~vulcan.model.DateTime` ~.date_modified: grade's modification date
(may be the same as ``date_created`` if it was never modified)
:var `~vulcan.model.Teacher` ~.teacher_created: the teacher who added
the grade
:var `~vulcan.model.Teacher` ~.teacher_modified: the teacher who modified
the grade
:var `~vulcan.data.GradeColumn` ~.column: grade's column
:var float ~.value: grade's value, may be `None` if 0.0
:var str ~.comment: grade's comment, visible in parentheses in ``content_raw``
:var float ~.numerator: for point grades: the numerator value
:var float ~.denominator: for point grades: the denominator value
"""
id: int = IntegerField(key="Id")
key: str = StringField(key="Key")
pupil_id: int = IntegerField(key="PupilId")
content_raw: str = StringField(key="ContentRaw")
content: str = StringField(key="Content")
date_created: DateTime = ChildField(DateTime, key="DateCreated")
date_modified: DateTime = ChildField(DateTime, key="DateModify")
teacher_created: Teacher = ChildField(Teacher, key="Creator")
teacher_modified: Teacher = ChildField(Teacher, key="Modifier")
column: GradeColumn = ChildField(GradeColumn, key="Column")
value: float = FloatField(key="Value", required=False)
comment: str = StringField(key="Comment", required=False)
numerator: float = FloatField(key="Numerator", required=False)
denominator: float = FloatField(key="Denominator", required=False)
@classmethod
async def get(
cls, api, last_sync, deleted, **kwargs
) -> Union[AsyncIterator["Grade"], List[int]]:
"""
:rtype: Union[AsyncIterator[:class:`~vulcan.data.Grade`], List[int]]
"""
data = await api.helper.get_list(
DATA_GRADE,
FilterType.BY_PUPIL,
deleted=deleted,
last_sync=last_sync,
**kwargs
)
for grade in data:
grade["Column"]["Period"] = api.student.period_by_id(
grade["Column"]["PeriodId"]
).as_dict
yield Grade.load(grade)
class Attachment(Serializable):
"""An attachment
:var str ~.name: Name
:var str ~.link: Link
"""
name: str = StringField(key="Name")
link: str = StringField(key="Link")
class Role(Serializable):
"""A role of addressee.
:var str ~.role_name: role name
:var int ~.role_order: role order
:var str ~.address_name: address name
:var str ~.address_hash: address hash
:var str ~.first_name: recipient's first name
:var str ~.last_name: recipient's last name
:var str ~.initials: recipient's initials
:var str ~.unit_symbol: recipient's unit_symbol
:var str ~.constituent_unit_symbol: recipient's constituent unit symbol
:var str ~.class_symbol: recipient's class symbol
"""
role_name: str = StringField(key="RoleName")
role_order: int = IntegerField(key="RoleOrder")
address_name: str = StringField(key="Address")
address_hash: str = StringField(key="AddressHash")
first_name: str = StringField(key="Name")
last_name: str = StringField(key="Surname")
initials: str = StringField(key="Initials")
unit_symbol: str = StringField(key="UnitSymbol", required=False)
constituent_unit_symbol: str = StringField(key="ConstituentUnitSymbol",
required=False)
class_symbol: str = StringField(key="ClassSymbol", required=False)
class GradeCategory:
"""Grade category
:var id ~.id: Category ID
:var str ~.name: Full category name
:var str ~.short: Short name of the category
"""
id = IntegerField(key="Id")
name = StringField(key="Nazwa")
short = StringField(key="Kod")
class GradeCategory(Serializable):
"""A base grade category. Represents a generic type, like an exam, a short test,
a homework or other ("current") grades.
:var int ~.id: grade category's ID
:var str ~.name: grade category's name
:var str ~.code: grade category's code (e.g. short name or abbreviation)
"""
id: int = IntegerField(key="Id")
name: str = StringField(key="Name")
code: str = StringField(key="Code")
class Teacher(Serializable):
"""A teacher or other school employee.
:var int ~.id: teacher ID
:var str ~.name: teacher's name
:var str ~.surname: teacher's surname
:var str ~.display_name: teacher's display name
"""
id: int = IntegerField(key="Id")
name: str = StringField(key="Name")
surname: str = StringField(key="Surname")
display_name: str = StringField(key="DisplayName")
class TeamClass(Serializable):
"""A school class.
:var int ~.id: class ID
:var str ~.key: class's key (UUID)
:var str ~.display_name: class's display name
:var str ~.symbol: class's symbol (e.g. a letter after the level, "C" in "6C")
"""
id: int = IntegerField(key="Id")
key: str = StringField(key="Key")
display_name: str = StringField(key="DisplayName")
symbol: str = StringField(key="Symbol")
class Subject:
"""School subject
:var int ~.id: Subject ID
:var str ~.name: Subject full name
:var str ~.short: Short name of the subject
:var int ~.position: Position of the subject in subjects list
"""
id = IntegerField(key="Id")
name = StringField(key="Nazwa")
short = StringField(key="Kod")
position = IntegerField(key="Pozycja")
class School(Serializable):
"""A single school building.
:var int ~.id: school ID
:var str ~.name: school full name
:var str ~.short_name: school short name
:var str ~.address: school address (location)
"""
id: int = IntegerField(key="Id")
name: str = StringField(key="Name")
short_name: str = StringField(key="Short")
address: str = StringField(key="Address")
class Student:
"""Student
:var int ~.id: Student ID
:var int ~.login_id: ID of the logged user
:var str ~.account_name: Student account name
:var str ~.first_name: Student first name
:var str ~.second_name: Student second name, optional
:var str ~.last_name: Student last name (surname)
:var `~vulcan._student.Gender` ~.gender: Student gender
:var str ~.nickname: Student nickname
:var `~vulcan._period.Period` ~.period: Current student class period
:var `~vulcan._class.Class` ~.class_: Student class
:var `~vulcan._school.School` ~.school: Student school
"""
id = IntegerField(key="Id")
login_id = IntegerField(key="UzytkownikLoginId")
account_name = StringField(key="UzytkownikNazwa")
first_name = StringField(key="Imie")
last_name = StringField(key="Nazwisko")
gender = ChildField(Gender, key="UczenPlec")
second_name = StringField(key="Imie2", required=False)
nickname = StringField(key="Pseudonim", required=False)
period = ChildField(Period, required=False)
class_ = ChildField(Class, required=False)
school = ChildField(School, required=False)
@property
def name(self):
"""Returns the student's full name as "Name SecondName Surname".
:rtype: str
"""
first = "{} {}".format(self.first_name, self.second_name).rstrip()
return "{} {}".format(first, self.last_name)
@staticmethod
def format_json(json):
json["period"] = Period.only_keys(json)
json["class_"] = Class.only_keys(json)
json["school"] = School.only_keys(json)
return json
@classmethod
def get(cls, api):
j = api.post(api.base_url + "UczenStart/ListaUczniow")
for student in j.get("Data", []):
yield to_model(cls, cls.format_json(student))
class Homework(Serializable):
"""A homework.
:var int ~.id: homework's external ID
:var str ~.key: homework's key (UUID)
:var int ~.homework_id: homework's internal ID
:var str ~.content: homework's content
:var `~vulcan.hebe.model.DateTime` ~.date_created: homework's creation date
:var `~vulcan.hebe.model.Teacher` ~.creator: the teacher who added
the homework
:var `~vulcan.hebe.model.Subject` ~.subject: the homework's subject
:var List[Attachment] ~.attachments: attachments added to homework
:var bool ~.is_answer_required: Is an answer required
:var `~vulcan.hebe.model.DateTime` ~.deadline: homework's date and time
:var `~vulcan.hebe.model.DateTime` ~.answer_deadline: homework's answer deadline
:var `~vulcan.hebe.model.DateTime` ~.answer_date: homework's answer date and time
"""
id: int = IntegerField(key="Id")
key: str = StringField(key="Key")
homework_id: int = StringField(key="IdHomework")
content: str = StringField(key="Content")
date_created: DateTime = ChildField(DateTime, key="DateCreated")
creator: Teacher = ChildField(Teacher, key="Creator")
subject: Subject = ChildField(Subject, key="Subject")
attachments: List[Attachment] = SequenceField(Attachment,
key="Attachments",
repr=True)
is_answer_required: Subject = BooleanField(key="IsAnswerRequired")
deadline: DateTime = ChildField(DateTime, key="Deadline")
answer_deadline: DateTime = ChildField(DateTime,
key="AnswerDeadline",
required=False)
answer_date: DateTime = ChildField(DateTime,
key="AnswerDate",
required=False)
@classmethod
async def get(cls, api, last_sync, deleted,
**kwargs) -> Union[AsyncIterator["Homework"], List[int]]:
"""
:rtype: Union[AsyncIterator[:class:`~vulcan.hebe.data.Homework`], List[int]]
"""
data = await api.helper.get_list(DATA_HOMEWORK,
FilterType.BY_PUPIL,
deleted=deleted,
last_sync=last_sync,
**kwargs)
for homework in data:
yield Homework.load(homework)
class Exam(Serializable):
"""An exam or short quiz.
:var int ~.id: exam's ID
:var str ~.key: exam's key (UUID)
:var str ~.type: exam's type
:var str ~.topic: exam's topic
:var `~vulcan.hebe.model.DateTime` ~.date_created: exam's creation date
:var `~vulcan.hebe.model.DateTime` ~.date_modified: exam's modification date
(may be the same as ``date_created`` if it was never modified)
:var `~vulcan.hebe.model.DateTime` ~.deadline: exam's date and time
:var `~vulcan.hebe.model.Teacher` ~.creator: the teacher who added
the exam
:var `~vulcan.hebe.model.Subject` ~.subject: the exam's subject
:var `~vulcan.hebe.model.TeamClass` ~.team_class: the class taking the exam
:var `~vulcan.hebe.model.TeamVirtual` ~.team_virtual: the class distribution
taking the exam, optional
"""
id: int = IntegerField(key="Id")
key: str = StringField(key="Key")
type: str = StringField(key="Type")
topic: str = StringField(key="Content")
date_created: DateTime = ChildField(DateTime, key="DateCreated")
date_modified: DateTime = ChildField(DateTime, key="DateModify")
deadline: DateTime = ChildField(DateTime, key="Deadline")
creator: Teacher = ChildField(Teacher, key="Creator")
subject: Subject = ChildField(Subject, key="Subject")
team_class: TeamClass = ChildField(TeamClass, key="Class")
team_virtual: TeamVirtual = ChildField(
TeamVirtual, key="Distribution", required=False
)
@classmethod
async def get(
cls, api, last_sync, deleted, **kwargs
) -> Union[AsyncIterator["Exam"], List[int]]:
"""
:rtype: Union[AsyncIterator[:class:`~vulcan.hebe.data.Exam`], List[int]]
"""
data = await api.helper.get_list(
DATA_EXAM,
FilterType.BY_PUPIL,
deleted=deleted,
last_sync=last_sync,
**kwargs
)
for exam in data:
yield Exam.load(exam)
class Subject(Serializable):
"""A school subject.
:var int ~.id: subject ID
:var str ~.key: subject's key (UUID)
:var str ~.name: subject's name
:var str ~.code: subject's code (e.g. short name or abbreviation)
:var int ~.position: unknown, yet
"""
id: int = IntegerField(key="Id")
key: str = StringField(key="Key")
name: str = StringField(key="Name")
code: str = StringField(key="Kod")
position: int = IntegerField(key="Position")
class Notice:
"""Positive, negative or neutral student notice
:var int ~.id: Notice ID
:var str ~.content: Content of the notice
:var `datetime.date` ~.date: Notice added date
:var `~vulcan._notice.NoticeType` ~.type: Notice type class
:var `~vulcan._teacher.Teacher` ~.teacher: Teacher, who added the notice
"""
id = IntegerField(key="Id")
content = StringField(key="TrescUwagi")
date = DateField(key="DataWpisuTekst")
type = ChildField(NoticeType, required=False)
teacher = ChildField(Teacher, required=False)
@classmethod
def get(cls, api):
j = api.post("Uczen/UwagiUcznia")
notices = sorted(j.get("Data", []), key=itemgetter("DataWpisu"))
for notice in notices:
notice["type"] = api.dict.get_notice_category_json(
notice["IdKategoriaUwag"])
notice["teacher"] = api.dict.get_teacher_json(
notice["IdPracownik"])
yield to_model(cls, notice)
class TeamVirtual(Serializable):
"""A virtual team, i.e. a part of the school class. Often called
a "distribution" of the class.
:var int ~.id: team ID
:var str ~.key: team's key (UUID)
:var str ~.shortcut: team's short name
:var str ~.name: team's name
:var str ~.part_type: type of the distribution
"""
id: int = IntegerField(key="Id")
key: str = StringField(key="Key")
shortcut: str = StringField(key="Shortcut")
name: str = StringField(key="Name")
part_type: str = StringField(key="PartType")
class Account(Serializable):
"""An account in the e-register.
:var int ~.login_id: the account's login ID
:var str ~.user_login: the account's login name (email/username)
:var str ~.user_name: probably the same as user_login
:var str ~.rest_url: the API base URL for the partition symbol
"""
login_id: int = IntegerField(key="LoginId")
user_login: str = StringField(key="UserLogin")
user_name: str = StringField(key="UserName")
rest_url: str = StringField(key="RestURL")
@staticmethod
async def register(
keystore: Keystore, token: str, symbol: str, pin: str
) -> "Account":
token = str(token).upper()
symbol = str(symbol).lower()
pin = str(pin)
body = {
"OS": APP_OS,
"DeviceModel": keystore.device_model,
"Certificate": keystore.certificate,
"CertificateType": "X509",
"CertificateThumbprint": keystore.fingerprint,
"PIN": pin,
"SecurityToken": token,
"SelfIdentifier": uuid(keystore.fingerprint),
}
base_url = await get_base_url(token)
full_url = "/".join([base_url, symbol, DEVICE_REGISTER])
log.info("Registering to {}...".format(symbol))
api = Api(keystore)
response = await api.post(full_url, body)
await api.close()
log.info("Successfully registered as {}".format(response["UserName"]))
return Account.load(response)
class MessageRecipient:
"""Message recipient
:var int ~.login_id: Recipient's login ID
:var str ~.name: Recipient's name
"""
login_id = IntegerField(key="LoginId")
name = StringField(key="Nazwa")
class NoticeType:
"""Notice type
:var int ~.id: Notice type ID
:var str ~.name: Name of the notice type
"""
id = IntegerField(key="Id")
name = StringField(key="Nazwa")
class LessonRoom(Serializable):
"""Lesson room
:var int ~.id: lesson room ID
:var str ~.code: classroom code
"""
id: int = IntegerField(key="Id")
code: str = StringField(key="Code")
class Class:
"""Class
:var int ~.id: Class ID
:var int ~.level: Class level (eg. `8`)
:var str ~.name: Class name (eg. `"8A"`)
:var str ~.symbol: Class symbol (eg. `"A"`)
"""
id = IntegerField(key="IdOddzial")
level = IntegerField(key="OkresPoziom")
name = StringField(key="OddzialKod", required=False)
symbol = StringField(key="OddzialSymbol", required=False)
@staticmethod
def only_keys(json):
return dict_only(
json, {"IdOddzial", "OddzialKod", "OkresPoziom", "OddzialSymbol"})
class Pupil(Serializable):
"""A class containing the student's data.
:var int ~.id: pupil's ID
:var int ~.login_id: pupil's account login ID
:var str ~.login_value: pupil's account login name (email/username)
:var str ~.first_name: student's first name
:var str ~.second_name: student's second name, optional
:var str ~.last_name: student's last name / surname
:var `~vulcan.model.Gender` ~.gender: student's gender
"""
id: int = IntegerField(key="Id")
login_id: int = IntegerField(key="LoginId")
first_name: str = StringField(key="FirstName")
last_name: str = StringField(key="Surname")
gender: Gender = ChildField(Gender, key="Sex")
second_name: str = StringField(key="SecondName", required=False)
login_value: str = StringField(key="LoginValue", required=False)
class Project:
name = StringField()
long_name = StringField()
leaders = SetField(Agent, default=[missingAgent])
implementation_leaders = SetField(Agent, default=[missingAgent])
validation_leaders = SetField(Agent, default=[missingAgent])
version = StringField(default="0.0.1")
@staticmethod
def sample():
return Project(name='My Project',
long_name='My very precious project about stars',
leaders=[Agent(name='John Doe')],
implementation_leaders=[
Agent(name='Foo Bar'),
Agent(name='Stan Getz')
],
validation_leaders=[
Agent(name='Billy Holliday'),
Agent(name='Chet Baker')
])
class Keystore(Serializable):
"""A keystore containing of:
- a PEM-encoded X509 certificate signed using SHA-256 with RSA algorithm
- SHA-1 fingerprint of the certificate, represented
as lowercase hexadecimal characters
- a PEM-encoded PKCS#8 RSA 2048 private key
Additionally, to use with the Vulcan API the keystore contains:
- a Firebase Cloud Messaging token - to re-use for every request
- a device name string, also needed for API requests
:var str ~.certificate: a PEM-encoded certificate
:var str ~.fingerprint: the certificate's fingerprint
:var str ~.private_key: a PEM-encoded RSA 2048 private key
:var str ~.firebase_token: an FCM token
:var str ~.device_model: a device model string
"""
certificate: str = StringField(key="Certificate")
fingerprint: str = StringField(key="Fingerprint")
private_key: str = StringField(key="PrivateKey")
firebase_token: str = StringField(key="FirebaseToken")
device_model: str = StringField(key="DeviceModel")
@staticmethod
def create(
firebase_token: str = None,
device_model: str = default_device_model()
) -> "Keystore":
log.info("Generating key pair...")
keystore = Keystore(
*generate_key_pair(),
firebase_token if firebase_token else get_firebase_token(),
device_model)
log.info("Generated for {}, sha1: {}".format(device_model,
keystore.fingerprint))
return keystore
class Grade:
"""Grade
:var int ~.id: Grade ID
:var str ~.content: Grade content
:var float ~.weight: Grade weight
:var str ~.description: Grade description
:var `datetime.datetime` ~.date: Grade creation date
:var `datetime.datetime` ~.last_modification_date: Last grade modification date
:var float ~.value: Grade value (you can use it to calculate the average)
:var `~vulcan._teacher.Teacher` ~.teacher: Teacher, who added the grade
:var `~vulcan._subject.Subject` ~.subject: Subject, from which student received the grade
:var `~vulcan._grade.GradeCategory` ~.category: Grade category
"""
id = IntegerField(key="Id")
content = StringField(key="Wpis")
weight = FloatField(key="WagaOceny")
description = StringField(key="Opis")
date = DateTimeField(key="DataUtworzeniaTekst")
last_modification_date = DateTimeField(key="DataModyfikacjiTekst")
value = FloatField(key="Wartosc", required=False)
teacher = ChildField(Teacher, required=False)
subject = ChildField(Subject, required=False)
category = ChildField(GradeCategory, required=False)
@classmethod
def get(cls, api):
j = api.post("Uczen/Oceny")
for grade in j.get("Data", []):
grade["teacher"] = api.dict.get_teacher_json(grade["IdPracownikD"])
grade["subject"] = api.dict.get_subject_json(grade["IdPrzedmiot"])
grade["category"] = api.dict.get_grade_category_json(
grade["IdKategoria"])
yield to_model(cls, grade)
