Example #1
0
	def checklogin(self):
		fr = self.form_result

		# Try and copy user profile from another series
		if fr['otherseries']:
			log.info("Copy user profile from %s to %s", fr['otherseries'], self.database)
			driver = self._loadDriverFrom(fr['otherseries'], fr['firstname'], fr['lastname'], fr['email'])
			if driver is not None:
				self.session.add(driver)
				self.session.commit()
				self.user.setLoginInfo(driver)
			else:
				self.user.setPreviousError("Failed to find profile in %s" % (fr['otherseries']))
				log.error("Failed to load driver from other series (%s)", fr)

			redirect(url_for(action=''))

		# Try and login to all matching series, may or may not be this one
		othermatches = list()
		for series in self._databaseList(archived=False, driver=Driver(**fr)):
			if series.driver is not None:
				othermatches.append(series)
				if not self.user.hasCreds(series.name):
					self.user.setLoginInfo(series.driver, series.name)
				
		if not self.user.hasCreds(c.database.upper()):
			self.user.setPreviousError("login failed")
		redirect(url_for(action=''))
Example #2
0
    def rpx_token_url(self, *args, **kargs):
        'token' in request.params or redirect_to(url_for(controller="clock", action="now"))
        token = request.params['token']

        # contact rpx for the details:
        url = "https://rpxnow.com/api/v2/auth_info?token=%s&apiKey=%s" % (token, config.get('rpx_token'))
        json = json_.loads(urllib2.urlopen(url).read())

        if(json['stat'] == "ok"):
            json = json["profile"]
            session['identifier'] = json['identifier']
            session.save()

        redirect_to(url_for(controller="clock", action="now"))
Example #3
0
	def checklogin(self):
		query = self.session.query(Driver)
		query = query.filter(Driver.firstname.like(self.form_result['firstname']+'%'))
		query = query.filter(Driver.lastname.like(self.form_result['lastname']+'%'))
		for d in query.all():
			if d.email.lower().strip() == self.form_result['email'].lower().strip():
				self.user['driverid'] = d.id
				self.user['firstname'] = d.firstname
				self.user['lastname'] = d.lastname
				session.save()
				redirect(url_for(action='events'))

		self.user['previouserror'] =  """Couldn't find a match for your information, try again.<br>
				If you have never registered before, you can <a href='%s'>create a new profile</a>""" % url_for(action='new')
		session.save()
		redirect(url_for(action='login'))
Example #4
0
 def savecode(self):
     name = str(request.POST.get('name', None))
     data = str(request.POST.get('data', ''))
     if name is not None:
         Data.set(self.session, name, data)
         self.session.commit()
         redirect(url_for(action='editor', name=name))
Example #5
0
	def __before__(self):
		action = self.routingargs.get('action', '')
		if action == 'ipn': # nothing else needs to be done for IPN
			return

		c.title = 'Scorekeeper Registration'
		c.stylesheets = ['/css/register.css', '/css/redmond/jquery-ui-1.8.2.custom.css']
		c.javascript = ['/js/register.js', '/js/jquery-1.4.2.min.js', '/js/jquery-ui-1.8.2.custom.min.js', '/js/jquery.validate.min.js']
		c.tabflags = {}
		c.sponsorlink = self.settings.sponsorlink
		c.seriesname = self.settings.seriesname

		ipsession = session.setdefault(self.srcip, {})

		if self.database is not None:
			self.user = ipsession.setdefault(self.database, {})
			c.driverid = self.user.get('driverid', 0)
			c.firstname = self.user.get('firstname', '')
			c.lastname = self.user.get('lastname', '')
			c.previouserror = self.user.get('previouserror', '')
			self.user['previouserror'] = ''

			if action in ['index', 'events', 'cars', 'profile'] and c.driverid < 1:
				session.save()
				redirect(url_for(action='login'))

			if action not in ['view'] and self.settings.locked:
				# Delete any saved session data for this person
				del ipsession[self.database]
				session.save()
				raise BeforePage(render_mako('/register/locked.mako'))

			c.events = self.session.query(Event).all()
			c.cars = self.session.query(Car).filter(Car.driverid==c.driverid).order_by(Car.classcode,Car.number).all()
			session.save()
Example #6
0
	def editprofile(self):
		driver = self.session.query(Driver).filter(Driver.id==c.driverid).first()
		for k, v in self.form_result.iteritems():
			if v is not None and hasattr(driver, k):
				setattr(driver, k, v)
		self.session.commit()
		redirect(url_for(action='profile'))
Example #7
0
	def newprofile(self):
		query = self.session.query(Driver)
		query = query.filter(Driver.firstname.like(self.form_result['firstname'])) # no case compare
		query = query.filter(Driver.lastname.like(self.form_result['lastname'])) # no case compare
		query = query.filter(Driver.email.like(self.form_result['email'])) # no case compare
		for d in query.all():
			self.user.setPreviousError("Name and unique ID already exist, please login instead")
			redirect(url_for(action=''))

		driver = Driver()
		self.session.add(driver)
		self._extractDriver(driver)
		self.session.commit()

		self.user.setLoginInfo(driver)
		redirect(url_for(action=''))
