Exemplo n.º 1
0
def add(request, pid="0"):
    """Course add page view"""
    if not request.user.is_authenticated():
        return HttpResponseRedirect('/users/auth_login')

    if request.method == 'POST':  # if the form has been submitted...
        form = EditPeriodForm(request.POST)   # A form bound to the POST data
        if form.is_valid() and form.check_conflict(pid):  # Check validation
            new_period = Period(
                code=form.cleaned_data['code'],
                name=form.cleaned_data['name'],
                lecturer=form.cleaned_data['lecturer'],
                position=(int(form.cleaned_data['day'])-1)*10+int(form.cleaned_data['start']),
                length=form.cleaned_data['length'],
                timetable_id=pid)
            new_period.save()
            return HttpResponseRedirect('/')           # Redirect after POST
        else:
            return HttpResponseRedirect('/users/gateway/do=6')
    else:
        form = EditPeriodForm()

    return render(
        request,
        'periods/edit/index.html', {
            'form': form
        }
    )
Exemplo n.º 2
0
def my_home():
    categorys_list=[]
    categorys=Category.get_categorys()
    for category in categorys:
        periods=Period.get_index_periods(cid=category.id)
        categorys_list.append((category.name,periods))
    hot_products = Period.get_hot_products()
    return render_template('index.html', categorys_list=categorys_list, hot_products=hot_products)
Exemplo n.º 3
0
    def get(self):

        # Check if datasets are loaded in datastore

        # Items in datastore
        d = Dataset.query().count()
        # Items in CDB
        q = "select count(*) as c from resource_staging" + \
            " where ipt is true and networks like '%VertNet%';"
        c = cartodb_query(q)[0]['c']

        # Number of reports stored in the datastore
        num_reports = Report.query().count()

        periods = Period.query()
        num_periods = periods.count()

        periods_done = Period.query(Period.status == "done")
        num_periods_done = periods_done.count()

        periods_progress = Period.query(Period.status == "in progress")
        num_periods_progress = periods_progress.count()

        periods_failed = Period.query(Period.status == "failed")
        num_periods_failed = periods_failed.count()

        resp = {
            "Datastore integrity": [
                {"Datasets in CartoDB": c},
                {"Datasets in the Datastore": d}
            ],
            "Report periods": [
                {"Stored periods": num_periods},
                {"Stored reports": num_reports},
                {"Periods completed": num_periods_done},
                {"Periods in progress": num_periods_progress},
                {"Periods failed": num_periods_failed},
            ]
        }

        if c != d or c == 0:
            dataset_setup_url = "http://%s/setup_datasets" % _HOSTNAME
            resp["Datastore integrity"].append({"URL for dataset setup": dataset_setup_url})
        if num_periods > 0:
            links_to_periods = ["http://%s/status/period/%s" % (_HOSTNAME, x.key.id()) for x in periods.fetch()]
            resp["Report periods"].append({"Links to periods": links_to_periods})
        if num_periods_done > 0:
            resp['Report periods'].append({'List of periods done': [x.period.strftime("%Y-%m") for x in periods_done.fetch()]})
        if num_periods_progress > 0:
            resp['Report periods'].append({'List of periods in progress': [x.period.strftime("%Y-%m") for x in periods_progress.fetch()]})
        if num_periods_failed > 0:
            resp['Report periods'].append({'List of periods failed': [x.period.strftime("%Y-%m") for x in periods_failed.fetch()]})

        self.response.headers['content-type'] = "application/json"
        self.response.write(json.dumps(resp))
def schedule(request):
    schedule = []
    today = date.today()
    while today.weekday() >= 5 or ScheduleDay.objects.filter(
            date=today).count() > 0 and ScheduleDay.objects.get(
                date=today).day_off:
        today += timedelta(1)
    schedule_day = None
    if ScheduleDay.objects.filter(date=today).count() > 0:
        schedule_day = ScheduleDay.objects.get(date=today)
    else:
        done = False
        one_day = timedelta(1)
        today_dt = datetime.combine(today, time())
        today_dt -= one_day
        new_date = today_dt.date()
        days_ellapsed = 0
        day = 0
        while not done:
            if new_date.weekday() < 5 and ScheduleDay.objects.filter(
                    date=new_date).count() == 0:
                days_ellapsed += 1
            elif new_date.weekday() < 5 and not ScheduleDay.objects.get(
                    date=new_date).day_off:
                done = True
                day = (ScheduleDay.objects.get(date=new_date).day +
                       days_ellapsed) % 7
            new_dt = datetime.combine(new_date, time())
            new_dt -= one_day
            new_date = new_dt.date()
        schedule_day = ScheduleDay(date=today,
                                   day_off=False,
                                   day=day,
                                   schedule="")
        schedule_day.save()
    print(schedule_day.day)
    if schedule_day.schedule == "":
        schedule_day.schedule = master_schedule[schedule_day.day]
        s

    if len(schedule_day.period_set.all()) == 0:
        for i in range(len(schedule_day.schedule)):
            period = Period(day=schedule_day,
                            period_number=i,
                            period_letter=schedule_day.schedule[i:i + 1])
            period.save()

    schedule.append([])
    for period in schedule_day.schedule:
        schedule.append([[period]])

    return render(request, "scanner/schedule.html",
                  {'schedule_table': schedule})
