def create_initial_application_acl(mapper, connection, target):
if target.application_type == SVN:
acl_rules = [
("internal_developer", "edit"),
("internal_developer", "view"),
("external_developer", "edit"),
("external_developer", "view"),
]
else:
acl_rules = [
("internal_developer", "view"),
("external_developer", "view"),
("secretary", "view"),
("secretary", "edit"),
]
if target.application_type == "trac":
acl_rules.append(("customer", "view"))
for role_id, permission_name in acl_rules:
acl = DBSession.query(ApplicationACL).get((target.id, role_id, permission_name))
if not acl:
acl = ApplicationACL(application_id=target.id, role_id=role_id, permission_name=permission_name)
DBSession.add(acl)
else:
# XXX this should not happen.
pass
def test_add_project(self):
project_name = u'A project'
session = DBSession()
project = Project(name=project_name)
session.add(project)
transaction.commit()
self.assertEqual(session.query(Project).filter_by(name=project_name).first().name, 'A project')
def password_reset(request):
email = request.params.get('email')
try:
session = DBSession()
user = DBSession.query(User).filter_by(email=email).one()
ptoken = DBSession.query(PasswordResetToken).get(user.id)
if not ptoken:
ptoken = PasswordResetToken(user_id=user.id)
token = str(uuid4())
ptoken.token = token
session.add(ptoken)
except NoResultFound:
token = None
if token:
# settings = request.registry.settings
mailer = get_mailer(request)
headers = {"header": u'Password reset',
"message": u'Please click on the link bellow to reset your penelope account\'s password.',
"link": '%s/change_password?token=%s' % (request.application_url, token),
"action": 'Reset password'}
message = Message(subject=u"Password reset request",
recipients=[email],
body=u'Password reset',
extra_headers={'X-MC-Template': 'general',
'X-MC-MergeVars': json.dumps(headers)})
mailer.send(message)
return {'request': request, 'token': token}
def test_add_application_with_sa_to_project(self):
session = DBSession()
project = Project(name=u'My project 1')
application = Application(name=u'Trac')
project.add_application(application)
session.add(project)
transaction.commit()
self.assertEqual(session.query(Project).filter_by(name=u'My project 1').first().applications[0].name, u'Trac')
def test_project_creation_date(self):
session = DBSession()
project = Project(name=u'My first project A')
session.add(project)
transaction.commit()
self.assertEqual(session.query(Project)\
.filter_by(name=u'My first project A')\
.first().creation_date.strftime('%Y%m%d'), datetime.now().strftime('%Y%m%d'))
def test_get_user_by_attribute(self):
session = DBSession()
user = User(email=u'*****@*****.**')
session.add(user)
transaction.commit()
#Get the user by email
resp = self.proxy.get_user_by_email('*****@*****.**')
self.assertEqual(resp['email'], u'*****@*****.**')
def test_add_duplicated_project(self):
session = DBSession()
project = Project(name=u'My project A')
session.add(project)
project = Project(name=u'My project A')
session.add(project)
self.assertRaises(IntegrityError, transaction.commit)
session.rollback()
def test_add_application_to_project(self):
session = DBSession()
project = Project(name=u'My project 2')
application = Application(name=u'Trac', api_uri='http://simple.api.uri')
project.add_application(application)
session.add(project)
transaction.commit()
self.assertEqual(session.query(Project).filter_by(name=u'My project 2').first().applications[0].name, u'Trac')
def test_get_user_by_openid(self):
session = DBSession()
user = User(email=u'*****@*****.**')
user.add_openid(u'*****@*****.**')
session.add(user)
transaction.commit()
resp = self.proxy.get_user_by_openid('*****@*****.**')
self.assertTrue(u'*****@*****.**' in resp['openids'])
def test_get_customer_by_name(self):
customer_name = u'A rich customer'
session = DBSession()
customer = Customer(name=customer_name)
session.add(customer)
transaction.commit()
resp = self.proxy.get_customer_by_name(customer_name)
self.assertEqual(resp['name'], customer_name)
def autoregister(profile):
session = DBSession()
chars = string.letters + string.digits
password = ''.join(choice(chars) for _ in range(9))
user = User(fullname = profile.get('displayName'),
email = profile.get('emails')[0])
user.set_password(password)
user.add_openid(profile.get('accounts')[0].get('username'))
session.add(user)
return user
def smartadd_submit(self):
"""
Receives a line of smart-add and performs validation/insertion.
"""
projects = dict(
('%s - %s' % (p.name, p.customer.name), p.id)
for p in self.request.filter_viewables(DBSession.query(Project).filter(Project.active))
)
def ticket_provider(project_id):
if project_id:
project = DBSession.query(Project).get(project_id)
return [
t['id']
for t in ticket_store.get_tickets_for_project(project=project,
not_invoiced=True,
request=self.request)
]
parser = SmartAddParser(unicode(self.request.body, 'utf8', 'ignore'),
projects=projects,
available_tickets=ticket_provider,
request=self.request)
errors = parser.validation_errors()
if errors:
# XXX register appropriate exception handler
return Response(' - '.join(errors), status_int=400)
pte = parser.parsed_time_entry
parsed_tickets = pte['tickets']
ticket_summaries = []
entry_durations = list(time_chunks(pte['hours'], len(parsed_tickets)))
for parsed_ticket, duration in zip(parsed_tickets, entry_durations):
date = pte.get('date') or datetime.date.today()
te = TimeEntry(date = date,
start = pte['start'],
end = pte['start'],
description = pte['description'],
ticket = parsed_ticket,
project_id = pte['project_id'],
hours = duration,
)
te.request = self.request #bind for user calculation
DBSession.add(te)
# retrieve ticket descriptions (another trip to the store..)
ticket_summaries.append(
'#%s (%s)' % (te.ticket, ticket_store.get_ticket(self.request, te.project_id, te.ticket)[3]['summary'])
)
return Response(u'Added to ticket(s) %s' % ', '.join(ticket_summaries))
def test_get_project_by_name(self):
project_name = u'A nice project'
customer_name = u'A good customer'
session = DBSession()
project = Project(name=project_name)
customer = Customer(name=customer_name)
customer.add_project(project)
session.add(customer)
transaction.commit()
resp = self.proxy.get_project_by_name(project_name)
self.assertEqual(resp['name'], project_name)
def test_project_modification_date(self):
project_name = u'C project'
session = DBSession()
project = Project(name=project_name)
session.add(project)
transaction.commit()
project = session.query(Project).filter_by(name=project_name).first()
old_date = project.modification_date
project.name = u'A modified project'
time.sleep(0.1)
transaction.commit()
project = session.query(Project).filter_by(name=u'A modified project').first()
new_date = project.modification_date
self.assertNotEqual(old_date, new_date)
def security_save(self):
context = self.context.get_instance()
for acl in context.acl:
DBSession.delete(acl)
for checkbox_name in self.request.POST:
role_id, permission_name = checkbox_name.split('.')
acl = ApplicationACL(application_id=context.id,
role_id=role_id,
permission_name=permission_name)
DBSession.add(acl)
request = self.request
return HTTPFound(location=request.fa_url(request.model_name, request.model_id, 'security'))
def test_add_primarykey_cr(self):
session = DBSession()
project1 = Project(name=u'My project 11')
cr1 = CustomerRequest(name=u'My Customer reqeust 1')
cr1.project = project1
cr2 = CustomerRequest(name=u'My Customer reqeust 2')
cr2.project = project1
project2 = Project(name=u'My project 12')
cr3 = CustomerRequest(name=u'My Customer reqeust 1')
cr3.project = project2
session.add(cr1)
session.add(cr2)
session.add(cr3)
session.flush()
self.assertTrue(cr1.id in ['my-project-11_2','my-project-11_1'])
self.assertTrue(cr2.id in ['my-project-11_2','my-project-11_1'])
self.assertEqual(cr3.id, 'my-project-12_1')
def save_query(context, request):
current_uid = request.authenticated_user.id
query_meta = cgi.parse_qs(request.POST['query_meta'])
if not 'query_name' in query_meta:
return Response(u"Please specify a query name.", status=409)
query_name = query_meta['query_name'][0]
taken = DBSession.query(SavedQuery).filter(SavedQuery.author_id==current_uid).filter(SavedQuery.query_name==query_name).count()
submit_type = request.POST['submit_type']
if submit_type == 'submit_edit':
if taken:
return Response(u"Name already in use: '%s'." % query_name, status=409)
sq_id = query_meta['sq_id'][0]
qry = DBSession.query(SavedQuery)
qry = qry.filter(SavedQuery.author_id==current_uid)
qry = qry.filter(SavedQuery.id==sq_id)
sq = qry.one()
sq.query_name = query_name
return Response(u"The query has been renamed as '%s'." % query_name)
elif submit_type == 'submit_delete':
sq_id = query_meta['sq_id'][0]
qry = DBSession.query(SavedQuery)
qry = qry.filter(SavedQuery.author_id==current_uid)
qry = qry.filter(SavedQuery.id==sq_id)
sq = qry.one()
DBSession.delete(sq)
return Response(u"The saved query has been deleted.")
elif submit_type == 'submit_add':
if taken:
return Response(u"Name already in use: '%s'." % query_name, status=409)
# add
sq = SavedQuery(query_name=query_name,
report_name=query_meta['report_name'][0],
query_string=request.POST['query_string'],
author_id = current_uid)
DBSession.add(sq)
return Response(u"The query has been saved as '%s'." % query_name)
def test_application_position(self):
session = DBSession()
project1 = Project(id='sortedone')
project2 = Project(id='sortedtwo')
app1 = Application(name=u'First')
app2 = Application(name=u'Second')
app3 = Application(name=u'Third')
app4 = Application(name=u'Fourth')
app5 = Application(name=u'Fivth')
project1.applications.append(app1)
project1.applications.append(app2)
project1.applications.append(app3)
project2.applications.append(app4)
project2.applications.append(app5)
session.add(project1)
session.add(project2)
transaction.commit()
self.assertEqual([a.position for a in session.query(Project).get('sortedone').applications], [0,1,2])
self.assertEqual([a.position for a in session.query(Project).get('sortedtwo').applications], [0,1])
project1 = session.query(Project).get('sortedone')
app = project1.applications.pop(2)
project1.applications.insert(0,app)
transaction.commit()
self.assertEqual([a.name for a in session.query(Project).get('sortedone').applications], [u'Third', u'First', u'Second'])
def test_project_attributes(self):
project_name = u'Another nice project'
customer_name = u'A very good customer'
session = DBSession()
project = Project(name=project_name)
customer = Customer(name=customer_name)
customer.add_project(project)
applications1 = Application(name=u'Trac')
applications2 = Application(name=u'Svn')
customerR1 = CustomerRequest(name=u'A bad request')
customerR2 = CustomerRequest(name=u'A good request')
project.add_application(applications1)
project.add_application(applications2)
project.add_customer_request(customerR1)
project.add_customer_request(customerR2)
session.add(customer)
transaction.commit()
resp = self.proxy.get_project_by_name(project_name)
self.assertTrue(u'Trac' in resp['applications'])
self.assertTrue(u'another-nice-project_1' in [item for sublist in resp['customer_requests'] for item in sublist])
self.assertTrue(u'another-nice-project_2' in [item for sublist in resp['customer_requests'] for item in sublist])
self.assertTrue(2, len(resp['customer_requests']))
self.assertTrue(2, len(resp['applications']))
crstate_errors = timeentry_crstate_validation_errors(entry_project, [entry_ticket], request)
if crstate_errors:
return {
'state': False,
'message': '\n'.join(crstate_errors),
}
time_entry = TimeEntry(date = entry_date,
hours = entry_time_delta,
location = entry_location,
description = entry_description,
ticket = entry_ticket)
time_entry.request = request # bind for user lookup
time_entry.project_id = entry_project
session.add(time_entry)
session.flush()
return {
'status': True,
'message': u'Correctly added time entry %s for %s ticket #%s' % (time_entry.id, entry_project, entry_ticket),
}
@jsonrpc_method(endpoint='DashboardAPI')
def create_new_advanced_time_entry(request, entry_ticket, entry_start, entry_end,
entry_description, entry_location, entry_project):
"""
Time entry creation: simple time entry case
"""
def test_sa_registration_validation(self):
session = DBSession()
application = Application(name=u'Trac')
application.sa_uri = 'sqlite://'
session.add(application)
transaction.commit()
def test_time_entry_creation(self):
"""
This test check time entry parameters
"""
#customer data
customer_name = u'RFCCustomer'
#project data
project_name = u'A new project'
project_id = 'a-new-project'
#entry data
entry_date = datetime.date(2011, 05, 26)
entry_hours = '2:30'
entry_location = u'RedTurtle Technology'
entry_description = u'Trying to create ticket for API tests'
entry_ticket = '45'
#Start to create customer, project and time entry for project
session = DBSession()
project = Project(name=project_name, id=project_id)
customer = Customer(name=customer_name)
customer.add_project(project)
session.add(customer)
transaction.commit()
#Try to get errors
resp = self.proxy.create_new_simple_time_entry(1, entry_date,
entry_hours, entry_description,
entry_location,10)
self.assertEqual(resp['message'], u"'int' object has no attribute 'decode'")
resp = self.proxy.create_new_simple_time_entry(entry_ticket,
entry_date,
u'9000',
entry_description,
entry_location,
10)
self.assertEqual(resp['message'], u'Cannot parse time (must be HH:MM)')
resp = self.proxy.create_new_simple_time_entry(entry_ticket,
entry_date,
u'9:40',
entry_description,
entry_location,
10)
self.assertEqual(resp['message'], u'Time value too big (must be <= 8:00)')
resp = self.proxy.create_new_simple_time_entry(entry_ticket,
entry_date,
entry_hours,
entry_description,
entry_location,
100)
self.assertEqual(resp['message'], u'Not able to get the project with id 100')
resp = self.proxy.create_new_simple_time_entry(entry_ticket,
'2011 01 01',
entry_hours,
entry_description,
entry_location,
100)
self.assertEqual(resp['message'], u"time data '2011 01 01' does not match format '%Y-%m-%d'")
#Let's try to create a simple time entry
resp = self.proxy.create_new_simple_time_entry(entry_ticket,
entry_date,
entry_hours,
entry_description,
entry_location,
project_id)
self.assertRegexpMatches(resp['message'], u'Correctly added time entry \d+ for %s ticket #%s' %(project_id, entry_ticket))
resp = self.proxy.create_new_simple_time_entry(entry_ticket,
entry_date,
entry_hours,
'',
entry_location,
project_id)
self.assertEqual(resp['message'], u"Description is required.")
#Now try to create a more complex time entry
entry_start = datetime.datetime(2011, 01, 01, 15, 30)
entry_end = datetime.datetime(2011, 01, 01, 17, 30)
entry_ticket = '#99'
resp = self.proxy.create_new_advanced_time_entry(99,
entry_start,
entry_end,
entry_description,
entry_location,
10)
self.assertEqual(resp['message'], u"'int' object has no attribute 'decode'")
resp = self.proxy.create_new_advanced_time_entry(entry_ticket,
entry_start,
entry_end,
entry_description,
entry_location,
100)
self.assertEqual(resp['message'], u'Not able to get the project with id 100')
resp = self.proxy.create_new_advanced_time_entry(entry_ticket,
'2011 08 24',
entry_end,
entry_description,
entry_location,
10)
self.assertEqual(resp['message'], u"time data '2011 08 24' does not match format '%Y-%m-%d %H:%M:%S'")
resp = self.proxy.create_new_advanced_time_entry(entry_ticket,
entry_start,
entry_end,
entry_description,
entry_location,
project_id)
self.assertRegexpMatches(resp['message'], u'Correctly added time entry \d+ for %s ticket #%s' %(project_id, entry_ticket))
def add_user(self, email):
session = DBSession()
user = User(email=email)
session.add(user)
transaction.commit()
