Example #1
0
def create_panel_permissions():
    sales_admin = CustomSysRole.query.filter_by(name='Sales Admin').first()
    from app.views.super_admin import SALES
    perm, _ = get_or_create(PanelPermission, panel_name=SALES, role=sales_admin)
    db.session.add(perm)
    marketer = CustomSysRole.query.filter_by(name='Marketer').first()
    perm, _ = get_or_create(PanelPermission, panel_name=SALES, role=marketer)
    db.session.add(perm)
Example #2
0
def create_services():
    track = Track.get_service_name()
    session = Session.get_service_name()
    speaker = Speaker.get_service_name()
    sponsor = Sponsor.get_service_name()
    microlocation = Microlocation.get_service_name()

    get_or_create(Service, name=track)
    get_or_create(Service, name=session)
    get_or_create(Service, name=speaker)
    get_or_create(Service, name=sponsor)
    get_or_create(Service, name=microlocation)
Example #3
0
def create_user_permissions():
    # Publish Event
    user_perm, _ = get_or_create(UserPermission, name='publish_event',
                                 description='Publish event (make event live)')
    user_perm.verified_user = True
    db.session.add(user_perm)

    # Create Event
    user_perm, _ = get_or_create(UserPermission, name='create_event',
                                 description='Create event')
    user_perm.verified_user, user_perm.unverified_user = True, True
    db.session.add(user_perm)
def create_roles():
    get_or_create(Role, name=ORGANIZER, title_name='Organizer')
    get_or_create(Role, name=COORGANIZER, title_name='Co-organizer')
    get_or_create(
        Role, name=TRACK_ORGANIZER,
             title_name='Track Organizer')
    get_or_create(Role, name=MODERATOR, title_name='Moderator')
def create_panel_permissions():
    # For Super Admin
    for panel in PANEL_LIST:
        panel_perm, _ = get_or_create(PanelPermission, role_name=SUPERADMIN, panel_name=panel)
        panel_perm.can_access = True
        db.session.add(panel_perm)

    # For Admin
    for panel in PANEL_LIST:
        panel_perm, _ = get_or_create(PanelPermission, role_name=ADMIN, panel_name=panel)
        panel_perm.can_access = True
        db.session.add(panel_perm)

    # For Sales Admin
    panel_perm, _ = get_or_create(PanelPermission, role_name=SALES_ADMIN, panel_name=SALES)
    panel_perm.can_access = True
    db.session.add(panel_perm)
Example #6
0
def create_admin_message_settings():
    default_mails = ["Next Event",
                     "Session Schedule Change",
                     "User email",
                     "Invitation For Papers",
                     "After Event",
                     "Ticket(s) Purchased",
                     "Session Accept or Reject",
                     "Event Published",
                     "Event Export Failed",
                     "Event Exported",
                     "Event Role Invitation",
                     "New Session Proposal"]
    for mail in MAILS:
        if mail in default_mails:
            get_or_create(MessageSettings, action=mail, mail_status=1, notif_status=1, user_control_status=1)
        else:
            get_or_create(MessageSettings, action=mail, mail_status=0, notif_status=0, user_control_status=0)
def create_panel_permissions():
    # For Super Admin
    for panel in PANEL_LIST:
        panel_perm, _ = get_or_create(PanelPermission,
                                      role_name=SUPERADMIN,
                                      panel_name=panel)
        panel_perm.can_access = True
        db.session.add(panel_perm)

    # For Admin
    for panel in PANEL_LIST:
        panel_perm, _ = get_or_create(PanelPermission,
                                      role_name=ADMIN,
                                      panel_name=panel)
        panel_perm.can_access = True
        db.session.add(panel_perm)

    # For Sales Admin
    panel_perm, _ = get_or_create(PanelPermission,
                                  role_name=SALES_ADMIN,
                                  panel_name=SALES)
    panel_perm.can_access = True
    db.session.add(panel_perm)