Exemplo n.º 5
0
def create_tables():
    auth.User.create_table(fail_silently=True)
    Users.create_table(fail_silently=True)
    Role.create_table(fail_silently=True)
    Category.create_table(fail_silently=True)
    Product.create_table(fail_silently=True)
    Period.create_table(fail_silently=True)
    Order_detail.create_table(fail_silently=True)
    Address.create_table(fail_silently=True)
    Show.create_table(fail_silently=True)
    UserRoles.create_table(fail_silently=True)
    Configure.create_table(fail_silently=True)
    WinRecord.create_table(fail_silently=True)
Exemplo n.º 6
0
def fill_dummy_data():
    p = Period(name="H1")
    p.save()

    i = Instrument(name="GBPUSD", description="The cable!", is_forex = True)
    i.save()

    price = 1.4567
    initial_date = datetime.datetime(2014,05,01,hour=12,minute=00,second=00, tzinfo=utc)
    for x in range(1000):
        tstamp = initial_date + (x * timedelta(hours=1))
        price += random.randint(1,3) * random.randint(-1,1) * random.randint(0, 10) / 1e4
        ibar = IBar(start_time = tstamp, open=price, high=price, low=price, close=price, period=p, instrument=i)
        ibar.save()
Exemplo n.º 7
0
def create_period(pro_id, tcount, number=None):
    if number:
        Period.create(
            product=pro_id,
            number=number,
            total_count=tcount,
            all_num=create_all_num(tcount),
        )
    else:
        Period.create(
            product=pro_id,
            total_count=tcount,
            all_num=create_all_num(tcount),
        )
Exemplo n.º 8
0
def pay_handler():
    if request.method =='POST':
        data = request_form_to_dict()
        pid = int(data.get("pid"))
        count = int(data.get("amount"))
        period=Period.get(id=pid)
        time_now=datetime.now()
        left=period.total_count-period.join_count
        if left >= count:
            num = get_num(pid, count)
            # 创建或更新夺宝订单明细记录
            create_or_update_order_detail(current_user.id, pid, {
                "count": count,
                "created_datetime": time_now,
                "num": num
            })
            # 更新用户余额
            update_user(current_user.id, current_user.balance - count)
            if left == count:
                kj_time = get_kj_time(time_now)
                update_period(pid, {
                     "join_count": period.join_count + count,
                     "status": 1,
                     "end_time": time_now,
                     "kj_count": create_kj_count(time_now),
                     "kj_time": kj_time,
                })
                create_period(period.product.id, period.total_count,  period.number+ 1)
            else:
                update_period(pid,{
                    "join_count": period.join_count + count,
                    })
            return redirect(url_for('period_detail',pid=pid))
Exemplo n.º 9
0
def enroll(request, pid='0'):
    """Course enroll page view"""
    if not request.user.is_authenticated():
        return HttpResponseRedirect('/users/auth_login')
    if request.method == 'GET':
        tb_array = Timetable.objects.filter(owner=request.user.id)
        if tb_array.exists():
            tid = tb_array[0].owner
        else:
            tid = 0
        periods = Period.objects.get(id=pid)
        periods_array = Period.objects.filter(timetable_id=tid)
        pos = periods.position
        leg = periods.length
        free = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
                17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
                31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
                45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
                59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73]
        for f in free:
            f = True
        for p in periods_array:
            free[p.position] = False
            j = p.position
            while j <= p.position + p.length-1:
                if (j > 0) and (j < 71):
                    free[j] = False
                j += 1
        j = pos
        while j <= pos+leg-1:
            if j > 70:
                return HttpResponseRedirect('/users/gateway/do=5')
            if not free[j]:
                return HttpResponseRedirect('/users/gateway/do=5')
            else:
                free[j] = False
            j += 1
        new_period = Period(code=periods.code,
                            name=periods.name,
                            period_type=periods.period_type,
                            lecturer=periods.lecturer,
                            position=periods.position,
                            length=periods.length,
                            timetable_id=tid)
        new_period.save()
        return HttpResponseRedirect('/')
Exemplo n.º 10
0
def product_all():
    page = int(request.args.get("page", 1))
    order = request.args.get("order")
    cid = request.args.get("cid")
    if cid:
        current_cate=Category.get(id=cid)
    else:
        current_cate=None
    periods=Period.get_list_periods(cid=cid,page=page,order=order)
    return render_template( 'new_list.html', periods=periods,order=order,cid=cid,current_cate=current_cate)
Exemplo n.º 11
0
def get_num(pid, price):

    period = Period.get(id=pid)
    all_seq = str(period.all_num).split(' ')
    random_seq = random.sample(all_seq, price)
    random_text = ' '.join(random_seq)
    left_seq = set(all_seq) - set(random_seq)
    left_text = ' '.join(left_seq)
    period.all_num = left_text
    period.save()
    return random_text
Exemplo n.º 12
0
def update_period(pid, data):
    period = Period.get(id=int(pid))
    if data.get("status"):
        period.join_count = data["join_count"]
        period.status = data["status"]
        period.end_time = data["end_time"]
        period.kj_count = data["kj_count"]
        period.kj_time = data["kj_time"]
    else:
        period.join_count = data["join_count"]
    period.save()
