def add(request):
"""Add/Delete Chain"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
database = DataBase()
if request.method == 'POST': # chains: 1-1 1-2 3-2 4-5
doit = ''
try:
request.POST['save']
doit = 'save'
except KeyError:
doit = ''
if doit == '':
try:
request.POST['delete']
doit = 'delete'
except KeyError:
return redirect('/chains/add/')
if doit == 'save':
try:
chains = request.POST['chains']
except KeyError:
return redirect('/chains/add/')
s_chains = chains.split(' ')
for s_chain in s_chains:
try:
id_main, id_slave = s_chain.split('-')[0:2]
if request.user.has_perm('main.add_chain'):
database.add_chain(database.doc.get(id = id_main),
database.doc.get(id = id_slave))
except ValueError:
pass
if doit == 'delete':
try:
chain_id = request.POST['chain_id']
except KeyError:
return redirect('/chains/add/')
if request.user.has_perm('main.delete_chain'):
database.chain.get(id = chain_id).delete()
return redirect('/chains/add/')
else:
data['docs'] = database.doc.all()
data['chains'] = database.chain.all()
data['content'] = 'chains/add.html'
return render_to_response('index.html', data)
def links(request):
"""View all links"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
database = DataBase()
if request.method == 'POST':
if request.POST['do'] == 'delete':
id_link = request.POST['id_link']
if request.user.has_perm('main.delete_link'):
database.del_link_id(id_link)
elif request.POST['do'] == 'add':
id_doc = request.POST['id_doc']
id_tag = request.POST['id_tag']
if request.user.has_perm('main.add_link'):
database.add_link(database.doc.get(id = id_doc),
database.tag.get(id = id_tag))
all_docs = database.doc.all()
all_db_tags = database.tag.all()
all_tags = []
for db_tag in all_db_tags:
if not parse_docs.check_cycle(db_tag.name):
all_tags.append(db_tag)
out = []
for doc in all_docs:
lns = []
doc_links = database.link.filter(doc = doc)
use_tags = []
free_tags = []
for link in doc_links:
tag = link.tag
if not parse_docs.check_cycle(tag.name):
use_tags.append(tag)
lns.append(link)
for tag in all_tags:
if tag not in use_tags:
free_tags.append(tag)
out.append( {'doc': doc, 'links': lns, 'free_tags': free_tags} )
data['out'] = out
data['content'] = 'tags/links.html'
return render_to_response('index.html', data)
def buttons_stuff(call):
bot = Bot(tgbot, currency_bot, call=call, database=DataBase())
bot.database = DataBase()
print('calldata:', bot.call_parser.data)
print(bot.user.trade_request, 'found trade (buttons)')
print(bot.user.help_request, 'found help (buttons)')
print(bot.user.replenish_request, 'found replenish (buttons)')
print(bot.user.service_request, 'found service (buttons)')
print(bot.user.return_request, 'found return (buttons)')
if bot.user.is_admin or bot.user.is_operator:
bot.operator_call_data_handler()
bot.user_call_data_handler()
def group(request, doit = '', permid = ''):
"""Return group permissions"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
database = DataBase()
if request.method == 'POST':
if request.POST['do'] == 'add':
try:
if request.POST['write'] == u'enable':
write = True
except KeyError:
write = False
if request.user.has_perm('main.add_group_perms'):
for doc_id in request.POST.getlist('doc_id'):
database.add_group_perm(doc = database.doc.get(
id = doc_id),
group = database.group.get(
id = request.POST['group_id']),
write = write)
return redirect('/perms/group/')
if doit == 'delete':
if request.user.has_perm('main.delete_group_perms'):
database.group_perms.get(id = permid).delete()
return redirect('/perms/group/')
if doit == 'toggle':
if request.user.has_perm('main.change_group_perms'):
group_perms = database.group_perms.get(id = permid)
group_perms.write = not group_perms.write
group_perms.save()
return redirect('/perms/group/')
groups = database.group.all()
docs = database.doc.all()
perms = database.group_perms.all()
data['type'] = 'group'
data['groups'] = groups
data['docs'] = docs
data['allperms'] = perms
data['content'] = 'perms/group.html'
return render_to_response('index.html', data)
def need(request):
"""Need documents for create"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
database = DataBase()
docs = database.get_all_need_slave(request.user)
data['content'] = 'chains/need.html'
data['need_docs'] = docs
return render_to_response('index.html', data)
def default_answer_data(request):
"""Generate default data for views"""
databse = DataBase()
auth_this = auth_support.auth_user(request)
if auth_this:
need = len(databse.get_all_need_slave(request.user))
else:
need = 0
return RequestContext(request, {
'auth': auth_this,
'req_url': request.path,
'Title': config.Title,
'Need': need,
})
def msg_analyzer(msg):
bot = Bot(tgbot, msg=msg, curr_bot=currency_bot, database=DataBase())
print(bot.user.trade_request, 'found trade')
print(bot.user.help_request, 'found help')
print(bot.user.replenish_request, 'found replenish')
print(bot.user.service_request, 'found service')
print(bot.user.return_request, 'found return')
bot.message_processor()
def addcheck(request, id_main = 0, id_slave = 0):
"""Test to add chains
Response: True - ok, False - not ok
"""
auth_this = auth_support.auth_user(request)
if not auth_this:
return support.auth_error()
if id_main == 0 or id_slave == 0:
raise Http404
database = DataBase()
data = {
'check': database.check_add_chain(id_main, id_slave)
}
return render_to_response('chains/addcheck.html', data)
def held(request, num = '0'):
"""Change held_status of nunmber"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
if num == '0':
raise Http404
database = DataBase()
number = database.number.get(id = num)
if not support.check_doc_perm(request, number.doc, True):
return support.perm_error()
database.change_number(number, True)
return redirect('/documents/show/')
def parse(request):
"""Parse all printforms and add new docs"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
database = DataBase()
parser = parse_docs.Parser(settings.PRINT_FORMS_DIR)
scanned = []
for path_pf, title_pf, new_tags, main_pf, type_odf, odf_list in parser.scan():
doc = database.add_doc(path_pf, title_pf, type_odf, odf_list, main_pf)
doc_links = database.link.filter(doc = doc)
tags = []
test_tags = []
for tag_name, tag_desc in new_tags:
test_tags.append(tag_name)
try:
tag = database.tag.get(name = tag_name)
database.link.get(doc = doc, tag = tag)
except ObjectDoesNotExist:
tags.append( (tag_name, tag_desc) )
database_tag = database.add_tag(tag_name, tag_desc)
database.add_link(doc, database_tag)
delete_tags = []
for link in doc_links:
tag = link.tag
name = tag.name
desc = tag.description
if name not in test_tags:
delete_tags.append( (name, desc) )
scanned.append( (path_pf, title_pf, tags, main_pf, delete_tags) )
data['scanned'] = scanned
data['content'] = 'documents/parse.html'
return render_to_response('index.html', data)
def check_doc_perm(request, doc, write = False):
"""Return True, if ok perms for doc"""
database = DataBase()
user = request.user
# True if superuser
if user.is_superuser:
return True
# True if user ok
if database.check_user_perm(doc = doc, user = user, write = write):
return True
# Else check groups perms, and true if ok
groups = request.user.groups
for group in groups.all():
if database.check_group_perm(doc = doc, group = group, write = write):
return True
# Else - False
return False
def show(request):
"""View all tags"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
database = DataBase()
if request.method == 'POST':
if request.POST['do'] == 'delete':
id_tag = request.POST['id_tag']
if request.user.has_perm('main.delete_tag'):
database.del_tag(database.tag.get(id = id_tag))
if request.POST['do'] == 'add':
name = request.POST['name']
desc = request.POST['description']
if request.user.has_perm('main.add_tag'):
database.add_tag(name, desc)
all_db_tags = database.tag.all()
all_tags = []
for db_tag in all_db_tags:
if not parse_docs.check_cycle(db_tag.name):
all_tags.append(db_tag)
out = []
for tag in all_tags:
numbers = database.numbers_from_tag(tag)
out.append( {'tag': tag, 'numbers': numbers} )
data['out'] = out
data['content'] = 'tags/show.html'
return render_to_response('index.html', data)
#!/usr/bin/env python3
from falcon import HTTP_404, HTTP_201, HTTP_409, HTTP_403, HTTP_202
from modules.database import DataBase
from modules.constants import *
import hug
db = DataBase("database/users.db")
@hug.post("/users/add/")
@hug.get("/users/add/{name}&{ip}&{port}&{pubKey}")
def AddUser(name, ip, port, pubKey, response=None):
if db.KeyExists(name):
response.status = HTTP_409
return "User {0} already exists".format(name)
db.AddUser(name, ip, port, pubKey)
response.status = HTTP_201
return "User Added"
@hug.post("/users/update/")
@hug.get("/users/update/{name}&{ip}&{port}&{validationMSG}")
def UpdateUser(name, ip, port, validationMSG, response=None):
if not db.KeyExists(name):
response.status = HTTP_404
return "User {0} doesn't exists".format(name)
if not db.UpdateUser(name, ip, port, validationMSG):
def testBasic(self):
"""All tests"""
database = DataBase()
response = self.client.post('', {'login': '******', 'pass': '******'})
login = self.client.login(username='******', password='******')
self.assertEqual(login, True)
self.assertContains(response, 'logout')
doc1 = database.add_doc('jopa0.odt', 'JOPA0', 'odt', 0, True)
doc2 = database.add_doc('jopa1.odt', 'JOPA1', 'odt', 0, True)
database.add_doc('jopa2.odt', 'JOPA2', 'odt', 0, False)
response = self.client.get('/documents/all/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, '<div id="1">JOPA0</div>')
self.assertContains(response, '<div id="2">JOPA1</div>')
self.assertContains(response, '<div id="3">JOPA2</div>')
response = self.client.get('/documents/parse/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/chains/addcheck/1/1/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'True')
database.add_chain(doc1, doc1)
database.add_chain(doc1, doc2)
response = self.client.get('/chains/addcheck/1/1/')
self.assertContains(response, 'False')
response = self.client.get('/chains/addcheck/')
self.assertEqual(response.status_code, 404)
response = self.client.get('/chains/addcheck/1/')
self.assertEqual(response.status_code, 404)
tag1 = database.add_tag('tag1', 'tag1')
tag2 = database.add_tag('tag2', 'tag2')
tag3 = database.add_tag('tag3', 'tag3')
database.add_link(doc1, tag3)
database.add_link(doc1, tag2)
database.add_link(doc1, tag1)
response = self.client.get('/documents/new/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, '<option value="1">JOPA0</option>')
response = self.client.post('/documents/new/', {'id_doc': '1'})
self.assertEqual(response.status_code, 302)
response = self.client.get('/documents/new/1/')
self.assertEqual(response.status_code, 200)
self.assertContains(response, 'tag3')
self.assertContains(response, 'tag2')
self.assertContains(response, 'tag1')
response = self.client.post('/documents/new/1/',
{tag1.name: 'nya1',
tag2.name: 'nya2',
tag3.name: 'nya3'})
self.assertEqual(response.status_code, 302)
response = self.client.get('/documents/show/1/')
self.assertContains(response, 'nya1')
self.assertContains(response, 'nya2')
self.assertContains(response, 'nya3')
response = self.client.get('/documents/edit/1/')
self.assertContains(response, '<input type="submit" value="Change">')
response = self.client.post('/documents/edit/1/',
{'do': 'change',
tag1.name: 'nya1_e',
tag2.name: 'nya2_e',
tag3.name: 'nya3_e'})
self.assertEqual(response.status_code, 302)
response = self.client.get('/documents/odf/1/')
self.assertEqual(response.status_code, 404)
response = self.client.get('/documents/perm_error/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/documents/show/1/')
self.assertContains(response, 'nya1_e')
self.assertContains(response, 'nya2_e')
self.assertContains(response, 'nya3_e')
response = self.client.get('/documents/held/1/')
self.assertEqual(response.status_code, 302)
response = self.client.get('/documents/show/1/')
self.assertContains(response, '<b>Helded:')
response = self.client.get('/chains/need/')
self.assertContains(response, '<a href="/documents/new/1/1/">JOPA0 → JOPA0</a><br>')
self.assertContains(response, '<a href="/documents/new/2/1/">JOPA0 → JOPA1</a><br>')
response = self.client.get('/documents/new/1/1/')
self.assertEqual(response.status_code, 200)
response = self.client.post('/documents/new/1/1/',
{tag3.name: 'nya3_n',
tag2.name: 'nya2_n',
tag1.name: 'nya1_n'})
self.assertEqual(response.status_code, 302)
response = self.client.get('/documents/show/2/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/documents/show/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/documents/edit/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/chains/add/')
self.assertContains(response, '1 JOPA0 → 1 JOPA0')
self.assertContains(response, '1 JOPA0 → 2 JOPA1')
response = self.client.post('/chains/add/', {'chains': '2-1', 'save': ''})
response = self.client.get('/chains/add/')
self.assertContains(response, '1 JOPA0 → 1 JOPA0')
self.assertContains(response, '1 JOPA0 → 2 JOPA1')
self.assertContains(response, '2 JOPA1 → 1 JOPA0')
response = self.client.get('/tags/links/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/tags/show/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/support/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/login/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/perms/user/')
self.assertEqual(response.status_code, 200)
response = self.client.get('/perms/group/')
self.assertEqual(response.status_code, 200)
# logout
response = self.client.post('', {'logout': 'logout'} )
self.assertContains(response, 'Auth')
response = self.client.get('/documents/all/')
self.assertEqual(response.status_code, 302)
def testBasic(self):
database = DataBase()
doc1 = database.add_doc('jopa.odt', 'JOPA', 'odt', 0, True)
doc1 = database.add_doc('jopa.odt', 'JOPA1', 'odt', 0, True)
self.assertEqual(doc1.id, 1)
self.assertEqual(doc1.title, 'JOPA1')
doc2 = database.add_doc('jopa2.odt', 'JOPA2', 'odt', 0, False)
self.assertEqual(doc2.id, 2)
doc3 = database.add_doc('jopa3.odt', 'JOPA3', 'odt', 0, False)
self.assertEqual(doc3.id, 3)
tag1 = database.add_tag('FIO', 'Name and Surname')
tag1 = database.add_tag('FIO', 'Name and Surname 2')
self.assertEqual(tag1.id, 1)
self.assertEqual(tag1.description, 'Name and Surname 2')
tag2 = database.add_tag('date', u'Date')
self.assertEqual(tag2.id, 2)
tag3 = database.add_tag('tag3', u'Tag3')
self.assertEqual(database.del_tag(tag3), True)
link1 = database.add_link(doc1, tag1)
link1 = database.add_link(doc1, tag1)
self.assertEqual(link1.id, 1)
link2 = database.add_link(doc1, tag2)
link3 = database.add_link(doc2, tag2)
link4 = database.add_link(doc3, tag1)
database.del_link_id(link4.id)
self.assertEqual((link2.id, link3.id), (2, 3))
chain1 = database.add_chain(doc1, doc2)
self.assertEqual(chain1.id, 1)
chain1 = database.add_chain(doc1, doc2)
self.assertEqual(chain1.id, 1)
chain2 = database.add_chain(doc3, doc1)
self.assertEqual(chain2.id, 2)
self.assertEqual(database.check_add_chain(doc1.id, doc2.id), False)
self.assertEqual(database.check_add_chain(doc2.id, doc1.id), True)
num1 = database.add_number(doc1, self.user)
self.assertEqual(num1.id, 1)
num2 = database.add_number(doc1, self.user, num1)
self.assertEqual(num2.id, 2)
num3 = database.add_number(doc3, self.user)
self.assertEqual(database.del_number(num3), True)
num3 = database.add_number(doc3, self.user)
database.change_number(num3, True)
self.assertEqual(database.del_number(num3), False)
data1 = database.add_data(num1, tag1.name, 'gggg')
self.assertEqual(data1, True)
data2 = database.add_data(num1, tag1.name, 'hhhh')
self.assertEqual(data2, False)
data2 = database.add_data(num2, tag1.name, 'hhhh')
self.assertEqual(data2, True)
database.add_data(num2, tag1.name, 'tag1')
self.assertEqual(database.del_tag_from_datadoc(num2, tag1.name), True)
database.numbers_from_doc(doc1)
data1 = database.change_data(num1, tag1.name, 'lololo')
self.assertEqual(data1.tag_value, 'lololo')
r = database.change_number(num1, False)
self.assertEqual(r, True)
r = database.change_number(num1, True)
self.assertEqual(r, True)
docs = database.get_slave_docs(num1)
self.assertEqual(docs[0].id, 2)
slaves = database.get_all_need_slave(self.user)
self.assertEqual(slaves[0][0].id, 2)
numbers = database.numbers_from_doc(doc1)
self.assertEqual((numbers[0].id, numbers[1].id), (1, 2))
# Test doc permissions
self.user1 = auth.models.User.objects.create_user('user1', '*****@*****.**', 'user1')
self.group1 = auth.models.Group.objects.create()
self.group1.name = 'group1'
self.group1.save()
self.assertEqual(database.check_user_perm(self.user1, doc1, False), False)
database.add_user_perm(self.user1, doc1, False)
self.assertEqual(database.check_user_perm(self.user1, doc1, False), True)
self.assertEqual(database.check_user_perm(self.user1, doc1, True), False)
database.add_user_perm(self.user1, doc2, True)
self.assertEqual(database.check_user_perm(self.user1, doc2, True), True)
self.user1.groups.add(self.group1)
database.add_group_perm(self.group1, doc1, True)
self.assertEqual(database.check_group_perm(self.group1, doc1, True), True)
docs = database.doc.all()
database.add_group_perm(self.group1, doc3, False)
self.user.groups.add(self.group1)
docs_f = database.perm_doc_filter(self.user1, docs, False)
self.assertEqual(docs_f, [doc1, doc2, doc3])
docs_f = database.perm_doc_filter(self.user1, docs, True)
self.assertEqual(docs_f, [doc2, doc1])
self.assertEqual(database.check_doc_id('1'), True)
self.assertEqual(database.check_doc_id('100'), False)
# False - in number
self.assertEqual(database.del_tag(tag1), False)
def show(request, num = '0'):
"""Show data of number"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
database = DataBase()
if num == '0':
if request.method == 'POST':
number = request.POST['number']
num = database.number.get(id = number)
if not support.check_doc_perm(request, num.doc):
return support.perm_error()
if request.POST['do'] == 'Show':
return redirect('/documents/show/{0}/'.format(number))
elif request.POST['do'] == 'Edit':
if not support.check_doc_perm(request, num.doc, True):
return support.perm_error()
return redirect('/documents/edit/{0}/'.format(number))
elif request.POST['do'] == 'Held':
if not support.check_doc_perm(request, num.doc, True):
return support.perm_error()
return redirect('/documents/held/{0}/'.format(number))
elif request.POST['do'] == 'ODF':
return redirect('/documents/odf/{0}/'.format(number))
nums = database.number.all()
data['numbers'] = nums
data['content'] = 'documents/numbers.html'
return render_to_response('index.html', data)
num = database.number.get(id = num)
if not support.check_doc_perm(request, num.doc):
return support.perm_error()
if request.method == 'POST':
if request.POST['do'] == 'del_tag':
if not support.check_doc_perm(request, num.doc, True):
return support.perm_error()
tag_name = request.POST['tag_name']
if request.user.has_perm(
'main.delete_data') and request.user.has_perm(
'main.change_number'):
if not parse_docs.check_cycle_template(tag_name):
database.del_tag_from_datadoc(num,
tag_name)
else:
try:
row = int(request.POST['row'])-1
except ValueError:
raise Http404
if row < -1:
row = -1
row = str(row)
database.del_tag_from_datadoc(num,
tag_name, row)
elif request.POST['do'] == 'del_number':
if request.user.has_perm('main.delete_number'):
if not support.check_doc_perm(request, num.doc, True):
return support.perm_error()
if database.del_number(num):
return redirect('/documents/show/')
all_data = database.get_all_datatags(num)
doc = num.doc
data['Title_Doc'] = doc.title
data['template'] = doc.print_form
data['Number'] = num.id
data['Date'] = num.date_change
data['Author'] = '{0} [{1}]'.format(num.user.username,
num.user.get_full_name())
data['held_status'] = num.held_status
data['Date_Held'] = num.date_held
data['showthis'] = all_data
data['content'] = 'documents/show.html'
return render_to_response('index.html', data)
def new(request, id_doc = '0', id_num = '0'):
"""Create new document"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
database = DataBase()
if id_doc == '0':
if request.method == 'POST':
id_doc = request.POST['id_doc']
if not support.check_doc_perm(
request,
database.doc.get(id = id_doc),
True):
return support.perm_error()
num = '0'
if database.doc.get(id = id_doc).main:
return redirect('/documents/new/{0}/{1}/'.format(id_doc, num))
else:
raise Http404
docs = database.doc.filter(main = True)
docs = database.perm_doc_filter(request.user, docs, True)
data['content'] = 'documents/choose.html'
data['docs'] = docs
return render_to_response('index.html', data)
if not database.check_doc_id(id_doc):
raise Http404
doc = database.doc.get(id = id_doc)
if not support.check_doc_perm(request, doc, True):
return support.perm_error()
if request.method == 'POST':
if id_num == '0':
if doc.main:
num = database.add_number(doc, user = request.user)
for tag_name in request.POST:
database.add_data(number = num,
tag_name = tag_name,
tag_value = request.POST[tag_name])
return redirect('/documents/edit/{0}/'.format(num.id))
else:
raise Http404
else:
main_num = database.number.get(id = id_num)
slaves = database.get_slave_docs(main_num)
if doc in slaves:
num = database.add_number(doc = doc,
user = request.user,
main_number = main_num)
for tag_name in request.POST:
database.add_data(number = num,
tag_name = tag_name,
tag_value = request.POST[tag_name])
return redirect('/documents/edit/{0}/'.format(num.id))
else:
raise Http404
data['Title_Doc'] = doc.title
cur_links = database.link.filter(doc = doc)
tags = []
for link in cur_links:
name = link.tag.name
cycle = parse_docs.check_cycle(name)
cycle_template = parse_docs.check_cycle_template(name)
if cycle:
name += '_0'
if id_num != '0':
num = database.number.get(id = id_num)
try:
value = database.data.get(number = num,
tag_name = link.tag.name).tag_value
except ObjectDoesNotExist:
value = ''
if cycle_template:
value = '0'
else:
value = ''
desc = link.tag.description
if cycle:
desc = database.tag.get(
name = parse_docs.get_template_from_tagname(
name)).description +' | '+ desc
tags.append({'name': name,
'desc': desc,
'value': value,
'cycle': cycle,
'cycle_template': cycle_template})
data['tags'] = tags
data['content'] = 'documents/new.html'
return render_to_response('index.html', data)
def start_menu(msg):
bot = Bot(tgbot, msg, currency_bot, database=DataBase())
bot.database = DataBase()
bot.send_start()
def delete_admin(msg):
bot = Bot(tgbot, msg, currency_bot, database=DataBase())
bot.delete_admin()
def delete_operator(msg):
bot = Bot(tgbot, msg, currency_bot, database=DataBase())
bot.delete_operator()
def add_new_operator(msg):
bot = Bot(tgbot, msg, currency_bot, database=DataBase())
bot.add_new_operator()
def add_new_admin(msg):
bot = Bot(tgbot, msg, currency_bot, database=DataBase())
bot.add_new_admin()
def send_admin_menu(msg):
bot = Bot(tgbot, msg, currency_bot, database=DataBase())
bot.send_a_menu()
def send_operator_menu(msg):
bot = Bot(tgbot, msg, currency_bot, database=DataBase())
bot.send_o_menu()
def edit(request, num = '0'):
"""Edit data of number-document"""
data = support.default_answer_data(request)
if not data['auth']:
return support.auth_error()
if num == '0':
return redirect('/documents/edit/')
database = DataBase()
num = database.number.get(id = num)
if not support.check_doc_perm(request, num.doc, True):
return support.perm_error()
if request.method == 'POST':
if request.POST['do'] == 'change':
for tag in request.POST:
if tag == 'do':
continue
if request.user.has_perm('main.change_data'):
tag_value = request.POST[tag]
if parse_docs.check_cycle_template(tag):
tag_value = str(int(tag_value))
database.change_data(number = num,
tag_name = tag,
tag_value = tag_value)
return redirect('/documents/edit/{0}/'.format(num.id))
if request.POST['do'] == 'add_tag':
if request.user.has_perm(
'main.add_data') and request.user.has_perm(
'main.change_number'):
cur_tag = database.tag.get(id = request.POST['id_tag'])
if parse_docs.check_cycle_template(cur_tag.name):
cur_tag_value = request.POST['tag_value']
try:
count_add = int(cur_tag_value)
except ValueError:
count_add = 0
if count_add != 0:
tags = database.tag.all()
add_tags = []
for tag in tags:
if parse_docs.check_cycle(tag.name):
if parse_docs.get_template_from_tagname(
tag.name) == cur_tag.name:
add_tags.append(tag)
for i in xrange(count_add):
data_tags = database.get_all_datatags(num)
table_num = '0'
for data_tag in data_tags:
if parse_docs.check_cycle_template(data_tag['tag_name']):
if cur_tag.name == data_tag['tag_name']:
table_num = str(int(data_tag['tag_value']))
break
for add_tag in add_tags:
if database.add_data(
number = num,
tag_name = add_tag.name + '_' + table_num,
tag_value = ''
):
database.change_number(number = num)
if table_num == '0':
if database.add_data(
number = num,
tag_name = cur_tag.name,
tag_value = '0'):
database.change_number(number = num)
else:
database.change_data(number = num,
tag_name = cur_tag.name,
tag_value = table_num)
else:
if database.add_data(
number = num,
tag_name = cur_tag.name,
tag_value = request.POST['tag_value']):
database.change_number(number = num)
all_data = database.get_all_datatags(num)
all_database_tags = database.tag.all()
doc = num.doc
data['Title_Doc'] = doc.title
data['template'] = doc.print_form
data['Number'] = num.id
data['Date'] = num.date_change
data['Author'] = '{0} [{1}]'.format(num.user.username,
num.user.get_full_name())
data['held_status'] = num.held_status
if data['held_status']:
data['date_held'] = num.date_held
showthis = []
test_tags = []
for data_tag in all_data:
showthis.append(data_tag)
test_tags.append(database.tag.get(id = data_tag['tag_id']))
all_tags = []
for tag in all_database_tags:
if tag not in test_tags:
if not parse_docs.check_cycle(tag.name):
all_tags.append(tag)
else:
if parse_docs.check_cycle_template(tag.name):
all_tags.append(tag)
data['all_tags'] = all_tags
data['showthis'] = showthis
data['content'] = 'documents/edit.html'
return render_to_response('index.html', data)