Example #8
0
 def savecode(self):
     name = str(request.POST.get("name", None))
     data = str(request.POST.get("data", ""))
     if name is not None:
         Data.set(self.session, name, data)
         self.session.commit()
         redirect(url_for(action="editor", name=name))
Example #9
0
	def savecode(self):
		name = str(request.POST.get('name', None))
		data = str(request.POST.get('data', ''))
		if name is not None:
			Data.set(self.session, name, data)
			self.session.commit()
			redirect(url_for(action='editor', name=name))
Example #10
0
 def newevent(self):
     """ Process new event form submission """
     ev = Event()
     print self.form_result
     self.copyvalues(self.form_result, ev)
     self.session.add(ev)
     self.session.commit()
     redirect(url_for(eventid=ev.id, action=""))
Example #11
0
 def delreg(self):
     regid = request.POST.get("regid", None)
     if regid:
         reg = self.session.query(Registration).filter(Registration.id == regid).first()
         if reg:
             self.session.delete(reg)
             self.session.commit()
     redirect(url_for(action="list"))
Example #12
0
	def setpasswords(self):
		passwords = Password.load(self.session)
		for k, v in request.POST.iteritems():
			if v.strip() != '':
				passwords[k] = v
		Password.save(self.session, passwords)
		self.session.commit()
		redirect(url_for(action='index'))
Example #13
0
 def setpasswords(self):
     passwords = Password.load(self.session)
     for k, v in request.POST.iteritems():
         if v.strip() != '':
             passwords[k] = v
     Password.save(self.session, passwords)
     self.session.commit()
     redirect(url_for(action='index'))
Example #14
0
 def get_linker(action, modelname=modelname):
     _ = get_translator().gettext
     label = action == "edit" and _("edit") or _("delete")
     return lambda item: '<a href="%s" title="%s" class="icon %s">%s</a>' % (
         h.url_for(controller=controller, modelname=modelname, action=action, id=_pk(item)),
         label,
         action,
         label,
     )
Example #15
0
 def feed(self):
     etag_cache(get_last())
     alerts = model.Session.query(model.Alert)
     alerts = alerts.order_by(model.sa.desc(model.Alert.time)).limit(100)
     f = Atom1Feed(
         title="Alerts",
         link=url_for(),
         description="Alerts",
     )
     for a in alerts:
         f.add_item(
             title="%s - %s" % (a.addr, a.name),
             link=url_for(controller="alerts", action="notes", id=a.id),
             description="Down at %s\nUp at %s" % (a.time, a.uptime),
             pubdate=a.time,
         )
     response.content_type = 'application/atom+xml'
     return f.writeString('utf-8')
Example #16
0
 def delreg(self):
     regid = request.POST.get('regid', None)
     if regid:
         reg = self.session.query(Registration).filter(
             Registration.id == regid).first()
         if reg:
             self.session.delete(reg)
             self.session.commit()
     redirect(url_for(action='list'))
Example #17
0
 def feed(self):
     etag_cache(get_last())
     alerts = model.Session.query(model.Alert)
     alerts = alerts.order_by(model.sa.desc(model.Alert.time)).limit(100)
     f = Atom1Feed(
         title = "Alerts",
         link=url_for(),
         description="Alerts",
     )
     for a in alerts:
         f.add_item(
             title="%s - %s" %(a.addr, a.name),
             link=url_for(controller="alerts",action="notes",id=a.id),
             description="Down at %s\nUp at %s" % (a.time,a.uptime),
             pubdate = a.time,
         )
     response.content_type = 'application/atom+xml'
     return f.writeString('utf-8')
Example #18
0
	def processFieldList(self):
		data = self.form_result['fieldlist']
		if len(data) > 0:
			# delete fields, then add new submitted ones
			for fld in self.session.query(DriverField):
				self.session.delete(fld)
			for obj in data:
				self.session.add(DriverField(**obj))
		self.session.commit()
		redirect(url_for(action='fieldlist'))
Example #19
0
 def processIndexList(self):
     data = self.form_result['idxlist']
     if len(data) > 0:
         # delete indexes, then add new submitted ones
         for idx in self.session.query(Index):
             self.session.delete(idx)
         for obj in data:
             self.session.add(Index(**obj))
     self.session.commit()
     redirect(url_for(action='indexlist'))
Example #20
0
 def processClassList(self):
     data = self.form_result['clslist']
     if len(data) > 0:
         # delete classes, then add new submitted ones
         for cls in self.session.query(Class):
             self.session.delete(cls)
         for obj in data:
             self.session.add(Class(**obj))
     self.session.commit()
     redirect(url_for(action='classlist'))
Example #21
0
 def processFieldList(self):
     data = self.form_result['fieldlist']
     if len(data) > 0:
         # delete fields, then add new submitted ones
         for fld in self.session.query(DriverField):
             self.session.delete(fld)
         for obj in data:
             self.session.add(DriverField(**obj))
     self.session.commit()
     redirect(url_for(action='fieldlist'))
Example #22
0
 def processClassList(self):
     data = self.form_result["clslist"]
     if len(data) > 0:
         # delete classes, then add new submitted ones
         for cls in self.session.query(Class):
             self.session.delete(cls)
         for obj in data:
             self.session.add(Class(**obj))
     self.session.commit()
     redirect(url_for(action="classlist"))