Exemplo n.º 13
0
class PeriodTest(TestCase):

    def __init__(self, *args, **kwargs):
        super(PeriodTest, self).__init__(*args, **kwargs)

        self.h1period = Period(name="H1")
        self.m15period = Period(name="M15")

    def test_get_or_create(self):
        p = Period.get_period("M30")
        self.assertEqual(p.get_numeric(), 30)
        self.assertTrue(p.get_unit_letter() == "M") # TEST FAILING !
        self.assertEqual(p.get_py_tdelta(), timedelta(minutes=30))

    def test_get_numeric(self):
        self.assertTrue(self.h1period.get_numeric() == 1)
        self.assertTrue(self.m15period.get_numeric() == 15)

    def test_get_letter(self):
        self.assertTrue(self.h1period.get_unit_letter() == "H")
        self.assertTrue(self.m15period.get_unit_letter() == "M")

    def test_get_timedelta(self):
        h1tdelta = timedelta(hours=1)
        m15tdelta = timedelta(minutes=15)

        self.assertAlmostEquals(self.h1period.get_py_tdelta(), h1tdelta)
        self.assertAlmostEquals(self.m15period.get_py_tdelta(), m15tdelta)
Exemplo n.º 14
0
    def putMenu(self, date, periodId):
        """ date format: XXXX-XX-XX, peroid: 481,482,483 for breakfast, lunch and dinner, 1778 and 1779 for other two """
        values = {}
        values['LocationId'] = "1965"  # fixed for ARA
        values['PeriodId'] = periodId  # 481,482,483 for breakfast, lunch and dinner, 1778 and 1779 for other two
        values['MenuDate'] = date
        values['UIBuildDateForm'] = date
        data = urllib.urlencode(values)
        url = "http://rose-hulman.campusdish.com/Commerce/Catalog/Menus.aspx"
        geturl = url + "?" + data
        print geturl
        request = urllib2.Request(geturl)
        response = urllib2.urlopen(request)
        soup = BeautifulSoup(response.read())
        blocks = soup.find_all('div', class_='menu-details-station')

        if periodId == 481:
            pName = "Breakfast"
        elif periodId == 482:
            pName = "Lunch"
        elif periodId == 483:
            pName = "Dinner"
        elif periodId == 1778:
            pName = "Con't Breakfast"
        elif periodId == 1779:
            pName = "Soup & Salad"

        period = Period(selectDate=date,
                        name=pName)
        period.put()
        for block in blocks:
            # print block.h2.string, "------"
            category = Category(parent=period.entityKey,
                                name=block.h2.string)
            category.put()
            for item in block.find_all('div', class_='menu-name'):
                # print "     ", item.a.string
                dish = Dish(parent=category.entityKey,
                            name=item.a.string)
                dish.put()
Exemplo n.º 15
0
def event_index(request):
    if request.method == 'GET':
        page_size = int(request.GET.get('pageSize',settings.DEFAUTL_PAGE_SIZE))
        page_num = long(request.GET.get('pageNum',1))
        order_str = title_field_html.get_order_str(request)
        query = Event.all().filter('owner =',users.get_current_user())
        if order_str:
            query = query.order(order_str)
        else:
            query = query.order('-start')
        context = title_field_html.pagination_context(query.count(),page_num,page_size)
        context['object_list'] = query.fetch(page_size,offset=(page_num-1)*page_size)
        return render_to_response('work_note/event_list.html',context,
                                  context_instance=RequestContext(request))
    elif request.method == 'POST':
        f = EventForm(request.POST)
        if f.is_valid():
            event = f.save(commit=False)
            event.owner = users.get_current_user()
            period = Period(start=event.start,finish=event.finish)
            if event.finish:
                delta = event.finish - event.start
                event.total_work_time = delta.days*24*3600 + delta.seconds
            event.put()
            period.event = event
            period.put()
            event.set_last_period(period)
            event.put()
            logging.info('%s created event named %s.'%(users.get_current_user(),event.summary))
            return HttpResponseRedirect(str(event.key()))
        else:
            return render_to_response('work_note/event_form.html', {
                    'form':        f,
                    "submit_times":int(request.POST['submit_times']) - 1,
                    'display_cancel':request.POST.get('display_cancel','true'),
                    },context_instance=RequestContext(request))
    raise Http404
Exemplo n.º 16
0
def period_detail():
    pid=request.args.get("pid")
    join_records = None
    count_now_time = None
    user_join_record = None
    zj_user_join_record = None
    newest_period = None
    period = Period.get_period(pid)
    newest_period = get_newest_period(period.product.id)
    join_records=get_join_records(period.kj_time)
    if period.status==1:
        join_records = get_join_records(period.end_time)
        count_now_time = time.time()
        newest_period = get_newest_period(period.product.id)
    if period.status == 2:
        zj_user_join_record = get_single_join_record(period.zj_user.id, pid)
    if current_user.get_id():
        user_join_record = get_single_join_record(current_user.id, pid)
    return render_template('shop.html', period=period, join_records=join_records,
                           count_now_time=count_now_time, newest_period=newest_period, user_join_record=user_join_record,
                           zj_user_join_record=zj_user_join_record)