Example #8
0
def create_permissions():
    orgr = Role.query.get(1)
    coorgr = Role.query.get(2)
    track_orgr = Role.query.get(3)
    mod = Role.query.get(4)

    track = Service.query.get(1)
    session = Service.query.get(2)
    speaker = Service.query.get(3)
    sponsor = Service.query.get(4)
    microlocation = Service.query.get(5)

    # For ORGANIZER
    # All four permissions set to True
    get_or_create(Permission, role=orgr, service=track)
    get_or_create(Permission, role=orgr, service=session)
    get_or_create(Permission, role=orgr, service=speaker)
    get_or_create(Permission, role=orgr, service=sponsor)
    get_or_create(Permission, role=orgr, service=microlocation)

    # For COORGANIZER
    perm, _ = get_or_create(Permission, role=coorgr, service=track)
    perm.can_create, perm.can_delete = False, False
    db.session.add(perm)

    perm, _ = get_or_create(Permission, role=coorgr, service=session)
    perm.can_create, perm.can_delete = False, False
    db.session.add(perm)

    perm, _ = get_or_create(Permission, role=coorgr, service=speaker)
    perm.can_create, perm.can_delete = False, False
    db.session.add(perm)

    perm, _ = get_or_create(Permission, role=coorgr, service=sponsor)
    perm.can_create, perm.can_delete = False, False
    db.session.add(perm)

    perm, _ = get_or_create(Permission, role=coorgr, service=microlocation)
    perm.can_create, perm.can_delete = False, False
    db.session.add(perm)

    # For TRACK_ORGANIZER
    perm, _ = get_or_create(Permission, role=track_orgr, service=track)
    db.session.add(perm)

    # For MODERATOR
    perm, _ = get_or_create(Permission, role=mod, service=track)
    perm.can_create, perm.can_update, perm.can_delete = False, False, False
    db.session.add(perm)
Example #9
0
def create_roles():
    get_or_create(Role, name=ORGANIZER, title_name='Organizer')
    get_or_create(Role, name=COORGANIZER, title_name='Co-organizer')
    get_or_create(Role, name=TRACK_ORGANIZER, title_name='Track Organizer')
    get_or_create(Role, name=MODERATOR, title_name='Moderator')
    get_or_create(Role, name=ATTENDEE, title_name='Attendee')
    get_or_create(Role, name=REGISTRAR, title_name='Registrar')
Example #10
0
def create_custom_sys_roles():
    role, _ = get_or_create(CustomSysRole, name='Sales Admin')
    db.session.add(role)
    role, _ = get_or_create(CustomSysRole, name='Marketer')
    db.session.add(role)