Example #23
0
 def processIndexList(self):
     data = self.form_result["idxlist"]
     if len(data) > 0:
         # delete indexes, then add new submitted ones
         for idx in self.session.query(Index):
             self.session.delete(idx)
         for obj in data:
             self.session.add(Index(**obj))
     self.session.commit()
     redirect(url_for(action="indexlist"))
Example #24
0
	def newprofile(self):
		query = self.session.query(Driver)
		query = query.filter(Driver.firstname.like(self.form_result['firstname'])) # no case compare
		query = query.filter(Driver.lastname.like(self.form_result['lastname'])) # no case compare
		query = query.filter(Driver.email.like(self.form_result['email'])) # no case compare
		for d in query.all():
			self.user['previouserror'] =  "Name and unique ID already exist, please login instead"
			redirect(url_for(action='login'))

		driver = Driver()
		self.session.add(driver)
		self.copyvalues(self.form_result, driver)
		self.session.commit()

		self.user['driverid'] = driver.id
		self.user['firstname'] = driver.firstname
		self.user['lastname'] = driver.lastname
		session.save()
		redirect(url_for(action='events'))
Example #25
0
	def deleteevent(self):
		""" Request to delete an event, verify if we can first, then do it """
		if self.session.query(Run).filter(Run.eventid==self.eventid).count() > 0:
			c.text = "<h3>%s has runs assigned to it, you cannot delete it</h3>" % (c.event.name)
			raise BeforePage(render_mako('/admin/simple.mako'))

		# no runs, kill it
		self.session.query(Registration).filter(Registration.eventid==self.eventid).delete()
		self.session.query(Event).filter(Event.id==self.eventid).delete()
		self.session.commit()
		redirect(url_for(eventid='s', action=''))
Example #26
0
    def updatesettings(self):
        """ Process settings form submission """
        self.settings.set(self.form_result)
        self.settings.save(self.session)

        for key, file in self.form_result.iteritems():
            if hasattr(file, "filename"):
                # TODO: Check file size before doing this
                Data.set(self.session, key, file.value, file.type)

        self.session.commit()
        redirect(url_for(action="seriessettings"))
Example #27
0
	def __before__(self):
		c.title = 'Scorekeeper Results'
		c.seriesname = self.settings.seriesname
		c.stylesheets = []
		c.javascript = []
		if self.database is not None:
			c.stylesheets.append(url_for(controller='db', name='results.css', eventid=None))
			self.eventid = self.routingargs.get('eventid', None)
			if self.eventid:
				c.classdata = ClassData(self.session)
				c.event = self.session.query(Event).get(self.eventid)
				c.active = Class.activeClasses(self.session, self.eventid)
Example #28
0
    def login(self):
        password = request.POST.get("password")
        ipsession = session.setdefault(self.srcip, {})
        tokens = ipsession.setdefault("authtokens", set())

        if password == self.settings.password:
            tokens.add("series")

        for event in c.events:
            if password == event.password:
                tokens.add(event.id)

        session.save()
        redirect(url_for(action=""))
Example #29
0
    def deleteevent(self):
        """ Request to delete an event, verify if we can first, then do it """
        if self.session.query(Run).filter(
                Run.eventid == self.eventid).count() > 0:
            c.text = "<h3>%s has runs assigned to it, you cannot delete it</h3>" % (
                c.event.name)
            raise BeforePage(render_mako('/admin/simple.mako'))

        # no runs, kill it
        self.session.query(Registration).filter(
            Registration.eventid == self.eventid).delete()
        self.session.query(Event).filter(Event.id == self.eventid).delete()
        self.session.commit()
        redirect(url_for(eventid='s', action=''))
Example #30
0
	def view(self):
		try:
			id = int(self.routingargs.get('other', 0))
		except:
			abort(404, "No event for input provided")
		if id == 0:
			redirect(url_for(action=''))
			
		c.classdata = ClassData(self.session)
		c.event = self.session.query(Event).get(id)
		query = self.session.query(Driver,Car,Registration).join('cars', 'registration').filter(Registration.eventid==id)
		query = query.order_by(Car.classcode, Car.number)
		c.reglist = query.all()
		return render_mako('/register/reglist.mako')
Example #31
0
	def editcar(self):
		p = request.POST
		car = self.session.query(Car).get(p['carid'])
		if car is None:
			car = Car()
			self.session.add(car)
			car.driverid = c.driverid
		if p.get('ctype', '') == 'delete':
			self.session.delete(car)
		else:
			for attr in ('year', 'make', 'model', 'color', 'number', 'classcode', 'indexcode'):
				if attr in p:
					setattr(car, attr, p[attr])
		self.session.commit()
		redirect(url_for(action='cars'))
Example #32
0
    def __before__(self):
        c.title = 'Scorekeeper Results'
        c.seriesname = self.settings.seriesname
        c.stylesheets = []
        c.javascript = []

        if self.database is not None:
            c.stylesheets.append(
                url_for(controller='db', name='results.css', eventid=None))
            self.eventid = self.routingargs.get('eventid', None)
            if self.eventid:
                c.classdata = ClassData(self.session)
                c.event = self.session.query(Event).get(self.eventid)
                c.active = Class.activeClasses(self.session, self.eventid)
                if c.event is None:
                    abort(404, "Invalid event id")
