Exemplo n.º 1
0
    def cvtLastPeriod(self, factor, unit, length):
        obj = self.cvtField(factor)
        if 'year' == unit:
            year_obj = self.cvtTimeField(obj, 'year')
            return (year_obj > extract('year', current_date(type_ = types.Date)) - length)
        elif 'month' == unit:
            year_obj = self.cvtTimeField(obj, 'year')
            month_obj = self.cvtTimeField(obj, 'month')
            year_dist, month_dist = length / 12, length % 12

            return and_( \
                year_obj >= (extract('year', current_date(type_ = types.Date)) - year_dist - 1) \
                , month_obj > ((extract('month', current_date(type_ = types.Date)) - month_dist + 12) % 12) \
            )

        elif 'day' == unit:
            pass
        else:
            pass
Exemplo n.º 2
0
    def get_active_files(self, dir_id):
        '''
        特定のディレクトリに含まれる有効なファイルの一覧を取得する

        :param int dir_id: ディレクトリ ID
        :return: ファイル情報辞書のリスト
        '''
        return self.session_scope(lambda s: [
            n.to_dict() for n in s.query(File).filter(
                File.
                directory_id == dir_id, File.expires >= functions.current_date(
                ), File.is_deleted == False).order_by(File.file_id.desc())
        ])
Exemplo n.º 3
0
    def get_file(self, dir_id, file_id, only_active=True):
        '''
        ファイルの情報を取得する

        :param str dir_id: ディレクトリ名
        :param int file_id: ファイル ID
        :param bool only_active: 有効なファイルの場合にのみ取得したい場合は
            ``True`` を指定する。
        :return: hit した場合はファイル情報の辞書を、それ以外の場合は ``None`` を返す。

        ファイルが ``dir_name`` のディレクトリに含まれるものでない場合は無効となる。
        '''
        q = Query(File).filter(File.file_id == file_id,
                               File.directory_id == dir_id)
        if only_active:
            q = q.filter(File.expires >= functions.current_date(),
                         File.is_deleted == False)
        return self.session_scope(lambda s: (lambda f: f.to_dict(
        ) if f else None)(q.with_session(s).one_or_none()))
def registerInput(session):
    valid_username = False
    while not valid_username:
        username = input("Username: "******"Password: "******"Username is Already in Use" + bcolors.ENDC)
        else:
            print(bcolors.OKBLUE + "Successfully Registered!" + bcolors.ENDC)
            valid_username = True
            new_user = User(username=username,
                            password=password,
                            creation_date=current_date())
            session.add(new_user)
            session.commit()
Exemplo n.º 5
0
class Reservation(Base):
    __tablename__ = 'reservations'
    reservations_id = Column(Integer, primary_key=True, autoincrement=True)
    client_id = Column(Integer, ForeignKey(Client.client_id), nullable=False)
    room_number = Column(Integer, ForeignKey(Room.room_number), nullable=False)
    start_date = Column(Date, nullable=False, default=current_date())
    end_date = Column(Date, nullable=False)

    def __str__(self):
        return (f'reservation_id: {self.reservations_id}\n'
                f'client_id: {self.client_id}\n'
                f'room_number: {self.room_number}\n'
                f'start_date: {self.start_date}\n'
                f'end_date: {self.end_date}')

    def __repr__(self):
        return (f'reservation_id: {self.reservations_id}\n'
                f'client_id: {self.client_id}\n'
                f'room_number: {self.room_number}\n'
                f'start_date: {self.start_date}\n'
                f'end_date: {self.end_date}')
def loginInput(session):
    validUserFound = False
    while not validUserFound:
        username = input("Username: "******"Password: "******"password") == password).count()
        if user_count == 1:
            user = session.query(User).filter(
                getattr(User, 'username') == username,
                getattr(User, "password") == password).one()

            user.last_access_date = current_date()
            session.commit()
            print(bcolors.OKBLUE + "Successfully Logged In" + bcolors.ENDC)
            return user
        else:
            print(bcolors.FAIL + "User and Password Combination not Found" +
                  bcolors.ENDC)