Example #11
0
    def import_data(file_path, creator_id, task_handle):
        update_status(task_handle, 'Parsing iCal file')
        file = open(file_path, 'rb')
        calendar = Calendar.from_ical(file.read())
        update_status(task_handle, 'Processing event')
        event = Event()

        if 'X-WR-CALNAME' in calendar:
            event.name = get_valid_event_name(calendar.decoded('X-WR-CALNAME'))
        if not event.name and 'X-WR-CALDESC' in calendar:
            event.name = get_valid_event_name(calendar.decoded('X-WR-CALDESC'))
        for session in calendar.walk('vevent'):
            if not event.name:
                event.name = get_valid_event_name(session.decoded('UID'))

            start_time = session.decoded('dtstart')
            end_time = session.decoded('dtend')

            if not event.start_time or start_time < event.start_time:
                event.start_time = start_time
            if not event.end_time or end_time > event.end_time:
                event.end_time = end_time

        if not event.name:
            event.name = 'Un-named Event'
        # Event name set

        if 'X-WR-TIMEZONE' in calendar:
            event.timezone = calendar.decoded('X-WR-TIMEZONE')

        event.has_session_speakers = True
        event.state = 'Published'
        event.privacy = 'public'
        db.session.add(event)

        update_status(task_handle, 'Adding sessions')

        for session_block in calendar.walk('vevent'):
            track_id = None
            if 'CATEGORIES' in session_block:
                categories = session_block['CATEGORIES']
                string_to_hash = categories if not hasattr(categories, '__iter__') else categories[0]
                seed = int('100'.join(list(str(ord(character)) for character in string_to_hash)))
                random.seed(seed)
                color = "#%06x" % random.randint(0, 0xFFFFFF)
                track, _ = get_or_create(Track, event_id=event.id, name=string_to_hash, color=color)
                track_id = track.id

            microlocation, _ = get_or_create(Microlocation, event_id=event.id, name=session_block.decoded('location'))

            session = Session()
            session.track_id = track_id
            session.microlocation_id = microlocation.id
            session.title = session_block.decoded('summary')
            session.short_abstract = session_block.decoded('description')
            session.start_time = session_block.decoded('dtstart')
            session.end_time = session_block.decoded('dtend')
            session.signup_url = session_block.decoded('url')
            session.event_id = event.id
            session.state = 'accepted'
            session.speakers = []
            save_to_db(session, 'Session Updated')

            attendees = []
            if 'attendee' in session_block:
                attendees_dirty = session_block['attendee']
                if hasattr(attendees_dirty, '__iter__'):
                    for attendee in attendees_dirty:
                        attendees.append((attendee.params['CN'], attendee))
                else:
                    attendees.append((attendees_dirty.params['CN'], attendees_dirty))

            for attendee in attendees:
                speaker = Speaker(name=attendee[0], event_id=event.id, email=attendee[1].replace('MAILTO:', ''),
                                  country='Earth',
                                  organisation='')
                db.session.add(speaker)
                session.speakers.append(speaker)
                db.session.commit()

            update_status(task_handle, 'Added session "' + session.title + '"')

        update_status(task_handle, 'Saving data')
        save_to_db(event)
        update_status(task_handle, 'Finalizing')

        own_event(event=event, user_id=creator_id)
        return event
    def import_from_pentabarf(file_path=None,
                              string=None,
                              creator=None,
                              task_handle=None):

        if file_path:
            with open(file_path, 'r') as xml_file:
                string = xml_file.read().replace('\n', '')

        if not creator:
            creator = current_user

        try:
            update_status(task_handle, 'Parsing XML file')
            conference_object = PentabarfParser.parse(string)
            update_status(task_handle, 'Processing event')
            event = Event()
            event.start_time = conference_object.start
            event.end_time = conference_object.end
            event.has_session_speakers = True
            event.creator = creator
            event.name = conference_object.title
            event.location_name = conference_object.venue + ', ' + conference_object.city
            event.searchable_location_name = conference_object.city
            event.state = 'Published'
            event.privacy = 'public'
            db.session.add(event)
            update_status(task_handle, 'Adding sessions')
            index = 1
            for day_object in conference_object.day_objects:
                for room_object in day_object.room_objects:
                    microlocation, _ = get_or_create(Microlocation,
                                                     event_id=event.id,
                                                     name=room_object.name)
                    for event_object in room_object.event_objects:
                        session_type_id = None
                        if event_object.type:
                            session_type, _ = get_or_create(
                                SessionType,
                                event_id=event.id,
                                name=event_object.type,
                                length=30)
                            session_type_id = session_type.id
                        track_id = None
                        if event_object.track:
                            string_to_hash = event_object.track
                            seed = int('100'.join(
                                list(
                                    str(ord(character))
                                    for character in string_to_hash)))
                            random.seed(seed)
                            color = "#%06x" % random.randint(0, 0xFFFFFF)
                            track, _ = get_or_create(Track,
                                                     event_id=event.id,
                                                     name=event_object.track,
                                                     color=color)
                            track_id = track.id

                        session = Session()
                        session.track_id = track_id
                        session.microlocation_id = microlocation.id
                        session.session_type_id = session_type_id
                        session.title = event_object.title
                        session.short_abstract = event_object.abstract
                        session.long_abstract = event_object.description
                        session.start_time = event_object.date + string_to_timedelta(
                            event_object.start)
                        session.end_time = session.start_time + string_to_timedelta(
                            event_object.duration)
                        session.slides = event_object.slides_url
                        session.video = event_object.video_url
                        session.audio = event_object.audio_url
                        session.signup_url = event_object.conf_url
                        session.event_id = event.id
                        session.state = 'accepted'
                        db.session.add(session)

                        update_status(task_handle,
                                      'Adding session "' + session.title + '"')

                        index += 1

                        for person_object in event_object.person_objects:
                            name_mix = person_object.name + ' ' + conference_object.title
                            email = ''.join(
                                x for x in name_mix.title()
                                if not x.isspace()) + '@example.com'
                            speaker = Speaker(name=person_object.name,
                                              event_id=event.id,
                                              email=email,
                                              country='Earth',
                                              organisation=person_object.name)
                            db.session.add(speaker)

            update_status(task_handle, 'Saving data')
            save_to_db(event)
            update_status(task_handle, 'Finalizing')
        except Exception as e:
            from app.api.helpers.import_helpers import make_error
            raise make_error('event', er=e)
        return event