Example #33
0
	def updatesettings(self):
		""" Process settings form submission """
		self.settings.set(self.form_result)
		self.settings.save(self.session)

		for key, fileobj in self.form_result.iteritems():
			if hasattr(fileobj, 'filename') and fileobj.type.startswith("image/"):
				Data.set(self.session, key, fileobj.value, fileobj.type)

			if key.startswith('blank'):
				try:
					from PIL import Image
				except:
					import Image
				output = cStringIO.StringIO()
				Image.new('RGB', (4,4), (255,255,255)).save(output, "PNG")
				Data.set(self.session, key[5:], output.getvalue(), 'image/png')
				output.close()

		self.session.commit()
		redirect(url_for(action='seriessettings'))
Example #34
0
	def register(self):
		carid = int(request.POST.get('carid', 0))
		regid = int(request.POST.get('regid', 0))
		eventid = int(request.POST.get('eventid', 0))
		reg = self.session.query(Registration).filter(Registration.id==regid).first()

		if carid < 0: # delete car
			self.session.delete(reg)
		elif regid > 0: # modify car
			reg.carid = carid
		else: # add car
			event = self.session.query(Event).filter(Event.id==eventid).first()
			if event.totlimit and event.count >= event.totlimit:
				self.user['previouserror'] = "Sorry, prereg reached its limit of %d since your last page load" % (event.totlimit)
				session.save()
			else:
				reg = Registration(eventid, carid)
				self.session.add(reg)

		self.session.commit()
		redirect(url_for(action='events'))
Example #35
0
    def updatesettings(self):
        """ Process settings form submission """
        self.settings.set(self.form_result)
        self.settings.save(self.session)

        for key, fileobj in self.form_result.iteritems():
            if hasattr(fileobj,
                       'filename') and fileobj.type.startswith("image/"):
                Data.set(self.session, key, fileobj.value, fileobj.type)

            if key.startswith('blank'):
                try:
                    from PIL import Image
                except:
                    import Image
                output = cStringIO.StringIO()
                Image.new('RGB', (4, 4), (255, 255, 255)).save(output, "PNG")
                Data.set(self.session, key[5:], output.getvalue(), 'image/png')
                output.close()

        self.session.commit()
        redirect(url_for(action='seriessettings'))
Example #36
0
def secure_url_for(**kw):
    kw[secure_form_tag.token_key] = secure_form_tag.authentication_token()
    return url_for(**kw)
Example #37
0
 def forceunlock(self):
     self.settings.locked = False
     self.settings.save(self.session)
     self.session.commit()
     redirect(url_for(action=request.GET.get('next', '')))
Example #38
0
 def forceunlock(self):
     self.settings.locked = False
     self.settings.save(self.session)
     self.session.commit()
     redirect(url_for(action=request.GET.get("next", "")))
Example #39
0
    def processCopySeries(self):
        try:
            import sqlite3
        except:
            from pysqlite2 import dbapi2 as sqlite3

        """ Process settings form submission """
        log.debug("copyseriesform: %s", self.form_result)
        name = self.form_result["name"]
        import nwrsc

        root = nwrsc.__path__[0]

        if not os.path.exists(self.databasePath(name)):
            metadata.bind = create_engine("sqlite:///%s" % self.databasePath(name), poolclass=NullPool)
            metadata.create_all()

            conn = sqlite3.connect(":memory:")
            conn.row_factory = sqlite3.Row
            cur = conn.cursor()
            cur.execute("attach '%s' as old" % self.databasePath(self.database))
            cur.execute("attach '%s' as new" % self.databasePath(name))

            # Settings
            if self.form_result["settings"]:
                cur.execute("insert into new.settings select * from old.settings")
            else:
                for k, v in {"useevents": 5, "ppoints": "20,16,13,11,9,7,6,5,4,3,2,1"}.iteritems():
                    cur.execute("insert into new.settings values (?,?)", (k, v))
            cur.execute("insert or replace into new.settings values (?,?)", ("password", self.form_result["password"]))

            # Template data
            if self.form_result["data"]:
                cur.execute("insert into new.data select * from old.data")
            else:
                insertfile(cur, "results.css", "text/css", os.path.join(root, "examples/wwresults.css"))
                insertfile(cur, "event.mako", "text/plain", os.path.join(root, "examples/wwevent.mako"))
                insertfile(cur, "champ.mako", "text/plain", os.path.join(root, "examples/wwchamp.mako"))
                insertfile(cur, "toptimes.mako", "text/plain", os.path.join(root, "examples/toptimes.mako"))
                insertfile(cur, "classresult.mako", "text/plain", os.path.join(root, "examples/classresults.mako"))
                insertfile(cur, "card.py", "text/plain", os.path.join(root, "examples/basiccard.py"))

            if self.form_result["classes"]:
                cur.execute("insert into new.classlist select * from old.classlist")
                cur.execute("insert into new.indexlist select * from old.indexlist")

            if self.form_result["drivers"]:
                cur.execute("insert into new.drivers select * from old.drivers")

            if self.form_result["cars"]:
                cur.execute("insert into new.cars select * from old.cars")

            if self.form_result["prevlist"]:
                cur.execute(
                    """insert into new.prevlist (firstname, lastname) 
							select distinct lower(d.firstname) as firstname, lower(d.lastname) as lastname
							from old.runs as r, old.cars as c, old.drivers as d
							where r.carid=c.id and c.driverid=d.id """
                )
                c.feelists = FeeList.getAll(self.session)

            cur.close()
            conn.commit()

        else:
            log.error("database exists")

        redirect(url_for(action="copyseries"))