Exemplo n.º 17
0
    def initialize_extraction(self, period=None, force=None):
        """Check if Period parameter is valid, if the Period entity already exists
and create a new Period."""
        self.response.headers['Content-Type'] = "application/json"

        # Check that 'period' is provided
        if not self.period:
            logging.error("Period not found on POST body. Aborting.")
            self.error(400)
            resp = {
                "status": "error",
                "message": "Period not found on POST body. " +
                           "Aborting."
            }
            self.response.write(json.dumps(resp) + "\n")
            return 1

        # Check that 'period' is valid
        if len(self.period) != 6:
            self.error(400)
            resp = {
                "status": "error",
                "message": "Malformed period. Should be YYYYMM (e.g., 201603)"
            }
            self.response.write(json.dumps(resp) + "\n")
            return 1

        # Get existing period
        period_key = ndb.Key("Period", self.period)
        period_entity = period_key.get()

        # If existing, abort or clear and start from scratch
        if period_entity:
            if self.force is not True:
                logging.error("Period %s already exists. " % self.period +
                              "Aborting. To override, use 'force=true'.")
                resp = {
                    "status": "error",
                    "message": "Period %s already exists. " % self.period +
                               "Aborting. To override, use 'force=true'."
                }
                self.response.write(json.dumps(resp) + "\n")
                return 1
            else:
                logging.warning("Period %s already exists. " % self.period +
                                "Overriding.")
                # Delete Reports referencing period
                r = Report.query().filter(Report.reported_period == period_key)
                to_delete = r.fetch(keys_only=True)
                logging.info("Deleting %d Report entities" % len(to_delete))
                deleted = ndb.delete_multi(to_delete)
                logging.info("%d Report entities removed" % len(deleted))

                # Delete Period itself
                logging.info("Deleting Period %s" % period_key)
                period_key.delete()
                logging.info("Period entity deleted")

        # Create new Period (id=YYYYMM)
        logging.info("Creating new Period %s" % self.period)
        y, m = (int(self.period[:4]), int(self.period[-2:]))
        p = Period(id=self.period)
        p.year = y
        p.month = m
        p.status = 'in progress'
        period_key = p.put()

        # Check
        if period_key:
            logging.info("New Period %s created successfully." % self.period)
            logging.info("New period's key = %s" % period_key)
        else:
            self.error(500)
            logging.error("Could not create new Period %s" % self.period)
            resp = {
                "status": "error",
                "message": "Could not create new Period %s" % self.period
            }
            self.response.write(json.dumps(resp) + "\n")
            return 1

        # Clear temporary entities
        keys_to_delete = ReportToProcess.query().fetch(keys_only=True)
        logging.info("Deleting %d temporal (internal use only) entities"
                     % len(keys_to_delete))
        ndb.delete_multi(keys_to_delete)

        return 0
Exemplo n.º 18
0
    def get(self):

        # Check if datasets are loaded in datastore

        # Items in datastore
        d = Dataset.query().count()

        # Items in Carto
        q = "select count(*) as c from resource_staging" + \
            " where ipt is true and networks like '%VertNet%';"
        c = carto_query(q)[0]['c']

        # Number of reports stored in the datastore
        num_reports = Report.query().count()

        periods = Period.query()
        num_periods = periods.count()

        periods_done = Period.query(Period.status == "done")
        num_periods_done = periods_done.count()

        periods_progress = Period.query(Period.status == "in progress")
        num_periods_progress = periods_progress.count()

        periods_failed = Period.query(Period.status == "failed")
        num_periods_failed = periods_failed.count()

        resp = {
            "Datastore integrity": [
                {"Datasets in Carto": c},
                {"Datasets in the Datastore": d}
            ],
            "Report periods": [
                {"Stored periods": num_periods},
                {"Stored reports": num_reports},
                {"Periods completed": num_periods_done},
                {"Periods in progress": num_periods_progress},
                {"Periods failed": num_periods_failed},
            ]
        }

        if c != d or c == 0:
            dataset_setup_url = "http://%s/admin/setup/datasets" % _HOSTNAME
            resp["Datastore integrity"].append({"URL for dataset setup": dataset_setup_url})
        if num_periods > 0:
            links_to_periods = ["http://%s/admin/status/period/%s" % (_HOSTNAME, x.key.id()) for x in periods.fetch()]
            resp["Report periods"].append({"Links to periods": links_to_periods})
        if num_periods_done > 0:
            resp['Report periods'].append({'List of periods done': [x.period.strftime("%Y-%m") for x in periods_done.fetch()]})
        if num_periods_progress > 0:
            resp['Report periods'].append({'List of periods in progress': [x.period.strftime("%Y-%m") for x in periods_progress.fetch()]})
        if num_periods_failed > 0:
            resp['Report periods'].append({'List of periods failed': [x.period.strftime("%Y-%m") for x in periods_failed.fetch()]})

        headers = {
            'User-Agent': 'VertNet',
            'Accept': 'application/vnd.github.v3+json',
            'Authorization': 'token {0}'.format(apikey('ghb'))
        }

        # API URL https://api.github.com/rate-limit
        rpc = urlfetch.create_rpc()
        url = '/'.join([GH_URL, 'users', 'VertNet'])
        urlfetch.set_default_fetch_deadline(60)
        urlfetch.make_fetch_call(rpc, url, headers=headers)

        h = rpc.get_result().headers
        u = rpc.get_result().content
        resp['url'] = url
        user = {}
        user['content']=json.loads(u)
        timefloat = float(h['x-ratelimit-reset'])
        expires = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(timefloat))
        user['x-ratelimit-limit'] = h['x-ratelimit-limit']
        user['x-ratelimit-remaining'] = h['x-ratelimit-remaining']
        user['x-ratelimit-reset'] = expires
        resp['user'] = user

        self.response.headers['content-type'] = "application/json"
        self.response.write(json.dumps(resp))
