def hello_world(request):
# print(request.GET)
get_dict = dict(six.iterlists(request.GET))
post_dict = dict(six.iterlists(request.POST))
print(get_dict)
print(post_dict)
return render(request, 'first_app/helloworld.html', get_dict)
def test_multivaluedict(self):
d = MultiValueDict({'name': ['Adrian', 'Simon'],
'position': ['Developer']})
self.assertEqual(d['name'], 'Simon')
self.assertEqual(d.get('name'), 'Simon')
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
self.assertEqual(list(six.iteritems(d)),
[('position', 'Developer'), ('name', 'Simon')])
self.assertEqual(list(six.iterlists(d)),
[('position', ['Developer']),
('name', ['Adrian', 'Simon'])])
# MultiValueDictKeyError: "Key 'lastname' not found in
# <MultiValueDict: {'position': ['Developer'],
# 'name': ['Adrian', 'Simon']}>"
self.assertRaisesMessage(MultiValueDictKeyError,
'"Key \'lastname\' not found in <MultiValueDict: {\'position\':'\
' [\'Developer\'], \'name\': [\'Adrian\', \'Simon\']}>"',
d.__getitem__, 'lastname')
self.assertEqual(d.get('lastname'), None)
self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
self.assertEqual(d.getlist('lastname'), [])
self.assertEqual(d.getlist('doesnotexist', ['Adrian', 'Simon']),
['Adrian', 'Simon'])
d.setlist('lastname', ['Holovaty', 'Willison'])
self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
self.assertEqual(list(six.itervalues(d)),
['Developer', 'Simon', 'Willison'])
def post(self, request):
data = dict(six.iterlists(request.post))
log_url = data['site'][0]
# path = "/Users/tyflow/Downloads/chromedriver"
# options = webdriver.ChromeOptions()
# options.add_argument('headless')
# options.add_argument('window-size=1920x1080')
# options.add_argument("disable-gpu")
# driver = webdriver.Chrome(path, chrome_options=options)
path = "/Users/tyflow/Downloads/chromedriver"
driver = webdriver.Chrome(path)
driver.get(log_url)
log_id = data['id'][0]
log_pw = data['pw'][0]
log = driver.find_element_by_id("userId")
log.send_keys(log_id)
log = driver.find_element_by_id("userPwd")
log.send_keys(log_pw)
log.send_keys(Keys.RETURN)
if driver.current_url == 'https://accounts.interpark.com/login/form':
return HttpResponse("오류")
else:
return HttpResponse("성공")
def and_filter(project_list, request, *fieldtofilter):
q_dict = dict(six.iterlists(request.GET))
# print(q_dict)
for field in fieldtofilter:
project_list2 = []
if field not in q_dict:
continue
field_attribute = q_dict.get(field)
# print(skills)
etalon = []
for s in field_attribute:
etalon.append(apps.get_model('fairapp', field).objects.get(pk=s))
# print(project_list)
length = len(project_list)
for p in range(length):
attr = getattr(project_list[p], field)
# print(project_list[p])
# print(etalon)
# print(list(attr.all()))
# print(set(list(attr.all()))&set(etalon)==set(etalon))
if set(list(attr.all())) & set(etalon) == set(etalon):
#list(p.skill.all()) == etalon:
project_list2.append(project_list[p])
if len(project_list2) > 0:
project_list = project_list2
return project_list
def test_multivaluedict(self):
d = MultiValueDict({"name": ["Adrian", "Simon"], "position": ["Developer"]})
self.assertEqual(d["name"], "Simon")
self.assertEqual(d.get("name"), "Simon")
self.assertEqual(d.getlist("name"), ["Adrian", "Simon"])
self.assertEqual(sorted(list(six.iteritems(d))), [("name", "Simon"), ("position", "Developer")])
self.assertEqual(sorted(list(six.iterlists(d))), [("name", ["Adrian", "Simon"]), ("position", ["Developer"])])
# MultiValueDictKeyError: "Key 'lastname' not found in
# <MultiValueDict: {'position': ['Developer'],
# 'name': ['Adrian', 'Simon']}>"
six.assertRaisesRegex(
self, MultiValueDictKeyError, r'"Key \'lastname\' not found in <MultiValueDict', d.__getitem__, "lastname"
)
self.assertEqual(d.get("lastname"), None)
self.assertEqual(d.get("lastname", "nonexistent"), "nonexistent")
self.assertEqual(d.getlist("lastname"), [])
self.assertEqual(d.getlist("doesnotexist", ["Adrian", "Simon"]), ["Adrian", "Simon"])
d.setlist("lastname", ["Holovaty", "Willison"])
self.assertEqual(d.getlist("lastname"), ["Holovaty", "Willison"])
self.assertEqual(sorted(list(six.itervalues(d))), ["Developer", "Simon", "Willison"])
def query(request):
form_dict = dict(six.iterlists(request.GET))
pivoted = get_df(form_dict, ENGINE)
table = ptable(pivoted)
table = table.to_html(
formatters=build_formatters_by_cl(table), # 逐列调整表格内数字格式
classes='ui selectable celled table', # 指定表格css class为Semantic UI主题
table_id='ptable' # 指定表格id
)
# Pyecharts交互图表
bar_total_trend = json.loads(
prepare_chart(pivoted, 'bar_total_trend', form_dict))
# Matplotlib静态图表
bubble_performance = prepare_chart(pivoted, 'bubble_performance',
form_dict)
context = {
'market_size': kpi(pivoted)[0],
'market_gr': kpi(pivoted)[1],
'market_cagr': kpi(pivoted)[2],
'ptable': table,
}
for v, k in context.items():
# int64对象，json库不认识。
if type(k) is not str:
context[v] = k.astype(float)
context['bar_total_trend'] = bar_total_trend
context['bubble_performance'] = bubble_performance
a = json.dumps(context, ensure_ascii=False)
return HttpResponse(
a, content_type="application/json charset=utf-8") # 返回结果必须是json格式
def register_a_book_for_pre_order(request):
if request.method == "GET":
# structure of form defined below
return render(request, 'addbookforpreorder.html')
if request.method == "POST":
post_dict = dict(six.iterlists(request.POST))
jso = json.loads(post_dict['command'][0])
if request.user.is_authenticated:
user = BookMaker.objects.filter(django_user=request.user)
else:
print("Anonymous User Error!")
if len(user) < 1:
print("Invalid User!")
else:
book = Book.objects.create(
title=jso['title'],
first_publish_year=int(jso['publish_year']),
isbn=jso['isbn'],
number_of_pages=int(jso['number_of_pages']),
summary=jso['summary'],
cover_image_addr=jso['cover_image'],
author_name=jso['author_name'])
book.save()
w_entry = Write.objects.create(book_id=book, book_maker_id=user)
w_entry.save()
def test_multivaluedict(self):
d = MultiValueDict({'name': ['Adrian', 'Simon'],
'position': ['Developer']})
self.assertEqual(d['name'], 'Simon')
self.assertEqual(d.get('name'), 'Simon')
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
self.assertEqual(sorted(list(six.iteritems(d))),
[('name', 'Simon'), ('position', 'Developer')])
self.assertEqual(sorted(list(six.iterlists(d))),
[('name', ['Adrian', 'Simon']),
('position', ['Developer'])])
six.assertRaisesRegex(self, MultiValueDictKeyError, 'lastname',
d.__getitem__, 'lastname')
self.assertEqual(d.get('lastname'), None)
self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
self.assertEqual(d.getlist('lastname'), [])
self.assertEqual(d.getlist('doesnotexist', ['Adrian', 'Simon']),
['Adrian', 'Simon'])
d.setlist('lastname', ['Holovaty', 'Willison'])
self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
self.assertEqual(sorted(list(six.itervalues(d))),
['Developer', 'Simon', 'Willison'])
def frontend_url(request, url=None, back_link=None, absolute=True):
"""Construct an url for a frontend view.
:keyword back: type of the back link to be added to the query string
- here: link to the current request page
- here_if_none: add link only if there is no `back` parameter
:keyword absolute: construct absolute url, including host name
namespace = self.ns_map[task.process.flow_class]
return frontend_url(
self.request,
flow_url(namespace, task, 'index', user=request.user),
back='here')
"""
params = QueryDict(mutable=True)
for key, value in six.iterlists(request.GET):
if not key.startswith('datatable-') and key != '_':
params.setlist(key, value)
if back_link == 'here_if_none' and 'back' in params:
# Do nothing
pass
elif back_link is not None:
if params:
back = "{}?{}".format(quote(request.path),
quote(params.urlencode()))
else:
back = "{}".format(quote(request.path))
params['back'] = back
if url is not None:
location = '{}?{}'.format(url, params.urlencode())
return request.build_absolute_uri(location) if absolute else location
else:
return params.urlencode()
def __deepcopy__(self, memo):
result = self.__class__('', mutable=True, encoding=self.encoding)
memo[id(self)] = result
for key, value in six.iterlists(self):
result.setlist(copy.deepcopy(key, memo),
copy.deepcopy(value, memo))
return result
def market_dates3(request):
form_dict = dict(six.iterlists(request.GET))
bmonth = form_dict['START_time3'][0].replace('-', '')
emonth = form_dict['END_time3'][0].replace('-', '')
zid = form_dict['DIMENSION_select3[]']
zid_fuc = []
df_origin = pd.DataFrame([], columns=['ERDAT'])
for i in range(0, len(zid)):
sql = '''select a.dim_id,a.erdat,a.close_price,b.dim_def
from dim_market_price a,
dim_market_id b
where a.dim_id=b.dim_id
and a.dim_id = '%s'
and substr(erdat,1,6) between '%s' and '%s'
order by erdat
''' % (zid[i], bmonth, emonth)
df = ora_result(sql)
zid_fuc.append(df['DIM_DEF'][0])
# 取数列,并重命名,结果为(index,erdat,i,...,price_i,...,def_i,...)
df_origin = pd.merge(df, df_origin, on=['ERDAT'], how='outer')
df_origin = df_origin.rename(columns={'DIM_ID': zid_fuc[i]})
df_origin = df_origin.rename(columns={'CLOSE_PRICE': 'PRICE' + zid_fuc[i]})
df_origin = df_origin.rename(columns={'DIM_DEF': 'DEF' + zid_fuc[i]})
head = ['DIM_ID']+ list(df_origin['ERDAT'])
result = [head,]
for i in range(0, len(zid)):
values = [zid_fuc[i]]+ list(df_origin['PRICE'+zid_fuc[i]])
result.append(values)
ret = {
'RESULT': result,
'RHEAD': zid_fuc
}
print(result)
return HttpResponse(json.dumps(ret, ensure_ascii=False), content_type="application/json charset=utf-8")
def dec(request):
mess = Meso.objects.all()
if request.method == 'POST':
r = request.POST
tw = dict(six.iterlists(r))
em = list(tw.values())[1][0]
pk = list(tw.values())[2][0]
print(em)
print(pk)
def readpriKeyFile():
content1 = list(map(int, pk.strip().split(',')))
keySize, n, EorD = content1[0], content1[1], content1[2]
return (int(keySize), int(n), int(EorD))
def readFromFileAndDecrypt(message2):
keySize, n, d = readpriKeyFile()
messageLength, blockSize, encryptedMessage = message2.split('_')
messageLength = int(messageLength)
blockSize = int(blockSize)
if not (math.log(2**keySize, len(SYMBOLS)) >= blockSize):
sys.exit(
'ERROR: Block size is too large for the key and symbolset size. Did you specify the correct key file and encryptedfile?'
)
encryptedBlocks = []
for block in encryptedMessage.split(','):
encryptedBlocks.append(int(block))
return decryptMessage(encryptedBlocks, messageLength, (n, d),
blockSize)
tf = readFromFileAndDecrypt(em)
return render(request, 'dec.html', {"mess": mess, "tf": tf})
def get_params(req):
LOG.debug('query: %s' % req.query_params)
if req.query_params:
qp = req.query_params.copy()
return six.iterlists(qp)
return {}
def query(request):
form_dict = dict(six.iterlists(request.GET))
print(form_dict)
bmonth = form_dict['START_time'][0]
emonth = form_dict['END_time'][0]
bmonth = bmonth.replace('-', '')
emonth = emonth.replace('-', '')
prices, zzb = [], []
df1 = pd.DataFrame([], columns=['erdat'])
for i in range(0, len(form_dict['DIMENSION_select[]'])):
zb = form_dict['DIMENSION_select[]'][i]
zzb.append(zb)
sql = '''select zb,erdat,spj
from"COMMON"."XFM_MARKT"
where zb='%s'
and left(erdat,6) between '%s' and '%s'
order by erdat
'''% (zb, bmonth, emonth)
df = sql_result(sql)
df2 = pd.DataFrame(list(df.ERDAT), columns=['erdat'])
df1 = pd.concat([df2, df1],ignore_index=True).drop_duplicates()
prices.append(list(df.SPJ))
dates = list(df1.erdat)
ret = {
'a': dates,
'b': prices,
'id': zzb
}
print(ret)
return HttpResponse(json.dumps(ret, ensure_ascii=False), content_type="application/json charset=utf-8") # 返回结果必须是json格式
def index_view(request):
if request.method == 'POST':
query = dict(six.iterlists(request.POST))
query.pop('csrfmiddlewaretoken')
names = NameModel(names=query)
names.save()
return render(request, 'index.html')
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict(str("vote=yes&vote=no"))
self.assertEqual(q["vote"], "no")
self.assertRaises(AttributeError, q.__setitem__, "something", "bar")
self.assertEqual(q.get("vote", "default"), "no")
self.assertEqual(q.get("foo", "default"), "default")
self.assertEqual(q.getlist("vote"), ["yes", "no"])
self.assertEqual(q.getlist("foo"), [])
self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
self.assertRaises(AttributeError, q.setlist, "foo", ["bar", "baz"])
self.assertRaises(AttributeError, q.appendlist, "foo", ["bar"])
if six.PY2:
self.assertEqual(q.has_key("vote"), True)
self.assertEqual("vote" in q, True)
if six.PY2:
self.assertEqual(q.has_key("foo"), False)
self.assertEqual("foo" in q, False)
self.assertEqual(list(six.iteritems(q)), [("vote", "no")])
self.assertEqual(list(six.iterlists(q)), [("vote", ["yes", "no"])])
self.assertEqual(list(six.iterkeys(q)), ["vote"])
self.assertEqual(list(six.itervalues(q)), ["no"])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {"foo": "bar"})
self.assertRaises(AttributeError, q.pop, "foo")
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, "foo", "bar")
self.assertRaises(AttributeError, q.__delitem__, "vote")
def message(self):
"""Construct an outgoing message for the e-mail.
This will construct a message based on the data provided to the
constructor. This represents the e-mail that will later be sent using
:py:meth:`send`.
After calling this method, the message's ID will be stored in the
:py:attr:`message_id` attribute for later reference.
This does not need to be called manually. It's called by
:py:meth:`send`.
Returns:
django.core.mail.message.SafeMIMEText:
The resulting message.
"""
msg = super(EmailMessage, self).message()
self.message_id = msg['Message-ID']
for name, value_list in six.iterlists(self._headers):
for value in value_list:
# Use the native string on each version of Python. These
# are headers, so they'll be convertible without encoding
# issues.
msg.add_header(str(name), value)
return msg
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict(str('vote=yes&vote=no'))
self.assertEqual(q['vote'], 'no')
self.assertRaises(AttributeError, q.__setitem__, 'something', 'bar')
self.assertEqual(q.get('vote', 'default'), 'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), ['yes', 'no'])
self.assertEqual(q.getlist('foo'), [])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
self.assertRaises(AttributeError, q.setlist, 'foo', ['bar', 'baz'])
self.assertRaises(AttributeError, q.appendlist, 'foo', ['bar'])
if not six.PY3:
self.assertEqual(q.has_key('vote'), True)
self.assertEqual('vote' in q, True)
if not six.PY3:
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(list(six.iteritems(q)), [('vote', 'no')])
self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])])
self.assertEqual(list(six.iterkeys(q)), ['vote'])
self.assertEqual(list(six.itervalues(q)), ['no'])
self.assertEqual(len(q), 1)
self.assertRaises(AttributeError, q.update, {'foo': 'bar'})
self.assertRaises(AttributeError, q.pop, 'foo')
self.assertRaises(AttributeError, q.popitem)
self.assertRaises(AttributeError, q.clear)
self.assertRaises(AttributeError, q.setdefault, 'foo', 'bar')
self.assertRaises(AttributeError, q.__delitem__, 'vote')
def book_maker_signup(request):
if request.method == "GET":
return render(request, 'bookmakersignup.html')
if request.method == "POST":
post_dict = dict(six.iterlists(request.POST))
jso = json.loads(post_dict['command'][0])
if jso['gender'] == 'زن':
jso['gender'] = 'FM'
else:
jso['gender'] = 'ML'
if jso['type'] == 'مولف':
jso['type'] = 'AUT'
else:
if jso['type'] == 'مترجم':
jso['type'] = 'TR'
else:
jso['type'] = 'BOTH'
d_user = User.objects.create(username=jso['username'], password=jso['password'], first_name=jso['first_name'],
last_name=jso['last_name'], email=jso['email'])
user = BookMaker.objects.create(django_user=d_user, birth_date_day=jso['day'], birth_date_month=jso['month'],
birth_date_year=jso['year'],
telephone_no=jso['tel_no'],address=jso['address'],
book_maker_type=jso['type'], gender=jso['gender'])
user.save()
return redirect("/admin")
def test_multivaluedict(self):
d = MultiValueDict({
'name': ['Adrian', 'Simon'],
'position': ['Developer']
})
self.assertEqual(d['name'], 'Simon')
self.assertEqual(d.get('name'), 'Simon')
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
self.assertEqual(sorted(list(six.iteritems(d))),
[('name', 'Simon'), ('position', 'Developer')])
self.assertEqual(sorted(list(six.iterlists(d))),
[('name', ['Adrian', 'Simon']),
('position', ['Developer'])])
six.assertRaisesRegex(self, MultiValueDictKeyError, 'lastname',
d.__getitem__, 'lastname')
self.assertEqual(d.get('lastname'), None)
self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
self.assertEqual(d.getlist('lastname'), [])
self.assertEqual(d.getlist('doesnotexist', ['Adrian', 'Simon']),
['Adrian', 'Simon'])
d.setlist('lastname', ['Holovaty', 'Willison'])
self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
self.assertEqual(sorted(list(six.itervalues(d))),
['Developer', 'Simon', 'Willison'])
def test_multivaluedict(self):
d = MultiValueDict({
'name': ['Adrian', 'Simon'],
'position': ['Developer']
})
self.assertEqual(d['name'], 'Simon')
self.assertEqual(d.get('name'), 'Simon')
self.assertEqual(d.getlist('name'), ['Adrian', 'Simon'])
self.assertEqual(list(six.iteritems(d)), [('position', 'Developer'),
('name', 'Simon')])
self.assertEqual(list(six.iterlists(d)),
[('position', ['Developer']),
('name', ['Adrian', 'Simon'])])
# MultiValueDictKeyError: "Key 'lastname' not found in
# <MultiValueDict: {'position': ['Developer'],
# 'name': ['Adrian', 'Simon']}>"
self.assertRaisesMessage(MultiValueDictKeyError,
'"Key \'lastname\' not found in <MultiValueDict: {\'position\':'\
' [\'Developer\'], \'name\': [\'Adrian\', \'Simon\']}>"',
d.__getitem__, 'lastname')
self.assertEqual(d.get('lastname'), None)
self.assertEqual(d.get('lastname', 'nonexistent'), 'nonexistent')
self.assertEqual(d.getlist('lastname'), [])
self.assertEqual(d.getlist('doesnotexist', ['Adrian', 'Simon']),
['Adrian', 'Simon'])
d.setlist('lastname', ['Holovaty', 'Willison'])
self.assertEqual(d.getlist('lastname'), ['Holovaty', 'Willison'])
self.assertEqual(list(six.itervalues(d)),
['Developer', 'Simon', 'Willison'])
def message(self):
"""Construct an outgoing message for the e-mail.
This will construct a message based on the data provided to the
constructor. This represents the e-mail that will later be sent using
:py:meth:`send`.
After calling this method, the message's ID will be stored in the
:py:attr:`message_id` attribute for later reference.
This does not need to be called manually. It's called by
:py:meth:`send`.
Returns:
django.core.mail.message.SafeMIMEText:
The resulting message.
"""
msg = super(EmailMessage, self).message()
self.message_id = msg['Message-ID']
for name, value_list in six.iterlists(self._headers):
for value in value_list:
# Use the native string on each version of Python. These
# are headers, so they'll be convertible without encoding
# issues.
msg.add_header(str(name), value)
return msg
def get_request_params(self, request):
if request.query_params:
qp = request.query_params.copy()
for param in self.proxy_settings.DISALLOWED_PARAMS:
if param in qp:
del qp[param]
return six.iterlists(qp)
return {}
def get_request_params(self, request):
if request.query_params:
qp = request.query_params.copy()
for param in self.proxy_settings.DISALLOWED_PARAMS:
if param in qp:
del qp[param]
return six.iterlists(qp)
return {}
def translate_a_book(request):
if request.method == "POST":
post_dict = dict(six.iterlists(request.POST))
jso = json.loads(post_dict['command'][0])
if request.user.is_authenticated:
translator = BookMaker.objects.filter(django_user=request.user)
else:
print('Anonymous User Error!')
if len(translator) < 1:
print("invalid User!")
def evaluate(request):
if request.method == 'POST':
features = list(six.iterlists(request.POST))[0][1]
features = list(map(float, features))
modelType = int(list(six.iterlists(request.POST))[1][1][0])
normValues = []
for num in range(2, len(request.POST)):
normValues.append(
list(map(float,
list(six.iterlists(request.POST))[num][1])))
originalFrame = pd.DataFrame(createFeatureList(features, normValues),
columns)
if modelType == 1:
model = load('AI4fitUserTest/static/ExtraTreesClassifier.joblib')
elif modelType == 2:
model = load('AI4fitUserTest/static/LogisticRegression.joblib')
else:
model = "random"
if model == "random":
mark = randint(1, 5)
else:
mark = model.predict(originalFrame.T)[0]
limits = []
for featureIdx in range(12):
for direction in range(2):
value = computeVariation(features, featureIdx, direction, mark,
normValues, model)
limits.append(value)
response = []
response.append(float(mark))
for tuple in limits:
for val in tuple:
response.append(float(val))
return HttpResponse(json.dumps(response))
return render(request, 'userTest.html')
def search_results(request):
try:
get_dict = dict(six.iterlists(request.GET))
mpks = get_dict['mv[]']
movies = Movie.objects.none()
for i in mpks:
movies |= Movie.objects.filter(id=i)
serializer = MovieSerializer(movies, many=True)
return Response(data=serializer.data, status=status.HTTP_200_OK)
except:
return Response(data={}, status=status.HTTP_404_NOT_FOUND)
def test_immutable_basic_operations(self):
q = QueryDict()
self.assertEqual(q.getlist('foo'), [])
if six.PY2:
self.assertIs(q.has_key('foo'), False)
self.assertNotIn('foo', q)
self.assertEqual(list(six.iteritems(q)), [])
self.assertEqual(list(six.iterlists(q)), [])
self.assertEqual(list(six.iterkeys(q)), [])
self.assertEqual(list(six.itervalues(q)), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
def test_immutable_basic_operations(self):
q = QueryDict(str(''))
self.assertEqual(q.getlist('foo'), [])
if not six.PY3:
self.assertEqual(q.has_key('foo'), False)
self.assertEqual('foo' in q, False)
self.assertEqual(list(six.iteritems(q)), [])
self.assertEqual(list(six.iterlists(q)), [])
self.assertEqual(list(six.iterkeys(q)), [])
self.assertEqual(list(six.itervalues(q)), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
def test_immutable_basic_operations(self):
q = QueryDict()
self.assertEqual(q.getlist('foo'), [])
if six.PY2:
self.assertIs(q.has_key('foo'), False)
self.assertNotIn('foo', q)
self.assertEqual(list(six.iteritems(q)), [])
self.assertEqual(list(six.iterlists(q)), [])
self.assertEqual(list(six.iterkeys(q)), [])
self.assertEqual(list(six.itervalues(q)), [])
self.assertEqual(len(q), 0)
self.assertEqual(q.urlencode(), '')
def book_reader_signup(request):
if request.method == "GET":
return render(request, 'bookreadersignup.html')
if request.method == "POST":
post_dict = dict(six.iterlists(request.POST))
jso = json.loads(post_dict['command'][0])
d_user = User.objects.create(username=jso['username'], password=jso['password'] ,
first_name=jso['first_name'],last_name=jso['last_name'], email=jso['email'])
user = BookReaderUser.objects.create(django_user=d_user, address=jso['address'], telephone_no=jso['tel_no'],
birth_date_day=jso['day'], birth_date_month=jso['month'],
birth_date_year=jso['year'])
user.save()
return redirect("/admin")
def querystring(data, exclude="page,all"):
"""
Returns the current querystring, excluding specified GET parameters::
{% request.GET|querystring:"page,all" %}
"""
exclude = exclude.split(",")
items = reduce(
operator.add, (list((k, v) for v in values) for k, values in six.iterlists(data) if k not in exclude), []
)
return urlencode(sorted(items))
def deliver_order(request):
if request.method == "POST":
post_dict = dict(six.iterlists(request.POST))
jso = json.loads(post_dict['command'][0])
# id is the primary key that must be in the json object
p_key = jso['id']
try:
order = Order.objects.get(pk=p_key)
if order.delivery_date is None:
order.delivery_date = timezone.now()
else:
print("Order Already Delivered!")
except ObjectDoesNotExist:
print("requested Order Does not Exists!")
def post(self, request):
data = dict(six.iterlists(request.POST))
log_url = data['site'][0]
# path = "/Users/tyflow/Downloads/chromedriver"
# options = webdriver.ChromeOptions()
# options.add_argument('headless')
# options.add_argument('window-size=1920x1080')
# options.add_argument("disable-gpu")
# driver = webdriver.Chrome(path, chrome_options=options)
path = "/Users/tyflow/Downloads/chromedriver"
driver = webdriver.Chrome(path)
driver.get(log_url)
log_id = data['id'][0]
log_pw = data['pw'][0]
log = driver.find_element_by_id("userId")
log.send_keys(log_id)
log = driver.find_element_by_id("userPwd")
log.send_keys(log_pw)
log.send_keys(Keys.RETURN)
time.sleep(2)
ticket_url = data['url'][0]
driver.get(ticket_url)
time.sleep(2)
driver.find_elements_by_xpath(data['xpath'][0])[0].click()
# driver.switch_to_window(driver.window_handles[1])
# driver.switch_to_frame(driver.find_elements_by_tag_name('iframe')[0])
# driver.find_element_by_xpath('//*[@id="CellPlayDate"]').click()
# print('날짜선택')
# driver.switch_to_window(driver.window_handles[1])
# time.sleep(2)
# driver.find_elements_by_xpath('//*[@id="LargeNextBtnImage"]')[0].click()
# print('다음단계')
# print(driver.find_elements_by_xpath('//*[@id="SID1"]'))
# # test = driver.find_element_by_xpath('//*[@id="CellPlayDate"]')
# # print(test.text)
# # req = driver.page_source
# # soup = BeautifulSoup(req, 'html.parser')
# # print(soup)
# # driver.find_element_by_xpath('//*[@id="CellPlayDate"]')[0].click()
# # while True:
# # if str(datetime.datetime.today())[11:16] == '14:31':
# # driver.find_elements_by_xpath('/html/body/div[9]/div[2]/div[4]/div/div[2]/div/div[2]/div[5]/a')[0].click()
# # break
return HttpResponse("Post 요청을 잘받았다")
def verify_book_seller_user(request):
if request.method == "POST":
post_dict = dict(six.iterlists(request.POST))
jso = json.loads(post_dict['command'][0])
# id is the primary key that must be in the json object
p_key = jso['id']
try:
user = BookSeller.objects.get(pk=p_key)
if not user.is_verified:
user.is_verified = True
user.save()
else:
print("User Already Verified!")
except ObjectDoesNotExist:
print("requested user does not exists!")
def querystring(data, exclude='page,all'):
"""
Returns the current querystring, excluding specified GET parameters::
{% request.GET|querystring:"page,all" %}
"""
exclude = exclude.split(',')
items = reduce(operator.add,
(list((k, v) for v in values)
for k, values in six.iterlists(data) if k not in exclude),
[])
return urlencode(sorted(items))
def index(request):
query = request.GET.copy()
params = dict(iterlists(query))
available_filters = {}
search_term = None
search_field = None
products = PrepaidProduct.objects
total_count = products.count()
valid_filters = ['prepaid_type', 'status', 'issuer_name']
if params:
params.pop('page', None)
search_term = params.pop('q', None)
search_field = params.pop('search_field', None)
if search_field:
search_field = search_field[0]
if search_term:
search_term = search_term[0].strip()
if search_term != '':
products = search_products(search_term, search_field, products)
available_filters = get_available_filters(products)
products = filter_products(params, products)
if not available_filters:
for filter_name in valid_filters:
available_filters[filter_name] = PrepaidProduct.objects.order_by(
filter_name).values_list(filter_name, flat=True).distinct()
current_count = products.count()
paginator = Paginator(products.all(), 20)
page_number = validate_page_number(request, paginator)
page = paginator.page(page_number)
return render(
request, 'prepaid_agreements/index.html', {
'current_page': page_number,
'results': page,
'total_count': total_count,
'paginator': paginator,
'current_count': current_count,
'filters': params,
'query': search_term or '',
'active_filters': available_filters,
'valid_filters': valid_filters,
'search_field': search_field,
'disclaimer_text': get_disclaimer_text(),
'support_text': get_support_text()
})
def test_single_key_value(self):
"""Test QueryDict with one key/value pair"""
q = QueryDict(str('foo=bar'))
self.assertEqual(q['foo'], 'bar')
with self.assertRaises(KeyError):
q.__getitem__('bar')
with self.assertRaises(AttributeError):
q.__setitem__('something', 'bar')
self.assertEqual(q.get('foo', 'default'), 'bar')
self.assertEqual(q.get('bar', 'default'), 'default')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertEqual(q.getlist('bar'), [])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar'])
with self.assertRaises(AttributeError):
q.appendlist('foo', ['bar'])
if six.PY2:
self.assertTrue(q.has_key('foo'))
self.assertIn('foo', q)
if six.PY2:
self.assertFalse(q.has_key('bar'))
self.assertNotIn('bar', q)
self.assertEqual(list(six.iteritems(q)), [('foo', 'bar')])
self.assertEqual(list(six.iterlists(q)), [('foo', ['bar'])])
self.assertEqual(list(six.iterkeys(q)), ['foo'])
self.assertEqual(list(six.itervalues(q)), ['bar'])
self.assertEqual(len(q), 1)
with self.assertRaises(AttributeError):
q.update({'foo': 'bar'})
with self.assertRaises(AttributeError):
q.pop('foo')
with self.assertRaises(AttributeError):
q.popitem()
with self.assertRaises(AttributeError):
q.clear()
with self.assertRaises(AttributeError):
q.setdefault('foo', 'bar')
self.assertEqual(q.urlencode(), 'foo=bar')
def test_multiple_keys(self):
"""Test QueryDict with two key/value pairs with same keys."""
q = QueryDict(str('vote=yes&vote=no'))
self.assertEqual(q['vote'], 'no')
with self.assertRaises(AttributeError):
q.__setitem__('something', 'bar')
self.assertEqual(q.get('vote', 'default'), 'no')
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.getlist('vote'), ['yes', 'no'])
self.assertEqual(q.getlist('foo'), [])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar', 'baz'])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar', 'baz'])
with self.assertRaises(AttributeError):
q.appendlist('foo', ['bar'])
if six.PY2:
self.assertIs(q.has_key('vote'), True)
self.assertIn('vote', q)
if six.PY2:
self.assertIs(q.has_key('foo'), False)
self.assertNotIn('foo', q)
self.assertEqual(list(six.iteritems(q)), [('vote', 'no')])
self.assertEqual(list(six.iterlists(q)), [('vote', ['yes', 'no'])])
self.assertEqual(list(six.iterkeys(q)), ['vote'])
self.assertEqual(list(six.itervalues(q)), ['no'])
self.assertEqual(len(q), 1)
with self.assertRaises(AttributeError):
q.update({'foo': 'bar'})
with self.assertRaises(AttributeError):
q.pop('foo')
with self.assertRaises(AttributeError):
q.popitem()
with self.assertRaises(AttributeError):
q.clear()
with self.assertRaises(AttributeError):
q.setdefault('foo', 'bar')
with self.assertRaises(AttributeError):
q.__delitem__('vote')
def test_single_key_value(self):
"""Test QueryDict with one key/value pair"""
q = QueryDict(str("foo=bar"))
self.assertEqual(q["foo"], "bar")
with self.assertRaises(KeyError):
q.__getitem__("bar")
with self.assertRaises(AttributeError):
q.__setitem__("something", "bar")
self.assertEqual(q.get("foo", "default"), "bar")
self.assertEqual(q.get("bar", "default"), "default")
self.assertEqual(q.getlist("foo"), ["bar"])
self.assertEqual(q.getlist("bar"), [])
with self.assertRaises(AttributeError):
q.setlist("foo", ["bar"])
with self.assertRaises(AttributeError):
q.appendlist("foo", ["bar"])
if six.PY2:
self.assertTrue(q.has_key("foo"))
self.assertIn("foo", q)
if six.PY2:
self.assertFalse(q.has_key("bar"))
self.assertNotIn("bar", q)
self.assertEqual(list(six.iteritems(q)), [("foo", "bar")])
self.assertEqual(list(six.iterlists(q)), [("foo", ["bar"])])
self.assertEqual(list(six.iterkeys(q)), ["foo"])
self.assertEqual(list(six.itervalues(q)), ["bar"])
self.assertEqual(len(q), 1)
with self.assertRaises(AttributeError):
q.update({"foo": "bar"})
with self.assertRaises(AttributeError):
q.pop("foo")
with self.assertRaises(AttributeError):
q.popitem()
with self.assertRaises(AttributeError):
q.clear()
with self.assertRaises(AttributeError):
q.setdefault("foo", "bar")
self.assertEqual(q.urlencode(), "foo=bar")
def test_single_key_value(self):
"""Test QueryDict with one key/value pair"""
q = QueryDict(str('foo=bar'))
self.assertEqual(q['foo'], 'bar')
with self.assertRaises(KeyError):
q.__getitem__('bar')
with self.assertRaises(AttributeError):
q.__setitem__('something', 'bar')
self.assertEqual(q.get('foo', 'default'), 'bar')
self.assertEqual(q.get('bar', 'default'), 'default')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertEqual(q.getlist('bar'), [])
with self.assertRaises(AttributeError):
q.setlist('foo', ['bar'])
with self.assertRaises(AttributeError):
q.appendlist('foo', ['bar'])
if six.PY2:
self.assertTrue(q.has_key('foo'))
self.assertIn('foo', q)
if six.PY2:
self.assertFalse(q.has_key('bar'))
self.assertNotIn('bar', q)
self.assertEqual(list(six.iteritems(q)), [('foo', 'bar')])
self.assertEqual(list(six.iterlists(q)), [('foo', ['bar'])])
self.assertEqual(list(six.iterkeys(q)), ['foo'])
self.assertEqual(list(six.itervalues(q)), ['bar'])
self.assertEqual(len(q), 1)
with self.assertRaises(AttributeError):
q.update({'foo': 'bar'})
with self.assertRaises(AttributeError):
q.pop('foo')
with self.assertRaises(AttributeError):
q.popitem()
with self.assertRaises(AttributeError):
q.clear()
with self.assertRaises(AttributeError):
q.setdefault('foo', 'bar')
self.assertEqual(q.urlencode(), 'foo=bar')
def test_basic_mutable_operations(self):
q = QueryDict(str('')).copy()
q['name'] = 'john'
self.assertEqual(q.get('foo', 'default'), 'default')
self.assertEqual(q.get('name', 'default'), 'john')
self.assertEqual(q.getlist('name'), ['john'])
self.assertEqual(q.getlist('foo'), [])
q.setlist('foo', ['bar', 'baz'])
self.assertEqual(q.get('foo', 'default'), 'baz')
self.assertEqual(q.getlist('foo'), ['bar', 'baz'])
q.appendlist('foo', 'another')
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another'])
self.assertEqual(q['foo'], 'another')
if not six.PY3:
self.assertTrue(q.has_key('foo'))
self.assertTrue('foo' in q)
self.assertEqual(sorted(list(six.iteritems(q))),
[('foo', 'another'), ('name', 'john')])
self.assertEqual(sorted(list(six.iterlists(q))),
[('foo', ['bar', 'baz', 'another']), ('name', ['john'])])
self.assertEqual(sorted(list(six.iterkeys(q))),
['foo', 'name'])
self.assertEqual(sorted(list(six.itervalues(q))),
['another', 'john'])
self.assertEqual(len(q), 2)
q.update({'foo': 'hello'})
self.assertEqual(q['foo'], 'hello')
self.assertEqual(q.get('foo', 'not available'), 'hello')
self.assertEqual(q.getlist('foo'), ['bar', 'baz', 'another', 'hello'])
self.assertEqual(q.pop('foo'), ['bar', 'baz', 'another', 'hello'])
self.assertEqual(q.pop('foo', 'not there'), 'not there')
self.assertEqual(q.get('foo', 'not there'), 'not there')
self.assertEqual(q.setdefault('foo', 'bar'), 'bar')
self.assertEqual(q['foo'], 'bar')
self.assertEqual(q.getlist('foo'), ['bar'])
self.assertIn(q.urlencode(), ['foo=bar&name=john', 'name=john&foo=bar'])
q.clear()
self.assertEqual(len(q), 0)
def test_multivaluedict(self):
d = MultiValueDict({"name": ["Adrian", "Simon"], "position": ["Developer"]})
self.assertEqual(d["name"], "Simon")
self.assertEqual(d.get("name"), "Simon")
self.assertEqual(d.getlist("name"), ["Adrian", "Simon"])
self.assertEqual(sorted(list(six.iteritems(d))), [("name", "Simon"), ("position", "Developer")])
self.assertEqual(sorted(list(six.iterlists(d))), [("name", ["Adrian", "Simon"]), ("position", ["Developer"])])
six.assertRaisesRegex(self, MultiValueDictKeyError, "lastname", d.__getitem__, "lastname")
self.assertEqual(d.get("lastname"), None)
self.assertEqual(d.get("lastname", "nonexistent"), "nonexistent")
self.assertEqual(d.getlist("lastname"), [])
self.assertEqual(d.getlist("doesnotexist", ["Adrian", "Simon"]), ["Adrian", "Simon"])
d.setlist("lastname", ["Holovaty", "Willison"])
self.assertEqual(d.getlist("lastname"), ["Holovaty", "Willison"])
self.assertEqual(sorted(list(six.itervalues(d))), ["Developer", "Simon", "Willison"])
def test_basic_mutable_operations(self):
q = QueryDict(str("")).copy()
q["name"] = "john"
self.assertEqual(q.get("foo", "default"), "default")
self.assertEqual(q.get("name", "default"), "john")
self.assertEqual(q.getlist("name"), ["john"])
self.assertEqual(q.getlist("foo"), [])
q.setlist("foo", ["bar", "baz"])
self.assertEqual(q.get("foo", "default"), "baz")
self.assertEqual(q.getlist("foo"), ["bar", "baz"])
q.appendlist("foo", "another")
self.assertEqual(q.getlist("foo"), ["bar", "baz", "another"])
self.assertEqual(q["foo"], "another")
if not six.PY3:
self.assertTrue(q.has_key("foo"))
self.assertTrue("foo" in q)
self.assertEqual(list(six.iteritems(q)), [("foo", "another"), ("name", "john")])
self.assertEqual(list(six.iterlists(q)), [("foo", ["bar", "baz", "another"]), ("name", ["john"])])
self.assertEqual(list(six.iterkeys(q)), ["foo", "name"])
self.assertEqual(list(six.itervalues(q)), ["another", "john"])
self.assertEqual(len(q), 2)
q.update({"foo": "hello"})
self.assertEqual(q["foo"], "hello")
self.assertEqual(q.get("foo", "not available"), "hello")
self.assertEqual(q.getlist("foo"), ["bar", "baz", "another", "hello"])
self.assertEqual(q.pop("foo"), ["bar", "baz", "another", "hello"])
self.assertEqual(q.pop("foo", "not there"), "not there")
self.assertEqual(q.get("foo", "not there"), "not there")
self.assertEqual(q.setdefault("foo", "bar"), "bar")
self.assertEqual(q["foo"], "bar")
self.assertEqual(q.getlist("foo"), ["bar"])
self.assertEqual(q.urlencode(), "foo=bar&name=john")
q.clear()
self.assertEqual(len(q), 0)
def __deepcopy__(self, memo):
result = self.__class__('', mutable=True, encoding=self.encoding)
memo[id(self)] = result
for key, value in six.iterlists(self):
result.setlist(copy.deepcopy(key, memo), copy.deepcopy(value, memo))
return result
def __copy__(self):
result = self.__class__('', mutable=True, encoding=self.encoding)
for key, value in six.iterlists(self):
result.setlist(key, value)
return result
from __future__ import unicode_literals