Example #40
0
 def updateevent(self):
     """ Process edit event form submission """
     c.event.merge(**self.form_result)
     self.session.commit()
     redirect(url_for(action='editevent'))
Example #41
0
 def newevent(self):
     """ Process new event form submission """
     ev = Event(**self.form_result)
     self.session.add(ev)
     self.session.commit()
     redirect(url_for(eventid=ev.id, action=''))
Example #42
0
    def user(self, subaction="index", id=-1):
        id = int(id)
        user_manager = UserManager(self.__manager)
        template = "/default/derived/account.mako"
        is_new = False

        c.user_list = self.__manager.user_list
        c.list_users = True
        c.list_groups = False

        if len(c.filter_name) > 0:
            c.user_list = self.__filter_users(c.user_list, c.filter_name)

        if c.filter_status != -1:
            if c.filter_status == 1:
                c.user_list = self.__manager.filter_enabled_disabled(True)
            elif c.filter_status == 0:
                c.user_list = self.__manager.filter_enabled_disabled(False)

        if id == -1:
            is_new = True

        ##
        ## Edit a User
        ##
        if subaction == "edit" or subaction == "add":
            c.p = ParamConfiguration('user-account-parameters')
            c.user = user_manager.edit(id, is_new)

            if c.user is not None:
                template = "/default/derived/edit-user-account.mako"
            else:
                type = "critical"
                cause = _("Unkown Reason")

                if group_manager.has_message():
                    cause = group_manager.get_message()

                message = _("Unable to get User to edit - %s" % (cause))
                SwatMessages.add(message, type)
        ##
        ## Save the changes made to a User
        ##
        elif subaction == "save" or subaction == "apply":
            (new_id, saved) = user_manager.save(id, is_new)

            if saved:
                type = "cool"
                message = _("Sucessfuly saved the User with the ID %s" %
                            (new_id))
            else:
                type = "critical"
                cause = _("Unkown Reason")

                if user_manager.has_message():
                    cause = user_manager.get_message()

                message = _("Error saving the User with the ID %s: %s" %
                            (new_id, cause))

            SwatMessages.add(message, type)

            if subaction == "save_add":
                redirect_to(
                    url_for("with_subaction",
                            controller='account',
                            action="user",
                            subaction="add"))
            elif subaction == "save":
                redirect_to(controller='account', action='user')
            elif subaction == "apply":
                redirect_to("account_action",
                            action='user',
                            subaction='edit',
                            id=new_id)

        ##
        ## Remove a Certain User or a List of Users
        ##
        elif subaction == "remove":
            list_uid = variabledecode.variable_decode(request.params).get(
                "uid", id)
            ok_list = []

            if not isinstance(list_uid, list):
                list_uid = [list_uid]

            for uid in list_uid:
                uid = int(uid)
                removed = user_manager.remove(uid)

                if removed:
                    ok_list.append(uid)
                    log.info("Deleted " + str(uid) + " :: success: " +
                             str(removed))
                else:
                    SwatMessages.add(user_manager.get_message(), "critical")

            if len(ok_list) > 0:
                joined = ", ".join(["%d" % v for v in ok_list])

                if len(ok_list) == 1:
                    message = _("The User with the ID %s was deleted sucessfuly" \
                                % (joined))
                else:
                    message = _("The Users IDs [%s] were deleted sucessfuly" \
                                % (joined))

                SwatMessages.add(message)

            redirect_to(controller='account', action='user')

        ##
        ## Disable a User or a List of Users
        ##
        elif subaction == "toggle":
            list_uid = variabledecode.variable_decode(request.params).get(
                "uid", id)
            enabled_list = []
            disabled_list = []

            if not isinstance(list_uid, list):
                list_uid = [list_uid]

            for uid in list_uid:
                uid = int(uid)
                (toggled, new_status) = user_manager.toggle(uid)

                if toggled:
                    if new_status == True:
                        disabled_list.append(uid)
                    else:
                        enabled_list.append(uid)
                else:
                    SwatMessages.add(
                        _("Error toggling User ID %d: %s" %
                          (uid, user_manager.get_message())), "critical")

            if len(enabled_list) > 0:
                joined = ", ".join(["%d" % v for v in enabled_list])
                message = _(
                    "The following User IDs [%s] were ENABLED successfuly" %
                    (joined))
                SwatMessages.add(message)

            if len(disabled_list) > 0:
                joined = ", ".join(["%d" % v for v in disabled_list])
                message = _(
                    "The following User IDs [%s] were DISABLED successfuly" %
                    (joined))
                SwatMessages.add(message)

            redirect_to(controller='account', action='user')

        return render(template)