Exemplo n.º 19
0
    def _create_or_add_period(self, period_name, parentnode, extras):
        period = Period(parentnode=parentnode, short_name=period_name, long_name=period_name.capitalize(),
                        start_time=datetime.now(), end_time=datetime.now() + timedelta(days=5 * 30))
        try:
            period.full_clean()
            period.save()
        except ValidationError:
            period = Period.objects.get(parentnode=parentnode, short_name=period_name)

        # add the extras (only admins allowed in subject)
        for admin in extras['admin']:
            period.admins.add(self._create_or_add_user(admin))

        if extras['begins']:
            period.start_time = datetime.now() + timedelta(days=int(extras['begins'][0]) * 30)
        if extras['ends']:
            period.end_time = period.start_time + timedelta(days=int(extras['ends'][0]) * 30)
        elif extras['begins'] and not extras['ends']:
            period.end_time = period.start_time + timedelta(5 * 30)

        if extras['ln']:
            period.long_name = extras['ln'][0]

        period.full_clean()
        period.save()

        vars(self)[parentnode.short_name + '_' + period.short_name] = period
        return period
def schedule(request):
    schedule=[]
    today = date.today()
    while today.weekday() >= 5 or ScheduleDay.objects.filter(date=today).count() > 0 and ScheduleDay.objects.get(date=today).day_off:
        today += timedelta(1)
    schedule_day = None
    if ScheduleDay.objects.filter(date=today).count() > 0:
        schedule_day = ScheduleDay.objects.get(date=today)
    else:
        done = False
        one_day = timedelta(1)
        today_dt = datetime.combine(today, time())
        today_dt -= one_day
        new_date = today_dt.date()
        days_ellapsed = 0
        day = 0
        while not done:
            if new_date.weekday() < 5 and ScheduleDay.objects.filter(date=new_date).count() == 0:
                days_ellapsed += 1
            elif new_date.weekday() < 5 and not ScheduleDay.objects.get(date=new_date).day_off:
                done = True
                day = (ScheduleDay.objects.get(date=new_date).day + days_ellapsed) % 7
            new_dt = datetime.combine(new_date, time())
            new_dt -= one_day
            new_date = new_dt.date()
        schedule_day = ScheduleDay(date=today, day_off=False, day=day, schedule="")
        schedule_day.save()
    print(schedule_day.day)
    if schedule_day.schedule == "":
        schedule_day.schedule = master_schedule[schedule_day.day]
        s
        
    if len(schedule_day.period_set.all()) == 0:
        for i in range(len(schedule_day.schedule)):
            period = Period(day=schedule_day, period_number=i, period_letter=schedule_day.schedule[i:i + 1])
            period.save()
    
    for period in schedule_day
    for period in schedule_day.schedule:
        schedule.append([[period]])
    
    
    return render(request, "scanner/schedule.html", {'schedule_table': schedule})

@not_login_required
def checkin (request):
    
    messages = []
    
    if request.method == 'POST':
        form = ScanForm(request.POST)
        if form.is_valid():
            data = form.cleaned_data
            idnum = data["scan"]
            if len(Person.objects.filter(id=idnum)) != 0:
                person = Person.objects.get(id=idnum)
                checkins = Checkin.objects.filter(person=person, completed=False)
                if len(checkins) == 0:
                    messages.append("Successfully checked in " + person.first_name + " " + person.last_name)
                    new_checkin = Checkin(person=person, checkin=datetime.now(), checkout=datetime.now())
                    new_checkin.save()
                else:
                    for obj in checkins:
                        obj.checkout = datetime.now()
                        obj.completed = True
                        obj.save()
                        person.hours += float((obj.checkout - obj.checkin).total_seconds()) / 3600
                        person.save()
                    messages.append("Successfully checked out " + person.first_name + " " + person.last_name)
        
    form = ScanForm()
    return render(request, "scanner/checkin.html", {"form": form, "messages": messages})

@not_login_required
def scan (request, idnum):
    idnum = int(idnum)
    if idnum < 10000 or idnum > 20000:
        return user(request, idnum)
    if idnum > 10000 and idnum < 20000:
        return checkout_item(request, idnum)
    return render(request, "scanner/item.html", {"idnum": idnum})

@not_login_required
def user (request, idnum):
    if len(Person.objects.filter(id=idnum)) == 0:
        if request.method == 'POST':
            form = NewUserForm(request.POST)
            if form.is_valid():
                person = form.save(commit=False)
                person.id = idnum
                person.save()
        else:
            form = NewUserForm()
            return render(request, "scanner/newuser.html", {"idnum": idnum, "form": form})
    
    person = Person.objects.get(id=idnum)
    messages = []
    
    if request.method == 'POST':
        form = ScanForm(request.POST)
        if form.is_valid():
            if len(CheckoutItem.objects.filter(id=form.cleaned_data["scan"])) > 0:
                item = CheckoutItem.objects.get(id=form.cleaned_data["scan"])
                if len(Checkout.objects.filter(person=person, item=item, checked_in=False)) > 0:
                    for checkout in Checkout.objects.filter(person=person, item=item, checked_in=False):
                        checkout.checked_in = True
                        checkout.date_returned = datetime.now()
                        checkout.save()
                        messages.append(item.name + " successfully checked in.")
                else:
                    new_checkout = Checkout(person=person, item=CheckoutItem.objects.get(id=form.cleaned_data["scan"]), date_checked_out=datetime.now() , date_due=datetime.now() + timedelta(CheckoutItem.objects.get(id=form.cleaned_data["scan"]).default_checkout_time))
                    new_checkout.save()
                    messages.append(item.name + " successfully checked out.")
            else:
                messages.append("That item is not in the database.")
    form = ScanForm()
    return render(request, "scanner/user.html", {"person": person, "form": form, "checkouts": Checkout.objects.filter(person=person, checked_in=False), "messages": messages})