Example #13
0
    def import_data(file_path, creator_id, task_handle):

        with open(file_path, 'r') as xml_file:
            string = xml_file.read().replace('\n', '')

        update_status(task_handle, 'Parsing XML file')
        conference_object = PentabarfParser.parse(string)
        update_status(task_handle, 'Processing event')
        event = Event()
        event.start_time = conference_object.start
        event.end_time = conference_object.end
        event.has_session_speakers = True
        event.name = conference_object.title
        event.location_name = conference_object.venue  # + ', ' + conference_object.city
        event.searchable_location_name = conference_object.city
        event.state = 'Published'
        event.privacy = 'public'
        db.session.add(event)
        event_time_updated = False
        update_status(task_handle, 'Adding sessions')
        for day_object in conference_object.day_objects:
            for room_object in day_object.room_objects:
                microlocation, _ = get_or_create(Microlocation, event_id=event.id, name=room_object.name)
                for event_object in room_object.event_objects:
                    session_type_id = None
                    if event_object.type:
                        session_type, _ = get_or_create(SessionType, event_id=event.id,
                                                        name=event_object.type, length=str(30))  # TODO: hardcoded here
                        session_type_id = session_type.id
                    track_id = None
                    if event_object.track:
                        string_to_hash = event_object.track
                        seed = int('100'.join(list(str(ord(character)) for character in string_to_hash)))
                        random.seed(seed)
                        color = "#%06x" % random.randint(0, 0xFFFFFF)
                        track, _ = get_or_create(Track, event_id=event.id, name=event_object.track, color=color)
                        track_id = track.id

                    session = Session()
                    session.track_id = track_id
                    session.microlocation_id = microlocation.id
                    session.session_type_id = session_type_id
                    session.title = event_object.title
                    session.short_abstract = event_object.abstract
                    session.long_abstract = event_object.description
                    session.level = getattr(event_object, 'level', None)  # https://github.com/niranjan94/python-pentabarf-xml/issues/3
                    session.start_time = event_object.date + string_to_timedelta(event_object.start)
                    session.end_time = session.start_time + string_to_timedelta(event_object.duration)
                    session.slides = event_object.slides_url
                    session.video = event_object.video_url
                    session.audio = event_object.audio_url
                    session.signup_url = event_object.conf_url
                    session.event_id = event.id
                    session.state = 'accepted'
                    session.speakers = []
                    save_to_db(session, 'Session Updated')

                    if not event_time_updated:
                        event.start_time = None
                        event.end_time = None
                        event_time_updated = True

                    if not event.start_time or session.start_time < event.start_time:
                        event.start_time = session.start_time
                    if not event.end_time or session.end_time > event.end_time:
                        event.end_time = session.end_time

                    for person_object in event_object.person_objects:
                        name_mix = person_object.name + ' ' + conference_object.title
                        email = ''.join(x for x in name_mix.title() if not x.isspace()) + '@example.com'
                        speaker = Speaker(name=person_object.name, event_id=event.id, email=email,
                                          country='Earth',
                                          organisation='')
                        db.session.add(speaker)
                        session.speakers.append(speaker)
                        db.session.commit()

                    update_status(task_handle, 'Added session "' + session.title + '"')

        update_status(task_handle, 'Saving data')
        save_to_db(event)
        update_status(task_handle, 'Finalizing')
        own_event(event=event, user_id=creator_id)
        return event
def create_permissions():
    orgr = Role.query.get(1)
    coorgr = Role.query.get(2)
    track_orgr = Role.query.get(3)
    mod = Role.query.get(4)

    track = Service.query.get(1)
    session = Service.query.get(2)
    speaker = Service.query.get(3)
    sponsor = Service.query.get(4)
    microlocation = Service.query.get(5)

    # For ORGANIZER
    get_or_create(Permission, role=orgr, service=track, can_create=True, can_read=True, can_update=True, can_delete=True)
    get_or_create(Permission, role=orgr, service=session, can_create=True, can_read=True, can_update=True, can_delete=True)
    get_or_create(Permission, role=orgr, service=speaker, can_create=True, can_read=True, can_update=True, can_delete=True)
    get_or_create(Permission, role=orgr, service=sponsor, can_create=True, can_read=True, can_update=True, can_delete=True)
    get_or_create(Permission, role=orgr, service=microlocation, can_create=True, can_read=True, can_update=True, can_delete=True)

    # For COORGANIZER
    get_or_create(Permission, role=coorgr, service=track, can_create=False, can_read=True, can_update=True, can_delete=False)
    get_or_create(Permission, role=coorgr, service=session, can_create=False, can_read=True, can_update=True, can_delete=False)
    get_or_create(Permission, role=coorgr, service=speaker, can_create=False, can_read=True, can_update=True, can_delete=False)
    get_or_create(Permission, role=coorgr, service=sponsor, can_create=False, can_read=True, can_update=True, can_delete=False)
    get_or_create(Permission, role=coorgr, service=microlocation, can_create=False, can_read=True, can_update=True, can_delete=False)

    # For TRACK_ORGANIZER
    get_or_create(Permission, role=track_orgr, service=track, can_create=False, can_read=True, can_update=True, can_delete=False)

    # For MODERATOR
    get_or_create(Permission, role=mod, service=track, can_create=False, can_read=True, can_update=False, can_delete=False)