Example #43
0
 def updateevent(self):
     """ Process edit event form submission """
     self.copyvalues(self.form_result, c.event)
     self.session.commit()
     redirect(url_for(action="editevent"))
Example #44
0
class AdminController(BaseController, EntrantEditor, ObjectEditor,
                      CardPrinting, PurgeCopy):
    def __before__(self):
        c.stylesheets = ['/css/admin.css']
        c.javascript = ['/js/admin.js']

        if self.database is not None:
            c.events = self.session.query(Event).all()
            c.seriesname = self.database
        self.eventid = self.routingargs.get('eventid', None)
        self.action = self.routingargs.get('action', '')

        c.isLocked = self.settings.locked
        c.settings = self.settings
        c.event = None
        if self.eventid and self.eventid.isdigit():
            c.event = self.session.query(Event).get(self.eventid)

        if c.event is None and self.eventid not in (None, 's'):
            c.text = "<h3>No such event for %s</h3>" % self.eventid
            raise BeforePage(render_mako('/admin/simple.mako'))

        if self.database is None or (self.action == 'index'
                                     and c.event is None):
            return

        self._checkauth(c.event)

        if self.settings.locked:
            if self.action not in ('index', 'printcards', 'paid', 'numbers',
                                   'paypal', 'newentrants', 'printhelp',
                                   'forceunlock'):
                c.seriesname = self.settings.seriesname
                c.next = self.action
                raise BeforePage(render_mako('/admin/locked.mako'))

    def _checkauth(self, event):
        if self.srcip == '127.0.0.1':
            c.isAdmin = True
            return

        try:
            digestinfo = session.setdefault(('digest', self.srcip), {})
            pwdict = Password.load(self.session)
            passwords = {"admin": pwdict["series"]}
            if event is not None and str(event.id) in pwdict:
                passwords["event"] = pwdict[str(event.id)]

            authname = authCheck(digestinfo, self.database, passwords, request)
            if authname == "admin":
                c.isAdmin = True
        finally:
            session.save()

    def passwords(self):
        c.action = 'setpasswords'
        return render_mako("/admin/passwords.mako")

    def setpasswords(self):
        passwords = Password.load(self.session)
        for k, v in request.POST.iteritems():
            if v.strip() != '':
                passwords[k] = v
        Password.save(self.session, passwords)
        self.session.commit()
        redirect(url_for(action='index'))

    def forceunlock(self):
        self.settings.locked = False
        self.settings.save(self.session)
        self.session.commit()
        redirect(url_for(action=request.GET.get('next', '')))

    def index(self):
        if self.eventid and self.eventid.isdigit():
            return render_mako('/admin/event.mako')
        elif self.database is not None:
            c.text = "<h2>%s Adminstration</h2>" % self.routingargs['database']
            return render_mako('/admin/simple.mako')
        else:
            return self.databaseSelector(archived=True)

    def contactlist(self):
        c.classlist = self.session.query(Class).order_by(Class.code).all()
        c.indexlist = [""] + [
            x[0] for x in self.session.query(Index.code).order_by(Index.code)
        ]
        c.preselect = request.GET.get('preselect', "").split(',')

        c.drivers = dict()
        for (dr, car, reg) in self.session.query(Driver, Car,
                                                 Registration).join(
                                                     'cars', 'registration'):
            if self.eventid.isdigit() and reg.eventid != int(self.eventid):
                continue

            if dr.id not in c.drivers:
                dr.events = set([reg.eventid])
                dr.classes = set([car.classcode])
                c.drivers[dr.id] = dr
            else:
                dr = c.drivers[dr.id]
                dr.events.add(reg.eventid)
                dr.classes.add(car.classcode)

        if self.eventid.isdigit():
            c.title = c.event.name
            c.showevents = False
        else:
            c.title = "Series"
            c.showevents = True

        return render_mako('/admin/contactlist.mako')

    def downloadcontacts(self):
        """ Process settings form submission """
        idlist = request.POST['ids'].split(',')
        drivers = self.session.query(Driver).filter(
            Driver.id.in_(idlist)).all()
        cols = [
            'id', 'firstname', 'lastname', 'email', 'address', 'city', 'state',
            'zip', 'phone', 'membership', 'brag', 'sponsor'
        ]
        return self.csv("ContactList", cols, drivers)

    def weekend(self):
        """ Create a weekend report reporting unique entrants and their information """
        bins = defaultdict(list)
        events = self.session.query(Event).order_by(Event.date).all()
        for e in events:
            wed = e.date + timedelta(
                -(e.date.weekday() + 5) %
                7)  # convert M-F(0-7) to Wed-Tues(0-7), formerly (2-6,0-1)
            bins[wed].append(e)

        c.weeks = dict()
        for wed in sorted(bins):
            eventids = [e.id for e in bins[wed]]
            report = WeekendReport()
            c.weeks[wed] = report

            report.events = bins[wed]
            report.drivers = self.session.query(Driver).join(
                'cars',
                'runs').filter(Run.eventid.in_(eventids)).distinct().all()
            report.membership = list()
            report.invalid = list()
            for d in report.drivers:
                if d.membership is None:
                    d.membership = ""
                try:
                    report.membership.append(
                        _validateNumber(d.membership) or "")
                except IndexError:
                    report.invalid.append(d.membership or " ")

            report.membership.sort(
            )  # TODO: should we take into account first letters and go totally numeric?
            report.invalid.sort()

        return render_mako('/admin/weekend.mako')

    ### Settings table editor ###
    def seriessettings(self):
        c.settings = self.settings
        c.parentlist = self.lineage(self.settings.parentseries)
        c.action = 'updatesettings'
        c.button = 'Update'
        return render_mako('/admin/seriessettings.mako')

    @validate(schema=SettingsSchema(),
              form='seriessettings',
              prefix_error=False)
    def updatesettings(self):
        """ Process settings form submission """
        self.settings.set(self.form_result)
        self.settings.save(self.session)

        for key, fileobj in self.form_result.iteritems():
            if hasattr(fileobj,
                       'filename') and fileobj.type.startswith("image/"):
                Data.set(self.session, key, fileobj.value, fileobj.type)

            if key.startswith('blank'):
                try:
                    from PIL import Image
                except:
                    import Image
                output = cStringIO.StringIO()
                Image.new('RGB', (4, 4), (255, 255, 255)).save(output, "PNG")
                Data.set(self.session, key[5:], output.getvalue(), 'image/png')
                output.close()

        self.session.commit()
        redirect(url_for(action='seriessettings'))

    ### Data editor ###
    def editor(self):
        if 'name' not in request.GET:
            return "Missing name"
        c.name = request.GET['name']
        c.data = ""
        data = self.session.query(Data).get(c.name)
        if data is not None:
            c.data = data.data
        return render_mako('/admin/editor.mako')

    def savecode(self):
        name = str(request.POST.get('name', None))
        data = str(request.POST.get('data', ''))
        if name is not None:
            Data.set(self.session, name, data)
            self.session.commit()
            redirect(url_for(action='editor', name=name))

    def cleanup(self):
        Registration.updateFromRuns(self.session)
        c.text = "<h3>Cleaned</h3>"
        return render_mako('/admin/simple.mako')

    def recalc(self):
        return render_mako('/admin/recalc.mako')

    def dorecalc(self):
        from nwrsc.lib.resultscalc import RecalculateResults
        response.content_type = 'text/plain'
        return RecalculateResults(self.session, self.settings)

    def printhelp(self):
        return render_mako('/admin/printhelp.mako')

    def restricthelp(self):
        return render_mako('/admin/restricthelp.mako')

    def numbers(self):
        # As with other places, one big query followed by mangling in python is faster (and clearer)
        c.numbers = {}
        for res in self.session.query(Driver.firstname, Driver.lastname,
                                      Car.classcode, Car.number).join('cars'):
            if self.settings.superuniquenumbers:
                code = "All"
            else:
                code = res[2]
            num = res[3]
            name = res[0] + " " + res[1]
            if code not in c.numbers:
                c.numbers[code] = {}
            c.numbers[code].setdefault(num, set()).add(name)

        return render_mako('/admin/numberlist.mako')

    def paid(self):
        """ Return the list of fees paid before this event """
        c.header = '<h2>Fees Collected Before %s</h2>' % c.event.name
        c.beforelist = FeeList.get(self.session, self.eventid)[-1].before
        return render_mako('/admin/feelist.mako')

    def newentrants(self):
        """ Return the list of new entrants/fees collected by event or for the series """
        if self.eventid == 's':
            c.feelists = FeeList.getAll(self.session)
            return render_mako('/admin/newentrants.mako')
        else:
            c.feelists = FeeList.get(self.session, self.eventid)
            return render_mako('/admin/newentrants.mako')

    def paypal(self):
        """ Return a list of paypal transactions for the current event """
        c.payments = self.session.query(Payment).filter(
            Payment.eventid == self.eventid).all()
        c.payments.sort(key=lambda obj: obj.driver.lastname)
        return render_mako('/admin/paypal.mako')

    ### RunGroup Editor ###
    def rungroups(self):
        c.action = 'setRunGroups'
        c.groups = {0: []}
        allcodes = set([res[0] for res in self.session.query(Class.code)])
        for group in self.session.query(RunGroup).order_by(
                RunGroup.rungroup, RunGroup.gorder).filter(
                    RunGroup.eventid == self.eventid).all():
            c.groups.setdefault(group.rungroup, list()).append(group.classcode)
            allcodes.discard(group.classcode)
        for code in sorted(allcodes):
            c.groups[0].append(code)
        return render_mako('/admin/editrungroups.mako')

    def setRunGroups(self):
        try:
            for group in self.session.query(RunGroup).filter(
                    RunGroup.eventid == self.eventid):
                self.session.delete(group)
            self.session.flush()
            for k in request.POST:
                if k[:5] == 'group':
                    if int(k[5]) == 0:  # not recorded means group 0
                        continue
                    for ii, code in enumerate(request.POST[k].split(',')):
                        g = RunGroup()
                        g.eventid = self.eventid
                        g.rungroup = int(k[5])
                        g.classcode = str(code)
                        g.gorder = ii
                        self.session.add(g)
            self.session.commit()
        except Exception, e:
            log.error("setRunGroups failed: %s" % e)
            self.session.rollback()
        redirect(url_for(action='rungroups'))