@not_login_required
def checkout_item (request, idnum):
    if len(CheckoutItem.objects.filter(id=idnum)) == 0:
        if request.method == 'POST':
            form = NewItemForm(request.POST)
            if form.is_valid():
                item = form.save(commit=False)
                item.id = idnum
                item.save()
            else:
                form = NewItemForm()
                return render(request, "scanner/newitem.html", {"idnum": idnum, "form": form})
        else:
            form = NewItemForm()
            return render(request, "scanner/newitem.html", {"idnum": idnum, "form": form})
            
    return render(request, "scanner/item.html", {"item": CheckoutItem.objects.get(id=idnum)})

@not_login_required
def checkout(request, personid, itemid):
    return render(request, "scanner/item.html", {"item": CheckoutItem.objects.get(id=itemid)})
    
@login_required
def admin(request):
    person = request.user.leadershipmember
    return render(request, "scanner/admin.html", {"person": person})

@not_login_required
def admin_login(request):
    
    if request.method == 'POST':
        form = AdminLoginForm(request.POST)
        if form.is_valid():
            data = form.cleaned_data
            username = data["id"]
            password = data["password"]
            user = authenticate(username=username, password=password)
            if user is not None:
                login(request, user)
                return HttpResponseRedirect(reverse("admin"))
    
    form = AdminLoginForm()
        
    return render(request, "scanner/admin_login.html", {"form": form})
    
@login_required
def admin_add_leadership(request):
    if not request.user.leadershipmember.can_add_leadership_members:
        return HttpResponseRedirect(reverse("admin"))
    if request.method == 'POST':
        form = NewLeadershipMemberForm(request.POST)
        if form.is_valid():
            data = form.cleaned_data
            person = Person.objects.get(id=data["id"])
            
            if len(User.objects.filter(username=data["id"])) == 0:
                print(data["password"])
                user = User.objects.create_user(data["id"], data["email"], data["password"])
                user.save()
            user = User.objects.get(username=data["id"])
            leadershipmember = LeadershipMember(first_name=person.first_name, last_name=person.last_name, id=person.id, hours=person.hours, periods=data["periods"], user=user)
            person.delete()
            leadershipmember.save()
            return HttpResponseRedirect(reverse("admin"))
    
    form = NewLeadershipMemberForm()
    return render(request, "scanner/admin_add_leadership.html", {"form": form})

@login_required
def admin_change_permissions(request):
    if not request.user.leadershipmember.can_change_leadership_permissions:
        return HttpResponseRedirect(reverse("admin"))
    leadershipmembers = LeadershipMember.objects.exclude(id=request.user.leadershipmember.id)
    return render(request, "scanner/admin_change_permissions.html", {'leadershipmembers': leadershipmembers})
    
@login_required
def admin_edit_info(request):
    if request.method == 'POST':
        form = LeadershipEditInfoForm(request.POST, instance=request.user.leadershipmember)
        if form.is_valid():
            form.save()
            return HttpResponseRedirect(reverse("admin"))
    form = LeadershipEditInfoForm(instance=request.user.leadershipmember)        
    return render(request, "scanner/admin_edit_info.html", {"form": form})
  
@login_required  
def admin_change_user_permissions(request, id):
    if not request.user.leadershipmember.can_change_leadership_permissions:
        return HttpResponseRedirect(reverse("admin"))
    if request.method == 'POST':
        form = ChangePermissionsForm(request.POST)
        if form.is_valid():
            print("1")
            data = form.cleaned_data
            lm = LeadershipMember.objects.get(id=id)
            lm.can_add_leadership_members = data["can_add_leadership_members"]
            lm.can_change_leadership_permissions = data["can_change_leadership_permissions"]
            lm.save()
            return HttpResponseRedirect(reverse("admin change permissions"))
    person = request.user.leadershipmember
    form = ChangePermissionsForm(instance=LeadershipMember.objects.get(id=id))
    return render(request, "scanner/admin_change_user_permissions.html", {"form": form, "person": person, "id": id})