Exemplo n.º 7
0
def get_activity(connection: Connection,
                 email: str,
                 survey_id: str=None) -> dict:
    """
    Get the number of submissions per day for the last 30 days for the given
    survey.

    :param connection: a SQLAlchemy Connection
    :param email: the user's e-mail address
    :param survey_id: the UUID of the survey, or None if fetching for all
                      user's surveys
    :return: a JSON dict of the result
    """
    submission_date = cast(submission_table.c.submission_time, Date)
    conditions = [
        submission_date > (current_date() - 30),
        auth_user_table.c.email == email
    ]
    if survey_id is not None:
        conditions.append(submission_table.c.survey_id == survey_id)

    result = connection.execute(
        select(
            [count(), submission_date]
        ).select_from(
            submission_table.join(survey_table).join(auth_user_table)
        ).where(
            and_(*conditions)
        ).group_by(
            submission_date
        ).order_by(
            submission_date
        )
    ).fetchall()

    return json_response(
        [[num, sub_time.isoformat()] for num, sub_time in result]
    )
Exemplo n.º 8
0
class File(Base):
    '''
    ファイルテーブルクラス
    '''
    __tablename__ = 'file_info'

    file_id = Column(Integer,
                     nullable=False,
                     primary_key=True,
                     autoincrement=True)
    origin_file_name = Column(Unicode(500), nullable=False)
    directory_id = Column(Integer,
                          ForeignKey('directory.directory_id',
                                     ondelete="cascade"),
                          nullable=False)
    expires = Column(Date, nullable=False)
    registered_user_id = Column(Unicode(50), nullable=False)
    registered_date = Column(Date,
                             nullable=False,
                             server_default=functions.current_date())
    summary = Column(UnicodeText)
    is_deleted = Column(Boolean, nullable=False, server_default=false())

    __table_args__ = (Index("idx_file_active", directory_id, expires.desc(),
                            is_deleted, file_id.desc()), )

    directory = relationship('Directory', back_populates="files")

    def __init__(self, file_name, dir_id, expires, user_id):
        '''
        コンストラクタ

        :param str file_name: オリジナルファイル名
        :param str dir_id: 登録先のディレクトリ ID
        :param datetime.date expires: 保存期限
        :param str user_id: 登録者のアカウントユーザー ID
        '''
        self.origin_file_name = file_name
        self.directory_id = dir_id
        self.expires = expires
        self.registered_user_id = user_id

    def to_dict(self, with_relation=True):
        '''
        辞書に変換

        :return: メンバー値を含む辞書を返す
        '''
        result = {
            "file_id": self.file_id,
            "origin_file_name": self.origin_file_name,
            "directory_id": self.directory_id,
            "expires": self.expires,
            "registered_user_id": self.registered_user_id,
            "registered_date": self.registered_date,
            "summary": self.summary,
            "is_deleted": self.is_deleted,
        }
        if with_relation:
            result.update({
                "directory":
                self.directory.to_dict(with_relation=False),
            })

        return result
Exemplo n.º 9
0
class Directory(Base):
    '''
    ディレクトリテーブルクラス
    '''
    __tablename__ = 'directory'

    directory_id = Column(Integer, nullable=False, primary_key=True)
    directory_name = Column(Unicode(100), nullable=False)
    create_date = Column(Date,
                         nullable=False,
                         server_default=functions.current_date())
    summary = Column(UnicodeText)
    expires_days = Column(Integer, nullable=False)
    is_deleted = Column(Boolean, nullable=False, server_default=false())

    __table_args__ = (Index("idx_directory_name_exists", directory_name,
                            is_deleted), )

    permissions = relationship("Permission",
                               back_populates="directory",
                               cascade="all, delete-orphan")
    files = relationship("File",
                         back_populates="directory",
                         cascade="all, delete-orphan")

    def __init__(self, dir_name, expires_days):
        '''
        コンストラクタ

        :param str dir_name: ディレクトリ名
        :param int expires_days: デフォルトのファイル保存期間

        ファイルのデフォルトの保存期限は、ファイル登録日の `expires_days` 日後となる。

        `summary` はインスタンス生成後に呼び出し側で格納すること。
        '''
        self.directory_name = dir_name
        self.expires_days = expires_days

    def to_dict(self, with_relation=True):
        '''
        辞書に変換

        :param bool with_relation: リレーションメンバーの値を含めるか?
        :return: メンバー値を含む辞書を返す

        ``with_relation == True`` であっても ``files`` は含めないものとする。
        ディレクトリに表示するファイルの一覧を取得するには、
        TmpboxDB.get_active_files() メソッドを使用すること。
        '''
        result = {
            "directory_id": self.directory_id,
            "directory_name": self.directory_name,
            "create_date": self.create_date,
            "summary": self.summary,
            "expires_days": self.expires_days,
        }
        if with_relation:
            result.update({
                "permissions":
                [n.to_dict(with_relation=False) for n in self.permissions],
            })
        return result