Example #45
0
	def login(self):
		redirect(url_for(action=''))
Example #46
0
	def logout(self):
		# Clear session for database
		self.user.clear()
		redirect(url_for(action=''))
Example #47
0
 def logout(self):
     session['identifier'] = None
     del session['identifier']
     session.save()
     redirect_to(url_for(controller = "clock", action = "now"))
Example #48
0
    def group(self, subaction="index", id=-1):
        id = int(id)
        group_manager = GroupManager(self.__manager)
        template = '/default/derived/account.mako'
        is_new = False

        c.group_list = self.__manager.group_list
        c.list_users = False
        c.list_groups = True

        if len(c.filter_name) > 0:
            c.group_list = self.__filter_groups(c.group_list, c.filter_name)

        if id == -1:
            is_new = True

        ##
        ## Edit a Group
        ##
        if subaction == "edit" or subaction == "add":
            c.p = ParamConfiguration('group-parameters')
            c.group = group_manager.edit(id, is_new)

            if c.group is not None:
                c.user_group_list = self.__manager.get_users_in_group(id)
                template = "/default/derived/edit-group.mako"
            else:
                type = "critical"
                cause = _("Unkown Reason")

                if group_manager.has_message():
                    cause = group_manager.get_message()

                message = _("Unable to get Group to edit - %s" % (cause))
                SwatMessages.add(message, type)

        ##
        ## Save the changes made to a Group
        ##
        elif subaction == "save" or subaction == "apply" or subaction == "save_add":
            (new_id, saved) = group_manager.save(id, is_new)

            if saved:
                type = "cool"
                message = _("Sucessfuly saved the Group with the ID %s" % (id))
            else:
                type = "critical"
                cause = _("Unkown Reason")

                if group_manager.has_message():
                    cause = group_manager.get_message()

                message = _("Error saving the Group with the ID %s: %s" %
                            (id, cause))

            SwatMessages.add(message, type)

            if subaction == "save_add":
                redirect_to(
                    url_for("with_subaction",
                            controller='account',
                            action="group",
                            subaction="add"))
            elif subaction == "save":
                redirect_to(controller='account', action='group')
            elif subaction == "apply":
                redirect_to("account_action",
                            action='group',
                            subaction='edit',
                            id=new_id)

        ##
        ## Remove a Certain Group
        ##
        elif subaction == "remove":
            removed = group_manager.remove(id)

            if removed:
                type = "cool"
                message = _("Sucessfuly deleted the Group with the ID %s" %
                            (id))
            else:
                type = "critical"
                cause = _("Unkown Reason")

                if group_manager.has_message():
                    cause = group_manager.get_message()

                message = _("Error deleting the Group with the ID %s - %s" %
                            (id, cause))

            SwatMessages.add(message, type)
            redirect_to(controller='account', action='user')

        return render(template)