Exemplo n.º 21
0
def create_from_path(path):
    """ Create a Node, Subject, Period, Assignment or AssignmentGroup from
    ``path``.

    Examples::

        assignmentgroup = create_from_path(
                'ifi:inf1100.spring05.oblig1.student1,student2')
        oblig1 = create_from_path(
                'ifi:inf1100.spring05.oblig1')
    """
    split = path.split(':', 1)
    nodes = split[0].split('.')
    for nodename in nodes:
        node = Node(short_name=nodename, long_name=nodename.capitalize())
        try:
            node.clean()
            node.save()
        except:
            node = Node.objects.get(short_name=nodename)
        last = node

    if len(split) != 2:
        return last
    pathsplit = split[1].split('.')

    # Subject
    subjectname = pathsplit[0]
    subject = Subject(parentnode=node, short_name=subjectname,
            long_name=subjectname.capitalize())
    try:
        subject.clean()
        subject.save()
    except:
        subject = Subject.objects.get(short_name=subjectname)
    last = subject

    # Period
    if len(pathsplit) > 1:
        periodname = pathsplit[1]
        period = Period(parentnode=subject, short_name=periodname,
                long_name=periodname.capitalize(), start_time=datetime.now(),
                end_time=datetime.now() + timedelta(10))
        try:
            period.clean()
            period.save()
        except:
            period = Period.objects.get(parentnode=subject,
                    short_name=periodname)
        last = period

    # Assignment
    if len(pathsplit) > 2:
        assignmentname = pathsplit[2]
        assignment = Assignment(parentnode=period, short_name=assignmentname,
                long_name=assignmentname.capitalize(), publishing_time=datetime.now())
        
        assignment.clean()
        try:
            assignment.save()
        except:
            assignment = Assignment.objects.get(parentnode=period,
                    short_name=assignmentname)
        last = assignment

    # Candidates
    if len(pathsplit) > 3:
        usernames = pathsplit[3].split(',')
        users = []
        for u in usernames:
            user = User(username=u)
            try:
                user.save()
            except:
                user = User.objects.get(username=u)
            users.append(user)
        assignment_group = AssignmentGroup(parentnode=assignment)
        assignment_group.clean()
        assignment_group.save()
        for user in users:
            assignment_group.candidates.add(Candidate(student=user))
        last = assignment_group
    return last
Exemplo n.º 22
0
 def test_bars(self):
     instrument = Instrument.objects.get(name="GBPUSD")
     list = instrument.get_bar_collection(Period.get_period("H1"))
     self.assertTrue(list) # only confirm a list is returned, tested manually = order working
Exemplo n.º 23
0
    def _create_or_add_period(self, period_name, parentnode, extras):
        period = Period(parentnode=parentnode,
                        short_name=period_name,
                        long_name=period_name.capitalize(),
                        start_time=datetime.now(),
                        end_time=datetime.now() + timedelta(days=5 * 30))
        try:
            period.full_clean()
            period.save()
        except ValidationError:
            period = Period.objects.get(parentnode=parentnode,
                                        short_name=period_name)

        # add the extras (only admins allowed in subject)
        for admin in extras['admin']:
            period.admins.add(self._create_or_add_user(admin))

        if extras['begins']:
            period.start_time = datetime.now() + timedelta(
                days=int(extras['begins'][0]) * 30)
        if extras['ends']:
            period.end_time = period.start_time + timedelta(
                days=int(extras['ends'][0]) * 30)
        elif extras['begins'] and not extras['ends']:
            period.end_time = period.start_time + timedelta(5 * 30)

        if extras['ln']:
            period.long_name = extras['ln'][0]

        period.full_clean()
        period.save()

        vars(self)[parentnode.short_name + '_' + period.short_name] = period
        return period
Exemplo n.º 24
0
def create_from_path(path):
    """ Create a Node, Subject, Period, Assignment or AssignmentGroup from
    ``path``.

    Examples::

        assignmentgroup = create_from_path(
                'ifi:inf1100.spring05.oblig1.student1,student2')
        oblig1 = create_from_path(
                'ifi:inf1100.spring05.oblig1')
    """
    split = path.split(':', 1)
    nodes = split[0].split('.')
    for nodename in nodes:
        node = Node(short_name=nodename, long_name=nodename.capitalize())
        try:
            node.clean()
            node.save()
        except:
            node = Node.objects.get(short_name=nodename)
        last = node

    if len(split) != 2:
        return last
    pathsplit = split[1].split('.')

    # Subject
    subjectname = pathsplit[0]
    subject = Subject(parentnode=node,
                      short_name=subjectname,
                      long_name=subjectname.capitalize())
    try:
        subject.clean()
        subject.save()
    except:
        subject = Subject.objects.get(short_name=subjectname)
    last = subject

    # Period
    if len(pathsplit) > 1:
        periodname = pathsplit[1]
        period = Period(parentnode=subject,
                        short_name=periodname,
                        long_name=periodname.capitalize(),
                        start_time=datetime.now(),
                        end_time=datetime.now() + timedelta(10))
        try:
            period.clean()
            period.save()
        except:
            period = Period.objects.get(parentnode=subject,
                                        short_name=periodname)
        last = period

    # Assignment
    if len(pathsplit) > 2:
        assignmentname = pathsplit[2]
        assignment = Assignment(parentnode=period,
                                short_name=assignmentname,
                                long_name=assignmentname.capitalize(),
                                publishing_time=datetime.now())

        assignment.clean()
        try:
            assignment.save()
        except:
            assignment = Assignment.objects.get(parentnode=period,
                                                short_name=assignmentname)
        last = assignment

    # Candidates
    if len(pathsplit) > 3:
        usernames = pathsplit[3].split(',')
        users = []
        for u in usernames:
            try:
                user = get_user_model().objects.get(shortname=u)
            except get_user_model().DoesNotExist:
                user = get_user_model().objects.create_user(username=u)
            users.append(user)
        assignment_group = AssignmentGroup(parentnode=assignment)
        assignment_group.clean()
        assignment_group.save()
        for user in users:
            assignment_group.candidates.add(Candidate(student=user))
        last = assignment_group
    return last