Example #49
0
    def create(self):
        email = ''
        pwd = ''

        if (('email' in request.params) and ('pwd' in request.params)):
            email = request.params['email']
            pwd = request.params['pwd']

        if email and pwd:

            user_email = email
            user_pwd = pwd
            user_license = ''
            user_nonce = ''

            tmp_usr = User.get_by(email=user_email)

            if (tmp_usr):
                user_license = tmp_usr.license
                user_nonce = tmp_usr.nonce
                user_pwd = tmp_usr.pwd

            if (user_license == 'none'):
                response.status = 403
                return 'user_registration_locked'

            elif ((user_license == '') or (user_license == 'confirm')):

                enable_register = c.mc.freemium_autoregister
                if not enable_register:
                    response.status = 403
                    return 'registration_disabled'

                if (user_nonce == '' or (pwd != user_pwd)):
                    user_nonce = self.generateNonce()
                    user_pwd = pwd

                user_license = 'confirm'

                # Send confirmation email
                confirm_link = url_for('confirm',
                                       email=user_email,
                                       nonce=user_nonce,
                                       qualified=True)
                log.debug("confirm link:  " + confirm_link)

                conf = get_kcd_external_conf_object(master_config=c.mc)

                if not conf:
                    response.status = 405
                    return 'The free registration is not available. Please conact your system adminstrator.'

                try:
                    kc = FreemiumKcdClient(conf)
                    kc.send_freemium_confirmation_email(
                        conf.kcd_passwd, user_email, confirm_link)
                except Exception, err:
                    log.error(str(err))
                    response.status = 500
                    return 'Teambox Main Application Server error'

                # Update user in freemium and kps DB
                try:
                    rpc_server, rpc_sid, str_org_id = self.connectToRPC()
                    rpc_server.set_freemium_user(rpc_sid, str_org_id,
                                                 user_email, user_pwd,
                                                 user_license, user_nonce, '',
                                                 False)
                except Exception, err:
                    log.error(str(err))
                    response.status = 500
                    return 'Teambox Sign-on Server error'

                return 'confirm'