Exemplo n.º 25
0
 def test_get_or_create(self):
     p = Period.get_period("M30")
     self.assertEqual(p.get_numeric(), 30)
     self.assertTrue(p.get_unit_letter() == "M") # TEST FAILING !
     self.assertEqual(p.get_py_tdelta(), timedelta(minutes=30))
Exemplo n.º 26
0
    def __init__(self, *args, **kwargs):
        super(PeriodTest, self).__init__(*args, **kwargs)

        self.h1period = Period(name="H1")
        self.m15period = Period(name="M15")
Exemplo n.º 27
0
def announced():
    count_now_time = time.time()
    periods = Period.get_announced_list()
    winrecords=WinRecord.get_winrecords()
    return render_template('announced.html', periods=periods, count_now_time=count_now_time,winrecords=winrecords)
Exemplo n.º 28
0
def get_newest_period(proid):
    period = Period.select().where(Period.product == proid,
                                   Period.status == 0).get()
    return period
            elif new_date.weekday() < 5 and not ScheduleDay.objects.get(date=new_date).day_off:
                done = True
                day = (ScheduleDay.objects.get(date=new_date).day + days_ellapsed) % 7
            new_dt = datetime.combine(new_date, time())
            new_dt -= one_day
            new_date = new_dt.date()
        schedule_day = ScheduleDay(date=today, day_off=False, day=day, schedule="")
        schedule_day.save()
    print(schedule_day.day)
    if schedule_day.schedule == "":
        schedule_day.schedule = master_schedule[schedule_day.day]
        s
        
        for 
        for i in range(len(schedule_day.schedule)):
            period = Period(day=schedule_day, period_number=i, period_letter=schedule_day.schedule[i:i + 1])
            period.save()
    
    schedule.append([["Day " + str(schedule_day.day + 1)]])
    for period in schedule_day.schedule:
        schedule.append([[period]])
    
    
    return render(request, "scanner/schedule.html", {'schedule_table': schedule})

@not_login_required
def checkin (request):
    
    messages = []
    
    if request.method == 'POST':
Exemplo n.º 30
0
    def initialize_extraction(self, period=None, force=None):
        """Check if Period parameter is valid, if the Period entity already exists
           and create a new Period.
        """
        self.response.headers['Content-Type'] = "application/json"

        # Check that 'period' is provided
        if not self.period:
            s = "Version: %s\n" % __version__
            s += "Period not found on POST body. Aborting."
            logging.error(s)
            self.error(400)
            resp = {"status": "error", "message": s}
            self.response.write(json.dumps(resp) + "\n")
            return 1

        # Check that 'period' is valid
        if len(self.period) != 6:
            s = "Version: %s\n" % __version__
            s += "Malformed period. Should be YYYYMM (e.g., 201603)"
            logging.error(s)
            self.error(400)
            resp = {"status": "error", "message": s}
            self.response.write(json.dumps(resp) + "\n")
            return 1

        # Get existing period
        period_key = ndb.Key("Period", self.period)
        period_entity = period_key.get()

        # If existing, abort or clear and start from scratch
        if period_entity:
            if self.force is not True:
                s = "Version: %s\n" % __version__
                s += "Period %s already exists. " % self.period
                s += "Aborting. To override, use 'force=true'."
                logging.error(s)
                resp = {"status": "error", "message": s}
                self.response.write(json.dumps(resp) + "\n")
                return 1
            else:
                s = "Version: %s\n" % __version__
                s += "Period %s already exists. " % self.period
                s += "Overriding."
                logging.warning(s)

                # Delete Reports referencing period
                r = Report.query().filter(Report.reported_period == period_key)
                to_delete = r.fetch(keys_only=True)
                s = "Version: %s\n" % __version__
                s += "Deleting %d Report entities" % len(to_delete)
                logging.info(s)
                deleted = ndb.delete_multi(to_delete)
                s = "Version: %s\n" % __version__
                s += "%d Report entities removed" % len(deleted)
                logging.info(s)

                # Delete Period itself
                s = "Version: %s\n" % __version__
                s += "Deleting Period %s" % period_key
                logging.info(s)
                period_key.delete()
                s = "Version: %s\n" % __version__
                s += "Period %s deleted" % period_key
                logging.info(s)

        # Create new Period (id=YYYYMM)
        s = "Version: %s\n" % __version__
        s += "Creating new Period %s" % self.period
        logging.info(s)
        y, m = (int(self.period[:4]), int(self.period[-2:]))
        p = Period(id=self.period)
        p.year = y
        p.month = m
        p.status = 'in progress'
        period_key = p.put()

        # Check
        if period_key:
            s = "Version: %s\n" % __version__
            s += "New Period %s created successfully" % self.period
            s += "with key %s" % period_key
            logging.info(s)
        else:
            self.error(500)
            s = "Version: %s\n" % __version__
            s += "Could not create new Period %s" % self.period
            logging.error(s)
            resp = {"status": "error", "message": s}
            self.response.write(json.dumps(resp) + "\n")
            return 1

        # Clear temporary entities
        keys_to_delete = ReportToProcess.query().fetch(keys_only=True)
        s = "Version: %s\n" % __version__
        s += "Deleting %d temporal (internal use only) entities" % len(
            keys_to_delete)
        logging.info(s)
        ndb.delete_multi(keys_to_delete)
        return 0